Return to atrm.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / at / atrm

Annotation of 43BSDReno/usr.bin/at/atrm/atrm.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: char copyright[] =
        !             9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\
        !            10:  All rights reserved.\n";
        !            11: #endif not lint
        !            12: 
        !            13: #ifndef lint
        !            14: static char sccsid[] = "@(#)atrm.c     5.5 (Berkeley) 5/11/89";
        !            15: #endif not lint
        !            16: 
        !            17: /*
        !            18:  *     synopsis: atrm [-f] [-i] [-] [[job #] [user] ...]
        !            19:  *
        !            20:  *
        !            21:  *     Remove files from the directory /usr/spool/at. These files
        !            22:  *     represent jobs to be run at a later date.
        !            23:  *
        !            24:  *     Author: Steve Wall
        !            25:  *             Computer Systems Research Group
        !            26:  *             University of California @ Berkeley
        !            27:  *
        !            28:  */
        !            29: 
        !            30: #include <sys/types.h>
        !            31: #include <sys/dir.h>
        !            32: #include <sys/file.h>
        !            33: #include <sys/stat.h>
        !            34: #include <stdio.h>
        !            35: #include <pwd.h>
        !            36: #include <ctype.h>
        !            37: #include "pathnames.h"
        !            38: 
        !            39: #define SUPERUSER      0                       /* is user super-user? */
        !            40: #define MAXENTRIES     1000                    /* max # of entries allowed */
        !            41: 
        !            42: int user;                                      /* person requesting removal */
        !            43: int fflag = 0;                                 /* suppress announcements? */
        !            44: int iflag = 0;                                 /* run interactively? */
        !            45: 
        !            46: main(argc,argv)
        !            47: int argc;
        !            48: char **argv;
        !            49: 
        !            50: {
        !            51:        register int i;                 /* for loop index */
        !            52:        int isuname;                    /* is a command line argv a user name?*/
        !            53:        int numjobs;                    /* # of jobs in spooling area */
        !            54:        int usage();                    /* print usage info and exit */
        !            55:        int allflag = 0;                /* remove all jobs belonging to user? */
        !            56:        int jobno;
        !            57:        int jobexists;                  /* does a requested job exist? */
        !            58:        int alphasort();                /* sort jobs by date of execution */
        !            59:        int filewanted();               /* should a file be listed in queue? */
        !            60:        char *myname, *getname();       /* current user's name */
        !            61:        char *owner, *fowner();
        !            62:        struct stat *statptr;           /* pointer to file stat structure */
        !            63:        struct stat *stbuf[MAXENTRIES]; /* array of pointers to stat structs */
        !            64:        struct direct **namelist;       /* names of jobs in spooling area */
        !            65: 
        !            66: 
        !            67:        /*
        !            68:         * If job number, user name, or "-" is not specified, just print
        !            69:         * usage info and exit.
        !            70:         */
        !            71:        if (argc < 2)
        !            72:                usage();
        !            73: 
        !            74:        --argc; ++argv;
        !            75: 
        !            76:        /*
        !            77:         * Process command line flags.
        !            78:         * Special case the "-" option so that others may be grouped.
        !            79:         */
        !            80:        while (argc > 0 && **argv == '-') {
        !            81:                if (*(++(*argv)) == '\0') {
        !            82:                        ++allflag;
        !            83:                } else while (**argv) switch (*(*argv)++) {
        !            84: 
        !            85:                        case 'f':       ++fflag;
        !            86:                                        break;
        !            87:                                        
        !            88:                        case 'i':       ++iflag;
        !            89:                                        break;
        !            90:                                        
        !            91:                        default:        usage();
        !            92:                }
        !            93:                ++argv; --argc;
        !            94:        }
        !            95: 
        !            96:        /*
        !            97:         * If all jobs are to be removed and extra command line arguments 
        !            98:         * are given, print usage info and exit.
        !            99:         */
        !           100:        if (allflag && argc) 
        !           101:                usage();
        !           102: 
        !           103:        /*
        !           104:         * If only certain jobs are to be removed and no job #'s or user
        !           105:         * names are specified, print usage info and exit.
        !           106:         */
        !           107:        if (!allflag && !argc)
        !           108:                usage();
        !           109: 
        !           110:        /*
        !           111:         * If interactive removal and quiet removal are requested, override
        !           112:         * quiet removal and run interactively.
        !           113:         */
        !           114:        if (iflag && fflag)
        !           115:                fflag = 0;
        !           116: 
        !           117:        /* 
        !           118:         * Move to spooling area and get user id of person requesting removal.
        !           119:         */
        !           120:        if (chdir(_PATH_ATDIR) == -1) {
        !           121:                perror(_PATH_ATDIR);
        !           122:                exit(1);
        !           123:        }
        !           124:        user = getuid();
        !           125:        myname = getname(user);
        !           126: 
        !           127:        /*
        !           128:         * Get a list of the files in the spooling area.
        !           129:         */
        !           130:        if ((numjobs = scandir(".",&namelist,filewanted,alphasort)) < 0) {
        !           131:                perror(_PATH_ATDIR);
        !           132:                exit(1);
        !           133:        }
        !           134: 
        !           135:        /*
        !           136:         * Build an array of pointers to the file stats for all jobs in
        !           137:         * the spooling area.
        !           138:         */
        !           139:        for (i = 0; i < numjobs; ++i) { 
        !           140:                statptr = (struct stat *) malloc(sizeof(struct stat));
        !           141:                if (statptr == NULL) {
        !           142:                        perror("malloc");
        !           143:                        exit(1);
        !           144:                }
        !           145:                if (stat(namelist[i]->d_name,statptr) < 0) {
        !           146:                        perror("stat");
        !           147:                        continue;
        !           148:                }
        !           149:                stbuf[i] = statptr;
        !           150:        }
        !           151: 
        !           152:        /*
        !           153:         * If all jobs belonging to the user are to be removed, compare
        !           154:         * the user's id to the owner of the file. If they match, remove
        !           155:         * the file. If the user is the super-user, don't bother comparing
        !           156:         * the id's. After all files are removed, exit (status 0).
        !           157:         */
        !           158:        if (allflag) {
        !           159:                for (i = 0; i < numjobs; ++i) { 
        !           160:                        owner = fowner(namelist[i]->d_name); 
        !           161:                        if (isowner(myname, owner)) 
        !           162:                                removentry(namelist[i]->d_name,
        !           163:                                    (int)stbuf[i]->st_ino, NULL);
        !           164:                }
        !           165:                exit(0);
        !           166:        }
        !           167: 
        !           168:        /*
        !           169:         * If only certain jobs are to be removed, interpret each command
        !           170:         * line argument. A check is done to see if it is a user's name or
        !           171:         * a job number (inode #). If it's a user's name, compare the argument
        !           172:         * to the files owner. If it's a job number, compare the argument to
        !           173:         * the inode number of the file. In either case, if a match occurs,
        !           174:         * try to remove the file. (The function "isusername" scans the
        !           175:         * argument to see if it is all digits which we will assume means 
        !           176:         * that it's a job number (a fairly safe assumption?). This is done
        !           177:         * because we have to determine whether we are dealing with a user
        !           178:         * name or a job number. By assuming that only arguments that are
        !           179:         * all digits is a job number, we allow users to have digits in
        !           180:         * their login name i.e. "johndoe2").
        !           181:         */
        !           182: 
        !           183:        while (argc--) {
        !           184:                jobexists = 0;
        !           185:                isuname = isusername(*argv);
        !           186:                if (!isuname)
        !           187:                        jobno = atoi(*argv);
        !           188:                for (i = 0; i < numjobs; ++i) {
        !           189: 
        !           190:                        /* if the inode number is 0, this entry was removed */
        !           191:                        if (stbuf[i]->st_ino == 0)
        !           192:                                continue;
        !           193: 
        !           194:                        owner = fowner(namelist[i]->d_name);
        !           195:                        /* 
        !           196:                         * if argv is a username, compare it to
        !           197:                         * the owner of the file......
        !           198:                         * otherwise, we assume that the argv is a job # and
        !           199:                         * thus compare argv to the inode (job #) of the file.
        !           200:                         */
        !           201:                        if (isuname) {
        !           202:                                if (strcmp(*argv, owner))
        !           203:                                        continue;
        !           204:                        } else {
        !           205:                                if (stbuf[i]->st_ino != jobno) 
        !           206:                                        continue;
        !           207:                        }
        !           208:                        ++jobexists;
        !           209:                        /*
        !           210:                         * if the entry is removed, don't
        !           211:                         * try to remove it again later.
        !           212:                         */
        !           213:                        if (user == SUPERUSER || isowner(myname, owner)) {
        !           214:                                removentry(namelist[i]->d_name,
        !           215:                                    (int)stbuf[i]->st_ino, owner);
        !           216:                                stbuf[i]->st_ino = 0;
        !           217:                        } else if (!fflag)
        !           218:                                printf("%6d: permission denied\n",
        !           219:                                    stbuf[i]->st_ino);
        !           220:                        if (!isuname)
        !           221:                                break;
        !           222:                }
        !           223: 
        !           224:                /*
        !           225:                 * If a requested argument doesn't exist, print a message.
        !           226:                 */
        !           227:                if (!jobexists && !fflag && !isuname) {
        !           228:                        fprintf(stderr, "%6s: no such job number\n", *argv);
        !           229:                }
        !           230:                ++argv;
        !           231:        }
        !           232:        exit(0);
        !           233: }
        !           234: 
        !           235: /*
        !           236:  * Print usage info and exit.
        !           237:  */
        !           238: usage()
        !           239: {
        !           240:        fprintf(stderr,"usage: atrm [-f] [-i] [-] [[job #] [user] ...]\n");
        !           241:        exit(1);
        !           242: }
        !           243: 
        !           244: /*
        !           245:  * Do we want to include a file in the queue? (used by "scandir") We are looking
        !           246:  * for files with following syntax: yy.ddd.hhhh. so the test is made to see if 
        !           247:  * the file name has three dots in it. This test will suffice since the only
        !           248:  * other files in /usr/spool/at don't have any dots in their name.
        !           249:  */
        !           250: filewanted(direntry)
        !           251: struct direct *direntry;
        !           252: {
        !           253:        int numdot = 0;                 /* number of dots in a filename */
        !           254:        char *filename;                 /* filename we are looking at */
        !           255: 
        !           256:        filename = direntry->d_name;
        !           257:        while (*filename)
        !           258:                numdot += (*(filename++) == '.');
        !           259:        return(numdot == 3);
        !           260: }
        !           261: 
        !           262: /*
        !           263:  * Is a command line argument a username? As noted above we will assume 
        !           264:  * that an argument that is all digits means that it's a job number, not
        !           265:  * a user's name. We choose to determine whether an argument is a user name
        !           266:  * in this manner because then it's ok for someone to have digits in their 
        !           267:  * user name.
        !           268:  */
        !           269: isusername(string)
        !           270: char *string;
        !           271: {
        !           272:        char *ptr;                      /* pointer used for scanning string */
        !           273: 
        !           274:        ptr = string;
        !           275:        while (isdigit(*ptr))
        !           276:                ++ptr;
        !           277:        return((*ptr == '\0') ? 0 : 1);
        !           278: }
        !           279: 
        !           280: /*
        !           281:  * Remove an entry from the queue. The access of the file is checked for
        !           282:  * write permission (since all jobs are mode 644). If access is granted,
        !           283:  * unlink the file. If the fflag (suppress announcements) is not set,
        !           284:  * print the job number that we are removing and the result of the access
        !           285:  * check (either "permission denied" or "removed"). If we are running 
        !           286:  * interactively (iflag), prompt the user before we unlink the file. If 
        !           287:  * the super-user is removing jobs, inform him/her who owns each file before 
        !           288:  * it is removed.
        !           289:  */
        !           290: removentry(filename, inode, owner)
        !           291: char *filename;
        !           292: int inode;
        !           293: char *owner;
        !           294: {
        !           295: 
        !           296:        if (!fflag)
        !           297:                printf("%6d: ",inode);
        !           298: 
        !           299:        if (iflag) {
        !           300:                if (user == SUPERUSER && owner)
        !           301:                        printf("\t(owned by %s) ", owner);
        !           302:                printf("remove? ");
        !           303:                if (!yes())
        !           304:                        return;
        !           305:        }
        !           306:        if (unlink(filename) < 0)
        !           307:                perror(filename);
        !           308:        else if (!fflag && !iflag)
        !           309:                printf("removed\n");
        !           310: }
        !           311: 
        !           312: /*
        !           313:  * See if "name" owns job owned by "jobname".
        !           314:  */
        !           315: isowner(name,jobname)
        !           316: char *name;
        !           317: char *jobname;
        !           318: {
        !           319: 
        !           320:        return (strcmp(name,jobname) == 0);
        !           321: }
        !           322: 
        !           323: /*
        !           324:  * Return the owner of the job. This is stored on the first line of the
        !           325:  * spoolfile. If we run into trouble getting the name, we'll just return "???".
        !           326:  */
        !           327: char *
        !           328: fowner(file)
        !           329: char *file;
        !           330: {
        !           331:        static char owner[128];                 /* the owner */
        !           332:        FILE *infile;                           /* I/O stream to spoolfile */
        !           333: 
        !           334:        /*
        !           335:         * Open the job file and grab the first line.
        !           336:         */
        !           337: 
        !           338:        if ((infile = fopen(file,"r")) == NULL) {
        !           339:                perror(file);
        !           340:                return ("???");
        !           341:        }
        !           342: 
        !           343:        if (fscanf(infile,"# owner: %127s%*[^\n]\n",owner) != 1) {
        !           344:                fclose(infile);
        !           345:                return ("???");
        !           346:        }
        !           347: 
        !           348:        fclose(infile);
        !           349:        return (owner);
        !           350: 
        !           351: }
        !           352: 
        !           353: /*
        !           354:  * Get answer to interactive prompts, eating all characters beyond the first
        !           355:  * one. If a 'y' is typed, return 1.
        !           356:  */
        !           357: yes()
        !           358: {
        !           359:        char ch;                                /* dummy variable */
        !           360:        char ch1;                               /* dummy variable */
        !           361: 
        !           362:        ch = ch1 = getchar();
        !           363:        while (ch1 != '\n' && ch1 != EOF)
        !           364:                ch1 = getchar();
        !           365:        if (isupper(ch))
        !           366:                ch = tolower(ch);
        !           367:        return(ch == 'y');
        !           368: }
        !           369: 
        !           370: /*
        !           371:  * Get the uid of a person using his/her login name. Return -1 if no
        !           372:  * such account name exists.
        !           373:  */
        !           374: getid(name)
        !           375: char *name;
        !           376: {
        !           377: 
        !           378:        struct passwd *pwdinfo;         /* password info structure */
        !           379:        
        !           380:        if ((pwdinfo = getpwnam(name)) == 0)
        !           381:                return(-1);
        !           382: 
        !           383:        return(pwdinfo->pw_uid);
        !           384: }
        !           385: 
        !           386: /*
        !           387:  * Get the full login name of a person using his/her user id.
        !           388:  */
        !           389: char *
        !           390: getname(uid)
        !           391: int uid;
        !           392: {
        !           393:        struct passwd *pwdinfo;                 /* password info structure */
        !           394:        char *logname, *getlogin();
        !           395:        
        !           396: 
        !           397:        logname = getlogin();
        !           398:        if (logname == NULL || (pwdinfo = getpwnam(logname)) == NULL ||
        !           399:            pwdinfo->pw_uid != uid)
        !           400:                pwdinfo = getpwuid(uid);
        !           401:        if (pwdinfo == 0) {
        !           402:                fprintf(stderr, "no name for uid %d?\n", uid);
        !           403:                exit(1);
        !           404:        }
        !           405:        return(pwdinfo->pw_name);
        !           406: }

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