Changeset 3232 in MondoRescue for branches/3.2/mindi-busybox/sysklogd

Timestamp:

Jan 1, 2014, 12:47:38 AM (11 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.21.1

Location:

branches/3.2/mindi-busybox/sysklogd

Files:

• Config.src (modified) (3 diffs)
• klogd.c (modified) (4 diffs)
• logger.c (modified) (1 diff)
• logread.c (modified) (1 diff)
• syslogd.c (modified) (27 diffs)

branches/3.2/mindi-busybox/sysklogd/Config.src

@@ -52 +52 @@
       Option -D instructs syslogd to drop consecutive messages
       which are totally the same.
+
+config FEATURE_SYSLOGD_CFG
+    bool "Support syslog.conf"
+    default y
+    depends on SYSLOGD
+    help
+      Supports restricted syslogd config. See docs/syslog.conf.txt
 
 config FEATURE_SYSLOGD_READ_BUFFER_SIZE
@@ -107 +114 @@
       contention at some minor memory expense.
 
+config FEATURE_KMSG_SYSLOG
+    bool "Linux kernel printk buffer support"
+    default y
+    depends on SYSLOGD
+    select PLATFORM_LINUX
+    help
+      When you enable this feature, the syslogd utility will
+      write system log message to the Linux kernel's printk buffer.
+      This can be used as a smaller alternative to the syslogd IPC
+      support, as klogd and logread aren't needed.
+
+      NOTICE: Syslog facilities in log entries needs kernel 3.5+.
+
 config KLOGD
     bool "klogd"
@@ -117 +137 @@
       you should enable this option.
 
+comment "klogd should not be used together with syslog to kernel printk buffer"
+    depends on KLOGD && FEATURE_KMSG_SYSLOG
+
 config FEATURE_KLOGD_KLOGCTL
     bool "Use the klogctl() interface"
     default y
-    depends on KLOGD && PLATFORM_LINUX
+    depends on KLOGD
+    select PLATFORM_LINUX
     help
       The klogd applet supports two interfaces for reading

branches/3.2/mindi-busybox/sysklogd/klogd.c

@@ -17 +17 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+
+//usage:#define klogd_trivial_usage
+//usage:       "[-c N] [-n]"
+//usage:#define klogd_full_usage "\n\n"
+//usage:       "Kernel logger\n"
+//usage:     "\n    -c N    Print to console messages more urgent than prio N (1-8)"
+//usage:     "\n    -n  Run in foreground"
 
 #include "libbb.h"
@@ -189 +196 @@
     syslog(LOG_NOTICE, "klogd started: %s", bb_banner);
 
+    write_pidfile(CONFIG_PID_FILE_PATH "/klogd.pid");
+
     used = 0;
     while (!bb_got_signal) {
@@ -232 +241 @@
             if (*start == '<') {
                 start++;
-                if (*start) {
-                    /* kernel never generates multi-digit prios */
-                    priority = (*start - '0');
-                    start++;
-                }
+                if (*start)
+                    priority = strtoul(start, &start, 10);
                 if (*start == '>')
                     start++;
@@ -252 +258 @@
     klogd_close();
     syslog(LOG_NOTICE, "klogd: exiting");
+    remove_pidfile(CONFIG_PID_FILE_PATH "/klogd.pid");
     if (bb_got_signal)
         kill_myself_with_sig(bb_got_signal);

branches/3.2/mindi-busybox/sysklogd/logger.c

@@ -7 +7 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+
+//usage:#define logger_trivial_usage
+//usage:       "[OPTIONS] [MESSAGE]"
+//usage:#define logger_full_usage "\n\n"
+//usage:       "Write MESSAGE (or stdin) to syslog\n"
+//usage:     "\n    -s  Log to stderr as well as the system log"
+//usage:     "\n    -t TAG  Log using the specified tag (defaults to user name)"
+//usage:     "\n    -p PRIO Priority (numeric or facility.level pair)"
+//usage:
+//usage:#define logger_example_usage
+//usage:       "$ logger \"hello\"\n"
 
 /*

branches/3.2/mindi-busybox/sysklogd/logread.c

@@ -9 +9 @@
  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
+
+//usage:#define logread_trivial_usage
+//usage:       "[-f]"
+//usage:#define logread_full_usage "\n\n"
+//usage:       "Show messages in syslogd's circular buffer\n"
+//usage:     "\n    -f  Output data as log grows"
 
 #include "libbb.h"

branches/3.2/mindi-busybox/sysklogd/syslogd.c

@@ -14 +14 @@
  */
 
+//usage:#define syslogd_trivial_usage
+//usage:       "[OPTIONS]"
+//usage:#define syslogd_full_usage "\n\n"
+//usage:       "System logging utility\n"
+//usage:    IF_NOT_FEATURE_SYSLOGD_CFG(
+//usage:       "(this version of syslogd ignores /etc/syslog.conf)\n"
+//usage:    )
+//usage:     "\n    -n      Run in foreground"
+//usage:     "\n    -O FILE     Log to FILE (default:/var/log/messages)"
+//usage:     "\n    -l N        Log only messages more urgent than prio N (1-8)"
+//usage:     "\n    -S      Smaller output"
+//usage:    IF_FEATURE_ROTATE_LOGFILE(
+//usage:     "\n    -s SIZE     Max size (KB) before rotation (default:200KB, 0=off)"
+//usage:     "\n    -b N        N rotated logs to keep (default:1, max=99, 0=purge)"
+//usage:    )
+//usage:    IF_FEATURE_REMOTE_LOG(
+//usage:     "\n    -R HOST[:PORT]  Log to IP or hostname on PORT (default PORT=514/UDP)"
+//usage:     "\n    -L      Log locally and via network (default is network only if -R)"
+//usage:    )
+//usage:    IF_FEATURE_SYSLOGD_DUP(
+//usage:     "\n    -D      Drop duplicates"
+//usage:    )
+//usage:    IF_FEATURE_IPC_SYSLOG(
+/* NB: -Csize shouldn't have space (because size is optional) */
+//usage:     "\n    -C[size_kb] Log to shared mem buffer (use logread to read it)"
+//usage:    )
+//usage:    IF_FEATURE_SYSLOGD_CFG(
+//usage:     "\n    -f FILE     Use FILE as config (default:/etc/syslog.conf)"
+//usage:    )
+/* //usage:  "\n    -m MIN      Minutes between MARK lines (default:20, 0=off)" */
+//usage:    IF_FEATURE_KMSG_SYSLOG(
+//usage:     "\n    -K      Log to kernel printk buffer (use dmesg to read it)"
+//usage:    )
+//usage:
+//usage:#define syslogd_example_usage
+//usage:       "$ syslogd -R masterlog:514\n"
+//usage:       "$ syslogd -R 192.168.1.1:601\n"
+
 /*
  * Done in syslogd_and_logger.c:
@@ -67 +105 @@
 #endif
 
+typedef struct logFile_t {
+    const char *path;
+    int fd;
+#if ENABLE_FEATURE_ROTATE_LOGFILE
+    unsigned size;
+    uint8_t isRegular;
+#endif
+} logFile_t;
+
+#if ENABLE_FEATURE_SYSLOGD_CFG
+typedef struct logRule_t {
+    uint8_t enabled_facility_priomap[LOG_NFACILITIES];
+    struct logFile_t *file;
+    struct logRule_t *next;
+} logRule_t;
+#endif
+
 /* Allows us to have smaller initializer. Ugly. */
 #define GLOBALS \
-    const char *logFilePath;                \
-    int logFD;                              \
+    logFile_t logFile;                      \
     /* interval between marks in seconds */ \
     /*int markInterval;*/                   \
@@ -80 +134 @@
     /* number of rotated message files */   \
     unsigned logFileRotate;                 \
-    unsigned curFileSize;                   \
-    smallint isRegular;                     \
 ) \
 IF_FEATURE_IPC_SYSLOG( \
@@ -89 +141 @@
     struct sembuf SMwup[1];                 \
     struct sembuf SMwdn[3];                 \
+) \
+IF_FEATURE_SYSLOGD_CFG( \
+    logRule_t *log_rules; \
+) \
+IF_FEATURE_KMSG_SYSLOG( \
+    int kmsgfd; \
+    int primask; \
 )
 
@@ -120 +179 @@
 
 static const struct init_globals init_data = {
-    .logFilePath = "/var/log/messages",
-    .logFD = -1,
+    .logFile = {
+        .path = "/var/log/messages",
+        .fd = -1,
+    },
 #ifdef SYSLOGD_MARK
     .markInterval = 20 * 60,
@@ -133 +194 @@
     .shmid = -1,
     .s_semid = -1,
-    .shm_size = ((CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE)*1024), // default shm size
+    .shm_size = ((CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE)*1024), /* default shm size */
     .SMwup = { {1, -1, IPC_NOWAIT} },
     .SMwdn = { {0, 0}, {1, 0}, {1, +1} },
@@ -158 +219 @@
     IF_FEATURE_IPC_SYSLOG(    OPTBIT_circularlog,)  // -C
     IF_FEATURE_SYSLOGD_DUP(   OPTBIT_dup        ,)  // -D
+    IF_FEATURE_SYSLOGD_CFG(   OPTBIT_cfg        ,)  // -f
+    IF_FEATURE_KMSG_SYSLOG(   OPTBIT_kmsg       ,)  // -K
 
     OPT_mark        = 1 << OPTBIT_mark    ,
@@ -170 +233 @@
     OPT_circularlog = IF_FEATURE_IPC_SYSLOG(    (1 << OPTBIT_circularlog)) + 0,
     OPT_dup         = IF_FEATURE_SYSLOGD_DUP(   (1 << OPTBIT_dup        )) + 0,
+    OPT_cfg         = IF_FEATURE_SYSLOGD_CFG(   (1 << OPTBIT_cfg        )) + 0,
+    OPT_kmsg        = IF_FEATURE_KMSG_SYSLOG(   (1 << OPTBIT_kmsg       )) + 0,
+
 };
 #define OPTION_STR "m:nO:l:S" \
@@ -177 +243 @@
     IF_FEATURE_REMOTE_LOG(    "L"  ) \
     IF_FEATURE_IPC_SYSLOG(    "C::") \
-    IF_FEATURE_SYSLOGD_DUP(   "D"  )
+    IF_FEATURE_SYSLOGD_DUP(   "D"  ) \
+    IF_FEATURE_SYSLOGD_CFG(   "f:" ) \
+    IF_FEATURE_KMSG_SYSLOG(   "K"  )
 #define OPTION_DECL *opt_m, *opt_l \
     IF_FEATURE_ROTATE_LOGFILE(,*opt_s) \
     IF_FEATURE_ROTATE_LOGFILE(,*opt_b) \
-    IF_FEATURE_IPC_SYSLOG(    ,*opt_C = NULL)
-#define OPTION_PARAM &opt_m, &G.logFilePath, &opt_l \
+    IF_FEATURE_IPC_SYSLOG(    ,*opt_C = NULL) \
+    IF_FEATURE_SYSLOGD_CFG(   ,*opt_f = NULL)
+#define OPTION_PARAM &opt_m, &(G.logFile.path), &opt_l \
     IF_FEATURE_ROTATE_LOGFILE(,&opt_s) \
     IF_FEATURE_ROTATE_LOGFILE(,&opt_b) \
-    IF_FEATURE_REMOTE_LOG(    ,&remoteAddrList) \
-    IF_FEATURE_IPC_SYSLOG(    ,&opt_C)
-
+    IF_FEATURE_REMOTE_LOG(    ,&remoteAddrList) \
+    IF_FEATURE_IPC_SYSLOG(    ,&opt_C) \
+    IF_FEATURE_SYSLOGD_CFG(   ,&opt_f)
+
+
+#if ENABLE_FEATURE_SYSLOGD_CFG
+static const CODE* find_by_name(char *name, const CODE* c_set)
+{
+    for (; c_set->c_name; c_set++) {
+        if (strcmp(name, c_set->c_name) == 0)
+            return c_set;
+    }
+    return NULL;
+}
+#endif
+static const CODE* find_by_val(int val, const CODE* c_set)
+{
+    for (; c_set->c_name; c_set++) {
+        if (c_set->c_val == val)
+            return c_set;
+    }
+    return NULL;
+}
+
+#if ENABLE_FEATURE_SYSLOGD_CFG
+static void parse_syslogdcfg(const char *file)
+{
+    char *t;
+    logRule_t **pp_rule;
+    /* tok[0] set of selectors */
+    /* tok[1] file name */
+    /* tok[2] has to be NULL */
+    char *tok[3];
+    parser_t *parser;
+
+    parser = config_open2(file ? file : "/etc/syslog.conf",
+                file ? xfopen_for_read : fopen_for_read);
+    if (!parser)
+        /* didn't find default /etc/syslog.conf */
+        /* proceed as if we built busybox without config support */
+        return;
+
+    /* use ptr to ptr to avoid checking whether head was initialized */
+    pp_rule = &G.log_rules;
+    /* iterate through lines of config, skipping comments */
+    while (config_read(parser, tok, 3, 2, "# \t", PARSE_NORMAL | PARSE_MIN_DIE)) {
+        char *cur_selector;
+        logRule_t *cur_rule;
+
+        /* unexpected trailing token? */
+        if (tok[2])
+            goto cfgerr;
+
+        cur_rule = *pp_rule = xzalloc(sizeof(*cur_rule));
+
+        cur_selector = tok[0];
+        /* iterate through selectors: "kern.info;kern.!err;..." */
+        do {
+            const CODE *code;
+            char *next_selector;
+            uint8_t negated_prio; /* "kern.!err" */
+            uint8_t single_prio;  /* "kern.=err" */
+            uint32_t facmap; /* bitmap of enabled facilities */
+            uint8_t primap;  /* bitmap of enabled priorities */
+            unsigned i;
+
+            next_selector = strchr(cur_selector, ';');
+            if (next_selector)
+                *next_selector++ = '\0';
+
+            t = strchr(cur_selector, '.');
+            if (!t)
+                goto cfgerr;
+            *t++ = '\0'; /* separate facility from priority */
+
+            negated_prio = 0;
+            single_prio = 0;
+            if (*t == '!') {
+                negated_prio = 1;
+                ++t;
+            }
+            if (*t == '=') {
+                single_prio = 1;
+                ++t;
+            }
+
+            /* parse priority */
+            if (*t == '*')
+                primap = 0xff; /* all 8 log levels enabled */
+            else {
+                uint8_t priority;
+                code = find_by_name(t, prioritynames);
+                if (!code)
+                    goto cfgerr;
+                primap = 0;
+                priority = code->c_val;
+                if (priority == INTERNAL_NOPRI) {
+                    /* ensure we take "enabled_facility_priomap[fac] &= 0" branch below */
+                    negated_prio = 1;
+                } else {
+                    priority = 1 << priority;
+                    do {
+                        primap |= priority;
+                        if (single_prio)
+                            break;
+                        priority >>= 1;
+                    } while (priority);
+                    if (negated_prio)
+                        primap = ~primap;
+                }
+            }
+
+            /* parse facility */
+            if (*cur_selector == '*')
+                facmap = (1<<LOG_NFACILITIES) - 1;
+            else {
+                char *next_facility;
+                facmap = 0;
+                t = cur_selector;
+                /* iterate through facilities: "kern,daemon.<priospec>" */
+                do {
+                    next_facility = strchr(t, ',');
+                    if (next_facility)
+                        *next_facility++ = '\0';
+                    code = find_by_name(t, facilitynames);
+                    if (!code)
+                        goto cfgerr;
+                    /* "mark" is not a real facility, skip it */
+                    if (code->c_val != INTERNAL_MARK)
+                        facmap |= 1<<(LOG_FAC(code->c_val));
+                    t = next_facility;
+                } while (t);
+            }
+
+            /* merge result with previous selectors */
+            for (i = 0; i < LOG_NFACILITIES; ++i) {
+                if (!(facmap & (1<<i)))
+                    continue;
+                if (negated_prio)
+                    cur_rule->enabled_facility_priomap[i] &= primap;
+                else
+                    cur_rule->enabled_facility_priomap[i] |= primap;
+            }
+
+            cur_selector = next_selector;
+        } while (cur_selector);
+
+        /* check whether current file name was mentioned in previous rules or
+         * as global logfile (G.logFile).
+         */
+        if (strcmp(G.logFile.path, tok[1]) == 0) {
+            cur_rule->file = &G.logFile;
+            goto found;
+        }
+        /* temporarily use cur_rule as iterator, but *pp_rule still points
+         * to currently processing rule entry.
+         * NOTE: *pp_rule points to the current (and last in the list) rule.
+         */
+        for (cur_rule = G.log_rules; cur_rule != *pp_rule; cur_rule = cur_rule->next) {
+            if (strcmp(cur_rule->file->path, tok[1]) == 0) {
+                /* found - reuse the same file structure */
+                (*pp_rule)->file = cur_rule->file;
+                cur_rule = *pp_rule;
+                goto found;
+            }
+        }
+        cur_rule->file = xzalloc(sizeof(*cur_rule->file));
+        cur_rule->file->fd = -1;
+        cur_rule->file->path = xstrdup(tok[1]);
+ found:
+        pp_rule = &cur_rule->next;
+    }
+    config_close(parser);
+    return;
+
+ cfgerr:
+    bb_error_msg_and_die("error in '%s' at line %d",
+            file ? file : "/etc/syslog.conf",
+            parser->lineno);
+}
+#endif
 
 /* circular buffer variables/structures */
@@ -232 +479 @@
     /*G.shbuf->tail = 0;*/
 
-    // we'll trust the OS to set initial semval to 0 (let's hope)
+    /* we'll trust the OS to set initial semval to 0 (let's hope) */
     G.s_semid = semget(KEY_ID, 2, IPC_CREAT | IPC_EXCL | 1023);
     if (G.s_semid == -1) {
@@ -245 +492 @@
 
 /* Write message to shared mem buffer */
-static void log_to_shmem(const char *msg, int len)
+static void log_to_shmem(const char *msg)
 {
     int old_tail, new_tail;
+    int len;
 
     if (semop(G.s_semid, G.SMwdn, 3) == -1) {
@@ -259 +507 @@
      * Last byte of buffer is never used and remains NUL.
      */
-    len++; /* length with NUL included */
+    len = strlen(msg) + 1; /* length with NUL included */
  again:
     old_tail = G.shbuf->tail;
@@ -284 +532 @@
 }
 #else
-void ipcsyslog_cleanup(void);
-void ipcsyslog_init(void);
+static void ipcsyslog_cleanup(void) {}
+static void ipcsyslog_init(void) {}
 void log_to_shmem(const char *msg);
 #endif /* FEATURE_IPC_SYSLOG */
 
+#if ENABLE_FEATURE_KMSG_SYSLOG
+static void kmsg_init(void)
+{
+    G.kmsgfd = xopen("/dev/kmsg", O_WRONLY);
+
+    /*
+     * kernel < 3.5 expects single char printk KERN_* priority prefix,
+     * from 3.5 onwards the full syslog facility/priority format is supported
+     */
+    if (get_linux_version_code() < KERNEL_VERSION(3,5,0))
+        G.primask = LOG_PRIMASK;
+    else
+        G.primask = -1;
+}
+
+static void kmsg_cleanup(void)
+{
+    if (ENABLE_FEATURE_CLEAN_UP)
+        close(G.kmsgfd);
+}
+
+/* Write message to /dev/kmsg */
+static void log_to_kmsg(int pri, const char *msg)
+{
+    /*
+     * kernel < 3.5 expects single char printk KERN_* priority prefix,
+     * from 3.5 onwards the full syslog facility/priority format is supported
+     */
+    pri &= G.primask;
+
+    write(G.kmsgfd, G.printbuf, sprintf(G.printbuf, "<%d>%s\n", pri, msg));
+}
+#else
+static void kmsg_init(void) {}
+static void kmsg_cleanup(void) {}
+static void log_to_kmsg(int pri UNUSED_PARAM, const char *msg UNUSED_PARAM) {}
+#endif /* FEATURE_KMSG_SYSLOG */
 
 /* Print a message to the log file. */
-static void log_locally(time_t now, char *msg)
+static void log_locally(time_t now, char *msg, logFile_t *log_file)
 {
 #ifdef SYSLOGD_WRLOCK
@@ -298 +583 @@
     int len = strlen(msg);
 
-#if ENABLE_FEATURE_IPC_SYSLOG
-    if ((option_mask32 & OPT_circularlog) && G.shbuf) {
-        log_to_shmem(msg, len);
-        return;
-    }
-#endif
-    if (G.logFD >= 0) {
+    if (log_file->fd >= 0) {
         /* Reopen log file every second. This allows admin
          * to delete the file and not worry about restarting us.
@@ -314 +593 @@
         if (G.last_log_time != now) {
             G.last_log_time = now;
-            close(G.logFD);
+            close(log_file->fd);
             goto reopen;
         }
     } else {
  reopen:
-        G.logFD = open(G.logFilePath, O_WRONLY | O_CREAT
+        log_file->fd = open(log_file->path, O_WRONLY | O_CREAT
                     | O_NOCTTY | O_APPEND | O_NONBLOCK,
                     0666);
-        if (G.logFD < 0) {
+        if (log_file->fd < 0) {
             /* cannot open logfile? - print to /dev/console then */
             int fd = device_open(DEV_CONSOLE, O_WRONLY | O_NOCTTY | O_NONBLOCK);
@@ -335 +614 @@
         {
             struct stat statf;
-            G.isRegular = (fstat(G.logFD, &statf) == 0 && S_ISREG(statf.st_mode));
+            log_file->isRegular = (fstat(log_file->fd, &statf) == 0 && S_ISREG(statf.st_mode));
             /* bug (mostly harmless): can wrap around if file > 4gb */
-            G.curFileSize = statf.st_size;
+            log_file->size = statf.st_size;
         }
 #endif
@@ -347 +626 @@
     fl.l_len = 1;
     fl.l_type = F_WRLCK;
-    fcntl(G.logFD, F_SETLKW, &fl);
+    fcntl(log_file->fd, F_SETLKW, &fl);
 #endif
 
 #if ENABLE_FEATURE_ROTATE_LOGFILE
-    if (G.logFileSize && G.isRegular && G.curFileSize > G.logFileSize) {
+    if (G.logFileSize && log_file->isRegular && log_file->size > G.logFileSize) {
         if (G.logFileRotate) { /* always 0..99 */
-            int i = strlen(G.logFilePath) + 3 + 1;
+            int i = strlen(log_file->path) + 3 + 1;
             char oldFile[i];
             char newFile[i];
@@ -359 +638 @@
             /* rename: f.8 -> f.9; f.7 -> f.8; ... */
             while (1) {
-                sprintf(newFile, "%s.%d", G.logFilePath, i);
+                sprintf(newFile, "%s.%d", log_file->path, i);
                 if (i == 0) break;
-                sprintf(oldFile, "%s.%d", G.logFilePath, --i);
+                sprintf(oldFile, "%s.%d", log_file->path, --i);
                 /* ignore errors - file might be missing */
                 rename(oldFile, newFile);
             }
             /* newFile == "f.0" now */
-            rename(G.logFilePath, newFile);
+            rename(log_file->path, newFile);
+            /* Incredibly, if F and F.0 are hardlinks, POSIX
+             * _demands_ that rename returns 0 but does not
+             * remove F!!!
+             * (hardlinked F/F.0 pair was observed after
+             * power failure during rename()).
+             * Ensure old file is gone:
+             */
+            unlink(log_file->path);
 #ifdef SYSLOGD_WRLOCK
             fl.l_type = F_UNLCK;
-            fcntl(G.logFD, F_SETLKW, &fl);
-#endif
-            close(G.logFD);
+            fcntl(log_file->fd, F_SETLKW, &fl);
+#endif
+            close(log_file->fd);
             goto reopen;
         }
-        ftruncate(G.logFD, 0);
-    }
-    G.curFileSize +=
-#endif
-            full_write(G.logFD, msg, len);
+        ftruncate(log_file->fd, 0);
+    }
+    log_file->size +=
+#endif
+            full_write(log_file->fd, msg, len);
 #ifdef SYSLOGD_WRLOCK
     fl.l_type = F_UNLCK;
-    fcntl(G.logFD, F_SETLKW, &fl);
+    fcntl(log_file->fd, F_SETLKW, &fl);
 #endif
 }
@@ -389 +676 @@
     const CODE *c_pri, *c_fac;
 
-    if (pri != 0) {
-        c_fac = facilitynames;
-        while (c_fac->c_name) {
-            if (c_fac->c_val != (LOG_FAC(pri) << 3)) {
-                c_fac++;
-                continue;
-            }
-            /* facility is found, look for prio */
-            c_pri = prioritynames;
-            while (c_pri->c_name) {
-                if (c_pri->c_val != LOG_PRI(pri)) {
-                    c_pri++;
-                    continue;
-                }
-                snprintf(res20, 20, "%s.%s",
-                        c_fac->c_name, c_pri->c_name);
-                return;
-            }
-            /* prio not found, bail out */
-            break;
-        }
-        snprintf(res20, 20, "<%d>", pri);
-    }
+    c_fac = find_by_val(LOG_FAC(pri) << 3, facilitynames);
+    if (c_fac) {
+        c_pri = find_by_val(LOG_PRI(pri), prioritynames);
+        if (c_pri) {
+            snprintf(res20, 20, "%s.%s", c_fac->c_name, c_pri->c_name);
+            return;
+        }
+    }
+    snprintf(res20, 20, "<%d>", pri);
 }
 
@@ -436 +709 @@
     timestamp[15] = '\0';
 
+    if (option_mask32 & OPT_kmsg) {
+        log_to_kmsg(pri, msg);
+        return;
+    }
+
     if (option_mask32 & OPT_small)
         sprintf(G.printbuf, "%s %s\n", timestamp, msg);
@@ -445 +723 @@
 
     /* Log message locally (to file or shared mem) */
-    log_locally(now, G.printbuf);
+#if ENABLE_FEATURE_SYSLOGD_CFG
+    {
+        bool match = 0;
+        logRule_t *rule;
+        uint8_t facility = LOG_FAC(pri);
+        uint8_t prio_bit = 1 << LOG_PRI(pri);
+
+        for (rule = G.log_rules; rule; rule = rule->next) {
+            if (rule->enabled_facility_priomap[facility] & prio_bit) {
+                log_locally(now, G.printbuf, rule->file);
+                match = 1;
+            }
+        }
+        if (match)
+            return;
+    }
+#endif
+    if (LOG_PRI(pri) < G.logLevel) {
+#if ENABLE_FEATURE_IPC_SYSLOG
+        if ((option_mask32 & OPT_circularlog) && G.shbuf) {
+            log_to_shmem(G.printbuf);
+            return;
+        }
+#endif
+        log_locally(now, G.printbuf, &G.logFile);
+    }
 }
 
@@ -490 +793 @@
 
         /* Now log it */
-        if (LOG_PRI(pri) < G.logLevel)
-            timestamp_and_log(pri, G.parsebuf, q - G.parsebuf);
+        timestamp_and_log(pri, G.parsebuf, q - G.parsebuf);
     }
 }
@@ -512 +814 @@
     int sock_fd;
     char *dev_log_name;
+
+#if ENABLE_FEATURE_SYSTEMD
+    if (sd_listen_fds() == 1)
+        return SD_LISTEN_FDS_START;
+#endif
 
     memset(&sunx, 0, sizeof(sunx));
@@ -577 +884 @@
     sock_fd = create_socket();
 
-    if (ENABLE_FEATURE_IPC_SYSLOG && (option_mask32 & OPT_circularlog)) {
+    if (option_mask32 & OPT_circularlog)
         ipcsyslog_init();
-    }
+
+    if (option_mask32 & OPT_kmsg)
+        kmsg_init();
 
     timestamp_and_log_internal("syslogd started: BusyBox v" BB_VER);
@@ -666 +975 @@
     timestamp_and_log_internal("syslogd exiting");
     puts("syslogd exiting");
-    if (ENABLE_FEATURE_IPC_SYSLOG)
-        ipcsyslog_cleanup();
+    remove_pidfile(CONFIG_PID_FILE_PATH "/syslogd.pid");
+    ipcsyslog_cleanup();
+    if (option_mask32 & OPT_kmsg)
+        kmsg_cleanup();
     kill_myself_with_sig(bb_got_signal);
 #undef recvbuf
@@ -715 +1026 @@
         G.shm_size = xatoul_range(opt_C, 4, INT_MAX/1024) * 1024;
 #endif
-
     /* If they have not specified remote logging, then log locally */
     if (ENABLE_FEATURE_REMOTE_LOG && !(opts & OPT_remotelog)) // -R
         option_mask32 |= OPT_locallog;
+#if ENABLE_FEATURE_SYSLOGD_CFG
+    parse_syslogdcfg(opt_f);
+#endif
 
     /* Store away localhost's name before the fork */
@@ -727 +1040 @@
         bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
     }
+
     //umask(0); - why??
-    write_pidfile("/var/run/syslogd.pid");
+    write_pidfile(CONFIG_PID_FILE_PATH "/syslogd.pid");
+
     do_syslogd();
     /* return EXIT_SUCCESS; */