Return to dblbuf.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/dblbuf.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <signal.h>
                      3: 
                      4: #define Read 1
                      5: #define Write 2
                      6: #define Endfile 3
                      7: #define Error 4
                      8: 
                      9: int inpipe, outpipe;
                     10: int infd = 0, outfd = 1;
                     11: int bufmax = 32768;
                     12: char *buffer;
                     13: int reclen;
                     14: extern char *optarg;
                     15: extern int optind;
                     16: extern char *malloc();
                     17: 
                     18: int
                     19: gettoken()
                     20: {
                     21:        char c;
                     22: 
                     23:        switch (read (inpipe, &c, 1)) {
                     24:        case 0: return Endfile;
                     25:        case 1: return c;
                     26:        default:
                     27:                perror ("gettoken");
                     28:                return Error;
                     29:        }
                     30: }
                     31: 
                     32: void
                     33: puttoken(t)
                     34:        char t;
                     35: {
                     36:        write (outpipe, &t, 1);
                     37: }
                     38: 
                     39: int
                     40: readbuf()
                     41: {
                     42:        reclen = read (infd, buffer, bufmax);
                     43: 
                     44:        if (reclen < 0) {
                     45:                perror ("read");
                     46:                return 0;
                     47:        }
                     48: 
                     49:        return reclen > 0;
                     50: }
                     51: 
                     52: int
                     53: writebuf()
                     54: {
                     55:        if (write (outfd, buffer, reclen) != reclen) {
                     56:                perror ("write");
                     57:                return 0;
                     58:        }
                     59:        return 1;
                     60: }
                     61: 
                     62: int
                     63: copyloop()
                     64: {
                     65:        for (;;) {
                     66:                int t;
                     67:                if ((t = gettoken()) != Read)
                     68:                        return t;
                     69:                if (!readbuf()) {
                     70:                        puttoken (Endfile);
                     71:                        return Endfile;
                     72:                }
                     73:                puttoken (Read);
                     74:                if ((t = gettoken()) != Write)
                     75:                        return t;
                     76:                if (!writebuf()) {
                     77:                        puttoken (Error);
                     78:                        return Error;
                     79:                }
                     80:                puttoken (Write);
                     81:        }
                     82: }
                     83: 
                     84: int
                     85: copyfile()
                     86: {
                     87:        int p0[2], p1[2];
                     88:        int p, pid, status;
                     89:        pipe (p0);
                     90:        pipe (p1);
                     91:        switch (pid = fork()) {
                     92:        default:                        /* parent */
                     93:                inpipe = p0[0];
                     94:                close (p0[1]);
                     95:                outpipe = p1[1];
                     96:                close (p1[0]);
                     97: 
                     98:                status = copyloop();
                     99:                if (status != Endfile) {
                    100:                        fprintf (stderr, "error: parent status %d\n", status);
                    101:                        return 1;
                    102:                }
                    103: 
                    104:                do      p = wait (&status);
                    105:                while (p >= 0 && p != pid);
                    106:                if (p < 0) {
                    107:                        perror ("wait");
                    108:                        return 1;
                    109:                }
                    110: 
                    111:                if (status != Endfile<<8) {
                    112:                        fprintf (stderr, "error: child status %d\n", status);
                    113:                        return 1;
                    114:                }
                    115:                
                    116:                return 0;
                    117: 
                    118:        case 0:                         /* child */
                    119:                inpipe = p1[0];
                    120:                close (p1[1]);
                    121:                outpipe = p0[1];
                    122:                close (p0[0]);
                    123:                puttoken (Read);
                    124:                puttoken (Write);
                    125:                exit (copyloop());
                    126: 
                    127:        case -1:                        /* error */
                    128:                perror ("fork");
                    129:                return 1;
                    130:        }
                    131: }
                    132: 
                    133: main (argc, argv)
                    134:        int argc;
                    135:        char **argv;
                    136: {
                    137:        int c;
                    138:        while ((c = getopt (argc, argv, "b:")) != -1) {
                    139:                switch (c) {
                    140:                case 'b':
                    141:                        bufmax = atoi (optarg);
                    142:                        if (bufmax <= 0) {
                    143:                                fprintf (stderr, "invalid buffer size\n");
                    144:                                exit (1);
                    145:                        }
                    146:                }
                    147:        }
                    148: 
                    149:        if ((buffer = malloc (bufmax)) == NULL) {
                    150:                fprintf (stderr, "out of memory\n");
                    151:                exit (1);
                    152:        }
                    153: 
                    154:        if (argc > optind + 1) {
                    155:                fprintf (stderr, "only one input file\n");
                    156:                exit (1);
                    157:        }
                    158: 
                    159:        if (argc > optind) {
                    160:                infd = open (argv[optind], 0);
                    161:                if (infd < 0) {
                    162:                        perror (argv[optind]);
                    163:                        exit (1);
                    164:                }
                    165:        }
                    166: 
                    167:        signal (SIGPIPE, SIG_IGN);
                    168:        return copyfile();
                    169: }

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