Return to ipcopen.c CVS log

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

Annotation of researchv10no/cmd/nupas/ipc/ipcopen.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <sysexits.h>
        !             3: #include <string.h>
        !             4: 
        !             5: /*
        !             6:  * globals for ipc
        !             7:  */
        !             8: 
        !             9: int    ipcdebug = 0;
        !            10: 
        !            11: extern int ipcerrno;
        !            12: 
        !            13: extern int tcp_connect();
        !            14: extern int dk_connect();
        !            15: extern int mx_connect();
        !            16: extern int proxy_connect();
        !            17: 
        !            18: extern int tcp_close();
        !            19: extern int dk_close();
        !            20: 
        !            21: #define INETPROXY      "tcp!inet.research.att.com!402"
        !            22: /* #define INETPROXY   "dk!nj/astro/inet.proxy"*/
        !            23: 
        !            24: #define ATTPROXY       "tcp!att-in.att.com!402"
        !            25: /* #define ATTPROXY    "dk!oh/cbl/att-in.proxy"*/
        !            26: 
        !            27: #ifndef PROXY
        !            28: #define PROXY          ATTPROXY
        !            29: #endif
        !            30: 
        !            31: struct conntype {
        !            32:        char    *prefix;
        !            33:        int     (*connector)();
        !            34:        int     (*closer)();
        !            35:        char    *prhost;
        !            36: } conntype[] = {
        !            37:        {"tcp",   tcp_connect,   tcp_close,   NULL},
        !            38:        {"dk",    dk_connect,    dk_close,    NULL},
        !            39:        {"mx",    mx_connect,    tcp_close,   NULL},
        !            40:        {"proxy", proxy_connect, NULL,        PROXY},
        !            41:        {"inet",  proxy_connect, NULL,        INETPROXY},
        !            42:        {"att",   proxy_connect, NULL,        ATTPROXY},
        !            43:        {NULL,    NULL,          NULL,        NULL}
        !            44: };
        !            45: 
        !            46: #define MAXFD  32              /* maximum file descriptors we handle */
        !            47: int (*closelist[MAXFD])();
        !            48: 
        !            49: /*
        !            50:  * ipcopen - determine the network and call the open processor for it.
        !            51:  *     name is of the form     network!host!service
        !            52:  *      param is passed on, for what it is worth.
        !            53:  */
        !            54: int
        !            55: ipcopen(name, param)
        !            56: char *name, *param;
        !            57: {
        !            58:        int fd;
        !            59:        struct  conntype *ct;
        !            60:        char buf[100];
        !            61:        char *dialer = buf, *dialno;
        !            62: 
        !            63:        if (ipcdebug) {
        !            64:                setbuf(stderr, (char *)0);
        !            65:                fprintf(stderr, "ipcopen `%s` `%s`\n", name, param);
        !            66:        }
        !            67: 
        !            68:        strncpy(buf, name, sizeof(buf));
        !            69:        buf[sizeof(buf)] = '\0';
        !            70:        dialno = strchr(buf, '!');
        !            71:        if (dialno != NULL)
        !            72:                *dialno++ = '\0';
        !            73: 
        !            74:        if ((*dialer) == '\0') {
        !            75:                ipcseterror(EX_USAGE, "Dialer name missing", "Can't dial");
        !            76:                return -1;
        !            77:        }
        !            78:        for (ct = conntype; ct->prefix; ct++)
        !            79:                if (strcmp(ct->prefix, dialer) == 0)
        !            80:                        break;
        !            81:        if (ct->prefix == NULL) {
        !            82:                ipcseterror(EX_USAGE, "Unknown network type", "Can't dial");
        !            83:                return -1;
        !            84:        }
        !            85: 
        !            86:        if (ipcdebug)
        !            87:                fprintf(stderr, "Connecting to network %s %s\n",
        !            88:                        dialer, dialno);
        !            89:        if (ct->prhost == NULL) {       /*not proxy connect*/
        !            90:                fd = (ct->connector)(dialno, param);
        !            91:                if ((fd >= 0) && (fd <= MAXFD))
        !            92:                        closelist[fd] = ct->closer;
        !            93:        } else
        !            94:                fd = proxy_connect(dialno, param, ct->prhost);
        !            95: 
        !            96:        if (ipcdebug)
        !            97:                fprintf(stderr, "Ipcopen returning %d, err=%d\n",
        !            98:                        fd, ipcerrno);
        !            99:        return fd;
        !           100: }
        !           101: 
        !           102: int
        !           103: ipcclose(fd)
        !           104: int fd;
        !           105: {
        !           106:        if (ipcdebug)
        !           107:                fprintf(stderr, "Closing fd %d\n", fd);
        !           108:        if ((fd >= 0) && (fd <= MAXFD) && (closelist[fd] != 0)) {
        !           109:                int rc = (closelist[fd])(fd);
        !           110:                closelist[fd] = 0;
        !           111:                return rc;
        !           112:        } else
        !           113:                return close(fd);
        !           114: }
        !           115: 

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