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 541387c..485c5d7 100644 (file)
--- a/usr/src/usr.sbin/syslogd/syslogd.c
+++ b/usr/src/usr.sbin/syslogd/syslogd.c
@@ -1,20 +1,19 @@
 /*
 /*
- * Copyright (c) 1983 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1983, 1988, 1993, 1994
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * %sccs.include.redist.c%
  */
 
 #ifndef lint
  */
 
 #ifndef lint
-char copyright[] =
-"@(#) Copyright (c) 1983 Regents of the University of California.\n\
- All rights reserved.\n";
-#endif not lint
+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
 
 #ifndef lint
-static char sccsid[] = "@(#)syslogd.c  5.7 (Berkeley) %G%";
-#endif not lint
-
-#define COMPAT         /* include 4.3 Alpha compatibility */
+static char sccsid[] = "@(#)syslogd.c  8.3 (Berkeley) %G%";
+#endif /* not lint */
 
 /*
  *  syslogd -- log system messages
 
 /*
  *  syslogd -- log system messages
@@ -30,35 +29,25 @@ static char sccsid[] = "@(#)syslogd.c       5.7 (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.
  * 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           20              /* max number of log files */
 #define        MAXLINE         1024            /* maximum line length */
 #define        MAXLINE         1024            /* maximum line length */
+#define        MAXSVLINE       120             /* maximum saved line length */
 #define DEFUPRI                (LOG_USER|LOG_NOTICE)
 #define DEFSPRI                (LOG_KERN|LOG_CRIT)
 #define DEFUPRI                (LOG_USER|LOG_NOTICE)
 #define DEFSPRI                (LOG_KERN|LOG_CRIT)
+#define TIMERINTVL     30              /* interval for checking flush, mark */
 
 
-#include <syslog.h>
-#include <errno.h>
-#include <stdio.h>
-#include <utmp.h>
-#include <ctype.h>
-#include <signal.h>
-#include <sysexits.h>
-#include <strings.h>
-
-#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/param.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>
@@ -67,21 +56,33 @@ static char sccsid[] = "@(#)syslogd.c       5.7 (Berkeley) %G%";
 
 #include <netinet/in.h>
 #include <netdb.h>
 
 #include <netinet/in.h>
 #include <netdb.h>
+#include <arpa/inet.h>
+
+#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"
 
 
-char   *LogName = "/dev/log";
-char   *ConfFile = "/etc/syslog.conf";
-char   *PidFile = "/etc/syslog.pid";
-char   ctty[] = "/dev/console";
+#define SYSLOG_NAMES
+#include <sys/syslog.h>
+
+char   *LogName = _PATH_LOG;
+char   *ConfFile = _PATH_LOGCONF;
+char   *PidFile = _PATH_LOGPID;
+char   ctty[] = _PATH_CONSOLE;
 
 #define FDMASK(fd)     (1 << (fd))
 
 #define        dprintf         if (Debug) printf
 
 
 #define FDMASK(fd)     (1 << (fd))
 
 #define        dprintf         if (Debug) printf
 
-#define UNAMESZ                8       /* length of a login name */
 #define MAXUNAMES      20      /* maximum number of user names */
 #define MAXUNAMES      20      /* maximum number of user names */
-#define MAXFNAME       200     /* max file pathname length */
-
-#define NOPRI          0x10    /* the "no priority" priority */
 
 /*
  * Flags to logmsg().
 
 /*
  * Flags to logmsg().
@@ -89,8 +90,8 @@ char  ctty[] = "/dev/console";
 
 #define IGN_CONS       0x001   /* don't print on console */
 #define SYNC_FILE      0x002   /* do fsync on file after printing */
 
 #define IGN_CONS       0x001   /* don't print on console */
 #define SYNC_FILE      0x002   /* do fsync on file after printing */
-#define NOCOPY         0x004   /* don't suppress duplicate messages */
-#define ADDDATE                0x008   /* add a date to the message */
+#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
@@ -98,20 +99,40 @@ char        ctty[] = "/dev/console";
  */
 
 struct filed {
  */
 
 struct filed {
+       struct  filed *f_next;          /* next in linked list */
        short   f_type;                 /* entry type, see below */
        short   f_file;                 /* file descriptor */
        short   f_type;                 /* entry type, see below */
        short   f_file;                 /* file descriptor */
-       u_char  f_pmask[LOG_NFACILITIES];       /* priority mask */
+       time_t  f_time;                 /* time this was last written */
+       u_char  f_pmask[LOG_NFACILITIES+1];     /* priority mask */
        union {
        union {
-               char    f_uname[MAXUNAMES][UNAMESZ+1];
-               struct
-               {
+               char    f_uname[MAXUNAMES][UT_NAMESIZE+1];
+               struct {
                        char    f_hname[MAXHOSTNAMELEN+1];
                        struct sockaddr_in      f_addr;
                        char    f_hname[MAXHOSTNAMELEN+1];
                        struct sockaddr_in      f_addr;
-               }       f_forw;         /* forwarding address */
-               char    f_fname[MAXFNAME];
-       }       f_un;
+               } 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 */
 };
 
 };
 
+/*
+ * 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; \
+                       }
+
 /* values for f_type */
 #define F_UNUSED       0               /* unused entry */
 #define F_FILE         1               /* regular file */
 /* values for f_type */
 #define F_UNUSED       0               /* unused entry */
 #define F_FILE         1               /* regular file */
@@ -126,133 +147,97 @@ char     *TypeNames[7] = {
        "FORW",         "USERS",        "WALL"
 };
 
        "FORW",         "USERS",        "WALL"
 };
 
