Return to lpr.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / lpr

Annotation of 3BSD/cmd/lpr/lpr.c, revision 1.1

1.1     ! root        1: #include <signal.h>
        !             2: #include <pagsiz.h>
        !             3: 
        !             4: #define        BUFSIZ  BSIZE
        !             5: /*
        !             6:  * lpr -- on-line printer spooler
        !             7:  */
        !             8: 
        !             9: char   tfname[]        = "/usr/spool/lpd/tfaXXXXX";
        !            10: char   cfname[]        = "/usr/spool/lpd/cfaXXXXX";
        !            11: char   lfname[]        = "/usr/spool/lpd/lfaXXXXX";
        !            12: char   dfname[]        = "/usr/spool/lpd/dfaXXXXX";
        !            13: int    nact;
        !            14: int    tff;
        !            15: int    mailflg;
        !            16: char   person[10];
        !            17: int    inchar;
        !            18: int    maxrec  = 400;
        !            19: 
        !            20: main(argc, argv)
        !            21:        int argc;
        !            22:        char *argv[];
        !            23: {
        !            24:        register char *arg, *remote;
        !            25:        int c, f, flag;
        !            26:        int out();
        !            27: 
        !            28:        pidfn();
        !            29:        if (signal(SIGINT, SIG_IGN) == SIG_DFL)
        !            30:                signal(SIGINT, out);
        !            31:        if (signal(SIGQUIT, SIG_IGN) == SIG_DFL)
        !            32:                signal(SIGQUIT, out);
        !            33:        if (signal(SIGHUP, SIG_IGN) == SIG_DFL)
        !            34:                signal(SIGHUP, out);
        !            35:        if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
        !            36:                signal(SIGTERM, out);
        !            37:        remote = "$     remote  **,onl";
        !            38:        flag = 0;
        !            39:        tff = nfile(tfname);
        !            40:        while (argc>1 && (arg = argv[1])[0]=='-') {
        !            41:                if (arg[1] && arg[2]) {
        !            42:                        remote[12] = arg[1];
        !            43:                        remote[13] = arg[2];
        !            44:                        remote[14] = 0;
        !            45:                } else switch (arg[1]) {
        !            46: 
        !            47:                case '-':
        !            48:                        remote[12] = 'r';
        !            49:                        remote[13] = '1';
        !            50:                        remote[14] = '\0';
        !            51:                        break;
        !            52: 
        !            53:                case 'c':
        !            54:                        flag = '+';
        !            55:                        break;
        !            56: 
        !            57:                case 'r':
        !            58:                        flag = '-';
        !            59:                        break;
        !            60: 
        !            61:                case 'm':
        !            62:                        mailflg = 1;
        !            63:                        break;
        !            64:                }
        !            65:                argc--;
        !            66:                argv++;
        !            67:        }
        !            68:        ident();
        !            69:        if(argc == 1)
        !            70:                copy(0);
        !            71:        while(--argc) {
        !            72:                arg = *++argv;
        !            73:                if(flag == '+')
        !            74:                        goto cf;
        !            75: /*
        !            76:  * This may not work because the daemon runs as someone else, so don't bother
        !            77:                if(*arg == '/' && flag != '-') {
        !            78:                        card('F', arg);
        !            79:                        nact++;
        !            80:                        continue;
        !            81:                }
        !            82:  */
        !            83:                if(link(arg, lfname) < 0)
        !            84:                        goto cf;
        !            85:                card('F', lfname);
        !            86:                card('U', lfname);
        !            87:                lfname[inchar]++;
        !            88:                nact++;
        !            89:                goto df;
        !            90: 
        !            91:        cf:
        !            92:                f = open(arg, 0);
        !            93:                if(f < 0) {
        !            94:                        printf("Cannot open %s\n", arg);
        !            95:                        continue;
        !            96:                }
        !            97:                copy(f);
        !            98:                close(f);
        !            99: 
        !           100:        df:
        !           101:                if(flag == '-') {
        !           102:                        f = unlink(arg);
        !           103:                        if(f < 0)
        !           104:                                printf("Cannot remove %s\n", arg);
        !           105:                }
        !           106:        }
        !           107: 
        !           108:        if(nact) {
        !           109:                tfname[inchar]--;
        !           110:                f = link(tfname, dfname);
        !           111:                if(f < 0) {
        !           112:                        printf("Cannot rename %s\n", dfname);
        !           113:                        tfname[inchar]++;
        !           114:                        out();
        !           115:                }
        !           116:                unlink(tfname);
        !           117:                execl("/usr/lib/lpd", "lpd", 0);
        !           118:                dfname[inchar]++;
        !           119:                printf("Daemon doesn't exist\n");
        !           120:                exit(0);
        !           121:        }
        !           122:        out();
        !           123: }
        !           124: 
        !           125: copy(f)
        !           126: int f;
        !           127: {
        !           128:        int ff, i, nr, nc;
        !           129:        static char buf[BUFSIZ];
        !           130: 
        !           131:        card('F', cfname);
        !           132:        card('U', cfname);
        !           133:        ff = nfile(cfname);
        !           134:        nc = 0;
        !           135:        nr = 0;
        !           136:        while((i = read(f, buf, BUFSIZ)) > 0) {
        !           137:                write(ff, buf, i);
        !           138:                nc += i;
        !           139:                if(nc >= BUFSIZ) {
        !           140:                        nc -= BUFSIZ;
        !           141:                        nr++;
        !           142:                        if(nr > maxrec) {
        !           143:                                printf("Copy file is too large\n");
        !           144:                                break;
        !           145:                        }
        !           146:                }
        !           147:        }
        !           148:        close(ff);
        !           149:        nact++;
        !           150: }
        !           151: 
        !           152: card(c, s)
        !           153: int c;
        !           154: char s[];
        !           155: {
        !           156:        char *p1, *p2;
        !           157:        static char buf[BUFSIZ];
        !           158:        int col;
        !           159: 
        !           160:        p1 = buf;
        !           161:        p2 = s;
        !           162:        col = 0;
        !           163:        *p1++ = c;
        !           164:        while((c = *p2++) != '\0') {
        !           165:                *p1++ = c;
        !           166:                col++;
        !           167:        }
        !           168:        *p1++ = '\n';
        !           169:        write(tff, buf, col+2);
        !           170: }
        !           171: 
        !           172: ident()
        !           173: {
        !           174:        int c, n;
        !           175:        register char *b1p, *pp, *b2p;
        !           176:        static char b1[100], b2[100];
        !           177: 
        !           178:        b1p = b1;
        !           179:        if(getpw(getuid(), b1p)) {
        !           180:                b1p = "pdp::::m0000,m000:";
        !           181:        }
        !           182:        n = 0;
        !           183:        b2p = b2;
        !           184:        while(*b2p++ = "$       ident   "[n++]);
        !           185:        b2p--;
        !           186:        n = 5;
        !           187:        while(--n) while(*b1p++ != ':');
        !           188:        while((*b2p++ = *b1p++) != ':');
        !           189:        b2p[-1] = ',';
        !           190:        b1p = b1;
        !           191:        pp = person;
        !           192:        while((c = *b1p++) != ':') {
        !           193:                *b2p++ = c;
        !           194:                *pp++ = c;
        !           195:        }
        !           196:        *b2p++ = 0;
        !           197:        *pp++ = 0;
        !           198:        card('L', person);
        !           199:        if (mailflg)
        !           200:                card('M', person);
        !           201: }
        !           202: 
        !           203: pidfn()
        !           204: {
        !           205:        register i, j, c;
        !           206:        int s;
        !           207:        int p;
        !           208: 
        !           209:        s = p = getpid();
        !           210:        p &= 077777;
        !           211:        i = 0;
        !           212:        while(tfname[i] != 'X')
        !           213:                i++;
        !           214:        i += 4;
        !           215:        for(j=0; j<5; j++) {
        !           216:                c = (p%10) + '0';
        !           217:                if(s<0 && j==4)
        !           218:                        c += 4;
        !           219:                p /= 10;
        !           220:                tfname[i] = c;
        !           221:                cfname[i] = c;
        !           222:                lfname[i] = c;
        !           223:                dfname[i] = c;
        !           224:                i--;
        !           225:        }
        !           226:        inchar = i;
        !           227: }
        !           228: 
        !           229: nfile(name)
        !           230: char *name;
        !           231: {
        !           232:        register f;
        !           233: 
        !           234:        f = creat(name, 0644);
        !           235:        if(f < 0) {
        !           236:                printf("Cannot create %s\n", name);
        !           237:                out();
        !           238:        }
        !           239:        name[inchar]++;
        !           240:        return(f);
        !           241: }
        !           242: 
        !           243: out()
        !           244: {
        !           245:        register i;
        !           246: 
        !           247:        signal(SIGINT, SIG_IGN);
        !           248:        signal(SIGQUIT, SIG_IGN);
        !           249:        signal(SIGHUP, SIG_IGN);
        !           250:        signal(SIGTERM, SIG_IGN);
        !           251:        i = inchar;
        !           252:        while(tfname[i] != 'a') {
        !           253:                tfname[i]--;
        !           254:                unlink(tfname);
        !           255:        }
        !           256:        while(cfname[i] != 'a') {
        !           257:                cfname[i]--;
        !           258:                unlink(cfname);
        !           259:        }
        !           260:        while(lfname[i] != 'a') {
        !           261:                lfname[i]--;
        !           262:                unlink(lfname);
        !           263:        }
        !           264:        while(dfname[i] != 'a') {
        !           265:                dfname[i]--;
        !           266:                unlink(dfname);
        !           267:        }
        !           268:        exit(0);
        !           269: }

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