xti_lib.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

tmp_size = sizeof(xti_epvalid);
status = getsockopt(fd, SOL_SOCKET, SO_XTIFDVALID, 
		    (char *) &xti_epvalid,
		    &tmp_size);

if (status < 0) return(0);

return(xti_epvalid);

}


/*
 *	XTI_PEEK - peek at the current event on a transport endpoint
 */

int
xti_peek(fd, evtinfo_ptr)
int fd;
struct xti_evtinfo *evtinfo_ptr;

{


  int status;
  int tmp_size;
  struct xti_evtinfo tmp_event;

  if (!(check_xtifd(fd))) {
    t_errno = TBADF;
    return(-1);
  }

  tmp_size = sizeof(struct xti_evtinfo);
  status = getsockopt(fd, SOL_SOCKET, SO_XTIPEEKEVENT,
		      (char *) &tmp_event,
		      &tmp_size);

  if (status < 0) {
    map_err_to_XTI(errno, &t_errno);
    return(-1);
  }

  if (evtinfo_ptr != T_NULL) *evtinfo_ptr = tmp_event;

  return(0);


}

#ifdef old

/*
 *	XTI_SYNC - synchronize transport library
 */

int 
xti_sync (fd)
int fd;
{

  int status;
  int tmp_state;
  int tmp_size;

  if (d_table.dcb == T_NULL) {
    t_errno = TBADF;
    return(-1);
  }

  status = setsockopt(fd, SOL_SOCKET, SO_XTISYNC, (char *) 0, 0);

  if (status < 0) {
    map_err_to_XTI(errno,&t_errno);		
    return (-1);
  }

  tmp_size = sizeof(tmp_state);
  status = getsockopt(fd, SOL_SOCKET, SO_XTITPSTATE,
		      (char *) &tmp_state,
		      &tmp_size);

  if (status < 0) {
    map_err_to_XTI(errno,&t_errno);		
    return (-1);
  }

  table(fd).active_flag = 1;   /* make an active descriptor */
 
  return(tmp_state);

}


pt()
{
  int i;

  if (d_table.dcb == NULL) {
    printf("No table\n");
    return (0);
  }

  for (i = 0; i < getdtablesize(); i++) {
    printf("fd=%d\n",i);
    printf("sequence = %d\n",table(i).sequence);
    printf("qlen = %d\n",table(i).qlen);
    printf("cnt_outs_con_ind = %d\n",table(i).cnt_outs_con_ind);
    printf("active_flag = %d\n",table(i).active_flag);
    printf("state = %d\n",table(i).state);
    printf("event = %d\n",table(i).event);
    printf("t_info.addr = %d\n",table(i).info.addr);
    printf("t_info.options = %d\n",table(i).info.options);
    printf("t_info.tsdu = %d\n",table(i).info.tsdu);
    printf("t_info.etsdu = %d\n",table(i).info.etsdu);
    printf("t_info.connect = %d\n",table(i).info.connect);
    printf("t_info.discon = %d\n",table(i).info.discon);
    printf("t_info.servtype = %d\n",table(i).info.servtype);
    printf("family = %d\n",table(i).family);
    printf("xti_proto = %d\n",table(i).xti_proto);
  }

  return(0);

}

pte(i)
     int i;
{
  
  if (d_table.dcb == NULL) {
    printf("No table\n");
    return (0);
  }

  printf("fd=%d\n",i);
  printf("sequence = %d\n",table(i).sequence);
  printf("qlen = %d\n",table(i).qlen);
  printf("cnt_outs_con_ind = %d\n",table(i).cnt_outs_con_ind);
  printf("active_flag = %d\n",table(i).active_flag);
  printf("state = %d\n",table(i).state);
  printf("event = %d\n",table(i).event);
  printf("t_info.addr = %d\n",table(i).info.addr);
  printf("t_info.options = %d\n",table(i).info.options);
  printf("t_info.tsdu = %d\n",table(i).info.tsdu);
  printf("t_info.etsdu = %d\n",table(i).info.etsdu);
  printf("t_info.connect = %d\n",table(i).info.connect);
  printf("t_info.discon = %d\n",table(i).info.discon);
  printf("t_info.servtype = %d\n",table(i).info.servtype);
  printf("family = %d\n",table(i).family);
  printf("xti_proto = %d\n",table(i).xti_proto);

  return(0);
  
}

#endif old

char *
  allocate_addr(struct_type, in_ptr, opt_addr, udata_addr, sizea)
