![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uuq.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 / uucp|
Return to uuq.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)uuq.c 4.10 (Berkeley) 5/4/88";
3: #endif
4:
5: /*
6: * This file contains no ATT code and is not subject to the ATT
7: * license provisions regarding redistribution.
8: * Rick Adams 2/23/88
9: */
10:
11: /*
12: * uuq - looks at uucp queues
13: *
14: * Lou Salkind
15: * New York University
16: *
17: */
18:
19: #include "uucp.h"
20: #include <stdio.h>
21:
22: #ifdef NDIR
23: #include "libndir/ndir.h"
24: #else !NDIR
25: #include <sys/dir.h>
26: #endif !NDIR
27: #include <sys/stat.h>
28:
29: #define NOSYS (struct sys *)0
30:
31: #define W_TYPE wrkvec[0]
32: #define W_FILE1 wrkvec[1]
33: #define W_FILE2 wrkvec[2]
34: #define W_USER wrkvec[3]
35: #define W_OPTNS wrkvec[4]
36: #define W_DFILE wrkvec[5]
37: #define W_MODE wrkvec[6]
38: #define WSUFSIZE 5 /* work file name suffix size */
39:
40: struct sys {
41: char s_name[8];
42: int s_njobs;
43: off_t s_bytes;
44: struct job *s_jobp;
45: struct sys *s_sysp;
46: };
47:
48: struct job {
49: int j_files;
50: int j_flags;
51: char j_jobno[WSUFSIZE];
52: char j_user[22];
53: char j_fname[128];
54: char j_grade;
55: off_t j_bytes;
56: time_t j_date;
57: struct job *j_jobp;
58: };
59:
60: struct sys *syshead;
61: struct sys *getsys();
62: int jcompare();
63: char *sysname;
64: char *user;
65: char *rmjob;
66: int hflag;
67: int lflag;
68:
69: char *malloc(), *calloc();
70: double atof();
71: float baudrate = 2400.;
72: char Username[BUFSIZ];
73: char Filename[BUFSIZ];
74: int Maxulen = 0;
75: struct timeb Now;
76:
77: main(argc, argv)
78: int argc;
79: char **argv;
80: {
81: register int i;
82: register struct sys *sp;
83: register struct job *jp;
84: struct job **sortjob;
85: int nsys;
86: extern char *optarg;
87: extern int optind;
88:
89: strcpy(Progname, "uuq");
90: uucpname(Myname);
91:
92: while ((i = getopt(argc, argv, "r:S:s:u:d:b:hl")) != EOF)
93: switch (i) {
94: case 'r':
95: case 'S':
96: Spool = optarg;
97: break;
98: case 's':
99: sysname = optarg;
100: if (strlen(sysname) > SYSNSIZE)
101: sysname[SYSNSIZE] = '\0';
102: break;
103: case 'u':
104: user = optarg;
105: break;
106: case 'd':
107: rmjob = optarg;
108: break;
109: case 'b':
110: baudrate = atof(optarg);
111: break;
112: case 'h':
113: hflag++;
114: break;
115: case 'l':
116: lflag++;
117: break;
118: default:
119: fprintf(stderr,
120: "usage: uuq [-l] [-h] [-ssystem] [-uuser] [-djobno] [-rspool] [-bbaudrate]\n");
121: exit(0);
122: }
123:
124: subchdir(Spool);
125: baudrate *= 0.7; /* reduce speed because of protocol overhead */
126: baudrate *= 7.5; /* convert to chars/minute (60/8) */
127: gather();
128: nsys = 0;
129: for (sp = syshead; sp; sp = sp->s_sysp) {
130: if (sp->s_njobs == 0)
131: continue;
132: if (!hflag && nsys++ > 0)
133: putchar('\n');
134: printf("%s: %d %s", sp->s_name,
135: sp->s_njobs, sp->s_njobs > 1 ? "jobs" : "job");
136: if (lflag) {
137: float minutes;
138: int hours;
139: /* The 80 * njobs is because of the uucp handshaking */
140: minutes = (float)(sp->s_bytes + 80 * sp->s_njobs)/baudrate;
141: hours = minutes/60;
142: printf(", %ld bytes, ", sp->s_bytes);
143: if (minutes > 60){
144: printf("%d hour%s, ",hours,
145: hours > 1 ? "s": "");
146: minutes -= 60 * hours;
147: }
148: printf("%3.1f minutes (@ effective baudrate of %d)",
149: minutes,(int)(baudrate/6));
150: }
151: putchar('\n');
152: if (hflag)
153: continue;
154: /* sort them babies! */
155: sortjob = (struct job **)calloc(sp->s_njobs, sizeof (struct job *));
156: for (i=0, jp=sp->s_jobp; i < sp->s_njobs; i++, jp=jp->j_jobp)
157: sortjob[i] = jp;
158: qsort(sortjob, sp->s_njobs, sizeof (struct job *), jcompare);
159: for (i = 0; i < sp->s_njobs; i++) {
160: jp = sortjob[i];
161: if (lflag) {
162: printf("%s %2d %-*s%7ld%5.1f %-12.12s %c %.*s\n",
163: jp->j_jobno, jp->j_files, Maxulen, jp->j_user, jp->j_bytes, jp->j_bytes/baudrate,
164: ctime(&jp->j_date) + 4, jp->j_flags, sizeof (jp->j_fname), jp->j_fname
165: );
166: } else {
167: printf("%s", jp->j_jobno);
168: putchar((i+1)%10 ? '\t' : '\n');
169: }
170: /* There's no need to keep the force poll if jobs > 1*/
171: if (sp->s_njobs > 1 && strcmp("POLL", jp->j_jobno)==0) {
172: char pbuf[BUFSIZ];
173: sprintf(pbuf,"%s/%c.%s%cPOLL",
174: subdir(Spool, CMDPRE), CMDPRE,
175: sp->s_name, jp->j_grade);
176: (void) unlink(pbuf);
177: }
178: }
179: if (!lflag && (sp->s_njobs%10))
180: putchar('\n');
181: }
182: exit(0);
183: }
184:
185: jcompare(j1, j2)
186: struct job **j1, **j2;
187: {
188: int delta;
189:
190: delta = (*j1)->j_grade - (*j2)->j_grade;
191: if (delta)
192: return delta;
193: return(strcmp((*j1)->j_jobno,(*j2)->j_jobno));
194: }
195:
196: /*
197: * Get all the command file names
198: */
199: gather()
200: {
201: struct direct *d;
202: DIR *df;
203:
204: /*
205: * Find all the spool files in the spooling directory
206: */
207: if ((df = opendir(subdir(Spool, CMDPRE))) == NULL) {
208: fprintf(stderr, "can't examine spooling area\n");
209: exit(1);
210: }
211: for (;;) {
212: if ((d = readdir(df)) == NULL)
213: break;
214: if (d->d_namlen <= 2 || d->d_name[0] != CMDPRE ||
215: d->d_name[1] != '.')
216: continue;
217: if (analjob(d->d_name) < 0) {
218: fprintf(stderr, "out of memory\n");
219: break;
220: }
221: }
222: closedir(df);
223: }
224:
225: /*
226: * analjob does the grunge work of verifying jobs
227: */
228: #include <pwd.h>
229: analjob(filename)
230: char *filename;
231: {
232: struct job *jp;
233: struct sys *sp;
234: char sbuf[MAXNAMLEN+1], str[256], nbuf[256];
235: char *jptr, *wrkvec[20];
236: char grade;
237: FILE *fp, *df;
238: struct stat statb;
239: int files, gotname, i;
240: off_t bytes;
241:
242: strncpy(sbuf, filename, MAXNAMLEN);
243: sbuf[MAXNAMLEN] = '\0';
244: jptr = sbuf + strlen(sbuf) - WSUFSIZE;
245: grade = *jptr;
246: *jptr++ = 0;
247: /*
248: * sbuf+2 now points to sysname name (null terminated)
249: * jptr now points to job number (null terminated)
250: */
251: if (rmjob) {
252: if (strcmp(rmjob, jptr))
253: return(0);
254: } else {
255: if ((sp = getsys(sbuf+2)) == NOSYS)
256: return(0);
257: if (!lflag) {
258: /* SHOULD USE A SMALLER STRUCTURE HERE */
259: jp = (struct job *)malloc(sizeof(struct job));
260: if (jp == (struct job *)0)
261: return(-1);
262: strcpy(jp->j_jobno, jptr);
263: jp->j_jobp = sp->s_jobp;
264: jp->j_grade = grade;
265: sp->s_jobp = jp;
266: sp->s_njobs++;
267: return(1);
268: }
269: }
270: if ((fp = fopen(subfile(filename), "r")) == NULL) {
271: perror(subfile(filename));
272: return(0);
273: }
274: files = 0;
275: bytes = 0;
276: gotname = 0;
277: while (fgets(str, sizeof str, fp)) {
278: if (getargs(str, wrkvec, 20) <= 0)
279: continue;
280: if (rmjob) {
281: int myuid;
282: struct passwd *pw;
283: /*
284: * Make sure person who is removing data files is
285: * the person who created it or root.
286: */
287: myuid = getuid();
288: pw = getpwnam(W_USER);
289: if (myuid && (pw == NULL || myuid != pw->pw_uid)) {
290: fprintf(stderr, "Permission denied.\n");
291: exit(1);
292: }
293: if (W_TYPE[0] == 'S' && !index(W_OPTNS, 'c')) {
294: unlink(subfile(W_DFILE));
295: fprintf(stderr, "Removing data file %s\n", W_DFILE);
296: }
297: continue;
298: }
299: if (user && (W_TYPE[0] == 'X' || !prefix(user, W_USER))) {
300: fclose(fp);
301: return(0);
302: }
303: files++;
304: if (W_TYPE[0] == 'S') {
305: if (strcmp(W_DFILE, "D.0") &&
306: stat(subfile(W_DFILE), &statb) >= 0)
307: bytes += statb.st_size;
308: else if (stat(subfile(W_FILE1), &statb) >= 0)
309: bytes += statb.st_size;
310: }
311: /* amusing heuristic */
312: #define isXfile(s) (s[0]=='D' && s[strlen(s)-WSUFSIZE]=='X')
313: if (gotname == 0 && isXfile(W_FILE1)) {
314: if ((df = fopen(subfile(W_FILE1), "r")) == NULL)
315: continue;
316: while (fgets(nbuf, sizeof nbuf, df)) {
317: nbuf[strlen(nbuf) - 1] = '\0';
318: if (nbuf[0] == 'C' && nbuf[1] == ' ') {
319: strcpy(Filename, nbuf+2);
320: gotname++;
321: } else if (nbuf[0] == 'R' && nbuf[1] == ' ') {
322: register char *p, *q, *r;
323: r = q = p = nbuf+2;
324: do {
325: if (*p == '!' || *p == '@'){
326: r = q;
327: q = p+1;
328: }
329: } while (*p++);
330:
331: strcpy(Username, r);
332: W_USER = Username;
333: }
334: }
335: fclose(df);
336: }
337: }
338: fclose(fp);
339: if (rmjob) {
340: unlink(subfile(filename));
341: fprintf(stderr, "Removing command file %s\n", filename);
342: exit(0);
343: }
344: if (files == 0) {
345: static char *wtype = "X";
346: static char *wfile = "forced poll";
347: if (strcmp("POLL", &filename[strlen(filename)-4])) {
348: fprintf(stderr, "%.14s: empty command file\n", filename);
349: return(0);
350: }
351: W_TYPE = wtype;
352: W_FILE1 = wfile;
353: }
354: jp = (struct job *)malloc(sizeof(struct job));
355: if (jp == (struct job *)0)
356: return(-1);
357: strcpy(jp->j_jobno, jptr);
358: jp->j_files = files;
359: jp->j_bytes = bytes;
360: jp->j_grade = grade;
361: jp->j_flags = W_TYPE[0];
362: strncpy(jp->j_user, W_TYPE[0]=='X' ? "---" : W_USER, 20 );
363: jp->j_user[20] = '\0';
364: i = strlen(jp->j_user);
365: if (i > Maxulen)
366: Maxulen = i;
367: /* SHOULD ADD ALL INFORMATION IN THE WHILE LOOP */
368: if (gotname)
369: strncpy(jp->j_fname, Filename, sizeof jp->j_fname);
370: else
371: strncpy(jp->j_fname, W_FILE1, sizeof jp->j_fname);
372: stat(subfile(filename), &statb);
373: jp->j_date = statb.st_mtime;
374: jp->j_jobp = sp->s_jobp;
375: sp->s_jobp = jp;
376: sp->s_njobs++;
377: sp->s_bytes += jp->j_bytes;
378: return(1);
379: }
380:
381: struct sys *
382: getsys(s)
383: register char *s;
384: {
385: register struct sys *sp;
386:
387: for (sp = syshead; sp; sp = sp->s_sysp)
388: if (strcmp(s, sp->s_name) == 0)
389: return(sp);
390: if (sysname && !prefix(sysname, s))
391: return(NOSYS);
392: sp = (struct sys *)malloc(sizeof(struct sys));
393: if (sp == NOSYS)
394: return(NOSYS);
395: strcpy(sp->s_name, s);
396: sp->s_njobs = 0;
397: sp->s_jobp = (struct job *)0;
398: sp->s_sysp = syshead;
399: sp->s_bytes = 0;
400: syshead = sp;
401: return(sp);
402: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.