projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
prettiness police
[unix-history] / usr / src / usr.sbin / syslogd / syslogd.c
diff --git a/usr/src/usr.sbin/syslogd/syslogd.c b/usr/src/usr.sbin/syslogd/syslogd.c
index ef39e50..485c5d7 100644 (file)
--- a/usr/src/usr.sbin/syslogd/syslogd.c
+++ b/usr/src/usr.sbin/syslogd/syslogd.c
@@ -1,6 +1,19 @@
+/*
+ * Copyright (c) 1983, 1988, 1993, 1994
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * %sccs.include.redist.c%
+ */
+
 #ifndef lint
 #ifndef lint
-static char sccsid[] = "@(#)syslogd.c  4.10 (Berkeley) %G%";
-#endif
+static char copyright[] =
+"@(#) Copyright (c) 1983, 1988, 1993, 1994\n\
+       The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)syslogd.c  8.3 (Berkeley) %G%";
+#endif /* not lint */
 
 /*
  *  syslogd -- log system messages
 
 /*
  *  syslogd -- log system messages
@@ -16,62 +29,69 @@ static char sccsid[] = "@(#)syslogd.c       4.10 (Berkeley) %G%";
  * Defined Constants:
  *
  * MAXLINE -- the maximimum line length that can be handled.
  * Defined Constants:
  *
  * MAXLINE -- the maximimum line length that can be handled.
- * NLOGS   -- the maximum number of simultaneous log files.
- * NUSERS  -- the maximum number of people that can
- *             be designated as "superusers" on your system.
  * DEFUPRI -- the default priority for user messages
  * DEFSPRI -- the default priority for kernel messages
  *
  * Author: Eric Allman
  * extensive changes by Ralph Campbell
  * DEFUPRI -- the default priority for user messages
  * DEFSPRI -- the default priority for kernel messages
  *
  * Author: Eric Allman
  * extensive changes by Ralph Campbell
+ * more extensive changes by Eric Allman (again)
  */
 
  */
 
-#define        NLOGS           10              /* max number of log files */
-#define        NSUSERS         10              /* max number of special users */
 #define        MAXLINE         1024            /* maximum line length */
 #define        MAXLINE         1024            /* maximum line length */
-#define DEFUPRI                LOG_NOTICE
-#define DEFSPRI                LOG_EMERG
-
-#include <syslog.h>
-#include <errno.h>
-#include <stdio.h>
-#include <utmp.h>
-#include <ctype.h>
-#include <signal.h>
-#include <sysexits.h>
-#include <strings.h>
+#define        MAXSVLINE       120             /* maximum saved line length */
+#define DEFUPRI                (LOG_USER|LOG_NOTICE)
+#define DEFSPRI                (LOG_KERN|LOG_CRIT)
+#define TIMERINTVL     30              /* interval for checking flush, mark */
 
 
-#include <sys/types.h>
+#include <sys/param.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/socket.h>
-#include <sys/file.h>
 #include <sys/msgbuf.h>
 #include <sys/uio.h>
 #include <sys/un.h>
 #include <sys/msgbuf.h>
 #include <sys/uio.h>
 #include <sys/un.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 
 #include <netinet/in.h>
 #include <netdb.h>
 
 #include <netinet/in.h>
 #include <netdb.h>
+#include <arpa/inet.h>
 
 
-char   logname[] = "/dev/log";
-char   defconf[] = "/etc/syslog.conf";
-char   defpid[] = "/etc/syslog.pid";
-char   ctty[] = "/dev/console";
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <utmp.h>
+#include "pathnames.h"
 
 
-#define        dprintf         if (Debug) printf
+#define SYSLOG_NAMES
+#include <sys/syslog.h>
+
+char   *LogName = _PATH_LOG;
+char   *ConfFile = _PATH_LOGCONF;
+char   *PidFile = _PATH_LOGPID;
+char   ctty[] = _PATH_CONSOLE;
 
 
-#define UNAMESZ        8       /* length of a login name */
+#define FDMASK(fd)     (1 << (fd))
 
 
-#define mask(x)        (1 << (x))
+#define        dprintf         if (Debug) printf
+
+#define MAXUNAMES      20      /* maximum number of user names */
 
 /*
  * Flags to logmsg().
  */
 
 /*
  * Flags to logmsg().
  */
-#define IGN_CONS       0x1
-#define SYNC_FILE      0x2
-#define NOCOPY         0x4
-#define ISMARK         0x10
+
+#define IGN_CONS       0x001   /* don't print on console */
+#define SYNC_FILE      0x002   /* do fsync on file after printing */
+#define ADDDATE                0x004   /* add a date to the message */
+#define MARK           0x008   /* this message is a mark */
 
 /*
  * This structure represents the files that will have log
 
 /*
  * This structure represents the files that will have log
@@ -79,122 +99,153 @@ char      ctty[] = "/dev/console";
  */
 
 struct filed {
  */
 
 struct filed {
-       int     f_file;                 /* file descriptor */
-       u_int   f_pmask;                /* priority mask */
-       u_int   f_flags;                /* see #defines below */
-       struct  sockaddr_in f_addr;     /* forwarding address */
-       char    f_name[248];            /* filename */
+       struct  filed *f_next;          /* next in linked list */
+       short   f_type;                 /* entry type, see below */
+       short   f_file;                 /* file descriptor */
+       time_t  f_time;                 /* time this was last written */
+       u_char  f_pmask[LOG_NFACILITIES+1];     /* priority mask */
+       union {
+               char    f_uname[MAXUNAMES][UT_NAMESIZE+1];
+               struct {
+                       char    f_hname[MAXHOSTNAMELEN+1];
+                       struct sockaddr_in      f_addr;
+               } f_forw;               /* forwarding address */
+               char    f_fname[MAXPATHLEN];
+       } f_un;
+       char    f_prevline[MAXSVLINE];          /* last message logged */
+       char    f_lasttime[16];                 /* time of last occurrence */
+       char    f_prevhost[MAXHOSTNAMELEN+1];   /* host from which recd. */
+       int     f_prevpri;                      /* pri of f_prevline */
+       int     f_prevlen;                      /* length of f_prevline */
+       int     f_prevcount;                    /* repetition cnt of prevline */
+       int     f_repeatcount;                  /* number of "repeated" msgs */
 };
 
 };
 
-#define F_TTY  001             /* file is a tty */
-#define F_MARK 002             /* write to the file periodically */
-#define F_FORW 004             /* forward message to another host */
-#define F_CONS 010             /* file is the console */
-
-struct filed   Files[NLOGS];
+/*
+ * Intervals at which we flush out "message repeated" messages,
+ * in seconds after previous message is logged.  After each flush,
+ * we move to the next interval until we reach the largest.
+ */
+int    repeatinterval[] = { 30, 120, 600 };    /* # of secs before flush */
+#define        MAXREPEAT ((sizeof(repeatinterval) / sizeof(repeatinterval[0])) - 1)
+#define        REPEATTIME(f)   ((f)->f_time + repeatinterval[(f)->f_repeatcount])
+#define        BACKOFF(f)      { if (++(f)->f_repeatcount > MAXREPEAT) \
+                                (f)->f_repeatcount = MAXREPEAT; \
+                       }
 
 
-/* list of superusers */
-struct susers {
-       u_int   s_pmask;                /* priority mask */
-       char    s_name[UNAMESZ+1];
+/* values for f_type */
+#define F_UNUSED       0               /* unused entry */
+#define F_FILE         1               /* regular file */
+#define F_TTY          2               /* terminal */
+#define F_CONSOLE      3               /* console terminal */
+#define F_FORW         4               /* remote machine */
+#define F_USERS                5               /* list of users */
+#define F_WALL         6               /* everyone logged on */
+
+char   *TypeNames[7] = {
+       "UNUSED",       "FILE",         "TTY",          "CONSOLE",
+       "FORW",         "USERS",        "WALL"
 };
 
 };
 
