home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2646 / ultrix.syslogd.patches < prev   
Encoding:
Text File  |  1991-02-01  |  25.7 KB  |  1,089 lines
  1. *** pristine-syslogd.c    Thu Jan 31 11:58:58 1991
  2. --- syslogd.c    Thu Jan 31 13:29:47 1991
  3. ***************
  4. *** 24,30 ****
  5.   #endif /* not lint */
  6.   
  7.   #ifndef lint
  8. ! static char sccsid[] = "@(#)syslogd.c    5.42 (Berkeley) 6/29/90";
  9.   #endif /* not lint */
  10.   
  11.   /*
  12. --- 24,30 ----
  13.   #endif /* not lint */
  14.   
  15.   #ifndef lint
  16. ! static char sccsid[] = "@(#)syslogd.c    5.42 (Berkeley) 6/29/90, with ultrix/zephyr/COMPAT42 mods";
  17.   #endif /* not lint */
  18.   
  19.   /*
  20. ***************
  21. *** 47,52 ****
  22. --- 47,57 ----
  23.    * Author: Eric Allman
  24.    * extensive changes by Ralph Campbell
  25.    * more extensive changes by Eric Allman (again)
  26. + #ifdef ZEPHYR
  27. +  * changes for Zephyr and a little dynamic allocation 
  28. +  *    by Jon Rochlis (MIT), July 1987
  29. + #endif
  30. +  * COMPAT42 changes by John Kohl (MIT/DEC), December 1990
  31.    */
  32.   
  33.   #define    MAXLINE        1024        /* maximum line length */
  34. ***************
  35. *** 62,68 ****
  36. --- 67,75 ----
  37.   #include <sys/wait.h>
  38.   #include <sys/socket.h>
  39.   #include <sys/file.h>
  40. + #ifndef NO_KLOG
  41.   #include <sys/msgbuf.h>
  42. + #endif
  43.   #include <sys/uio.h>
  44.   #include <sys/un.h>
  45.   #include <sys/time.h>
  46. ***************
  47. *** 69,83 ****
  48. --- 76,101 ----
  49.   #include <sys/resource.h>
  50.   #include <sys/signal.h>
  51.   
  52. + #ifdef ZEPHYR
  53. + #include <zephyr/zephyr.h>
  54. + #else
  55.   #include <netinet/in.h>
  56. + #endif /* ZEPHYR */
  57.   #include <netdb.h>
  58.   
  59. + #ifdef macII
  60. + #include <sys/types.h>
  61. + #include <time.h>
  62. + #endif
  63. + 
  64.   #include <utmp.h>
  65.   #include <setjmp.h>
  66.   #include <stdio.h>
  67.   #include <ctype.h>
  68.   #include <string.h>
  69. + #ifdef POSIX
  70.   #include <unistd.h>
  71. + #endif
  72.   #include "pathnames.h"
  73.   
  74.   #define SYSLOG_NAMES
  75. ***************
  76. *** 88,97 ****
  77. --- 106,132 ----
  78.   char    *PidFile = _PATH_LOGPID;
  79.   char    ctty[] = _PATH_CONSOLE;
  80.   
  81. + #ifdef COMPAT42
  82. + struct in_addr localhostaddr;
  83. + #endif
  84. + 
  85.   #define FDMASK(fd)    (1 << (fd))
  86.   
  87.   #define    dprintf        if (Debug) printf
  88.   
  89. + #ifndef UT_NAMESIZE
  90. + #define UT_NAMESIZE    8
  91. + #endif
  92. + #ifndef _PATH_UTMP
  93. + #define _PATH_UTMP    UTMP_FILE
  94. + #endif
  95. + 
  96. + #ifdef ZEPHYR
  97. + #define UNAMESIZE    ANAME_SZ+INST_SZ+REALM_SZ /* 8 isn't good enough anymore */
  98. + #else
  99. + #define UNAMESIZE    UT_NAMESIZE
  100. + #endif
  101. + 
  102.   #define MAXUNAMES    20    /* maximum number of user names */
  103.   
  104.   /*
  105. ***************
  106. *** 115,121 ****
  107.       time_t    f_time;            /* time this was last written */
  108.       u_char    f_pmask[LOG_NFACILITIES+1];    /* priority mask */
  109.       union {
  110. !         char    f_uname[MAXUNAMES][UT_NAMESIZE+1];
  111.           struct {
  112.               char    f_hname[MAXHOSTNAMELEN+1];
  113.               struct sockaddr_in    f_addr;
  114. --- 150,156 ----
  115.       time_t    f_time;            /* time this was last written */
  116.       u_char    f_pmask[LOG_NFACILITIES+1];    /* priority mask */
  117.       union {
  118. !         char    f_uname[MAXUNAMES][UNAMESIZE+1];
  119.           struct {
  120.               char    f_hname[MAXHOSTNAMELEN+1];
  121.               struct sockaddr_in    f_addr;
  122. ***************
  123. *** 126,131 ****
  124. --- 161,167 ----
  125.       char    f_lasttime[16];            /* time of last occurrence */
  126.       char    f_prevhost[MAXHOSTNAMELEN+1];    /* host from which recd. */
  127.       int    f_prevpri;            /* pri of f_prevline */
  128. +     int    f_prevfac;            /* fac of f_prevline */
  129.       int    f_prevlen;            /* length of f_prevline */
  130.       int    f_prevcount;            /* repetition cnt of prevline */
  131.       int    f_repeatcount;            /* number of "repeated" msgs */
  132. ***************
  133. *** 151,160 ****
  134.   #define F_FORW        4        /* remote machine */
  135.   #define F_USERS        5        /* list of users */
  136.   #define F_WALL        6        /* everyone logged on */
  137.   
  138. ! char    *TypeNames[7] = {
  139.       "UNUSED",    "FILE",        "TTY",        "CONSOLE",
  140.       "FORW",        "USERS",    "WALL"
  141.   };
  142.   
  143.   struct    filed *Files;
  144. --- 187,202 ----
  145.   #define F_FORW        4        /* remote machine */
  146.   #define F_USERS        5        /* list of users */
  147.   #define F_WALL        6        /* everyone logged on */
  148. + #define F_ZEPHYR    7        /* use zephyr notification system */
  149.   
  150. ! char    *TypeNames[8] = {
  151.       "UNUSED",    "FILE",        "TTY",        "CONSOLE",
  152.       "FORW",        "USERS",    "WALL"
  153. + #ifdef ZEPHYR
  154. +     ,"ZEPHYR"
  155. + #else
  156. +     ,0
  157. + #endif
  158.   };
  159.   
  160.   struct    filed *Files;
  161. ***************
  162. *** 170,178 ****
  163. --- 212,276 ----
  164.   int    MarkInterval = 20 * 60;    /* interval between marks in seconds */
  165.   int    MarkSeq = 0;        /* mark sequence number */
  166.   
  167. + #ifdef ZEPHYR
  168. + ZNotice_t znotice;              /* for zephyr notices */
  169. + #endif
  170. + 
  171. + extern    int sys_nerr;
  172. + extern    char *sys_errlist[];
  173. + 
  174.   extern    int errno;
  175.   extern    char *ctime(), *index(), *calloc();
  176.   
  177. + #ifndef max
  178. + #define max(a,b) ((a) > (b) ? (a) : (b))
  179. + #endif
  180. + 
  181. + #ifdef ZEPHYR
  182. + 
  183. + /* private copies here, since the facility/priority names in the header file
  184. +    are not in numerical order, and we need a no-gap table */
  185. + 
  186. + CODE FacNames[] = {
  187. +     "kern",        LOG_KERN,
  188. +     "user",        LOG_USER,
  189. +     "mail",        LOG_MAIL,
  190. +     "daemon",    LOG_DAEMON,
  191. +     "auth",        LOG_AUTH,
  192. +     "syslog",    LOG_SYSLOG,
  193. +     "lpr",        LOG_LPR,
  194. +     "news",        LOG_NEWS,
  195. +     "uucp",        LOG_UUCP,
  196. +     "cron",     LOG_CRON,
  197. +     "reserved",    -1,
  198. +     "reserved",    -1,
  199. +     "reserved",    -1,
  200. +     "reserved",    -1,
  201. +     "reserved",    -1,
  202. +     "compat",    LOG_COMPAT,
  203. +     "local0",    LOG_LOCAL0,
  204. +     "local1",    LOG_LOCAL1,
  205. +     "local2",    LOG_LOCAL2,
  206. +     "local3",    LOG_LOCAL3,
  207. +     "local4",    LOG_LOCAL4,
  208. +     "local5",    LOG_LOCAL5,
  209. +     "local6",    LOG_LOCAL6,
  210. +     "local7",    LOG_LOCAL7,
  211. +     NULL,        -1,
  212. + };
  213. + CODE PriNames[] = {
  214. +     "emerg",    LOG_EMERG,
  215. +     "alert",    LOG_ALERT,
  216. +     "crit",        LOG_CRIT,
  217. +     "err",        LOG_ERR,
  218. +     "warning",    LOG_WARNING,
  219. +     "notice",    LOG_NOTICE,
  220. +     "info",        LOG_INFO,
  221. +     "debug",    LOG_DEBUG,
  222. +     NULL,        -1,
  223. + };
  224. + #endif
  225. + 
  226.   main(argc, argv)
  227.       int argc;
  228.       char **argv;
  229. ***************
  230. *** 184,193 ****
  231.       struct sockaddr_in sin, frominet;
  232.       FILE *fp;
  233.       int ch;
  234. !     char line[MSG_BSIZE + 1];
  235.       extern int optind;
  236.       extern char *optarg;
  237.       void die(), domark(), init(), reapchild();
  238.   
  239.       while ((ch = getopt(argc, argv, "df:m:p:")) != EOF)
  240.           switch((char)ch) {
  241. --- 282,298 ----
  242.       struct sockaddr_in sin, frominet;
  243.       FILE *fp;
  244.       int ch;
  245. ! #ifdef MSG_BSIZE
  246. !     char line[max(MSG_BSIZE,BUFSIZ) + 1];
  247. ! #else
  248. !     char line[BUFSIZ + 1];
  249. ! #endif
  250.       extern int optind;
  251.       extern char *optarg;
  252.       void die(), domark(), init(), reapchild();
  253. + #ifdef COMPAT42
  254. +     localhostaddr.s_addr = htonl(0x7f000001L); /* 127.0.0.1 */
  255. + #endif
  256.   
  257.       while ((ch = getopt(argc, argv, "df:m:p:")) != EOF)
  258.           switch((char)ch) {
  259. ***************
  260. *** 212,219 ****
  261.   
  262.       if (!Debug)
  263.           daemon(0, 0);
  264. !     else
  265. !         setlinebuf(stdout);
  266.   
  267.       consfile.f_type = F_CONSOLE;
  268.       (void) strcpy(consfile.f_un.f_fname, ctty);
  269. --- 317,330 ----
  270.   
  271.       if (!Debug)
  272.           daemon(0, 0);
  273. !     else {
  274. ! #ifndef macII
  275. !           setlinebuf(stdout);
  276. ! #else
  277. !         static char buf[BUFSIZ];
  278. !         setvbuf (stdout, buf, _IOLBF, BUFSIZ);
  279. ! #endif
  280. !     }
  281.   
  282.       consfile.f_type = F_CONSOLE;
  283.       (void) strcpy(consfile.f_un.f_fname, ctty);
  284. ***************
  285. *** 225,232 ****
  286. --- 336,354 ----
  287.       else
  288.           LocalDomain = "";
  289.       (void) signal(SIGTERM, die);
  290. + #ifdef ultrix
  291. +     /* compiler otherwise chokes on the ? : */
  292. +     if (Debug) {
  293. +         (void) signal(SIGINT, die);
  294. +         (void) signal(SIGQUIT, die);
  295. +     } else {
  296. +         (void) signal(SIGINT, SIG_IGN);
  297. +         (void) signal(SIGQUIT, SIG_IGN);
  298. +     }
  299. + #else
  300.       (void) signal(SIGINT, Debug ? die : SIG_IGN);
  301.       (void) signal(SIGQUIT, Debug ? die : SIG_IGN);
  302. + #endif
  303.       (void) signal(SIGCHLD, reapchild);
  304.       (void) signal(SIGALRM, domark);
  305.       (void) alarm(TIMERINTVL);
  306. ***************
  307. *** 237,243 ****
  308.       (void) strncpy(sunx.sun_path, LogName, sizeof sunx.sun_path);
  309.       funix = socket(AF_UNIX, SOCK_DGRAM, 0);
  310.       if (funix < 0 || bind(funix, (struct sockaddr *) &sunx,
  311. !         sizeof(sunx.sun_family)+sizeof(sunx.sun_len)+
  312.           strlen(sunx.sun_path)) < 0 ||
  313.           chmod(LogName, 0666) < 0) {
  314.           (void) sprintf(line, "cannot create %s", LogName);
  315. --- 359,368 ----
  316.       (void) strncpy(sunx.sun_path, LogName, sizeof sunx.sun_path);
  317.       funix = socket(AF_UNIX, SOCK_DGRAM, 0);
  318.       if (funix < 0 || bind(funix, (struct sockaddr *) &sunx,
  319. !         sizeof(sunx.sun_family)+
  320. ! #ifdef TAHOE_SOCKETS
  321. !         sizeof(sunx.sun_len)+
  322. ! #endif
  323.           strlen(sunx.sun_path)) < 0 ||
  324.           chmod(LogName, 0666) < 0) {
  325.           (void) sprintf(line, "cannot create %s", LogName);
  326. ***************
  327. *** 266,271 ****
  328. --- 391,400 ----
  329.               InetInuse = 1;
  330.           }
  331.       }
  332. + #ifdef NO_KLOG
  333. +     klogm = 0;
  334. +     fklog = 0;
  335. + #else
  336.       if ((fklog = open(_PATH_KLOG, O_RDONLY, 0)) >= 0)
  337.           klogm = FDMASK(fklog);
  338.       else {
  339. ***************
  340. *** 272,277 ****
  341. --- 401,407 ----
  342.           dprintf("can't open %s (%d)\n", _PATH_KLOG, errno);
  343.           klogm = 0;
  344.       }
  345. + #endif
  346.   
  347.       /* tuck my process id away */
  348.       fp = fopen(PidFile, "w");
  349. ***************
  350. *** 282,287 ****
  351. --- 412,427 ----
  352.   
  353.       dprintf("off & running....\n");
  354.   
  355. + #ifdef ZEPHYR
  356. +     /* initialize zephyr stuff */
  357. +     bzero (&znotice, sizeof (znotice));
  358. +     znotice.z_kind = UNSAFE;
  359. +     znotice.z_class = "SYSLOG";
  360. +     znotice.z_class_inst = LocalHostName;
  361. +     znotice.z_default_format = "Syslog message from $instance, level $opcode:\n$message";
  362. +     (void) ZInitialize ();
  363. + #endif
  364. + 
  365.       init();
  366.       (void) signal(SIGHUP, init);
  367.   
  368. ***************
  369. *** 317,323 ****
  370.                   (struct sockaddr *) &fromunix, &len);
  371.               if (i > 0) {
  372.                   line[i] = '\0';
  373. !                 printline(LocalHostName, line);
  374.               } else if (i < 0 && errno != EINTR)
  375.                   logerror("recvfrom unix");
  376.           }
  377. --- 457,463 ----
  378.                   (struct sockaddr *) &fromunix, &len);
  379.               if (i > 0) {
  380.                   line[i] = '\0';
  381. !                 printline(LocalHostName, line, 0);
  382.               } else if (i < 0 && errno != EINTR)
  383.                   logerror("recvfrom unix");
  384.           }
  385. ***************
  386. *** 329,335 ****
  387.                   extern char *cvthname();
  388.   
  389.                   line[i] = '\0';
  390. !                 printline(cvthname(&frominet), line);
  391.               } else if (i < 0 && errno != EINTR)
  392.                   logerror("recvfrom inet");
  393.           } 
  394. --- 469,483 ----
  395.                   extern char *cvthname();
  396.   
  397.                   line[i] = '\0';
  398. ! #ifdef COMPAT42
  399. !                 /* if it matches the localhost loopback,
  400. !                    this is an old client, so humor him. */
  401. !                 if (frominet.sin_addr.s_addr ==
  402. !                     localhostaddr.s_addr)
  403. !                     printline(cvthname(&frominet), line, 1);
  404. !                 else
  405. ! #endif
  406. !                     printline(cvthname(&frominet), line, 0);
  407.               } else if (i < 0 && errno != EINTR)
  408.                   logerror("recvfrom inet");
  409.           } 
  410. ***************
  411. *** 343,356 ****
  412.       exit(1);
  413.   }
  414.   
  415.   /*
  416.    * Take a raw input line, decode the message, and print the message
  417.    * on the appropriate log files.
  418.    */
  419.   
  420. ! printline(hname, msg)
  421.       char *hname;
  422.       char *msg;
  423.   {
  424.       register char *p, *q;
  425.       register int c;
  426. --- 491,522 ----
  427.       exit(1);
  428.   }
  429.   
  430. + #ifdef COMPAT42
  431. + int convert_oldpri[] = {
  432. +     LOG_COMPAT|LOG_EMERG,        /* there is no 0 */
  433. +     LOG_COMPAT|LOG_ALERT,        /* old LOG_ALERT */
  434. +     LOG_COMPAT|LOG_ALERT,        /* old LOG_SALERT */
  435. +     LOG_COMPAT|LOG_CRIT,        /* old LOG_EMERG */
  436. +     LOG_COMPAT|LOG_ERR,            /* old LOG_ERROR */
  437. +     LOG_COMPAT|LOG_WARNING,        /* old LOG_CRIT */
  438. +     LOG_COMPAT|LOG_WARNING,        /* old LOG_WARNING */
  439. +     LOG_COMPAT|LOG_NOTICE,        /* old LOG_NOTICE */
  440. +     LOG_COMPAT|LOG_INFO,        /* old LOG_INFO */
  441. +     LOG_COMPAT|LOG_DEBUG,        /* old LOG_DEBUG */
  442. + };
  443. + int noldpri = sizeof(convert_oldpri)/sizeof(convert_oldpri[0]);
  444. + #endif
  445. + 
  446. + 
  447.   /*
  448.    * Take a raw input line, decode the message, and print the message
  449.    * on the appropriate log files.
  450.    */
  451.   
  452. ! printline(hname, msg, oldcompat)
  453.       char *hname;
  454.       char *msg;
  455. +     int oldcompat;
  456.   {
  457.       register char *p, *q;
  458.       register int c;
  459. ***************
  460. *** 367,372 ****
  461. --- 533,546 ----
  462.           if (*p == '>')
  463.               ++p;
  464.       }
  465. + #ifdef COMPAT42
  466. +     if (oldcompat) {
  467. +         if (pri > 0 && pri < noldpri)
  468. +         pri = convert_oldpri[pri];
  469. +         else
  470. +         pri = LOG_MAKEPRI(LOG_COMPAT, LOG_ERR);
  471. +     }
  472. + #endif
  473.       if (pri &~ (LOG_FACMASK|LOG_PRIMASK))
  474.           pri = DEFUPRI;
  475.   
  476. ***************
  477. *** 435,440 ****
  478. --- 609,630 ----
  479.   
  480.   time_t    now;
  481.   
  482. + #ifndef O_NOCTTY
  483. + void
  484. + untty()
  485. + {
  486. +     int i;
  487. + 
  488. +     if (!Debug) {
  489. +         i = open("/dev/tty", O_RDWR);
  490. +         if (i >= 0) {
  491. +             (void) ioctl(i, (int) TIOCNOTTY, (char *)0);
  492. +             (void) close(i);
  493. +         }
  494. +     }
  495. + }
  496. + #endif
  497. + 
  498.   /*
  499.    * Log a message to the appropriate log files, users, etc. based on
  500.    * the priority.
  501. ***************
  502. *** 483,492 ****
  503.       /* log the message to the particular outputs */
  504.       if (!Initialized) {
  505.           f = &consfile;
  506.           f->f_file = open(ctty, O_WRONLY, 0);
  507.   
  508.           if (f->f_file >= 0) {
  509. !             fprintlog(f, flags, msg);
  510.               (void) close(f->f_file);
  511.           }
  512.           (void) sigsetmask(omask);
  513. --- 673,689 ----
  514.       /* log the message to the particular outputs */
  515.       if (!Initialized) {
  516.           f = &consfile;
  517. + #ifdef O_NOCTTY
  518. +         f->f_file = open(ctty, O_WRONLY|O_NOCTTY, 0);
  519. + #else
  520.           f->f_file = open(ctty, O_WRONLY, 0);
  521. + #endif
  522.   
  523.           if (f->f_file >= 0) {
  524. ! #ifndef O_NOCTTY
  525. !             untty();
  526. ! #endif
  527. !             fprintlog(f, flags, msg, fac, prilev);
  528.               (void) close(f->f_file);
  529.           }
  530.           (void) sigsetmask(omask);
  531. ***************
  532. *** 523,535 ****
  533.                * in the future.
  534.                */
  535.               if (now > REPEATTIME(f)) {
  536. !                 fprintlog(f, flags, (char *)NULL);
  537.                   BACKOFF(f);
  538.               }
  539.           } else {
  540.               /* new line, save it */
  541.               if (f->f_prevcount)
  542. !                 fprintlog(f, 0, (char *)NULL);
  543.               f->f_repeatcount = 0;
  544.               (void) strncpy(f->f_lasttime, timestamp, 15);
  545.               (void) strncpy(f->f_prevhost, from,
  546. --- 720,732 ----
  547.                * in the future.
  548.                */
  549.               if (now > REPEATTIME(f)) {
  550. !                 fprintlog(f, flags, (char *)NULL, fac, prilev);
  551.                   BACKOFF(f);
  552.               }
  553.           } else {
  554.               /* new line, save it */
  555.               if (f->f_prevcount)
  556. !                 fprintlog(f, 0, (char *)NULL, fac, prilev);
  557.               f->f_repeatcount = 0;
  558.               (void) strncpy(f->f_lasttime, timestamp, 15);
  559.               (void) strncpy(f->f_prevhost, from,
  560. ***************
  561. *** 537,548 ****
  562.               if (msglen < MAXSVLINE) {
  563.                   f->f_prevlen = msglen;
  564.                   f->f_prevpri = pri;
  565.                   (void) strcpy(f->f_prevline, msg);
  566. !                 fprintlog(f, flags, (char *)NULL);
  567.               } else {
  568.                   f->f_prevline[0] = 0;
  569.                   f->f_prevlen = 0;
  570. !                 fprintlog(f, flags, msg);
  571.               }
  572.           }
  573.       }
  574. --- 734,746 ----
  575.               if (msglen < MAXSVLINE) {
  576.                   f->f_prevlen = msglen;
  577.                   f->f_prevpri = pri;
  578. +                 f->f_prevfac = fac;
  579.                   (void) strcpy(f->f_prevline, msg);
  580. !                 fprintlog(f, flags, (char *)NULL, fac, prilev);
  581.               } else {
  582.                   f->f_prevline[0] = 0;
  583.                   f->f_prevlen = 0;
  584. !                 fprintlog(f, flags, msg, fac, prilev);
  585.               }
  586.           }
  587.       }
  588. ***************
  589. *** 549,570 ****
  590.       (void) sigsetmask(omask);
  591.   }
  592.   
  593. ! fprintlog(f, flags, msg)
  594.       register struct filed *f;
  595.       int flags;
  596.       char *msg;
  597.   {
  598.       struct iovec iov[6];
  599.       register struct iovec *v;
  600.       register int l;
  601.       char line[MAXLINE + 1], repbuf[80], greetings[200];
  602.   
  603.       v = iov;
  604.       if (f->f_type == F_WALL) {
  605.           v->iov_base = greetings;
  606. !         v->iov_len = sprintf(greetings,
  607.               "\r\n\7Message from syslogd@%s at %.24s ...\r\n",
  608.               f->f_prevhost, ctime(&now));
  609.           v++;
  610.           v->iov_base = "";
  611.           v->iov_len = 0;
  612. --- 747,776 ----
  613.       (void) sigsetmask(omask);
  614.   }
  615.   
  616. ! fprintlog(f, flags, msg, fac, prilev)
  617.       register struct filed *f;
  618.       int flags;
  619.       char *msg;
  620. +     int fac;
  621. +     int prilev;
  622.   {
  623.       struct iovec iov[6];
  624.       register struct iovec *v;
  625.       register int l;
  626.       char line[MAXLINE + 1], repbuf[80], greetings[200];
  627. + #ifdef ZEPHYR
  628. +     char pri_fac_str[MAXLINE];
  629. +     int zcode;
  630. +     register int i;
  631. + #endif
  632.   
  633.       v = iov;
  634.       if (f->f_type == F_WALL) {
  635.           v->iov_base = greetings;
  636. !         (void) sprintf(greetings,
  637.               "\r\n\7Message from syslogd@%s at %.24s ...\r\n",
  638.               f->f_prevhost, ctime(&now));
  639. +         v->iov_len = strlen(greetings);
  640.           v++;
  641.           v->iov_base = "";
  642.           v->iov_len = 0;
  643. ***************
  644. *** 589,596 ****
  645.           v->iov_len = strlen(msg);
  646.       } else if (f->f_prevcount > 1) {
  647.           v->iov_base = repbuf;
  648. !         v->iov_len = sprintf(repbuf, "last message repeated %d times",
  649.               f->f_prevcount);
  650.       } else {
  651.           v->iov_base = f->f_prevline;
  652.           v->iov_len = f->f_prevlen;
  653. --- 795,803 ----
  654.           v->iov_len = strlen(msg);
  655.       } else if (f->f_prevcount > 1) {
  656.           v->iov_base = repbuf;
  657. !         (void) sprintf(repbuf, "last message repeated %d times",
  658.               f->f_prevcount);
  659. +         v->iov_len = strlen(repbuf);
  660.       } else {
  661.           v->iov_base = f->f_prevline;
  662.           v->iov_len = f->f_prevlen;
  663. ***************
  664. *** 607,614 ****
  665.   
  666.       case F_FORW:
  667.           dprintf(" %s\n", f->f_un.f_forw.f_hname);
  668. !         l = sprintf(line, "<%d>%.15s %s", f->f_prevpri,
  669.               iov[0].iov_base, iov[4].iov_base);
  670.           if (l > MAXLINE)
  671.               l = MAXLINE;
  672.           if (sendto(finet, line, l, 0, &f->f_un.f_forw.f_addr,
  673. --- 814,822 ----
  674.   
  675.       case F_FORW:
  676.           dprintf(" %s\n", f->f_un.f_forw.f_hname);
  677. !         (void) sprintf(line, "<%d>%.15s %s", f->f_prevpri,
  678.               iov[0].iov_base, iov[4].iov_base);
  679. +         l = strlen(line);
  680.           if (l > MAXLINE)
  681.               l = MAXLINE;
  682.           if (sendto(finet, line, l, 0, &f->f_un.f_forw.f_addr,
  683. ***************
  684. *** 662,667 ****
  685. --- 870,905 ----
  686.               (void) fsync(f->f_file);
  687.           break;
  688.   
  689. + #ifdef ZEPHYR
  690. +              case F_ZEPHYR:
  691. +             (void) sprintf(line, "%.15s [%s] %s",
  692. +                        iov[0].iov_base,
  693. +                        iov[2].iov_base,
  694. +                        iov[4].iov_base);
  695. +             (void) sprintf(pri_fac_str, "%s.%s",
  696. +                        FacNames[fac].c_name,
  697. +                        PriNames[(prilev & LOG_PRIMASK)].c_name);
  698. +             znotice.z_message = line;
  699. +             /* include the null just in case */
  700. +             znotice.z_message_len = strlen (line) + 1;
  701. +             znotice.z_opcode = pri_fac_str;
  702. +             dprintf (" z_opcode %s\n", pri_fac_str);
  703. +             for (i = 0; i < MAXUNAMES; i++) {
  704. +               if (!f->f_un.f_uname[i][0]) 
  705. +                 break;
  706. +               /* map "*" into null recipient and therefore
  707. +                  anybody who is listening */
  708. +               if (strcmp (f->f_un.f_uname[i], "*") == 0)
  709. +                 znotice.z_recipient = "";
  710. +               else
  711. +                 znotice.z_recipient = f->f_un.f_uname[i];
  712. +               zcode = ZSendNotice (&znotice, ZNOAUTH); 
  713. +               if (zcode != 0)
  714. +                 logerror (error_message (zcode));
  715. +             }
  716. +             break;
  717. + #endif
  718. + 
  719.       case F_USERS:
  720.       case F_WALL:
  721.           dprintf("\n");
  722. ***************
  723. *** 752,757 ****
  724. --- 990,1000 ----
  725.           dprintf("Malformed from address\n");
  726.           return ("???");
  727.       }
  728. + #ifdef COMPAT42
  729. +     /* don't bother looking up 127.0.0.1, it's us. */
  730. +     if (f->sin_addr.s_addr == localhostaddr.s_addr)
  731. +         return(LocalHostName);
  732. + #endif
  733.       hp = gethostbyaddr(&f->sin_addr, sizeof(struct in_addr), f->sin_family);
  734.       if (hp == 0) {
  735.           dprintf("Host name for your address (%s) unknown\n",
  736. ***************
  737. *** 781,787 ****
  738.               dprintf("flush %s: repeated %d times, %d sec.\n",
  739.                   TypeNames[f->f_type], f->f_prevcount,
  740.                   repeatinterval[f->f_repeatcount]);
  741. !             fprintlog(f, 0, (char *)NULL);
  742.               BACKOFF(f);
  743.           }
  744.       }
  745. --- 1024,1030 ----
  746.               dprintf("flush %s: repeated %d times, %d sec.\n",
  747.                   TypeNames[f->f_type], f->f_prevcount,
  748.                   repeatinterval[f->f_repeatcount]);
  749. !             fprintlog(f, 0, (char *)NULL, f->f_prevfac, f->f_prevpri);
  750.               BACKOFF(f);
  751.           }
  752.       }
  753. ***************
  754. *** 814,820 ****
  755.       for (f = Files; f != NULL; f = f->f_next) {
  756.           /* flush any pending output */
  757.           if (f->f_prevcount)
  758. !             fprintlog(f, 0, (char *)NULL);
  759.       }
  760.       if (sig) {
  761.           dprintf("syslogd: exiting on signal %d\n", sig);
  762. --- 1057,1063 ----
  763.       for (f = Files; f != NULL; f = f->f_next) {
  764.           /* flush any pending output */
  765.           if (f->f_prevcount)
  766. !             fprintlog(f, 0, (char *)NULL, f->f_prevfac, f->f_prevpri);
  767.       }
  768.       if (sig) {
  769.           dprintf("syslogd: exiting on signal %d\n", sig);
  770. ***************
  771. *** 848,860 ****
  772.       for (f = Files; f != NULL; f = next) {
  773.           /* flush any pending output */
  774.           if (f->f_prevcount)
  775. !             fprintlog(f, 0, (char *)NULL);
  776.   
  777.           switch (f->f_type) {
  778.             case F_FILE:
  779.             case F_TTY:
  780.             case F_CONSOLE:
  781. -           case F_FORW:
  782.               (void) close(f->f_file);
  783.               break;
  784.           }
  785. --- 1091,1102 ----
  786.       for (f = Files; f != NULL; f = next) {
  787.           /* flush any pending output */
  788.           if (f->f_prevcount)
  789. !             fprintlog(f, 0, (char *)NULL, f->f_prevfac, f->f_prevpri);
  790.   
  791.           switch (f->f_type) {
  792.             case F_FILE:
  793.             case F_TTY:
  794.             case F_CONSOLE:
  795.               (void) close(f->f_file);
  796.               break;
  797.           }
  798. ***************
  799. *** 920,925 ****
  800. --- 1162,1168 ----
  801.                   break;
  802.   
  803.               case F_USERS:
  804. +             case F_ZEPHYR:
  805.                   for (i = 0; i < MAXUNAMES && *f->f_un.f_uname[i]; i++)
  806.                       printf("%s, ", f->f_un.f_uname[i]);
  807.                   break;
  808. ***************
  809. *** 1025,1031 ****
  810.           hp = gethostbyname(p);
  811.           if (hp == NULL) {
  812.               extern int h_errno, h_nerr;
  813. !             extern char **h_errlist;
  814.   
  815.               logerror((u_int)h_errno < h_nerr ?
  816.                   h_errlist[h_errno] : "Unknown error");
  817. --- 1268,1274 ----
  818.           hp = gethostbyname(p);
  819.           if (hp == NULL) {
  820.               extern int h_errno, h_nerr;
  821. !             extern char *h_errlist[];
  822.   
  823.               logerror((u_int)h_errno < h_nerr ?
  824.                   h_errlist[h_errno] : "Unknown error");
  825. ***************
  826. *** 1041,1064 ****
  827.   
  828.       case '/':
  829.           (void) strcpy(f->f_un.f_fname, p);
  830. !         if ((f->f_file = open(p, O_WRONLY|O_APPEND, 0)) < 0) {
  831.               f->f_file = F_UNUSED;
  832.               logerror(p);
  833.               break;
  834.           }
  835. !         if (isatty(f->f_file))
  836.               f->f_type = F_TTY;
  837. !         else
  838.               f->f_type = F_FILE;
  839.           if (strcmp(p, ctty) == 0)
  840.               f->f_type = F_CONSOLE;
  841.           break;
  842.   
  843.       case '*':
  844.           f->f_type = F_WALL;
  845.           break;
  846. ! 
  847. !     default:
  848.           for (i = 0; i < MAXUNAMES && *p; i++) {
  849.               for (q = p; *q && *q != ','; )
  850.                   q++;
  851. --- 1284,1322 ----
  852.   
  853.       case '/':
  854.           (void) strcpy(f->f_un.f_fname, p);
  855. ! #ifdef O_NOCTTY
  856. ! #define FLAGS O_WRONLY|O_APPEND|O_NOCTTY
  857. ! #else
  858. ! #define FLAGS O_WRONLY|O_APPEND
  859. ! #endif
  860. !         if ((f->f_file = open(p, FLAGS, 0)) < 0) {
  861. ! #undef FLAGS
  862.               f->f_file = F_UNUSED;
  863.               logerror(p);
  864.               break;
  865.           }
  866. !         if (isatty(f->f_file)) {
  867.               f->f_type = F_TTY;
  868. ! #ifndef O_NOCTTY
  869. !             untty();
  870. ! #endif
  871. !         } else
  872.               f->f_type = F_FILE;
  873.           if (strcmp(p, ctty) == 0)
  874.               f->f_type = F_CONSOLE;
  875.           break;
  876.   
  877. + #ifndef ZEPHYR
  878.       case '*':
  879.           f->f_type = F_WALL;
  880.           break;
  881. ! #else
  882. !     case '!':
  883. !         p++;
  884. !         if (*p == '*') {
  885. !         f->f_type = F_WALL;
  886. !         break;
  887. !         }
  888.           for (i = 0; i < MAXUNAMES && *p; i++) {
  889.               for (q = p; *q && *q != ','; )
  890.                   q++;
  891. ***************
  892. *** 1072,1077 ****
  893. --- 1330,1356 ----
  894.               p = q;
  895.           }
  896.           f->f_type = F_USERS;
  897. +         break;
  898. + #endif
  899. + 
  900. +     default:
  901. +         for (i = 0; i < MAXUNAMES && *p; i++) {
  902. +             for (q = p; *q && *q != ','; )
  903. +                 q++;
  904. +             (void) strncpy(f->f_un.f_uname[i], p, UNAMESIZE);
  905. +             if ((q - p) > UNAMESIZE)
  906. +                 f->f_un.f_uname[i][UNAMESIZE] = '\0';
  907. +             else
  908. +                 f->f_un.f_uname[i][q - p] = '\0';
  909. +             while (*q == ',' || *q == ' ')
  910. +                 q++;
  911. +             p = q;
  912. +         }
  913. + #ifdef ZEPHYR
  914. +         f->f_type = F_ZEPHYR;
  915. + #else
  916. +         f->f_type = F_USERS;
  917. + #endif
  918.           break;
  919.       }
  920.   }
  921. *** pristine-syslog.h    Thu Jan 31 12:18:55 1991
  922. --- syslog.h    Thu Jan 31 13:26:30 1991
  923. ***************
  924. *** 17,23 ****
  925.    * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  926.    * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  927.    *
  928. !  *    @(#)syslog.h    7.16 (Berkeley) 6/28/90
  929.    */
  930.   
  931.   /*
  932. --- 17,23 ----
  933.    * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  934.    * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  935.    *
  936. !  *    @(#)syslog.h    7.16 (Berkeley) 6/28/90, with COMPAT42 mods
  937.    */
  938.   
  939.   /*
  940. ***************
  941. *** 80,85 ****
  942. --- 80,86 ----
  943.   #define    LOG_NEWS    (7<<3)    /* network news subsystem */
  944.   #define    LOG_UUCP    (8<<3)    /* UUCP subsystem */
  945.   #define    LOG_CRON    (9<<3)    /* clock daemon */
  946. + #define    LOG_COMPAT    (15<<3)    /* compatibility with 4.2 syslog */
  947.       /* other codes through 15 reserved for system use */
  948.   #define    LOG_LOCAL0    (16<<3)    /* reserved for local use */
  949.   #define    LOG_LOCAL1    (17<<3)    /* reserved for local use */
  950. ***************
  951. *** 98,103 ****
  952. --- 99,105 ----
  953.   #ifdef SYSLOG_NAMES
  954.   CODE facilitynames[] = {
  955.       "auth",        LOG_AUTH,
  956. +     "compat",    LOG_COMPAT,
  957.       "cron",     LOG_CRON,
  958.       "daemon",    LOG_DAEMON,
  959.       "kern",        LOG_KERN,
  960. *** pristine-pathnames.h    Thu Jan 31 13:20:23 1991
  961. --- pathnames.h    Thu Jan 31 13:21:00 1991
  962. ***************
  963. *** 16,22 ****
  964.    * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  965.    * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  966.    *
  967. !  *    @(#)pathnames.h    5.3 (Berkeley) 6/1/90
  968.    */
  969.   
  970.   #include <paths.h>
  971. --- 16,22 ----
  972.    * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  973.    * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  974.    *
  975. !  *    @(#)pathnames.h    5.3 (Berkeley) 6/1/90, with COMPAT42 mods
  976.    */
  977.   
  978.   #include <paths.h>
  979. ***************
  980. *** 23,27 ****
  981. --- 23,32 ----
  982.   
  983.   #define    _PATH_KLOG    "/dev/klog"
  984.   #define    _PATH_LOG    "/dev/log"
  985. + #ifdef COMPAT42
  986. + #define    _PATH_LOGCONF    "/etc/nsyslog.conf"
  987. + #define    _PATH_LOGPID    "/etc/nsyslog.pid"
  988. + #else
  989.   #define    _PATH_LOGCONF    "/etc/syslog.conf"
  990.   #define    _PATH_LOGPID    "/var/run/syslog.pid"
  991. + #endif
  992. *** pristine-syslog.c    Thu Jan 31 13:49:38 1991
  993. --- syslog.c    Thu Jan 31 13:56:42 1991
  994. ***************
  995. *** 18,24 ****
  996.    */
  997.   
  998.   #if defined(LIBC_SCCS) && !defined(lint)
  999. ! static char sccsid[] = "@(#)syslog.c    5.28 (Berkeley) 6/27/90";
  1000.   #endif /* LIBC_SCCS and not lint */
  1001.   
  1002.   /*
  1003. --- 18,24 ----
  1004.    */
  1005.   
  1006.   #if defined(LIBC_SCCS) && !defined(lint)
  1007. ! static char sccsid[] = "@(#)syslog.c    5.28 (Berkeley) 6/27/90, with varags changes";
  1008.   #endif /* LIBC_SCCS and not lint */
  1009.   
  1010.   /*
  1011. ***************
  1012. *** 37,42 ****
  1013. --- 37,48 ----
  1014.    * Modified to use UNIX domain IPC by Ralph Campbell
  1015.    */
  1016.   
  1017. + #ifdef __STDC__
  1018. + #include <stdarg.h>
  1019. + #else
  1020. + #include <varargs.h>
  1021. + #endif
  1022. + 
  1023.   #include <sys/types.h>
  1024.   #include <sys/socket.h>
  1025.   #include <sys/file.h>
  1026. ***************
  1027. *** 46,52 ****
  1028.   #include <sys/wait.h>
  1029.   #include <netdb.h>
  1030.   #include <string.h>
  1031. - #include <varargs.h>
  1032.   #include <paths.h>
  1033.   #include <stdio.h>
  1034.   
  1035. --- 52,57 ----
  1036. ***************
  1037. *** 58,68 ****
  1038.   static char    *LogTag = "syslog";    /* string to tag the entry with */
  1039.   static int    LogFacility = LOG_USER;    /* default facility code */
  1040.   
  1041. ! syslog(pri, fmt, args)
  1042. !     int pri, args;
  1043. !     char *fmt;
  1044.   {
  1045. !     vsyslog(pri, fmt, &args);
  1046.   }
  1047.   
  1048.   vsyslog(pri, fmt, ap)
  1049. --- 63,85 ----
  1050.   static char    *LogTag = "syslog";    /* string to tag the entry with */
  1051.   static int    LogFacility = LOG_USER;    /* default facility code */
  1052.   
  1053. ! #ifdef __STDC__
  1054. ! syslog(int pri, const char *fmt, ...)
  1055. ! #else
  1056. ! syslog(pri, fmt, va_alist)
  1057. !       int pri;
  1058. !       char *fmt;
  1059. !       va_dcl
  1060. ! #endif
  1061.   {
  1062. !     va_list pvar;
  1063. ! #ifdef __STDC__
  1064. !     va_start(pvar, fmt);
  1065. ! #else
  1066. !     va_start(pvar);
  1067. ! #endif
  1068. !     vsyslog(pri, fmt, pvar);
  1069. !     va_end(pvar);
  1070.   }
  1071.   
  1072.   vsyslog(pri, fmt, ap)
  1073. ***************
  1074. *** 149,156 ****
  1075. --- 166,178 ----
  1076.        * output the message to the console; don't worry about
  1077.        * blocking, if console blocks everything will.
  1078.        */
  1079. + #ifdef O_NOCTTY
  1080. +     if ((fd = open(_PATH_CONSOLE, O_NOCTTY|O_WRONLY, 0)) < 0)
  1081. +         return;
  1082. + #else
  1083.       if ((fd = open(_PATH_CONSOLE, O_WRONLY, 0)) < 0)
  1084.           return;
  1085. + #endif
  1086.       (void)strcat(tbuf, "\r\n");
  1087.       cnt += 2;
  1088.       p = index(tbuf, '>') + 1;
  1089.