-struct filed   Files[NLOGS];
+struct filed *Files;
+struct filed consfile;
 
 int    Debug;                  /* debug flag */
 char   LocalHostName[MAXHOSTNAMELEN+1];        /* our hostname */
 
 int    Debug;                  /* debug flag */
 char   LocalHostName[MAXHOSTNAMELEN+1];        /* our hostname */
+char   *LocalDomain;           /* our local domain name */
 int    InetInuse = 0;          /* non-zero if INET sockets are being used */
 int    InetInuse = 0;          /* non-zero if INET sockets are being used */
+int    finet;                  /* Internet datagram socket */
 int    LogPort;                /* port number for INET connections */
 int    LogPort;                /* port number for INET connections */
-char   PrevLine[MAXLINE + 1];  /* copy of last line to supress repeats */
-char   PrevHost[MAXHOSTNAMELEN+1];             /* previous host */
-int    PrevFlags;
-int    PrevPri;
-int    PrevCount = 0;          /* number of times seen */
 int    Initialized = 0;        /* set when we have initialized ourselves */
 int    Initialized = 0;        /* set when we have initialized ourselves */
-
-extern int errno, sys_nerr;
-extern char *sys_errlist[];
-extern char *ctime(), *index();
-
-#ifdef COMPAT
-int    CompatMode = 0;         /* run in compatibility mode */
-int    CompatCodes[32] = {
-               LOG_USER|LOG_ALERT,     /* 0 -- undefined */
-                       /* kernel priorities */
-               LOG_KERN|LOG_EMERG,     /* KERN_EMERG */
-               LOG_KERN|LOG_ALERT,     /* KERN_ALERT */
-               LOG_KERN|LOG_CRIT,      /* KERN_ERR */
-               LOG_KERN|LOG_ERR,       /* KERN_FAIL */
-               LOG_KERN|LOG_WARNING,   /* KERN_RECOV */
-               LOG_KERN|LOG_INFO,      /* KERN_INFO */
-                       /* user abnormal conditions priorities */
-               LOG_USER|LOG_EMERG,     /* LOG_EMERG */
-               LOG_USER|LOG_ALERT,     /* LOG_ALERT */
-               LOG_USER|LOG_CRIT,      /* LOG_CRIT */
-               LOG_USER|LOG_ERR,       /* LOG_ERR */
-               LOG_USER|LOG_ERR,       /* LOG_ERR */
-               LOG_USER|LOG_WARNING,   /* LOG_WARNING */
-                       /* user priorities */
-               LOG_USER|LOG_ALERT,     /* LOG_SALERT */
-               LOG_AUTH|LOG_NOTICE,    /* LOG_SECURITY */
-               LOG_USER|LOG_INFO,      /* LOG_FIXED */
-               LOG_MAIL|LOG_ERR,       /* LOG_MAIL */
-               LOG_DAEMON|LOG_ERR,     /* LOG_REJECT */
-               LOG_USER|LOG_NOTICE,    /* LOG_NOTICE */
-                       /* user information priorities */
-               LOG_USER|LOG_INFO,      /* LOG_INFO */
-               LOG_LOCAL1|LOG_INFO,    /* LOG_INFO1 */
-               LOG_LOCAL2|LOG_INFO,    /* LOG_INFO2 */
-               LOG_LOCAL3|LOG_INFO,    /* LOG_INFO3 */
-               LOG_LOCAL4|LOG_INFO,    /* LOG_INFO4 */
-               LOG_LOCAL5|LOG_INFO,    /* LOG_INFO5 */
-                       /* user debug/local priorities */
-               LOG_USER|LOG_DEBUG,     /* LOG_DEBUG */
-               LOG_LOCAL1|LOG_DEBUG,   /* LOG_LOCAL1 */
-               LOG_LOCAL2|LOG_DEBUG,   /* LOG_LOCAL2 */
-               LOG_LOCAL3|LOG_DEBUG,   /* LOG_LOCAL3 */
-               LOG_LOCAL4|LOG_DEBUG,   /* LOG_LOCAL4 */
-               LOG_LOCAL5|LOG_DEBUG,   /* LOG_LOCAL5 */
-               LOG_LOCAL6|LOG_DEBUG,   /* LOG_LOCAL6 */
-};
-#endif COMPAT
-
+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();
-
-       while (--argc > 0) {
-               p = *++argv;
-               if (p[0] != '-')
-                       usage();
-               switch (p[1]) {
-               case 'f':               /* configuration file */
-                       if (p[2] != '\0')
-                               ConfFile = &p[2];
-                       break;
+       char *p, line[MSG_BSIZE + 1];
 
 
+       while ((ch = getopt(argc, argv, "df:m:p:")) != EOF)
+               switch(ch) {
                case 'd':               /* debug */
                        Debug++;
                        break;
                case 'd':               /* debug */
                        Debug++;
                        break;
-
-#ifdef COMPAT
-               case 'C':               /* run in compat mode */
-                       CompatMode++;
+               case 'f':               /* configuration file */
+                       ConfFile = optarg;
+                       break;
+               case 'm':               /* mark interval */
+                       MarkInterval = atoi(optarg) * 60;
                        break;
                        break;
-#endif COMPAT
-
                case 'p':               /* path */
                case 'p':               /* path */
-                       if (p[2] != '\0')
-                               LogName = &p[2];
+                       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);
 
-       (void) signal(SIGTERM, die);
-       (void) signal(SIGINT, Debug ? die : SIG_IGN);
-       (void) signal(SIGQUIT, Debug ? die : SIG_IGN);
-       (void) signal(SIGCHLD, reapchild);
-       (void) unlink(LogName);
-
-       sun.sun_family = AF_UNIX;
-       (void) strncpy(sun.sun_path, LogName, sizeof sun.sun_path);
-       (void) gethostname(LocalHostName, sizeof LocalHostName);
+       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, (struct sockaddr *) &sun,
-           sizeof(sun.sun_family)+strlen(sun.sun_path)) < 0 ||
+       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);
            chmod(LogName, 0666) < 0) {
                (void) sprintf(line, "cannot create %s", LogName);
                logerror(line);
@@ -260,6 +245,7 @@ main(argc, argv)
                die(0);
        }
        finet = socket(AF_INET, SOCK_DGRAM, 0);
                die(0);
        }
        finet = socket(AF_INET, SOCK_DGRAM, 0);