-struct susers Susers[NSUSERS];
+struct filed *Files;
+struct filed consfile;
 
 int    Debug;                  /* debug flag */
 
 int    Debug;                  /* debug flag */
-int    LogFile;                /* log file descriptor */
-u_int  Sumask;                 /* priorities written to super-users */
-int    MarkIntvl = 15;         /* mark interval in minutes */
-char   *ConfFile = defconf;    /* configuration file */
-char   host[32];               /* our hostname */
-char   rhost[32];              /* hostname of sender (forwarded messages) */
-int    inet = 0;               /* non-zero if INET sockets are being used */
-int    port;                   /* port number for INET connections */
-u_int  Copymask = 0xffffffff;  /* priorities to supress multiple copies */
-char   prevline[MAXLINE + 1];  /* copy of last line to supress repeats */
-char   *prevdate;              /* pointer to the date in prevline */
-char   prevhost[32];           /* previous host */
-int    prevflags;
-int    prevpri;
-int    count = 0;              /* number of times seen */
-
-extern int errno, sys_nerr;
-extern char *sys_errlist[];
-extern char *ctime(), *index();
-
+char   LocalHostName[MAXHOSTNAMELEN+1];        /* our hostname */
+char   *LocalDomain;           /* our local domain name */
+int    InetInuse = 0;          /* non-zero if INET sockets are being used */
+int    finet;                  /* Internet datagram socket */
+int    LogPort;                /* port number for INET connections */
+int    Initialized = 0;        /* set when we have initialized ourselves */
+int    MarkInterval = 20 * 60; /* interval between marks in seconds */
+int    MarkSeq = 0;            /* mark sequence number */
+
+void   cfline __P((char *, struct filed *));
+char   *cvthname __P((struct sockaddr_in *));
+int    decode __P((const char *, CODE *));
+void   die __P((int));
+void   domark __P((int));
+void   fprintlog __P((struct filed *, int, char *));
+void   init __P((int));
+void   logerror __P((char *));
+void   logmsg __P((int, char *, char *, int));
+void   printline __P((char *, char *));
+void   printsys __P((char *));
+void   reapchild __P((int));
+char   *ttymsg __P((struct iovec *, int, char *, int));
+void   usage __P((void));
+void   wallmsg __P((struct filed *, struct iovec *));
+
+int
 main(argc, argv)
        int argc;
 main(argc, argv)
        int argc;
