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