+       inetm = 0;
        if (finet >= 0) {
                struct servent *sp;
 
        if (finet >= 0) {
                struct servent *sp;
 
@@ -269,9 +255,10 @@ main(argc, argv)
                        logerror("syslog/udp: unknown service");
                        die(0);
                }
                        logerror("syslog/udp: unknown service");
                        die(0);
                }
+               memset(&sin, 0, sizeof(sin));
                sin.sin_family = AF_INET;
                sin.sin_port = LogPort = sp->s_port;
                sin.sin_family = AF_INET;
                sin.sin_port = LogPort = sp->s_port;
-               if (bind(finet, &sin, sizeof(sin)) < 0) {
+               if (bind(finet, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
                        logerror("bind");
                        if (!Debug)
                                die(0);
                        logerror("bind");
                        if (!Debug)
                                die(0);
@@ -280,10 +267,10 @@ main(argc, argv)
                        InetInuse = 1;
                }
        }
                        InetInuse = 1;
                }
        }
-       if ((fklog = open("/dev/klog", O_RDONLY)) >= 0)
+       if ((fklog = open(_PATH_KLOG, O_RDONLY, 0)) >= 0)
                klogm = FDMASK(fklog);
        else {
                klogm = FDMASK(fklog);
        else {
-               dprintf("can't open /dev/klog (%d)\n", errno);
+               dprintf("can't open %s (%d)\n", _PATH_KLOG, errno);
                klogm = 0;
        }
 
                klogm = 0;
        }
 
@@ -296,17 +283,15 @@ main(argc, argv)
 
        dprintf("off & running....\n");
 
 
        dprintf("off & running....\n");
 
-       init();
-       (void) signal(SIGHUP, init);
+       init(0);
+       (void)signal(SIGHUP, init);
 
        for (;;) {
                int nfds, readfds = FDMASK(funix) | inetm | klogm;
 
 
        for (;;) {
                int nfds, readfds = FDMASK(funix) | inetm | klogm;
 
-               errno = 0;
-               dprintf("readfds = %#x\n", readfds, funix, finet, fklog);
-               nfds = select(20, (fd_set *) &readfds, (fd_set *) NULL,
-                                 (fd_set *) NULL, (struct timeval *) NULL);
-               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) {
@@ -314,6 +299,7 @@ main(argc, argv)
                                logerror("select");
                        continue;
                }
                                logerror("select");
                        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) {
@@ -326,9 +312,9 @@ main(argc, argv)
                        }
                }
                if (readfds & FDMASK(funix)) {
                        }
                }
                if (readfds & FDMASK(funix)) {
-                       len = sizeof fromunix;
+                       len = sizeof(fromunix);
                        i = recvfrom(funix, line, MAXLINE, 0,
                        i = recvfrom(funix, line, MAXLINE, 0,
-                                    (struct sockaddr *) &fromunix, &len);
+                           (struct sockaddr *)&fromunix, &len);
                        if (i > 0) {
                                line[i] = '\0';
                                printline(LocalHostName, line);
                        if (i > 0) {
                                line[i] = '\0';
                                printline(LocalHostName, line);
@@ -336,11 +322,10 @@ main(argc, argv)
                                logerror("recvfrom unix");
                }
                if (readfds & inetm) {
                                logerror("recvfrom unix");
                }
                if (readfds & inetm) {
-                       len = sizeof frominet;
-                       i = recvfrom(finet, line, MAXLINE, 0, &frominet, &len);
+                       len = sizeof(frominet);
+                       i = recvfrom(finet, line, MAXLINE, 0,
+                           (struct sockaddr *)&frominet, &len);
                        if (i > 0) {
                        if (i > 0) {
-                               extern char *cvthname();
-
                                line[i] = '\0';
                                printline(cvthname(&frominet), line);
                        } else if (i < 0 && errno != EINTR)
                                line[i] = '\0';
                                printline(cvthname(&frominet), line);
                        } else if (i < 0 && errno != EINTR)
@@ -349,38 +334,26 @@ main(argc, argv)
        }
 }
 
        }
 }
 
