![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / at|
Return to atq.c CVS log | Up to [CSRG BSD Unix] / 43BSD / 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[] = "@(#)atq.c 5.2 (Berkeley) 5/28/86";
15: #endif not lint
16:
17: /*
18: *
19: * Synopsis: atq [ -c ] [ -n ] [ name ... ]
20: *
21: *
22: * Print the queue of files waiting to be executed. These files
23: * were created by using the "at" command and are located in the
24: * directory "/usr/spool/at".
25: *
26: *
27: * Author: Steve Wall
28: * Computer Systems Research Group
29: * University of California @ Berkeley
30: *
31: */
32:
33: # include <stdio.h>
34: # include <sys/types.h>
35: # include <sys/file.h>
36: # include <sys/dir.h>
37: # include <sys/stat.h>
38: # include <sys/time.h>
39: # include <pwd.h>
40: # include <ctype.h>
41:
42: # define ATDIR "/usr/spool/at" /* spooling area */
43: # define LASTFILE "/usr/spool/at/lasttimedone" /* update time record
44: file */
45:
46: /*
47: * Months of the year
48: */
49: static char *mthnames[12] = {
50: "Jan","Feb","Mar","Apr","May","Jun","Jul",
51: "Aug","Sep","Oct","Nov","Dec",
52: };
53:
54: char *nullentry = NULL; /* avoid 'namelist' NULL ptr problems */
55: int numentries; /* number of entries in spooling area */
56: int namewanted = 0; /* only print jobs belonging to a
57: certain person */
58: struct direct **queue; /* the queue itself */
59:
60:
61: main(argc,argv)
62: int argc;
63: char **argv;
64: {
65:
66: int cflag = 0; /* print in order of creation time */
67: int nflag = 0; /* just print the number of jobs in
68: queue */
69: int usage(); /* print usage info and exit */
70: int creation(); /* sort jobs by date of creation */
71: int alphasort(); /* sort jobs by date of execution */
72: int filewanted(); /* should a file be included in queue?*/
73: int printqueue(); /* print the queue */
74: int countfiles(); /* count the number of files in queue
75: for a given person */
76: char **namelist = &nullentry; /* array of specific name(s) requested*/
77:
78:
79: --argc, ++argv;
80:
81: /*
82: * Interpret command line flags if they exist.
83: */
84: while (argc > 0 && **argv == '-') {
85: (*argv)++;
86: while (**argv) switch (*(*argv)++) {
87:
88: case 'c' : cflag++;
89: break;
90:
91: case 'n' : nflag++;
92: break;
93:
94: default : usage();
95:
96: }
97: --argc, ++argv;
98: }
99:
100: /*
101: * If a certain name (or names) is requested, set a pointer to the
102: * beginning of the list.
103: */
104: if (argc > 0) {
105: ++namewanted;
106: namelist = argv;
107: }
108:
109: /*
110: * Move to the spooling area and scan the directory, placing the
111: * files in the queue structure. The queue comes back sorted by
112: * execution time or creation time.
113: */
114: if (chdir(ATDIR) == -1) {
115: perror(ATDIR);
116: exit(1);
117: }
118: if ((numentries = scandir(".",&queue,filewanted, (cflag) ? creation :
119: alphasort)) < 0) {
120: perror(ATDIR);
121: exit(1);
122: }
123:
124: /*
125: * Either print a message stating:
126: *
127: * 1) that the spooling area is empty.
128: * 2) the number of jobs in the spooling area.
129: * 3) the number of jobs in the spooling area belonging to
130: * a certain person.
131: * 4) that the person requested doesn't have any files in the
132: * spooling area.
133: *
134: * or send the queue off to "printqueue" for printing.
135: *
136: * This whole process might seem a bit elaborate, but it's worthwhile
137: * to print some informative messages for the user.
138: *
139: */
140: if ((numentries == 0) && (!nflag)) {
141: printf("no files in queue.\n");
142: exit(0);
143: }
144: if (nflag) {
145: printf("%d\n",(namewanted) ? countfiles(namelist) : numentries);
146: exit(0);
147: }
148: if ((namewanted) && (countfiles(namelist) == 0)) {
149: printf("no files for %s.\n", (argc == 1) ?
150: *argv : "specified users");
151: exit(0);
152: }
153: printqueue(namelist);
154: exit(0);
155: }
156:
157: /*
158: * Count the number of jobs in the spooling area owned by a certain person(s).
159: */
160: countfiles(namelist)
161: char **namelist;
162: {
163: int i; /* for loop index */
164: int entryfound; /* found file owned by user(s)*/
165: int numfiles = 0; /* number of files owned by a
166: certain person(s) */
167: char **ptr; /* scratch pointer */
168:
169:
170: /*
171: * For each file in the queue, see if the user(s) own the file. We
172: * have to use "entryfound" (rather than simply incrementing "numfiles")
173: * so that if a person's name appears twice on the command line we
174: * don't double the number of files owned by him/her.
175: */
176: for (i = 0; i < numentries ; i++) {
177: ptr = namelist;
178: entryfound = 0;
179:
180: while (*ptr) {
181: if (isowner(*ptr,queue[i]->d_name))
182: ++entryfound;
183: ++ptr;
184: }
185: if (entryfound)
186: ++numfiles;
187: }
188: return(numfiles);
189: }
190:
191: /*
192: * Print the queue. If only jobs belonging to a certain person(s) are requested,
193: * only print jobs that belong to that person(s).
194: */
195: printqueue(namelist)
196: char **namelist;
197: {
198: int i; /* for loop index */
199: int rank = 1; /* rank of a job */
200: int entryfound; /* found file owned by user(s)*/
201: int printrank(); /* print the rank of a job */
202: int plastrun(); /* print the last time the
203: spooling area was updated */
204: int powner(); /* print the name of the owner
205: of the job */
206: int getid(); /* get uid of a person */
207: char **ptr; /* scratch pointer */
208: struct stat stbuf; /* buffer for file stats */
209:
210:
211: /*
212: * Print the time the spooling area was last modified and the header
213: * for the queue.
214: */
215: plastrun();
216: printf(" Rank Execution Date Owner Job # Job Name\n");
217:
218: /*
219: * Print the queue. If a certain name(s) was requested, print only jobs
220: * belonging to that person(s), otherwise print the entire queue.
221: * Once again, we have to use "entryfound" (rather than simply
222: * comparing each command line argument) so that if a person's name
223: * appears twice we don't print each file owned by him/her twice.
224: *
225: *
226: * "printrank", "printdate", and "printjobname" all take existing
227: * data and display it in a friendly manner.
228: *
229: */
230: for (i = 0; i < numentries; i++) {
231: if ((stat(queue[i]->d_name, &stbuf)) < 0) {
232: continue;
233: }
234: if (namewanted) {
235: ptr = namelist;
236: entryfound = 0;
237:
238: while (*ptr) {
239: if (isowner(*ptr,queue[i]->d_name))
240: ++entryfound;
241: ++ptr;
242: }
243: if (!entryfound)
244: continue;
245: }
246: printrank(rank++);
247: printdate(queue[i]->d_name);
248: powner(queue[i]->d_name);
249: printf("%5d",stbuf.st_ino);
250: printjobname(queue[i]->d_name);
251: }
252: ++ptr;
253: }
254:
255: /*
256: * See if "name" owns "job".
257: */
258: isowner(name,job)
259: char *name;
260: char *job;
261: {
262: char buf[128]; /* buffer for 1st line of spoolfile
263: header */
264: FILE *infile; /* I/O stream to spoolfile */
265:
266: if ((infile = fopen(job,"r")) == NULL) {
267: fprintf(stderr,"Couldn't open spoolfile ");
268: perror(job);
269: return(0);
270: }
271:
272: if (fscanf(infile,"# owner: %127s%*[^\n]\n",buf) != 1) {
273: fclose(infile);
274: return(0);
275: }
276:
277: fclose(infile);
278: return((strcmp(name,buf) == 0) ? 1 : 0);
279: }
280:
281: /*
282: * Print the owner of the job. This is stored on the first line of the
283: * spoolfile. If we run into trouble getting the name, we'll just print "???".
284: */
285: powner(file)
286: char *file;
287: {
288: char owner[10]; /* the owner */
289: FILE *infile; /* I/O stream to spoolfile */
290:
291: /*
292: * Open the job file and grab the first line.
293: */
294:
295: if ((infile = fopen(file,"r")) == NULL) {
296: printf("%-10.9s","???");
297: perror(file);
298: return;
299: }
300:
301: if (fscanf(infile,"# owner: %9s%*[^\n]\n",owner) != 1) {
302: printf("%-10.9s","???");
303: fclose(infile);
304: return;
305: }
306:
307: fclose(infile);
308: printf("%-10.9s",owner);
309:
310: }
311:
312:
313: /*
314: * Get the uid of a person using his/her login name. Return -1 if no
315: * such account name exists.
316: */
317: getid(name)
318: char *name;
319: {
320:
321: struct passwd *pwdinfo; /* password info structure */
322:
323:
324: if ((pwdinfo = getpwnam(name)) == 0)
325: return(-1);
326:
327: return(pwdinfo->pw_uid);
328: }
329:
330: /*
331: * Print the time the spooling area was updated.
332: */
333: plastrun()
334: {
335: struct timeval now; /* time it is right now */
336: struct timezone zone; /* NOT USED */
337: struct tm *loc; /* detail of time it is right */
338: u_long lasttime; /* last update time in seconds
339: since 1/1/70 */
340: FILE *last; /* file where last update hour
341: is stored */
342:
343:
344: /*
345: * Open the file where the last update time is stored, and grab the
346: * last update hour. The update time is measured in seconds since
347: * 1/1/70.
348: */
349: if ((last = fopen(LASTFILE,"r")) == NULL) {
350: perror(LASTFILE);
351: exit(1);
352: }
353: fscanf(last,"%d",(u_long) &lasttime);
354: fclose(last);
355:
356: /*
357: * Get a broken down representation of the last update time.
358: */
359: loc = localtime(&lasttime);
360:
361: /*
362: * Print the time that the spooling area was last updated.
363: */
364: printf("\n LAST EXECUTION TIME: %s ",mthnames[loc->tm_mon]);
365: printf("%d, 19%d ",loc->tm_mday,loc->tm_year);
366: printf("at %d:%02d\n\n",loc->tm_hour,loc->tm_min);
367: }
368:
369: /*
370: * Print the rank of a job. (I've got to admit it, I stole it from "lpq")
371: */
372: static
373: printrank(n)
374: {
375: static char *r[] = {
376: "th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"
377: };
378:
379: if ((n/10) == 1)
380: printf("%3d%-5s", n,"th");
381: else
382: printf("%3d%-5s", n, r[n%10]);
383: }
384:
385: /*
386: * Print the date that a job is to be executed. This takes some manipulation
387: * of the file name.
388: */
389: printdate(filename)
390: char *filename;
391: {
392: int yday = 0; /* day of year file will be
393: executed */
394: int min = 0; /* min. file will be executed */
395: int hour = 0; /* hour file will be executed */
396: int day = 0; /* day file will be executed */
397: int month = 0; /* month file will be executed*/
398: int year = 0; /* year file will be executed */
399: int get_mth_day(); /* convert a day of year to a
400: month and day of month */
401: char date[18]; /* reformatted execution date */
402:
403: /*
404: * Pick off the necessary info from the file name and convert the day
405: * of year to a month and day of month.
406: */
407: sscanf(filename,"%2d.%3d.%2d%2d",&year,&yday,&hour,&min);
408: get_mth_day(year,yday,&month,&day);
409:
410: /*
411: * Format the execution date of a job.
412: */
413: sprintf(date,"%3s %2d, 19%2d %02d:%02d",mthnames[month],
414: day, year,hour,min);
415:
416: /*
417: * Print the date the job will be executed.
418: */
419: printf("%-21.18s",date);
420: }
421:
422: /*
423: * Given a day of the year, calculate the month and day of month.
424: */
425: get_mth_day(year,dayofyear,month,day)
426: int year, dayofyear, *month, *day;
427:
428: {
429:
430: int i = 1; /* for loop index */
431: int leap; /* are we dealing with a leap
432: year? */
433: /* Table of the number of days
434: in each month of the year.
435:
436: dofy_tab[1] -- regular year
437: dofy_tab[2] -- leap year
438: */
439:
440: static int dofy_tab[2][13] = {
441: { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
442: { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
443: };
444:
445: /*
446: * Are we dealing with a leap year?
447: */
448: leap = ((year%4 == 0 && year%100 != 0) || year%100 == 0);
449:
450: /*
451: * Calculate the month of the year and day of the month.
452: */
453: while (dayofyear >= dofy_tab[leap][i]) {
454: dayofyear -= dofy_tab[leap][i++];
455: ++(*month);
456: }
457: *day = (dayofyear + 1);
458: }
459:
460: /*
461: * Print a job name. If the old "at" has been used to create the spoolfile,
462: * the three line header that the new version of "at" puts in the spoolfile.
463: * Thus, we just print "???".
464: */
465: printjobname(file)
466: char *file;
467: {
468: char *ptr; /* scratch pointer */
469: char jobname[28]; /* the job name */
470: FILE *filename; /* job file in spooling area */
471:
472: /*
473: * Open the job file and grab the second line.
474: */
475: printf(" ");
476:
477: if ((filename = fopen(file,"r")) == NULL) {
478: printf("%.27s\n", "???");
479: perror(file);
480: return;
481: }
482: /*
483: * Skip over the first line.
484: */
485: fscanf(filename,"%*[^\n]\n");
486:
487: /*
488: * Now get the job name.
489: */
490: if (fscanf(filename,"# jobname: %27s%*[^\n]\n",jobname) != 1) {
491: printf("%.27s\n", "???");
492: fclose(filename);
493: return;
494: }
495: fclose(filename);
496:
497: /*
498: * Put a pointer at the begining of the line and remove the basename
499: * from the job file.
500: */
501: ptr = jobname;
502: if ((ptr = (char *)rindex(jobname,'/')) != 0)
503: ++ptr;
504: else
505: ptr = jobname;
506:
507: if (strlen(ptr) > 23)
508: printf("%.23s ...\n",ptr);
509: else
510: printf("%.27s\n",ptr);
511: }
512:
513: /*
514: * Do we want to include a file in the queue? (used by "scandir") We are looking
515: * for files with following syntax: yy.ddd.hhhh. so the test is made to see if
516: * the file name has three dots in it. This test will suffice since the only
517: * other files in /usr/spool/at don't have any dots in their name.
518: */
519: filewanted(direntry)
520: struct direct *direntry;
521: {
522: int numdot = 0;
523: char *filename;
524:
525: filename = direntry->d_name;
526: while (*filename)
527: numdot += (*(filename++) == '.');
528: return(numdot == 3);
529: }
530:
531: /*
532: * Sort files by time of creation. (used by "scandir")
533: */
534: creation(d1, d2)
535: struct direct **d1, **d2;
536: {
537: struct stat stbuf1, stbuf2;
538:
539: if (stat((*d1)->d_name,&stbuf1) < 0)
540: return(1);
541:
542: if (stat((*d2)->d_name,&stbuf2) < 0)
543: return(1);
544:
545: return(stbuf1.st_ctime < stbuf2.st_ctime);
546: }
547:
548: /*
549: * Print usage info and exit.
550: */
551: usage()
552: {
553: fprintf(stderr,"usage: atq [-c] [-n] [name ...]\n");
554: exit(1);
555: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.