home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / mmdf / mmdf-IIb.43 / src / tools / checkup.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-28  |  30.5 KB  |  1,142 lines
  1. /*
  2.  *     MULTI-CHANNEL MEMO DISTRIBUTION FACILITY  (MMDF)
  3.  *
  4.  *
  5.  *     Copyright (C) 1979,1980,1981  University of Delaware
  6.  *
  7.  *     Department of Electrical Engineering
  8.  *     University of Delaware
  9.  *     Newark, Delaware  19711
  10.  *
  11.  *     Phone:  (302) 738-1163
  12.  *
  13.  *
  14.  *     This program module was developed as part of the University
  15.  *     of Delaware's Multi-Channel Memo Distribution Facility (MMDF).
  16.  *
  17.  *     Acquisition, use, and distribution of this module and its listings
  18.  *     are subject restricted to the terms of a license agreement.
  19.  *     Documents describing systems using this module must cite its source.
  20.  *
  21.  *     The above statements must be retained with all copies of this
  22.  *     program and may not be removed without the consent of the
  23.  *     University of Delaware.
  24.  *
  25.  *
  26.  *     version  -1    David H. Crocker    March   1979
  27.  *     version   0    David H. Crocker    April   1980
  28.  *     version  v7    David H. Crocker    May     1981
  29.  *     version   1    David H. Crocker    October 1981
  30.  *
  31.  */
  32. /*      check directory, file, and program conditions, for MMDF
  33.  *
  34.  *  Jan 82  D. Crocker    Cleaned up protection-setting, a bit more
  35.  *                        Temporarily ignore group id mismatches
  36.  *  Jun 82  S. Manion     Major functional upgrade, such as verifying
  37.  *                        necessary alias entries exist.
  38.  *  Feb 84  D. Long       Check for slave in cmddfldir...not /usr/mmdf/lib.
  39.  *  Mar 84  D. Long       Report the line type of dialports.
  40.  */
  41.  
  42. #include "util.h"
  43. #include "mmdf.h"
  44. #include <pwd.h>
  45. #include <sys/stat.h>
  46. #include "ch.h"
  47. #ifndef NODIAL
  48. #include "d_proto.h"
  49. #include "d_structs.h"
  50. #endif /* NODIAL */
  51. #include "gettys.h"
  52. #include "dm.h"
  53.  
  54. #define MAXARG 50
  55.  
  56. /*  maximum number of output lines to be queued at once  */
  57. #define         QUESIZ          20
  58.  
  59. /*  the maximum number of path names that can be remembered as
  60.  *  having been checked already.  See chkpath()
  61. */
  62. #define         MAXPATH         15
  63.  
  64. /*  various verbosity levels  */
  65. #define         PERROR             01   /*  perror() should be called */
  66. #define         ANYLEVEL          070   /*  any bit in this field */
  67. #define         LEVEL1            010   /*  fatal */
  68. #define         LEVEL1P      LEVEL1|PERROR
  69. #define         LEVEL3            020   /*  major section */
  70. #define         LEVEL4            030   /*  sub-section */
  71. #define         LEVEL5            040
  72. #define         LEVEL6            050
  73. #define         LEVEL6_5          060   /*  warning [..] messages */
  74. #define         LEVEL7            070   /* nitty gritty junk */
  75. #define         LEVEL0       LEVEL1|PERROR
  76.  
  77. #define         BACKGROUND      LEVEL6  /* default verbosity */
  78. #define         FINAL           0
  79. #define         PARTIAL         1
  80.  
  81. extern char *dupfpath();
  82. extern char *strncpy();
  83. extern int  sys_nerr;
  84. extern char *sys_errlist[];
  85. extern int  errno;
  86.  
  87. extern LLog msglog;
  88. extern Chan **ch_tbsrch;       /* defined channels */
  89. extern Table **tb_list;        /* full list of known tables */
  90.  
  91. extern Domain **dm_list;
  92. extern char *mmdflogin;        /* login name for mmdf processes */
  93. extern char *mmtailor;        /* external tailoring information */
  94.  
  95.  
  96. extern char     *lckdfldir,
  97.            *pn_quedir;
  98.  
  99. #ifdef JNTMAIL
  100. int daemonuid,
  101.     daemongid;
  102. #define DAEMON  "daemon";       /* Can be overridden at compile time */
  103. char daemonname[]  = DAEMON;
  104. #endif /* JNTMAIL */
  105.  
  106. extern char *locmachine, *locfullmachine, *locfullname, *locname, *locdomain;
  107.  
  108. extern char
  109.         *logdfldir,
  110.         *phsdfldir,
  111.         *tbldfldir,
  112.         *tbldbm,
  113.         *cmddfldir,
  114.         *chndfldir,
  115.         *mldfldir;
  116.  
  117. extern char
  118.         *quedfldir,
  119.         *tquedir,
  120.         *aquedir,
  121.         *mquedir,
  122.         *squepref;
  123.  
  124. extern char
  125.         *pathdeliver,
  126.         *pathsubmit,
  127.         *pathpkup,
  128.         *pathmail;
  129.  
  130. extern char *tai_eptr;
  131.  
  132. extern int queprot;             /* protection on quedfldir[] parent */
  133.  
  134. extern struct ll_struct    msglog,
  135.             chanlog;
  136.  
  137. #ifndef NODIAL
  138. extern struct ll_struct    ph_log;
  139. extern struct dialports *d_prts;
  140. extern struct directlines *d_lines;
  141. #endif /* NODIAL */
  142. extern struct passwd *getpwuid ();
  143. extern struct passwd *getpwnam ();
  144.  
  145. struct stat statbuf;
  146.  
  147. struct prtque  {
  148.     int q_level;
  149.     char q_text[126];
  150. };
  151.  
  152. int mmdfuid,
  153.     mmdfgid;
  154. int rootgid;
  155. int verbosity = BACKGROUND;
  156. char hdrfmt[] = "\n%-24s: %s\n";
  157. char subhdrfmt[] = "    %-20s: %s\n";
  158. char probfmt[] = "%-18s: %s\n";
  159. char errflg;                    /* error during mmdf_init */
  160. char *xerrstr();
  161. /* */
  162.  
  163. main (argc, argv)
  164.   int argc;
  165.   char *argv[];
  166. {
  167.     char tmpfile[FILNSIZE];
  168.     struct passwd *pwdptr;
  169.     int ind;
  170.  
  171.     /*  check for the verbosity flag  */
  172.     flaginit (argc, argv);
  173.  
  174.     que (BACKGROUND, "\n**  Asterisks indicate potentially serious anomolies.\n");
  175.     que (LEVEL6_5, "[ Information which is bracketed is advisory. ]\n");
  176.     qflush (LEVEL0);
  177.  
  178.     chktai ();  /* is the tailoring file there ? */
  179.  
  180.     mmdf_init (argv[0]);
  181.     if (errflg)
  182.     endit (NOTOK);
  183.     ll_hdinit (&msglog, argv[0]);
  184.     msglog.ll_file = dupfpath (msglog.ll_file, logdfldir);
  185.  
  186. #ifdef JNTMAIL
  187.     if ((pwdptr = getpwnam (daemonname)) == (struct passwd *) NULL)
  188.     {
  189.       que (LEVEL1, hdrfmt, "** No /etc/passwd login", daemonname);
  190.       endit (NOTOK);
  191.     }
  192.     daemonuid = pwdptr -> pw_uid;
  193.     daemongid = pwdptr -> pw_gid;
  194. #endif /* JNTMAIL */
  195.  
  196.     que (BACKGROUND, hdrfmt, "Default local machine name", locmachine);
  197.     que (LEVEL7, subhdrfmt, "", "this is your 'official' machine name");
  198.     qflush (LEVEL7);
  199.  
  200.     que (BACKGROUND, hdrfmt, "Default full local machine name", locfullmachine);
  201.     que (LEVEL7, subhdrfmt, "", "this is your 'official' full machine name");
  202.     qflush (LEVEL7);
  203.  
  204.     que (BACKGROUND, hdrfmt, "Default local name", locname);
  205.     que (LEVEL7, subhdrfmt, "", "this is your 'official' host name");
  206.     qflush (LEVEL7);
  207.  
  208.     que (BACKGROUND, hdrfmt, "Default full local name", locfullname);
  209.     que (LEVEL7, subhdrfmt, "", "this is your 'official' full domain name");
  210.     qflush (LEVEL7);
  211.  
  212.     que (BACKGROUND, hdrfmt, "Default domain name", locdomain);
  213.     que (LEVEL7, subhdrfmt, "", "this is your 'official' domain name");
  214.     qflush (LEVEL7);
  215.  
  216.     /*  get uid & gid for mmdf login, for setting directory ownerships */
  217.     if ((pwdptr = getpwnam (mmdflogin)) == (struct passwd *) NULL)
  218.     {
  219.     que (LEVEL1, hdrfmt, "** No /etc/passwd login", mmdflogin);
  220.     endit (NOTOK);
  221.     }
  222.     mmdfuid = pwdptr -> pw_uid;
  223.     mmdfgid = pwdptr -> pw_gid;
  224.  
  225.     que (LEVEL3, "\nMMDF login %-11s  : uid (%d), gid (%d)\n",
  226.         mmdflogin, mmdfuid, mmdfgid);
  227.     chkalias (mmdflogin);
  228.     que (LEVEL7, subhdrfmt, "", "alias this to root or systems staff");
  229.     qflush (LEVEL7);
  230.     qflush (LEVEL3);
  231.  
  232.     /* check for hashed table, if required */
  233.     if (tbldbm != (char *) 0)
  234.     {
  235.     que (BACKGROUND, hdrfmt, "MMDF DBM database", tbldbm);
  236.     que (LEVEL7, hdrfmt, "", "compiled by dbmbuild");
  237.     qflush (LEVEL7);
  238.  
  239.     getfpath (tbldbm, tbldfldir, tmpfile);
  240.     strcat (tmpfile, ".dir");
  241.     que (LEVEL7, subhdrfmt, "data directory", tmpfile);
  242.     chkfile (tmpfile, 0644, 0664, mmdfuid, mmdfgid, mmdflogin);
  243.  
  244.     getfpath (tbldbm, tbldfldir, tmpfile);
  245.     strcat (tmpfile, ".pag");
  246.     que (LEVEL7, subhdrfmt, "data pages", tmpfile);
  247.     chkfile (tmpfile, 0644, 0664, mmdfuid, mmdfgid, mmdflogin);
  248.     qflush (LEVEL7);
  249.     }
  250.  
  251.     que (BACKGROUND, hdrfmt, "Trouble report address", "Postmaster");
  252.     que (LEVEL7, subhdrfmt, "", "alias this to root or systems staff");
  253.     qflush (LEVEL7);
  254.     chkalias ("Postmaster");    /*  make sure the name is aliased  */
  255.     qflush (LEVEL0);
  256.  
  257.     if ((pwdptr = getpwuid (0)) != (struct passwd *) NULL)
  258.     rootgid = pwdptr -> pw_gid;
  259.  
  260.     que (LEVEL3, hdrfmt, "Checking directories", "");
  261.  
  262.     /*  standard directories */
  263.     que (LEVEL4, subhdrfmt, "Logging directory", logdfldir);
  264.     if (chkfile (logdfldir, 0711, 0755, mmdfuid, mmdfgid, mmdflogin) >= OK)
  265.     chklog ();
  266.     qflush (LEVEL4);
  267.  
  268.     que (LEVEL4, "\n");
  269.     que (LEVEL4, subhdrfmt, "Phase (timestamps)", phsdfldir);
  270.     chkfile (phsdfldir, 0711, 0755, mmdfuid, mmdfgid, mmdflogin);
  271.     qflush (LEVEL4);
  272.  
  273. #ifndef V4_2BSD
  274.     que (LEVEL4, "\n");
  275.     que (LEVEL4, subhdrfmt, "Locking directory", lckdfldir);
  276.     chkfile (lckdfldir, 0777, 0777, mmdfuid, mmdfgid, mmdflogin);
  277.     qflush (LEVEL4);
  278. #endif /* V4_2BSD */
  279.  
  280. #ifdef JNTMAIL
  281.     que (LEVEL4, "\n");
  282.     que (LEVEL4, subhdrfmt, "NIFTP spool directory", pn_quedir);
  283.     chkfile (pn_quedir, 0700, 0700, daemonuid, daemongid, daemonname);
  284.     qflush (LEVEL4);
  285. #endif
  286.  
  287.     que (LEVEL4, "\n");
  288.     que (LEVEL4, subhdrfmt, "Tables & scripts", tbldfldir);
  289.     if (chkfile (tbldfldir, 0711, 0755, mmdfuid, mmdfgid, mmdflogin) >= OK)
  290.     chktab ();
  291.     qflush (LEVEL4);
  292.  
  293.     que (LEVEL4, hdrfmt, "MMDF Commands", cmddfldir);
  294.     if (chkfile (cmddfldir, 0711, 0755, mmdfuid, mmdfgid, mmdflogin) >= OK)
  295.     chkcmd ();
  296.     qflush (LEVEL4);
  297.  
  298.     que (LEVEL4, hdrfmt, "Channel programs", chndfldir);
  299.     if (chkfile (chndfldir, 0500, 0770, mmdfuid, mmdfgid, mmdflogin) >= OK)
  300.     chkchan ();
  301.     qflush (LEVEL4);
  302.  
  303.     if (isstr(mldfldir))
  304.     {                           /* all mail delivered in common dir     */
  305.     que (LEVEL4, hdrfmt, "Shared receipt directory", mldfldir);
  306.     chkfile (mldfldir, 0777, 0777, mmdfuid, mmdfgid, mmdflogin);
  307.     qflush (LEVEL4);
  308.     }
  309.     qflush (LEVEL0);
  310.  
  311.     /*  queue directory substructure */
  312.     que (LEVEL4, hdrfmt, "Mail queue home", quedfldir);
  313.     if (chkpath (FINAL, quedfldir, 0777, 0777, mmdfuid, mmdfgid, mmdflogin) < OK)
  314.     que (LEVEL1, "cannot check queue further\n");
  315.     else
  316.     {
  317.     que (LEVEL7, "\t(changing into queue home directory...)\n");
  318.     if (chdir (quedfldir) < OK)
  319.     {
  320.         que (LEVEL1, probfmt, "cannot chdir", xerrstr());
  321.         que (LEVEL1, "unable to check queue directory tree further\n");
  322.     }
  323.     else
  324.     {
  325.         qflush (LEVEL7);
  326.         que (LEVEL5, subhdrfmt, "Queue lock", "home's parent directory");
  327.         if (stat ("..", &statbuf) < OK)
  328.         que (LEVEL1P, "cannot stat home queue parent, ");
  329.         else
  330.         {
  331.         statbuf.st_mode &= 06707;
  332.         if (statbuf.st_mode != queprot)
  333.             que (LEVEL1, "Wrong mode        : (0%o) should be (0%o)\n",
  334.                 statbuf.st_mode, queprot);
  335.         }
  336.         qflush (LEVEL5);
  337.  
  338.         que (LEVEL5, subhdrfmt, "Address-building", tquedir);
  339.         chkpath (FINAL, tquedir, 0777, 0777, mmdfuid, mmdfgid, mmdflogin);
  340.         qflush (LEVEL5);
  341.  
  342.         que (LEVEL5, subhdrfmt, "Queued addresses", aquedir);
  343.         chkpath (FINAL, aquedir, 0777, 0777, mmdfuid, mmdfgid, mmdflogin);
  344.         qflush (LEVEL5);
  345.  
  346.         que (LEVEL5, subhdrfmt, "Message text", mquedir);
  347.         chkpath (FINAL, mquedir, 0777, 0777, mmdfuid, mmdfgid, mmdflogin);
  348.         qflush (LEVEL5);
  349.  
  350.         que (LEVEL5, "Queueing directories:\n");
  351.         for (ind = 0; ch_tbsrch[ind] != (Chan *) 0; ind++)
  352.         {
  353.             static char path[64];
  354.  
  355.             (void) sprintf (path, "%s%s",
  356.             squepref, ch_tbsrch[ind] -> ch_queue);
  357.         que (LEVEL5, subhdrfmt, ch_tbsrch[ind] -> ch_show, path);
  358.         chkpath (FINAL, path, 0777, 0777, mmdfuid, mmdfgid, mmdflogin);
  359.         qflush (LEVEL5);
  360.         }
  361.     }
  362.     }
  363.     qflush (LEVEL0);
  364.  
  365. #ifndef NODIAL
  366.     que (LEVEL4, hdrfmt, "Dial out ports", "");
  367.     chk_dprts ();               /*  check the dial out ports  */
  368.     qflush (LEVEL0);
  369.  
  370.     que (LEVEL4, hdrfmt, "Direct-connect lines", "");
  371.     chk_dirlin ();              /*  check the direct lines  */
  372.     qflush (LEVEL0);
  373. #endif /* NODIAL */
  374.  
  375.     endit (OK);
  376. }
  377. /* */
  378.  
  379. flaginit (argc, argv)
  380. int argc;
  381. char *argv[];
  382. {
  383.     register int argind, charind;
  384.  
  385.     for (argind = 1;  argind < argc;  argind++)
  386.     if (argv[argind][0] == '-')
  387.         for (charind = 1;  argv[argind][charind] != '\0';  charind++)
  388.         switch (argv[argind][charind])
  389.         {
  390.             case 'p':           /* only note problems */
  391.             verbosity = LEVEL1;
  392.             break;
  393.  
  394.             case 'v':
  395.             verbosity = atoi (&argv[argind][++charind]);
  396.             if (verbosity < 0)
  397.                 verbosity = LEVEL1;
  398.             if (verbosity == 0)
  399.                 verbosity = LEVEL7;
  400.             while (isdigit (argv[argind][charind]))
  401.                 charind++;
  402.             charind--;
  403.             break;
  404.  
  405.             default:
  406.             printf ("Unknown flag %c\n", argv[argind][charind]);
  407.             printf ("Usage:  %s [-p][-v<verbosity>]\n", argv[0]);
  408.             exit (NOTOK);
  409.         }
  410. }
  411. /* */
  412.  
  413. #ifndef NODIAL
  414. chk_dprts ()
  415. {
  416.     struct ttys data;
  417.     char desc[30];
  418.     register int index, result;
  419.  
  420.     for (index = 0;  d_prts[index].p_port != NULL;  index++)
  421.     {
  422.     /*  check the dial out lines  */
  423.     (void) sprintf (desc, "0%o %.25s", d_prts[index].p_speed,
  424.         d_prts[index].p_ltype);
  425.     que (LEVEL5, subhdrfmt, d_prts[index].p_port, desc);
  426.     qflush (LEVEL5);
  427.  
  428.     /*  verify that the device exists  */
  429.     if (stat (d_prts[index].p_port, &statbuf) < 0)
  430.         que (LEVEL1, probfmt, "No port", xerrstr());
  431.     else
  432.         que (LEVEL7, "\tPort exists\n");
  433.     qflush (LEVEL7);
  434.  
  435.     /*  make sure it is not enabled  */
  436.     result = getttynam (&data, &d_prts[index].p_port[5]);
  437.     if (result == BADDATA)
  438.         que (LEVEL1, "No listing        : Port not in /etc/ttys\n");
  439.     else
  440.         if (data.t_valid == 0)
  441.         que (LEVEL7, "\tPort is set correctly (disabled)\n");
  442.         else
  443.         que (LEVEL1, "Wrong state      : Port should not be enabled\n");
  444.     qflush (LEVEL7);
  445.  
  446.     /*  make sure the lines dialer exists  */
  447.     if (stat (d_prts[index].p_acu, &statbuf) < 0)
  448.         que (LEVEL1P, "No dialer         : (%s)\n", d_prts[index].p_acu);
  449.     else
  450.         que (LEVEL7, "\tDialer (%s) exists\n", d_prts[index].p_acu);
  451.  
  452.     qflush (LEVEL5);
  453.     }
  454.     if (index == 0)
  455.     {
  456.     que (LEVEL5, subhdrfmt, "None", "");
  457.     qflush (LEVEL5);
  458.     }
  459. }
  460. /* */
  461.  
  462. chk_dirlin()
  463. { 
  464.     register int index, ret;
  465.     struct ttys ttybuf;
  466.  
  467.     for (index = 0;  d_lines[index].l_name != 0;  index++)
  468.     {
  469.     que (LEVEL5, subhdrfmt, d_lines[index].l_name, d_lines[index].l_tty);
  470.     qflush (LEVEL5);
  471.  
  472.     /*  verify that the device exists  */
  473.     if (stat (d_lines[index].l_tty, &statbuf) < 0)
  474.         que (LEVEL1, probfmt, "No line", xerrstr());
  475.     else
  476.         que (LEVEL7, "\tLine exists\n");
  477.     qflush (LEVEL7);
  478.  
  479.     /*  Is the line disabled?  */
  480.     ret = getttynam (&ttybuf, &d_lines[index].l_tty[5]);
  481.     if (ret == BADDATA)
  482.         que (LEVEL1, "No listing        : Line not in /etc/ttys\n");
  483.     else
  484.         if (ttybuf.t_valid == 0)
  485.         que (LEVEL7, "\tLine setup correctly (disabled)\n");
  486.         else
  487.         que (LEVEL1,
  488.             "Wrong state       : Line must NOT be enabled for terminal login\n");
  489.  
  490.     qflush (LEVEL5);
  491.     }
  492.     if (index == 0)
  493.     {
  494.     que (LEVEL5, subhdrfmt, "None", "");
  495.     qflush (LEVEL5);
  496.     }
  497. }
  498. #endif /* NODIAL */
  499. /* */
  500.  
  501. chklog ()
  502. {
  503.  
  504.     que (LEVEL7, "\n(changing into log directory...)\n");
  505.     qflush (LEVEL6);
  506.  
  507.     if (chdir (logdfldir) < OK)
  508.     {
  509.     que (LEVEL1, probfmt, "cannot chdir", xerrstr());
  510.     return;
  511.     }
  512.  
  513.     que (LEVEL6, subhdrfmt, "message-level log", msglog.ll_file);
  514.     chkfile (msglog.ll_file, 0622, 0666, mmdfuid, mmdfgid, mmdflogin);
  515.     qflush (LEVEL6);
  516.  
  517.     que (LEVEL6, subhdrfmt, "channel log", chanlog.ll_file);
  518.     chkfile (chanlog.ll_file, 0622, 0666, mmdfuid, mmdfgid, mmdflogin);
  519.     qflush (LEVEL6);
  520.  
  521. #ifndef NODIAL
  522.     que (LEVEL6, subhdrfmt, "phone (link) log", ph_log.ll_file);
  523.     chkfile (ph_log.ll_file, 0622, 0666, mmdfuid, mmdfgid, mmdflogin);
  524.     qflush (LEVEL6);
  525. #endif /* NODIAL */
  526. }
  527. /* */
  528.  
  529. chktab ()
  530. {
  531.     int didone;
  532.     register int ind, n;
  533.  
  534.     que (LEVEL7, "\n(changing into table directory...)\n");
  535.     qflush (LEVEL6);
  536.  
  537.     if (chdir (tbldfldir) < OK)
  538.     {
  539.     que (LEVEL1, probfmt, "cannot chdir", xerrstr());
  540.     return;
  541.     }
  542.  
  543.     que (LEVEL4, "\nChannel name tables & associated system entries:\n");
  544.     for (ind = 0; ch_tbsrch[ind] != (Chan *) 0; ind++)
  545.     {
  546.     if (ind > 0)
  547.         que (LEVEL5, "\n");
  548.     que (LEVEL5, subhdrfmt, ch_tbsrch[ind] -> ch_show,
  549.             ch_tbsrch[ind] -> ch_name);
  550.     que (LEVEL6, subhdrfmt, "Queue name", ch_tbsrch[ind] -> ch_queue);
  551.     qflush (LEVEL6);
  552.  
  553.     /*  verify that ch_name is legal, ie, less than 8 chars
  554.      *  long, and containing only alphanumerics or -.
  555.      */
  556.     for (n = 0;  ch_tbsrch[ind] -> ch_name[n] != '\0';  n++)
  557.         if( ((isalnum (ch_tbsrch[ind] -> ch_name[n]) == 0) &&
  558.          (ch_tbsrch[ind] -> ch_name[n] != '-'      )   ) ||
  559.         (n > 8                                          )   )
  560.         break;
  561.     /*  make sure the loop terminated normally  */
  562.     if (n > 8)
  563.         que (LEVEL1, "Long name         : '%s' should be 8 or fewer characters\n",
  564.             ch_tbsrch[ind] -> ch_name);
  565.     else
  566.         if (ch_tbsrch[ind] -> ch_name[n] != '\0')
  567.         que (LEVEL1, "Illegal char      : (%c) in '%s'\n",
  568.             ch_tbsrch[ind] -> ch_name[n], ch_tbsrch[ind] -> ch_name);
  569.  
  570.     que (LEVEL6, subhdrfmt, "  Local host name",
  571.                     ch_tbsrch[ind] -> ch_lname);
  572.     que (LEVEL6, subhdrfmt, "  Local domain name",
  573.                     ch_tbsrch[ind] -> ch_ldomain);
  574.     qflush (LEVEL6);
  575.  
  576.     cktable (ch_tbsrch[ind] -> ch_table, "Channel table");
  577.  
  578.     if (ch_tbsrch[ind] -> ch_indest != (Table *) 0)
  579.         cktable (ch_tbsrch[ind] -> ch_indest, "Destination filter");
  580.  
  581.     if (ch_tbsrch[ind] -> ch_outdest != (Table *) 0)
  582.         cktable (ch_tbsrch[ind] -> ch_outdest, "Destination filter");
  583.  
  584.     if (ch_tbsrch[ind] -> ch_insource != (Table *) 0)
  585.         cktable (ch_tbsrch[ind] -> ch_insource, "Source filter");
  586.  
  587.     if (ch_tbsrch[ind] -> ch_outsource != (Table *) 0)
  588.         cktable (ch_tbsrch[ind] -> ch_outsource, "Source filter");
  589.  
  590.     if (ch_tbsrch[ind] -> ch_known != (Table *) 0)
  591.         cktable (ch_tbsrch[ind] -> ch_known, "Table of known hosts");
  592.  
  593.     if (ch_tbsrch[ind] -> ch_script != 0)
  594.     {
  595.         que (LEVEL6, subhdrfmt, "Dialing script",
  596.                     ch_tbsrch[ind] -> ch_script);
  597.         if (stat (ch_tbsrch[ind] -> ch_script, &statbuf) < OK)
  598.         que (LEVEL1, probfmt, "cannot stat", xerrstr());
  599.         qflush (LEVEL6);
  600.     }
  601.  
  602.     if (ch_tbsrch[ind] -> ch_trans != (char *) DEFTRANS)
  603.     {
  604.         que (LEVEL6, subhdrfmt, "Phone transcript",
  605.                 ch_tbsrch[ind] -> ch_trans );
  606.         qflush (LEVEL6);
  607.     }
  608.     if (ch_tbsrch[ind] -> ch_login != NOLOGIN)
  609.         chklogin (ch_tbsrch[ind]);
  610.     qflush (LEVEL5);
  611.     }
  612.     qflush (LEVEL4);
  613.  
  614.     que (LEVEL4, hdrfmt, "Domain tables", "");
  615.     for (didone = FALSE, ind = 0; dm_list[ind] != (Domain *) 0; ind++)
  616.     {
  617.     if (dm_list[ind] -> dm_table -> tb_fp == (FILE *) NOTOK)
  618.         continue;
  619.     didone = TRUE;
  620.     que (LEVEL5, subhdrfmt,
  621.          isstr(dm_list[ind] -> dm_domain) ? dm_list[ind] -> dm_domain : "(root)",
  622.          dm_list[ind] -> dm_show);
  623.  
  624.     /*  verify that spec is legal, containing only alphanumerics or -.
  625.      */
  626.     for (n = 0;  dm_list[ind] -> dm_domain[n] != '\0';  n++)
  627.         if( ((isalnum (dm_list[ind] -> dm_domain[n]) == 0) &&
  628.          (dm_list[ind] -> dm_domain[n] != '-'      )  &&
  629.          (dm_list[ind] -> dm_domain[n] != '.'      )   ) )
  630.         break;
  631.  
  632.     /*  make sure the loop terminated normally  */
  633.     if (dm_list[ind] -> dm_domain[n] != '\0')
  634.         que (LEVEL1, "Illegal char      : (%c) in '%s'\n",
  635.         dm_list[ind] -> dm_domain[n], dm_list[ind] -> dm_domain);
  636.  
  637.     cktable(dm_list[ind] -> dm_table, "");
  638.     qflush (LEVEL5);
  639.     }
  640.     if (!didone)
  641.     {
  642.     que (LEVEL5, subhdrfmt, "None", "");
  643.     qflush (LEVEL5);
  644.     }
  645.  
  646.     que (LEVEL4, hdrfmt, "Additional tables", "");
  647.     for (didone = FALSE, ind = 0; tb_list[ind] != (Table *) 0; ind++)
  648.     {
  649.     if (tb_list[ind] -> tb_fp == (FILE *) NOTOK)
  650.         continue;           /* already done */
  651.  
  652.     didone = TRUE;
  653.     que (LEVEL5, subhdrfmt, tb_list[ind] -> tb_show,
  654.                 tb_list[ind] -> tb_name);
  655.  
  656.     /*  verify that spec is legal, ie, less than 8 chars
  657.      *  long, and containing only alphanumerics or -.
  658.      */
  659.     for (n = 0;  tb_list[ind] -> tb_name[n] != '\0';  n++)
  660.         if( ((isalnum (tb_list[ind] -> tb_name[n]) == 0) &&
  661.          (tb_list[ind] -> tb_name[n] != '-'      )   &&
  662.          (tb_list[ind] -> tb_name[n] != '.'      )   ) )
  663.         break;
  664.  
  665.     /*  make sure the loop terminated normally  */
  666.     if (tb_list[ind] -> tb_name[n] != '\0')
  667.         que (LEVEL1, "Illegal char      : (%c) in '%s'\n",
  668.         tb_list[ind] -> tb_name[n], tb_list[ind] -> tb_name);
  669.  
  670.         cktable (tb_list[ind], "");
  671.     qflush (LEVEL5);
  672.     }
  673.     if (!didone)
  674.     {
  675.     que (LEVEL5, subhdrfmt, "None", "");
  676.     qflush (LEVEL5);
  677.     }
  678.     qflush (LEVEL4);
  679. }
  680. /* */
  681.  
  682. cktable(tb, title)
  683. register Table *tb;
  684. register char *title;
  685. {
  686.     struct stat statbuf;
  687.  
  688.     tb -> tb_fp = (FILE *) NOTOK;    /* flag this table as processed */
  689.     if ((tb -> tb_flags&TB_SRC) == TB_NS) {
  690.     que (LEVEL6, subhdrfmt, title, "(via nameserver)");
  691.         return;
  692.     } else {
  693.     que (LEVEL6, subhdrfmt, title, tb -> tb_file);
  694.     if (stat (tb -> tb_file, &statbuf) < OK)
  695.         que (LEVEL1, probfmt, "cannot stat", xerrstr());
  696.     }
  697.     qflush (LEVEL6);
  698. }
  699.  
  700. chklogin (chanptr)
  701. Chan *chanptr;
  702. {
  703.     register char *name;
  704.     struct passwd *ret, *getpwnam ();
  705.     char slaveloc[FILNSIZE];
  706.     int mode;
  707.  
  708.     /*  transfer to a more accessable variable  */
  709.     name = chanptr -> ch_login;
  710.  
  711.     /*  verify that there is a login for this channel  */
  712.     ret = getpwnam (name);
  713.     if (ret == NULL)
  714.     {
  715.     que (LEVEL1, "No login          : for '%s'\n", name);
  716.     return;
  717.     }
  718.  
  719.     que (LEVEL6, subhdrfmt, "Login name", name);
  720.     chkalias (name);            /*  make sure the name is aliased  */
  721.     qflush (LEVEL6);
  722.  
  723.     /*  make sure the login program is the standard slave program  */
  724.     if ((initstr("pobox", chanptr -> ch_ppath, 5) != (-1)) &&
  725.     ((chanptr -> ch_access & DLVRPSV) != 0        )   )
  726.     {
  727.     strcat(strcpy(slaveloc,cmddfldir), "/slave");
  728.     if (strcmp (ret -> pw_shell, slaveloc) != 0)
  729.         que (LEVEL1, "Bad login prog    : '%s' is not phonenet slave\n",
  730.                 ret -> pw_shell);
  731.     else
  732.         que (LEVEL6, subhdrfmt, "Login program", ret -> pw_shell);
  733.     qflush (LEVEL6);
  734.     }
  735.     else
  736.     que (LEVEL6_5, "\t[ Login program : %s ]\n", ret -> pw_shell);
  737.     qflush (LEVEL6_5);
  738.  
  739.     /*  verify that the login directory exists and check protections  */
  740.     if (stat (ret -> pw_dir, &statbuf) < OK)
  741.     {
  742.     que (LEVEL1P, "Bad login dir     : Couldn't stat '%s'; ",
  743.             ret -> pw_dir);
  744.     return;
  745.     }
  746.  
  747.     mode = statbuf.st_mode & 04777;
  748.     if ((mode&06707) != 0701)
  749.     que (LEVEL1, "Wrong mode        : (0%o) on login directory; should be 711\n",
  750.             mode, ret -> pw_dir);
  751. }
  752. /* */
  753.  
  754. chkalias (name)
  755. char *name;
  756. {
  757.     int flags;
  758.     char alias[LINESIZE];
  759.  
  760.     if (aliasfetch(TRUE, name, alias, &flags) == OK) {
  761.     if ((flags & (AL_PUBLIC | AL_NOBYPASS)) == (AL_PUBLIC | AL_NOBYPASS))
  762.         que (LEVEL1, "Public alias      : '%s' (** normally not public)\n",
  763.           alias);
  764.     else if ((flags & AL_PUBLIC) == AL_PUBLIC)
  765.         que (LEVEL1, 
  766.          "Public, bypassable\n**    alias             : '%s' (** normally neither)\n",
  767.         alias);
  768.     else if ((flags & AL_NOBYPASS) == AL_NOBYPASS)
  769.         que (LEVEL6, subhdrfmt, "Alias value", alias);
  770.     else
  771.             que (LEVEL1, "Bypassable alias  : '%s' (** normally not bypassable)\n",
  772.           alias);
  773.    } else {
  774.     que (LEVEL1, "No mail alias     : for address '%s'\n", name);
  775.     }
  776.     qflush (LEVEL6);
  777. }
  778.  
  779.  
  780.  
  781. /* */
  782.  
  783. chkcmd ()
  784. {
  785.     que (LEVEL7, "\n(changing into command library...)\n");
  786.     qflush (LEVEL7);
  787.  
  788.     if (chdir (cmddfldir) < OK)
  789.     {
  790.     que (LEVEL1, probfmt, "cannot chdir", xerrstr());
  791.     return;
  792.     }
  793.  
  794.     que (LEVEL6, subhdrfmt, "Posting/submission", pathsubmit);
  795.     chkfile (pathsubmit, 04711, 04755, mmdfuid, mmdfgid, mmdflogin);
  796.     qflush (LEVEL6);
  797.  
  798.     que (LEVEL6, subhdrfmt, "Delivery management", pathdeliver);
  799.     chkfile (pathdeliver, 04711, 04755, 0, rootgid, "root");
  800.     qflush (LEVEL6);
  801.  
  802.     if (strcmp (pathdeliver, pathpkup) != 0)
  803.     {
  804.     que (LEVEL6, subhdrfmt, "P.O. Box retrieval", pathpkup);
  805.     chkfile (pathpkup, 04711, 04755, 0, rootgid, "root");
  806.     qflush (LEVEL6);
  807.     }
  808.  
  809.     que (LEVEL6, subhdrfmt, "V6Mail (for notices)",
  810.         pathmail);
  811.     chkfile (pathmail, 0711, 0755, mmdfuid, mmdfgid, mmdflogin);
  812.     qflush (LEVEL6);
  813.  
  814.     que (LEVEL6, subhdrfmt, "cleanque", "Queue garbage cleaner");
  815.     chkfile ("cleanque", 04711, 04755, 0, rootgid, "root");
  816.     qflush (LEVEL6);
  817.  
  818.     que (LEVEL6, subhdrfmt, "checkque", "Queue status checker");
  819.     chkfile ("checkque", 04711, 04755, mmdfuid, mmdfgid, mmdflogin);
  820.     qflush (LEVEL6);
  821.  
  822.     que (LEVEL6, subhdrfmt, "setlogs", "Log cleanup shellfile");
  823.     chkfile ("setlogs", 0700, 0755, mmdfuid, mmdfgid, mmdflogin);
  824.     qflush (LEVEL6);
  825. }
  826. /* */
  827.  
  828. chkchan ()
  829. {
  830.     register int ind;
  831.     register Chan *chan;
  832.  
  833.     que (LEVEL7, "\n(changing into channel directory...)\n");
  834.     qflush (LEVEL7);
  835.  
  836.     que (BACKGROUND,"\t[ Some channels, such as Local, need to be setuid ]\n");
  837.     qflush (BACKGROUND);
  838.  
  839.     if (chdir (chndfldir) < OK)
  840.     que (LEVEL1, probfmt, "cannot chdir", xerrstr());
  841.     else
  842.     {
  843.     for (ind = 0; (chan = ch_tbsrch[ind]) != (Chan *) 0; ind++)
  844.     {
  845.         que (LEVEL5, subhdrfmt, chan -> ch_show, "");
  846.         if (chan -> ch_ppath[0] == '\0')
  847.         que (LEVEL1, "No channel prog\n");
  848.         else
  849.         {
  850.         que (LEVEL6, subhdrfmt, "Channel program",
  851.                     chan -> ch_ppath);
  852.         if (stat (chan -> ch_ppath, &statbuf) < OK)
  853.             que (LEVEL1, probfmt, "Can't stat prog", xerrstr());
  854.         qflush (LEVEL6);
  855.         }
  856.         if (chan -> ch_logfile) {
  857.             chan -> ch_logfile = dupfpath(chan -> ch_logfile, logdfldir);
  858.         que (LEVEL6, subhdrfmt, "logfile", chan -> ch_logfile);
  859.         chkfile (chan -> ch_logfile, 0622, 0666, mmdfuid, mmdfgid, mmdflogin);
  860.         qflush (LEVEL6);
  861.         }
  862.         qflush (LEVEL5);
  863.     }
  864.     }
  865. }
  866. /* */
  867.  
  868. chkfile (dirptr, maxprot, minprot, owner, group, ownname)
  869. register char *dirptr;
  870. int maxprot, minprot, owner, group;
  871. char ownname[];
  872. {
  873.     register char *nptr;
  874.     char partpath[128];
  875.  
  876.     /*  verify that I have been given a real path name  */
  877.     if (!isstr(dirptr))
  878.     {
  879.     que (LEVEL1, "useless filename\n");
  880.     return (NOTOK);
  881.     }
  882.  
  883.     /*  step through the path, stopping at /'s to check the
  884.      *  directory.
  885.      */
  886.     nptr = partpath;
  887.     while ((*nptr++ = *dirptr++) != '\0')
  888.     /*  Note that this checks the NEXT char, not the one just
  889.      *  transfered.
  890.      */
  891.     if (*dirptr == '/')
  892.     {
  893.         *nptr = '\0';
  894.         if (chkpath (PARTIAL, partpath, maxprot, minprot, owner, group, ownname) != OK)
  895.         return (NOTOK);
  896.     }
  897.  
  898.     /*  At this point the entire pathname has been transfered.
  899.      *  Check it (errors here are more serious than above.)
  900.      */
  901.     if (chkpath(FINAL, partpath, maxprot, minprot, owner, group, ownname) != OK)
  902.     return (NOTOK);
  903.     return (OK);
  904. }
  905. /* */
  906.  
  907. /*  Note that a return of OK from this routine indicates only
  908.  */
  909. /*ARGSUSED*/
  910. chkpath (control, name, maxprot, minprot, owner, group, ownname)
  911. int control;
  912. char *name;
  913. int maxprot, minprot, owner, group;
  914. char *ownname;
  915. {
  916.     struct passwd *pwdptr;
  917.     static char pathdone[MAXPATH][50];
  918.     register int n;
  919.  
  920.     /*  First, must check to see if the dir is statable.
  921.      *  A failure here must return NOTOK even if this dir
  922.      *  has been checked before.
  923.      */
  924.     if (stat (name, &statbuf) < OK)
  925.     {
  926.     que (LEVEL1, probfmt, "unable to stat", xerrstr());
  927.         if (control == PARTIAL)
  928.         que (LEVEL1, "Unable to proceed checking this path.\n");
  929.     return (NOTOK);
  930.     }
  931.  
  932.     /*  If this path has already been checked, then don't
  933.      *  do it again.  The repeated error msgs are annoying.
  934.      */
  935.     for (n = 0;  ((n < MAXPATH) && (pathdone[n][0] != '\0'));  n++)
  936.     if (strcmp (name, pathdone[n]) == 0)
  937.         return (OK);
  938.  
  939.     /*  save this name as one that has been checked  */
  940.     if (n < MAXPATH)
  941.     (void) strcpy (pathdone[n], name);
  942.  
  943.     /*  verify that the owner is correct  */
  944.     if (statbuf.st_uid != owner)
  945.     {
  946.     if ((pwdptr = getpwuid (statbuf.st_uid)) != NULL)
  947.     {
  948.         if (control == FINAL)
  949.         que (LEVEL1, "Wrong owner       : (%s) for '%s'; should be %s\n",
  950.             pwdptr -> pw_name, name, ownname);
  951.         else
  952.         que (LEVEL6_5, "\t[ Wrong owner   : (%s) for '%s'; should be %s ]\n",
  953.             pwdptr -> pw_name, name, ownname);
  954.     }
  955.     else
  956.     {
  957.         if (control == FINAL)
  958.         que (LEVEL1, "Wrong owner      : (uid %d) for '%s'; should be %s\n",
  959.                 statbuf.st_uid, name, ownname);
  960.         else
  961.         que (LEVEL6_5, "\t[ Wrong owner  : (uid %d) for '%s'; should be %s ]\n",
  962.                 statbuf.st_uid, name, ownname);
  963.     }
  964.     qflush (LEVEL6_5);
  965.     }
  966.  
  967.     /* 
  968.      *  Ingore bits that are site choice and not critical to operation.
  969.      */
  970.     if (control == PARTIAL) {
  971.         minprot |= 0111;
  972.         maxprot |= 0111;
  973.     }
  974.     statbuf.st_mode &= 06707;
  975.     minprot &= 06707;
  976.     maxprot &= 06707;
  977.     if ((statbuf.st_mode&(~minprot)) ||     /* Any extra bit on? */
  978.         (statbuf.st_mode&maxprot) != maxprot)    /* Any bits missing? */
  979.     {
  980.     if (control == FINAL)
  981.         que (LEVEL1, "Wrong mode        : (0%o) for '%s'; should be (0%o to 0%o)\n",
  982.             statbuf.st_mode, name, maxprot, minprot);
  983.     else
  984.         que (LEVEL6_5, "\t[ Wrong mode    : (0%o) for '%s'; should be (0%o to 0%o) ]\n",
  985.             statbuf.st_mode, name, maxprot, minprot);
  986.     qflush (LEVEL6_5);
  987.     }
  988.     return (OK);
  989. }
  990.  
  991. chktai ()
  992. {
  993.     if (mmtailor != (char *) 0)
  994.     {
  995.     if (stat (mmtailor, &statbuf) < OK)
  996.     {
  997.         que (LEVEL1, "No tailor file   : %s", mmtailor);
  998.         endit (NOTOK);
  999.     }
  1000.     else
  1001.         que (LEVEL4, hdrfmt, "Tailor file", mmtailor);
  1002.     qflush (LEVEL4);
  1003.     }
  1004. }
  1005. /* */
  1006.  
  1007. int prtmax;
  1008. struct prtque prtque[QUESIZ];
  1009.  
  1010. qflush (control)
  1011. int control;
  1012. {
  1013.     register int index, prtany;
  1014.  
  1015.     /*  determine if any of the queue should be output */
  1016.     for (prtany = index = 0;  index < prtmax;  index++)
  1017.     if (prtque[index].q_level <= verbosity)
  1018.     {
  1019.         prtany = 1;
  1020.         break;
  1021.     }
  1022.  
  1023.     if (prtany != 0)        /*  go through and print appropriate lines  */
  1024.     {
  1025.     for (index = 0;  index < prtmax;  index++)
  1026.         printf ("%s", prtque[index].q_text);
  1027.     prtmax = 0;            /* start over */
  1028.     }
  1029.     else
  1030.     {
  1031.     for (index = 0;     /* remove excess only */
  1032.         (index < prtmax) && (prtque[index].q_level < control);
  1033.         index++)
  1034.         ;
  1035.     prtmax = index;
  1036.     }
  1037.     return;
  1038. }
  1039.  
  1040. /*VARARGS1*/
  1041. que (control, msg, arga, argb, argc, argd)
  1042. int control;
  1043. char *msg, *arga, *argb, *argc, *argd;
  1044. {
  1045.     char tmp[128];
  1046.  
  1047.     if (prtmax < (QUESIZ-1))
  1048.     format (prtque[prtmax].q_text, control, msg, arga, argb, argc, argd);
  1049.     else
  1050.     {
  1051.     qflush (LEVEL0);
  1052.     printf ("Recompile this program with larger QUESIZ.\n");
  1053.     printf ("Queue overflow on:\n  ");
  1054.     format (tmp, control, msg, arga, argb, argc, argd);
  1055.     printf (tmp);
  1056.     exit (NOTOK);
  1057.     }
  1058.     prtque[prtmax].q_level = control & ~PERROR;
  1059.     if (prtque[prtmax].q_level <= verbosity)
  1060.     qflush (prtque[prtmax++].q_level);
  1061.     else
  1062.     prtmax++;
  1063.     return;
  1064. }
  1065. /* */
  1066.  
  1067. /*VARARGS2*/
  1068. format (buff, control, msg, arga, argb, argc, argd)
  1069. char buff[];
  1070. int control;
  1071. char *msg, *arga, *argb, *argc, *argd;
  1072. {
  1073.     register int n;
  1074.  
  1075.     switch (control&~PERROR)
  1076.     {
  1077.     case LEVEL1:
  1078.         (void) strncpy (buff, "**    ", 6);
  1079.         n = 6;
  1080.         break;
  1081.  
  1082.     default:
  1083.         n = 0;
  1084.     }
  1085.  
  1086.     (void) sprintf (&buff[n], msg, arga, argb, argc, argd);
  1087.  
  1088.     if ((control & PERROR) && (errno > 0)) {
  1089.         n = strlen(buff);
  1090.     (void) sprintf(&buff[n], " (%s)\n", xerrstr());
  1091.     }
  1092.  
  1093.     return;
  1094. }
  1095.  
  1096. char *
  1097. xerrstr()
  1098. {
  1099.     static char buff[64];
  1100.  
  1101.     if (errno > sys_nerr || errno < 0)
  1102.     (void) sprintf (buff, "Errno %d", errno);
  1103.     else
  1104.     (void) strcpy(buff, sys_errlist[errno]);
  1105.     return (buff);
  1106. }
  1107. /* */
  1108. /*ARGSUSED*/
  1109. post_tai (argc, argv)           /* let user know about unknowns tailor info */
  1110.     int argc;
  1111.     char *argv[];
  1112. {
  1113.     char errline[LINESIZE];
  1114.  
  1115.     arg2vstr (0, sizeof errline, errline, argv);
  1116.     if (tai_eptr == (char *) 0)
  1117.     {
  1118.     if (errno == 0)
  1119.         que (LEVEL1, "Unknown tailor    : '%s'\n", errline);
  1120.     else
  1121.         que (LEVEL1, "Tailor error      : '%s'\n", errline);
  1122.     }
  1123.     else                        /* problem with subfield, not field name */
  1124.     que (LEVEL1, "Tailor error      : with '%s' in line: '%s'\n",
  1125.             tai_eptr, errline);
  1126.  
  1127.     if (errno > 0 && errno <= sys_nerr)
  1128.     que (LEVEL1, "                  : [ %s ]\n", sys_errlist[errno]);
  1129.  
  1130.     errflg = TRUE;
  1131.  
  1132.     return (YES);   /* we like everthing */
  1133. }
  1134.  
  1135. endit (type)
  1136.     int type;
  1137. {
  1138.     qflush (LEVEL0);
  1139.     (void) fflush (stdout);
  1140.     exit (type);
  1141. }
  1142.