+void
 usage()
 {
 usage()
 {
-       fprintf(stderr, "usage: syslogd [-d] [-ppath] [-fconffile]\n");
-       exit(1);
-}
-
-untty()
-{
-       int i;
 
 
-       if (!Debug) {
-               i = open("/dev/tty", O_RDWR);
-               if (i >= 0) {
-                       (void) ioctl(i, (int) 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.
  */
-
+void
 printline(hname, msg)
        char *hname;
        char *msg;
 {
 printline(hname, msg)
        char *hname;
        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;
@@ -391,43 +364,29 @@ printline(hname, msg)
                        pri = 10 * pri + (*p - '0');
                if (*p == '>')
                        ++p;
                        pri = 10 * pri + (*p - '0');
                if (*p == '>')
                        ++p;
-               if (pri <= 0 || pri >= (LOG_NFACILITIES << 3))
-                       pri = DEFUPRI;
        }
        }
+       if (pri &~ (LOG_FACMASK|LOG_PRIMASK))
+               pri = DEFUPRI;
 
        /* don't allow users to log kernel messages */
 
        /* don't allow users to log kernel messages */
-       if ((pri & LOG_PRIMASK) == LOG_KERN)
-               pri |= LOG_USER;
+       if (LOG_FAC(pri) == LOG_KERN)
+               pri = LOG_MAKEPRI(LOG_USER, LOG_PRI(pri));
 
        q = line;
 
        q = line;
-#ifdef COMPAT
-       if (CompatMode) {
-               register char *lp = index(p, ':');
 
 
-               if (lp && lp[1] == ' ' && lp[17] == '-' && lp[18] == '-') {
-                       /*
-                        * Old format message
-                        */
-                       dprintf("mapping <%d> to <%d>\n", pri, CompatCodes[pri]);
-                       pri = CompatCodes[pri];
-                       (void) strncpy(q, lp + 2, 15);
-                       q += 15;
-                       *q++ = ' ';
-                       (void) strncpy(q, p, lp - p + 1);
-                       q += lp - p + 1;
-                       p = lp + 19;
-               }
-       }
-#endif COMPAT
-
-       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';
 
        logmsg(pri, line, hname, 0);
        *q = '\0';
 
        logmsg(pri, line, hname, 0);
@@ -436,22 +395,17 @@ printline(hname, msg)
 /*
  * 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;
-       time_t now;
-
-       (void) time(&now);
-       (void) sprintf(line, "%.15s vmunix: ", 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;
@@ -459,18 +413,12 @@ printsys(msg)
                                pri = 10 * pri + (*p - '0');
                        if (*p == '>')
                                ++p;
                                pri = 10 * pri + (*p - '0');
                        if (*p == '>')
                                ++p;
-                       if (pri <= 0 || pri >= (LOG_NFACILITIES << 3))
-                               pri = DEFSPRI;
-#ifdef COMPAT
-                       else if (CompatMode) {
-                               dprintf("mapping <%d> to <%d>\n", pri, CompatCodes[pri]);
-                               pri = CompatCodes[pri];
-                       }
-#endif COMPAT
                } 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 = lp;
                while (*p != '\0' && (c = *p++) != '\n' &&
                    q < &line[MAXLINE])
@@ -480,268 +428,309 @@ printsys(msg)
        }
 }
 
        }
 }
 
+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)
        int pri;
        char *msg, *from;
        int flags;
 {
 logmsg(pri, msg, from, flags)
        int pri;
        char *msg, *from;
        int flags;
 {
-       char line[MAXLINE + 1];
-       register struct filed *f;
-       register int l;
-       int fac, prilev;
-       struct iovec iov[6];
-       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);
+       dprintf("logmsg: pri %o, flags %x, from %s, msg %s\n",
+           pri, flags, from, msg);
 
 
-       omask = sigblock(sigmask(SIGALRM)|sigmask(SIGHUP));
+       omask = sigblock(sigmask(SIGHUP)|sigmask(SIGALRM));
 
        /*
         * Check to see if msg looks non-standard.
         */
 
        /*
         * Check to see if msg looks non-standard.
         */
-       if (!(flags & ADDDATE) && (strlen(msg) < 16 ||
-           msg[3] != ' ' || msg[6] != ' ' ||
-           msg[9] != ':' || msg[12] != ':' || msg[15] != ' '))
+       msglen = strlen(msg);
+       if (msglen < 16 || msg[3] != ' ' || msg[6] != ' ' ||
+           msg[9] != ':' || msg[12] != ':' || msg[15] != ' ')
                flags |= ADDDATE;
 
                flags |= ADDDATE;
 
-       if ((flags & NOCOPY) == 0) {
-               if (flags & ADDDATE)
-                       flushmsg();
-               else if (!strcmp(msg + 16, PrevLine + 16)) {
-                       /* we found a match, update the time */
-                       (void) strncpy(PrevLine, msg, 15);
-                       PrevCount++;
-                       (void) sigsetmask(omask);
-                       return;
-               } else {
-                       /* new line, save it */
-                       flushmsg();
-                       (void) strcpy(PrevLine, msg);
-                       (void) strcpy(PrevHost, from);
-                       PrevFlags = flags;
-                       PrevPri = pri;
-               }
-       }
-
-       if (flags & ADDDATE) {
-               time_t now;
-
-               (void) time(&now);
-               v->iov_base = ctime(&now) + 4;
-       } else
-               v->iov_base = msg;
-       v->iov_len = 15;
-       v++;
-       v->iov_base = " ";
-       v->iov_len = 1;
-       v++;
-       v->iov_base = from;
-       v->iov_len = strlen(v->iov_base);
-       v++;
-       v->iov_base = " ";
-       v->iov_len = 1;
-       v++;
+       (void)time(&now);
        if (flags & ADDDATE)
        if (flags & ADDDATE)
-               v->iov_base = msg;
-       else
-               v->iov_base = msg + 16;
-       v->iov_len = strlen(v->iov_base);
-       v++;
+               timestamp = ctime(&now) + 4;
+       else {
+               timestamp = msg;
+               msg += 16;
+               msglen -= 16;
+       }
 
        /* extract facility and priority level */
 
        /* extract facility and priority level */
-       fac = (pri & LOG_FACMASK) >> 3;
-       prilev = pri & LOG_PRIMASK;
+       if (flags & MARK)
+               fac = LOG_NFACILITIES;
+       else
+               fac = LOG_FAC(pri);
+       prilev = LOG_PRI(pri);
 
        /* log the message to the particular outputs */
        if (!Initialized) {
 
        /* log the message to the particular outputs */
        if (!Initialized) {
-               int cfd = open(ctty, O_WRONLY);
+               f = &consfile;
+               f->f_file = open(ctty, O_WRONLY, 0);
 
 
-               if (cfd >= 0) {
-                       v->iov_base = "\r\n";
-                       v->iov_len = 2;
-                       (void) writev(cfd, iov, 6);
-                       (void) close(cfd);
+               if (f->f_file >= 0) {
+                       fprintlog(f, flags, msg);
+                       (void)close(f->f_file);
                }
                }
-               untty();
+               (void)sigsetmask(omask);
                return;
        }
                return;
        }
-       for (f = Files; f < &Files[NLOGS]; f++) {
+       for (f = Files; f; f = f->f_next) {
                /* skip messages that are incorrect priority */
                /* skip messages that are incorrect priority */
-               if (f->f_pmask[fac] < prilev || f->f_pmask[fac] == NOPRI)
+               if (f->f_pmask[fac] < prilev ||
+                   f->f_pmask[fac] == INTERNAL_NOPRI)
                        continue;
 
                        continue;
 
-               dprintf("Logging to %s", TypeNames[f->f_type]);
-               switch (f->f_type) {
-               case F_UNUSED:
-                       dprintf("\n");
-                       break;
+               if (f->f_type == F_CONSOLE && (flags & IGN_CONS))
+                       continue;
 
 
-               case F_FORW:
-                       dprintf(" %s\n", f->f_un.f_forw.f_hname);
-                       (void) sprintf(line, "<%d>%.15s %s", pri, v[0].iov_base,
-                               v[4].iov_base);
-                       l = strlen(line);
-                       if (l > MAXLINE)
-                               l = MAXLINE;
-                       if (sendto(f->f_file, line, l, 0,
-                           &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;
+               /* don't output marks to recently written files */
+               if ((flags & MARK) && (now - f->f_time) < MarkInterval / 2)
+                       continue;
 
 
-               case F_CONSOLE:
-                       if (flags & IGN_CONS) {
-                               dprintf(" (ignored)\n");
-                               break;
+               /*
+                * suppress duplicate lines to this file
+                */
+               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);
                        }
                        }
-
-               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 {
+                       /* new line, save it */
+                       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 {
                        } else {
-                               v->iov_base = "\n";
-                               v->iov_len = 1;
+                               f->f_prevline[0] = 0;
+                               f->f_prevlen = 0;
+                               fprintlog(f, flags, msg);
                        }
                        }
-                       if (writev(f->f_file, iov, 6) < 0) {
-                               int e = errno;
-                               (void) close(f->f_file);
-                               /*
-                                * Check for EBADF on TTY's due to vhangup() XXX
-                                */
-                               if (e == EBADF && f->f_type != F_FILE) {
-                                       f->f_file = open(f->f_un.f_fname, O_WRONLY|O_APPEND);
-                                       if (f->f_file < 0) {
-                                               f->f_type = F_UNUSED;
-                                               logerror(f->f_un.f_fname);
-                                       }
-                               } else {
-                                       f->f_type = F_UNUSED;
-                                       errno = e;
-                                       logerror(f->f_un.f_fname);
-                               }
-                       } else if (flags & SYNC_FILE)
-                               (void) fsync(f->f_file);
+               }
+       }
+       (void)sigsetmask(omask);
+}
+
+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++;
+
+       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++;
+
+       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;
                        break;
+               }
+               /* FALLTHROUGH */
 
 
-               case F_USERS:
-               case F_WALL:
-                       dprintf("\n");
+       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;
                        v->iov_base = "\r\n";
                        v->iov_len = 2;
-                       wallmsg(f, iov);
-                       break;
+               } else {
+                       v->iov_base = "\n";
+                       v->iov_len = 1;
                }
                }
-       }
+       again:
+               if (writev(f->f_file, iov, 6) < 0) {
+                       int e = errno;
+                       (void)close(f->f_file);
+                       /*
+                        * Check for errors on TTY's due to loss of tty
+                        */
+                       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 {
+                               f->f_type = F_UNUSED;
+                               errno = e;
+                               logerror(f->f_un.f_fname);
+                       }
+               } else if (flags & SYNC_FILE)
+                       (void)fsync(f->f_file);
+               break;
 
 
-       (void) sigsetmask(omask);
+       case F_USERS:
+       case F_WALL:
+               dprintf("\n");
+               v->iov_base = "\r\n";
+               v->iov_len = 2;
+               wallmsg(f, iov);
+               break;
+       }
+       f->f_prevcount = 0;
 }
 
 }
 