-       char **argv;
+       char *argv[];
 {
 {
-       register int i;
-       register char *p;
-       int funix, finet, inetm, fklog, klogm, len;
-       struct sockaddr_un sun, fromunix;
+       int ch, funix, i, inetm, fklog, klogm, len;
+       struct sockaddr_un sunx, fromunix;
        struct sockaddr_in sin, frominet;
        FILE *fp;
        struct sockaddr_in sin, frominet;
        FILE *fp;
-       char line[MSG_BSIZE + 1];
-       extern int die(), domark(), reapchild();
-
-       sun.sun_family = AF_UNIX;
-       strncpy(sun.sun_path, logname, sizeof sun.sun_path);
-       gethostname(host, sizeof host);
+       char *p, line[MSG_BSIZE + 1];
 
 
-       while (--argc > 0) {
-               p = *++argv;
-               if (p[0] != '-')
-                       usage();
-               switch (p[1]) {
-               case 'm':               /* set mark interval */
-                       MarkIntvl = atoi(&p[2]);
-                       if (MarkIntvl <= 0)
-                               MarkIntvl = 1;
+       while ((ch = getopt(argc, argv, "df:m:p:")) != EOF)
+               switch(ch) {
+               case 'd':               /* debug */
+                       Debug++;
                        break;
                        break;
-
                case 'f':               /* configuration file */
                case 'f':               /* configuration file */
-                       if (p[2] != '\0')
-                               ConfFile = &p[2];
+                       ConfFile = optarg;
                        break;
                        break;
-
-               case 'd':               /* debug */
-                       Debug++;
+               case 'm':               /* mark interval */
+                       MarkInterval = atoi(optarg) * 60;
                        break;
                        break;
-
                case 'p':               /* path */
                case 'p':               /* path */
-                       if (p[2] != '\0')
-                               strncpy(sun.sun_path, &p[2], 
-                                       sizeof sun.sun_path);
+                       LogName = optarg;
                        break;
                        break;
-
+               case '?':
                default:
                        usage();
                }
                default:
                        usage();
                }
-       }
+       if ((argc -= optind) != 0)
+               usage();
 
 
-       if (!Debug) {
-               if (fork())
-                       exit(0);
-               for (i = 0; i < 10; i++)
-                       (void) close(i);
-               (void) open("/", 0);
-               (void) dup2(0, 1);
-               (void) dup2(0, 2);
-               untty();
-       } else
+       if (!Debug)
+               (void)daemon(0, 0);
+       else
                setlinebuf(stdout);
 
                setlinebuf(stdout);
 
-       signal(SIGTERM, die);
-       signal(SIGINT, die);
-       signal(SIGCHLD, reapchild);
+       consfile.f_type = F_CONSOLE;
+       (void)strcpy(consfile.f_un.f_fname, ctty);
+       (void)gethostname(LocalHostName, sizeof(LocalHostName));
+       if ((p = strchr(LocalHostName, '.')) != NULL) {
+               *p++ = '\0';
+               LocalDomain = p;
+       } else
+               LocalDomain = "";
+       (void)signal(SIGTERM, die);
+       (void)signal(SIGINT, Debug ? die : SIG_IGN);
+       (void)signal(SIGQUIT, Debug ? die : SIG_IGN);
+       (void)signal(SIGCHLD, reapchild);
+       (void)signal(SIGALRM, domark);
+       (void)alarm(TIMERINTVL);
+       (void)unlink(LogName);
+
+#ifndef SUN_LEN
+#define SUN_LEN(unp) (strlen((unp)->sun_path) + 2)
+#endif
+       memset(&sunx, 0, sizeof(sunx));
+       sunx.sun_family = AF_UNIX;
+       (void)strncpy(sunx.sun_path, LogName, sizeof(sunx.sun_path));
        funix = socket(AF_UNIX, SOCK_DGRAM, 0);
        funix = socket(AF_UNIX, SOCK_DGRAM, 0);
-       if (funix < 0 || bind(funix, &sun,
-           sizeof(sun.sun_family)+strlen(sun.sun_path)) < 0 ||
-           chmod(sun.sun_path, 0666) < 0) {
-               fp = fopen(ctty, "w");
-               fprintf(fp, "\r\nsyslogd: cannot create %s (%d)\r\n", logname, errno);
-               dprintf("cannot create %s (%d)\n", logname, errno);
-               exit(1);
+       if (funix < 0 ||
+           bind(funix, (struct sockaddr *)&sunx, SUN_LEN(&sunx)) < 0 ||
+           chmod(LogName, 0666) < 0) {
+               (void) sprintf(line, "cannot create %s", LogName);
+               logerror(line);
+               dprintf("cannot create %s (%d)\n", LogName, errno);
+               die(0);
        }
        finet = socket(AF_INET, SOCK_DGRAM, 0);
        }
        finet = socket(AF_INET, SOCK_DGRAM, 0);
+       inetm = 0;
        if (finet >= 0) {
                struct servent *sp;
 
        if (finet >= 0) {
                struct servent *sp;
 
@@ -202,54 +253,53 @@ main(argc, argv)
                if (sp == NULL) {
                        errno = 0;
                        logerror("syslog/udp: unknown service");
                if (sp == NULL) {
                        errno = 0;
                        logerror("syslog/udp: unknown service");
-                       die();
+                       die(0);
                }
                }
+               memset(&sin, 0, sizeof(sin));
                sin.sin_family = AF_INET;
                sin.sin_family = AF_INET;
-               sin.sin_port = port = sp->s_port;
-               if (bind(finet, &sin, sizeof(sin), 0) < 0) {
+               sin.sin_port = LogPort = sp->s_port;
+               if (bind(finet, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
                        logerror("bind");
                        logerror("bind");
-                       die();
+                       if (!Debug)
+                               die(0);
+               } else {
+                       inetm = FDMASK(finet);
+                       InetInuse = 1;
                }
                }
-               inetm = mask(finet);
-               inet = 1;
        }
        }
-       if ((fklog = open("/dev/klog", O_RDONLY)) >= 0)
-               klogm = mask(fklog);
+       if ((fklog = open(_PATH_KLOG, O_RDONLY, 0)) >= 0)
+               klogm = FDMASK(fklog);
        else {
        else {
-               dprintf("can't open /dev/klog (%d)\n", errno);
+               dprintf("can't open %s (%d)\n", _PATH_KLOG, errno);
                klogm = 0;
        }
 
        /* tuck my process id away */
                klogm = 0;
        }
 
        /* tuck my process id away */
-       fp = fopen(defpid, "w");
+       fp = fopen(PidFile, "w");
        if (fp != NULL) {
                fprintf(fp, "%d\n", getpid());
        if (fp != NULL) {
                fprintf(fp, "%d\n", getpid());
-               fclose(fp);
+               (void) fclose(fp);
        }
 
        dprintf("off & running....\n");
 
        }
 
        dprintf("off & running....\n");
 
-       for (i = 0; i < NLOGS; i++)
-               Files[i].f_file = -1;
-       init();
-       signal(SIGHUP, init);
-       signal(SIGALRM, domark);
-       alarm(MarkIntvl * 60);
+       init(0);
+       (void)signal(SIGHUP, init);
 
        for (;;) {
 
        for (;;) {
-               int nfds, readfds = mask(funix) | inetm | klogm;
+               int nfds, readfds = FDMASK(funix) | inetm | klogm;
 
 
-               dprintf("readfds = %#x\n", readfds, funix, finet, fklog);
-               nfds = select(20, &readfds, 0, 0, 0);
-               dprintf("got a message (%d, %#x)\n", nfds, readfds);
+               dprintf("readfds = %#x\n", readfds);
+               nfds = select(20, (fd_set *)&readfds, (fd_set *)NULL,
+                   (fd_set *)NULL, (struct timeval *)NULL);
                if (nfds == 0)
                        continue;
                if (nfds < 0) {
                if (nfds == 0)
                        continue;
                if (nfds < 0) {
-                       if (errno == EINTR)
-                               continue;
-                       logerror("select");
+                       if (errno != EINTR)
+                               logerror("select");
                        continue;
                }
                        continue;
                }
+               dprintf("got a message (%d, %#x)\n", nfds, readfds);
                if (readfds & klogm) {
                        i = read(fklog, line, sizeof(line) - 1);
                        if (i > 0) {
                if (readfds & klogm) {
                        i = read(fklog, line, sizeof(line) - 1);
                        if (i > 0) {
@@ -261,59 +311,49 @@ main(argc, argv)
                                klogm = 0;
                        }
                }
                                klogm = 0;
                        }
                }
-               if (readfds & mask(funix)) {
-                       len = sizeof fromunix;
-                       i = recvfrom(funix, line, MAXLINE, 0, &fromunix, &len);
+               if (readfds & FDMASK(funix)) {
+                       len = sizeof(fromunix);
+                       i = recvfrom(funix, line, MAXLINE, 0,
+                           (struct sockaddr *)&fromunix, &len);
                        if (i > 0) {
                                line[i] = '\0';
                        if (i > 0) {
                                line[i] = '\0';
-                               printline(1, line);
+                               printline(LocalHostName, line);
                        } else if (i < 0 && errno != EINTR)
                        } else if (i < 0 && errno != EINTR)
-                               logerror("recvfrom");
+                               logerror("recvfrom unix");
                }
                if (readfds & inetm) {
                }
                if (readfds & inetm) {
-                       len = sizeof frominet;
-                       i = recvfrom(finet, line, MAXLINE, 0, &frominet, &len);
-                       if (i > 0 && chkhost(&frominet)) {
+                       len = sizeof(frominet);
+                       i = recvfrom(finet, line, MAXLINE, 0,
+                           (struct sockaddr *)&frominet, &len);
+                       if (i > 0) {
                                line[i] = '\0';
                                line[i] = '\0';
-                               printline(0, line);
+                               printline(cvthname(&frominet), line);
                        } else if (i < 0 && errno != EINTR)
                        } else if (i < 0 && errno != EINTR)
-                               logerror("recvfrom");
+                               logerror("recvfrom inet");
                } 
        }
 }
 
                } 
        }
 }
 
+void
 usage()
 {
 usage()
 {
-       fprintf(stderr, "usage: syslogd [-m#] [-d] [-ppath] [-fconffile]\n");
-       exit(1);
-}
 
 
-untty()
-{
-       int i;
-
-       if (!Debug) {
-               i = open("/dev/tty", O_RDWR);
-               if (i >= 0) {
-                       ioctl(i, TIOCNOTTY, (char *)0);
-                       (void) close(i);
-               }
-       }
+       (void)fprintf(stderr,
+           "usage: syslogd [-f conffile] [-m markinterval] [-p logpath]\n");
+       exit(1);
 }
 
 /*
  * Take a raw input line, decode the message, and print the message
  * on the appropriate log files.
  */
 }
 
 /*
  * Take a raw input line, decode the message, and print the message
  * on the appropriate log files.
  */
-
-printline(local, msg)
-       int local;
+void
+printline(hname, msg)
+       char *hname;
        char *msg;
 {
        char *msg;
 {
-       register char *p, *q;
-       register int c;
-       char line[MAXLINE + 1];
-       int pri;
+       int c, pri;
+       char *p, *q, line[MAXLINE + 1];
 
        /* test for special codes */
        pri = DEFUPRI;
 
        /* test for special codes */
        pri = DEFUPRI;
@@ -324,43 +364,48 @@ printline(local, msg)
                        pri = 10 * pri + (*p - '0');
                if (*p == '>')
                        ++p;
                        pri = 10 * pri + (*p - '0');
                if (*p == '>')
                        ++p;
-               if (pri <= 0 || pri >= 32)
-                       pri = DEFUPRI;
        }
        }
+       if (pri &~ (LOG_FACMASK|LOG_PRIMASK))
+               pri = DEFUPRI;
+
+       /* don't allow users to log kernel messages */
+       if (LOG_FAC(pri) == LOG_KERN)
+               pri = LOG_MAKEPRI(LOG_USER, LOG_PRI(pri));
 
        q = line;
 
        q = line;
-       while ((c = *p++ & 0177) != '\0' && c != '\n' &&
-           q < &line[sizeof(line) - 1]) {
-               if (iscntrl(c)) {
-                       *q++ = '^';
-                       *q++ = c ^ 0100;
-               } else
+
+       while ((c = *p++ & 0177) != '\0' &&
+           q < &line[sizeof(line) - 1])
+               if (iscntrl(c))
+                       if (c == '\n')
+                               *q++ = ' ';
+                       else if (c == '\t')
+                               *q++ = '\t';
+                       else {
+                               *q++ = '^';
+                               *q++ = c ^ 0100;
+                       }
+               else
                        *q++ = c;
                        *q++ = c;
-       }
        *q = '\0';
 
        *q = '\0';
 
-       logmsg(pri, line, local ? host : rhost, 0);
+       logmsg(pri, line, hname, 0);
 }
 
 /*
  * Take a raw input line from /dev/klog, split and format similar to syslog().
  */
 }
 
 /*
  * Take a raw input line from /dev/klog, split and format similar to syslog().
  */
