Return to call.c CVS log

Up to [Research Unix] / researchv10dc / cmd / post

Annotation of researchv10dc/cmd/post/call.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Call server module
        !             3:  */
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include <string.h>
        !             7: #include <malloc.h>
        !             8: #include <errno.h>
        !             9: #include "server.h"
        !            10: 
        !            11: typedef struct {
        !            12:        char    *tag;
        !            13:        char    line[BUFSIZ];
        !            14:        char    buf[BUFSIZ];
        !            15:        char    *ptr, *end;
        !            16: } call_t;
        !            17: 
        !            18: static int     stalk(), sgetc();
        !            19: extern char    *pq_open();
        !            20: 
        !            21: char *
        !            22: call_open(argv)
        !            23: char   *argv[];
        !            24: {
        !            25:        register call_t *call = (call_t *) malloc(sizeof (call_t));
        !            26: 
        !            27:        if (call->tag = pq_open(argv)) {
        !            28:                call->ptr = call->end = call->buf;
        !            29:                if (stalk(call, 0, "") != -1)
        !            30:                        return (char *) call;
        !            31:        }
        !            32:        free((char *) call);
        !            33:        return 0;
        !            34: }
        !            35: 
        !            36: call_close(call)
        !            37: call_t *call;
        !            38: {
        !            39:        register int    r1, r2;
        !            40: 
        !            41:        r1 = stalk(call, CLOSE, "");
        !            42:        if ((r2 = pq_close(call->tag)) == -1)
        !            43:                error(-1, "call: close");
        !            44:        free((char *) call);
        !            45:        return (r1 != -1 && r2 != -1) ? 0 : -1;
        !            46: }
        !            47: 
        !            48: call_read(call, argv)
        !            49: call_t *call;
        !            50: char   *argv[];
        !            51: {
        !            52:        register char   *s;
        !            53:        register int    rv;
        !            54: 
        !            55:        if ((rv = stalk(call, READ, "")) > 0) {
        !            56:                s = call->line;
        !            57:                while (s = strchr(s, VALUE))
        !            58:                        *s++ = 0, *argv++ = s;
        !            59:                *argv = 0;
        !            60:        }
        !            61:        return rv;
        !            62: }
        !            63: 
        !            64: call_write(call, argv)
        !            65: call_t *call;
        !            66: char   *argv[];
        !            67: {
        !            68:        char    line[BUFSIZ];
        !            69:        char    *a, *s = line;
        !            70: 
        !            71:        while (a = *argv++) {
        !            72:                *s++ = VALUE;
        !            73:                while (*s++ = *a++);
        !            74:                s--;
        !            75:        }
        !            76:        return stalk(call, WRITE, line);
        !            77: }
        !            78: 
        !            79: static int
        !            80: stalk(call, cmd, arg)
        !            81: call_t *call;
        !            82: char   cmd;
        !            83: char   *arg;
        !            84: {
        !            85:        register char   *s;
        !            86:        register int    c;
        !            87: 
        !            88:        if (cmd) {
        !            89:                s = call->line;
        !            90:                *s++ = cmd;
        !            91:                if (arg) {
        !            92:                        while (*s++ = *arg++);
        !            93:                        s--;
        !            94:                }
        !            95:                *s++ = '\n';
        !            96:                c = s - call->line;
        !            97:                if (pq_write(call->tag, call->line, c) != c)
        !            98:                        return error(-1, "call: write");
        !            99:        }
        !           100:        switch (c = sgetc(call)) {
        !           101:        case EOF:
        !           102:                return -1;
        !           103:        case PROMPT:
        !           104:                return 0;
        !           105:        case '\n':
        !           106:        case VALUE:
        !           107:        case ERROR:
        !           108:                s = call->line;
        !           109:                while (c != EOF && c != '\n')
        !           110:                        *s++ = c, c = sgetc(call);
        !           111:                if (c == EOF)
        !           112:                        return -1;
        !           113:                *s = 0;
        !           114:                if (sgetc(call) == PROMPT)
        !           115:                        return (*call->line != ERROR) ? 1
        !           116:                                : error(0, "%s", call->line + 1);
        !           117:                /* fall thru */
        !           118:        default:
        !           119:                return error(0, "call: Protocol error");
        !           120:        }
        !           121: }
        !           122: 
        !           123: static int
        !           124: sgetc(call)
        !           125: register call_t        *call;
        !           126: {
        !           127:        if (call->ptr == call->end) {
        !           128:                int n = pq_read(call->tag, call->buf, sizeof call->buf);
        !           129:                if (n <= 0) {
        !           130:                        error(n == 0 ? EPIPE : -1, "call: read");
        !           131:                        return EOF;
        !           132:                }
        !           133:                call->ptr = call->buf;
        !           134:                call->end = call->buf + n;
        !           135:        }
        !           136:        return *call->ptr++;
        !           137: }

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