X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=sysklogd%2Fsyslogd.c;h=8b59962beab757d45e16fa2a93fb161a26444114;hb=59f2c34037cc1044d9966acdb86ebc11b42dbd86;hp=9a5a04adbc5c760492d56e6f88cc96c706e24f40;hpb=49ea46667ffbaac7d3dc26f49720b98d4ac19af8;p=oweals%2Fbusybox.git diff --git a/sysklogd/syslogd.c b/sysklogd/syslogd.c index 9a5a04adb..8b59962be 100644 --- a/sysklogd/syslogd.c +++ b/sysklogd/syslogd.c @@ -15,7 +15,6 @@ #include "busybox.h" #include -#include #include /* SYSLOG_NAMES defined to pull some extra junk from syslog.h */ @@ -23,54 +22,101 @@ #include #include -/* Path for the file where all log messages are written */ -#define __LOG_FILE "/var/log/messages" +#define DEBUG 0 /* Path to the unix socket */ -static char lfile[MAXPATHLEN]; - -static const char *logFilePath = __LOG_FILE; +static char *dev_log_name; -#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 +/* Path for the file where all log messages are written */ +static const char *logFilePath = "/var/log/messages"; +static int logFD = -1; /* interval between marks in seconds */ -static int MarkInterval = 20 * 60; +static int markInterval = 20 * 60; + +/* level of messages to be locally logged */ +static int logLevel = 8; /* localhost's name */ -static char LocalHostName[64]; +static char localHostName[64]; -#ifdef CONFIG_FEATURE_REMOTE_LOG +#if ENABLE_FEATURE_ROTATE_LOGFILE +/* max size of message file before being rotated */ +static unsigned logFileSize = 200 * 1024; +/* number of rotated message files */ +static unsigned logFileRotate = 1; +static unsigned curFileSize; +static smallint isRegular; +#endif + +#if ENABLE_FEATURE_REMOTE_LOG #include /* udp socket for logging to remote host */ -static int remotefd = -1; -static struct sockaddr_in remoteaddr; - -/* where do we log? */ -static char *RemoteHost; - -/* what port to log to? */ -static int RemotePort = 514; - +static int remoteFD = -1; +static struct sockaddr_in remoteAddr; #endif -/* options */ -static unsigned opts; -#define SYSLOG_OPT_small (1) -#define SYSLOG_OPT_remotelog (2) -#define SYSLOG_OPT_locallog (4) -#define SYSLOG_OPT_circularlog (8) - -#define MAXLINE 1024 /* maximum line length */ +/* We are using bb_common_bufsiz1 for buffering: */ +enum { MAX_READ = (BUFSIZ/6) & ~0xf }; +/* We recv into RECVBUF... (size: MAX_READ ~== BUFSIZ/6) */ +#define RECVBUF bb_common_bufsiz1 +/* ...then copy to PARSEBUF, escaping control chars */ +/* (can grow x2 max ~== BUFSIZ/3) */ +#define PARSEBUF (bb_common_bufsiz1 + MAX_READ) +/* ...then sprintf into PRINTBUF, adding timestamp (15 chars), + * host (64), fac.prio (20) to the message */ +/* (growth by: 15 + 64 + 20 + delims = ~110) */ +#define PRINTBUF (bb_common_bufsiz1 + 3*MAX_READ) +/* totals: BUFSIZ == BUFSIZ/6 + BUFSIZ/3 + (BUFSIZ/3+BUFSIZ/6) + * -- we have BUFSIZ/6 extra at the ent of PRINTBUF + * which covers needed ~110 extra bytes (and much more) */ + + +/* 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, &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) /* circular buffer variables/structures */ -#ifdef CONFIG_FEATURE_IPC_SYSLOG +#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. @@ -82,30 +128,25 @@ static unsigned opts; #include /* our shared key */ -static const long KEY_ID = 0x414e4547; /*"GENA" */ +#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 -} *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 + int32_t size; // size of data written + int32_t head; // start of message list + int32_t tail; // end of message list + char data[1]; // data/messages +} *shbuf; // shared memory pointer + +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) { - printf("Exiting Syslogd!\n"); if (shmid != -1) { - shmdt(buf); + shmdt(shbuf); } - if (shmid != -1) { shmctl(shmid, IPC_RMID, NULL); } @@ -116,381 +157,321 @@ static void ipcsyslog_cleanup(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(%lx, %d,...)\n", KEY_ID, shm_size); - if ((buf = shmat(shmid, NULL, 0)) == NULL) { - bb_perror_msg_and_die("shmat"); - } + 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"); + } - buf->size = shm_size - sizeof(*buf); - buf->head = buf->tail = 0; + shbuf->size = shm_size - offsetof(struct shbuf_ds, data); + shbuf->head = shbuf->tail = 0; - // 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"); - } + // 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) + return; } - } else { - printf("Buffer already allocated just grab the semaphore?"); + bb_perror_msg_and_die("semget"); } } -/* write message to buffer */ -static 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 */ - const char * const fail_msg = "Can't find the terminator token%s?\n"; + /* Why libc insists on these being rw? */ + static struct sembuf SMwup[1] = { {1, -1, IPC_NOWAIT} }; + static struct sembuf SMwdn[3] = { {0, 0}, {1, 0}, {1, +1} }; + + int old_tail, new_tail; + char *c; if (semop(s_semid, 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 threadsafe way of handling shared memory operations. + * tail == position where to store next syslog message. + * head == position of next message to retrieve ("print"). + * if head == tail, there is no "unprinted" messages left. + * head is typically advanced by separate "reader" program, + * but if there isn't one, we have to do it ourself. + * messages are NUL-separated. */ - 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(fail_msg,""); - buf->head = 0; - } + len++; /* length with NUL included */ + again: + old_tail = shbuf->tail; + new_tail = old_tail + len; + if (new_tail < shbuf->size) { + /* No need to move head if shbuf->head <= old_tail, + * else... */ + if (old_tail < shbuf->head && shbuf->head <= new_tail) { + /* ...need to move head forward */ + c = memchr(shbuf->data + new_tail, '\0', + shbuf->size - new_tail); + if (!c) /* no NUL ahead of us, wrap around */ + c = memchr(shbuf->data, '\0', old_tail); + if (!c) { /* still nothing? point to this msg... */ + shbuf->head = old_tail; + } else { + /* convert pointer to offset + skip NUL */ + shbuf->head = c - shbuf->data + 1; } } - - /* 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 */ + /* store message, set new tail */ + memcpy(shbuf->data + old_tail, msg, len); + 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(fail_msg, " from the beginning"); - buf->head = buf->tail = 0; /* reset buffer, since it's probably corrupted */ + /* we need to break up the message and wrap it around */ + /* k == available buffer space ahead of old tail */ + int k = shbuf->size - old_tail - 1; + if (shbuf->head > old_tail) { + /* we are going to overwrite head, need to + * move it out of the way */ + c = memchr(shbuf->data, '\0', old_tail); + if (!c) { /* nothing? point to this msg... */ + shbuf->head = old_tail; + } else { /* convert pointer to offset + skip NUL */ + shbuf->head = c - shbuf->data + 1; + } } - + /* copy what fits to the end of buffer, and repeat */ + memcpy(shbuf->data + old_tail, msg, k); + msg += k; + len -= k; + shbuf->tail = 0; + goto again; } if (semop(s_semid, SMwup, 1) == -1) { bb_perror_msg_and_die("SMwup"); } - + if (DEBUG) + printf("head:%d tail:%d\n", shbuf->head, shbuf->tail); } #else void ipcsyslog_cleanup(void); void ipcsyslog_init(void); -void circ_message(const char *msg); -#endif /* CONFIG_FEATURE_IPC_SYSLOG */ +void log_to_shmem(const char *msg); -/* 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; +#endif /* FEATURE_IPC_SYSLOG */ -#ifdef CONFIG_FEATURE_IPC_SYSLOG - if ((opts & SYSLOG_OPT_circularlog) && (buf != NULL)) { - char b[1024]; - va_start(arguments, fmt); - vsnprintf(b, sizeof(b) - 1, fmt, arguments); - va_end(arguments); - circ_message(b); +/* Print a message to the log file. */ +static void log_locally(char *msg) +{ + static time_t last; - } else + struct flock fl; + int len = strlen(msg); + +#if ENABLE_FEATURE_IPC_SYSLOG + if ((option_mask32 & OPT_circularlog) && shbuf) { + log_to_shmem(msg, len); + return; + } #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; - char oldFile[(strlen(logFilePath)+4)]; - char newFile[(strlen(logFilePath)+4)]; - 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 ); - } - } + if (logFD >= 0) { + time_t cur; + time(&cur); + if (last != cur) { + last = cur; /* reopen log file every second */ + close(logFD); + goto reopen; } -#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); + reopen: + logFD = device_open(logFilePath, O_WRONLY | O_CREAT + | O_NOCTTY | O_APPEND | O_NONBLOCK); + if (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; + + isRegular = (fstat(logFD, &statf) == 0 && (statf.st_mode & S_IFREG)); + /* bug (mostly harmless): can wrap around if file > 4gb */ + curFileSize = statf.st_size; } +#endif } -} -#ifdef CONFIG_FEATURE_REMOTE_LOG -static void init_RemoteLog(void) -{ - memset(&remoteaddr, 0, sizeof(remoteaddr)); - remotefd = xsocket(AF_INET, SOCK_DGRAM, 0); - remoteaddr.sin_family = AF_INET; - remoteaddr.sin_addr = *(struct in_addr *) *(xgethostbyname(RemoteHost))->h_addr_list; - remoteaddr.sin_port = htons(RemotePort); -} -#else -void init_RemoteLog(void); + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 1; + fl.l_type = F_WRLCK; + fcntl(logFD, F_SETLKW, &fl); + +#if ENABLE_FEATURE_ROTATE_LOGFILE + if (logFileSize && isRegular && curFileSize > logFileSize) { + if (logFileRotate) { /* always 0..99 */ + int i = strlen(logFilePath) + 3 + 1; + char oldFile[i]; + char newFile[i]; + i = logFileRotate - 1; + /* rename: f.8 -> f.9; f.7 -> f.8; ... */ + while (1) { + sprintf(newFile, "%s.%d", logFilePath, i); + if (i == 0) break; + sprintf(oldFile, "%s.%d", logFilePath, --i); + rename(oldFile, newFile); + } + /* newFile == "f.0" now */ + rename(logFilePath, newFile); + fl.l_type = F_UNLCK; + fcntl(logFD, F_SETLKW, &fl); + close(logFD); + goto reopen; + } + ftruncate(logFD, 0); + } + curFileSize += #endif + full_write(logFD, msg, len); + fl.l_type = F_UNLCK; + fcntl(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; - char res[20]; 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); } +} + +/* 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 (strlen(msg) < 16 || msg[3] != ' ' || msg[6] != ' ' || - msg[9] != ':' || msg[12] != ':' || msg[15] != ' ') { + 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; } + timestamp[15] = '\0'; + + /* Log message locally (to file or shared mem) */ + if (!ENABLE_FEATURE_REMOTE_LOG || (option_mask32 & OPT_locallog)) { + if (LOG_PRI(pri) < logLevel) { + if (option_mask32 & OPT_small) + sprintf(PRINTBUF, "%s %s\n", timestamp, msg); + else { + char res[20]; + parse_fac_prio_20(pri, res); + sprintf(PRINTBUF, "%s %s %s %s\n", timestamp, localHostName, res, msg); + } + log_locally(PRINTBUF); + } + } +} - /* todo: supress duplicates */ +static void split_escape_and_log(char *tmpbuf, int len) +{ + char *p = tmpbuf; -#ifdef CONFIG_FEATURE_REMOTE_LOG - if (opts & SYSLOG_OPT_remotelog) { - char line[MAXLINE + 1]; - /* trying connect the socket */ - if (-1 == remotefd) { - init_RemoteLog(); - } + tmpbuf += len; + while (p < tmpbuf) { + char c; + char *q = PARSEBUF; + int pri = (LOG_USER | LOG_NOTICE); - /* if we have a valid socket, send the message */ - if (-1 != remotefd) { - now = 1; - snprintf(line, sizeof(line), "<%d>%s", pri, msg); - -retry: - /* send message to remote logger */ - if(( -1 == sendto(remotefd, line, strlen(line), 0, - (struct sockaddr *) &remoteaddr, - sizeof(remoteaddr))) && (errno == EINTR)) { - /* sleep now seconds and retry (with now * 2) */ - sleep(now); - now *= 2; - goto retry; + 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); } } - } - if (opts & SYSLOG_OPT_locallog) -#endif - { - /* now spew out the message to wherever it is supposed to go */ - if (opts & SYSLOG_OPT_small) - message("%s %s\n", timestamp, msg); - else - message("%s %s %s %s\n", timestamp, LocalHostName, res, msg); + while ((c = *p++)) { + if (c == '\n') + c = ' '; + if (!(c & ~0x1f)) { + *q++ = '^'; + c += '@'; /* ^@, ^A, ^B... */ + } + *q++ = c; + } + *q = '\0'; + /* Now log it */ + timestamp_and_log(pri, PARSEBUF, q - PARSEBUF); } } static void quit_signal(int sig) { - logMessage(LOG_SYSLOG | LOG_INFO, "System log daemon exiting."); - unlink(lfile); + timestamp_and_log(LOG_SYSLOG | LOG_INFO, "System log daemon exiting", 0); + puts("System log daemon exiting"); + unlink(dev_log_name); if (ENABLE_FEATURE_IPC_SYSLOG) ipcsyslog_cleanup(); - - exit(TRUE); -} - -static void domark(int sig) -{ - if (MarkInterval > 0) { - logMessage(LOG_SYSLOG | LOG_INFO, "-- MARK --"); - alarm(MarkInterval); - } + exit(1); } -/* 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) +static void do_mark(int sig) { - 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); + if (markInterval) { + timestamp_and_log(LOG_SYSLOG | LOG_INFO, "-- MARK --", 0); + alarm(markInterval); } - return n_read; } -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. */ + /* Set up signal handlers */ signal(SIGINT, quit_signal); signal(SIGTERM, quit_signal); signal(SIGQUIT, quit_signal); @@ -499,150 +480,130 @@ static void doSyslogd(void) #ifdef SIGCLD signal(SIGCLD, SIG_IGN); #endif - signal(SIGALRM, domark); - alarm(MarkInterval); + signal(SIGALRM, do_mark); + alarm(markInterval); - /* Create the syslog file so realpath() can work. */ - if (realpath(_PATH_LOG, lfile) != NULL) { - unlink(lfile); - } + dev_log_name = xmalloc_realpath(_PATH_LOG); + if (!dev_log_name) + dev_log_name = _PATH_LOG; + + /* Unlink old /dev/log (or object it points to) */ + unlink(dev_log_name); memset(&sunx, 0, sizeof(sunx)); sunx.sun_family = AF_UNIX; - strncpy(sunx.sun_path, lfile, sizeof(sunx.sun_path)); + strncpy(sunx.sun_path, dev_log_name, 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("Could not connect to socket " _PATH_LOG); - } + xbind(sock_fd, (struct sockaddr *) &sunx, addrLength); - if (chmod(lfile, 0666) < 0) { - bb_perror_msg_and_die("Could not set permission on " _PATH_LOG); + if (chmod(dev_log_name, 0666) < 0) { + bb_perror_msg_and_die("cannot set permission on %s", dev_log_name); } - if (ENABLE_FEATURE_IPC_SYSLOG && opts & SYSLOG_OPT_circularlog) { + if (ENABLE_FEATURE_IPC_SYSLOG && (option_mask32 & OPT_circularlog)) { ipcsyslog_init(); } - if (ENABLE_FEATURE_REMOTE_LOG && opts & SYSLOG_OPT_remotelog) { - init_RemoteLog(); - } - - logMessage(LOG_SYSLOG | LOG_INFO, "syslogd started: " "BusyBox v" BB_VER ); + timestamp_and_log(LOG_SYSLOG | LOG_INFO, "syslogd started: BusyBox v" BB_VER, 0); 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. */ + /* alarm may have happened */ continue; } - bb_perror_msg_and_die("select error"); + 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 { + i = recv(sock_fd, RECVBUF, MAX_READ - 1, 0); + if (i <= 0) bb_perror_msg_and_die("UNIX socket error"); + /* 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 (option_mask32 & OPT_remotelog) { + if (-1 == remoteFD) { + remoteFD = socket(AF_INET, SOCK_DGRAM, 0); + } + if (-1 != remoteFD) { + /* send message to remote logger, ignore possible error */ + sendto(remoteFD, RECVBUF, i, MSG_DONTWAIT, + (struct sockaddr *) &remoteAddr, + sizeof(remoteAddr)); + } } - } /* FD_ISSET() */ - } /* for main loop */ +#endif + RECVBUF[i] = '\0'; + split_escape_and_log(RECVBUF, i); + } /* FD_ISSET() */ + } /* for */ } int syslogd_main(int argc, char **argv) { - int opt; - - int doFork = TRUE; - + char OPTION_DECL; char *p; /* do normal option parsing */ - while ((opt = getopt(argc, argv, "m:nO:s:Sb:R:LC::")) > 0) { - switch (opt) { - case 'm': - MarkInterval = atoi(optarg) * 60; - break; - case 'n': - doFork = FALSE; - break; - case 'O': - logFilePath = optarg; - break; -#ifdef CONFIG_FEATURE_ROTATE_LOGFILE - case 's': - logFileSize = atoi(optarg) * 1024; - break; - case 'b': - logFileRotate = atoi(optarg); - if( logFileRotate > 99 ) logFileRotate = 99; - break; -#endif -#ifdef CONFIG_FEATURE_REMOTE_LOG - case 'R': - RemoteHost = xstrdup(optarg); - if ((p = strchr(RemoteHost, ':'))) { - RemotePort = atoi(p + 1); - *p = '\0'; - } - opts |= SYSLOG_OPT_remotelog; - break; - case 'L': - opts |= SYSLOG_OPT_locallog; - break; -#endif -#ifdef CONFIG_FEATURE_IPC_SYSLOG - case 'C': - if (optarg) { - int buf_size = atoi(optarg); - if (buf_size >= 4) { - shm_size = buf_size * 1024; - } - } - opts |= SYSLOG_OPT_circularlog; - break; + opt_complementary = "=0"; /* no non-option params */ + getopt32(argc, argv, OPTION_STR, OPTION_PARAM); + if (option_mask32 & OPT_mark) // -m + markInterval = xatou_range(opt_m, 0, INT_MAX/60) * 60; + //if (option_mask32 & OPT_nofork) // -n + //if (option_mask32 & OPT_outfile) // -O + if (option_mask32 & OPT_loglevel) // -l + logLevel = xatou_range(opt_l, 1, 8); + //if (option_mask32 & OPT_small) // -S +#if ENABLE_FEATURE_ROTATE_LOGFILE + if (option_mask32 & OPT_filesize) // -s + logFileSize = xatou_range(opt_s, 0, INT_MAX/1024) * 1024; + if (option_mask32 & OPT_rotatecnt) // -b + logFileRotate = xatou_range(opt_b, 0, 99); #endif - case 'S': - opts |= SYSLOG_OPT_small; - break; - default: - bb_show_usage(); +#if ENABLE_FEATURE_REMOTE_LOG + if (option_mask32 & OPT_remotelog) { // -R + int port = 514; + p = strchr(opt_R, ':'); + if (p) { + *p++ = '\0'; + port = xatou16(p); } + /* FIXME: looks ip4-specific. need to do better */ + bb_lookup_host(&remoteAddr, opt_R); + remoteAddr.sin_port = bb_lookup_port(port, "udp", port); } + //if (option_mask32 & OPT_locallog) // -L +#endif +#if ENABLE_FEATURE_IPC_SYSLOG + if ((option_mask32 & OPT_circularlog) && opt_C) // -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 && !(opts & SYSLOG_OPT_remotelog)) - opts |= SYSLOG_OPT_locallog; - + 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, '.'))) { + gethostname(localHostName, sizeof(localHostName)); + p = strchr(localHostName, '.'); + if (p) { *p = '\0'; } - umask(0); - - if (doFork == TRUE) { + 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; + umask(0); + do_syslogd(); + /* return EXIT_SUCCESS; */ }