diff options
Diffstat (limited to 'release/src/router/busybox/sysklogd')
| -rw-r--r--[-rwxr-xr-x] | release/src/router/busybox/sysklogd/Config.in | 88 | ||||
| -rw-r--r-- | release/src/router/busybox/sysklogd/Kbuild | 11 | ||||
| -rw-r--r-- | release/src/router/busybox/sysklogd/Makefile | 30 | ||||
| -rwxr-xr-x | release/src/router/busybox/sysklogd/Makefile.in | 35 | ||||
| -rw-r--r-- | release/src/router/busybox/sysklogd/klogd.c | 214 | ||||
| -rw-r--r-- | release/src/router/busybox/sysklogd/logger.c | 168 | ||||
| -rw-r--r-- | release/src/router/busybox/sysklogd/logread.c | 262 | ||||
| -rw-r--r-- | release/src/router/busybox/sysklogd/syslogd.c | 1083 | ||||
| -rw-r--r-- | release/src/router/busybox/sysklogd/syslogd_and_logger.c | 51 |
9 files changed, 1003 insertions, 939 deletions
diff --git a/release/src/router/busybox/sysklogd/Config.in b/release/src/router/busybox/sysklogd/Config.in index 87b9ed7a..0664be08 100755..100644 --- a/release/src/router/busybox/sysklogd/Config.in +++ b/release/src/router/busybox/sysklogd/Config.in @@ -5,77 +5,113 @@ menu "System Logging Utilities" -config CONFIG_SYSLOGD +config SYSLOGD bool "syslogd" default n help The syslogd utility is used to record logs of all the - significant events that occur on a system. Every + significant events that occur on a system. Every message that is logged records the date and time of the event, and will generally also record the name of the - application that generated the message. When used in + application that generated the message. When used in conjunction with klogd, messages from the Linux kernel - can also be recorded. This is terribly useful, - especially for finding what happened when somthing goes - wrong. And something almost always will go wrong if + can also be recorded. This is terribly useful, + especially for finding what happened when something goes + wrong. And something almost always will go wrong if you wait long enough.... -config CONFIG_FEATURE_REMOTE_LOG - bool " Remote Log support" +config FEATURE_ROTATE_LOGFILE + bool "Rotate message files" default n - depends on CONFIG_SYSLOGD + depends on SYSLOGD + help + This enables syslogd to rotate the message files + on his own. No need to use an external rotatescript. + +config FEATURE_REMOTE_LOG + bool "Remote Log support" + default n + depends on SYSLOGD help When you enable this feature, the syslogd utility can be used to send system log messages to another system - connected via a network. This allows the remote + connected via a network. This allows the remote machine to log all the system messages, which can be terribly useful for reducing the number of serial - cables you use. It can also be a very good security + cables you use. It can also be a very good security measure to prevent system logs from being tampered with by an intruder. -config CONFIG_FEATURE_IPC_SYSLOG - bool " Circular Buffer support" +config FEATURE_SYSLOGD_DUP + bool "Support -D (drop dups) option" + default n + depends on SYSLOGD + help + Option -D instructs syslogd to drop consecutive messages + which are totally the same. + +config FEATURE_IPC_SYSLOG + bool "Circular Buffer support" default n - depends on CONFIG_SYSLOGD + depends on SYSLOGD help When you enable this feature, the syslogd utility will use a circular buffer to record system log messages. When the buffer is filled it will continue to overwrite - the oldest messaged. This can be very useful for - systems with little or no perminant storage, since + the oldest messages. This can be very useful for + systems with little or no permanent storage, since otherwise system logs can eventually fill up your entire filesystem, which may cause your system to break badly. -config CONFIG_LOGREAD - bool " logread" +config FEATURE_IPC_SYSLOG_BUFFER_SIZE + int "Circular buffer size in Kbytes (minimum 4KB)" + default 16 + range 4 2147483647 + depends on FEATURE_IPC_SYSLOG + help + This option sets the size of the circular buffer + used to record system log messages. + +config LOGREAD + bool "logread" default y - depends on CONFIG_FEATURE_IPC_SYSLOG + depends on FEATURE_IPC_SYSLOG help If you enabled Circular Buffer support, you almost - certainly want to enable this feature as well. This + certainly want to enable this feature as well. This utility will allow you to read the messages that are stored in the syslogd circular buffer. -config CONFIG_KLOGD +config FEATURE_LOGREAD_REDUCED_LOCKING + bool "Double buffering" + default n + depends on LOGREAD + help + 'logread' ouput to slow serial terminals can have + side effects on syslog because of the semaphore. + This option make logread to double buffer copy + from circular buffer, minimizing semaphore + contention at some minor memory expense. + +config KLOGD bool "klogd" default n - depends on CONFIG_SYSLOGD help - klogd is a utility which which intercepts and logs all + klogd is a utility which intercepts and logs all messages from the Linux kernel and sends the messages - out to the 'syslogd' utility so they can be logged. If + out to the 'syslogd' utility so they can be logged. If you wish to record the messages produced by the kernel, you should enable this option. -config CONFIG_LOGGER +config LOGGER bool "logger" default n + select FEATURE_SYSLOG help The logger utility allows you to send arbitrary text messages to the system log (i.e. the 'syslogd' utility) so - they can be logged. This is generally used to help locate + they can be logged. This is generally used to help locate problems that occur within programs and scripts. endmenu diff --git a/release/src/router/busybox/sysklogd/Kbuild b/release/src/router/busybox/sysklogd/Kbuild new file mode 100644 index 00000000..d802198e --- /dev/null +++ b/release/src/router/busybox/sysklogd/Kbuild @@ -0,0 +1,11 @@ +# Makefile for busybox +# +# Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org> +# +# Licensed under the GPL v2, see the file LICENSE in this tarball. + +lib-y:= +lib-$(CONFIG_KLOGD) += klogd.o +lib-$(CONFIG_LOGGER) += syslogd_and_logger.o +lib-$(CONFIG_LOGREAD) += logread.o +lib-$(CONFIG_SYSLOGD) += syslogd_and_logger.o diff --git a/release/src/router/busybox/sysklogd/Makefile b/release/src/router/busybox/sysklogd/Makefile deleted file mode 100644 index 0c01f546..00000000 --- a/release/src/router/busybox/sysklogd/Makefile +++ /dev/null @@ -1,30 +0,0 @@ -# Makefile for busybox -# -# Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org> -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -TOPDIR:= ../ -SYSKLOGD_DIR:=./ -include $(TOPDIR).config -include $(TOPDIR)Rules.mak -include Makefile.in -all: $(libraries-y) --include $(TOPDIR).depend - -clean: - rm -f *.o *.a $(AR_TARGET) - diff --git a/release/src/router/busybox/sysklogd/Makefile.in b/release/src/router/busybox/sysklogd/Makefile.in deleted file mode 100755 index d088ae85..00000000 --- a/release/src/router/busybox/sysklogd/Makefile.in +++ /dev/null @@ -1,35 +0,0 @@ -# Makefile for busybox -# -# Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org> -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -SYSKLOGD_AR:=sysklogd.a -ifndef $(SYSKLOGD_DIR) -SYSKLOGD_DIR:=$(TOPDIR)sysklogd/ -endif - -SYSKLOGD-:= -SYSKLOGD-$(CONFIG_KLOGD) += klogd.o -SYSKLOGD-$(CONFIG_LOGGER) += logger.o -SYSKLOGD-$(CONFIG_LOGREAD) += logread.o -SYSKLOGD-$(CONFIG_SYSLOGD) += syslogd.o - -libraries-y+=$(SYSKLOGD_DIR)$(SYSKLOGD_AR) - -$(SYSKLOGD_DIR)$(SYSKLOGD_AR): $(patsubst %,$(SYSKLOGD_DIR)%, $(SYSKLOGD-y)) - $(AR) -ro $@ $(patsubst %,$(SYSKLOGD_DIR)%, $(SYSKLOGD-y)) - diff --git a/release/src/router/busybox/sysklogd/klogd.c b/release/src/router/busybox/sysklogd/klogd.c index c132e065..c54e80a3 100644 --- a/release/src/router/busybox/sysklogd/klogd.c +++ b/release/src/router/busybox/sysklogd/klogd.c @@ -4,9 +4,9 @@ * * Copyright (C) 2001 by Gennady Feldman <gfeldman@gena01.com>. * Changes: Made this a standalone busybox module which uses standalone - * syslog() client interface. + * syslog() client interface. * - * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org> + * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> * * Copyright (C) 2000 by Karl M. Hegbloom <karlheg@debian.org> * @@ -14,154 +14,122 @@ * * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001 * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. */ -#include <stdio.h> -#include <stdlib.h> -#include <signal.h> /* for our signal() handlers */ -#include <string.h> /* strncpy() */ -#include <errno.h> /* errno and friends */ -#include <unistd.h> -#include <ctype.h> -#include <sys/syslog.h> +#include "libbb.h" +#include <syslog.h> #include <sys/klog.h> -#include "busybox.h" - static void klogd_signal(int sig) { - klogctl(7, NULL, 0); - klogctl(0, 0, 0); - /* logMessage(0, "Kernel log daemon exiting."); */ - syslog_msg(LOG_SYSLOG, LOG_NOTICE, "Kernel log daemon exiting."); - exit(TRUE); + /* FYI: cmd 7 is equivalent to setting console_loglevel to 7 + * via klogctl(8, NULL, 7). */ + klogctl(7, NULL, 0); /* "7 -- Enable printk's to console" */ + klogctl(0, NULL, 0); /* "0 -- Close the log. Currently a NOP" */ + syslog(LOG_NOTICE, "klogd: exiting"); + kill_myself_with_sig(sig); } -static void doKlogd(const char console_log_level) __attribute__ ((noreturn)); -static void doKlogd(const char console_log_level) +#define log_buffer bb_common_bufsiz1 +enum { + KLOGD_LOGBUF_SIZE = sizeof(log_buffer), + OPT_LEVEL = (1 << 0), + OPT_FOREGROUND = (1 << 1), +}; + +int klogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int klogd_main(int argc UNUSED_PARAM, char **argv) { - int priority = LOG_INFO; - char log_buffer[4096]; - int i, n, lastc; - char *start; - - /* Set up sig handlers */ - signal(SIGINT, klogd_signal); - signal(SIGKILL, klogd_signal); - signal(SIGTERM, klogd_signal); + int i = 0; + char *opt_c; + int opt; + int used = 0; + + opt = getopt32(argv, "c:n", &opt_c); + if (opt & OPT_LEVEL) { + /* Valid levels are between 1 and 8 */ + i = xatou_range(opt_c, 1, 8); + } + if (!(opt & OPT_FOREGROUND)) { + bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv); + } + + openlog("kernel", 0, LOG_KERN); + + bb_signals(BB_FATAL_SIGS, klogd_signal); signal(SIGHUP, SIG_IGN); - /* "Open the log. Currently a NOP." */ + /* "Open the log. Currently a NOP" */ klogctl(1, NULL, 0); - /* Set level of kernel console messaging.. */ - if (console_log_level) - klogctl(8, NULL, console_log_level); + /* "printk() prints a message on the console only if it has a loglevel + * less than console_loglevel". Here we set console_loglevel = i. */ + if (i) + klogctl(8, NULL, i); - syslog_msg(LOG_SYSLOG, LOG_NOTICE, "klogd started: " BB_BANNER); + syslog(LOG_NOTICE, "klogd started: %s", bb_banner); while (1) { - /* Use kernel syscalls */ - memset(log_buffer, '\0', sizeof(log_buffer)); - n = klogctl(2, log_buffer, sizeof(log_buffer)); - if (n < 0) { - char message[80]; + int n; + int priority; + char *start; + /* "2 -- Read from the log." */ + start = log_buffer + used; + n = klogctl(2, start, KLOGD_LOGBUF_SIZE-1 - used); + if (n < 0) { if (errno == EINTR) continue; - snprintf(message, 79, - "klogd: Error return from sys_sycall: %d - %s.\n", errno, - strerror(errno)); - syslog_msg(LOG_SYSLOG, LOG_ERR, message); - exit(1); + syslog(LOG_ERR, "klogd: error %d in klogctl(2): %m", + errno); + break; } + start[n] = '\0'; /* klogctl buffer parsing modelled after code in dmesg.c */ - start = &log_buffer[0]; - lastc = '\0'; - for (i = 0; i < n; i++) { - if (lastc == '\0' && log_buffer[i] == '<') { - priority = 0; - i++; - while (isdigit(log_buffer[i])) { - priority = priority * 10 + (log_buffer[i] - '0'); - i++; + /* Process each newline-terminated line in the buffer */ + start = log_buffer; + while (1) { + char *newline = strchrnul(start, '\n'); + + if (*newline == '\0') { + /* This line is incomplete... */ + if (start != log_buffer) { + /* move it to the front of the buffer */ + overlapping_strcpy(log_buffer, start); + used = newline - start; + /* don't log it yet */ + break; } - if (log_buffer[i] == '>') - i++; - start = &log_buffer[i]; - } - if (log_buffer[i] == '\n') { - log_buffer[i] = '\0'; /* zero terminate this message */ - syslog_msg(LOG_KERN, priority, start); - start = &log_buffer[i + 1]; - priority = LOG_INFO; + /* ...but if buffer is full, log it anyway */ + used = 0; + newline = NULL; + } else { + *newline++ = '\0'; } - lastc = log_buffer[i]; - } - } -} -extern int klogd_main(int argc, char **argv) -{ - /* no options, no getopt */ - int opt; - int doFork = TRUE; - unsigned char console_log_level = 7; - - /* do normal option parsing */ - while ((opt = getopt(argc, argv, "c:n")) > 0) { - switch (opt) { - case 'c': - if ((optarg == NULL) || (optarg[1] != '\0')) { - bb_show_usage(); - } - /* Valid levels are between 1 and 8 */ - console_log_level = *optarg - '1'; - if (console_log_level > 7) { - bb_show_usage(); + /* Extract the priority */ + priority = LOG_INFO; + if (*start == '<') { + start++; + if (*start) { + /* kernel never generates multi-digit prios */ + priority = (*start - '0'); + start++; + } + if (*start == '>') + start++; } - console_log_level++; - - break; - case 'n': - doFork = FALSE; - break; - default: - bb_show_usage(); - } - } + /* Log (only non-empty lines) */ + if (*start) + syslog(priority, "%s", start); - if (doFork) { - if (daemon(0, 1) < 0) - bb_perror_msg_and_die("daemon"); -#if defined(__uClinux__) - vfork_daemon_rexec(argc, argv, "-n"); -#endif + if (!newline) + break; + start = newline; + } } - doKlogd(console_log_level); - return EXIT_SUCCESS; + return EXIT_FAILURE; } - -/* -Local Variables -c-file-style: "linux" -c-basic-offset: 4 -tab-width: 4 -End: -*/ diff --git a/release/src/router/busybox/sysklogd/logger.c b/release/src/router/busybox/sysklogd/logger.c index 252cfc49..759981c7 100644 --- a/release/src/router/busybox/sysklogd/logger.c +++ b/release/src/router/busybox/sysklogd/logger.c @@ -2,76 +2,42 @@ /* * Mini logger implementation for busybox * - * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> * + * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. */ -#include <stdio.h> -#include <unistd.h> -#include <sys/types.h> -#include <fcntl.h> -#include <ctype.h> -#include <string.h> -#include <stdlib.h> - -#include "busybox.h" -#if !defined CONFIG_SYSLOGD - +/* + * Done in syslogd_and_logger.c: +#include "libbb.h" #define SYSLOG_NAMES -#include <sys/syslog.h> - -#else -#include <sys/syslog.h> -# ifndef __dietlibc__ - /* We have to do this since the header file defines static - * structures. Argh.... bad libc, bad, bad... - */ - typedef struct _code { - char *c_name; - int c_val; - } CODE; - extern CODE prioritynames[]; - extern CODE facilitynames[]; -# endif -#endif +#define SYSLOG_NAMES_CONST +#include <syslog.h> +*/ -/* Decode a symbolic name to a numeric value +/* Decode a symbolic name to a numeric value * this function is based on code * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. - * + * * Original copyright notice is retained at the end of this file. */ -static int decode(char *name, CODE * codetab) +static int decode(char *name, const CODE *codetab) { - CODE *c; + const CODE *c; if (isdigit(*name)) - return (atoi(name)); + return atoi(name); for (c = codetab; c->c_name; c++) { if (!strcasecmp(name, c->c_name)) { - return (c->c_val); + return c->c_val; } } - return (-1); + return -1; } -/* Decode a symbolic name to a numeric value +/* Decode a symbolic name to a numeric value * this function is based on code * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. @@ -83,87 +49,76 @@ static int pencode(char *s) char *save; int lev, fac = LOG_USER; - for (save = s; *s && *s != '.'; ++s); + for (save = s; *s && *s != '.'; ++s) + ; if (*s) { *s = '\0'; fac = decode(save, facilitynames); if (fac < 0) - bb_error_msg_and_die("unknown facility name: %s", save); + bb_error_msg_and_die("unknown %s name: %s", "facility", save); *s++ = '.'; } else { s = save; } lev = decode(s, prioritynames); if (lev < 0) - bb_error_msg_and_die("unknown priority name: %s", save); + bb_error_msg_and_die("unknown %s name: %s", "priority", save); return ((lev & LOG_PRIMASK) | (fac & LOG_FACMASK)); } +#define strbuf bb_common_bufsiz1 -extern int logger_main(int argc, char **argv) +int logger_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int logger_main(int argc, char **argv) { - int pri = LOG_USER | LOG_NOTICE; - int option = 0; - int c, i, opt; - char buf[1024], name[128]; + char *str_p, *str_t; + int opt; + int i = 0; /* Fill out the name string early (may be overwritten later) */ - my_getpwuid(name, geteuid()); + str_t = uid2uname_utoa(geteuid()); /* Parse any options */ - while ((opt = getopt(argc, argv, "p:st:")) > 0) { - switch (opt) { - case 's': - option |= LOG_PERROR; - break; - case 'p': - pri = pencode(optarg); - break; - case 't': - safe_strncpy(name, optarg, sizeof(name)); - break; - default: - bb_show_usage(); - } - } - - openlog(name, option, (pri | LOG_FACMASK)); - if (optind == argc) { - do { - /* read from stdin */ - i = 0; - while ((c = getc(stdin)) != EOF && c != '\n' && - i < (sizeof(buf)-1)) { - buf[i++] = c; - } - if (i > 0) { - buf[i++] = '\0'; - syslog(pri, "%s", buf); + opt = getopt32(argv, "p:st:", &str_p, &str_t); + + if (opt & 0x2) /* -s */ + i |= LOG_PERROR; + //if (opt & 0x4) /* -t */ + openlog(str_t, i, 0); + i = LOG_USER | LOG_NOTICE; + if (opt & 0x1) /* -p */ + i = pencode(str_p); + + argc -= optind; + argv += optind; + if (!argc) { + while (fgets(strbuf, COMMON_BUFSIZE, stdin)) { + if (strbuf[0] + && NOT_LONE_CHAR(strbuf, '\n') + ) { + /* Neither "" nor "\n" */ + syslog(i, "%s", strbuf); } - } while (c != EOF); + } } else { char *message = NULL; - int len = argc - optind; /* for the space between the args - and '\0' */ - opt = len; - argv += optind; - for (i = 0; i < opt; i++) { - len += strlen(*argv); - message = xrealloc(message, len); - if(!i) - message[0] = 0; - else - strcat(message, " "); - strcat(message, *argv); - argv++; - } - syslog(pri, "%s", message); + int len = 0; + int pos = 0; + do { + len += strlen(*argv) + 1; + message = xrealloc(message, len + 1); + sprintf(message + pos, " %s", *argv), + pos = len; + } while (*++argv); + syslog(i, "%s", message + 1); /* skip leading " " */ } closelog(); return EXIT_SUCCESS; } +/* Clean up. Needed because we are included from syslogd_and_logger.c */ +#undef strbuf /*- * Copyright (c) 1983, 1993 @@ -180,8 +135,8 @@ extern int logger_main(int argc, char **argv) * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change - * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change> + * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change + * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change> * * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software @@ -199,6 +154,3 @@ extern int logger_main(int argc, char **argv) * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ - - - diff --git a/release/src/router/busybox/sysklogd/logread.c b/release/src/router/busybox/sysklogd/logread.c index 2692efbe..603a3776 100644 --- a/release/src/router/busybox/sysklogd/logread.c +++ b/release/src/router/busybox/sysklogd/logread.c @@ -6,132 +6,180 @@ * * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001 * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - * 02111-1307 USA - * + * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. */ - -#include <stdio.h> -#include <stdlib.h> -#include <string.h> +#include "libbb.h" #include <sys/ipc.h> -#include <sys/types.h> #include <sys/sem.h> #include <sys/shm.h> -#include <signal.h> -#include <setjmp.h> -#include "busybox.h" - -static const long KEY_ID = 0x414e4547; /*"GENA"*/ - -static struct shbuf_ds { - int size; // size of data written - int head; // start of message list - int tail; // end of message list - char data[1]; // data/messages -} *buf = NULL; // shared memory pointer - -// Semaphore operation structures -static struct sembuf SMrup[1] = {{0, -1, IPC_NOWAIT | SEM_UNDO}}; // set SMrup -static struct sembuf SMrdn[2] = {{1, 0}, {0, +1, SEM_UNDO}}; // set SMrdn - -static int log_shmid = -1; // ipc shared memory id -static int log_semid = -1; // ipc semaphore id -static jmp_buf jmp_env; - -static void error_exit(const char *str); -static void interrupted(int sig); +#define DEBUG 0 + +/* our shared key (syslogd.c and logread.c must be in sync) */ +enum { KEY_ID = 0x414e4547 }; /* "GENA" */ + +struct shbuf_ds { + int32_t size; // size of data - 1 + int32_t tail; // end of message list + char data[1]; // messages +}; + +static const struct sembuf init_sem[3] = { + {0, -1, IPC_NOWAIT | SEM_UNDO}, + {1, 0}, {0, +1, SEM_UNDO} +}; + +struct globals { + struct sembuf SMrup[1]; // {0, -1, IPC_NOWAIT | SEM_UNDO}, + struct sembuf SMrdn[2]; // {1, 0}, {0, +1, SEM_UNDO} + struct shbuf_ds *shbuf; +}; +#define G (*(struct globals*)&bb_common_bufsiz1) +#define SMrup (G.SMrup) +#define SMrdn (G.SMrdn) +#define shbuf (G.shbuf) +#define INIT_G() do { \ + memcpy(SMrup, init_sem, sizeof(init_sem)); \ +} while (0) + +static void error_exit(const char *str) NORETURN; +static void error_exit(const char *str) +{ + //release all acquired resources + shmdt(shbuf); + bb_perror_msg_and_die(str); +} /* * sem_up - up()'s a semaphore. */ -static inline void sem_up(int semid) +static void sem_up(int semid) { - if ( semop(semid, SMrup, 1) == -1 ) + if (semop(semid, SMrup, 1) == -1) error_exit("semop[SMrup]"); } -/* - * sem_down - down()'s a semaphore - */ -static inline void sem_down(int semid) +static void interrupted(int sig UNUSED_PARAM) { - if ( semop(semid, SMrdn, 2) == -1 ) - error_exit("semop[SMrdn]"); + signal(SIGINT, SIG_IGN); + shmdt(shbuf); + exit(EXIT_SUCCESS); } -extern int logread_main(int argc, char **argv) +int logread_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int logread_main(int argc UNUSED_PARAM, char **argv) { - int i; - - /* no options, no getopt */ - if (argc > 1) - bb_show_usage(); - - // handle intrrupt signal - if (setjmp(jmp_env)) goto output_end; - - // attempt to redefine ^C signal - signal(SIGINT, interrupted); - - if ( (log_shmid = shmget(KEY_ID, 0, 0)) == -1) - error_exit("Can't find circular buffer"); - - // Attach shared memory to our char* - if ( (buf = shmat(log_shmid, NULL, SHM_RDONLY)) == NULL) - error_exit("Can't get access to circular buffer from syslogd"); - - if ( (log_semid = semget(KEY_ID, 0, 0)) == -1) - error_exit("Can't get access to semaphone(s) for circular buffer from syslogd"); - - sem_down(log_semid); - // Read Memory - i=buf->head; - - //printf("head: %i tail: %i size: %i\n",buf->head,buf->tail,buf->size); - if (buf->head == buf->tail) { - printf("<empty syslog>\n"); - } - - while ( i != buf->tail) { - printf("%s", buf->data+i); - i+= strlen(buf->data+i) + 1; - if (i >= buf->size ) - i=0; - } - sem_up(log_semid); - -output_end: - if (log_shmid != -1) - shmdt(buf); - - return EXIT_SUCCESS; -} + unsigned cur; + int log_semid; /* ipc semaphore id */ + int log_shmid; /* ipc shared memory id */ + smallint follow = getopt32(argv, "f"); -static void interrupted(int sig){ - signal(SIGINT, SIG_IGN); - longjmp(jmp_env, 1); -} + INIT_G(); -static void error_exit(const char *str){ - perror(str); - //release all acquired resources - if (log_shmid != -1) - shmdt(buf); + log_shmid = shmget(KEY_ID, 0, 0); + if (log_shmid == -1) + bb_perror_msg_and_die("can't find syslogd buffer"); + + /* Attach shared memory to our char* */ + shbuf = shmat(log_shmid, NULL, SHM_RDONLY); + if (shbuf == NULL) + bb_perror_msg_and_die("can't access syslogd buffer"); + + log_semid = semget(KEY_ID, 0, 0); + if (log_semid == -1) + error_exit("can't get access to semaphores for syslogd buffer"); + + signal(SIGINT, interrupted); - exit(1); + /* Suppose atomic memory read */ + /* Max possible value for tail is shbuf->size - 1 */ + cur = shbuf->tail; + + /* Loop for logread -f, one pass if there was no -f */ + do { + unsigned shbuf_size; + unsigned shbuf_tail; + const char *shbuf_data; +#if ENABLE_FEATURE_LOGREAD_REDUCED_LOCKING + int i; + int len_first_part; + int len_total = len_total; /* for gcc */ + char *copy = copy; /* for gcc */ +#endif + if (semop(log_semid, SMrdn, 2) == -1) + error_exit("semop[SMrdn]"); + + /* Copy the info, helps gcc to realize that it doesn't change */ + shbuf_size = shbuf->size; + shbuf_tail = shbuf->tail; + shbuf_data = shbuf->data; /* pointer! */ + + if (DEBUG) + printf("cur:%d tail:%i size:%i\n", + cur, shbuf_tail, shbuf_size); + + if (!follow) { + /* advance to oldest complete message */ + /* find NUL */ + cur += strlen(shbuf_data + cur); + if (cur >= shbuf_size) { /* last byte in buffer? */ + cur = strnlen(shbuf_data, shbuf_tail); + if (cur == shbuf_tail) + goto unlock; /* no complete messages */ + } + /* advance to first byte of the message */ + cur++; + if (cur >= shbuf_size) /* last byte in buffer? */ + cur = 0; + } else { /* logread -f */ + if (cur == shbuf_tail) { + sem_up(log_semid); + fflush(stdout); + sleep(1); /* TODO: replace me with a sleep_on */ + continue; + } + } + + /* Read from cur to tail */ +#if ENABLE_FEATURE_LOGREAD_REDUCED_LOCKING + len_first_part = len_total = shbuf_tail - cur; + if (len_total < 0) { + /* message wraps: */ + /* [SECOND PART.........FIRST PART] */ + /* ^data ^tail ^cur ^size */ + len_total += shbuf_size; + } + copy = xmalloc(len_total + 1); + if (len_first_part < 0) { + /* message wraps (see above) */ + len_first_part = shbuf_size - cur; + memcpy(copy + len_first_part, shbuf_data, shbuf_tail); + } + memcpy(copy, shbuf_data + cur, len_first_part); + copy[len_total] = '\0'; + cur = shbuf_tail; +#else + while (cur != shbuf_tail) { + fputs(shbuf_data + cur, stdout); + cur += strlen(shbuf_data + cur) + 1; + if (cur >= shbuf_size) + cur = 0; + } +#endif + unlock: + /* release the lock on the log chain */ + sem_up(log_semid); + +#if ENABLE_FEATURE_LOGREAD_REDUCED_LOCKING + for (i = 0; i < len_total; i += strlen(copy + i) + 1) { + fputs(copy + i, stdout); + } + free(copy); +#endif + } while (follow); + + shmdt(shbuf); + + fflush_stdout_and_exit(EXIT_SUCCESS); } diff --git a/release/src/router/busybox/sysklogd/syslogd.c b/release/src/router/busybox/sysklogd/syslogd.c index c554536c..89391036 100644 --- a/release/src/router/busybox/sysklogd/syslogd.c +++ b/release/src/router/busybox/sysklogd/syslogd.c @@ -2,7 +2,7 @@ /* * Mini syslogd implementation for busybox * - * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org> + * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> * * Copyright (C) 2000 by Karl M. Hegbloom <karlheg@debian.org> * @@ -10,643 +10,706 @@ * * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001 * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. */ -#include <stdio.h> -#include <stdlib.h> -#include <ctype.h> -#include <errno.h> -#include <fcntl.h> -#include <netdb.h> +/* + * Done in syslogd_and_logger.c: +#include "libbb.h" +#define SYSLOG_NAMES +#define SYSLOG_NAMES_CONST +#include <syslog.h> +*/ + #include <paths.h> -#include <signal.h> -#include <stdarg.h> -#include <time.h> -#include <string.h> -#include <unistd.h> -#include <sys/socket.h> -#include <sys/types.h> #include <sys/un.h> -#include <sys/param.h> - -#include "busybox.h" - -/* SYSLOG_NAMES defined to pull some extra junk from syslog.h */ -#define SYSLOG_NAMES -#include <sys/syslog.h> #include <sys/uio.h> -/* Path for the file where all log messages are written */ -#define __LOG_FILE "/var/log/messages" - -/* Path to the unix socket */ -static char lfile[MAXPATHLEN]; - -static char *logFilePath = __LOG_FILE; - -/* interval between marks in seconds */ -static int MarkInterval = 20 * 60; - -/* localhost's name */ -static char LocalHostName[64]; - -#ifdef CONFIG_FEATURE_REMOTE_LOG +#if ENABLE_FEATURE_REMOTE_LOG #include <netinet/in.h> -/* udp socket for logging to remote host */ -static int remotefd = -1; - -/* where do we log? */ -static char *RemoteHost; - -/* what port to log to? */ -static int RemotePort = 514; - -/* To remote log or not to remote log, that is the question. */ -static int doRemoteLog = FALSE; -static int local_logging = FALSE; #endif - -#define MAXLINE 1024 /* maximum line length */ - - -/* circular buffer variables/structures */ -#ifdef CONFIG_FEATURE_IPC_SYSLOG +#if ENABLE_FEATURE_IPC_SYSLOG #include <sys/ipc.h> #include <sys/sem.h> #include <sys/shm.h> +#endif -/* our shared key */ -static const long KEY_ID = 0x414e4547; /*"GENA" */ -// Semaphore operation structures -static struct shbuf_ds { - int size; // size of data written - int head; // start of message list - int tail; // end of message list - char data[1]; // data/messages -} *buf = NULL; // shared memory pointer +#define DEBUG 0 + +/* MARK code is not very useful, is bloat, and broken: + * can deadlock if alarmed to make MARK while writing to IPC buffer + * (semaphores are down but do_mark routine tries to down them again) */ +#undef SYSLOGD_MARK + +/* Write locking does not seem to be useful either */ +#undef SYSLOGD_WRLOCK + +enum { + MAX_READ = 256, + DNS_WAIT_SEC = 2 * 60, +}; + +/* Semaphore operation structures */ +struct shbuf_ds { + int32_t size; /* size of data - 1 */ + int32_t tail; /* end of message list */ + char data[1]; /* data/messages */ +}; + +/* Allows us to have smaller initializer. Ugly. */ +#define GLOBALS \ + const char *logFilePath; \ + int logFD; \ + /* interval between marks in seconds */ \ + /*int markInterval;*/ \ + /* level of messages to be logged */ \ + int logLevel; \ +USE_FEATURE_ROTATE_LOGFILE( \ + /* max size of file before rotation */ \ + unsigned logFileSize; \ + /* number of rotated message files */ \ + unsigned logFileRotate; \ + unsigned curFileSize; \ + smallint isRegular; \ +) \ +USE_FEATURE_REMOTE_LOG( \ + /* udp socket for remote logging */ \ + int remoteFD; \ + len_and_sockaddr* remoteAddr; \ +) \ +USE_FEATURE_IPC_SYSLOG( \ + int shmid; /* ipc shared memory id */ \ + int s_semid; /* ipc semaphore id */ \ + int shm_size; \ + struct sembuf SMwup[1]; \ + struct sembuf SMwdn[3]; \ +) + +struct init_globals { + GLOBALS +}; + +struct globals { + GLOBALS + +#if ENABLE_FEATURE_REMOTE_LOG + unsigned last_dns_resolve; + char *remoteAddrStr; +#endif -static struct sembuf SMwup[1] = { {1, -1, IPC_NOWAIT} }; // set SMwup -static struct sembuf SMwdn[3] = { {0, 0}, {1, 0}, {1, +1} }; // set SMwdn +#if ENABLE_FEATURE_IPC_SYSLOG + struct shbuf_ds *shbuf; +#endif + time_t last_log_time; + /* localhost's name. We print only first 64 chars */ + char *hostname; + + /* We recv into recvbuf... */ + char recvbuf[MAX_READ * (1 + ENABLE_FEATURE_SYSLOGD_DUP)]; + /* ...then copy to parsebuf, escaping control chars */ + /* (can grow x2 max) */ + char parsebuf[MAX_READ*2]; + /* ...then sprintf into printbuf, adding timestamp (15 chars), + * host (64), fac.prio (20) to the message */ + /* (growth by: 15 + 64 + 20 + delims = ~110) */ + char printbuf[MAX_READ*2 + 128]; +}; + +static const struct init_globals init_data = { + .logFilePath = "/var/log/messages", + .logFD = -1, +#ifdef SYSLOGD_MARK + .markInterval = 20 * 60, +#endif + .logLevel = 8, +#if ENABLE_FEATURE_ROTATE_LOGFILE + .logFileSize = 200 * 1024, + .logFileRotate = 1, +#endif +#if ENABLE_FEATURE_REMOTE_LOG + .remoteFD = -1, +#endif +#if ENABLE_FEATURE_IPC_SYSLOG + .shmid = -1, + .s_semid = -1, + .shm_size = ((CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE)*1024), // default shm size + .SMwup = { {1, -1, IPC_NOWAIT} }, + .SMwdn = { {0, 0}, {1, 0}, {1, +1} }, +#endif +}; + +#define G (*ptr_to_globals) +#define INIT_G() do { \ + SET_PTR_TO_GLOBALS(memcpy(xzalloc(sizeof(G)), &init_data, sizeof(init_data))); \ +} while (0) + + +/* Options */ +enum { + OPTBIT_mark = 0, // -m + OPTBIT_nofork, // -n + OPTBIT_outfile, // -O + OPTBIT_loglevel, // -l + OPTBIT_small, // -S + USE_FEATURE_ROTATE_LOGFILE(OPTBIT_filesize ,) // -s + USE_FEATURE_ROTATE_LOGFILE(OPTBIT_rotatecnt ,) // -b + USE_FEATURE_REMOTE_LOG( OPTBIT_remotelog ,) // -R + USE_FEATURE_REMOTE_LOG( OPTBIT_locallog ,) // -L + USE_FEATURE_IPC_SYSLOG( OPTBIT_circularlog,) // -C + USE_FEATURE_SYSLOGD_DUP( OPTBIT_dup ,) // -D + + OPT_mark = 1 << OPTBIT_mark , + OPT_nofork = 1 << OPTBIT_nofork , + OPT_outfile = 1 << OPTBIT_outfile , + OPT_loglevel = 1 << OPTBIT_loglevel, + OPT_small = 1 << OPTBIT_small , + OPT_filesize = USE_FEATURE_ROTATE_LOGFILE((1 << OPTBIT_filesize )) + 0, + OPT_rotatecnt = USE_FEATURE_ROTATE_LOGFILE((1 << OPTBIT_rotatecnt )) + 0, + OPT_remotelog = USE_FEATURE_REMOTE_LOG( (1 << OPTBIT_remotelog )) + 0, + OPT_locallog = USE_FEATURE_REMOTE_LOG( (1 << OPTBIT_locallog )) + 0, + OPT_circularlog = USE_FEATURE_IPC_SYSLOG( (1 << OPTBIT_circularlog)) + 0, + OPT_dup = USE_FEATURE_SYSLOGD_DUP( (1 << OPTBIT_dup )) + 0, +}; +#define OPTION_STR "m:nO:l:S" \ + USE_FEATURE_ROTATE_LOGFILE("s:" ) \ + USE_FEATURE_ROTATE_LOGFILE("b:" ) \ + USE_FEATURE_REMOTE_LOG( "R:" ) \ + USE_FEATURE_REMOTE_LOG( "L" ) \ + USE_FEATURE_IPC_SYSLOG( "C::") \ + USE_FEATURE_SYSLOGD_DUP( "D" ) +#define OPTION_DECL *opt_m, *opt_l \ + USE_FEATURE_ROTATE_LOGFILE(,*opt_s) \ + USE_FEATURE_ROTATE_LOGFILE(,*opt_b) \ + USE_FEATURE_IPC_SYSLOG( ,*opt_C = NULL) +#define OPTION_PARAM &opt_m, &G.logFilePath, &opt_l \ + USE_FEATURE_ROTATE_LOGFILE(,&opt_s) \ + USE_FEATURE_ROTATE_LOGFILE(,&opt_b) \ + USE_FEATURE_REMOTE_LOG( ,&G.remoteAddrStr) \ + USE_FEATURE_IPC_SYSLOG( ,&opt_C) -static int shmid = -1; // ipc shared memory id -static int s_semid = -1; // ipc semaphore id -int data_size = 16000; // data size -int shm_size = 16000 + sizeof(*buf); // our buffer size -static int circular_logging = FALSE; -/* - * sem_up - up()'s a semaphore. - */ -static inline void sem_up(int semid) -{ - if (semop(semid, SMwup, 1) == -1) { - bb_perror_msg_and_die("semop[SMwup]"); - } -} +/* circular buffer variables/structures */ +#if ENABLE_FEATURE_IPC_SYSLOG -/* - * sem_down - down()'s a semaphore - */ -static inline void sem_down(int semid) -{ - if (semop(semid, SMwdn, 3) == -1) { - bb_perror_msg_and_die("semop[SMwdn]"); - } -} +#if CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE < 4 +#error Sorry, you must set the syslogd buffer size to at least 4KB. +#error Please check CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE +#endif +/* our shared key (syslogd.c and logread.c must be in sync) */ +enum { KEY_ID = 0x414e4547 }; /* "GENA" */ -void ipcsyslog_cleanup(void) +static void ipcsyslog_cleanup(void) { - printf("Exiting Syslogd!\n"); - if (shmid != -1) { - shmdt(buf); + if (G.shmid != -1) { + shmdt(G.shbuf); } - - if (shmid != -1) { - shmctl(shmid, IPC_RMID, NULL); + if (G.shmid != -1) { + shmctl(G.shmid, IPC_RMID, NULL); } - if (s_semid != -1) { - semctl(s_semid, 0, IPC_RMID, 0); + if (G.s_semid != -1) { + semctl(G.s_semid, 0, IPC_RMID, 0); } } -void ipcsyslog_init(void) +static void ipcsyslog_init(void) { - if (buf == NULL) { - if ((shmid = shmget(KEY_ID, shm_size, IPC_CREAT | 1023)) == -1) { - bb_perror_msg_and_die("shmget"); - } + if (DEBUG) + printf("shmget(%x, %d,...)\n", (int)KEY_ID, G.shm_size); - if ((buf = shmat(shmid, NULL, 0)) == NULL) { - bb_perror_msg_and_die("shmat"); - } + G.shmid = shmget(KEY_ID, G.shm_size, IPC_CREAT | 0644); + if (G.shmid == -1) { + bb_perror_msg_and_die("shmget"); + } - buf->size = data_size; - buf->head = buf->tail = 0; + G.shbuf = shmat(G.shmid, NULL, 0); + if (G.shbuf == (void*) -1L) { /* shmat has bizarre error return */ + bb_perror_msg_and_die("shmat"); + } - // we'll trust the OS to set initial semval to 0 (let's hope) - if ((s_semid = semget(KEY_ID, 2, IPC_CREAT | IPC_EXCL | 1023)) == -1) { - if (errno == EEXIST) { - if ((s_semid = semget(KEY_ID, 2, 0)) == -1) { - bb_perror_msg_and_die("semget"); - } - } else { - bb_perror_msg_and_die("semget"); - } + memset(G.shbuf, 0, G.shm_size); + G.shbuf->size = G.shm_size - offsetof(struct shbuf_ds, data) - 1; + /*G.shbuf->tail = 0;*/ + + // 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) { + if (errno == EEXIST) { + G.s_semid = semget(KEY_ID, 2, 0); + if (G.s_semid != -1) + return; } - } else { - printf("Buffer already allocated just grab the semaphore?"); + bb_perror_msg_and_die("semget"); } } -/* write message to buffer */ -void circ_message(const char *msg) +/* Write message to shared mem buffer */ +static void log_to_shmem(const char *msg, int len) { - int l = strlen(msg) + 1; /* count the whole message w/ '\0' included */ + int old_tail, new_tail; - sem_down(s_semid); + if (semop(G.s_semid, G.SMwdn, 3) == -1) { + bb_perror_msg_and_die("SMwdn"); + } - /* - * Circular Buffer Algorithm: + /* Circular Buffer Algorithm: * -------------------------- - * - * Start-off w/ empty buffer of specific size SHM_SIZ - * Start filling it up w/ messages. I use '\0' as separator to break up messages. - * This is also very handy since we can do printf on message. - * - * Once the buffer is full we need to get rid of the first message in buffer and - * insert the new message. (Note: if the message being added is >1 message then - * we will need to "remove" >1 old message from the buffer). The way this is done - * is the following: - * When we reach the end of the buffer we set a mark and start from the beginning. - * Now what about the beginning and end of the buffer? Well we have the "head" - * index/pointer which is the starting point for the messages and we have "tail" - * index/pointer which is the ending point for the messages. When we "display" the - * messages we start from the beginning and continue until we reach "tail". If we - * reach end of buffer, then we just start from the beginning (offset 0). "head" and - * "tail" are actually offsets from the beginning of the buffer. - * - * Note: This algorithm uses Linux IPC mechanism w/ shared memory and semaphores to provide - * a threasafe way of handling shared memory operations. + * tail == position where to store next syslog message. + * tail's max value is (shbuf->size - 1) + * Last byte of buffer is never used and remains NUL. */ - if ((buf->tail + l) < buf->size) { - /* before we append the message we need to check the HEAD so that we won't - overwrite any of the message that we still need and adjust HEAD to point - to the next message! */ - if (buf->tail < buf->head) { - if ((buf->tail + l) >= buf->head) { - /* we need to move the HEAD to point to the next message - * Theoretically we have enough room to add the whole message to the - * buffer, because of the first outer IF statement, so we don't have - * to worry about overflows here! - */ - int k = buf->tail + l - buf->head; /* we need to know how many bytes - we are overwriting to make - enough room */ - char *c = - memchr(buf->data + buf->head + k, '\0', - buf->size - (buf->head + k)); - if (c != NULL) { /* do a sanity check just in case! */ - buf->head = c - buf->data + 1; /* we need to convert pointer to - offset + skip the '\0' since - we need to point to the beginning - of the next message */ - /* Note: HEAD is only used to "retrieve" messages, it's not used - when writing messages into our buffer */ - } else { /* show an error message to know we messed up? */ - printf("Weird! Can't find the terminator token??? \n"); - buf->head = 0; - } - } - } - - /* in other cases no overflows have been done yet, so we don't care! */ - /* we should be ok to append the message now */ - strncpy(buf->data + buf->tail, msg, l); /* append our message */ - buf->tail += l; /* count full message w/ '\0' terminating char */ + len++; /* length with NUL included */ + again: + old_tail = G.shbuf->tail; + new_tail = old_tail + len; + if (new_tail < G.shbuf->size) { + /* store message, set new tail */ + memcpy(G.shbuf->data + old_tail, msg, len); + G.shbuf->tail = new_tail; } else { - /* we need to break up the message and "circle" it around */ - char *c; - int k = buf->tail + l - buf->size; /* count # of bytes we don't fit */ - - /* We need to move HEAD! This is always the case since we are going - * to "circle" the message. - */ - c = memchr(buf->data + k, '\0', buf->size - k); - - if (c != NULL) { /* if we don't have '\0'??? weird!!! */ - /* move head pointer */ - buf->head = c - buf->data + 1; - - /* now write the first part of the message */ - strncpy(buf->data + buf->tail, msg, l - k - 1); - - /* ALWAYS terminate end of buffer w/ '\0' */ - buf->data[buf->size - 1] = '\0'; - - /* now write out the rest of the string to the beginning of the buffer */ - strcpy(buf->data, &msg[l - k - 1]); - - /* we need to place the TAIL at the end of the message */ - buf->tail = k + 1; - } else { - printf - ("Weird! Can't find the terminator token from the beginning??? \n"); - buf->head = buf->tail = 0; /* reset buffer, since it's probably corrupted */ - } - + /* k == available buffer space ahead of old tail */ + int k = G.shbuf->size - old_tail; + /* copy what fits to the end of buffer, and repeat */ + memcpy(G.shbuf->data + old_tail, msg, k); + msg += k; + len -= k; + G.shbuf->tail = 0; + goto again; } - sem_up(s_semid); + if (semop(G.s_semid, G.SMwup, 1) == -1) { + bb_perror_msg_and_die("SMwup"); + } + if (DEBUG) + printf("tail:%d\n", G.shbuf->tail); } -#endif /* CONFIG_FEATURE_IPC_SYSLOG */ +#else +void ipcsyslog_cleanup(void); +void ipcsyslog_init(void); +void log_to_shmem(const char *msg); +#endif /* FEATURE_IPC_SYSLOG */ + -/* Note: There is also a function called "message()" in init.c */ /* Print a message to the log file. */ -static void message(char *fmt, ...) __attribute__ ((format(printf, 1, 2))); -static void message(char *fmt, ...) +static void log_locally(time_t now, char *msg) { - int fd; +#ifdef SYSLOGD_WRLOCK struct flock fl; - va_list arguments; +#endif + 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) { + /* Reopen log file every second. This allows admin + * to delete the file and not worry about restarting us. + * This costs almost nothing since it happens + * _at most_ once a second. + */ + if (!now) + now = time(NULL); + if (G.last_log_time != now) { + G.last_log_time = now; + close(G.logFD); + goto reopen; + } + } else { + reopen: + G.logFD = open(G.logFilePath, O_WRONLY | O_CREAT + | O_NOCTTY | O_APPEND | O_NONBLOCK, + 0666); + if (G.logFD < 0) { + /* cannot open logfile? - print to /dev/console then */ + int fd = device_open(DEV_CONSOLE, O_WRONLY | O_NOCTTY | O_NONBLOCK); + if (fd < 0) + fd = 2; /* then stderr, dammit */ + full_write(fd, msg, len); + if (fd != 2) + close(fd); + return; + } +#if ENABLE_FEATURE_ROTATE_LOGFILE + { + struct stat statf; + G.isRegular = (fstat(G.logFD, &statf) == 0 && S_ISREG(statf.st_mode)); + /* bug (mostly harmless): can wrap around if file > 4gb */ + G.curFileSize = statf.st_size; + } +#endif + } +#ifdef SYSLOGD_WRLOCK fl.l_whence = SEEK_SET; fl.l_start = 0; fl.l_len = 1; + fl.l_type = F_WRLCK; + fcntl(G.logFD, F_SETLKW, &fl); +#endif -#ifdef CONFIG_FEATURE_IPC_SYSLOG - if ((circular_logging == TRUE) && (buf != NULL)) { - char b[1024]; - - va_start(arguments, fmt); - vsnprintf(b, sizeof(b) - 1, fmt, arguments); - va_end(arguments); - circ_message(b); - - } else +#if ENABLE_FEATURE_ROTATE_LOGFILE + if (G.logFileSize && G.isRegular && G.curFileSize > G.logFileSize) { + if (G.logFileRotate) { /* always 0..99 */ + int i = strlen(G.logFilePath) + 3 + 1; + char oldFile[i]; + char newFile[i]; + i = G.logFileRotate - 1; + /* rename: f.8 -> f.9; f.7 -> f.8; ... */ + while (1) { + sprintf(newFile, "%s.%d", G.logFilePath, i); + if (i == 0) break; + sprintf(oldFile, "%s.%d", G.logFilePath, --i); + /* ignore errors - file might be missing */ + rename(oldFile, newFile); + } + /* newFile == "f.0" now */ + rename(G.logFilePath, newFile); +#ifdef SYSLOGD_WRLOCK + fl.l_type = F_UNLCK; + fcntl(G.logFD, F_SETLKW, &fl); #endif - if ((fd = - device_open(logFilePath, - O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND | - O_NONBLOCK)) >= 0) { - fl.l_type = F_WRLCK; - fcntl(fd, F_SETLKW, &fl); - va_start(arguments, fmt); - vdprintf(fd, fmt, arguments); - va_end(arguments); - fl.l_type = F_UNLCK; - fcntl(fd, F_SETLKW, &fl); - close(fd); - } else { - /* Always send console messages to /dev/console so people will see them. */ - if ((fd = - device_open(_PATH_CONSOLE, - O_WRONLY | O_NOCTTY | O_NONBLOCK)) >= 0) { - va_start(arguments, fmt); - vdprintf(fd, fmt, arguments); - va_end(arguments); - close(fd); - } else { - fprintf(stderr, "Bummer, can't print: "); - va_start(arguments, fmt); - vfprintf(stderr, fmt, arguments); - fflush(stderr); - va_end(arguments); + close(G.logFD); + goto reopen; } + ftruncate(G.logFD, 0); } + G.curFileSize += +#endif + full_write(G.logFD, msg, len); +#ifdef SYSLOGD_WRLOCK + fl.l_type = F_UNLCK; + fcntl(G.logFD, F_SETLKW, &fl); +#endif } -static void logMessage(int pri, char *msg) +static void parse_fac_prio_20(int pri, char *res20) { - time_t now; - char *timestamp; - static char res[20] = ""; - CODE *c_pri, *c_fac; + const CODE *c_pri, *c_fac; if (pri != 0) { - for (c_fac = facilitynames; - c_fac->c_name && !(c_fac->c_val == LOG_FAC(pri) << 3); c_fac++); - for (c_pri = prioritynames; - c_pri->c_name && !(c_pri->c_val == LOG_PRI(pri)); c_pri++); - if (c_fac->c_name == NULL || c_pri->c_name == NULL) { - snprintf(res, sizeof(res), "<%d>", pri); - } else { - snprintf(res, sizeof(res), "%s.%s", c_fac->c_name, c_pri->c_name); + 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); } +} - if (strlen(msg) < 16 || msg[3] != ' ' || msg[6] != ' ' || - msg[9] != ':' || msg[12] != ':' || msg[15] != ' ') { +/* len parameter is used only for "is there a timestamp?" check. + * NB: some callers cheat and supply len==0 when they know + * that there is no timestamp, short-circuiting the test. */ +static void timestamp_and_log(int pri, char *msg, int len) +{ + char *timestamp; + time_t now; + + if (len < 16 || msg[3] != ' ' || msg[6] != ' ' + || msg[9] != ':' || msg[12] != ':' || msg[15] != ' ' + ) { time(&now); - timestamp = ctime(&now) + 4; - timestamp[15] = '\0'; + timestamp = ctime(&now) + 4; /* skip day of week */ } else { + now = 0; timestamp = msg; - timestamp[15] = '\0'; msg += 16; } - - /* todo: supress duplicates */ - -#ifdef CONFIG_FEATURE_REMOTE_LOG - /* send message to remote logger */ - if (-1 != remotefd) { - static const int IOV_COUNT = 2; - struct iovec iov[IOV_COUNT]; - struct iovec *v = iov; - - memset(&res, 0, sizeof(res)); - snprintf(res, sizeof(res), "<%d>", pri); - v->iov_base = res; - v->iov_len = strlen(res); - v++; - - v->iov_base = msg; - v->iov_len = strlen(msg); - writev_retry: - if ((-1 == writev(remotefd, iov, IOV_COUNT)) && (errno == EINTR)) { - goto writev_retry; - } + timestamp[15] = '\0'; + + if (option_mask32 & OPT_small) + sprintf(G.printbuf, "%s %s\n", timestamp, msg); + else { + char res[20]; + parse_fac_prio_20(pri, res); + sprintf(G.printbuf, "%s %.64s %s %s\n", timestamp, G.hostname, res, msg); } - if (local_logging == TRUE) -#endif - /* now spew out the message to wherever it is supposed to go */ - message("%s %s %s %s\n", timestamp, LocalHostName, res, msg); -} - -static void quit_signal(int sig) -{ - logMessage(LOG_SYSLOG | LOG_INFO, "System log daemon exiting."); - unlink(lfile); -#ifdef CONFIG_FEATURE_IPC_SYSLOG - ipcsyslog_cleanup(); -#endif - exit(TRUE); + /* Log message locally (to file or shared mem) */ + log_locally(now, G.printbuf); } -static void domark(int sig) +static void timestamp_and_log_internal(const char *msg) { - if (MarkInterval > 0) { - logMessage(LOG_SYSLOG | LOG_INFO, "-- MARK --"); - alarm(MarkInterval); - } + /* -L, or no -R */ + if (ENABLE_FEATURE_REMOTE_LOG && !(option_mask32 & OPT_locallog)) + return; + timestamp_and_log(LOG_SYSLOG | LOG_INFO, (char*)msg, 0); } -/* This must be a #define, since when CONFIG_DEBUG and BUFFERS_GO_IN_BSS are - * enabled, we otherwise get a "storage size isn't constant error. */ -static int serveConnection(char *tmpbuf, int n_read) +/* tmpbuf[len] is a NUL byte (set by caller), but there can be other, + * embedded NULs. Split messages on each of these NULs, parse prio, + * escape control chars and log each locally. */ +static void split_escape_and_log(char *tmpbuf, int len) { char *p = tmpbuf; - while (p < tmpbuf + n_read) { - + tmpbuf += len; + while (p < tmpbuf) { + char c; + char *q = G.parsebuf; int pri = (LOG_USER | LOG_NOTICE); - int num_lt = 0; - char line[MAXLINE + 1]; - unsigned char c; - char *q = line; - - while ((c = *p) && q < &line[sizeof(line) - 1]) { - if (c == '<' && num_lt == 0) { - /* Parse the magic priority number. */ - num_lt++; - pri = 0; - while (isdigit(*(++p))) { - pri = 10 * pri + (*p - '0'); - } - if (pri & ~(LOG_FACMASK | LOG_PRIMASK)) { - pri = (LOG_USER | LOG_NOTICE); - } - } else if (c == '\n') { - *q++ = ' '; - } else if (iscntrl(c) && (c < 0177)) { + + if (*p == '<') { + /* Parse the magic priority number */ + pri = bb_strtou(p + 1, &p, 10); + if (*p == '>') + p++; + if (pri & ~(LOG_FACMASK | LOG_PRIMASK)) + pri = (LOG_USER | LOG_NOTICE); + } + + while ((c = *p++)) { + if (c == '\n') + c = ' '; + if (!(c & ~0x1f) && c != '\t') { *q++ = '^'; - *q++ = c ^ 0100; - } else { - *q++ = c; + c += '@'; /* ^@, ^A, ^B... */ } - p++; + *q++ = c; } *q = '\0'; - p++; + /* Now log it */ - logMessage(pri, line); + if (LOG_PRI(pri) < G.logLevel) + timestamp_and_log(pri, G.parsebuf, q - G.parsebuf); } - return n_read; } - -#ifdef CONFIG_FEATURE_REMOTE_LOG -static void init_RemoteLog(void) +#ifdef SYSLOGD_MARK +static void do_mark(int sig) { + if (G.markInterval) { + timestamp_and_log_internal("-- MARK --"); + alarm(G.markInterval); + } +} +#endif - struct sockaddr_in remoteaddr; - struct hostent *hostinfo; - int len = sizeof(remoteaddr); - - memset(&remoteaddr, 0, len); +/* Don't inline: prevent struct sockaddr_un to take up space on stack + * permanently */ +static NOINLINE int create_socket(void) +{ + struct sockaddr_un sunx; + int sock_fd; + char *dev_log_name; - remotefd = socket(AF_INET, SOCK_DGRAM, 0); + memset(&sunx, 0, sizeof(sunx)); + sunx.sun_family = AF_UNIX; - if (remotefd < 0) { - bb_error_msg_and_die("cannot create socket"); + /* Unlink old /dev/log or object it points to. */ + /* (if it exists, bind will fail) */ + strcpy(sunx.sun_path, "/dev/log"); + dev_log_name = xmalloc_follow_symlinks("/dev/log"); + if (dev_log_name) { + safe_strncpy(sunx.sun_path, dev_log_name, sizeof(sunx.sun_path)); + free(dev_log_name); } + unlink(sunx.sun_path); - hostinfo = xgethostbyname(RemoteHost); + sock_fd = xsocket(AF_UNIX, SOCK_DGRAM, 0); + xbind(sock_fd, (struct sockaddr *) &sunx, sizeof(sunx)); + chmod("/dev/log", 0666); - remoteaddr.sin_family = AF_INET; - remoteaddr.sin_addr = *(struct in_addr *) *hostinfo->h_addr_list; - remoteaddr.sin_port = htons(RemotePort); + return sock_fd; +} - /* Since we are using UDP sockets, connect just sets the default host and port - * for future operations - */ - if (0 != (connect(remotefd, (struct sockaddr *) &remoteaddr, len))) { - bb_error_msg_and_die("cannot connect to remote host %s:%d", RemoteHost, - RemotePort); +#if ENABLE_FEATURE_REMOTE_LOG +static int try_to_resolve_remote(void) +{ + if (!G.remoteAddr) { + unsigned now = monotonic_sec(); + + /* Don't resolve name too often - DNS timeouts can be big */ + if ((now - G.last_dns_resolve) < DNS_WAIT_SEC) + return -1; + G.last_dns_resolve = now; + G.remoteAddr = host2sockaddr(G.remoteAddrStr, 514); + if (!G.remoteAddr) + return -1; } - + return socket(G.remoteAddr->u.sa.sa_family, SOCK_DGRAM, 0); } #endif -static void doSyslogd(void) __attribute__ ((noreturn)); -static void doSyslogd(void) +static void do_syslogd(void) NORETURN; +static void do_syslogd(void) { - struct sockaddr_un sunx; - socklen_t addrLength; - int sock_fd; - fd_set fds; +#if ENABLE_FEATURE_SYSLOGD_DUP + int last_sz = -1; + char *last_buf; + char *recvbuf = G.recvbuf; +#else +#define recvbuf (G.recvbuf) +#endif - /* Set up signal handlers. */ - signal(SIGINT, quit_signal); - signal(SIGTERM, quit_signal); - signal(SIGQUIT, quit_signal); + /* Set up signal handlers (so that they interrupt read()) */ + signal_no_SA_RESTART_empty_mask(SIGTERM, record_signo); + signal_no_SA_RESTART_empty_mask(SIGINT, record_signo); + //signal_no_SA_RESTART_empty_mask(SIGQUIT, record_signo); signal(SIGHUP, SIG_IGN); - signal(SIGCHLD, SIG_IGN); -#ifdef SIGCLD - signal(SIGCLD, SIG_IGN); +#ifdef SYSLOGD_MARK + signal(SIGALRM, do_mark); + alarm(G.markInterval); #endif - signal(SIGALRM, domark); - alarm(MarkInterval); - - /* Create the syslog file so realpath() can work. */ - if (realpath(_PATH_LOG, lfile) != NULL) { - unlink(lfile); - } + sock_fd = create_socket(); - memset(&sunx, 0, sizeof(sunx)); - sunx.sun_family = AF_UNIX; - strncpy(sunx.sun_path, lfile, sizeof(sunx.sun_path)); - if ((sock_fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) { - bb_perror_msg_and_die("Couldn't get file descriptor for socket " - _PATH_LOG); - } - - addrLength = sizeof(sunx.sun_family) + strlen(sunx.sun_path); - if (bind(sock_fd, (struct sockaddr *) &sunx, addrLength) < 0) { - bb_perror_msg_and_die("Could not connect to socket " _PATH_LOG); - } - - if (chmod(lfile, 0666) < 0) { - bb_perror_msg_and_die("Could not set permission on " _PATH_LOG); - } -#ifdef CONFIG_FEATURE_IPC_SYSLOG - if (circular_logging == TRUE) { + if (ENABLE_FEATURE_IPC_SYSLOG && (option_mask32 & OPT_circularlog)) { ipcsyslog_init(); } -#endif - -#ifdef CONFIG_FEATURE_REMOTE_LOG - if (doRemoteLog == TRUE) { - init_RemoteLog(); - } -#endif - logMessage(LOG_SYSLOG | LOG_INFO, "syslogd started: " BB_BANNER); + timestamp_and_log_internal("syslogd started: BusyBox v" BB_VER); - for (;;) { + while (!bb_got_signal) { + ssize_t sz; - FD_ZERO(&fds); - FD_SET(sock_fd, &fds); +#if ENABLE_FEATURE_SYSLOGD_DUP + last_buf = recvbuf; + if (recvbuf == G.recvbuf) + recvbuf = G.recvbuf + MAX_READ; + else + recvbuf = G.recvbuf; +#endif + read_again: + sz = read(sock_fd, recvbuf, MAX_READ - 1); + if (sz < 0) { + if (!bb_got_signal) + bb_perror_msg("read from /dev/log"); + break; + } - if (select(sock_fd + 1, &fds, NULL, NULL, NULL) < 0) { - if (errno == EINTR) { - /* alarm may have happened. */ + /* Drop trailing '\n' and NULs (typically there is one NUL) */ + while (1) { + if (sz == 0) + goto read_again; + /* man 3 syslog says: "A trailing newline is added when needed". + * However, neither glibc nor uclibc do this: + * syslog(prio, "test") sends "test\0" to /dev/log, + * syslog(prio, "test\n") sends "test\n\0". + * IOW: newline is passed verbatim! + * I take it to mean that it's syslogd's job + * to make those look identical in the log files. */ + if (recvbuf[sz-1] != '\0' && recvbuf[sz-1] != '\n') + break; + sz--; + } +#if ENABLE_FEATURE_SYSLOGD_DUP + if ((option_mask32 & OPT_dup) && (sz == last_sz)) + if (memcmp(last_buf, recvbuf, sz) == 0) continue; + last_sz = sz; +#endif +#if ENABLE_FEATURE_REMOTE_LOG + /* We are not modifying log messages in any way before send */ + /* Remote site cannot trust _us_ anyway and need to do validation again */ + if (G.remoteAddrStr) { + if (-1 == G.remoteFD) { + G.remoteFD = try_to_resolve_remote(); + if (-1 == G.remoteFD) + goto no_luck; } - bb_perror_msg_and_die("select error"); + /* Stock syslogd sends it '\n'-terminated + * over network, mimic that */ + recvbuf[sz] = '\n'; + /* send message to remote logger, ignore possible error */ + /* TODO: on some errors, close and set G.remoteFD to -1 + * so that DNS resolution and connect is retried? */ + sendto(G.remoteFD, recvbuf, sz+1, MSG_DONTWAIT, + &G.remoteAddr->u.sa, G.remoteAddr->len); + no_luck: ; } - - if (FD_ISSET(sock_fd, &fds)) { - int i; - - RESERVE_CONFIG_BUFFER(tmpbuf, MAXLINE + 1); - - memset(tmpbuf, '\0', MAXLINE + 1); - if ((i = recv(sock_fd, tmpbuf, MAXLINE, 0)) > 0) { - serveConnection(tmpbuf, i); - } else { - bb_perror_msg_and_die("UNIX socket error"); - } - RELEASE_CONFIG_BUFFER(tmpbuf); - } /* FD_ISSET() */ - } /* for main loop */ +#endif + if (!ENABLE_FEATURE_REMOTE_LOG || (option_mask32 & OPT_locallog)) { + recvbuf[sz] = '\0'; /* ensure it *is* NUL terminated */ + split_escape_and_log(recvbuf, sz); + } + } /* while (!bb_got_signal) */ + + timestamp_and_log_internal("syslogd exiting"); + puts("syslogd exiting"); + if (ENABLE_FEATURE_IPC_SYSLOG) + ipcsyslog_cleanup(); + kill_myself_with_sig(bb_got_signal); +#undef recvbuf } -extern int syslogd_main(int argc, char **argv) +int syslogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int syslogd_main(int argc UNUSED_PARAM, char **argv) { - int opt; + char OPTION_DECL; + int opts; -#if ! defined(__uClinux__) - int doFork = TRUE; + INIT_G(); +#if ENABLE_FEATURE_REMOTE_LOG + G.last_dns_resolve = monotonic_sec() - DNS_WAIT_SEC - 1; #endif - char *p; - /* do normal option parsing */ - while ((opt = getopt(argc, argv, "m:nO:R:LC")) > 0) { - switch (opt) { - case 'm': - MarkInterval = atoi(optarg) * 60; - break; -#if ! defined(__uClinux__) - case 'n': - doFork = FALSE; - break; + opt_complementary = "=0"; /* no non-option params */ + opts = getopt32(argv, OPTION_STR, OPTION_PARAM); +#ifdef SYSLOGD_MARK + if (opts & OPT_mark) // -m + G.markInterval = xatou_range(opt_m, 0, INT_MAX/60) * 60; #endif - case 'O': - logFilePath = bb_xstrdup(optarg); - break; -#ifdef CONFIG_FEATURE_REMOTE_LOG - case 'R': - RemoteHost = bb_xstrdup(optarg); - if ((p = strchr(RemoteHost, ':'))) { - RemotePort = atoi(p + 1); - *p = '\0'; - } - doRemoteLog = TRUE; - break; - case 'L': - local_logging = TRUE; - break; + //if (opts & OPT_nofork) // -n + //if (opts & OPT_outfile) // -O + if (opts & OPT_loglevel) // -l + G.logLevel = xatou_range(opt_l, 1, 8); + //if (opts & OPT_small) // -S +#if ENABLE_FEATURE_ROTATE_LOGFILE + if (opts & OPT_filesize) // -s + G.logFileSize = xatou_range(opt_s, 0, INT_MAX/1024) * 1024; + if (opts & OPT_rotatecnt) // -b + G.logFileRotate = xatou_range(opt_b, 0, 99); #endif -#ifdef CONFIG_FEATURE_IPC_SYSLOG - case 'C': - circular_logging = TRUE; - break; +#if ENABLE_FEATURE_IPC_SYSLOG + if (opt_C) // -Cn + G.shm_size = xatoul_range(opt_C, 4, INT_MAX/1024) * 1024; #endif - default: - bb_show_usage(); - } - } -#ifdef CONFIG_FEATURE_REMOTE_LOG /* If they have not specified remote logging, then log locally */ - if (doRemoteLog == FALSE) - local_logging = TRUE; -#endif - + if (ENABLE_FEATURE_REMOTE_LOG && !(opts & OPT_remotelog)) // -R + option_mask32 |= OPT_locallog; /* Store away localhost's name before the fork */ - gethostname(LocalHostName, sizeof(LocalHostName)); - if ((p = strchr(LocalHostName, '.'))) { - *p++ = '\0'; - } - - umask(0); + G.hostname = safe_gethostname(); + *strchrnul(G.hostname, '.') = '\0'; - if ((doFork == TRUE) && (daemon(0, 1) < 0)) { - bb_perror_msg_and_die("daemon"); -#if ! defined(__uClinux__) - vfork_daemon_rexec(argc, argv, "-n"); -#endif + if (!(opts & OPT_nofork)) { + bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv); } - doSyslogd(); - - return EXIT_SUCCESS; + umask(0); + write_pidfile("/var/run/syslogd.pid"); + do_syslogd(); + /* return EXIT_SUCCESS; */ } -/* -Local Variables -c-file-style: "linux" -c-basic-offset: 4 -tab-width: 4 -End: -*/ +/* Clean up. Needed because we are included from syslogd_and_logger.c */ +#undef DEBUG +#undef SYSLOGD_MARK +#undef SYSLOGD_WRLOCK +#undef G +#undef GLOBALS +#undef INIT_G +#undef OPTION_STR +#undef OPTION_DECL +#undef OPTION_PARAM diff --git a/release/src/router/busybox/sysklogd/syslogd_and_logger.c b/release/src/router/busybox/sysklogd/syslogd_and_logger.c new file mode 100644 index 00000000..51573bd9 --- /dev/null +++ b/release/src/router/busybox/sysklogd/syslogd_and_logger.c @@ -0,0 +1,51 @@ +/* vi: set sw=4 ts=4: */ +/* + * prioritynames[] and facilitynames[] + * + * Copyright (C) 2008 by Denys Vlasenko <vda.linux@gmail.com> + * + * Licensed under GPLv2, see file LICENSE in this tarball for details. + */ + +#include "libbb.h" +#define SYSLOG_NAMES +#define SYSLOG_NAMES_CONST +#include <syslog.h> + +#if 0 +/* For the record: with SYSLOG_NAMES <syslog.h> defines + * (not declares) the following: + */ +typedef struct _code { + /*const*/ char *c_name; + int c_val; +} CODE; +/*const*/ CODE prioritynames[] = { + { "alert", LOG_ALERT }, +... + { NULL, -1 } +}; +/* same for facilitynames[] */ + +/* This MUST occur only once per entire executable, + * therefore we can't just do it in syslogd.c and logger.c - + * there will be two copies of it. + * + * We cannot even do it in separate file and then just reference + * prioritynames[] from syslogd.c and logger.c - bare <syslog.h> + * will not emit extern decls for prioritynames[]! Attempts to + * emit "matching" struct _code declaration defeat the whole purpose + * of <syslog.h>. + * + * For now, syslogd.c and logger.c are simply compiled into + * one object file. + */ +#endif + +#if ENABLE_SYSLOGD +#include "syslogd.c" +#endif + +#if ENABLE_LOGGER +#include "logger.c" +#endif |