X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=sysklogd%2Fsyslogd.c;h=f27bd8379214c323a5bd8e32a65768d499f6a0ad;hb=339936be006c3695de5c93bc59707c3d853ae186;hp=625f9971599f9783b60ac884b2d9abffed19b649;hpb=c8227639db90c3147ef68f33c98e96b0ab6b01d6;p=oweals%2Fbusybox.git diff --git a/sysklogd/syslogd.c b/sysklogd/syslogd.c index 625f99715..f27bd8379 100644 --- a/sysklogd/syslogd.c +++ b/sysklogd/syslogd.c @@ -2,650 +2,613 @@ /* * Mini syslogd implementation for busybox * - * Copyright (C) 1999,2000 by Lineo, inc. and Erik Andersen - * Copyright (C) 1999,2000,2001 by Erik Andersen + * Copyright (C) 1999-2004 by Erik Andersen * * Copyright (C) 2000 by Karl M. Hegbloom * - * "circular buffer" Copyright (C) 2001 by Gennady Feldman + * "circular buffer" Copyright (C) 2001 by Gennady Feldman * - * Maintainer: Gennady Feldman 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 + * Maintainer: Gennady Feldman as of Mar 12, 2001 * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. */ -#include -#include -#include -#include -#include -#include +#include "libbb.h" #include -#include -#include -#include -#include -#include -#include -#include #include -#include -#include "busybox.h" - -/* SYSLOG_NAMES defined to pull some extra junk from syslog.h */ +/* SYSLOG_NAMES defined to pull prioritynames[] and facilitynames[] + * from syslog.h. Grrrr - glibc puts those in _rwdata_! :( */ #define SYSLOG_NAMES +#define SYSLOG_NAMES_CONST /* uclibc is saner :) */ #include #include -/* Path for the file where all log messages are written */ -#define __LOG_FILE "/var/log/messages" - -/* Path to the unix socket */ -static char lfile[BUFSIZ]; - -static char *logFilePath = __LOG_FILE; - -/* interval between marks in seconds */ -static int MarkInterval = 20 * 60; - -/* localhost's name */ -static char LocalHostName[32]; - -#ifdef CONFIG_FEATURE_REMOTE_LOG +#if ENABLE_FEATURE_REMOTE_LOG #include -/* 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 - -/* circular buffer variables/structures */ -#ifdef CONFIG_FEATURE_IPC_SYSLOG - -#if __GNU_LIBRARY__ < 5 -#error Sorry. Looks like you are using libc5. -#error libc5 shm support isnt good enough. -#error Please disable CONFIG_FEATURE_IPC_SYSLOG #endif +#if ENABLE_FEATURE_IPC_SYSLOG #include #include #include +#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 - -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 -int data_size = 16000; // data size -int shm_size = 16000 + sizeof(*buf); // our buffer size -static int circular_logging = FALSE; +#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 + +enum { MAX_READ = 256 }; + +/* 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_IPC_SYSLOG + struct shbuf_ds *shbuf; +#endif + time_t last_log_time; + /* localhost's name */ + char localHostName[64]; + + /* We recv into recvbuf... */ + char recvbuf[MAX_READ]; + /* ...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) + + +/* 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_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, &G.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) -/* - * sem_up - up()'s a semaphore. - */ -static inline void sem_up(int semid) -{ - if ( semop(semid, SMwup, 1) == -1 ) - perror_msg_and_die("semop[SMwup]"); -} -/* - * sem_down - down()'s a semaphore - */ -static inline void sem_down(int semid) -{ - if ( semop(semid, SMwdn, 3) == -1 ) - perror_msg_and_die("semop[SMwdn]"); -} +/* circular buffer variables/structures */ +#if ENABLE_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 -void ipcsyslog_cleanup(void){ - printf("Exiting Syslogd!\n"); - if (shmid != -1) - shmdt(buf); +/* our shared key */ +#define KEY_ID ((long)0x414e4547) /* "GENA" */ - if (shmid != -1) - shmctl(shmid, IPC_RMID, NULL); - if (s_semid != -1) - semctl(s_semid, 0, IPC_RMID, 0); +static void ipcsyslog_cleanup(void) +{ + if (G.shmid != -1) { + shmdt(G.shbuf); + } + if (G.shmid != -1) { + shmctl(G.shmid, IPC_RMID, NULL); + } + if (G.s_semid != -1) { + semctl(G.s_semid, 0, IPC_RMID, 0); + } } -void ipcsyslog_init(void){ - if (buf == NULL){ - if ((shmid = shmget(KEY_ID, shm_size, IPC_CREAT | 1023)) == -1) - perror_msg_and_die("shmget"); - - - if ((buf = shmat(shmid, NULL, 0)) == NULL) - perror_msg_and_die("shmat"); +static void ipcsyslog_init(void) +{ + if (DEBUG) + printf("shmget(%lx, %d,...)\n", KEY_ID, G.shm_size); + 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) { + 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) - perror_msg_and_die("semget"); - }else - perror_msg_and_die("semget"); - } - }else{ - printf("Buffer already allocated just grab the semaphore?"); + 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; + } + bb_perror_msg_and_die("semget"); } } -/* write message to buffer */ -void circ_message(const char *msg){ - int l=strlen(msg)+1; /* count the whole message w/ '\0' included */ +/* Write message to shared mem buffer */ +static void log_to_shmem(const char *msg, int len) +{ + 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 */ - }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 */ - } - + 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 { + /* 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; + } + if (semop(G.s_semid, G.SMwup, 1) == -1) { + bb_perror_msg_and_die("SMwup"); } - sem_up(s_semid); + if (DEBUG) + printf("tail:%d\n", G.shbuf->tail); } -#endif -/* Note: There is also a function called "message()" in init.c */ +#else +void ipcsyslog_cleanup(void); +void ipcsyslog_init(void); +void log_to_shmem(const char *msg); +#endif /* FEATURE_IPC_SYSLOG */ + + /* 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(char *msg) { - int fd; struct flock fl; - va_list arguments; + int len = strlen(msg); - fl.l_whence = SEEK_SET; - fl.l_start = 0; - fl.l_len = 1; - -#ifdef CONFIG_FEATURE_IPC_SYSLOG - if ((circular_logging == TRUE) && (buf != NULL)){ - char b[1024]; - va_start (arguments, fmt); - vsprintf (b, fmt, arguments); - va_end (arguments); - circ_message(b); - - }else +#if ENABLE_FEATURE_IPC_SYSLOG + if ((option_mask32 & OPT_circularlog) && G.shbuf) { + log_to_shmem(msg, len); + return; + } #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); + if (G.logFD >= 0) { + time_t cur; + time(&cur); + if (G.last_log_time != cur) { + G.last_log_time = cur; /* reopen log file every second */ + close(G.logFD); + goto reopen; + } } 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); + reopen: + G.logFD = device_open(G.logFilePath, O_WRONLY | O_CREAT + | O_NOCTTY | O_APPEND | O_NONBLOCK); + if (G.logFD < 0) { + /* cannot open logfile? - print to /dev/console then */ + int fd = device_open(_PATH_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 } + + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 1; + fl.l_type = F_WRLCK; + fcntl(G.logFD, F_SETLKW, &fl); + +#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); + rename(oldFile, newFile); + } + /* newFile == "f.0" now */ + rename(G.logFilePath, newFile); + fl.l_type = F_UNLCK; + fcntl(G.logFD, F_SETLKW, &fl); + close(G.logFD); + goto reopen; + } + ftruncate(G.logFD, 0); + } + G.curFileSize += +#endif + full_write(G.logFD, msg, len); + fl.l_type = F_UNLCK; + fcntl(G.logFD, F_SETLKW, &fl); } -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 0 when they know + * that there is no timestamp, short-cutting the test. */ +static void timestamp_and_log(int pri, char *msg, int len) +{ + char *timestamp; + + if (len < 16 || msg[3] != ' ' || msg[6] != ' ' + || msg[9] != ':' || msg[12] != ':' || msg[15] != ' ' + ) { + time_t now; 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 - /* 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); - - if ( -1 == writev(remotefd,iov, IOV_COUNT)){ - error_msg_and_die("syslogd: cannot write to remote file handle on" - "%s:%d",RemoteHost,RemotePort); + timestamp[15] = '\0'; + + /* Log message locally (to file or shared mem) */ + if (!ENABLE_FEATURE_REMOTE_LOG || (option_mask32 & OPT_locallog)) { + if (LOG_PRI(pri) < G.logLevel) { + 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 %s %s %s\n", timestamp, G.localHostName, res, msg); + } + log_locally(G.printbuf); } } - 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) +static void split_escape_and_log(char *tmpbuf, int len) { - logMessage(LOG_SYSLOG | LOG_INFO, "System log daemon exiting."); - unlink(lfile); -#ifdef CONFIG_FEATURE_IPC_SYSLOG - ipcsyslog_cleanup(); -#endif - - exit(TRUE); -} - -static void domark(int sig) -{ - if (MarkInterval > 0) { - logMessage(LOG_SYSLOG | LOG_INFO, "-- MARK --"); - alarm(MarkInterval); - } -} - -/* This must be a #define, since when DODEBUG and BUFFERS_GO_IN_BSS are - * enabled, we otherwise get a "storage size isn't constant error. */ -#define BUFSIZE 1023 -static int serveConnection (int conn) -{ - RESERVE_CONFIG_BUFFER(tmpbuf, BUFSIZE + 1); - int n_read; char *p = tmpbuf; - n_read = read (conn, tmpbuf, BUFSIZE ); - - while (p < tmpbuf + n_read) { - - int pri = (LOG_USER | LOG_NOTICE); - char line[ BUFSIZE + 1 ]; - unsigned char c; - - char *q = line; - - tmpbuf[ n_read - 1 ] = '\0'; + tmpbuf += len; + while (p < tmpbuf) { + char c; + char *q = G.parsebuf; + int pri = (LOG_USER | LOG_NOTICE); + + 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 (p && (c = *p) && q < &line[ sizeof (line) - 1 ]) { - if (c == '<') { - /* Parse the magic priority number. */ - 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)) { + 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); + timestamp_and_log(pri, G.parsebuf, q - G.parsebuf); } - RELEASE_CONFIG_BUFFER (tmpbuf); - return n_read; } +static void quit_signal(int sig) +{ + timestamp_and_log(LOG_SYSLOG | LOG_INFO, (char*)"syslogd exiting", 0); + puts("syslogd exiting"); + if (ENABLE_FEATURE_IPC_SYSLOG) + ipcsyslog_cleanup(); + exit(1); +} -#ifdef CONFIG_FEATURE_REMOTE_LOG -static void init_RemoteLog (void){ - - struct sockaddr_in remoteaddr; - struct hostent *hostinfo; - int len = sizeof(remoteaddr); - - memset(&remoteaddr, 0, len); - - remotefd = socket(AF_INET, SOCK_DGRAM, 0); - - if (remotefd < 0) { - error_msg_and_die("syslogd: cannot create socket"); - } - - hostinfo = xgethostbyname(RemoteHost); - - remoteaddr.sin_family = AF_INET; - remoteaddr.sin_addr = *(struct in_addr *) *hostinfo->h_addr_list; - remoteaddr.sin_port = htons(RemotePort); - - /* - 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))){ - error_msg_and_die("syslogd: cannot connect to remote host %s:%d", RemoteHost, RemotePort); - } - +#ifdef SYSLOGD_MARK +static void do_mark(int sig) +{ + if (G.markInterval) { + timestamp_and_log(LOG_SYSLOG | LOG_INFO, (char*)"-- MARK --", 0); + alarm(G.markInterval); + } } #endif -static void doSyslogd (void) __attribute__ ((noreturn)); -static void doSyslogd (void) +static void do_syslogd(void) ATTRIBUTE_NORETURN; +static void do_syslogd(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); + char *dev_log_name; + + /* 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); + 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); +#ifdef SYSLOGD_MARK + signal(SIGALRM, do_mark); + alarm(G.markInterval); +#endif + remove_pidfile("/var/run/syslogd.pid"); - memset (&sunx, 0, sizeof (sunx)); + 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_STREAM, 0)) < 0) - 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)) || (listen (sock_fd, 5))) - perror_msg_and_die ("Could not connect to socket " _PATH_LOG); - - if (chmod (lfile, 0666) < 0) - perror_msg_and_die ("Could not set permission on " _PATH_LOG); + strcpy(sunx.sun_path, "/dev/log"); + + /* Unlink old /dev/log or object it points to. */ + /* (if it exists, bind will fail) */ + logmode = LOGMODE_NONE; + dev_log_name = xmalloc_readlink_or_warn("/dev/log"); + logmode = LOGMODE_STDIO; + if (dev_log_name) { + int fd = xopen(".", O_NONBLOCK); + xchdir("/dev"); + /* we do not check whether this is a link also */ + unlink(dev_log_name); + fchdir(fd); + close(fd); + safe_strncpy(sunx.sun_path, dev_log_name, sizeof(sunx.sun_path)); + free(dev_log_name); + } else { + unlink("/dev/log"); + } - FD_ZERO (&fds); - FD_SET (sock_fd, &fds); + sock_fd = xsocket(AF_UNIX, SOCK_DGRAM, 0); + xbind(sock_fd, (struct sockaddr *) &sunx, sizeof(sunx)); -#ifdef CONFIG_FEATURE_IPC_SYSLOG - if (circular_logging == TRUE ){ - ipcsyslog_init(); + if (chmod("/dev/log", 0666) < 0) { + bb_perror_msg_and_die("cannot set permission on /dev/log"); + } + 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(LOG_SYSLOG | LOG_INFO, + (char*)"syslogd started: BusyBox v" BB_VER, 0); for (;;) { - - fd_set readfds; - int n_ready; - int fd; - - memcpy (&readfds, &fds, sizeof (fds)); - - if ((n_ready = select (FD_SETSIZE, &readfds, NULL, NULL, NULL)) < 0) { - if (errno == EINTR) continue; /* alarm may have happened. */ - perror_msg_and_die ("select error"); + size_t sz; + + sz = read(sock_fd, G.recvbuf, MAX_READ - 1); + if (sz <= 0) { + if (sz == 0) + continue; /* EOF from unix socket??? */ + if (errno == EINTR) /* alarm may have happened */ + continue; + bb_perror_msg_and_die("read from /dev/log"); } - for (fd = 0; (n_ready > 0) && (fd < FD_SETSIZE); fd++) { - if (FD_ISSET (fd, &readfds)) { - - --n_ready; - - if (fd == sock_fd) { - int conn; - - //printf("New Connection request.\n"); - if ((conn = accept (sock_fd, (struct sockaddr *) &sunx, &addrLength)) < 0) { - perror_msg_and_die ("accept error"); - } - - FD_SET(conn, &fds); - //printf("conn: %i, set_size: %i\n",conn,FD_SETSIZE); - } else { - //printf("Serving connection: %i\n",fd); - if ( serveConnection(fd) <= 0 ) { - close (fd); - FD_CLR(fd, &fds); - } - } /* fd == sock_fd */ - }/* FD_ISSET() */ - }/* for */ - } /* for main loop */ + /* TODO: maybe suppress duplicates? */ +#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.remoteAddr) { + if (-1 == G.remoteFD) { + G.remoteFD = socket(G.remoteAddr->sa.sa_family, SOCK_DGRAM, 0); + } + if (-1 != G.remoteFD) { + /* send message to remote logger, ignore possible error */ + sendto(G.remoteFD, G.recvbuf, sz, MSG_DONTWAIT, + &G.remoteAddr->sa, G.remoteAddr->len); + } + } +#endif + G.recvbuf[sz] = '\0'; + split_escape_and_log(G.recvbuf, sz); + } /* for */ } -extern int syslogd_main(int argc, char **argv) +int syslogd_main(int argc, char **argv); +int syslogd_main(int argc, char **argv) { - int opt; - int doFork = TRUE; - + char OPTION_DECL; char *p; + PTR_TO_GLOBALS = memcpy(xzalloc(sizeof(G)), &init_data, sizeof(init_data)); + /* do normal option parsing */ - while ((opt = getopt(argc, argv, "m:nO:R:LC")) > 0) { - switch (opt) { - case 'm': - MarkInterval = atoi(optarg) * 60; - break; - case 'n': - doFork = FALSE; - break; - case 'O': - logFilePath = xstrdup(optarg); - break; -#ifdef CONFIG_FEATURE_REMOTE_LOG - case 'R': - RemoteHost = xstrdup(optarg); - if ( (p = strchr(RemoteHost, ':'))){ - RemotePort = atoi(p+1); - *p = '\0'; - } - doRemoteLog = TRUE; - break; - case 'L': - local_logging = TRUE; - break; + opt_complementary = "=0"; /* no non-option params */ + getopt32(argv, OPTION_STR, OPTION_PARAM); +#ifdef SYSLOGD_MARK + if (option_mask32 & OPT_mark) // -m + G.markInterval = xatou_range(opt_m, 0, INT_MAX/60) * 60; #endif -#ifdef CONFIG_FEATURE_IPC_SYSLOG - case 'C': - circular_logging = TRUE; - break; + //if (option_mask32 & OPT_nofork) // -n + //if (option_mask32 & OPT_outfile) // -O + if (option_mask32 & OPT_loglevel) // -l + G.logLevel = xatou_range(opt_l, 1, 8); + //if (option_mask32 & OPT_small) // -S +#if ENABLE_FEATURE_ROTATE_LOGFILE + if (option_mask32 & OPT_filesize) // -s + G.logFileSize = xatou_range(opt_s, 0, INT_MAX/1024) * 1024; + if (option_mask32 & OPT_rotatecnt) // -b + G.logFileRotate = xatou_range(opt_b, 0, 99); #endif - default: - show_usage(); - } +#if ENABLE_FEATURE_REMOTE_LOG + if (option_mask32 & OPT_remotelog) { // -R + G.remoteAddr = xhost2sockaddr(opt_R, 514); } - -#ifdef CONFIG_FEATURE_REMOTE_LOG - /* If they have not specified remote logging, then log locally */ - if (doRemoteLog == FALSE) - local_logging = TRUE; + //if (option_mask32 & OPT_locallog) // -L +#endif +#if ENABLE_FEATURE_IPC_SYSLOG + if (opt_C) // -Cn + G.shm_size = xatoul_range(opt_C, 4, INT_MAX/1024) * 1024; #endif + /* If they have not specified remote logging, then log locally */ + if (ENABLE_FEATURE_REMOTE_LOG && !(option_mask32 & OPT_remotelog)) + option_mask32 |= OPT_locallog; /* Store away localhost's name before the fork */ - gethostname(LocalHostName, sizeof(LocalHostName)); - if ((p = strchr(LocalHostName, '.'))) { - *p++ = '\0'; + gethostname(G.localHostName, sizeof(G.localHostName)); + p = strchr(G.localHostName, '.'); + if (p) { + *p = '\0'; } - umask(0); - - if (doFork == TRUE) { -#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__) - if (daemon(0, 1) < 0) - perror_msg_and_die("daemon"); -#else - error_msg_and_die("daemon not supported"); -#endif + if (!(option_mask32 & 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: -*/