int struct_type;
char *in_ptr;
char *opt_addr;
char *udata_addr;
int sizea;
{
  char *tmp;

  if ((sizea < 0) || (in_ptr == T_NULL)) {
    t_errno = TSYSERR;
    errno = EINVAL;
    if (opt_addr) free(opt_addr);
    if (udata_addr) free(udata_addr);
    return(T_NULL);
  }

  tmp = (char *)malloc( (unsigned) sizea); /* allocate memory */

  if (tmp == T_NULL) {
    if (opt_addr) free(opt_addr);
    if (udata_addr) free(udata_addr);
    return(T_NULL);
  }

  switch (struct_type) {
  case T_BIND_STR:

    ((struct t_bind *) in_ptr)->addr.buf = tmp;
    ((struct t_bind *) in_ptr)->addr.len = 0;
    ((struct t_bind *) in_ptr)->addr.maxlen = sizea;
    break;

  case T_CALL_STR:

    ((struct t_call *) in_ptr)->addr.buf = tmp;
    ((struct t_call *) in_ptr)->addr.len = 0;
    ((struct t_call *) in_ptr)->addr.maxlen = sizea;
    break;

  case T_UNITDATA_STR:

    ((struct t_unitdata *) in_ptr)->addr.buf = tmp;
    ((struct t_unitdata *) in_ptr)->addr.len = 0;
    ((struct t_unitdata *) in_ptr)->addr.maxlen = sizea;
    break;

  case T_UDERROR_STR:

    ((struct t_uderr *) in_ptr)->addr.buf = tmp;
    ((struct t_uderr *) in_ptr)->addr.len = 0;
    ((struct t_uderr *) in_ptr)->addr.maxlen = sizea;
    break;

  default:
    t_errno = TNOSTRUCTYPE;
    tmp = T_NULL;
    break;

  };

  return(tmp);
}

char *
  allocate_opt(struct_type, in_ptr, addr_addr, udata_addr, sizeo)
int struct_type;
char *in_ptr;
char *addr_addr;
char *udata_addr;
int sizeo;
{
  char *tmp;

  if ((sizeo < 0) || (in_ptr == T_NULL)) {
    t_errno = TSYSERR;
    errno = EINVAL;
    if (addr_addr) free(addr_addr);
    if (udata_addr) free(udata_addr);
    return(T_NULL);
  }

  tmp = (char *)malloc( (unsigned) sizeo); /* allocate memory */

  if (tmp == T_NULL) {
    if (addr_addr) free(addr_addr);
    if (udata_addr) free(udata_addr);
    return(T_NULL);
    }


  switch(struct_type) {

  case T_OPTMGMT_STR:

    ((struct t_optmgmt *) in_ptr)->opt.buf = tmp;
    ((struct t_optmgmt *) in_ptr)->opt.len = 0;
    ((struct t_optmgmt *) in_ptr)->opt.maxlen = sizeo;
    break;

  case T_CALL_STR:

    ((struct t_call *) in_ptr)->opt.buf = tmp;
    ((struct t_call *) in_ptr)->opt.len = 0;
    ((struct t_call *) in_ptr)->opt.maxlen = sizeo;
    break;

  case T_UNITDATA_STR:

    ((struct t_unitdata *) in_ptr)->opt.buf = tmp;
    ((struct t_unitdata *) in_ptr)->opt.len = 0;
    ((struct t_unitdata *) in_ptr)->opt.maxlen = sizeo;
    break;

  case T_UDERROR_STR:

    ((struct t_uderr *) in_ptr)->opt.buf = tmp;
    ((struct t_uderr *) in_ptr)->opt.len = 0;
    ((struct t_uderr *) in_ptr)->opt.maxlen = sizeo;
    break;

  default:
    t_errno = TNOSTRUCTYPE;
    tmp = T_NULL;
    break;

  };
  return(tmp);
}

char *
  allocate_udata(struct_type, in_ptr, opt_addr, addr_addr, sizeu)
int struct_type;
char *in_ptr;
char *opt_addr;
char *addr_addr;
int sizeu;
{
  char *tmp;

  if ((sizeu < 0) || (in_ptr == T_NULL)) {
    t_errno = TSYSERR;
    errno = EINVAL;
    if (opt_addr) free(opt_addr);
    if (addr_addr) free(addr_addr);
    return(T_NULL);
  }

  tmp = (char *)malloc( (unsigned) sizeu); /* allocate memory */

  if (tmp == T_NULL) {
    if (opt_addr) free(opt_addr);
    if (addr_addr) free(addr_addr);
    return(T_NULL);
    }

  switch (struct_type) {

    case T_CALL_STR:
    
    ((struct t_call *) in_ptr)->udata.buf = tmp;
    ((struct t_call *) in_ptr)->udata.len = 0;
    ((struct t_call *) in_ptr)->udata.maxlen = sizeu;
    break;

  case T_DIS_STR:

    ((struct t_discon *) in_ptr)->udata.buf = tmp;
    ((struct t_discon *) in_ptr)->udata.len = 0;
    ((struct t_discon *) in_ptr)->udata.maxlen = sizeu;
    break;

  case T_UNITDATA_STR:

    ((struct t_unitdata *) in_ptr)->udata.buf = tmp;
    ((struct t_unitdata *) in_ptr)->udata.len = 0;
    ((struct t_unitdata *) in_ptr)->udata.maxlen = sizeu;
    break;

  default:
    t_errno = TNOSTRUCTYPE;
    tmp = T_NULL;
    break;

  };

  return(tmp);
}