Return to s5sockbcon.c CVS log

Up to [Research Unix] / researchv10no / cmd / nupas / ipc

Annotation of researchv10no/cmd/nupas/ipc/s5sockbcon.c, revision 1.1.1.1

1.1       root        1: #include       "stdio.h"
                      2: #include       "tiuser.h"
                      3: #include       "sys/fcntl.h"
                      4: #include       "sys/stropts.h"
                      5: 
                      6: /*
                      7:  *     s5sockbcon():   System V socket-bind-connect sequence
                      8:  *
                      9:  *     Alan M Buckwalter       3-90
                     10:  *
                     11:  *     Mimic the BSD socket(), bind() and connect() sequence using
                     12:  *     System V TLI calls.
                     13:  *
                     14:  *     In:     IP Address              (char *)
                     15:  *             Port Number             (int)
                     16:  *             UNIX Device             (char *)
                     17:  *     Out:    Open File Descriptor or -1 on Failure
                     18:  *
                     19:  *     Warning, there is a bug in the standard UTS Phase I inet_addr()
                     20:  *             library call that corrupts the passed string.  Make sure
                     21:  *             this fix is installed on your system to avoid any nasty
                     22:  *             side affects from this routine.
                     23:  */
                     24: 
                     25: #define        MAXRETRY        10
                     26: 
                     27: s5sockbcon(add,port,dev)
                     28: char *add,*dev;
                     29: int port;
                     30: {
                     31:        int                     netfd,i;
                     32:        char                    addrs[20];
                     33:        struct  t_call          *callp;
                     34:        struct  netbuf          addr;
                     35:        static  int             stoa();
                     36:        static  char            *atos();
                     37:        extern int              t_errno;
                     38: 
                     39:        sprintf(addrs,"\\x%08x%04x0000\0",inet_addr(add),port);
                     40:        stoa(addrs,&addr);
                     41: 
                     42: #ifdef DEBUG
                     43:        fprintf(stderr,"%s - %d\n",atos(&addr),addr.len);
                     44: #endif
                     45: 
                     46:        /* open transport endpoint */
                     47:        if((netfd=t_open(dev,O_RDWR,NULL))<0) {
                     48:                t_error("t_open");
                     49:                return(-1);
                     50:        }
                     51: 
                     52:        /* bind default address */
                     53:        if(t_bind(netfd,NULL,NULL)<0) {
                     54:                t_error("t_bind");
                     55:                return(-1);
                     56:        }
                     57: 
                     58:        /* allocate call structure */
                     59:        if((callp=(struct t_call *)t_alloc(netfd,T_CALL,0))==NULL) {
                     60:                t_error("t_alloc");
                     61:                return(-1);
                     62:        }
                     63: 
                     64:        callp->addr.buf=addr.buf;
                     65:        callp->addr.len=addr.len;
                     66: 
                     67:        /* connect to the listener */
                     68:        for (i=0;i<MAXRETRY;i++) {
                     69:                if(t_connect(netfd,callp,NULL)==0)
                     70:                        break;
                     71:                if((t_errno==TLOOK)&&(t_look(netfd)==T_DISCONNECT)) {
                     72:                        t_rcvdis(netfd,NULL);
                     73:                } else {
                     74:                        t_error("t_connect");
                     75:                        return(-1);
                     76:                }
                     77:        }
                     78:        if(i>2) {
                     79:                t_error("t_connect");
                     80:                return(-1);
                     81:        }
                     82: 
                     83:        /* push the read/write streams modules */
                     84:        if(ioctl(netfd,I_PUSH,"tirdwr")<0) {
                     85:                t_error("ioctl");
                     86:                return(-1);
                     87:        }
                     88:        return(netfd);
                     89: }
                     90: 
                     91: static int
                     92: stoa(s, np)
                     93: register char  *s;
                     94: struct netbuf  *np;
                     95: {
                     96:        static char     buf[128];
                     97:        register char   *bp = buf;
                     98:        int     b;
                     99: 
                    100:        if (s[0] == '\\' && tolower(s[1]) == 'x') {
                    101:                while (*(s += 2)) {
                    102:                        sscanf(s, "%2x", &b);
                    103:                        *bp++ = b;
                    104:                }
                    105:                np->len = bp - buf;
                    106:        } else
                    107:                np->len = strlen(strcpy(buf, s));
                    108:        np->buf = buf;
                    109:        return 1;
                    110: }
                    111: 
                    112: static char *
                    113: atos(np)
                    114: register struct netbuf *np;
                    115: {
                    116:        static char     buf[128];
                    117:        register char   *bp = buf;
                    118:        register int    i;
                    119: 
                    120:        bp += sprintf(bp, "\\x");
                    121:        for (i = 0; i < np->len; i++)
                    122:                bp += sprintf(bp, "%.2x", np->buf[i]);
                    123:        return buf;
                    124: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.