Return to main.c CVS log

Up to [Research Unix] / researchv9 / netb / src

Annotation of researchv9/netb/src/main.c, revision 1.1

1.1     ! root        1: /* Network file system B.
        !             2:  * Setup message contains protocol type, max message size, and dev, at least.
        !             3:  * Maybe add some permissions stuff.
        !             4:  * The second message contains login names and uids from the client.
        !             5:  * The third message contains group names and gids from the client.
        !             6:  * Each message is acked by a single byte (1, 2, resp 3).
        !             7:  *
        !             8:  * All headers are translated from the client .../sys/h/netb.h into a global
        !             9:  * host structure that contains the union of all the fields.  Each type of
        !            10:  * response is converted back to the client's format as part of sending the
        !            11:  * response.  server() is in input.c.
        !            12:  */
        !            13: 
        !            14: #include "share.h"
        !            15: int cfd, dbgfd, debugflag;
        !            16: int dtime;
        !            17: 
        !            18: main(argc, argv)
        !            19: char **argv;
        !            20: {      int i, n;
        !            21:        char buf[32];
        !            22:        cfd = 0;        /* we get invoked by rexec */
        !            23:        dbgfd = open("/dev/null", 1);
        !            24: /*     dbgfd = creat("/tmp/zarf", 0644); /* /tmp/zarf is creamed on reboot */
        !            25:        n = xread(cfd, buf, 16);
        !            26:        if(n != 16)
        !            27:                fatal("client: read on setup %d bytes %d, |%s|\n", n, errno, buf);
        !            28:        n = buf[0];
        !            29:        hisdev = buf[1] << 8;   /* that's his dev */
        !            30:        switch(buf[2]) {
        !            31:        default:
        !            32:                fatal("unk protocol %c (0%0)\n", buf[2], buf[2]);
        !            33:        case 't': case 'd':
        !            34:                proto = buf[2];
        !            35:                break;
        !            36:        }
        !            37:        debugflag = buf[3];
        !            38:        switch(buf[4]) {
        !            39:        default:
        !            40:                fatal("unk client type %c (0%0)\n", buf[4], buf[4]);
        !            41:        case 'v': case 's':
        !            42:                clienttype = buf[4];
        !            43:                break;
        !            44:        }
        !            45:        buf[0] = 1;
        !            46:        write(cfd, buf, 1);
        !            47:        for(i = 0; i < FILES; i++)
        !            48:                files[i].fd = -1;
        !            49:        error("server %d\n", getpid());
        !            50:        error("CSOURCE=%s\n", getenv("CSOURCE"));
        !            51:        server(n * 1024);
        !            52: }
        !            53: 
        !            54: /* read a fixed size off cfd */
        !            55: xread(fd, buf, cnt)
        !            56: unsigned char *buf;
        !            57: {      unsigned char *p = buf;
        !            58:        int i, n;
        !            59:        n = 0;
        !            60: loop:
        !            61:        i = read(fd, p, cnt - n);
        !            62:        if(i <= 0)
        !            63:                fatal("xread(%d) n %d i %d\n", cnt, n, i);
        !            64:        
        !            65:        p += i;
        !            66:        n += i;
        !            67:        if(n >= cnt)
        !            68:                return(cnt);
        !            69:        goto loop;
        !            70: }
        !            71: 
        !            72: char msgbuf[1024];
        !            73: /* VARARGS1 */
        !            74: error(s, a, b, c, d, e, f)
        !            75: char *s;
        !            76: {
        !            77:        sprintf(msgbuf, s, a, b, c, d, e, f);
        !            78:        write(dbgfd, msgbuf, strlen(msgbuf));
        !            79: }
        !            80: 
        !            81: /* VARARGS1 */
        !            82: debug(s, a, b, c, d, e, f)
        !            83: char *s;
        !            84: {
        !            85:        if(!debugflag)
        !            86:                return;
        !            87:        sprintf(msgbuf, s, a, b, c, d, e, f);
        !            88:        write(dbgfd, msgbuf, strlen(msgbuf));
        !            89:        /*sync();vain attempt to preserve every precious byte of message */
        !            90: }
        !            91: /* VARARGS1 */
        !            92: fatal(s, a, b, c, d, e, f)
        !            93: {
        !            94:        sprintf(msgbuf, s, a, b, c, d, e, f);
        !            95:        write(dbgfd, msgbuf, strlen(msgbuf));
        !            96:        exit(1);
        !            97: }

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