Return to dk.c CVS log

Up to [Research Unix] / researchv10dc / ipc / bin / pupu

Annotation of researchv10dc/ipc/bin/pupu/dk.c, revision 1.1.1.1

1.1       root        1: #include <sys/types.h>
                      2: #include <sys/stream.h>
                      3: #include       <sys/filio.h>
                      4: #include       <sys/ttyio.h>
                      5: #include       <stdio.h>
                      6: #include       "sysexits.h"
                      7: #include       <signal.h>
                      8: #include       "tdefs.h"
                      9: #include       "udefs.h"
                     10: #include       "pupu.h"
                     11: 
                     12: /*
                     13:  * To avoid race conditions, we remember if mesgld has been pushed.
                     14:  * This flag should become a table if there is ever a need for more
                     15:  * than one datakit fd open at a time
                     16:  */
                     17: 
                     18: static char msgpushed;
                     19: 
                     20: static unsigned char eofmsg[] = { M_CTL, MSGMAGIC, 1, 0, 106 };
                     21: 
                     22: dkeof(fd)
                     23: {
                     24:        write (fd, eofmsg, sizeof (eofmsg));
                     25: }
                     26: 
                     27: msgwrite (fd, buf, len)
                     28:        int fd;
                     29:        char *buf;
                     30:        int len;
                     31: {
                     32:        struct mesg m;
                     33:        static struct mesg delim = {M_DELIM, MSGMAGIC, 0, 0};
                     34:        int ret;
                     35: 
                     36:        if (!msgpushed) {
                     37:                extern int mesg_ld;
                     38: 
                     39:                if (ioctl (fd, FIOPUSHLD, &mesg_ld) < 0) {
                     40:                        fprintf(stderr, "can't push message line discipline\n");
                     41:                        exit(fd);
                     42:                }
                     43:                msgpushed = 1;
                     44:        }
                     45: 
                     46:        m.type = M_DATA;
                     47:        m.magic = MSGMAGIC;
                     48:        m.losize = len & 0xff;
                     49:        m.hisize = (len >> 8) & 0xff;
                     50: 
                     51: db(stderr, "msgwrite %d\n", len);
                     52:        if (write (fd, &m, MSGHLEN) != MSGHLEN) {
                     53:                perror ("header write");
                     54:                return -1;
                     55:        }
                     56: 
                     57:        ret = len? write (fd, buf, len): 0;
                     58: 
                     59: db(stderr, "msgwrite delim\n");
                     60:        if(write (fd, &delim, MSGHLEN) != MSGHLEN){
                     61:                perror ("delim write");
                     62:                return -1;
                     63:        }
                     64: 
                     65:        return ret;
                     66: }
                     67: 
                     68: msgread (fd, buf, len)
                     69:        int fd;
                     70:        char *buf;
                     71:        int len;
                     72: {
                     73:        struct mesg m;
                     74:        static int remain, tossdelim;
                     75:        int n, ret = 0;
                     76: 
                     77:        if (!msgpushed)
                     78:                return read (fd, buf, len);
                     79: 
                     80:        if (remain) {
                     81:                n = remain > len? len: remain;
                     82:                if (iread (fd, buf, n) != n)
                     83:                        err ("Can't read trailer", NIL, -EX_PROTOCOL);
                     84:                remain -= n;
                     85:                return n;
                     86:        }
                     87: 
                     88:        while (len > 0) {
                     89: 
                     90:                do {
                     91:                        if (iread (fd, &m, MSGHLEN) != MSGHLEN)
                     92:                                err ("Stream msg header read error",
                     93:                                        NIL, -EX_PROTOCOL);
                     94:        
                     95:                        if (m.magic != MSGMAGIC)
                     96:                                err ("Bad msgmagic", NIL, -EX_PROTOCOL);
                     97: 
                     98: db(stderr, "msgread type %d len %d\n", m.type, (m.hisize << 8) + m.losize);
                     99:                } while (m.type != M_DATA && m.type != M_DELIM && m.type != M_CTL);
                    100: 
                    101:                if (m.type == M_DELIM) {
                    102:                        if (!tossdelim)
                    103:                                return ret;
                    104:                        tossdelim = 0;
                    105:                } else {
                    106:                        int r = (m.hisize << 8) + m.losize;
                    107: 
                    108:                        if (m.type == M_CTL) {
                    109:                                char c;
                    110: 
                    111:                                if (r != 1)
                    112:                                        err ("Control message, cnt > 1", NIL,
                    113:                                                -EX_PROTOCOL);
                    114: 
                    115:                                if (iread (fd, &c, r) != r)
                    116:                                        err ("Cannot read control char", NIL,
                    117:                                                -EX_PROTOCOL);
                    118: 
                    119:                                if (c != 106)  /* should be symbolic */
                    120:                                        err ("Unknown control char", NIL,
                    121:                                                -EX_PROTOCOL);
                    122: 
                    123:                                tossdelim = 0;
                    124:                        } else {
                    125: 
                    126:                                if(r)
                    127:                                        tossdelim = 0;
                    128:                                if (r > len) {
                    129:                                        remain = r - len;
                    130:                                        r = len;
                    131:                                }
                    132:                
                    133:                                if (r && iread (fd, buf, r) != r)
                    134:                                        err ("Bad data read", NIL, -EX_PROTOCOL);
                    135: 
                    136:                                buf += r;
                    137:                                len -= r;
                    138:                                ret += r;
                    139:                        }
                    140:                }
                    141:        }
                    142: 
                    143:        tossdelim = 1;
                    144:        return ret;
                    145: }

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