-
 /*
  *  WALLMSG -- Write a message to the world at large
  *
  *     Write the specified message to either the entire
  *     world, or a list of approved users.
  */
 /*
  *  WALLMSG -- Write a message to the world at large
  *
  *     Write the specified message to either the entire
  *     world, or a list of approved users.
  */
-
+void
 wallmsg(f, iov)
 wallmsg(f, iov)
-       register struct filed *f;
+       struct filed *f;
        struct iovec *iov;
 {
        struct iovec *iov;
 {
-       register char *p;
-       register int i;
-       int ttyf, len;
+       static int reenter;                     /* avoid calling ourselves */
        FILE *uf;
        FILE *uf;
-       static int reenter = 0;
        struct utmp ut;
        struct utmp ut;
-       time_t now;
-       char greetings[200];
+       int i;
+       char *p;
+       char line[sizeof(ut.ut_line) + 1];
 
        if (reenter++)
                return;
 
        if (reenter++)
                return;
-
-       /* open the user login file */
-       if ((uf = fopen("/etc/utmp", "r")) == NULL) {
-               logerror("/etc/utmp");
+       if ((uf = fopen(_PATH_UTMP, "r")) == NULL) {
+               logerror(_PATH_UTMP);
                reenter = 0;
                return;
        }
                reenter = 0;
                return;
        }
-
-       (void) time(&now);
-       (void) sprintf(greetings,
-           "\r\n\7Message from syslogd@%s at %.24s ...\r\n",
-               iov[2].iov_base, ctime(&now));
-       len = strlen(greetings);
-
-       /* scan the user login file */
-       while (fread((char *) &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 (f->f_type == F_USERS) {
-                       for (i = 0; i < MAXUNAMES; i++) {
-                               if (!f->f_un.f_uname[i][0]) {
-                                       i = MAXUNAMES;
-                                       break;
-                               }
-                               if (strncmp(f->f_un.f_uname[i], ut.ut_name,
-                                   UNAMESZ) == 0)
-                                       break;
+               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);
                        }
                        }
-                       if (i >= MAXUNAMES)
-                               continue;
+                       continue;
                }
                }
-
-               /* 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) {
-                       if (f->f_type == F_WALL) {
-                               iov[0].iov_base = greetings;
-                               iov[0].iov_len = len;
+               /* 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;
                        }
                        }
-                       (void) signal(SIGALRM, SIG_DFL);
-                       (void) alarm(30);
-                       /* open the terminal */
-                       ttyf = open(p, O_WRONLY);
-                       if (ttyf >= 0)
-                               (void) writev(ttyf, iov, 6);
-                       exit(0);
                }
                }
