Return to lprm.c CVS log

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

Annotation of 41BSD/cmd/lpr/lprm.c, revision 1.1.1.1

1.1       root        1: #include <sys/types.h>
                      2: #include <dir.h>
                      3: #include <stat.h>
                      4: #include <stdio.h>
                      5: 
                      6: char   line[128];
                      7: int    linel;
                      8: int    all;
                      9: char   lpddir[] = "/usr/spool/lpd";
                     10: FILE   *df;
                     11: FILE   *dfb;
                     12: 
                     13: main(argc, argv)
                     14:        int argc;
                     15:        char *argv[];
                     16: {
                     17:        register int i;
                     18:        register char *ap, *cp;
                     19:        int cnt;
                     20: 
                     21:        if (chdir(lpddir) < 0)
                     22:                perror(lpddir), exit(1);
                     23:        df = fopen(".", "r");
                     24:        if (df == NULL)
                     25:                perror(lpddir), exit(1);
                     26:        argc--, argv++;
                     27:        if (argc == 0) {
                     28:                printf("usage: lprm [ id ... ] [ filename ... ] [ user ... ]\n");
                     29:                exit(1);
                     30:        }
                     31:        do {
                     32:                if (strcmp(*argv, "-a") == 0)
                     33:                        all++;
                     34:                clobber(*argv++);
                     35:        } while (--argc);
                     36: }
                     37: 
                     38: clobber(cp)
                     39:        char *cp;
                     40: {
                     41:        struct dir dirent;
                     42:        int did = 0;
                     43: 
                     44:        rewind(df);
                     45:        while (fread(&dirent, sizeof dirent, 1, df) == 1) {
                     46:                if (dirent.d_ino == 0)
                     47:                        continue;
                     48:                if (dirent.d_name[0] != 'd' || dirent.d_name[1] != 'f')
                     49:                        continue;
                     50:                if (dirent.d_name[7] == 0 || dirent.d_name[8] != 0)
                     51:                        continue;
                     52:                if (chkclob(cp, dirent.d_name)) {
                     53:                        did++;
                     54:                        printf("removing %s\n", dirent.d_name+3);
                     55:                        unlink(dirent.d_name);
                     56:                        dirent.d_name[0] = 'c'; unlink(dirent.d_name);
                     57:                        dirent.d_name[0] = 'l'; unlink(dirent.d_name);
                     58:                        dirent.d_name[0] = 't'; unlink(dirent.d_name);
                     59:                        dirent.d_name[0] = 'd';
                     60:                }
                     61:        }
                     62:        if (did == 0)
                     63:                fprintf(stderr, "%s: nothing to remove\n", cp);
                     64: }
                     65: 
                     66: chkclob(pattern, file)
                     67:        char *pattern, *file;
                     68: {
                     69:        register char *id = pattern;
                     70: 
                     71:        /*
                     72:         * Quick check for matching id
                     73:         */
                     74:        if (any(id[0], "cd") && id[1] == 'f' && id[2] == 'a')
                     75:                id += 3;
                     76:        if (strcmp(file+3, id) == 0)
                     77:                return (1);
                     78:        /*
                     79:         * Now check for matching filename 'B', 'F' or id 'L'
                     80:         */
                     81:        dfb = fopen(file, "r");
                     82:        if (dfb == NULL)
                     83:                return (0);
                     84:        while (getline()) switch (line[0]) {
                     85: 
                     86:        case 'L':
                     87:        case 'B':
                     88:        case 'F':
                     89:                if (strcmp(line+1, pattern) == 0) {
                     90:                        fclose(dfb);
                     91:                        return (1);
                     92:                }
                     93:                continue;
                     94:        }
                     95:        fclose(dfb);
                     96:        return (0);
                     97: }
                     98: 
                     99: any(c, cp)
                    100:        char c;
                    101:        register char *cp;
                    102: {
                    103: 
                    104:        while (*cp)
                    105:                if (c == *cp++)
                    106:                        return (1);
                    107:        return (0);
                    108: }
                    109: 
                    110: getline()
                    111: {
                    112:        register int i, c;
                    113: 
                    114:        i = 0;
                    115:        while ((c = getc(dfb)) != '\n') {
                    116:                if (c <= 0)
                    117:                        return(0);
                    118:                if (i < 100)
                    119:                        line[i++] = c;
                    120:        }
                    121:        line[i++] = 0;
                    122:        return (1);
                    123: }

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