Return to lprm.c CVS log

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

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

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