-               /* avoid having them all pile up at once */
-               sleep(1);
        }
        }
-       /* close the user login file */
-       (void) fclose(uf);
+       (void)fclose(uf);
        reenter = 0;
 }
 
        reenter = 0;
 }
 
-reapchild()
+void
+reapchild(signo)
+       int signo;
 {
        union wait status;
 
 {
        union wait status;
 
-       while (wait3(&status, WNOHANG, (struct rusage *) NULL) > 0)
+       while (wait3((int *)&status, WNOHANG, (struct rusage *)NULL) > 0)
                ;
 }
 
                ;
 }
 
@@ -753,7 +742,7 @@ cvthname(f)
        struct sockaddr_in *f;
 {
        struct hostent *hp;
        struct sockaddr_in *f;
 {
        struct hostent *hp;
-       extern char *inet_ntoa();
+       char *p;
 
        dprintf("cvthname(%s)\n", inet_ntoa(f->sin_addr));
 
 
        dprintf("cvthname(%s)\n", inet_ntoa(f->sin_addr));
 
@@ -761,117 +750,164 @@ cvthname(f)
                dprintf("Malformed from address\n");
                return ("???");
        }
                dprintf("Malformed from address\n");
                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));
                return (inet_ntoa(f->sin_addr));
        }
        if (hp == 0) {
                dprintf("Host name for your address (%s) unknown\n",
                        inet_ntoa(f->sin_addr));
                return (inet_ntoa(f->sin_addr));
        }
+       if ((p = strchr(hp->h_name, '.')) && strcmp(p + 1, LocalDomain) == 0)
+               *p = '\0';
        return (hp->h_name);
 }
 
        return (hp->h_name);
 }
 
-flushmsg()
+void
+domark(signo)
+       int signo;
 {
 {
-       if (PrevCount == 0)
-               return;
-       if (PrevCount > 1)
-               (void) sprintf(PrevLine+16, "last message repeated %d times", PrevCount);
-       PrevCount = 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];
 
-       if (errno == 0)
-               (void) sprintf(buf, "syslogd: %s", type);
-       else if ((unsigned) errno > sys_nerr)
-               (void) sprintf(buf, "syslogd: %s: error %d", type, errno);
+       if (errno)
+               (void)snprintf(buf,
+                   sizeof(buf), "syslogd: %s: %s", type, strerror(errno));
        else
        else
-               (void) sprintf(buf, "syslogd: %s: %s", 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_DAEMON|LOG_ERR, buf, LocalHostName, ADDDATE);
+       logmsg(LOG_SYSLOG|LOG_ERR, buf, LocalHostName, ADDDATE);
 }
 
 }
 
-die(sig)
+void
+die(signo)
+       int signo;
 {
 {
+       struct filed *f;
        char buf[100];
 
        char buf[100];
 
-       dprintf("syslogd: going down on signal %d\n", sig);
-       flushmsg();
-       (void) sprintf(buf, "going down on signal %d", sig);
-       logerror(buf);
-       (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);
 }
 
 /*
  *  INIT -- Initialize syslogd from configuration table
  */
        exit(0);
 }
 
 /*
  *  INIT -- Initialize syslogd from configuration table
  */
