Return to vprm.c CVS log

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

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

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