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