-
+void
 printsys(msg)
        char *msg;
 {
 printsys(msg)
        char *msg;
 {
-       register char *p, *q;
-       register int c;
-       char line[MAXLINE + 1];
-       int pri, flags;
-       char *lp;
-       long now;
-
-       time(&now);
-       sprintf(line, "vmunix: %.15s-- ", ctime(&now) + 4);
+       int c, pri, flags;
+       char *lp, *p, *q, line[MAXLINE + 1];
+
+       (void)strcpy(line, "vmunix: ");
        lp = line + strlen(line);
        for (p = msg; *p != '\0'; ) {
        lp = line + strlen(line);
        for (p = msg; *p != '\0'; ) {
-               flags = SYNC_FILE;      /* fsync file after write */
+               flags = SYNC_FILE | ADDDATE;    /* fsync file after write */
                pri = DEFSPRI;
                if (*p == '<') {
                        pri = 0;
                pri = DEFSPRI;
                if (*p == '<') {
                        pri = 0;
@@ -368,318 +413,259 @@ printsys(msg)
                                pri = 10 * pri + (*p - '0');
                        if (*p == '>')
                                ++p;
                                pri = 10 * pri + (*p - '0');
                        if (*p == '>')
                                ++p;
-                       if (pri <= 0 || pri >= 32)
-                               pri = DEFSPRI;
                } else {
                        /* kernel printf's come out on console */
                        flags |= IGN_CONS;
                }
                } else {
                        /* kernel printf's come out on console */
                        flags |= IGN_CONS;
                }
+               if (pri &~ (LOG_FACMASK|LOG_PRIMASK))
+                       pri = DEFSPRI;
                q = lp;
                while (*p != '\0' && (c = *p++) != '\n' &&
                    q < &line[MAXLINE])
                        *q++ = c;
                *q = '\0';
                q = lp;
                while (*p != '\0' && (c = *p++) != '\n' &&
                    q < &line[MAXLINE])
                        *q++ = c;
                *q = '\0';
-               logmsg(pri, line, host, flags);
+               logmsg(pri, line, LocalHostName, flags);
        }
 }
 
        }
 }
 
+time_t now;
+
 /*
  * Log a message to the appropriate log files, users, etc. based on
  * the priority.
  */
 /*
  * Log a message to the appropriate log files, users, etc. based on
  * the priority.
  */
-
+void
 logmsg(pri, msg, from, flags)
 logmsg(pri, msg, from, flags)
