diff options
Diffstat (limited to 'sysklogd')
| -rw-r--r-- | sysklogd/Config.in | 111 | ||||
| -rw-r--r-- | sysklogd/Kbuild | 11 | ||||
| -rw-r--r-- | sysklogd/klogd.c | 123 | ||||
| -rw-r--r-- | sysklogd/logger.c | 179 | ||||
| -rw-r--r-- | sysklogd/logread.c | 171 | ||||
| -rw-r--r-- | sysklogd/syslogd.c | 643 |
6 files changed, 1238 insertions, 0 deletions
diff --git a/sysklogd/Config.in b/sysklogd/Config.in new file mode 100644 index 0000000..9875b3c --- /dev/null +++ b/sysklogd/Config.in @@ -0,0 +1,111 @@ +# +# For a description of the syntax of this configuration file, +# see scripts/kbuild/config-language.txt. +# + +menu "System Logging Utilities" + +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 + 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 + conjunction with klogd, messages from the Linux kernel + 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 FEATURE_ROTATE_LOGFILE + bool "Rotate message files" + default n + 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 + 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 + measure to prevent system logs from being tampered with + by an intruder. + +config FEATURE_IPC_SYSLOG + bool "Circular Buffer support" + default n + 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 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 FEATURE_IPC_SYSLOG_BUFFER_SIZE + int " Circular buffer size in Kbytes (minimum 4KB)" + default 16 + 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 FEATURE_IPC_SYSLOG + help + If you enabled Circular Buffer support, you almost + 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 FEATURE_LOGREAD_REDUCED_LOCKING + bool "logread 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 SYSLOGD + select FEATURE_SYSLOG + help + 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 + you wish to record the messages produced by the kernel, + you should enable this option. + +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 + problems that occur within programs and scripts. + +endmenu + diff --git a/sysklogd/Kbuild b/sysklogd/Kbuild new file mode 100644 index 0000000..0d5b2b9 --- /dev/null +++ b/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) += logger.o +lib-$(CONFIG_LOGREAD) += logread.o +lib-$(CONFIG_SYSLOGD) += syslogd.o diff --git a/sysklogd/klogd.c b/sysklogd/klogd.c new file mode 100644 index 0000000..f735d9f --- /dev/null +++ b/sysklogd/klogd.c @@ -0,0 +1,123 @@ +/* vi: set sw=4 ts=4: */ +/* + * Mini klogd implementation for busybox + * + * Copyright (C) 2001 by Gennady Feldman <gfeldman@gena01.com>. + * Changes: Made this a standalone busybox module which uses standalone + * syslog() client interface. + * + * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> + * + * Copyright (C) 2000 by Karl M. Hegbloom <karlheg@debian.org> + * + * "circular buffer" Copyright (C) 2000 by Gennady Feldman <gfeldman@gena01.com> + * + * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001 + * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. + */ + +#include "busybox.h" +#include <sys/syslog.h> +#include <sys/klog.h> + +static void klogd_signal(int sig ATTRIBUTE_UNUSED) +{ + klogctl(7, NULL, 0); + klogctl(0, 0, 0); + /* logMessage(0, "Kernel log daemon exiting."); */ + syslog(LOG_NOTICE, "Kernel log daemon exiting."); + exit(EXIT_SUCCESS); +} + +#define OPT_LEVEL 1 +#define OPT_FOREGROUND 2 + +#define KLOGD_LOGBUF_SIZE 4096 + +int klogd_main(int argc, char **argv) +{ + RESERVE_CONFIG_BUFFER(log_buffer, KLOGD_LOGBUF_SIZE); + int console_log_level = -1; + int priority = LOG_INFO; + int i, n, lastc; + char *start; + + { + unsigned opt; + + /* do normal option parsing */ + opt = getopt32(argc, argv, "c:n", &start); + + if (opt & OPT_LEVEL) { + /* Valid levels are between 1 and 8 */ + console_log_level = xatoul_range(start, 1, 8); + } + + if (!(opt & OPT_FOREGROUND)) { +#ifdef BB_NOMMU + vfork_daemon_rexec(0, 1, argc, argv, "-n"); +#else + xdaemon(0, 1); +#endif + } + } + + openlog("kernel", 0, LOG_KERN); + + /* Set up sig handlers */ + signal(SIGINT, klogd_signal); + signal(SIGKILL, klogd_signal); + signal(SIGTERM, klogd_signal); + signal(SIGHUP, SIG_IGN); + + /* "Open the log. Currently a NOP." */ + klogctl(1, NULL, 0); + + /* Set level of kernel console messaging.. */ + if (console_log_level != -1) + klogctl(8, NULL, console_log_level); + + syslog(LOG_NOTICE, "klogd started: %s", BB_BANNER); + + while (1) { + /* Use kernel syscalls */ + memset(log_buffer, '\0', KLOGD_LOGBUF_SIZE); + n = klogctl(2, log_buffer, KLOGD_LOGBUF_SIZE); + if (n < 0) { + if (errno == EINTR) + continue; + syslog(LOG_ERR, "klogd: Error from sys_sycall: %d - %m.\n", + errno); + exit(EXIT_FAILURE); + } + + /* 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 (log_buffer[i] >= '0' && log_buffer[i] <= '9') { + priority = priority * 10 + (log_buffer[i] - '0'); + i++; + } + if (log_buffer[i] == '>') + i++; + start = &log_buffer[i]; + } + if (log_buffer[i] == '\n') { + log_buffer[i] = '\0'; /* zero terminate this message */ + syslog(priority, "%s", start); + start = &log_buffer[i + 1]; + priority = LOG_INFO; + } + lastc = log_buffer[i]; + } + } + if (ENABLE_FEATURE_CLEAN_UP) + RELEASE_CONFIG_BUFFER(log_buffer); + + return EXIT_SUCCESS; +} diff --git a/sysklogd/logger.c b/sysklogd/logger.c new file mode 100644 index 0000000..8901bd7 --- /dev/null +++ b/sysklogd/logger.c @@ -0,0 +1,179 @@ +/* vi: set sw=4 ts=4: */ +/* + * Mini logger implementation for busybox + * + * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> + * + * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. + */ + +#include "busybox.h" +#include <stdio.h> +#include <unistd.h> +#include <sys/types.h> +#include <fcntl.h> +#include <ctype.h> +#include <string.h> +#include <stdlib.h> + +#if !defined CONFIG_SYSLOGD + +#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 + +/* 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) +{ + CODE *c; + + if (isdigit(*name)) + return atoi(name); + for (c = codetab; c->c_name; c++) { + if (!strcasecmp(name, c->c_name)) { + return c->c_val; + } + } + + return -1; +} + +/* 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 pencode(char *s) +{ + char *save; + int lev, fac = LOG_USER; + + 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); + *s++ = '.'; + } else { + s = save; + } + lev = decode(s, prioritynames); + if (lev < 0) + bb_error_msg_and_die("unknown priority name: %s", save); + return ((lev & LOG_PRIMASK) | (fac & LOG_FACMASK)); +} + + +int logger_main(int argc, char **argv) +{ + unsigned opt; + char *opt_p, *opt_t; + int pri = LOG_USER | LOG_NOTICE; + int option = 0; + int c, i; + char buf[1024], name[128]; + + /* Fill out the name string early (may be overwritten later) */ + bb_getpwuid(name, geteuid(), sizeof(name)); + + /* Parse any options */ + opt = getopt32(argc, argv, "p:st:", &opt_p, &opt_t); + if (opt & 0x1) pri = pencode(opt_p); // -p + if (opt & 0x2) option |= LOG_PERROR; // -s + if (opt & 0x4) safe_strncpy(name, opt_t, sizeof(name)); // -t + + openlog(name, option, 0); + 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); + } + } 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); + } + + closelog(); + return EXIT_SUCCESS; +} + + +/*- + * Copyright (c) 1983, 1993 + * The Regents of the University of California. All rights reserved. + * + * This is the original license statement for the decode and pencode functions. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * 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> + * + * 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 + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ diff --git a/sysklogd/logread.c b/sysklogd/logread.c new file mode 100644 index 0000000..9cc6561 --- /dev/null +++ b/sysklogd/logread.c @@ -0,0 +1,171 @@ +/* vi: set sw=4 ts=4: */ +/* + * circular buffer syslog implementation for busybox + * + * Copyright (C) 2000 by Gennady Feldman <gfeldman@gena01.com> + * + * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001 + * + * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. + */ + + +#include "busybox.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/ipc.h> +#include <sys/types.h> +#include <sys/sem.h> +#include <sys/shm.h> +#include <signal.h> +#include <setjmp.h> +#include <unistd.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); + +/* + * sem_up - up()'s a semaphore. + */ +static void sem_up(int semid) +{ + if ( semop(semid, SMrup, 1) == -1 ) + error_exit("semop[SMrup]"); +} + +/* + * sem_down - down()'s a semaphore + */ +static void sem_down(int semid) +{ + if ( semop(semid, SMrdn, 2) == -1 ) + error_exit("semop[SMrdn]"); +} + +int logread_main(int argc, char **argv) +{ + int i; + int follow=0; + + if (argc == 2 && argv[1][0]=='-' && argv[1][1]=='f') { + follow = 1; + } else { + /* no options, no getopt */ + if (argc > 1) + bb_show_usage(); + } + + // handle interrupt 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 semaphore(s) for circular buffer from syslogd"); + + // Suppose atomic memory move + i = follow ? buf->tail : buf->head; + + do { +#ifdef CONFIG_FEATURE_LOGREAD_REDUCED_LOCKING + char *buf_data; + int log_len,j; +#endif + + sem_down(log_semid); + + //printf("head: %i tail: %i size: %i\n",buf->head,buf->tail,buf->size); + if (buf->head == buf->tail || i==buf->tail) { + if (follow) { + sem_up(log_semid); + sleep(1); /* TODO: replace me with a sleep_on */ + continue; + } else { + printf("<empty syslog>\n"); + } + } + + // Read Memory +#ifdef CONFIG_FEATURE_LOGREAD_REDUCED_LOCKING + log_len = buf->tail - i; + if (log_len < 0) + log_len += buf->size; + buf_data = (char *)xmalloc(log_len); + + if (buf->tail < i) { + memcpy(buf_data, buf->data+i, buf->size-i); + memcpy(buf_data+buf->size-i, buf->data, buf->tail); + } else { + memcpy(buf_data, buf->data+i, buf->tail-i); + } + i = buf->tail; + +#else + while ( i != buf->tail) { + printf("%s", buf->data+i); + i+= strlen(buf->data+i) + 1; + if (i >= buf->size ) + i=0; + } +#endif + // release the lock on the log chain + sem_up(log_semid); + +#ifdef CONFIG_FEATURE_LOGREAD_REDUCED_LOCKING + for (j=0; j < log_len; j+=strlen(buf_data+j)+1) { + printf("%s", buf_data+j); + if (follow) + fflush(stdout); + } + free(buf_data); +#endif + fflush(stdout); + } while (follow); + +output_end: + if (log_shmid != -1) + shmdt(buf); + + return EXIT_SUCCESS; +} + +static void interrupted(int sig){ + signal(SIGINT, SIG_IGN); + longjmp(jmp_env, 1); +} + +static void error_exit(const char *str){ + bb_perror_msg(str); + //release all acquired resources + if (log_shmid != -1) + shmdt(buf); + + exit(1); +} diff --git a/sysklogd/syslogd.c b/sysklogd/syslogd.c new file mode 100644 index 0000000..453cbda --- /dev/null +++ b/sysklogd/syslogd.c @@ -0,0 +1,643 @@ +/* vi: set sw=4 ts=4: */ +/* + * Mini syslogd implementation for busybox + * + * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> + * + * Copyright (C) 2000 by Karl M. Hegbloom <karlheg@debian.org> + * + * "circular buffer" Copyright (C) 2001 by Gennady Feldman <gfeldman@gena01.com> + * + * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001 + * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. + */ + +#include "busybox.h" +#include <paths.h> +#include <stdbool.h> +#include <sys/un.h> + +/* SYSLOG_NAMES defined to pull some extra junk from syslog.h */ +#define SYSLOG_NAMES +#include <sys/syslog.h> +#include <sys/uio.h> + +/* Path to the unix socket */ +static char lfile[MAXPATHLEN]; + +/* Path for the file where all log messages are written */ +static const char *logFilePath = "/var/log/messages"; + +#ifdef CONFIG_FEATURE_ROTATE_LOGFILE +/* max size of message file before being rotated */ +static int logFileSize = 200 * 1024; + +/* number of rotated message files */ +static int logFileRotate = 1; +#endif + +/* interval between marks in seconds */ +static int MarkInterval = 20 * 60; + +/* level of messages to be locally logged */ +static int logLevel = 8; + +/* localhost's name */ +static char LocalHostName[64]; + +#ifdef CONFIG_FEATURE_REMOTE_LOG +#include <netinet/in.h> +/* udp socket for logging to remote host */ +static int remotefd = -1; +static struct sockaddr_in remoteaddr; + +#endif + +/* options */ +/* Correct regardless of combination of CONFIG_xxx */ +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_remote ,) // -R + USE_FEATURE_REMOTE_LOG( OPTBIT_localtoo ,) // -L + USE_FEATURE_IPC_SYSLOG( OPTBIT_circularlog,) // -C + + 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_remote )) + 0, + OPT_locallog = USE_FEATURE_REMOTE_LOG( (1 << OPTBIT_localtoo )) + 0, + OPT_circularlog = USE_FEATURE_IPC_SYSLOG( (1 << OPTBIT_circularlog)) + 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::") +#define OPTION_DECL *opt_m, *opt_l \ + USE_FEATURE_ROTATE_LOGFILE(,*opt_s) \ + USE_FEATURE_ROTATE_LOGFILE(,*opt_b) \ + USE_FEATURE_REMOTE_LOG( ,*opt_R) \ + USE_FEATURE_IPC_SYSLOG( ,*opt_C = NULL) +#define OPTION_PARAM &opt_m, &logFilePath, &opt_l \ + USE_FEATURE_ROTATE_LOGFILE(,&opt_s) \ + USE_FEATURE_ROTATE_LOGFILE(,&opt_b) \ + USE_FEATURE_REMOTE_LOG( ,&opt_R) \ + USE_FEATURE_IPC_SYSLOG( ,&opt_C) + +#define MAXLINE 1024 /* maximum line length */ + +/* circular buffer variables/structures */ +#ifdef CONFIG_FEATURE_IPC_SYSLOG + +#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 + +#include <sys/ipc.h> +#include <sys/sem.h> +#include <sys/shm.h> + +/* our shared key */ +#define KEY_ID ((long)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 +} *shbuf = NULL; // shared memory pointer + +static struct sembuf SMwup[1] = { {1, -1, IPC_NOWAIT} }; // set SMwup +static struct sembuf SMwdn[3] = { {0, 0}, {1, 0}, {1, +1} }; // set SMwdn + +static int shmid = -1; // ipc shared memory id +static int s_semid = -1; // ipc semaphore id +static int shm_size = ((CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE)*1024); // default shm size + +static void ipcsyslog_cleanup(void) +{ + puts("Exiting syslogd!"); + if (shmid != -1) { + shmdt(shbuf); + } + + if (shmid != -1) { + shmctl(shmid, IPC_RMID, NULL); + } + if (s_semid != -1) { + semctl(s_semid, 0, IPC_RMID, 0); + } +} + +static void ipcsyslog_init(void) +{ + if (shbuf == NULL) { + shmid = shmget(KEY_ID, shm_size, IPC_CREAT | 1023); + if (shmid == -1) { + bb_perror_msg_and_die("shmget"); + } + + shbuf = shmat(shmid, NULL, 0); + if (!shbuf) { + bb_perror_msg_and_die("shmat"); + } + + shbuf->size = shm_size - sizeof(*shbuf); + shbuf->head = shbuf->tail = 0; + + // we'll trust the OS to set initial semval to 0 (let's hope) + s_semid = semget(KEY_ID, 2, IPC_CREAT | IPC_EXCL | 1023); + if (s_semid == -1) { + if (errno == EEXIST) { + s_semid = semget(KEY_ID, 2, 0); + if (s_semid == -1) { + bb_perror_msg_and_die("semget"); + } + } else { + bb_perror_msg_and_die("semget"); + } + } + } else { + printf("Buffer already allocated just grab the semaphore?"); + } +} + +/* write message to buffer */ +static void circ_message(const char *msg) +{ + int l = strlen(msg) + 1; /* count the whole message w/ '\0' included */ + const char * const fail_msg = "Can't find the terminator token%s?\n"; + + if (semop(s_semid, SMwdn, 3) == -1) { + bb_perror_msg_and_die("SMwdn"); + } + + /* + * 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 threadsafe way of handling shared memory operations. + */ + if ((shbuf->tail + l) < shbuf->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 (shbuf->tail < shbuf->head) { + if ((shbuf->tail + l) >= shbuf->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! + */ + /* we need to know how many bytes we are overwriting to make enough room */ + int k = shbuf->tail + l - shbuf->head; + char *c = + memchr(shbuf->data + shbuf->head + k, '\0', + shbuf->size - (shbuf->head + k)); + if (c != NULL) { /* do a sanity check just in case! */ + /* we need to convert pointer to offset + skip the '\0' + since we need to point to the beginning of the next message */ + shbuf->head = c - shbuf->data + 1; + /* 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(fail_msg,""); + shbuf->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(shbuf->data + shbuf->tail, msg, l); /* append our message */ + shbuf->tail += l; /* count full message w/ '\0' terminating char */ + } else { + /* we need to break up the message and "circle" it around */ + char *c; + int k = shbuf->tail + l - shbuf->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(shbuf->data + k, '\0', shbuf->size - k); + + if (c != NULL) { /* if we don't have '\0'??? weird!!! */ + /* move head pointer */ + shbuf->head = c - shbuf->data + 1; + + /* now write the first part of the message */ + strncpy(shbuf->data + shbuf->tail, msg, l - k - 1); + + /* ALWAYS terminate end of buffer w/ '\0' */ + shbuf->data[shbuf->size - 1] = '\0'; + + /* now write out the rest of the string to the beginning of the buffer */ + strcpy(shbuf->data, &msg[l - k - 1]); + + /* we need to place the TAIL at the end of the message */ + shbuf->tail = k + 1; + } else { + printf(fail_msg, " from the beginning"); + shbuf->head = shbuf->tail = 0; /* reset buffer, since it's probably corrupted */ + } + + } + if (semop(s_semid, SMwup, 1) == -1) { + bb_perror_msg_and_die("SMwup"); + } + +} +#else +void ipcsyslog_cleanup(void); +void ipcsyslog_init(void); +void circ_message(const char *msg); +#endif /* CONFIG_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, ...) +{ + int fd = -1; + struct flock fl; + va_list arguments; + + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 1; + +#ifdef CONFIG_FEATURE_IPC_SYSLOG + if ((option_mask32 & OPT_circularlog) && shbuf) { + char b[1024]; + + va_start(arguments, fmt); + vsnprintf(b, sizeof(b) - 1, fmt, arguments); + va_end(arguments); + circ_message(b); + + } else +#endif + fd = device_open(logFilePath, O_WRONLY | O_CREAT + | O_NOCTTY | O_APPEND | O_NONBLOCK); + if (fd >= 0) { + fl.l_type = F_WRLCK; + fcntl(fd, F_SETLKW, &fl); + +#ifdef CONFIG_FEATURE_ROTATE_LOGFILE + if (ENABLE_FEATURE_ROTATE_LOGFILE && logFileSize > 0 ) { + struct stat statf; + int r = fstat(fd, &statf); + if (!r && (statf.st_mode & S_IFREG) + && (lseek(fd,0,SEEK_END) > logFileSize)) { + if (logFileRotate > 0) { + int i = strlen(logFilePath) + 4; + char oldFile[i]; + char newFile[i]; + for (i=logFileRotate-1; i>0; i--) { + sprintf(oldFile, "%s.%d", logFilePath, i-1); + sprintf(newFile, "%s.%d", logFilePath, i); + rename(oldFile, newFile); + } + sprintf(newFile, "%s.%d", logFilePath, 0); + fl.l_type = F_UNLCK; + fcntl(fd, F_SETLKW, &fl); + close(fd); + rename(logFilePath, newFile); + fd = device_open(logFilePath, + O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND | + O_NONBLOCK); + fl.l_type = F_WRLCK; + fcntl(fd, F_SETLKW, &fl); + } else { + ftruncate(fd, 0); + } + } + } +#endif + 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. */ + fd = device_open(_PATH_CONSOLE, O_WRONLY | O_NOCTTY | O_NONBLOCK); + if (fd >= 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); + } + } +} + +static void logMessage(int pri, char *msg) +{ + time_t now; + char *timestamp; + char res[20]; + CODE *c_pri, *c_fac; + + if (pri != 0) { + c_fac = facilitynames; + while (c_fac->c_name && !(c_fac->c_val == LOG_FAC(pri) << 3)) + c_fac++; + c_pri = prioritynames; + while (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); + } + } + + if (strlen(msg) < 16 || msg[3] != ' ' || msg[6] != ' ' || + msg[9] != ':' || msg[12] != ':' || msg[15] != ' ') { + time(&now); + timestamp = ctime(&now) + 4; + timestamp[15] = '\0'; + } else { + timestamp = msg; + timestamp[15] = '\0'; + msg += 16; + } + + /* todo: supress duplicates */ + +#ifdef CONFIG_FEATURE_REMOTE_LOG + if (option_mask32 & OPT_remotelog) { + char line[MAXLINE + 1]; + /* trying connect the socket */ + if (-1 == remotefd) { + remotefd = socket(AF_INET, SOCK_DGRAM, 0); + } + /* if we have a valid socket, send the message */ + if (-1 != remotefd) { + snprintf(line, sizeof(line), "<%d>%s", pri, msg); + /* send message to remote logger, ignore possible error */ + sendto(remotefd, line, strlen(line), 0, + (struct sockaddr *) &remoteaddr, sizeof(remoteaddr)); + } + } + + if (option_mask32 & OPT_locallog) +#endif + { + /* now spew out the message to wherever it is supposed to go */ + if (pri == 0 || LOG_PRI(pri) < logLevel) { + if (option_mask32 & OPT_small) + message("%s %s\n", timestamp, msg); + else + 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); + if (ENABLE_FEATURE_IPC_SYSLOG) + ipcsyslog_cleanup(); + + exit(1); +} + +static void domark(int sig) +{ + if (MarkInterval > 0) { + logMessage(LOG_SYSLOG | LOG_INFO, "-- MARK --"); + alarm(MarkInterval); + } +} + +/* 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) +{ + char *p = tmpbuf; + + while (p < tmpbuf + n_read) { + + 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)) { + *q++ = '^'; + *q++ = c ^ 0100; + } else { + *q++ = c; + } + p++; + } + *q = '\0'; + p++; + /* Now log it */ + logMessage(pri, line); + } + return n_read; +} + +static void doSyslogd(void) ATTRIBUTE_NORETURN; +static void doSyslogd(void) +{ + struct sockaddr_un sunx; + socklen_t addrLength; + + int sock_fd; + fd_set fds; + + /* Set up signal handlers. */ + signal(SIGINT, quit_signal); + signal(SIGTERM, quit_signal); + signal(SIGQUIT, quit_signal); + signal(SIGHUP, SIG_IGN); + signal(SIGCHLD, SIG_IGN); +#ifdef SIGCLD + signal(SIGCLD, SIG_IGN); +#endif + signal(SIGALRM, domark); + alarm(MarkInterval); + + /* Create the syslog file so realpath() can work. */ + if (realpath(_PATH_LOG, lfile) != NULL) { + unlink(lfile); + } + + memset(&sunx, 0, sizeof(sunx)); + sunx.sun_family = AF_UNIX; + strncpy(sunx.sun_path, lfile, sizeof(sunx.sun_path)); + sock_fd = xsocket(AF_UNIX, SOCK_DGRAM, 0); + addrLength = sizeof(sunx.sun_family) + strlen(sunx.sun_path); + if (bind(sock_fd, (struct sockaddr *) &sunx, addrLength) < 0) { + bb_perror_msg_and_die("cannot connect to socket %s", lfile); + } + + if (chmod(lfile, 0666) < 0) { + bb_perror_msg_and_die("cannot set permission on %s", lfile); + } + if (ENABLE_FEATURE_IPC_SYSLOG && (option_mask32 & OPT_circularlog)) { + ipcsyslog_init(); + } + + logMessage(LOG_SYSLOG | LOG_INFO, "syslogd started: " "BusyBox v" BB_VER ); + + for (;;) { + FD_ZERO(&fds); + FD_SET(sock_fd, &fds); + + if (select(sock_fd + 1, &fds, NULL, NULL, NULL) < 0) { + if (errno == EINTR) { + /* alarm may have happened. */ + continue; + } + bb_perror_msg_and_die("select"); + } + + if (FD_ISSET(sock_fd, &fds)) { + int i; +#if MAXLINE > BUFSIZ +# define TMP_BUF_SZ BUFSIZ +#else +# define TMP_BUF_SZ MAXLINE +#endif +#define tmpbuf bb_common_bufsiz1 + + if ((i = recv(sock_fd, tmpbuf, TMP_BUF_SZ, 0)) > 0) { + tmpbuf[i] = '\0'; + serveConnection(tmpbuf, i); + } else { + bb_perror_msg_and_die("UNIX socket error"); + } + } /* FD_ISSET() */ + } /* for main loop */ +} + + +int syslogd_main(int argc, char **argv) +{ + char OPTION_DECL; + char *p; + + /* do normal option parsing */ + getopt32(argc, argv, OPTION_STR, OPTION_PARAM); + if (option_mask32 & OPT_mark) MarkInterval = xatoul_range(opt_m, 0, INT_MAX/60) * 60; // -m + //if (option_mask32 & OPT_nofork) // -n + //if (option_mask32 & OPT_outfile) // -O + if (option_mask32 & OPT_loglevel) { // -l + logLevel = xatoi_u(opt_l); + /* Valid levels are between 1 and 8 */ + if (logLevel < 1 || logLevel > 8) + bb_show_usage(); + } + //if (option_mask32 & OPT_small) // -S +#if ENABLE_FEATURE_ROTATE_LOGFILE + if (option_mask32 & OPT_filesize) logFileSize = xatoul_range(opt_s, 0, INT_MAX/1024) * 1024; // -s + if (option_mask32 & OPT_rotatecnt) { // -b + logFileRotate = xatoi_u(opt_b); + if (logFileRotate > 99) logFileRotate = 99; + } +#endif +#if ENABLE_FEATURE_REMOTE_LOG + if (option_mask32 & OPT_remotelog) { // -R + int port = 514; + char *host = xstrdup(opt_R); + p = strchr(host, ':'); + if (p) { + port = xatou16(p + 1); + *p = '\0'; + } + remoteaddr.sin_family = AF_INET; + /* FIXME: looks ip4-specific. need to do better */ + remoteaddr.sin_addr = *(struct in_addr *) *(xgethostbyname(host)->h_addr_list); + remoteaddr.sin_port = htons(port); + free(host); + } + //if (option_mask32 & OPT_locallog) // -L +#endif +#if ENABLE_FEATURE_IPC_SYSLOG + if (option_mask32 & OPT_circularlog) { // -C + if (opt_C) { + 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 && !(option_mask32 & OPT_remotelog)) + option_mask32 |= OPT_locallog; + + /* Store away localhost's name before the fork */ + gethostname(LocalHostName, sizeof(LocalHostName)); + p = strchr(LocalHostName, '.'); + if (p) { + *p = '\0'; + } + + umask(0); + + if (!(option_mask32 & OPT_nofork)) { +#ifdef BB_NOMMU + vfork_daemon_rexec(0, 1, argc, argv, "-n"); +#else + xdaemon(0, 1); +#endif + } + doSyslogd(); + + return EXIT_SUCCESS; +} |