-
-init()
+void
+init(signo)
+       int signo;
 {
 {
-       register int i;
-       register FILE *cf;
-       register struct filed *f;
-       register char *p;
-       char cline[BUFSIZ];
+       int i;
+       FILE *cf;
+       struct filed *f, *next, **nextp;
+       char *p;
+       char cline[LINE_MAX];
 
        dprintf("init\n");
 
 
        dprintf("init\n");
 
-       /* flush any pending output */
-       flushmsg();
-
        /*
         *  Close all open log files.
         */
        /*
         *  Close all open log files.
         */
-       for (f = Files; f < &Files[NLOGS]; f++) {
-               if (f->f_type == F_FILE || f->f_type == F_TTY)
-                       (void) close(f->f_file);
-               f->f_type = F_UNUSED;
+       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);
 
        /* open the configuration file */
        if ((cf = fopen(ConfFile, "r")) == NULL) {
                dprintf("cannot open %s\n", ConfFile);
-               cfline("*.ERR\t/dev/console", &Files[0]);
-               cfline("*.PANIC\t*", &Files[1]);
+               *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.
         */
                return;
        }
 
        /*
         *  Foreach line in the conf table, open that file.
         */
-       f = Files;
-       while (fgets(cline, sizeof cline, cf) != NULL && f < &Files[NLOGS]) {
-               /* check for end-of-section */
-               if (cline[0] == '\n' || cline[0] == '#')
+       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;
                        continue;
-
-               /* strip off newline character */
-               p = index(cline, '\n');
-               if (p)
-                       *p = '\0';
-
-               cfline(cline, f++);
+               if (*p == NULL || *p == '#')
+                       continue;
+               for (p = strchr(cline, '\0'); isspace(*--p);)
+                       continue;
+               *++p = '\0';
+               f = (struct filed *)calloc(1, sizeof(*f));
+               *nextp = f;
+               nextp = &f->f_next;
+               cfline(cline, f);
        }
 
        /* close the configuration file */
        }
 
        /* close the configuration file */
-       (void) fclose(cf);
+       (void)fclose(cf);
 
        Initialized = 1;
 
        if (Debug) {
 
        Initialized = 1;
 
        if (Debug) {
-               for (f = Files; f < &Files[NLOGS]; f++) {
-                       for (i = 0; i < LOG_NFACILITIES; i++)
-                               if (f->f_pmask[i] == NOPRI)
+               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("X ");
                                else
                                        printf("%d ", f->f_pmask[i]);
@@ -896,70 +932,31 @@ init()
                }
        }
 
                }
        }
 
-       logmsg(LOG_DAEMON|LOG_INFO, "syslogd: restart", LocalHostName, ADDDATE);
+       logmsg(LOG_SYSLOG|LOG_INFO, "syslogd: restart", LocalHostName, ADDDATE);
        dprintf("syslogd: restarted\n");
 }
 
 /*
  * Crack a configuration file line
  */
        dprintf("syslogd: restarted\n");
 }
 
 /*
  * Crack a configuration file line
  */
-
-struct code {
-       char    *c_name;
-       int     c_val;
-};
-
-struct code    PriNames[] = {
-       "panic",        LOG_EMERG,
-       "emerg",        LOG_EMERG,
-       "alert",        LOG_ALERT,
-       "crit",         LOG_CRIT,
-       "err",          LOG_ERR,
-       "error",        LOG_ERR,
-       "warn",         LOG_WARNING,
-       "warning",      LOG_WARNING,
-       "notice",       LOG_NOTICE,
-       "info",         LOG_INFO,
-       "debug",        LOG_DEBUG,
-       NULL,           -1
-};
-
-struct code    FacNames[] = {
-       "kern",         LOG_KERN,
-       "user",         LOG_USER,
-       "mail",         LOG_MAIL,
-       "daemon",       LOG_DAEMON,
-       "auth",         LOG_AUTH,
-       "security",     LOG_AUTH,
-       "local0",       LOG_LOCAL0,
-       "local1",       LOG_LOCAL1,
-       "local2",       LOG_LOCAL2,
-       "local3",       LOG_LOCAL3,
-       "local4",       LOG_LOCAL4,
-       "local5",       LOG_LOCAL5,
-       "local6",       LOG_LOCAL6,
-       "local7",       LOG_LOCAL7,
-       NULL,           -1
-};
-
+void
 cfline(line, f)
        char *line;
 cfline(line, f)
        char *line;