-       int     pri;
-       char    *msg, *from;
-       int     flags;
+       int pri;
+       char *msg, *from;
+       int flags;
 {
 {
-       char line[MAXLINE + 1];
-       register struct filed *f;
-       register int l;
-       struct iovec iov[4];
-       register struct iovec *v = iov;
-       int omask;
+       struct filed *f;
+       int fac, msglen, omask, prilev;
+       char *timestamp;
+
+       dprintf("logmsg: pri %o, flags %x, from %s, msg %s\n",
+           pri, flags, from, msg);
+
+       omask = sigblock(sigmask(SIGHUP)|sigmask(SIGALRM));
 
 
-       omask = sigblock(sigmask(SIGALRM)|sigmask(SIGHUP));
+       /*
+        * Check to see if msg looks non-standard.
+        */
+       msglen = strlen(msg);
+       if (msglen < 16 || msg[3] != ' ' || msg[6] != ' ' ||
+           msg[9] != ':' || msg[12] != ':' || msg[15] != ' ')
+               flags |= ADDDATE;
+
+       (void)time(&now);
+       if (flags & ADDDATE)
+               timestamp = ctime(&now) + 4;
+       else {
+               timestamp = msg;
+               msg += 16;
+               msglen -= 16;
+       }
+
+       /* extract facility and priority level */
+       if (flags & MARK)
+               fac = LOG_NFACILITIES;
+       else
+               fac = LOG_FAC(pri);
+       prilev = LOG_PRI(pri);
+
+       /* log the message to the particular outputs */
+       if (!Initialized) {
+               f = &consfile;
+               f->f_file = open(ctty, O_WRONLY, 0);
+
+               if (f->f_file >= 0) {
+                       fprintlog(f, flags, msg);
+                       (void)close(f->f_file);
+               }
+               (void)sigsetmask(omask);
+               return;
+       }
+       for (f = Files; f; f = f->f_next) {
+               /* skip messages that are incorrect priority */
+               if (f->f_pmask[fac] < prilev ||
+                   f->f_pmask[fac] == INTERNAL_NOPRI)
+                       continue;
 
 
-       if ((flags & NOCOPY) == 0) {
-               register char *cp;
+               if (f->f_type == F_CONSOLE && (flags & IGN_CONS))
+                       continue;
+
+               /* don't output marks to recently written files */
+               if ((flags & MARK) && (now - f->f_time) < MarkInterval / 2)
+                       continue;
 
                /*
 
                /*
-                * Check to see if copies should be supressed or
-                * msg looks non-standard (e.g., 'prog: Feb 16 13:23:56-- ').
+                * suppress duplicate lines to this file
                 */
                 */
-               if ((Copymask & mask(pri)) == 0 ||
-                   (cp = index(msg, ':')) == NULL || strlen(cp) < 20 ||
-                   cp[5] != ' ' || cp[8] != ' ' || cp[11] != ':' ||
-                   cp[14] != ':' || cp[17] != '-' || cp[18] != '-' ||
-                   cp[19] != ' ')
-                       flushmsg();
-               else if (!strncmp(msg, prevline, cp-msg) &&
-                   !strcmp(cp+20, prevdate+18)) {
-                       /* we found a match, update the time */
-                       strncpy(prevdate, cp+2, 15);
-                       count++;
-                       (void) sigsetmask(omask);
-                       return;
+               if ((flags & MARK) == 0 && msglen == f->f_prevlen &&
+                   !strcmp(msg, f->f_prevline) &&
+                   !strcmp(from, f->f_prevhost)) {
+                       (void)strncpy(f->f_lasttime, timestamp, 15);
+                       f->f_prevcount++;
+                       dprintf("msg repeated %d times, %ld sec of %d\n",
+                           f->f_prevcount, now - f->f_time,
+                           repeatinterval[f->f_repeatcount]);
+                       /*
+                        * If domark would have logged this by now,
+                        * flush it now (so we don't hold isolated messages),
+                        * but back off so we'll flush less often
+                        * in the future.
+                        */
+                       if (now > REPEATTIME(f)) {
+                               fprintlog(f, flags, (char *)NULL);
+                               BACKOFF(f);
+                       }
                } else {
                        /* new line, save it */
                } else {
                        /* new line, save it */
-                       flushmsg();
-                       strcpy(prevline, msg);
-                       strcpy(prevhost, from);
-                       prevdate = prevline + (cp - msg) + 2;
-                       prevflags = flags;
-                       prevpri = pri;
+                       if (f->f_prevcount)
+                               fprintlog(f, 0, (char *)NULL);
+                       f->f_repeatcount = 0;
+                       (void)strncpy(f->f_lasttime, timestamp, 15);
+                       (void)strncpy(f->f_prevhost, from,
+                                       sizeof(f->f_prevhost));
+                       if (msglen < MAXSVLINE) {
+                               f->f_prevlen = msglen;
+                               f->f_prevpri = pri;
+                               (void)strcpy(f->f_prevline, msg);
+                               fprintlog(f, flags, (char *)NULL);
+                       } else {
+                               f->f_prevline[0] = 0;
+                               f->f_prevlen = 0;
+                               fprintlog(f, flags, msg);
+                       }
                }
        }
                }
        }
+       (void)sigsetmask(omask);
+}
 
 
-       v->iov_base = from;
+void
+fprintlog(f, flags, msg)
+       struct filed *f;
+       int flags;
+       char *msg;
+{
+       struct iovec iov[6];
+       struct iovec *v;
+       int l;
+       char line[MAXLINE + 1], repbuf[80], greetings[200];
+
+       v = iov;
+       if (f->f_type == F_WALL) {
+               v->iov_base = greetings;
+               v->iov_len = sprintf(greetings,
+                   "\r\n\7Message from syslogd@%s at %.24s ...\r\n",
+                   f->f_prevhost, ctime(&now));
+               v++;
+               v->iov_base = "";
+               v->iov_len = 0;
+               v++;
+       } else {
+               v->iov_base = f->f_lasttime;
+               v->iov_len = 15;
+               v++;
+               v->iov_base = " ";
+               v->iov_len = 1;
+               v++;
+       }
+       v->iov_base = f->f_prevhost;
        v->iov_len = strlen(v->iov_base);
        v++;
        v->iov_base = " ";
        v->iov_len = 1;
        v++;
        v->iov_len = strlen(v->iov_base);
        v++;
        v->iov_base = " ";
        v->iov_len = 1;
        v++;
-       v->iov_base = msg;
-       v->iov_len = strlen(v->iov_base);
+
+       if (msg) {
+               v->iov_base = msg;
+               v->iov_len = strlen(msg);
+       } else if (f->f_prevcount > 1) {
+               v->iov_base = repbuf;
+               v->iov_len = sprintf(repbuf, "last message repeated %d times",
+                   f->f_prevcount);
+       } else {
+               v->iov_base = f->f_prevline;
+               v->iov_len = f->f_prevlen;
+       }
        v++;
        v++;
-       /* log the message to the particular outputs */
-       for (f = Files; f < &Files[NLOGS]; f++) {
-               if (f->f_file < 0)
-                       continue;
-               if (flags & ISMARK) {   /* mark message */
-                       if (!(f->f_flags & F_MARK))
-                               continue;
-                       if (!(f->f_flags & F_CONS)) {
-                               struct stat stb;
-                               long now;
-
-                               if (fstat(f->f_file, &stb) < 0)
-                                       continue;
-                               time(&now);
-                               if (stb.st_mtime > now - MarkIntvl * 60)
-                                       continue;
-                       }
-               } else if ((f->f_pmask & mask(pri)) == 0 ||
-                   (flags & IGN_CONS) && (f->f_flags & F_CONS))
-                       continue;
-               if (f->f_flags & F_FORW) {
-                       sprintf(line, "<%d>%s", pri, msg);
-                       l = strlen(line);
-                       if (l > MAXLINE)
-                               l = MAXLINE;
-                       if (sendto(f->f_file, line, l, 0,
-                           &f->f_addr, sizeof f->f_addr) != l) {
-                               int e = errno;
-                               (void) close(f->f_file);
-                               f->f_file = -1;
-                               errno = e;
-                               logerror("sendto");
-                       }
-                       continue;
+
+       dprintf("Logging to %s", TypeNames[f->f_type]);
+       f->f_time = now;
+
+       switch (f->f_type) {
+       case F_UNUSED:
+               dprintf("\n");
+               break;
+
+       case F_FORW:
+               dprintf(" %s\n", f->f_un.f_forw.f_hname);
+               l = sprintf(line, "<%d>%.15s %s", f->f_prevpri,
+                   iov[0].iov_base, iov[4].iov_base);
+               if (l > MAXLINE)
+                       l = MAXLINE;
+               if (sendto(finet, line, l, 0,
+                   (struct sockaddr *)&f->f_un.f_forw.f_addr,
+                   sizeof(f->f_un.f_forw.f_addr)) != l) {
+                       int e = errno;
+                       (void)close(f->f_file);
+                       f->f_type = F_UNUSED;
+                       errno = e;
+                       logerror("sendto");
+               }
+               break;
+
+       case F_CONSOLE:
+               if (flags & IGN_CONS) {
+                       dprintf(" (ignored)\n");
+                       break;
                }
                }
-               if (f->f_flags & F_TTY) {
+               /* FALLTHROUGH */
+
+       case F_TTY:
+       case F_FILE:
+               dprintf(" %s\n", f->f_un.f_fname);
+               if (f->f_type != F_FILE) {
                        v->iov_base = "\r\n";
                        v->iov_len = 2;
                } else {
                        v->iov_base = "\n";
                        v->iov_len = 1;
                }
                        v->iov_base = "\r\n";
                        v->iov_len = 2;
                } else {
                        v->iov_base = "\n";
                        v->iov_len = 1;
                }
-               if (writev(f->f_file, iov, 4) < 0) {
+       again:
+               if (writev(f->f_file, iov, 6) < 0) {
                        int e = errno;
                        int e = errno;
-                       (void) close(f->f_file);
+                       (void)close(f->f_file);
                        /*
                        /*
-                        * Check for EBADF on the console due to vhangup() XXX
+                        * Check for errors on TTY's due to loss of tty
                         */
                         */
-                       if (e == EBADF && (f->f_flags & F_TTY)) {
-                               f->f_file = open(f->f_name, O_WRONLY|O_APPEND);
-                               if (f->f_file < 0)
-                                       logerror(f->f_name);
+                       if ((e == EIO || e == EBADF) && f->f_type != F_FILE) {
+                               f->f_file = open(f->f_un.f_fname,
+                                   O_WRONLY|O_APPEND, 0);
+                               if (f->f_file < 0) {
+                                       f->f_type = F_UNUSED;
+                                       logerror(f->f_un.f_fname);
+                               } else
+                                       goto again;
                        } else {
                        } else {
-                               f->f_file = -1;
+                               f->f_type = F_UNUSED;
                                errno = e;
                                errno = e;
-                               logerror(f->f_name);
+                               logerror(f->f_un.f_fname);
                        }
                } else if (flags & SYNC_FILE)
                        }
                } else if (flags & SYNC_FILE)
-                       (void) fsync(f->f_file);
-       }
-
-       /*
-        * Output high priority messages to terminals.
-        */
-       if (!(flags & ISMARK) && (mask(pri) & Sumask))
-               wallmsg(pri, msg, from);
-
-       (void) sigsetmask(omask);
-}
-
-/*
- *  INIT -- Initialize syslogd from configuration table
- *
- *     The configuration table consists of a series of lines broken
- *     into two sections by a blank line.  The first section gives a
- *     list of files to log on.  Each line begins with a
- *     comma-separated list of digits or ranges of digits (pairs of
- *     digits separated by a dash); if the priority of a message falls
- *     in the set of digits defined by this list, then the message is
- *     logged in the file corresponding to this line.  If the
- *     following character is an asterisk, then syslogd arranges for
- *     something to be printed every fifteen minutes (even if only a
- *     null line), so that crashes and other events can be localized.
- *     The rest of the line is the pathname of the log file.  The
- *     second section is a list of user names; these people are all
- *     notified when subalert messages occur (if they are logged on).
- *     These lines may also have associated priority lists.
- *
- *     The configuration table will be reread by this routine if a
- *     SIGHUP signal occurs; for that reason, it is tricky about not
- *     re-opening files and closing files it will not be using.
- */
-
-init()
-{
-       register int i;
-       register FILE *cf;
-       register struct filed *f;
-       register char *p;
-       char cline[BUFSIZ];
-       struct hostent *hp;
-       int pmask, flags;
-       long now;
-       char *getpmask();
-
-       dprintf("init\n");
-
-       /* flush any pending output */
-       flushmsg();
-
-       /*
-        *  Close all open log files.
-        */
-       for (f = Files; f < &Files[NLOGS]; f++) {
-               if (f->f_file >= 0)
-                       (void) close(f->f_file);
-               f->f_file = -1;
-       }
-
-       /* open the configuration file */
-       if ((cf = fopen(ConfFile, "r")) == NULL) {
-               dprintf("cannot open %s\n", ConfFile);
-               f = Files;
-               if ((f->f_file = open(ctty, O_WRONLY)) >= 0) {
-                       strncpy(f->f_name, ctty, sizeof(f->f_name)-1);
-                       f->f_pmask = mask(LOG_CRIT);
-                       f->f_flags = F_TTY|F_MARK|F_CONS;
-                       untty();
-               }
-               return;
+                       (void)fsync(f->f_file);
+               break;
+
+       case F_USERS:
+       case F_WALL:
+               dprintf("\n");
+               v->iov_base = "\r\n";
+               v->iov_len = 2;
+               wallmsg(f, iov);
+               break;
        }
        }
-
-       /*
-        *  Foreach line in the conf table, open that file.
-        */
-       f = Files;
-       while (fgets(cline, sizeof cline, cf) != NULL) {
-               /* check for end-of-section */
-               if (cline[0] == '\n')
-                       break;
-
-               /* strip off newline character */
-               p = index(cline, '\n');
-               if (p)
-                       *p = '\0';
-
-               dprintf("F: got line '%s'\n", cline);
-
-               /* extract priority mask and mark flag */
-               p = cline;
-               flags = 0;
-               p = getpmask(p, &pmask);
-               if (*p == '*') {
-                       p++;
-                       flags |= F_MARK;
-               }
-
-               if (f >= &Files[NLOGS])
-                       continue;
-
-               /* mark entry as used and update flags */
-               if (*p == '@') {
-                       if (!inet)
-                               continue;
-                       hp = gethostbyname(++p);
-                       if (hp == NULL) {
-                               char buf[100];
-
-                               sprintf(buf, "unknown host %s", p);
-                               errno = 0;
-                               logerror(buf);
-                               continue;
-                       }
-                       bzero(&f->f_addr, sizeof f->f_addr);
-                       f->f_addr.sin_family = AF_INET;
-                       f->f_addr.sin_port = port;
-                       bcopy(hp->h_addr, (char *) &f->f_addr.sin_addr, hp->h_length);
-                       f->f_file = socket(AF_INET, SOCK_DGRAM, 0);
-                       if (f->f_file < 0) {
-                               logerror("socket");
-                               continue;
-                       }
-                       flags |= F_FORW;
-                       f->f_pmask = pmask;
-                       f->f_flags = flags;
-                       dprintf("Host %s pmask %#x flags %#x\n", p, pmask, flags);
-                       f++;
-                       continue;
-               }
-               strncpy(f->f_name, p, sizeof(f->f_name)-1);
-               if ((f->f_file = open(p, O_WRONLY|O_APPEND)) < 0) {
-                       logerror(p);
-                       continue;
-               }
-               if (isatty(f->f_file)) {
-                       flags |= F_TTY;
-                       untty();
-               }
-               if (strcmp(p, ctty) == 0)
-                       flags |= F_CONS;
-               f->f_pmask = pmask;
-               f->f_flags = flags;
-               dprintf("File %s pmask %#x flags %#x\n", p, pmask, flags);
-               f++;
-       }
-
-       /*
-        *  Read the list of users.
-        *
-        *      Anyone in this list is informed directly if s/he
-        *      is logged in when a high priority message comes through.
-        */
-       Sumask = mask(LOG_ALERT);
-       for (i = 0; i < NSUSERS && fgets(cline, sizeof cline, cf) != NULL; i++) {
-               /* strip off newline */
-               p = index(cline, '\n');
-               if (p)
-                       *p = '\0';
-               dprintf("U: got line '%s'\n", cline);
-               p = cline;
-               if (isdigit(*p))
-                       p = getpmask(p, &pmask);
-               else
-                       pmask = mask(LOG_SALERT);
-               Susers[i].s_pmask = pmask;
-               Sumask |= pmask;
-               strncpy(Susers[i].s_name, p, UNAMESZ);
-               dprintf("Suser %s pmask %#x\n", p, pmask);
-       }
-
-       /* zero the rest of the old superusers */
-       while (i < NSUSERS)
-               Susers[i++].s_name[0] = '\0';
-
-       /* close the configuration file */
-       (void) fclose(cf);
-
-       dprintf("syslogd: restarted\n");
+       f->f_prevcount = 0;
 }
 
 /*
 }
 
 /*
@@ -688,208 +674,432 @@ init()
  *     Write the specified message to either the entire
  *     world, or a list of approved users.
  */
  *     Write the specified message to either the entire
  *     world, or a list of approved users.
  */
-
-wallmsg(pri, msg, from)
-       int pri;
-       char *msg, *from;
+void
+wallmsg(f, iov)
+       struct filed *f;
+       struct iovec *iov;
 {
 {
-       register char *p;
-       register int i;
-       int f, flags, len, e;
+       static int reenter;                     /* avoid calling ourselves */
        FILE *uf;
        struct utmp ut;
        FILE *uf;
        struct utmp ut;
-       long now;
-       char line[MAXLINE + 100];
-
-       /* open the user login file */
-       if ((uf = fopen("/etc/utmp", "r")) == NULL) {
-               i = Sumask;
-               Sumask = 0;
-               logerror("/etc/utmp");
-               Sumask = i;
+       int i;
+       char *p;
+       char line[sizeof(ut.ut_line) + 1];
+
+       if (reenter++)
+               return;
+       if ((uf = fopen(_PATH_UTMP, "r")) == NULL) {
+               logerror(_PATH_UTMP);
+               reenter = 0;
                return;
        }
                return;
        }
-
-       time(&now);
-       sprintf(line,
-           "\r\n\7Message from syslogd@%s at %.24s ...\r\n%s\r\n",
-               from, ctime(&now), msg);
-       len = strlen(line);
-
-       /* scan the user login file */
-       while (fread(&ut, sizeof ut, 1, uf) == 1) {
-               /* is this slot used? */
+       /* NOSTRICT */
+       while (fread((char *)&ut, sizeof(ut), 1, uf) == 1) {
                if (ut.ut_name[0] == '\0')
                        continue;
                if (ut.ut_name[0] == '\0')
                        continue;
-
-               /* should we send the message to this user? */
-               if (pri != LOG_ALERT) {
-                       for (i = 0; i < NSUSERS; i++) {
-                               if ((mask(pri) & Susers[i].s_pmask) == 0)
-                                       continue;
-                               if (strncmp(Susers[i].s_name, ut.ut_name,
-                                   UNAMESZ) == 0)
-                                       goto prmsg;
+               strncpy(line, ut.ut_line, sizeof(ut.ut_line));
+               line[sizeof(ut.ut_line)] = '\0';
+               if (f->f_type == F_WALL) {
+                       if ((p = ttymsg(iov, 6, line, 60*5)) != NULL) {
+                               errno = 0;      /* already in msg */
+                               logerror(p);
                        }
                        continue;
                }
                        }
                        continue;
                }
-       prmsg:
-
-               /* compute the device name */
-               p = "/dev/12345678";
-               strcpyn(&p[5], ut.ut_line, UNAMESZ);
-
-               /*
-                * Might as well fork instead of using nonblocking I/O
-                * and doing notty().
-                */
-               if (fork() == 0) {
-                       signal(SIGALRM, SIG_DFL);
-                       alarm(30);
-                       /* open the terminal */
-                       f = open(p, O_WRONLY);
-                       if (f >= 0)
-                               (void) write(f, line, len);
-                       exit(0);
+               /* should we send the message to this user? */
+               for (i = 0; i < MAXUNAMES; i++) {
+                       if (!f->f_un.f_uname[i][0])
+                               break;
+                       if (!strncmp(f->f_un.f_uname[i], ut.ut_name,
+                           UT_NAMESIZE)) {
+                               if ((p = ttymsg(iov, 6, line, 60*5)) != NULL) {
+                                       errno = 0;      /* already in msg */
+                                       logerror(p);
+                               }
+                               break;
+                       }
                }
        }
                }
        }
-       /* close the user login file */
-       (void) fclose(uf);
+       (void)fclose(uf);
+       reenter = 0;
 }
 
 }
 
-reapchild()
+void
+reapchild(signo)
+       int signo;
 {
        union wait status;
 
 {
        union wait status;
 
-       while (wait3(&status, WNOHANG, 0) > 0)
+       while (wait3((int *)&status, WNOHANG, (struct rusage *)NULL) > 0)
                ;
 }
 
 /*
                ;
 }
 
 /*
- * Make sure every marked file gets written to periodically.
- * Reset the alarm clock to call itself after MarkIntvl minutes.
+ * Return a printable representation of a host address.
  */
  */
-domark()
-{
-       char buf[50];
-       long now;
-
-       dprintf("domark\n");
-
-       time(&now);
-       sprintf(buf, "syslogd: %.24s-- MARK", ctime(&now));
-       flushmsg();
-       logmsg(0, buf, host, NOCOPY|ISMARK);
-       alarm(MarkIntvl * 60);
-}
-
-/*
- * Check to see if we should log this message.
- */
-chkhost(f)
+char *
+cvthname(f)
        struct sockaddr_in *f;
 {
        struct hostent *hp;
        struct sockaddr_in *f;
 {
        struct hostent *hp;
-       extern char *inet_ntoa();
+       char *p;
 
 
-       dprintf("chkhost\n");
+       dprintf("cvthname(%s)\n", inet_ntoa(f->sin_addr));
 
        if (f->sin_family != AF_INET) {
                dprintf("Malformed from address\n");
 
        if (f->sin_family != AF_INET) {
                dprintf("Malformed from address\n");
-               return (0);
+               return ("???");
        }
        }
-       hp = gethostbyaddr(&f->sin_addr, sizeof(struct in_addr), f->sin_family);
+       hp = gethostbyaddr((char *)&f->sin_addr,
+           sizeof(struct in_addr), f->sin_family);
        if (hp == 0) {
                dprintf("Host name for your address (%s) unknown\n",
                        inet_ntoa(f->sin_addr));
        if (hp == 0) {
                dprintf("Host name for your address (%s) unknown\n",
                        inet_ntoa(f->sin_addr));
-               return (0);
+               return (inet_ntoa(f->sin_addr));
        }
        }
-       strncpy(rhost, hp->h_name, sizeof rhost);
-       return (1);
+       if ((p = strchr(hp->h_name, '.')) && strcmp(p + 1, LocalDomain) == 0)
+               *p = '\0';
+       return (hp->h_name);
 }
 
 }
 
-flushmsg()
+void
+domark(signo)
+       int signo;
 {
 {
-       if (count == 0)
-               return;
-       if (count > 1)
-               sprintf(prevdate+18, "last message repeated %d times", count);
-       count = 0;
-       logmsg(prevpri, prevline, prevhost, prevflags|NOCOPY);
-       prevline[0] = '\0';
+       struct filed *f;
+
+       now = time((time_t *)NULL);
+       MarkSeq += TIMERINTVL;
+       if (MarkSeq >= MarkInterval) {
+               logmsg(LOG_INFO, "-- MARK --", LocalHostName, ADDDATE|MARK);
+               MarkSeq = 0;
+       }
+
+       for (f = Files; f; f = f->f_next) {
+               if (f->f_prevcount && now >= REPEATTIME(f)) {
+                       dprintf("flush %s: repeated %d times, %d sec.\n",
+                           TypeNames[f->f_type], f->f_prevcount,
+                           repeatinterval[f->f_repeatcount]);
+                       fprintlog(f, 0, (char *)NULL);
+                       BACKOFF(f);
+               }
+       }
+       (void)alarm(TIMERINTVL);
 }
 
 /*
  * Print syslogd errors some place.
  */
 }
 
 /*
  * Print syslogd errors some place.
  */
+void
 logerror(type)
        char *type;
 {
        char buf[100];
 logerror(type)
        char *type;
 {
        char buf[100];
-       long now;
-
-       time(&now);
-       if (errno == 0)
-               sprintf(buf, "syslogd: %.24s-- %s", ctime(&now), type);
-       else if ((unsigned) errno > sys_nerr)
-               sprintf(buf, "syslogd: %.24s-- %s: error %d",
-                       ctime(&now), type, errno);
+
+       if (errno)
+               (void)snprintf(buf,
+                   sizeof(buf), "syslogd: %s: %s", type, strerror(errno));
        else
        else
-               sprintf(buf, "syslogd: %.24s-- %s: %s",
-                       ctime(&now), type, sys_errlist[errno]);
+               (void)snprintf(buf, sizeof(buf), "syslogd: %s", type);
        errno = 0;
        dprintf("%s\n", buf);
        errno = 0;
        dprintf("%s\n", buf);
-       logmsg(LOG_ERR, buf, host, 0);
+       logmsg(LOG_SYSLOG|LOG_ERR, buf, LocalHostName, ADDDATE);
 }
 
 }
 
-die()
+void
+die(signo)
+       int signo;
 {
 {
+       struct filed *f;
+       char buf[100];
 
 
-       flushmsg();
-       dprintf("syslogd: going down\n");
-       (void) unlink(logname);
+       for (f = Files; f != NULL; f = f->f_next) {
+               /* flush any pending output */
+               if (f->f_prevcount)
+                       fprintlog(f, 0, (char *)NULL);
+       }
+       if (signo) {
+               dprintf("syslogd: exiting on signal %d\n", signo);
+               (void)sprintf(buf, "exiting on signal %d", signo);
+               errno = 0;
+               logerror(buf);
+       }
+       (void)unlink(LogName);
        exit(0);
 }
 
 /*
        exit(0);
 }
 
 /*
- * getpmask() parses a string cp looking for a set of numbers like
- * '1-5,8,16' and returns in *ppmask the set of bits represented by
- * these numbers.  A notation '1-5' is interpreted to mean 'turn on
- * bits 1 through 5 inclusive'.  getpmask() returns the address of
- * first byte after the number set.
+ *  INIT -- Initialize syslogd from configuration table
  */
  */
-char *
-getpmask(cp, ppmask)
-       register char *cp;
-       unsigned *ppmask;
+void
+init(signo)
+       int signo;
 {
 {
-       int count1, count2;
-       register int i;
-
-       *ppmask = 0;
-       while (isdigit(*cp)) {
-               count1 = count2 = 0;
-               do {
-                       count1 = 10 * count1 + (*cp++ - '0');
-               } while (isdigit(*cp));
-               switch (*cp) {
-               case ',':
-                       ++cp;
-                       /* FALL THRU */
-               default:
-                       *ppmask |= mask(count1);
+       int i;
+       FILE *cf;
+       struct filed *f, *next, **nextp;
+       char *p;
+       char cline[LINE_MAX];
+
+       dprintf("init\n");
+
+       /*
+        *  Close all open log files.
+        */
+       Initialized = 0;
+       for (f = Files; f != NULL; f = next) {
+               /* flush any pending output */
+               if (f->f_prevcount)
+                       fprintlog(f, 0, (char *)NULL);
+
+               switch (f->f_type) {
+               case F_FILE:
+               case F_TTY:
+               case F_CONSOLE:
+               case F_FORW:
+                       (void)close(f->f_file);
+                       break;
+               }
+               next = f->f_next;
+               free((char *)f);
+       }
+       Files = NULL;
+       nextp = &Files;
+
+       /* open the configuration file */
+       if ((cf = fopen(ConfFile, "r")) == NULL) {
+               dprintf("cannot open %s\n", ConfFile);
+               *nextp = (struct filed *)calloc(1, sizeof(*f));
+               cfline("*.ERR\t/dev/console", *nextp);
+               (*nextp)->f_next = (struct filed *)calloc(1, sizeof(*f));
+               cfline("*.PANIC\t*", (*nextp)->f_next);
+               Initialized = 1;
+               return;
+       }
+
+       /*
+        *  Foreach line in the conf table, open that file.
+        */
+       f = NULL;
+       while (fgets(cline, sizeof(cline), cf) != NULL) {
+               /*
+                * check for end-of-section, comments, strip off trailing
+                * spaces and newline character.
+                */
+               for (p = cline; isspace(*p); ++p)
+                       continue;
+               if (*p == NULL || *p == '#')
+                       continue;
+               for (p = strchr(cline, '\0'); isspace(*--p);)
                        continue;
                        continue;
+               *++p = '\0';
+               f = (struct filed *)calloc(1, sizeof(*f));
+               *nextp = f;
+               nextp = &f->f_next;
+               cfline(cline, f);
+       }
+
+       /* close the configuration file */
+       (void)fclose(cf);
+
+       Initialized = 1;
+
+       if (Debug) {
+               for (f = Files; f; f = f->f_next) {
+                       for (i = 0; i <= LOG_NFACILITIES; i++)
+                               if (f->f_pmask[i] == INTERNAL_NOPRI)
+                                       printf("X ");
+                               else
+                                       printf("%d ", f->f_pmask[i]);
+                       printf("%s: ", TypeNames[f->f_type]);
+                       switch (f->f_type) {
+                       case F_FILE:
+                       case F_TTY:
+                       case F_CONSOLE:
+                               printf("%s", f->f_un.f_fname);
+                               break;
+
+                       case F_FORW:
+                               printf("%s", f->f_un.f_forw.f_hname);
+                               break;
+
+                       case F_USERS:
+                               for (i = 0; i < MAXUNAMES && *f->f_un.f_uname[i]; i++)
+                                       printf("%s, ", f->f_un.f_uname[i]);
+                               break;
+                       }
+                       printf("\n");
+               }
+       }
+
+       logmsg(LOG_SYSLOG|LOG_INFO, "syslogd: restart", LocalHostName, ADDDATE);
+       dprintf("syslogd: restarted\n");
+}
+
+/*
+ * Crack a configuration file line
+ */
+void
+cfline(line, f)
+       char *line;
+       struct filed *f;
+{
+       struct hostent *hp;
+       int i, pri;
+       char *bp, *p, *q;
+       char buf[MAXLINE], ebuf[100];
+
+       dprintf("cfline(%s)\n", line);
+
+       errno = 0;      /* keep strerror() stuff out of logerror messages */
+
+       /* clear out file entry */
+       memset(f, 0, sizeof(*f));
+       for (i = 0; i <= LOG_NFACILITIES; i++)
+               f->f_pmask[i] = INTERNAL_NOPRI;
 
 
-               case '-':
-                       while (isdigit(*++cp))
-                               count2 = 10 * count2 + (*cp - '0');
-                       for (i = count1; i <= count2; ++i)
-                               *ppmask |= mask(i);
-                       if (*cp == ',')
-                               ++cp;
+       /* scan through the list of selectors */
+       for (p = line; *p && *p != '\t';) {
+
+               /* find the end of this facility name list */
+               for (q = p; *q && *q != '\t' && *q++ != '.'; )
                        continue;
                        continue;
+
+               /* collect priority name */
+               for (bp = buf; *q && !strchr("\t,;", *q); )
+                       *bp++ = *q++;
+               *bp = '\0';
+
+               /* skip cruft */
+               while (strchr(", ;", *q))
+                       q++;
+
+               /* decode priority name */
+               if (*buf == '*')
+                       pri = LOG_PRIMASK + 1;
+               else {
+                       pri = decode(buf, prioritynames);
+                       if (pri < 0) {
+                               (void)sprintf(ebuf,
+                                   "unknown priority name \"%s\"", buf);
+                               logerror(ebuf);
+                               return;
+                       }
+               }
+
+               /* scan facilities */
+               while (*p && !strchr("\t.;", *p)) {
+                       for (bp = buf; *p && !strchr("\t,;.", *p); )
+                               *bp++ = *p++;
+                       *bp = '\0';
+                       if (*buf == '*')
+                               for (i = 0; i < LOG_NFACILITIES; i++)
+                                       f->f_pmask[i] = pri;
+                       else {
+                               i = decode(buf, facilitynames);
+                               if (i < 0) {
+                                       (void)sprintf(ebuf,
+                                           "unknown facility name \"%s\"",
+                                           buf);
+                                       logerror(ebuf);
+                                       return;
+                               }
+                               f->f_pmask[i >> 3] = pri;
+                       }
+                       while (*p == ',' || *p == ' ')
+                               p++;
                }
                }
+
+               p = q;
+       }
+
+       /* skip to action part */
+       while (*p == '\t')
+               p++;
+
+       switch (*p)
+       {
+       case '@':
+               if (!InetInuse)
+                       break;
+               (void)strcpy(f->f_un.f_forw.f_hname, ++p);
+               hp = gethostbyname(p);
+               if (hp == NULL) {
+                       extern int h_errno;
+
+                       logerror(hstrerror(h_errno));
+                       break;
+               }
+               memset(&f->f_un.f_forw.f_addr, 0,
+                        sizeof(f->f_un.f_forw.f_addr));
+               f->f_un.f_forw.f_addr.sin_family = AF_INET;
+               f->f_un.f_forw.f_addr.sin_port = LogPort;
+               memmove(&f->f_un.f_forw.f_addr.sin_addr, hp->h_addr, hp->h_length);
+               f->f_type = F_FORW;
+               break;
+
+       case '/':
+               (void)strcpy(f->f_un.f_fname, p);
+               if ((f->f_file = open(p, O_WRONLY|O_APPEND, 0)) < 0) {
+                       f->f_file = F_UNUSED;
+                       logerror(p);
+                       break;
+               }
+               if (isatty(f->f_file))
+                       f->f_type = F_TTY;
+               else
+                       f->f_type = F_FILE;
+               if (strcmp(p, ctty) == 0)
+                       f->f_type = F_CONSOLE;
+               break;
+
+       case '*':
+               f->f_type = F_WALL;
+               break;
+
+       default:
+               for (i = 0; i < MAXUNAMES && *p; i++) {
+                       for (q = p; *q && *q != ','; )
+                               q++;
+                       (void)strncpy(f->f_un.f_uname[i], p, UT_NAMESIZE);
+                       if ((q - p) > UT_NAMESIZE)
+                               f->f_un.f_uname[i][UT_NAMESIZE] = '\0';
+                       else
+                               f->f_un.f_uname[i][q - p] = '\0';
+                       while (*q == ',' || *q == ' ')
+                               q++;
+                       p = q;
+               }
+               f->f_type = F_USERS;
+               break;
+       }
+}
+
+
+/*
+ *  Decode a symbolic name to a numeric value
+ */
+int
+decode(name, codetab)
+       const char *name;
+       CODE *codetab;
+{
+       CODE *c;
+       char *p, buf[40];
+
+       if (isdigit(*name))
+               return (atoi(name));
+
+       for (p = buf; *name && p < &buf[sizeof(buf) - 1]; p++, name++) {
+               if (isupper(*name))
+                       *p = tolower(*name);
+               else
+                       *p = *name;
        }
        }
+       *p = '\0';
+       for (c = codetab; c->c_name; c++)
+               if (!strcmp(buf, c->c_name))
+                       return (c->c_val);
 
 
-       return (cp);
+       return (-1);
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.