X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=syslogd.c;h=14219eb541f2b8710d91951abc3362966841f4cc;hb=220238305f8b6604fbc2eca463f9cd0dd755f1ad;hp=24c721f8eb4c9915a8f41025184622ecb70396c7;hpb=2cb55077e2f65f17dbc8933eec47760bcc2a6ba1;p=oweals%2Fbusybox.git diff --git a/syslogd.c b/syslogd.c index 24c721f8e..14219eb54 100644 --- a/syslogd.c +++ b/syslogd.c @@ -1,9 +1,16 @@ +/* vi: set sw=4 ts=4: */ /* * Mini syslogd implementation for busybox * - * Copyright (C) 1999 by Lineo, inc. + * Copyright (C) 1999,2000,2001 by Lineo, inc. * Written by Erik Andersen , * + * Copyright (C) 2000 by Karl M. Hegbloom + * + * "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 @@ -20,386 +27,613 @@ * */ -#include "internal.h" #include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include #include -#include -#include #include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include -#define ksyslog klogctl -extern int ksyslog(int type, char *buf, int len); - +#include "busybox.h" /* SYSLOG_NAMES defined to pull some extra junk from syslog.h */ #define SYSLOG_NAMES #include +#include /* Path for the file where all log messages are written */ -#define __LOG_FILE "/var/log/messages" +#define __LOG_FILE "/var/log/messages" +/* Path to the unix socket */ +static char lfile[BUFSIZ]; + +static char *logFilePath = __LOG_FILE; -static char* logFilePath = __LOG_FILE; /* interval between marks in seconds */ -static int MarkInterval = 20*60; +static int MarkInterval = 20 * 60; + /* localhost's name */ static char LocalHostName[32]; -static const char syslogd_usage[] = - "syslogd [OPTION]...\n\n" - "Linux system and kernel (provides klogd) logging utility.\n" - "Note that this version of syslogd/klogd ignores /etc/syslog.conf.\n\n" - "Options:\n" - "\t-m\tChange the mark timestamp interval. default=20min. 0=off\n" - "\t-n\tDo not fork into the background (for when run by init)\n" -#ifdef BB_KLOGD - "\t-K\tDo not start up the klogd process (by default syslogd spawns klogd).\n" +#ifdef BB_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 - "\t-O\tSpecify an alternate log file. default=/var/log/messages\n"; +/* circular buffer variables/structures */ +#ifdef BB_FEATURE_IPC_SYSLOG -/* try to open up the specified device */ -static int device_open(char *device, int mode) +#include +#include +#include + +/* 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; + +/* + * sem_up - up()'s a semaphore. + */ +static inline void sem_up(int semid) { - int m, f, fd = -1; - - m = mode | O_NONBLOCK; - - /* Retry up to 5 times */ - for (f = 0; f < 5; f++) - if ((fd = open(device, m)) >= 0) - break; - if (fd < 0) - return fd; - /* Reset original flags. */ - if (m != mode) - fcntl(fd, F_SETFL, mode); - return fd; + if ( semop(semid, SMwup, 1) == -1 ) + perror_msg_and_die("semop[SMwup]"); } -/* print a message to the log file */ -static void message(char *fmt, ...) +/* + * sem_down - down()'s a semaphore + */ +static inline void sem_down(int semid) { - int fd; - va_list arguments; - - if ((fd = device_open(logFilePath, O_WRONLY|O_CREAT|O_NOCTTY|O_APPEND|O_NONBLOCK)) >= 0) { - va_start(arguments, fmt); - vdprintf(fd, fmt, arguments); - va_end(arguments); - close(fd); - } else { - /* Always send console messages to /dev/console so people will see them. */ - if ((fd = device_open(_PATH_CONSOLE, O_WRONLY|O_NOCTTY|O_NONBLOCK)) >= 0) { - va_start(arguments, fmt); - vdprintf(fd, fmt, arguments); - va_end(arguments); - close(fd); - } else { - fprintf(stderr, "Bummer, can't print: "); - va_start(arguments, fmt); - vfprintf(stderr, fmt, arguments); - fflush(stderr); - va_end(arguments); + if ( semop(semid, SMwdn, 3) == -1 ) + perror_msg_and_die("semop[SMwdn]"); +} + + +void ipcsyslog_cleanup(void){ + printf("Exiting Syslogd!\n"); + if (shmid != -1) + shmdt(buf); + + if (shmid != -1) + shmctl(shmid, IPC_RMID, NULL); + if (s_semid != -1) + semctl(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"); + + + buf->size=data_size; + buf->head=buf->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) + perror_msg_and_die("semget"); + }else + perror_msg_and_die("semget"); + } + }else{ + printf("Buffer already allocated just grab the semaphore?"); } - } } -static void logMessage( int pri, char* msg) +/* write message to buffer */ +void circ_message(const char *msg){ + int l=strlen(msg)+1; /* count the whole message w/ '\0' included */ + + sem_down(s_semid); + + /* + * 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. + */ + 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 */ + } + + } + sem_up(s_semid); +} +#endif +/* 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, ...) { - time_t now; - char *timestamp; - static char res[20]; - CODE *c_pri, *c_fac; - - 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=='\0' || *c_pri->c_name=='\0') - 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 */ - - /* now spew out the message to wherever it is supposed to go */ - message( "%s %s %s %s\n", timestamp, LocalHostName, res, msg); + int fd; + struct flock fl; + va_list arguments; + + fl.l_whence = SEEK_SET; + fl.l_start = 0; + fl.l_len = 1; + +#ifdef BB_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 +#endif + if ((fd = device_open (logFilePath, + O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND | + O_NONBLOCK)) >= 0) { + fl.l_type = F_WRLCK; + fcntl (fd, F_SETLKW, &fl); + va_start (arguments, fmt); + vdprintf (fd, fmt, arguments); + va_end (arguments); + fl.l_type = F_UNLCK; + fcntl (fd, F_SETLKW, &fl); + close (fd); + } else { + /* Always send console messages to /dev/console so people will see them. */ + if ((fd = device_open (_PATH_CONSOLE, + O_WRONLY | O_NOCTTY | O_NONBLOCK)) >= 0) { + va_start (arguments, fmt); + vdprintf (fd, fmt, arguments); + va_end (arguments); + close (fd); + } else { + fprintf (stderr, "Bummer, can't print: "); + va_start (arguments, fmt); + vfprintf (stderr, fmt, arguments); + fflush (stderr); + va_end (arguments); + } + } } -static void quit_signal(int sig) +static void logMessage (int pri, char *msg) { - logMessage(LOG_SYSLOG|LOG_INFO, "System log daemon exiting."); - unlink( _PATH_LOG); - exit( TRUE); + time_t now; + char *timestamp; + static 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); + } + + 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 BB_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); + } + } + 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 restart_signal(int sig) +static void quit_signal(int sig) { - /* pretend to restart */ - logMessage(LOG_SYSLOG|LOG_INFO, "syslogd restarting"); + logMessage(LOG_SYSLOG | LOG_INFO, "System log daemon exiting."); + unlink(lfile); +#ifdef BB_FEATURE_IPC_SYSLOG + ipcsyslog_cleanup(); +#endif + + exit(TRUE); } static void domark(int sig) { - if (MarkInterval > 0) { - logMessage(LOG_SYSLOG|LOG_INFO, "-- MARK --"); - signal(SIGALRM, domark); - alarm(MarkInterval); - } + if (MarkInterval > 0) { + logMessage(LOG_SYSLOG | LOG_INFO, "-- MARK --"); + alarm(MarkInterval); + } } -static void doSyslogd(void) +/* 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) { - struct sockaddr_un sunx; - int fd, conn; - size_t addrLength; - char buf[1024]; - char *q, *p = buf; - int readSize; - - /* Remove any preexisting socket/file */ - unlink(_PATH_LOG); - - /* Set up sig handlers */ - signal(SIGINT, quit_signal); - signal(SIGTERM, quit_signal); - signal(SIGQUIT, quit_signal); - signal(SIGHUP, restart_signal); - signal(SIGALRM, domark); - alarm(MarkInterval); - - - unlink( _PATH_LOG); - memset(&sunx, 0, sizeof(sunx)); - sunx.sun_family = AF_UNIX; /* Unix domain socket */ - strncpy(sunx.sun_path, _PATH_LOG, sizeof(sunx.sun_path)); - if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0 ) { - perror("Couldn't obtain descriptor for socket " _PATH_LOG); - exit( FALSE); - } - - addrLength = sizeof(sunx.sun_family) + strlen(sunx.sun_path); - if ( (bind(fd, (struct sockaddr *) &sunx, addrLength)) || - (fchmod(fd, 0666) < 0) || (listen(fd, 5)) ) - { - perror("Could not connect to socket " _PATH_LOG); - exit( FALSE); - } - - - logMessage(LOG_SYSLOG|LOG_INFO, "syslogd started: " - "BusyBox v" BB_VER " (" BB_BT ")"); - - - while ((conn = accept(fd, (struct sockaddr *) &sunx, - &addrLength)) >= 0) - { - while ((readSize=read(conn, buf, sizeof(buf))) > 0) - { - char line[1025]; - unsigned char c; - int pri = (LOG_USER|LOG_NOTICE); - - memset (line, 0, sizeof(line)); - p = buf; - q = line; - 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)) { - *q++ = '^'; - *q++ = c ^ 0100; - } else { - *q++ = c; + RESERVE_BB_BUFFER(tmpbuf, BUFSIZE + 1); + int n_read; + + n_read = read (conn, tmpbuf, BUFSIZE ); + + if (n_read > 0) { + + int pri = (LOG_USER | LOG_NOTICE); + char line[ BUFSIZE + 1 ]; + unsigned char c; + + char *p = tmpbuf, *q = line; + + tmpbuf[ n_read - 1 ] = '\0'; + + 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)) { + *q++ = '^'; + *q++ = c ^ 0100; + } else { + *q++ = c; + } + p++; } - p++; - } - *q = '\0'; - - /* Now log it */ - logMessage( pri, line); + *q = '\0'; + /* Now log it */ + logMessage (pri, line); } - close(conn); - } - - close(fd); + RELEASE_BB_BUFFER (tmpbuf); + return n_read; } -#ifdef BB_KLOGD -static void klogd_signal(int sig) -{ - ksyslog(7, NULL, 0); - ksyslog(0, 0, 0); - logMessage(LOG_SYSLOG|LOG_INFO, "Kernel log daemon exiting."); - exit( TRUE); +#ifdef BB_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); + } + } +#endif -static void doKlogd(void) +static void doSyslogd (void) __attribute__ ((noreturn)); +static void doSyslogd (void) { - int priority=LOG_INFO; - char log_buffer[4096]; - char *logp; - - /* Set up sig handlers */ - signal(SIGINT, klogd_signal); - signal(SIGKILL, klogd_signal); - signal(SIGTERM, klogd_signal); - signal(SIGHUP, klogd_signal); - logMessage(LOG_SYSLOG|LOG_INFO, "klogd started: " - "BusyBox v" BB_VER " (" BB_BT ")"); - - ksyslog(1, NULL, 0); - - while (1) { - /* Use kernel syscalls */ - memset(log_buffer, '\0', sizeof(log_buffer)); - if ( ksyslog(2, log_buffer, sizeof(log_buffer)) < 0 ) { - char message[80]; - if ( errno == EINTR ) - continue; - snprintf(message, 79, "klogd: Error return from sys_sycall: " \ - "%d - %s.\n", errno, strerror(errno)); - logMessage(LOG_SYSLOG|LOG_ERR, message); - exit(1); + 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)); + 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); + + FD_ZERO (&fds); + FD_SET (sock_fd, &fds); + +#ifdef BB_FEATURE_IPC_SYSLOG + if (circular_logging == TRUE ){ + ipcsyslog_init(); } - logp=log_buffer; - if ( *log_buffer == '<' ) - { - switch ( *(log_buffer+1) ) - { - case '0': - priority = LOG_EMERG; - break; - case '1': - priority = LOG_ALERT; - break; - case '2': - priority = LOG_CRIT; - break; - case '3': - priority = LOG_ERR; - break; - case '4': - priority = LOG_WARNING; - break; - case '5': - priority = LOG_NOTICE; - break; - case '6': - priority = LOG_INFO; - break; - case '7': - default: - priority = LOG_DEBUG; - } - logp+=3; +#endif + + #ifdef BB_FEATURE_REMOTE_LOG + if (doRemoteLog == TRUE){ + init_RemoteLog(); } - logMessage(LOG_KERN|priority, logp); - } + #endif -} + logMessage (LOG_SYSLOG | LOG_INFO, "syslogd started: " BB_BANNER); -#endif + 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"); + } + + 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 */ +} extern int syslogd_main(int argc, char **argv) { - int pid, klogd_pid; - int doFork = TRUE; -#ifdef BB_KLOGD - int startKlogd = TRUE; + int opt; + int doFork = TRUE; + + char *p; + + /* do normal option parsing */ + while ((opt = getopt(argc, argv, "m:nO:R:LC")) > 0) { + switch (opt) { + case 'm': + MarkInterval = atoi(optarg) * 60; + break; + case 'n': + doFork = FALSE; + break; + case 'O': + logFilePath = strdup(optarg); + break; +#ifdef BB_FEATURE_REMOTE_LOG + case 'R': + RemoteHost = strdup(optarg); + if ( (p = strchr(RemoteHost, ':'))){ + RemotePort = atoi(p+1); + *p = '\0'; + } + doRemoteLog = TRUE; + break; + case 'L': + local_logging = TRUE; + break; #endif - char *p; - char **argv1=argv; - - while (--argc > 0 && **(++argv1) == '-') { - while (*(++(*argv1))) { - switch (**argv1) { - case 'm': - if (--argc == 0) { - usage(syslogd_usage); - } - MarkInterval = atoi(*(++argv1))*60; - break; - case 'n': - doFork = FALSE; - break; -#ifdef BB_KLOGD - case 'K': - startKlogd = FALSE; - break; +#ifdef BB_FEATURE_IPC_SYSLOG + case 'C': + circular_logging = TRUE; + break; #endif - case 'O': - if (--argc == 0) { - usage(syslogd_usage); + default: + show_usage(); } - logFilePath = *(++argv1); - break; - default: - usage(syslogd_usage); - } } - } - - /* Store away localhost's name before the fork */ - gethostname(LocalHostName, sizeof(LocalHostName)); - if ( (p = strchr(LocalHostName, '.')) ) { - *p++ = '\0'; - } - - if (doFork == TRUE) { - pid = fork(); - if ( pid < 0 ) - exit( pid); - else if ( pid == 0 ) { - strncpy(argv[0], "syslogd",strlen(argv[0])); - doSyslogd(); + +#ifdef BB_FEATURE_REMOTE_LOG + /* If they have not specified remote logging, then log locally */ + if (doRemoteLog == FALSE) + local_logging = TRUE; +#endif + + + /* Store away localhost's name before the fork */ + gethostname(LocalHostName, sizeof(LocalHostName)); + if ((p = strchr(LocalHostName, '.'))) { + *p++ = '\0'; } - } else { - doSyslogd(); - } - -#ifdef BB_KLOGD - /* Start up the klogd process */ - if (startKlogd == TRUE) { - klogd_pid = fork(); - if (klogd_pid == 0 ) { - strncpy(argv[0], "klogd", strlen(argv[0])); - doKlogd(); + + umask(0); + + if (doFork == TRUE) { + if (daemon(0, 1) < 0) + perror_msg_and_die("daemon"); } - } -#endif + doSyslogd(); - exit( TRUE); + return EXIT_SUCCESS; } - +/* +Local Variables +c-file-style: "linux" +c-basic-offset: 4 +tab-width: 4 +End: +*/