-       register struct filed *f;
+       struct filed *f;
 {
 {
-       register char *p;
-       register char *q;
-       register int i;
-       char *bp;
-       int pri;
        struct hostent *hp;
        struct hostent *hp;
-       char buf[MAXLINE];
+       int i, pri;
+       char *bp, *p, *q;
+       char buf[MAXLINE], ebuf[100];
 
        dprintf("cfline(%s)\n", line);
 
 
        dprintf("cfline(%s)\n", line);
 
+       errno = 0;      /* keep strerror() stuff out of logerror messages */
+
        /* clear out file entry */
        /* clear out file entry */
-       bzero((char *) f, sizeof *f);
-       for (i = 0; i < LOG_NFACILITIES; i++)
-               f->f_pmask[i] = NOPRI;
+       memset(f, 0, sizeof(*f));
+       for (i = 0; i <= LOG_NFACILITIES; i++)
+               f->f_pmask[i] = INTERNAL_NOPRI;
 
        /* scan through the list of selectors */
        for (p = line; *p && *p != '\t';) {
 
        /* scan through the list of selectors */
        for (p = line; *p && *p != '\t';) {
@@ -969,41 +966,42 @@ cfline(line, f)
                        continue;
 
                /* collect priority name */
                        continue;
 
                /* collect priority name */
-               for (bp = buf; *q && !index("\t,;", *q); )
+               for (bp = buf; *q && !strchr("\t,;", *q); )
                        *bp++ = *q++;
                *bp = '\0';
 
                /* skip cruft */
                        *bp++ = *q++;
                *bp = '\0';
 
                /* skip cruft */
-               while (index(", ;", *q))
+               while (strchr(", ;", *q))
                        q++;
 
                /* decode priority name */
                        q++;
 
                /* decode priority name */
-               pri = decode(buf, PriNames);
-               if (pri < 0) {
-                       char xbuf[200];
-
-                       (void) sprintf(xbuf, "unknown priority name \"%s\"", buf);
-                       logerror(xbuf);
-                       return;
+               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 */
                }
 
                /* scan facilities */
-               while (*p && !index("\t.;", *p)) {
-                       int i;
-
-                       for (bp = buf; *p && !index("\t,;.", *p); )
+               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 {
                                *bp++ = *p++;
                        *bp = '\0';
                        if (*buf == '*')
                                for (i = 0; i < LOG_NFACILITIES; i++)
                                        f->f_pmask[i] = pri;
                        else {
-                               i = decode(buf, FacNames);
+                               i = decode(buf, facilitynames);
                                if (i < 0) {
                                if (i < 0) {
-                                       char xbuf[200];
-
-                                       (void) sprintf(xbuf, "unknown facility name \"%s\"", buf);
-                                       logerror(xbuf);
+                                       (void)sprintf(ebuf,
+                                           "unknown facility name \"%s\"",
+                                           buf);
+                                       logerror(ebuf);
                                        return;
                                }
                                f->f_pmask[i >> 3] = pri;
                                        return;
                                }
                                f->f_pmask[i >> 3] = pri;
@@ -1024,39 +1022,31 @@ cfline(line, f)
        case '@':
                if (!InetInuse)
                        break;
        case '@':
                if (!InetInuse)
                        break;
-               (void) strcpy(f->f_un.f_forw.f_hname, ++p);
+               (void)strcpy(f->f_un.f_forw.f_hname, ++p);
                hp = gethostbyname(p);
                if (hp == NULL) {
                hp = gethostbyname(p);
                if (hp == NULL) {
-                       char buf[100];
+                       extern int h_errno;
 
 
-                       (void) sprintf(buf, "unknown host %s", p);
-                       errno = 0;
-                       logerror(buf);
+                       logerror(hstrerror(h_errno));
                        break;
                }
                        break;
                }
-               bzero((char *) &f->f_un.f_forw.f_addr,
-                        sizeof f->f_un.f_forw.f_addr);
+               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;
                f->f_un.f_forw.f_addr.sin_family = AF_INET;
                f->f_un.f_forw.f_addr.sin_port = LogPort;
-               bcopy(hp->h_addr, (char *) &f->f_un.f_forw.f_addr.sin_addr, hp->h_length);
-               f->f_file = socket(AF_INET, SOCK_DGRAM, 0);
-               if (f->f_file < 0) {
-                       logerror("socket");
-                       break;
-               }
+               memmove(&f->f_un.f_forw.f_addr.sin_addr, hp->h_addr, hp->h_length);
                f->f_type = F_FORW;
                break;
 
        case '/':
                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) {
+               (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;
                }
                        logerror(p);
                        break;
                }
-               if (isatty(f->f_file)) {
+               if (isatty(f->f_file))
                        f->f_type = F_TTY;
                        f->f_type = F_TTY;
-                       untty();
-               }
                else
                        f->f_type = F_FILE;
                if (strcmp(p, ctty) == 0)
                else
                        f->f_type = F_FILE;
                if (strcmp(p, ctty) == 0)
@@ -1071,9 +1061,9 @@ cfline(line, f)
                for (i = 0; i < MAXUNAMES && *p; i++) {
                        for (q = p; *q && *q != ','; )
                                q++;
                for (i = 0; i < MAXUNAMES && *p; i++) {
                        for (q = p; *q && *q != ','; )
                                q++;
-                       (void) strncpy(f->f_un.f_uname[i], p, UNAMESZ);
-                       if ((q - p) > UNAMESZ)
-                               f->f_un.f_uname[i][UNAMESZ] = '\0';
+                       (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 == ' ')
                        else
                                f->f_un.f_uname[i][q - p] = '\0';
                        while (*q == ',' || *q == ' ')
@@ -1089,22 +1079,24 @@ cfline(line, f)
 /*
  *  Decode a symbolic name to a numeric value
  */
 /*
  *  Decode a symbolic name to a numeric value
  */
-
+int
 decode(name, codetab)
 decode(name, codetab)
-       char *name;
-       struct code *codetab;
+       const char *name;
+       CODE *codetab;
 {
 {
-       register struct code *c;
-       register char *p;
-       char buf[40];
+       CODE *c;
+       char *p, buf[40];
 
        if (isdigit(*name))
                return (atoi(name));
 
 
        if (isdigit(*name))
                return (atoi(name));
 
-       (void) strcpy(buf, name);
-       for (p = buf; *p; p++)
-               if (isupper(*p))
-                       *p = tolower(*p);
+       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);
        for (c = codetab; c->c_name; c++)
                if (!strcmp(buf, c->c_name))
                        return (c->c_val);
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.