![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uustat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104|
Return to uustat.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* uustat.c
2: UUCP status program
3:
4: Copyright (C) 1991, 1992 Ian Lance Taylor
5:
6: This file is part of the Taylor UUCP package.
7:
8: This program is free software; you can redistribute it and/or
9: modify it under the terms of the GNU General Public License as
10: published by the Free Software Foundation; either version 2 of the
11: License, or (at your option) any later version.
12:
13: This program is distributed in the hope that it will be useful, but
14: WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16: General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with this program; if not, write to the Free Software
20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21:
22: The author of the program may be contacted at [email protected] or
23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
24: */
25:
26: #include "uucp.h"
27:
28: #if USE_RCS_ID
29: const char uustat_rcsid[] = "$Id: uustat.c,v 1.1 93/07/30 07:59:49 bin Exp Locker: bin $";
30: #endif
31:
32: #include <ctype.h>
33: #include <errno.h>
34:
35: #if HAVE_TIME_H
36: #include <time.h>
37: #endif
38:
39: #include "getopt.h"
40:
41: #include "uudefs.h"
42: #include "uuconf.h"
43: #include "system.h"
44:
45: /* The uustat program permits various listings and manipulations of
46: files in the spool directory. This implementation supports the
47: following switches:
48:
49: -a list all jobs
50: -Blines number of lines of standard input to mail
51: -ccommand list only executions of specified command
52: -Ccommand list only jobs other than executions of specified command
53: -e list execute jobs rather than command requests
54: -i ask user whether to kill each listed job
55: -Ifile set configuration file name
56: -kjobid kill job with specified ID
57: -K kill each listed job
58: -m report status for all remote machines
59: -M mail uucp about each job killed with -K
60: -N mail requestor about each job killed with -K
61: -ohour report jobs older than specified number of hours
62: -p do "ps -flp" on all processes holding lock files (Unix specific)
63: -q list number of jobs for all systems
64: -Q don't list jobs, just do -K processing
65: -rjobid rejuvenate job with specified ID
66: -ssystem report on all jobs for specified system
67: -Ssystem report on all jobs other than for specified system
68: -uuser report on all jobs for specified user
69: -Uuser report on all jobs other than for specified user
70: -Wcomment comment to include in mail messages
71: -xdebug set debugging level
72: -yhour report jobs younger than specified number of hours */
73:
74: /* The program name. */
75: char abProgram[] = "uustat";
76:
77: /* What to do with a job that matches the selection criteria; these
78: values may be or'red together. */
79: #define JOB_SHOW (01)
80: #define JOB_INQUIRE (02)
81: #define JOB_KILL (04)
82: #define JOB_MAIL (010)
83: #define JOB_NOTIFY (020)
84:
85: /* This structure is used to accumulate all the lines in a single
86: command file, so that they can all be displayed at once and so that
87: executions can be displayed reasonably. */
88:
89: struct scmdlist
90: {
91: struct scmdlist *qnext;
92: struct scmd s;
93: long itime;
94: };
95:
96: /* Local functions. */
97:
98: static void ususage P((void));
99: static boolean fsxqt_file_read P((pointer puuconf, const char *zfile));
100: static void usxqt_file_free P((void));
101: static int isxqt_cmd P((pointer puuconf, int argc, char **argv, pointer pvar,
102: pointer pinfo));
103: static int isxqt_file P((pointer puuconf, int argc, char **argv, pointer pvar,
104: pointer pinfo));
105: static int isxqt_user P((pointer puuconf, int argc, char **argv, pointer pvar,
106: pointer pinfo));
107: static boolean fsworkfiles P((pointer puuconf, int icmd, int csystems,
108: char **pazsystems, boolean fnotsystems,
109: int cusers, char **pazusers,
110: boolean fnotusers, long iold, long iyoung,
111: int ccommands, char **pazcommands,
112: boolean fnotcommands, const char *zcomment,
113: int cstdin));
114: static boolean fsworkfiles_system P((pointer puuconf,int icmd,
115: const struct uuconf_system *qsys,
116: int cusers, char **pazusers,
117: boolean fnotusers, long iold,
118: long iyoung, int ccommands,
119: char **pazcommands,
120: boolean fnotcommands,
121: const char *zcomment, int cstdin));
122: static boolean fsworkfile_show P((pointer puuconf, int icmd,
123: const struct uuconf_system *qsys,
124: const struct scmd *qcmd,
125: long itime, int ccommands,
126: char **pazcommands, boolean fnotcommands,
127: const char *zcomment, int cstdin));
128: static void usworkfile_header P((const struct uuconf_system *qsys,
129: const struct scmd *qcmd,
130: const char *zjobid,
131: long itime, boolean ffirst));
132: static boolean fsexecutions P((pointer puuconf, int icmd, int csystems,
133: char **pazsystems, boolean fnotsystems,
134: int cusers, char **pazusers,
135: boolean fnotusers, long iold, long iyoung,
136: int ccommands, char **pazcommands,
137: boolean fnotcommands, const char *zcomment,
138: int cstdin));
139: static boolean fsnotify P((pointer puuconf, int icmd, const char *zcomment,
140: int cstdin, boolean fkilled, const char *zcmd,
141: struct scmdlist *qcmd, const char *zid,
142: const char *zuser,
143: const struct uuconf_system *qsys,
144: const char *zstdin, pointer pstdinseq,
145: const char *zrequestor));
146: static boolean fsquery P((pointer puuconf));
147: static int csunits_show P((long idiff));
148: static boolean fsmachines P((void));
149:
150: /* Long getopt options. */
151: static const struct option asSlongopts[] = { { NULL, 0, NULL, 0 } };
152:
153: int
154: main (argc, argv)
155: int argc;
156: char **argv;
157: {
158: /* -a: list all jobs. */
159: boolean fall = FALSE;
160: /* -B lines: number of lines of standard input to mail. */
161: int cstdin = 100;
162: /* -c,-C command: list only specified command. */
163: int ccommands = 0;
164: char **pazcommands = NULL;
165: boolean fnotcommands = FALSE;
166: /* -e: list execute jobs. */
167: boolean fexecute = FALSE;
168: /* -k jobid: kill specified job. */
169: int ckills = 0;
170: char **pazkills = NULL;
171: /* -m: report machine status. */
172: boolean fmachine = FALSE;
173: /* -o hour: report jobs older than given number of hours. */
174: int ioldhours = -1;
175: /* -p: report status of jobs holding lock files. */
176: boolean fps = FALSE;
177: /* -q: list number of jobs for each system. */
178: boolean fquery = FALSE;
179: /* -r jobid: rejuvenate specified job. */
180: int crejuvs = 0;
181: char **pazrejuvs = NULL;
182: /* -s,-S system: list all jobs for specified system. */
183: int csystems = 0;
184: char **pazsystems = NULL;
185: boolean fnotsystems = FALSE;
186: /* -u,-U user: list all jobs for specified user. */
187: int cusers = 0;
188: char **pazusers = NULL;
189: boolean fnotusers = FALSE;
190: /* -W comment: comment to include in mail messages. */
191: const char *zcomment = NULL;
192: /* -y hour: report jobs younger than given number of hours. */
193: int iyounghours = -1;
194: /* -I file: set configuration file. */
195: const char *zconfig = NULL;
196: /* -Q, -i, -K, -M, -N: what to do with each job. */
197: int icmd = JOB_SHOW;
198: int ccmds;
199: int iopt;
200: pointer puuconf;
201: int iuuconf;
202: long iold;
203: long iyoung;
204: const char *azoneuser[1];
205: boolean fret;
206:
207: while ((iopt = getopt_long (argc, argv,
208: "aB:c:C:eiI:k:KmMNo:pqQr:s:S:u:U:W:x:y:",
209: asSlongopts, (int *) NULL)) != EOF)
210: {
211: switch (iopt)
212: {
213: case 'a':
214: /* List all jobs. */
215: fall = TRUE;
216: break;
217:
218: case 'B':
219: /* Number of lines of standard input to mail. */
220: cstdin = (int) strtol (optarg, (char **) NULL, 10);
221: break;
222:
223: case 'C':
224: /* List jobs for other than specified command. */
225: fnotcommands = TRUE;
226: /* Fall through. */
227: case 'c':
228: /* List specified command. */
229: ++ccommands;
230: pazcommands = (char **) xrealloc ((pointer) pazcommands,
231: ccommands * sizeof (char *));
232: pazcommands[ccommands - 1] = optarg;
233: break;
234:
235: case 'e':
236: /* List execute jobs. */
237: fexecute = TRUE;
238: break;
239:
240: case 'i':
241: /* Prompt the user whether to kill each job. */
242: icmd |= JOB_INQUIRE;
243: break;
244:
245: case 'I':
246: /* Set configuration file name. */
247: if (fsysdep_other_config (optarg))
248: zconfig = optarg;
249: break;
250:
251: case 'k':
252: /* Kill specified job. */
253: ++ckills;
254: pazkills = (char **) xrealloc ((pointer) pazkills,
255: ckills * sizeof (char *));
256: pazkills[ckills - 1] = optarg;
257: break;
258:
259: case 'K':
260: /* Kill each listed job. */
261: icmd |= JOB_KILL;
262: break;
263:
264: case 'm':
265: /* Report machine status. */
266: fmachine = TRUE;
267: break;
268:
269: case 'M':
270: /* Mail to uucp action taken on each job. */
271: icmd |= JOB_MAIL;
272: break;
273:
274: case 'N':
275: /* Mail to requestor action taken on each job. */
276: icmd |= JOB_NOTIFY;
277: break;
278:
279: case 'o':
280: /* Report old jobs. */
281: ioldhours = (int) strtol (optarg, (char **) NULL, 10);
282: break;
283:
284: case 'p':
285: /* Get status of processes holding locks. */
286: fps = TRUE;
287: break;
288:
289: case 'q':
290: /* List number of jobs for each system. */
291: fquery = TRUE;
292: break;
293:
294: case 'Q':
295: /* Don't list jobs, just do -K processing. */
296: icmd &=~ JOB_SHOW;
297: break;
298:
299: case 'r':
300: /* Rejuvenate specified job. */
301: ++crejuvs;
302: pazrejuvs = (char **) xrealloc ((pointer) pazrejuvs,
303: crejuvs * sizeof (char *));
304: pazrejuvs[crejuvs - 1] = optarg;
305: break;
306:
307: case 'S':
308: /* List jobs for other than specified system. */
309: fnotsystems = TRUE;
310: /* Fall through. */
311: case 's':
312: /* List jobs for specified system. */
313: ++csystems;
314: pazsystems = (char **) xrealloc ((pointer) pazsystems,
315: csystems * sizeof (char *));
316: pazsystems[csystems - 1] = optarg;
317: break;
318:
319: case 'U':
320: /* List jobs for other than specified user. */
321: fnotusers = TRUE;
322: /* Fall through. */
323: case 'u':
324: /* List jobs for specified user. */
325: ++cusers;
326: pazusers = (char **) xrealloc ((pointer) pazusers,
327: cusers * sizeof (char *));
328: pazusers[cusers - 1] = optarg;
329: break;
330:
331: case 'W':
332: /* Comment to include in mail messages. */
333: zcomment = optarg;
334: break;
335:
336: case 'x':
337: #if DEBUG > 1
338: /* Set debugging level. */
339: iDebug |= idebug_parse (optarg);
340: #endif
341: break;
342:
343: case 'y':
344: /* List jobs younger than given number of hours. */
345: iyounghours = (int) strtol (optarg, (char **) NULL, 10);
346: break;
347:
348: case 0:
349: /* Long option found and flag set. */
350: break;
351:
352: default:
353: ususage ();
354: break;
355: }
356: }
357:
358: if (optind != argc)
359: ususage ();
360:
361: /* To avoid confusion, most options are only permitted by
362: themselves. This restriction might be removed later, but it is
363: imposed by most implementations. We do permit any combination of
364: -c, -s, -u, -o and -y, and any combination of -k and -r. */
365: ccmds = 0;
366: if (fall)
367: ++ccmds;
368: if (ckills > 0 || crejuvs > 0)
369: ++ccmds;
370: if (fmachine)
371: ++ccmds;
372: if (fps)
373: ++ccmds;
374: if (fquery)
375: ++ccmds;
376: if (fexecute || csystems > 0 || cusers > 0 || ioldhours != -1
377: || iyounghours != -1 || ccommands > 0)
378: ++ccmds;
379:
380: if (ccmds > 1)
381: {
382: ulog (LOG_ERROR, "Too many options");
383: ususage ();
384: }
385:
386: iuuconf = uuconf_init (&puuconf, (const char *) NULL, zconfig);
387: if (iuuconf != UUCONF_SUCCESS)
388: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
389:
390: #if DEBUG > 1
391: {
392: const char *zdebug;
393:
394: iuuconf = uuconf_debuglevel (puuconf, &zdebug);
395: if (iuuconf != UUCONF_SUCCESS)
396: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
397: if (zdebug != NULL)
398: iDebug |= idebug_parse (zdebug);
399: }
400: #endif
401:
402: usysdep_initialize (puuconf, INIT_SUID);
403:
404: /* If no commands were specified, we list all commands for the given
405: user. */
406: if (ccmds == 0)
407: {
408: cusers = 1;
409: azoneuser[0] = zsysdep_login_name ();
410: pazusers = (char **) azoneuser;
411: }
412:
413: /* Canonicalize the system names. */
414: if (csystems > 0)
415: {
416: int i;
417:
418: for (i = 0; i < csystems; i++)
419: {
420: struct uuconf_system ssys;
421:
422: iuuconf = uuconf_system_info (puuconf, pazsystems[i], &ssys);
423: if (iuuconf != UUCONF_SUCCESS)
424: {
425: if (iuuconf == UUCONF_NOT_FOUND)
426: ulog (LOG_FATAL, "%s: System not found", pazsystems[i]);
427: else
428: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
429: }
430: if (strcmp (pazsystems[i], ssys.uuconf_zname) != 0)
431: pazsystems[i] = zbufcpy (ssys.uuconf_zname);
432: (void) uuconf_system_free (puuconf, &ssys);
433: }
434: }
435:
436: if (ioldhours == -1)
437: iold = (long) -1;
438: else
439: {
440: iold = (ixsysdep_time ((long *) NULL)
441: - (long) ioldhours * (long) 60 * (long) 60);
442: if (iold < 0L)
443: iold = 0L;
444: }
445: if (iyounghours == -1)
446: iyoung = (long) -1;
447: else
448: {
449: iyoung = (ixsysdep_time ((long *) NULL)
450: - (long) iyounghours * (long) 60 * (long) 60);
451: if (iyoung < 0L)
452: iyoung = 0L;
453: }
454:
455: if (! fexecute
456: && (fall
457: || csystems > 0
458: || cusers > 0
459: || ioldhours != -1
460: || iyounghours != -1
461: || ccommands > 0))
462: fret = fsworkfiles (puuconf, icmd, csystems, pazsystems, fnotsystems,
463: cusers, pazusers, fnotusers, iold, iyoung,
464: ccommands, pazcommands, fnotcommands, zcomment,
465: cstdin);
466: else if (fexecute)
467: fret = fsexecutions (puuconf, icmd, csystems, pazsystems, fnotsystems,
468: cusers, pazusers, fnotusers, iold, iyoung,
469: ccommands, pazcommands, fnotcommands, zcomment,
470: cstdin);
471: else if (icmd != JOB_SHOW)
472: {
473: ulog (LOG_ERROR,
474: "-i, -K, -M, -N, -Q not supported with -k, -m, -p, -q, -r");
475: ususage ();
476: fret = FALSE;
477: }
478: else if (fquery)
479: fret = fsquery (puuconf);
480: else if (fmachine)
481: fret = fsmachines ();
482: else if (ckills > 0 || crejuvs > 0)
483: {
484: int i;
485:
486: fret = TRUE;
487: for (i = 0; i < ckills; i++)
488: if (! fsysdep_kill_job (puuconf, pazkills[i]))
489: fret = FALSE;
490:
491: for (i = 0; i < crejuvs; i++)
492: if (! fsysdep_rejuvenate_job (puuconf, pazrejuvs[i]))
493: fret = FALSE;
494: }
495: else if (fps)
496: fret = fsysdep_lock_status ();
497: else
498: {
499: #if DEBUG > 0
500: ulog (LOG_FATAL, "Can't happen");
501: #endif
502: fret = FALSE;
503: }
504:
505: ulog_close ();
506:
507: usysdep_exit (fret);
508:
509: /* Avoid errors about not returning a value. */
510: return 0;
511: }
512:
513: /* Print a usage message and die. */
514:
515: static void
516: ususage ()
517: {
518: fprintf (stderr,
519: "Taylor UUCP version %s, copyright (C) 1991, 1992 Ian Lance Taylor\n",
520: VERSION);
521: fprintf (stderr,
522: "Usage: uustat [options]\n");
523: fprintf (stderr,
524: " -a: list all UUCP jobs\n");
525: fprintf (stderr,
526: " -B num: number of lines to return in -M or -N mail message\n");
527: fprintf (stderr,
528: " -c command: list requests for named command\n");
529: fprintf (stderr,
530: " -C command: list requests for other than named command\n");
531: fprintf (stderr,
532: " -e: list queued executions rather than job requests\n");
533: fprintf (stderr,
534: " -i: prompt for whether to kill each listed job\n");
535: fprintf (stderr,
536: " -k job: kill specified UUCP job\n");
537: fprintf (stderr,
538: " -K: kill each listed job\n");
539: fprintf (stderr,
540: " -m: report status for all remote machines\n");
541: fprintf (stderr,
542: " -M: mail report on each listed job to UUCP administrator\n");
543: fprintf (stderr,
544: " -N: mail report on each listed job to requestor\n");
545: fprintf (stderr,
546: " -o hours: list all jobs older than given number of hours\n");
547: fprintf (stderr,
548: " -p: show status of all processes holding UUCP locks\n");
549: fprintf (stderr,
550: " -q: list number of jobs for each system\n");
551: fprintf (stderr,
552: " -Q: don't list jobs, just take actions (-i, -K, -M, -N)\n");
553: fprintf (stderr,
554: " -r job: rejuvenate specified UUCP job\n");
555: fprintf (stderr,
556: " -s system: list all jobs for specified system\n");
557: fprintf (stderr,
558: " -S system: list all jobs for other than specified system\n");
559: fprintf (stderr,
560: " -u user: list all jobs for specified user\n");
561: fprintf (stderr,
562: " -U user: list all jobs for other than specified user\n");
563: fprintf (stderr,
564: " -W comment: comment to include in mail messages\n");
565: fprintf (stderr,
566: " -y hours: list all jobs younger than given number of hours\n");
567: fprintf (stderr,
568: " -x debug: Set debugging level (0 for none, 9 is max)\n");
569: #if HAVE_TAYLOR_CONFIG
570: fprintf (stderr,
571: " -I file: Set configuration file to use\n");
572: #endif /* HAVE_TAYLOR_CONFIG */
573: exit (EXIT_FAILURE);
574: }
575:
576: /* We need to be able to read information from an execution file. */
577:
578: /* The user name extracted from an execution file. */
579: static char *zSxqt_user;
580:
581: /* The system name from an execution file. */
582: static char *zSxqt_system;
583:
584: /* Address of requesting user (who to send mail to). */
585: static const char *zSxqt_requestor;
586:
587: /* The command (no arguments) from an execution file. */
588: static char *zSxqt_prog;
589:
590: /* The full command line from an execution file. */
591: static char *zSxqt_cmd;
592:
593: /* Number of files associated with an execution file. */
594: static int cSxqt_files;
595:
596: /* Names of files associated with execution file. */
597: static char **pazSxqt_files;
598:
599: /* Standard input file name. */
600: static const char *zSxqt_stdin;
601:
602: /* A command table used to dispatch an execution file. */
603: static const struct uuconf_cmdtab asSxqt_cmds[] =
604: {
605: { "C", UUCONF_CMDTABTYPE_FN | 0, NULL, isxqt_cmd },
606: { "I", UUCONF_CMDTABTYPE_STRING, (pointer) &zSxqt_stdin, NULL },
607: { "F", UUCONF_CMDTABTYPE_FN | 0, NULL, isxqt_file },
608: { "R", UUCONF_CMDTABTYPE_STRING, (pointer) &zSxqt_requestor, NULL },
609: { "U", UUCONF_CMDTABTYPE_FN | 3, NULL, isxqt_user },
610: { NULL, 0, NULL, NULL }
611: };
612:
613: /* Read an execution file, setting the above variables. */
614:
615: static boolean
616: fsxqt_file_read (puuconf, zfile)
617: pointer puuconf;
618: const char *zfile;
619: {
620: FILE *e;
621: int iuuconf;
622: boolean fret;
623:
624: e = fopen (zfile, "r");
625: if (e == NULL)
626: {
627: ulog (LOG_ERROR, "fopen (%s): %s", zfile, strerror (errno));
628: return FALSE;
629: }
630:
631: zSxqt_user = NULL;
632: zSxqt_system = NULL;
633: zSxqt_stdin = NULL;
634: zSxqt_requestor = NULL;
635: zSxqt_prog = NULL;
636: zSxqt_cmd = NULL;
637: cSxqt_files = 0;
638: pazSxqt_files = NULL;
639:
640: iuuconf = uuconf_cmd_file (puuconf, e, asSxqt_cmds, (pointer) NULL,
641: (uuconf_cmdtabfn) NULL,
642: UUCONF_CMDTABFLAG_CASE, (pointer) NULL);
643: (void) fclose (e);
644: if (iuuconf == UUCONF_SUCCESS)
645: fret = TRUE;
646: else
647: {
648: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
649: fret = FALSE;
650: }
651:
652: if (zSxqt_user == NULL)
653: zSxqt_user = zbufcpy ("*unknown*");
654: if (zSxqt_system == NULL)
655: zSxqt_system = zbufcpy ("*unknown*");
656: if (zSxqt_prog == NULL)
657: {
658: zSxqt_prog = zbufcpy ("*none*");
659: zSxqt_cmd = zbufcpy ("*none*");
660: }
661:
662: return fret;
663: }
664:
665: /* Free up the information read from an execution file. */
666:
667: static void
668: usxqt_file_free ()
669: {
670: int i;
671:
672: ubuffree (zSxqt_user);
673: zSxqt_user = NULL;
674: ubuffree (zSxqt_system);
675: zSxqt_system = NULL;
676: ubuffree (zSxqt_prog);
677: zSxqt_prog = NULL;
678: ubuffree (zSxqt_cmd);
679: zSxqt_cmd = NULL;
680: for (i = 0; i < cSxqt_files; i++)
681: ubuffree (pazSxqt_files[i]);
682: cSxqt_files = 0;
683: xfree ((pointer) pazSxqt_files);
684: pazSxqt_files = NULL;
685: zSxqt_stdin = NULL;
686: zSxqt_requestor = NULL;
687: }
688:
689: /* Get the command from an execution file. */
690:
691: /*ARGSUSED*/
692: static int
693: isxqt_cmd (puuconf, argc, argv, pvar, pinfo)
694: pointer puuconf;
695: int argc;
696: char **argv;
697: pointer pvar;
698: pointer pinfo;
699: {
700: size_t clen;
701: int i;
702:
703: if (argc <= 1)
704: return UUCONF_CMDTABRET_CONTINUE;
705:
706: zSxqt_prog = zbufcpy (argv[1]);
707:
708: clen = 0;
709: for (i = 1; i < argc; i++)
710: clen += strlen (argv[i]) + 1;
711:
712: zSxqt_cmd = zbufalc (clen);
713: zSxqt_cmd[0] = '\0';
714: for (i = 1; i < argc - 1; i++)
715: {
716: strcat (zSxqt_cmd, argv[i]);
717: strcat (zSxqt_cmd, " ");
718: }
719: strcat (zSxqt_cmd, argv[i]);
720:
721: return UUCONF_CMDTABRET_CONTINUE;
722: }
723:
724: /* Get the associated files from an execution file. */
725:
726: /*ARGSUSED*/
727: static int
728: isxqt_file (puuconf, argc, argv, pvar, pinfo)
729: pointer puuconf;
730: int argc;
731: char **argv;
732: pointer pvar;
733: pointer pinfo;
734: {
735: if (argc != 2 && argc != 3)
736: return UUCONF_CMDTABRET_CONTINUE;
737:
738: /* If this file is not in the spool directory, just ignore it. */
739: if (! fspool_file (argv[1]))
740: return UUCONF_CMDTABRET_CONTINUE;
741:
742: ++cSxqt_files;
743: pazSxqt_files = (char **) xrealloc ((pointer) pazSxqt_files,
744: cSxqt_files * sizeof (char *));
745:
746: pazSxqt_files[cSxqt_files - 1] = zbufcpy (argv[1]);
747:
748: return UUCONF_CMDTABRET_CONTINUE;
749: }
750:
751: /* Get the requesting user and system from an execution file. */
752:
753: /*ARGSUSED*/
754: static int
755: isxqt_user (puuconf, argc, argv, pvar, pinfo)
756: pointer puuconf;
757: int argc;
758: char **argv;
759: pointer pvar;
760: pointer pinfo;
761: {
762: zSxqt_user = zbufcpy (argv[1]);
763: zSxqt_system = zbufcpy (argv[2]);
764: return UUCONF_CMDTABRET_CONTINUE;
765: }
766:
767: /* Handle various possible requests to look at work files. */
768:
769: static boolean
770: fsworkfiles (puuconf, icmd, csystems, pazsystems, fnotsystems, cusers,
771: pazusers, fnotusers, iold, iyoung, ccommands, pazcommands,
772: fnotcommands, zcomment, cstdin)
773: pointer puuconf;
774: int icmd;
775: int csystems;
776: char **pazsystems;
777: boolean fnotsystems;
778: int cusers;
779: char **pazusers;
780: boolean fnotusers;
781: long iold;
782: long iyoung;
783: int ccommands;
784: char **pazcommands;
785: boolean fnotcommands;
786: const char *zcomment;
787: int cstdin;
788: {
789: boolean fret;
790: int i;
791: int iuuconf;
792: struct uuconf_system ssys;
793:
794: fret = TRUE;
795:
796: if (csystems > 0 && ! fnotsystems)
797: {
798: for (i = 0; i < csystems; i++)
799: {
800: iuuconf = uuconf_system_info (puuconf, pazsystems[i], &ssys);
801: if (iuuconf != UUCONF_SUCCESS)
802: {
803: if (iuuconf == UUCONF_NOT_FOUND)
804: ulog (LOG_ERROR, "%s: System not found", pazsystems[i]);
805: else
806: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
807: fret = FALSE;
808: continue;
809: }
810:
811: if (! fsworkfiles_system (puuconf, icmd, &ssys, cusers, pazusers,
812: fnotusers, iold, iyoung, ccommands,
813: pazcommands, fnotcommands, zcomment,
814: cstdin))
815: fret = FALSE;
816:
817: (void) uuconf_system_free (puuconf, &ssys);
818: }
819: }
820: else
821: {
822: char **pznames, **pz;
823:
824: iuuconf = uuconf_system_names (puuconf, &pznames, 0);
825: if (iuuconf != UUCONF_SUCCESS)
826: {
827: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
828: return FALSE;
829: }
830:
831: for (pz = pznames; *pz != NULL; pz++)
832: {
833: if (csystems > 0)
834: {
835: for (i = 0; i < csystems; i++)
836: if (strcmp (*pz, pazsystems[i]) == 0)
837: break;
838: if (i < csystems)
839: continue;
840: }
841:
842: iuuconf = uuconf_system_info (puuconf, *pz, &ssys);
843: if (iuuconf != UUCONF_SUCCESS)
844: {
845: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
846: fret = FALSE;
847: continue;
848: }
849:
850: if (! fsworkfiles_system (puuconf, icmd, &ssys, cusers, pazusers,
851: fnotusers, iold, iyoung, ccommands,
852: pazcommands, fnotcommands, zcomment,
853: cstdin))
854: fret = FALSE;
855:
856: (void) uuconf_system_free (puuconf, &ssys);
857: xfree ((pointer) *pz);
858: }
859: xfree ((pointer) pznames);
860: }
861:
862: return fret;
863: }
864:
865: /* Look at the work files for a particular system. */
866:
867: static boolean
868: fsworkfiles_system (puuconf, icmd, qsys, cusers, pazusers, fnotusers, iold,
869: iyoung, ccommands, pazcommands, fnotcommands, zcomment,
870: cstdin)
871: pointer puuconf;
872: int icmd;
873: const struct uuconf_system *qsys;
874: int cusers;
875: char **pazusers;
876: boolean fnotusers;
877: long iold;
878: long iyoung;
879: int ccommands;
880: char **pazcommands;
881: boolean fnotcommands;
882: const char *zcomment;
883: int cstdin;
884: {
885: boolean fret;
886:
887: if (! fsysdep_get_work_init (qsys, UUCONF_GRADE_LOW))
888: return FALSE;
889:
890: while (TRUE)
891: {
892: struct scmd s;
893: long itime;
894:
895: if (! fsysdep_get_work (qsys, UUCONF_GRADE_LOW, &s))
896: {
897: usysdep_get_work_free (qsys);
898: return FALSE;
899: }
900: if (s.bcmd == 'H')
901: break;
902:
903: if (cusers > 0)
904: {
905: boolean fmatch;
906: int i;
907:
908: fmatch = fnotusers;
909: for (i = 0; i < cusers; i++)
910: {
911: if (s.zuser != NULL
912: && strcmp (pazusers[i], s.zuser) == 0)
913: {
914: fmatch = ! fmatch;
915: break;
916: }
917: }
918: if (! fmatch)
919: continue;
920: }
921:
922: itime = ixsysdep_work_time (qsys, s.pseq);
923:
924: if (iold != (long) -1 && itime > iold)
925: continue;
926:
927: if (iyoung != (long) -1 && itime < iyoung)
928: continue;
929:
930: if (! fsworkfile_show (puuconf, icmd, qsys, &s, itime, ccommands,
931: pazcommands, fnotcommands, zcomment, cstdin))
932: {
933: usysdep_get_work_free (qsys);
934: return FALSE;
935: }
936: }
937:
938: fret = fsworkfile_show (puuconf, icmd, qsys, (const struct scmd *) NULL,
939: 0L, ccommands, pazcommands, fnotcommands, zcomment,
940: cstdin);
941:
942: usysdep_get_work_free (qsys);
943:
944: return fret;
945: }
946:
947: /* Show a single workfile. This is actually called once for each line
948: in the workfile, so we accumulate the lines and show them all at
949: once. This lets us show an execution in a useful fashion. */
950:
951: static boolean
952: fsworkfile_show (puuconf, icmd, qsys, qcmd, itime, ccommands, pazcommands,
953: fnotcommands, zcomment, cstdin)
954: pointer puuconf;
955: int icmd;
956: const struct uuconf_system *qsys;
957: const struct scmd *qcmd;
958: long itime;
959: int ccommands;
960: char **pazcommands;
961: boolean fnotcommands;
962: const char *zcomment;
963: int cstdin;
964: {
965: static struct scmdlist *qlist;
966: static char *zlistid;
967: char *zid;
968:
969: if (qcmd == NULL)
970: zid = NULL;
971: else
972: {
973: zid = zsysdep_jobid (qsys, qcmd->pseq);
974: if (zid == NULL)
975: return FALSE;
976: }
977:
978: /* If this is the same jobid as the list, put it on the end. */
979:
980: if (qcmd != NULL
981: && qlist != NULL
982: && strcmp (zlistid, zid) == 0)
983: {
984: struct scmdlist *qnew, **pq;
985:
986: ubuffree (zid);
987: qnew = (struct scmdlist *) xmalloc (sizeof (struct scmdlist));
988: qnew->qnext = NULL;
989: qnew->s = *qcmd;
990: qnew->itime = itime;
991: for (pq = &qlist; *pq != NULL; pq = &(*pq)->qnext)
992: ;
993: *pq = qnew;
994: return TRUE;
995: }
996:
997: /* Here we have found a different job ID, so we print the scmd
998: structures that we have accumulated. We look for the special
999: case of an execution (an E command, or one of the destination
1000: files begins with X.). We could be more clever about other
1001: situations as well. */
1002: if (qlist != NULL)
1003: {
1004: boolean fmatch;
1005: const char *zprog, *zcmd, *zrequestor, *zstdin;
1006: char *zfree;
1007: struct scmdlist *qxqt;
1008: struct scmdlist *qfree;
1009:
1010: fmatch = FALSE;
1011: zprog = zcmd = zrequestor = zstdin = NULL;
1012: zfree = NULL;
1013:
1014: for (qxqt = qlist; qxqt != NULL; qxqt = qxqt->qnext)
1015: if (qxqt->s.bcmd == 'E'
1016: || (qxqt->s.bcmd == 'S'
1017: && qxqt->s.zto[0] == 'X'
1018: && qxqt->s.zto[1] == '.'
1019: && fspool_file (qxqt->s.zfrom)))
1020: break;
1021:
1022: if (qxqt == NULL)
1023: {
1024: if (ccommands == 0
1025: || (fnotcommands
1026: && strcmp (pazcommands[0], "ALL") == 0))
1027: {
1028: /* Show all the lines in a regular work file. */
1029: fmatch = TRUE;
1030:
1031: if ((icmd & JOB_SHOW) != 0)
1032: {
1033: struct scmdlist *qshow;
1034:
1035: for (qshow = qlist; qshow != NULL; qshow = qshow->qnext)
1036: {
1037: char *zfile;
1038: long cbytes;
1039:
1040: usworkfile_header (qsys, &qshow->s, zlistid,
1041: qshow->itime, qshow == qlist);
1042:
1043: switch (qshow->s.bcmd)
1044: {
1045: case 'S':
1046: if (strchr (qshow->s.zoptions, 'C') != NULL
1047: || fspool_file (qshow->s.zfrom))
1048: zfile = zsysdep_spool_file_name (qsys,
1049: qshow->s.ztemp,
1050: qshow->s.pseq);
1051: else
1052: zfile = zbufcpy (qshow->s.zfrom);
1053: if (zfile == NULL)
1054: cbytes = 0;
1055: else
1056: {
1057: cbytes = csysdep_size (zfile);
1058: if (cbytes < 0)
1059: cbytes = 0;
1060: }
1061: printf ("Sending %s (%ld bytes) to %s",
1062: qshow->s.zfrom, cbytes, qshow->s.zto);
1063: ubuffree (zfile);
1064: break;
1065: case 'R':
1066: printf ("Requesting %s to %s", qshow->s.zfrom,
1067: qshow->s.zto);
1068: break;
1069: case 'X':
1070: printf ("Requesting %s to %s", qshow->s.zfrom,
1071: qshow->s.zto);
1072: break;
1073: case 'P':
1074: printf ("(poll file)");
1075: break;
1076: #if DEBUG > 0
1077: default:
1078: printf ("Bad line %d", qshow->s.bcmd);
1079: break;
1080: #endif
1081: }
1082:
1083: printf ("\n");
1084: }
1085: }
1086: }
1087: }
1088: else
1089: {
1090: long csize;
1091: struct scmdlist *qsize;
1092:
1093: /* Show the command for an execution file. */
1094: if (qxqt->s.bcmd == 'E')
1095: {
1096: zfree = zbufcpy (qxqt->s.zcmd);
1097: zfree[strcspn (zfree, " \t")] = '\0';
1098: zprog = zfree;
1099: zcmd = qxqt->s.zcmd;
1100: if (strchr (qxqt->s.zoptions, 'R') != NULL)
1101: zrequestor = qxqt->s.znotify;
1102: }
1103: else
1104: {
1105: char *zxqt;
1106:
1107: zxqt = zsysdep_spool_file_name (qsys, qxqt->s.zfrom,
1108: qxqt->s.pseq);
1109: if (zxqt == NULL)
1110: return FALSE;
1111:
1112: if (! fsxqt_file_read (puuconf, zxqt))
1113: {
1114: ubuffree (zxqt);
1115: return FALSE;
1116: }
1117:
1118: ubuffree (zxqt);
1119:
1120: zprog = zSxqt_prog;
1121: zcmd = zSxqt_cmd;
1122: zrequestor = zSxqt_requestor;
1123: }
1124:
1125: csize = 0L;
1126: for (qsize = qlist; qsize != NULL; qsize = qsize->qnext)
1127: {
1128: if (qsize->s.bcmd == 'S' || qsize->s.bcmd == 'E')
1129: {
1130: char *zfile;
1131:
1132: if (strchr (qsize->s.zoptions, 'C') != NULL
1133: || fspool_file (qsize->s.zfrom))
1134: zfile = zsysdep_spool_file_name (qsys, qsize->s.ztemp,
1135: qsize->s.pseq);
1136: else
1137: zfile = zbufcpy (qsize->s.zfrom);
1138: if (zfile != NULL)
1139: {
1140: long cbytes;
1141:
1142: cbytes = csysdep_size (zfile);
1143: if (cbytes > 0)
1144: csize += cbytes;
1145: ubuffree (zfile);
1146: }
1147: }
1148: }
1149:
1150: if (ccommands == 0)
1151: fmatch = TRUE;
1152: else
1153: {
1154: int i;
1155:
1156: fmatch = fnotcommands;
1157: for (i = 0; i < ccommands; i++)
1158: {
1159: if (strcmp (pazcommands[i], "ALL") == 0
1160: || strcmp (pazcommands[i], zprog) == 0)
1161: {
1162: fmatch = ! fmatch;
1163: break;
1164: }
1165: }
1166: }
1167:
1168: /* To get the name of the standard input file on this system
1169: we have to look through the list of file transfers to
1170: find the right one on the remote system. */
1171: if (fmatch)
1172: {
1173: struct scmdlist *qstdin;
1174:
1175: if (qxqt->s.bcmd == 'E')
1176: qstdin = qxqt;
1177: else if (zSxqt_stdin != NULL)
1178: {
1179: for (qstdin = qlist;
1180: qstdin != NULL;
1181: qstdin = qstdin->qnext)
1182: if (qstdin->s.bcmd == 'S'
1183: && strcmp (qstdin->s.zto, zSxqt_stdin) == 0)
1184: break;
1185: }
1186: else
1187: qstdin = NULL;
1188:
1189: if (qstdin != NULL)
1190: {
1191: if (strchr (qstdin->s.zoptions, 'C') != NULL
1192: || fspool_file (qstdin->s.zfrom))
1193: zstdin = qstdin->s.ztemp;
1194: else
1195: zstdin = qstdin->s.zfrom;
1196: }
1197: }
1198:
1199: if (fmatch && (icmd & JOB_SHOW) != 0)
1200: {
1201: usworkfile_header (qsys, &qxqt->s, zlistid, qxqt->itime,
1202: TRUE);
1203: printf ("Executing %s (sending %ld bytes)\n", zcmd, csize);
1204: }
1205: }
1206:
1207: if (fmatch)
1208: {
1209: boolean fkill;
1210:
1211: fkill = FALSE;
1212: if ((icmd & JOB_INQUIRE) != 0)
1213: {
1214: int b;
1215:
1216: /* Ask stdin whether this job should be killed. */
1217: fprintf (stderr, "%s: Kill %s? ", abProgram, zlistid);
1218: (void) fflush (stderr);
1219: b = getchar ();
1220: fkill = b == 'y' || b == 'Y';
1221: while (b != EOF && b != '\n')
1222: b = getchar ();
1223: }
1224: else if ((icmd & JOB_KILL) != 0)
1225: fkill = TRUE;
1226:
1227: if (fkill
1228: && (qlist->s.zuser == NULL
1229: || strcmp (zsysdep_login_name (), qlist->s.zuser) != 0)
1230: && ! fsysdep_privileged ())
1231: ulog (LOG_ERROR, "%s: Not submitted by you", zlistid);
1232: else
1233: {
1234: if ((icmd & (JOB_MAIL | JOB_NOTIFY)) != 0)
1235: {
1236: if (! fsnotify (puuconf, icmd, zcomment, cstdin, fkill,
1237: zcmd, qlist, zlistid, qlist->s.zuser,
1238: qsys, zstdin, qlist->s.pseq, zrequestor))
1239: return FALSE;
1240: }
1241:
1242: if (fkill)
1243: {
1244: if (! fsysdep_kill_job (puuconf, zlistid))
1245: return FALSE;
1246: }
1247: }
1248: }
1249:
1250: if (qxqt != NULL)
1251: {
1252: if (qxqt->s.bcmd == 'E')
1253: ubuffree (zfree);
1254: else
1255: usxqt_file_free ();
1256: }
1257:
1258: /* Free up the list of entries. */
1259: qfree = qlist;
1260: while (qfree != NULL)
1261: {
1262: struct scmdlist *qnext;
1263:
1264: qnext = qfree->qnext;
1265: xfree ((pointer) qfree);
1266: qfree = qnext;
1267: }
1268:
1269: ubuffree (zlistid);
1270:
1271: qlist = NULL;
1272: zlistid = NULL;
1273: }
1274:
1275: /* Start a new list with the entry we just got. */
1276: if (qcmd != NULL)
1277: {
1278: qlist = (struct scmdlist *) xmalloc (sizeof (struct scmdlist));
1279: qlist->qnext = NULL;
1280: qlist->s = *qcmd;
1281: qlist->itime = itime;
1282: zlistid = zid;
1283: }
1284:
1285: return TRUE;
1286: }
1287:
1288: /* Show the header of the line describing a workfile. */
1289:
1290: static void
1291: usworkfile_header (qsys, qcmd, zjobid, itime, ffirst)
1292: const struct uuconf_system *qsys;
1293: const struct scmd *qcmd;
1294: const char *zjobid;
1295: long itime;
1296: boolean ffirst;
1297: {
1298: const char *zshowid;
1299: struct tm stime;
1300:
1301: if (ffirst)
1302: zshowid = zjobid;
1303: else
1304: zshowid = "-";
1305:
1306: printf ("%s %s %s ", zshowid, qsys->uuconf_zname,
1307: qcmd->zuser != NULL ? qcmd->zuser : OWNER);
1308:
1309: usysdep_localtime (itime, &stime);
1310: printf ("%02d-%02d %02d:%02d ",
1311: stime.tm_mon + 1, stime.tm_mday, stime.tm_hour, stime.tm_min);
1312: }
1313:
1314: /* List queued executions that have not been processed by uuxqt for
1315: one reason or another. */
1316:
1317: static boolean
1318: fsexecutions (puuconf, icmd, csystems, pazsystems, fnotsystems, cusers,
1319: pazusers, fnotusers, iold, iyoung, ccommands, pazcommands,
1320: fnotcommands, zcomment, cstdin)
1321: pointer puuconf;
1322: int icmd;
1323: int csystems;
1324: char **pazsystems;
1325: boolean fnotsystems;
1326: int cusers;
1327: char **pazusers;
1328: boolean fnotusers;
1329: long iold;
1330: long iyoung;
1331: int ccommands;
1332: char **pazcommands;
1333: boolean fnotcommands;
1334: const char *zcomment;
1335: int cstdin;
1336: {
1337: const char *zlocalname;
1338: int iuuconf;
1339: char *zfile;
1340: char *zsystem;
1341: boolean ferr;
1342:
1343: iuuconf = uuconf_localname (puuconf, &zlocalname);
1344: if (iuuconf == UUCONF_NOT_FOUND)
1345: {
1346: zlocalname = zsysdep_localname ();
1347: if (zlocalname == NULL)
1348: return FALSE;
1349: }
1350: else if (iuuconf != UUCONF_SUCCESS)
1351: {
1352: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1353: return FALSE;
1354: }
1355:
1356: if (! fsysdep_get_xqt_init ())
1357: return FALSE;
1358:
1359: while ((zfile = zsysdep_get_xqt (&zsystem, &ferr)) != NULL)
1360: {
1361: boolean fmatch;
1362: int i;
1363: long itime;
1364:
1365: if (csystems > 0)
1366: {
1367: fmatch = fnotsystems;
1368: for (i = 0; i < csystems; i++)
1369: {
1370: if (strcmp (pazsystems[i], zsystem) == 0)
1371: {
1372: fmatch = ! fmatch;
1373: break;
1374: }
1375: }
1376: if (! fmatch)
1377: {
1378: ubuffree (zfile);
1379: ubuffree (zsystem);
1380: continue;
1381: }
1382: }
1383:
1384: itime = ixsysdep_file_time (zfile);
1385:
1386: if ((iold != (long) -1 && itime > iold)
1387: || (iyoung != (long) -1 && itime < iyoung))
1388: {
1389: ubuffree (zfile);
1390: ubuffree (zsystem);
1391: continue;
1392: }
1393:
1394: /* We need to read the execution file before we can check the
1395: user name. */
1396: if (! fsxqt_file_read (puuconf, zfile))
1397: {
1398: ubuffree (zfile);
1399: ubuffree (zsystem);
1400: continue;
1401: }
1402:
1403: if (cusers == 0)
1404: fmatch = TRUE;
1405: else
1406: {
1407: fmatch = fnotusers;
1408: for (i = 0; i < cusers; i++)
1409: {
1410: if (strcmp (zSxqt_user, pazusers[i]) == 0
1411: || (zSxqt_requestor != NULL
1412: && strcmp (zSxqt_requestor, pazusers[i]) == 0))
1413: {
1414: fmatch = ! fmatch;
1415: break;
1416: }
1417: }
1418: }
1419:
1420: if (fmatch && ccommands > 0)
1421: {
1422: fmatch = fnotcommands;
1423: for (i = 0; i < ccommands; i++)
1424: {
1425: if (strcmp (pazcommands[i], "ALL") == 0
1426: || strcmp (pazcommands[i], zSxqt_prog) == 0)
1427: {
1428: fmatch = ! fmatch;
1429: break;
1430: }
1431: }
1432: }
1433:
1434: if (fmatch)
1435: {
1436: boolean fbad, fkill;
1437: struct uuconf_system ssys;
1438:
1439: fbad = FALSE;
1440:
1441: if ((icmd & JOB_SHOW) != 0)
1442: {
1443: struct tm stime;
1444:
1445: printf ("%s %s!", zsystem, zSxqt_system);
1446: if (zSxqt_requestor != NULL)
1447: printf ("%s", zSxqt_requestor);
1448: else
1449: printf ("%s", zSxqt_user);
1450:
1451: usysdep_localtime (itime, &stime);
1452: printf (" %02d-%02d %02d:%02d ",
1453: stime.tm_mon + 1, stime.tm_mday, stime.tm_hour,
1454: stime.tm_min);
1455:
1456: printf ("%s\n", zSxqt_cmd);
1457: }
1458:
1459: fkill = FALSE;
1460: if ((icmd & JOB_INQUIRE) != 0)
1461: {
1462: int b;
1463:
1464: /* Ask stdin whether this job should be killed. */
1465: fprintf (stderr, "%s: Kill %s? ", abProgram, zSxqt_cmd);
1466: (void) fflush (stderr);
1467: b = getchar ();
1468: fkill = b == 'y' || b == 'Y';
1469: while (b != EOF && b != '\n')
1470: b = getchar ();
1471: }
1472: else if ((icmd & JOB_KILL) != 0)
1473: fkill = TRUE;
1474:
1475: if (fkill)
1476: {
1477: if ((strcmp (zSxqt_user, zsysdep_login_name ()) != 0
1478: || strcmp (zsystem, zlocalname) != 0)
1479: && ! fsysdep_privileged ())
1480: {
1481: ulog (LOG_ERROR, "Job not submitted by you\n");
1482: fbad = TRUE;
1483: }
1484: }
1485:
1486: if (! fbad)
1487: {
1488: iuuconf = uuconf_system_info (puuconf, zsystem, &ssys);
1489: if (iuuconf != UUCONF_SUCCESS)
1490: {
1491: if (iuuconf != UUCONF_NOT_FOUND)
1492: {
1493: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1494: fbad = TRUE;
1495: }
1496: else if (strcmp (zsystem, zlocalname) == 0)
1497: {
1498: iuuconf = uuconf_system_local (puuconf, &ssys);
1499: if (iuuconf != UUCONF_SUCCESS)
1500: {
1501: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1502: fbad = TRUE;
1503: }
1504: }
1505: else if (! funknown_system (puuconf, zsystem, &ssys))
1506: {
1507: ulog (LOG_ERROR, "Job for unknown system %s",
1508: zsystem);
1509: fbad = TRUE;
1510: }
1511: }
1512: }
1513:
1514: if (! fbad && (icmd & (JOB_MAIL | JOB_NOTIFY)) != 0)
1515: {
1516: if (! fsnotify (puuconf, icmd, zcomment, cstdin, fkill,
1517: zSxqt_cmd, (struct scmdlist *) NULL,
1518: (const char *) NULL, zSxqt_user, &ssys,
1519: zSxqt_stdin, (pointer) NULL, zSxqt_requestor))
1520: {
1521: ferr = TRUE;
1522: usxqt_file_free ();
1523: ubuffree (zfile);
1524: ubuffree (zsystem);
1525: break;
1526: }
1527: }
1528:
1529: if (! fbad && fkill)
1530: {
1531: for (i = 0; i < cSxqt_files; i++)
1532: {
1533: char *z;
1534:
1535: z = zsysdep_spool_file_name (&ssys, pazSxqt_files[i],
1536: (pointer) NULL);
1537: if (z != NULL)
1538: {
1539: (void) remove (z);
1540: ubuffree (z);
1541: }
1542: }
1543: if (remove (zfile) != 0)
1544: ulog (LOG_ERROR, "remove (%s): %s", zfile,
1545: strerror (errno));
1546: }
1547:
1548: if (! fbad)
1549: (void) uuconf_system_free (puuconf, &ssys);
1550: }
1551:
1552: usxqt_file_free ();
1553: ubuffree (zfile);
1554: ubuffree (zsystem);
1555: }
1556:
1557: usysdep_get_xqt_free ();
1558:
1559: return ferr;
1560: }
1561:
1562: /* When a job is killed, send mail to the appropriate people. */
1563:
1564: static boolean
1565: fsnotify (puuconf, icmd, zcomment, cstdin, fkilled, zcmd, qcmd, zid, zuser,
1566: qsys, zstdin, pstdinseq, zrequestor)
1567: pointer puuconf;
1568: int icmd;
1569: const char *zcomment;
1570: int cstdin;
1571: boolean fkilled;
1572: const char *zcmd;
1573: struct scmdlist *qcmd;
1574: const char *zid;
1575: const char *zuser;
1576: const struct uuconf_system *qsys;
1577: const char *zstdin;
1578: pointer pstdinseq;
1579: const char *zrequestor;
1580: {
1581: const char **pz;
1582: int cgot;
1583: int i, istdin;
1584: const char *zsubject;
1585: boolean fret;
1586:
1587: pz = (const char **) xmalloc (20 * sizeof (const char *));
1588: cgot = 20;
1589:
1590: i = 0;
1591: if (zid == NULL)
1592: pz[i++] = "A UUCP execution request";
1593: else
1594: {
1595: pz[i++] = "UUCP job\n\t";
1596: pz[i++] = zid;
1597: pz[i++] = "\nfor system\n\t";
1598: pz[i++] = qsys->uuconf_zname;
1599: }
1600: pz[i++] = "\nrequested by\n\t";
1601: pz[i++] = zuser != NULL ? zuser : OWNER;
1602: if (zid == NULL)
1603: {
1604: pz[i++] = "\non system\n\t";
1605: pz[i++] = qsys->uuconf_zname;
1606: }
1607: pz[i++] = "\n";
1608:
1609: if (fkilled)
1610: pz[i++] = "has been killed.\n";
1611:
1612: if (zcomment != NULL)
1613: {
1614: pz[i++] = zcomment;
1615: pz[i++] = "\n";
1616: }
1617:
1618: pz[i++] = "The job ";
1619: if (fkilled)
1620: pz[i++] = "was\n";
1621: else
1622: pz[i++] = "is\n";
1623:
1624: if (zcmd != NULL)
1625: {
1626: pz[i++] = "\t";
1627: pz[i++] = zcmd;
1628: }
1629: else
1630: {
1631: struct scmdlist *qshow;
1632:
1633: for (qshow = qcmd; qshow != NULL; qshow = qshow->qnext)
1634: {
1635: if (i + 10 > cgot)
1636: {
1637: cgot += 20;
1638: pz = (const char **) xrealloc ((pointer) pz,
1639: cgot * sizeof (const char *));
1640: }
1641:
1642: switch (qshow->s.bcmd)
1643: {
1644: case 'S':
1645: pz[i++] = "\tsend ";
1646: break;
1647: default:
1648: case 'R':
1649: case 'X':
1650: pz[i++] = "\trequest ";
1651: break;
1652: case 'P':
1653: pz[i++] = "\tpoll ";
1654: #if DEBUG > 0
1655: case 'E':
1656: ulog (LOG_FATAL, "fsnotify: Can't happen");
1657: break;
1658: #endif
1659: }
1660: if (qshow->s.zfrom != NULL && qshow->s.zto != NULL)
1661: {
1662: pz[i++] = qshow->s.zfrom;
1663: pz[i++] = " to ";
1664: pz[i++] = qshow->s.zto;
1665: }
1666: }
1667: }
1668:
1669: istdin = i;
1670: if (cstdin > 0 && zstdin != NULL)
1671: {
1672: boolean fspool;
1673: char *zfile;
1674: FILE *e;
1675:
1676: fspool = fspool_file (zstdin);
1677: if (fspool)
1678: zfile = zsysdep_spool_file_name (qsys, zstdin, pstdinseq);
1679: else
1680: zfile = zsysdep_local_file (zstdin, qsys->uuconf_zpubdir);
1681:
1682: if (zfile != NULL
1683: && (fspool
1684: || fin_directory_list (zfile, qsys->uuconf_pzremote_send,
1685: qsys->uuconf_zpubdir, TRUE, TRUE,
1686: (const char *) NULL)))
1687: {
1688: e = fopen (zfile, "r");
1689: if (e != NULL)
1690: {
1691: int clines, clen;
1692: char *zline;
1693: size_t cline;
1694:
1695: pz[i++] = "\n";
1696: istdin = i;
1697:
1698: clines = 0;
1699:
1700: zline = NULL;
1701: cline = 0;
1702: while ((clen = getline (&zline, &cline, e)) > 0)
1703: {
1704: if (memchr (zline, '\0', (size_t) clen) != NULL)
1705: {
1706: int ifree;
1707:
1708: /* A null character means this is probably a
1709: binary file. */
1710: for (ifree = istdin; ifree < i; ifree++)
1711: ubuffree ((char *) pz[ifree]);
1712: i = istdin - 1;
1713: break;
1714: }
1715: ++clines;
1716: if (clines > cstdin)
1717: break;
1718: if (i >= cgot)
1719: {
1720: cgot += 20;
1721: pz = (const char **) xrealloc ((pointer) pz,
1722: (cgot
1723: * sizeof (char *)));
1724: }
1725: pz[i++] = zbufcpy (zline);
1726: }
1727: xfree ((pointer) zline);
1728: (void) fclose (e);
1729: }
1730: }
1731:
1732: ubuffree (zfile);
1733: }
1734:
1735: if (fkilled)
1736: zsubject = "UUCP job killed";
1737: else
1738: zsubject = "UUCP notification";
1739:
1740: fret = TRUE;
1741:
1742: if ((icmd & JOB_MAIL) != 0)
1743: {
1744: if (! fsysdep_mail (OWNER, zsubject, i, pz))
1745: fret = FALSE;
1746: }
1747:
1748: if ((icmd & JOB_NOTIFY) != 0
1749: && (zrequestor != NULL || zuser != NULL))
1750: {
1751: const char *zmail;
1752: char *zfree;
1753:
1754: if (zrequestor != NULL)
1755: zmail = zrequestor;
1756: else
1757: zmail = zuser;
1758:
1759: zfree = NULL;
1760:
1761: if (zid == NULL)
1762: {
1763: int iuuconf;
1764: const char *zloc;
1765:
1766: /* This is an execution request, which may be from another
1767: system. If it is, we must prepend that system name to
1768: the user name extracted from the X. file. */
1769: iuuconf = uuconf_localname (puuconf, &zloc);
1770: if (iuuconf == UUCONF_NOT_FOUND)
1771: {
1772: zloc = zsysdep_localname ();
1773: if (zloc == NULL)
1774: return FALSE;
1775: }
1776: else if (iuuconf != UUCONF_SUCCESS)
1777: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
1778:
1779: if (strcmp (qsys->uuconf_zname, zloc) != 0
1780: #if HAVE_INTERNET_MAIL
1781: && strchr (zmail, '@') == NULL
1782: #endif
1783: )
1784: {
1785: zfree = zbufalc (strlen (qsys->uuconf_zname)
1786: + strlen (zmail)
1787: + sizeof "!");
1788: sprintf (zfree, "%s!%s", qsys->uuconf_zname, zmail);
1789: zmail = zfree;
1790: }
1791: }
1792:
1793: if (! fsysdep_mail (zmail, zsubject, i, pz))
1794: fret = FALSE;
1795:
1796: ubuffree (zfree);
1797: }
1798:
1799: while (istdin < i)
1800: {
1801: ubuffree ((char *) pz[istdin]);
1802: istdin++;
1803: }
1804:
1805: xfree ((pointer) pz);
1806:
1807: return fret;
1808: }
1809:
1810: /* Handle the -q option. For each remote system this lists the number
1811: of jobs queued, the number of executions queued, and the current
1812: call status. We get the executions all at once, because they are
1813: not accessed by system. They could be, but it is possible to have
1814: executions pending for an unknown system, so special handling would
1815: still be required. */
1816:
1817: struct sxqtlist
1818: {
1819: struct sxqtlist *qnext;
1820: char *zsystem;
1821: int cxqts;
1822: long ifirst;
1823: };
1824:
1825: /* These local functions need the definition of sxqtlist for the
1826: prototype. */
1827:
1828: static boolean fsquery_system P((const struct uuconf_system *qsys,
1829: struct sxqtlist **pq,
1830: long inow, const char *zlocalname));
1831: static boolean fsquery_show P((const struct uuconf_system *qsys, int cwork,
1832: long ifirstwork,
1833: struct sxqtlist *qxqt,
1834: long inow, const char *zlocalname));
1835:
1836: static boolean
1837: fsquery (puuconf)
1838: pointer puuconf;
1839: {
1840: int iuuconf;
1841: const char *zlocalname;
1842: struct sxqtlist *qlist;
1843: char *zfile, *zsystem;
1844: boolean ferr;
1845: long inow;
1846: char **pznames, **pz;
1847: boolean fret;
1848:
1849: iuuconf = uuconf_localname (puuconf, &zlocalname);
1850: if (iuuconf == UUCONF_NOT_FOUND)
1851: {
1852: zlocalname = zsysdep_localname ();
1853: if (zlocalname == NULL)
1854: return FALSE;
1855: }
1856: else if (iuuconf != UUCONF_SUCCESS)
1857: {
1858: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1859: return FALSE;
1860: }
1861:
1862: /* Get a count of all the execution files. */
1863: if (! fsysdep_get_xqt_init ())
1864: return FALSE;
1865:
1866: qlist = NULL;
1867: while ((zfile = zsysdep_get_xqt (&zsystem, &ferr)) != NULL)
1868: {
1869: struct sxqtlist *qlook;
1870:
1871: for (qlook = qlist; qlook != NULL; qlook = qlook->qnext)
1872: if (strcmp (zsystem, qlook->zsystem) == 0)
1873: break;
1874:
1875: if (qlook != NULL)
1876: {
1877: long itime;
1878:
1879: ubuffree (zsystem);
1880: ++qlook->cxqts;
1881: itime = ixsysdep_file_time (zfile);
1882: if (itime < qlook->ifirst)
1883: qlook->ifirst = itime;
1884: }
1885: else
1886: {
1887: struct sxqtlist *qnew;
1888:
1889: qnew = (struct sxqtlist *) xmalloc (sizeof (struct sxqtlist));
1890: qnew->qnext = qlist;
1891: qnew->zsystem = zsystem;
1892: qnew->cxqts = 1;
1893: qnew->ifirst = ixsysdep_file_time (zfile);
1894: qlist = qnew;
1895: }
1896:
1897: ubuffree (zfile);
1898: }
1899:
1900: usysdep_get_xqt_free ();
1901:
1902: if (ferr)
1903: return FALSE;
1904:
1905: inow = ixsysdep_time ((long *) NULL);
1906:
1907: /* Show the information for each system. */
1908: iuuconf = uuconf_system_names (puuconf, &pznames, 0);
1909: if (iuuconf != UUCONF_SUCCESS)
1910: {
1911: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1912: return FALSE;
1913: }
1914:
1915: fret = TRUE;
1916:
1917: for (pz = pznames; *pz != NULL; pz++)
1918: {
1919: struct uuconf_system ssys;
1920:
1921: iuuconf = uuconf_system_info (puuconf, *pz, &ssys);
1922: if (iuuconf != UUCONF_SUCCESS)
1923: {
1924: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1925: fret = FALSE;
1926: continue;
1927: }
1928:
1929: if (! fsquery_system (&ssys, &qlist, inow, zlocalname))
1930: fret = FALSE;
1931:
1932: (void) uuconf_system_free (puuconf, &ssys);
1933: xfree ((pointer) *pz);
1934: }
1935:
1936: /* Check for the local system in the list of execution files. */
1937: if (qlist != NULL)
1938: {
1939: struct sxqtlist **pq;
1940:
1941: for (pq = &qlist; *pq != NULL; pq = &(*pq)->qnext)
1942: {
1943: if (strcmp ((*pq)->zsystem, zlocalname) == 0)
1944: {
1945: struct uuconf_system ssys;
1946: struct sxqtlist *qfree;
1947:
1948: iuuconf = uuconf_system_info (puuconf, zlocalname, &ssys);
1949: if (iuuconf != UUCONF_SUCCESS)
1950: {
1951: if (iuuconf != UUCONF_NOT_FOUND)
1952: {
1953: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1954: fret = FALSE;
1955: break;
1956: }
1957:
1958: iuuconf = uuconf_system_local (puuconf, &ssys);
1959: if (iuuconf != UUCONF_SUCCESS)
1960: {
1961: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1962: fret = FALSE;
1963: break;
1964: }
1965: ssys.uuconf_zname = (char *) zlocalname;
1966: }
1967:
1968: if (! fsquery_show (&ssys, 0, 0L, *pq, inow, zlocalname))
1969: fret = FALSE;
1970: (void) uuconf_system_free (puuconf, &ssys);
1971: qfree = *pq;
1972: *pq = qfree->qnext;
1973: ubuffree (qfree->zsystem);
1974: xfree ((pointer) qfree);
1975: break;
1976: }
1977: }
1978: }
1979:
1980: /* Print out information for any unknown systems for which we have
1981: execution files. */
1982: while (qlist != NULL)
1983: {
1984: struct uuconf_system ssys;
1985: struct sxqtlist *qnext;
1986:
1987: if (! funknown_system (puuconf, qlist->zsystem, &ssys))
1988: {
1989: ulog (LOG_ERROR, "Executions queued up for unknown systems");
1990: fret = FALSE;
1991: break;
1992: }
1993:
1994: if (! fsquery_show (&ssys, 0, 0L, qlist, inow, zlocalname))
1995: fret = FALSE;
1996: (void) uuconf_system_free (puuconf, &ssys);
1997: qnext = qlist->qnext;
1998: ubuffree (qlist->zsystem);
1999: xfree ((pointer) qlist);
2000: qlist = qnext;
2001: }
2002:
2003: return fret;
2004: }
2005:
2006: /* Query a single known system. */
2007:
2008: static boolean
2009: fsquery_system (qsys, pq, inow, zlocalname)
2010: const struct uuconf_system *qsys;
2011: struct sxqtlist **pq;
2012: long inow;
2013: const char *zlocalname;
2014: {
2015: int cwork;
2016: long ifirstwork;
2017: char *zid;
2018: boolean fret;
2019:
2020: if (! fsysdep_get_work_init (qsys, UUCONF_GRADE_LOW))
2021: return FALSE;
2022:
2023: cwork = 0;
2024: ifirstwork = 0L;
2025: zid = NULL;
2026: while (TRUE)
2027: {
2028: struct scmd s;
2029: long itime;
2030: char *zthisid;
2031:
2032: if (! fsysdep_get_work (qsys, UUCONF_GRADE_LOW, &s))
2033: return FALSE;
2034: if (s.bcmd == 'H')
2035: break;
2036:
2037: zthisid = zsysdep_jobid (qsys, s.pseq);
2038: if (zid != NULL && strcmp (zid, zthisid) == 0)
2039: ubuffree (zthisid);
2040: else
2041: {
2042: ++cwork;
2043: ubuffree (zid);
2044: zid = zthisid;
2045: }
2046:
2047: itime = ixsysdep_work_time (qsys, s.pseq);
2048: if (ifirstwork == 0L || ifirstwork > itime)
2049: ifirstwork = itime;
2050: }
2051:
2052: usysdep_get_work_free (qsys);
2053: ubuffree (zid);
2054:
2055: /* Find the execution information, if any. */
2056: while (*pq != NULL)
2057: {
2058: if (strcmp ((*pq)->zsystem, qsys->uuconf_zname) == 0)
2059: break;
2060: pq = &(*pq)->qnext;
2061: }
2062:
2063: /* If there are no commands and no executions, don't print any
2064: information for this system. */
2065: if (cwork == 0 && *pq == NULL)
2066: return TRUE;
2067:
2068: fret = fsquery_show (qsys, cwork, ifirstwork, *pq, inow, zlocalname);
2069:
2070: if (*pq != NULL)
2071: {
2072: struct sxqtlist *qfree;
2073:
2074: qfree = *pq;
2075: *pq = qfree->qnext;
2076: ubuffree (qfree->zsystem);
2077: xfree ((pointer) qfree);
2078: }
2079:
2080: return fret;
2081: }
2082:
2083: /* Print out the query information for a single system. We handle the
2084: local system specially. */
2085:
2086: static boolean
2087: fsquery_show (qsys, cwork, ifirstwork, qxqt, inow, zlocalname)
2088: const struct uuconf_system *qsys;
2089: int cwork;
2090: long ifirstwork;
2091: struct sxqtlist *qxqt;
2092: long inow;
2093: const char *zlocalname;
2094: {
2095: boolean flocal;
2096: struct sstatus sstat;
2097: boolean fnostatus;
2098: struct tm stime;
2099: int cpad;
2100:
2101: flocal = strcmp (qsys->uuconf_zname, zlocalname) == 0;
2102:
2103: if (! flocal)
2104: {
2105: if (! fsysdep_get_status (qsys, &sstat, &fnostatus))
2106: return FALSE;
2107: }
2108:
2109: printf ("%-10s %3dC (", qsys->uuconf_zname, cwork);
2110:
2111: if (cwork == 0)
2112: {
2113: printf ("0 secs");
2114: cpad = 3;
2115: }
2116: else
2117: cpad = csunits_show (inow - ifirstwork);
2118:
2119: printf (") ");
2120: while (cpad-- != 0)
2121: printf (" ");
2122:
2123: if (qxqt == NULL)
2124: printf (" 0X (0 secs) ");
2125: else
2126: {
2127: printf ("%3dX (", qxqt->cxqts);
2128: cpad = csunits_show (inow - qxqt->ifirst);
2129: printf (")");
2130: while (cpad-- != 0)
2131: printf (" ");
2132: }
2133:
2134: if (flocal || fnostatus)
2135: {
2136: printf ("\n");
2137: return TRUE;
2138: }
2139:
2140: usysdep_localtime (sstat.ilast, &stime);
2141:
2142: printf (" %02d-%02d %02d:%02d ",
2143: stime.tm_mon + 1,stime.tm_mday, stime.tm_hour, stime.tm_min);
2144:
2145: printf ("%s\n", azStatus[(int) sstat.ttype]);
2146:
2147: return TRUE;
2148: }
2149:
2150: /* Print a time difference in the largest applicable units. */
2151:
2152: static int
2153: csunits_show (idiff)
2154: long idiff;
2155: {
2156: const char *zunit;
2157: long iunits;
2158: int cpad;
2159:
2160: if (idiff > (long) 24 * (long) 60 * (long) 60)
2161: {
2162: iunits = idiff / ((long) 24 * (long) 60 * (long) 60);
2163: zunit = "day";
2164: cpad = 4;
2165: }
2166: else if (idiff > (long) 60 * 60)
2167: {
2168: iunits = idiff / (long) (60 * 60);
2169: zunit = "hour";
2170: cpad = 3;
2171: }
2172: else if (idiff > (long) 60)
2173: {
2174: iunits = idiff / (long) 60;
2175: zunit = "min";
2176: cpad = 4;
2177: }
2178: else
2179: {
2180: iunits = idiff;
2181: zunit = "sec";
2182: cpad = 4;
2183: }
2184:
2185: printf ("%ld %s%s", iunits, zunit, iunits == 1 ? "" : "s");
2186:
2187: if (iunits != 1)
2188: --cpad;
2189: if (iunits > 99)
2190: --cpad;
2191: if (iunits > 9)
2192: --cpad;
2193: return cpad;
2194: }
2195:
2196: /* Give a list of all status entries for all machines that we have
2197: status entries for. We need to get a list of status entries in a
2198: system dependent fashion, since we may have status for unknown
2199: systems. */
2200:
2201: static boolean
2202: fsmachines ()
2203: {
2204: pointer phold;
2205: char *zsystem;
2206: boolean ferr;
2207: struct sstatus sstat;
2208:
2209: if (! fsysdep_all_status_init (&phold))
2210: return FALSE;
2211:
2212: while ((zsystem = zsysdep_all_status (phold, &ferr, &sstat)) != NULL)
2213: {
2214: struct tm stime;
2215:
2216: usysdep_localtime (sstat.ilast, &stime);
2217: printf ("%-14s %02d-%02d %02d:%02d %s", zsystem,
2218: stime.tm_mon + 1, stime.tm_mday, stime.tm_hour,
2219: stime.tm_min, azStatus[(int) sstat.ttype]);
2220: ubuffree (zsystem);
2221: if (sstat.ttype != STATUS_TALKING
2222: && sstat.cwait > 0)
2223: {
2224: printf (" (%d %s", sstat.cretries,
2225: sstat.cretries == 1 ? "try" : "tries");
2226: if (sstat.ilast + sstat.cwait > ixsysdep_time ((long *) NULL))
2227: {
2228: usysdep_localtime (sstat.ilast + sstat.cwait, &stime);
2229: printf (", next after %02d-%02d %02d:%02d",
2230: stime.tm_mon + 1, stime.tm_mday, stime.tm_hour,
2231: stime.tm_min);
2232: }
2233: printf (")");
2234: }
2235: printf ("\n");
2236: }
2237:
2238: usysdep_all_status_free (phold);
2239:
2240: return ! ferr;
2241: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.