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

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.