Return to vpr.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / vpr

Annotation of 41BSD/cmd/vpr/vpr.c, revision 1.1

1.1     ! root        1: #include <signal.h>
        !             2: #include <pagsiz.h>
        !             3: #define        BUFSIZ  BSIZE
        !             4: 
        !             5: /*
        !             6:  *     vpr -- varian and versatec (as printers) spooler
        !             7:  */
        !             8: 
        !             9: #define VAD            "/usr/lib/vad"
        !            10: #define VPD            "/usr/lib/vpd"
        !            11: char   VAtfname[] =    "/usr/spool/vad/tfaXXXXX";
        !            12: char   VAcfname[] =    "/usr/spool/vad/cfaXXXXX";
        !            13: char   VAdfname[] =    "/usr/spool/vad/dfaXXXXX";
        !            14: char   VPtfname[] =    "/usr/spool/vpd/tfaXXXXX";
        !            15: char   VPcfname[] =    "/usr/spool/vpd/cfaXXXXX";
        !            16: char   VPdfname[] =    "/usr/spool/vpd/dfaXXXXX";
        !            17: char   *tfname;
        !            18: char   *cfname;
        !            19: /* char        *lfname; */
        !            20: char   *dfname;
        !            21: int    wide;
        !            22: int    literal;
        !            23: int    nact;
        !            24: int    tff;
        !            25: int    mailflg;
        !            26: char   person[10];
        !            27: int    inchar;
        !            28: int    maxrec  = 2000;
        !            29: char   *width = "-w106";
        !            30: int    troffit;
        !            31: int     plotit;
        !            32: char   *fonts[4];
        !            33: 
        !            34: main(argc, argv)
        !            35:        int argc;
        !            36:        char *argv[];
        !            37: {
        !            38:        register char *arg, *remote;
        !            39:        int c, f, fv, flag;
        !            40:        int out();
        !            41: 
        !            42:        if (signal(SIGINT, SIG_IGN) == SIG_DFL)
        !            43:                signal(SIGINT, out);
        !            44:        if (signal(SIGQUIT, SIG_IGN) == SIG_DFL)
        !            45:                signal(SIGQUIT, out);
        !            46:        if (signal(SIGHUP, SIG_IGN) == SIG_DFL)
        !            47:                signal(SIGHUP, out);
        !            48:        if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
        !            49:                signal(SIGTERM, out);
        !            50:        remote = "$     remote  **,onl";
        !            51:        flag = 0;
        !            52:        wide = 0;
        !            53:        tfname = VAtfname;
        !            54:        cfname = VAcfname;
        !            55:        dfname = VAdfname;
        !            56:        while (argc>1 && (arg = argv[1])[0]=='-') {
        !            57:                if (arg[1] && arg[2]) {
        !            58:                        remote[12] = arg[1];
        !            59:                        remote[13] = arg[2];
        !            60:                        remote[14] = 0;
        !            61:                } else switch (arg[1]) {
        !            62: 
        !            63:                case 'W':
        !            64:                        wide++;
        !            65:                        tfname = VPtfname;
        !            66:                        cfname = VPcfname;
        !            67:                        dfname = VPdfname;
        !            68:                        break;
        !            69: 
        !            70:                case '-':
        !            71:                        remote[12] = 'r';
        !            72:                        remote[13] = '1';
        !            73:                        remote[14] = '\0';
        !            74:                        break;
        !            75: 
        !            76:                case 'c':
        !            77:                        flag = '+';
        !            78:                        break;
        !            79: 
        !            80:                case 'r':
        !            81:                        flag = '-';
        !            82:                        break;
        !            83: 
        !            84:                 case 'v':
        !            85:                         plotit = 1;
        !            86:                         width = 0;
        !            87:                         break;
        !            88: 
        !            89:                case 'm':
        !            90:                        mailflg = 1;
        !            91:                        break;
        !            92: 
        !            93:                case 't':
        !            94:                        troffit = 1;
        !            95:                        width = 0;
        !            96:                        break;
        !            97: 
        !            98:                case '4':
        !            99:                case '3':
        !           100:                case '2':
        !           101:                case '1':
        !           102:                        fonts[arg[1] - '1'] = argv[2];
        !           103:                        troffit = 1;
        !           104:                        argv++;
        !           105:                        argc--;
        !           106:                        break;
        !           107: 
        !           108:                case 'w':
        !           109:                        if (troffit)
        !           110:                                break;
        !           111:                        if (arg[2] == 0)
        !           112:                                width = 0;
        !           113:                        else
        !           114:                                width = arg;
        !           115:                        break;
        !           116: 
        !           117:                case 'l':
        !           118:                        literal++;      /* Pass control chars through. */
        !           119:                        break;
        !           120:                }
        !           121:                argc--;
        !           122:                argv++;
        !           123:        }
        !           124:        pidfn();
        !           125:        tff = nfile(tfname);
        !           126:        if (!wide)              /* varian doesn't use sidebyside. */
        !           127:                width = 0;
        !           128:        ident();
        !           129:        if(argc == 1)
        !           130:                copy(0);
        !           131:        while(--argc > 0) {
        !           132:                arg = *++argv;
        !           133: /*
        !           134:                if(flag == '+')
        !           135:                        goto cf;
        !           136:  * This may not work because the daemon runs as someone else, so don't bother
        !           137:                if(*arg == '/' && flag != '-') {
        !           138:                        card(literal ? 'G' : 'F', arg);
        !           139:                        nact++;
        !           140:                        continue;
        !           141:                }
        !           142:                if(link(arg, lfname) < 0)
        !           143:                        goto cf;
        !           144:                card(literal ? 'G' : 'F', lfname);
        !           145:                card('U', lfname);
        !           146:                lfname[inchar]++;
        !           147:                nact++;
        !           148:                goto df;
        !           149:  */
        !           150: 
        !           151:        cf:
        !           152:                f = open(arg, 0);
        !           153:                if(f < 0) {
        !           154:                        printf("Cannot open %s\n", arg);
        !           155:                        if (plotit) {
        !           156:                                --argc;
        !           157:                                arg = *++argv;
        !           158:                        }
        !           159:                        continue;
        !           160:                }
        !           161:                 if (plotit) {
        !           162:                        if (--argc > 0) {
        !           163:                                arg = *++argv;
        !           164:                                fv = open(arg, 0);
        !           165:                                if (fv < 0) {
        !           166:                                        printf("Cannot open %s\n", arg);
        !           167:                                        close(f);
        !           168:                                        continue;
        !           169:                                }
        !           170:                        }
        !           171:                        else {
        !           172:                                printf("Versaplot requires parm and vector file\n");
        !           173:                                close(f);
        !           174:                                continue;
        !           175:                        }
        !           176:                        copy(fv);
        !           177:                        close(fv);
        !           178:                }
        !           179:                copy(f);
        !           180:                close(f);
        !           181: 
        !           182:        df:
        !           183:                if(flag == '-') {
        !           184:                        f = unlink(arg);
        !           185:                        if(f < 0)
        !           186:                                printf("Cannot remove %s\n", arg);
        !           187:                }
        !           188:        }
        !           189: 
        !           190:        if(nact) {
        !           191:                tfname[inchar]--;
        !           192:                f = link(tfname, dfname);
        !           193:                if(f < 0) {
        !           194:                        printf("Cannot rename %s\n", dfname);
        !           195:                        tfname[inchar]++;
        !           196:                        out();
        !           197:                }
        !           198:                unlink(tfname);
        !           199:                if (wide)
        !           200:                        execl(VPD, "vpd", 0);
        !           201:                else
        !           202:                        execl(VAD, "vad", 0);
        !           203:                dfname[inchar]++;
        !           204:                printf("Daemon doesn't exist\n");
        !           205:                exit(0);
        !           206:        }
        !           207:        out();
        !           208: }
        !           209: 
        !           210: copy(f)
        !           211: int f;
        !           212: {
        !           213:        int ff, i, nr, nc;
        !           214:        static char buf[BUFSIZ];
        !           215:        int status;
        !           216: 
        !           217:        for (i = 0; i < 3; i++)
        !           218:                if (fonts[i])
        !           219:                        card('1' + i, fonts[i]);
        !           220:        if (troffit)
        !           221:                card('T', cfname);
        !           222:        else if (plotit)
        !           223:                card('P', cfname);
        !           224:        else
        !           225:                card(literal ? 'G' : 'F', cfname);
        !           226:        card('U', cfname);
        !           227:        ff = nfile(cfname);
        !           228:        nc = 0;
        !           229:        nr = 0;
        !           230:        if (width) {
        !           231:                int pvec[2];
        !           232:                pipe(pvec);
        !           233:                i = fork();
        !           234:                if (i < 0) {
        !           235:                        printf("No more processes\n");
        !           236:                        out();
        !           237:                }
        !           238:                if (i == 0) {
        !           239:                        if (f != 0) {
        !           240:                                close(0);
        !           241:                                dup(f);
        !           242:                        }
        !           243:                        close(1);
        !           244:                        dup(pvec[1]);
        !           245:                        close(pvec[0]);
        !           246:                        close(pvec[1]);
        !           247:                        execl("/usr/lib/sidebyside", "sidebyside", width, 0);
        !           248:                        perror("/usr/lib/sidebyside");
        !           249:                        exit(1);
        !           250:                }
        !           251:                close(pvec[1]);
        !           252:                close(f);
        !           253:                f = pvec[0];
        !           254:        }
        !           255:        while((i = read(f, buf, BUFSIZ)) > 0) {
        !           256:                write(ff, buf, i);
        !           257:                nc += i;
        !           258:                if(nc >= BUFSIZ) {
        !           259:                        nc -= BUFSIZ;
        !           260:                        nr++;
        !           261:                        if(nr > maxrec) {
        !           262:                                printf("Copy file is too large\n");
        !           263:                                break;
        !           264:                        }
        !           265:                }
        !           266:        }
        !           267:        close(ff);
        !           268:        nact++;
        !           269:        wait(&status);
        !           270: }
        !           271: 
        !           272: card(c, s)
        !           273: int c;
        !           274: char s[];
        !           275: {
        !           276:        char *p1, *p2;
        !           277:        static char buf[BUFSIZ];
        !           278:        int col;
        !           279: 
        !           280:        p1 = buf;
        !           281:        p2 = s;
        !           282:        col = 0;
        !           283:        *p1++ = c;
        !           284:        while((c = *p2++) != '\0') {
        !           285:                *p1++ = c;
        !           286:                col++;
        !           287:        }
        !           288:        *p1++ = '\n';
        !           289:        write(tff, buf, col+2);
        !           290: }
        !           291: 
        !           292: ident()
        !           293: {
        !           294:        int c, n;
        !           295:        register char *b1p, *pp, *b2p;
        !           296:        static char b1[100], b2[100];
        !           297: 
        !           298:        b1p = b1;
        !           299:        if(getpw(getuid(), b1p)) {
        !           300:                b1p = "pdp::::m0000,m000:";
        !           301:        }
        !           302:        n = 0;
        !           303:        b2p = b2;
        !           304:        while(*b2p++ = "$       ident   "[n++]);
        !           305:        b2p--;
        !           306:        n = 5;
        !           307:        while(--n) while(*b1p++ != ':');
        !           308:        while((*b2p++ = *b1p++) != ':');
        !           309:        b2p[-1] = ',';
        !           310:        b1p = b1;
        !           311:        pp = person;
        !           312:        while((c = *b1p++) != ':') {
        !           313:                *b2p++ = c;
        !           314:                *pp++ = c;
        !           315:        }
        !           316:        *b2p++ = 0;
        !           317:        *pp++ = 0;
        !           318:        card('L', person);
        !           319:        if (mailflg)
        !           320:                card('M', person);
        !           321: }
        !           322: 
        !           323: pidfn()
        !           324: {
        !           325:        register i, j, c;
        !           326:        int s;
        !           327:        int p;
        !           328: 
        !           329:        s = p = getpid();
        !           330:        p &= 077777;
        !           331:        i = 0;
        !           332:        while(tfname[i] != 'X')
        !           333:                i++;
        !           334:        i += 4;
        !           335:        for(j=0; j<5; j++) {
        !           336:                c = (p%10) + '0';
        !           337:                if(s<0 && j==4)
        !           338:                        c += 4;
        !           339:                p /= 10;
        !           340:                tfname[i] = c;
        !           341:                cfname[i] = c;
        !           342: /*
        !           343:                lfname[i] = c;
        !           344: */
        !           345:                dfname[i] = c;
        !           346:                i--;
        !           347:        }
        !           348:        inchar = i;
        !           349: }
        !           350: 
        !           351: nfile(name)
        !           352: char *name;
        !           353: {
        !           354:        register f;
        !           355: 
        !           356:        f = creat(name, 0644);
        !           357:        if(f < 0) {
        !           358:                printf("Cannot create %s\n", name);
        !           359:                out();
        !           360:        }
        !           361:        name[inchar]++;
        !           362:        return(f);
        !           363: }
        !           364: 
        !           365: out()
        !           366: {
        !           367:        register i;
        !           368: 
        !           369:        signal(SIGINT, SIG_IGN);
        !           370:        signal(SIGQUIT, SIG_IGN);
        !           371:        signal(SIGHUP, SIG_IGN);
        !           372:        signal(SIGTERM, SIG_IGN);
        !           373:        i = inchar;
        !           374:        while(tfname[i] != 'a') {
        !           375:                tfname[i]--;
        !           376:                unlink(tfname);
        !           377:        }
        !           378:        while(cfname[i] != 'a') {
        !           379:                cfname[i]--;
        !           380:                unlink(cfname);
        !           381:        }
        !           382: /*
        !           383:        while(lfname[i] != 'a') {
        !           384:                lfname[i]--;
        !           385:                unlink(lfname);
        !           386:        }
        !           387: */
        !           388:        while(dfname[i] != 'a') {
        !           389:                dfname[i]--;
        !           390:                unlink(dfname);
        !           391:        }
        !           392:        exit(0);
        !           393: }

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