sysklogd/syslogd.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini syslogd implementation for busybox
   4  *
   5  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
   6  *
   7  * Copyright (C) 2000 by Karl M. Hegbloom <karlheg@debian.org>
   8  *
   9  * "circular buffer" Copyright (C) 2001 by Gennady Feldman <gfeldman@gena01.com>
  10  *
  11  * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  21  * General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26  *
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <ctype.h>
  32 #include <errno.h>
  33 #include <fcntl.h>
  34 #include <getopt.h>
  35 #include <netdb.h>
  36 #include <paths.h>
  37 #include <signal.h>
  38 #include <stdarg.h>
  39 #include <stdbool.h>
  40 #include <time.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <sys/socket.h>
  44 #include <sys/types.h>
  45 #include <sys/un.h>
  46 #include <sys/param.h>
  47
  48 #include "busybox.h"
  49
  50 /* SYSLOG_NAMES defined to pull some extra junk from syslog.h */
  51 #define SYSLOG_NAMES
  52 #include <sys/syslog.h>
  53 #include <sys/uio.h>
  54
  55 /* Path for the file where all log messages are written */
  56 #define __LOG_FILE "/var/log/messages"
  57
  58 /* Path to the unix socket */
  59 static char lfile[MAXPATHLEN];
  60
  61 static const char *logFilePath = __LOG_FILE;
  62
  63 #ifdef CONFIG_FEATURE_ROTATE_LOGFILE
  64 /* max size of message file before being rotated */
  65 static int logFileSize = 200 * 1024;
  66
  67 /* number of rotated message files */
  68 static int logFileRotate = 1;
  69 #endif
  70
  71 /* interval between marks in seconds */
  72 static int MarkInterval = 20 * 60;
  73
  74 /* localhost's name */
  75 static char LocalHostName[64];
  76
  77 #ifdef CONFIG_FEATURE_REMOTE_LOG
  78 #include <netinet/in.h>
  79 /* udp socket for logging to remote host */
  80 static int remotefd = -1;
  81 static struct sockaddr_in remoteaddr;
  82
  83 /* where do we log? */
  84 static char *RemoteHost;
  85
  86 /* what port to log to? */
  87 static int RemotePort = 514;
  88
  89 /* To remote log or not to remote log, that is the question. */
  90 static int doRemoteLog = FALSE;
  91 static int local_logging = FALSE;
  92 #endif
  93
  94 /* Make loging output smaller. */
  95 static bool small = false;
  96
  97
  98 #define MAXLINE         1024    /* maximum line length */
  99
 100
 101 /* circular buffer variables/structures */
 102 #ifdef CONFIG_FEATURE_IPC_SYSLOG
 103
 104 #if CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE < 4
 105 #error Sorry, you must set the syslogd buffer size to at least 4KB.
 106 #error Please check CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE
 107 #endif
 108
 109 #include <sys/ipc.h>
 110 #include <sys/sem.h>
 111 #include <sys/shm.h>
 112
 113 /* our shared key */
 114 static const long KEY_ID = 0x414e4547;  /*"GENA" */
 115
 116 // Semaphore operation structures
 117 static struct shbuf_ds {
 118         int size;                       // size of data written
 119         int head;                       // start of message list
 120         int tail;                       // end of message list
 121         char data[1];           // data/messages
 122 } *buf = NULL;                  // shared memory pointer
 123
 124 static struct sembuf SMwup[1] = { {1, -1, IPC_NOWAIT} };        // set SMwup
 125 static struct sembuf SMwdn[3] = { {0, 0}, {1, 0}, {1, +1} };    // set SMwdn
 126
 127 static int shmid = -1;  // ipc shared memory id
 128 static int s_semid = -1;        // ipc semaphore id
 129 static int shm_size = ((CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE)*1024);   // default shm size
 130 static int circular_logging = FALSE;
 131
 132 /*
 133  * sem_up - up()'s a semaphore.
 134  */
 135 static inline void sem_up(int semid)
 136 {
 137         if (semop(semid, SMwup, 1) == -1) {
 138                 bb_perror_msg_and_die("semop[SMwup]");
 139         }
 140 }
 141
 142 /*
 143  * sem_down - down()'s a semaphore
 144  */
 145 static inline void sem_down(int semid)
 146 {
 147         if (semop(semid, SMwdn, 3) == -1) {
 148                 bb_perror_msg_and_die("semop[SMwdn]");
 149         }
 150 }
 151
 152
 153 static void ipcsyslog_cleanup(void)
 154 {
 155         printf("Exiting Syslogd!\n");
 156         if (shmid != -1) {
 157                 shmdt(buf);
 158         }
 159
 160         if (shmid != -1) {
 161                 shmctl(shmid, IPC_RMID, NULL);
 162         }
 163         if (s_semid != -1) {
 164                 semctl(s_semid, 0, IPC_RMID, 0);
 165         }
 166 }
 167
 168 static void ipcsyslog_init(void)
 169 {
 170         if (buf == NULL) {
 171                 if ((shmid = shmget(KEY_ID, shm_size, IPC_CREAT | 1023)) == -1) {
 172                         bb_perror_msg_and_die("shmget");
 173                 }
 174
 175                 if ((buf = shmat(shmid, NULL, 0)) == NULL) {
 176                         bb_perror_msg_and_die("shmat");
 177                 }
 178
 179                 buf->size = shm_size - sizeof(*buf);
 180                 buf->head = buf->tail = 0;
 181
 182                 // we'll trust the OS to set initial semval to 0 (let's hope)
 183                 if ((s_semid = semget(KEY_ID, 2, IPC_CREAT | IPC_EXCL | 1023)) == -1) {
 184                         if (errno == EEXIST) {
 185                                 if ((s_semid = semget(KEY_ID, 2, 0)) == -1) {
 186                                         bb_perror_msg_and_die("semget");
 187                                 }
 188                         } else {
 189                                 bb_perror_msg_and_die("semget");
 190                         }
 191                 }
 192         } else {
 193                 printf("Buffer already allocated just grab the semaphore?");
 194         }
 195 }
 196
 197 /* write message to buffer */
 198 static void circ_message(const char *msg)
 199 {
 200         int l = strlen(msg) + 1;        /* count the whole message w/ '\0' included */
 201
 202         sem_down(s_semid);
 203
 204         /*
 205          * Circular Buffer Algorithm:
 206          * --------------------------
 207          *
 208          * Start-off w/ empty buffer of specific size SHM_SIZ
 209          * Start filling it up w/ messages. I use '\0' as separator to break up messages.
 210          * This is also very handy since we can do printf on message.
 211          *
 212          * Once the buffer is full we need to get rid of the first message in buffer and
 213          * insert the new message. (Note: if the message being added is >1 message then
 214          * we will need to "remove" >1 old message from the buffer). The way this is done
 215          * is the following:
 216          *      When we reach the end of the buffer we set a mark and start from the beginning.
 217          *      Now what about the beginning and end of the buffer? Well we have the "head"
 218          *      index/pointer which is the starting point for the messages and we have "tail"
 219          *      index/pointer which is the ending point for the messages. When we "display" the
 220          *      messages we start from the beginning and continue until we reach "tail". If we
 221          *      reach end of buffer, then we just start from the beginning (offset 0). "head" and
 222          *      "tail" are actually offsets from the beginning of the buffer.
 223          *
 224          * Note: This algorithm uses Linux IPC mechanism w/ shared memory and semaphores to provide
 225          *       a threasafe way of handling shared memory operations.
 226          */
 227         if ((buf->tail + l) < buf->size) {
 228                 /* before we append the message we need to check the HEAD so that we won't
 229                    overwrite any of the message that we still need and adjust HEAD to point
 230                    to the next message! */
 231                 if (buf->tail < buf->head) {
 232                         if ((buf->tail + l) >= buf->head) {
 233                                 /* we need to move the HEAD to point to the next message
 234                                  * Theoretically we have enough room to add the whole message to the
 235                                  * buffer, because of the first outer IF statement, so we don't have
 236                                  * to worry about overflows here!
 237                                  */
 238                                 int k = buf->tail + l - buf->head;      /* we need to know how many bytes
 239                                                                                                            we are overwriting to make
 240                                                                                                            enough room */
 241                                 char *c =
 242                                         memchr(buf->data + buf->head + k, '\0',
 243                                                    buf->size - (buf->head + k));
 244                                 if (c != NULL) {        /* do a sanity check just in case! */
 245                                         buf->head = c - buf->data + 1;  /* we need to convert pointer to
 246                                                                                                            offset + skip the '\0' since
 247                                                                                                            we need to point to the beginning
 248                                                                                                            of the next message */
 249                                         /* Note: HEAD is only used to "retrieve" messages, it's not used
 250                                            when writing messages into our buffer */
 251                                 } else {        /* show an error message to know we messed up? */
 252                                         printf("Weird! Can't find the terminator token??? \n");
 253                                         buf->head = 0;
 254                                 }
 255                         }
 256                 }
 257
 258                 /* in other cases no overflows have been done yet, so we don't care! */
 259                 /* we should be ok to append the message now */
 260                 strncpy(buf->data + buf->tail, msg, l); /* append our message */
 261                 buf->tail += l; /* count full message w/ '\0' terminating char */
 262         } else {
 263                 /* we need to break up the message and "circle" it around */
 264                 char *c;
 265                 int k = buf->tail + l - buf->size;      /* count # of bytes we don't fit */
 266
 267                 /* We need to move HEAD! This is always the case since we are going
 268                  * to "circle" the message.
 269                  */
 270                 c = memchr(buf->data + k, '\0', buf->size - k);
 271
 272                 if (c != NULL) {        /* if we don't have '\0'??? weird!!! */
 273                         /* move head pointer */
 274                         buf->head = c - buf->data + 1;
 275
 276                         /* now write the first part of the message */
 277                         strncpy(buf->data + buf->tail, msg, l - k - 1);
 278
 279                         /* ALWAYS terminate end of buffer w/ '\0' */
 280                         buf->data[buf->size - 1] = '\0';
 281
 282                         /* now write out the rest of the string to the beginning of the buffer */
 283                         strcpy(buf->data, &msg[l - k - 1]);
 284
 285                         /* we need to place the TAIL at the end of the message */
 286                         buf->tail = k + 1;
 287                 } else {
 288                         printf
 289                                 ("Weird! Can't find the terminator token from the beginning??? \n");
 290                         buf->head = buf->tail = 0;      /* reset buffer, since it's probably corrupted */
 291                 }
 292
 293         }
 294         sem_up(s_semid);
 295 }
 296 #endif                                                  /* CONFIG_FEATURE_IPC_SYSLOG */
 297
 298 /* Note: There is also a function called "message()" in init.c */
 299 /* Print a message to the log file. */
 300 static void message(char *fmt, ...) __attribute__ ((format(printf, 1, 2)));
 301 static void message(char *fmt, ...)
 302 {
 303         int fd;
 304         struct flock fl;
 305         va_list arguments;
 306
 307         fl.l_whence = SEEK_SET;
 308         fl.l_start = 0;
 309         fl.l_len = 1;
 310
 311 #ifdef CONFIG_FEATURE_IPC_SYSLOG
 312         if ((circular_logging == TRUE) && (buf != NULL)) {
 313                 char b[1024];
 314
 315                 va_start(arguments, fmt);
 316                 vsnprintf(b, sizeof(b) - 1, fmt, arguments);
 317                 va_end(arguments);
 318                 circ_message(b);
 319
 320         } else
 321 #endif
 322         if ((fd = device_open(logFilePath,
 323                                         O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND |
 324                                                          O_NONBLOCK)) >= 0) {
 325                 fl.l_type = F_WRLCK;
 326                 fcntl(fd, F_SETLKW, &fl);
 327 #ifdef CONFIG_FEATURE_ROTATE_LOGFILE
 328                 if ( logFileSize > 0 ) {
 329                         struct stat statf;
 330                         int r = fstat(fd, &statf);
 331                         if( !r && (statf.st_mode & S_IFREG)
 332                                 && (lseek(fd,0,SEEK_END) > logFileSize) ) {
 333                                 if(logFileRotate > 0) {
 334                                         int i;
 335                                         char oldFile[(strlen(logFilePath)+4)], newFile[(strlen(logFilePath)+4)];
 336                                         for(i=logFileRotate-1;i>0;i--) {
 337                                                 sprintf(oldFile, "%s.%d", logFilePath, i-1);
 338                                                 sprintf(newFile, "%s.%d", logFilePath, i);
 339                                                 rename(oldFile, newFile);
 340                                         }
 341                                         sprintf(newFile, "%s.%d", logFilePath, 0);
 342                                         fl.l_type = F_UNLCK;
 343                                         fcntl (fd, F_SETLKW, &fl);
 344                                         close(fd);
 345                                         rename(logFilePath, newFile);
 346                                         fd = device_open (logFilePath,
 347                                                    O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND |
 348                                                    O_NONBLOCK);
 349                                         fl.l_type = F_WRLCK;
 350                                         fcntl (fd, F_SETLKW, &fl);
 351                                 } else {
 352                                         ftruncate( fd, 0 );
 353                                 }
 354                         }
 355                 }
 356 #endif
 357                 va_start(arguments, fmt);
 358                 vdprintf(fd, fmt, arguments);
 359                 va_end(arguments);
 360                 fl.l_type = F_UNLCK;
 361                 fcntl(fd, F_SETLKW, &fl);
 362                 close(fd);
 363         } else {
 364                 /* Always send console messages to /dev/console so people will see them. */
 365                 if ((fd = device_open(_PATH_CONSOLE,
 366                                                  O_WRONLY | O_NOCTTY | O_NONBLOCK)) >= 0) {
 367                         va_start(arguments, fmt);
 368                         vdprintf(fd, fmt, arguments);
 369                         va_end(arguments);
 370                         close(fd);
 371                 } else {
 372                         fprintf(stderr, "Bummer, can't print: ");
 373                         va_start(arguments, fmt);
 374                         vfprintf(stderr, fmt, arguments);
 375                         fflush(stderr);
 376                         va_end(arguments);
 377                 }
 378         }
 379 }
 380
 381 #ifdef CONFIG_FEATURE_REMOTE_LOG
 382 static void init_RemoteLog(void)
 383 {
 384         memset(&remoteaddr, 0, sizeof(remoteaddr));
 385         remotefd = socket(AF_INET, SOCK_DGRAM, 0);
 386
 387         if (remotefd < 0) {
 388                 bb_error_msg("cannot create socket");
 389         }
 390
 391         remoteaddr.sin_family = AF_INET;
 392         remoteaddr.sin_addr = *(struct in_addr *) *(xgethostbyname(RemoteHost))->h_addr_list;
 393         remoteaddr.sin_port = htons(RemotePort);
 394 }
 395 #endif
 396
 397 static void logMessage(int pri, char *msg)
 398 {
 399         time_t now;
 400         char *timestamp;
 401         static char res[20];
 402 #ifdef CONFIG_FEATURE_REMOTE_LOG
 403         static char line[MAXLINE + 1];
 404 #endif
 405         CODE *c_pri, *c_fac;
 406
 407         if (pri != 0) {
 408                 for (c_fac = facilitynames;
 409                          c_fac->c_name && !(c_fac->c_val == LOG_FAC(pri) << 3); c_fac++);
 410                 for (c_pri = prioritynames;
 411                          c_pri->c_name && !(c_pri->c_val == LOG_PRI(pri)); c_pri++);
 412                 if (c_fac->c_name == NULL || c_pri->c_name == NULL) {
 413                         snprintf(res, sizeof(res), "<%d>", pri);
 414                 } else {
 415                         snprintf(res, sizeof(res), "%s.%s", c_fac->c_name, c_pri->c_name);
 416                 }
 417         }
 418
 419         if (strlen(msg) < 16 || msg[3] != ' ' || msg[6] != ' ' ||
 420                 msg[9] != ':' || msg[12] != ':' || msg[15] != ' ') {
 421                 time(&now);
 422                 timestamp = ctime(&now) + 4;
 423                 timestamp[15] = '\0';
 424         } else {
 425                 timestamp = msg;
 426                 timestamp[15] = '\0';
 427                 msg += 16;
 428         }
 429
 430         /* todo: supress duplicates */
 431
 432 #ifdef CONFIG_FEATURE_REMOTE_LOG
 433         if (doRemoteLog == TRUE) {
 434                 /* trying connect the socket */
 435                 if (-1 == remotefd) {
 436                         init_RemoteLog();
 437                 }
 438
 439                 /* if we have a valid socket, send the message */
 440                 if (-1 != remotefd) {
 441                         now = 1;
 442                         snprintf(line, sizeof(line), "<%d>%s", pri, msg);
 443
 444                 retry:
 445                         /* send message to remote logger */
 446                         if(( -1 == sendto(remotefd, line, strlen(line), 0,
 447                                                         (struct sockaddr *) &remoteaddr,
 448                                                         sizeof(remoteaddr))) && (errno == EINTR)) {
 449                                 /* sleep now seconds and retry (with now * 2) */
 450                                 sleep(now);
 451                                 now *= 2;
 452                                 goto retry;
 453                         }
 454                 }
 455         }
 456
 457         if (local_logging == TRUE)
 458 #endif
 459         {
 460                 /* now spew out the message to wherever it is supposed to go */
 461                 if (small)
 462                         message("%s %s\n", timestamp, msg);
 463                 else
 464                         message("%s %s %s %s\n", timestamp, LocalHostName, res, msg);
 465         }
 466 }
 467
 468 static void quit_signal(int sig)
 469 {
 470         logMessage(LOG_SYSLOG | LOG_INFO, "System log daemon exiting.");
 471         unlink(lfile);
 472 #ifdef CONFIG_FEATURE_IPC_SYSLOG
 473         ipcsyslog_cleanup();
 474 #endif
 475
 476         exit(TRUE);
 477 }
 478
 479 static void domark(int sig)
 480 {
 481         if (MarkInterval > 0) {
 482                 logMessage(LOG_SYSLOG | LOG_INFO, "-- MARK --");
 483                 alarm(MarkInterval);
 484         }
 485 }
 486
 487 /* This must be a #define, since when CONFIG_DEBUG and BUFFERS_GO_IN_BSS are
 488  * enabled, we otherwise get a "storage size isn't constant error. */
 489 static int serveConnection(char *tmpbuf, int n_read)
 490 {
 491         char *p = tmpbuf;
 492
 493         while (p < tmpbuf + n_read) {
 494
 495                 int pri = (LOG_USER | LOG_NOTICE);
 496                 int num_lt = 0;
 497                 char line[MAXLINE + 1];
 498                 unsigned char c;
 499                 char *q = line;
 500
 501                 while ((c = *p) && q < &line[sizeof(line) - 1]) {
 502                         if (c == '<' && num_lt == 0) {
 503                                 /* Parse the magic priority number. */
 504                                 num_lt++;
 505                                 pri = 0;
 506                                 while (isdigit(*(++p))) {
 507                                         pri = 10 * pri + (*p - '0');
 508                                 }
 509                                 if (pri & ~(LOG_FACMASK | LOG_PRIMASK)) {
 510                                         pri = (LOG_USER | LOG_NOTICE);
 511                                 }
 512                         } else if (c == '\n') {
 513                                 *q++ = ' ';
 514                         } else if (iscntrl(c) && (c < 0177)) {
 515                                 *q++ = '^';
 516                                 *q++ = c ^ 0100;
 517                         } else {
 518                                 *q++ = c;
 519                         }
 520                         p++;
 521                 }
 522                 *q = '\0';
 523                 p++;
 524                 /* Now log it */
 525                 logMessage(pri, line);
 526         }
 527         return n_read;
 528 }
 529
 530 static void doSyslogd(void) __attribute__ ((noreturn));
 531 static void doSyslogd(void)
 532 {
 533         struct sockaddr_un sunx;
 534         socklen_t addrLength;
 535
 536         int sock_fd;
 537         fd_set fds;
 538
 539         /* Set up signal handlers. */
 540         signal(SIGINT, quit_signal);
 541         signal(SIGTERM, quit_signal);
 542         signal(SIGQUIT, quit_signal);
 543         signal(SIGHUP, SIG_IGN);
 544         signal(SIGCHLD, SIG_IGN);
 545 #ifdef SIGCLD
 546         signal(SIGCLD, SIG_IGN);
 547 #endif
 548         signal(SIGALRM, domark);
 549         alarm(MarkInterval);
 550
 551         /* Create the syslog file so realpath() can work. */
 552         if (realpath(_PATH_LOG, lfile) != NULL) {
 553                 unlink(lfile);
 554         }
 555
 556         memset(&sunx, 0, sizeof(sunx));
 557         sunx.sun_family = AF_UNIX;
 558         strncpy(sunx.sun_path, lfile, sizeof(sunx.sun_path));
 559         if ((sock_fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
 560                 bb_perror_msg_and_die("Couldn't get file descriptor for socket "
 561                                                    _PATH_LOG);
 562         }
 563
 564         addrLength = sizeof(sunx.sun_family) + strlen(sunx.sun_path);
 565         if (bind(sock_fd, (struct sockaddr *) &sunx, addrLength) < 0) {
 566                 bb_perror_msg_and_die("Could not connect to socket " _PATH_LOG);
 567         }
 568
 569         if (chmod(lfile, 0666) < 0) {
 570                 bb_perror_msg_and_die("Could not set permission on " _PATH_LOG);
 571         }
 572 #ifdef CONFIG_FEATURE_IPC_SYSLOG
 573         if (circular_logging == TRUE) {
 574                 ipcsyslog_init();
 575         }
 576 #endif
 577
 578 #ifdef CONFIG_FEATURE_REMOTE_LOG
 579         if (doRemoteLog == TRUE) {
 580                 init_RemoteLog();
 581         }
 582 #endif
 583
 584         logMessage(LOG_SYSLOG | LOG_INFO, "syslogd started: " BB_BANNER);
 585
 586         for (;;) {
 587
 588                 FD_ZERO(&fds);
 589                 FD_SET(sock_fd, &fds);
 590
 591                 if (select(sock_fd + 1, &fds, NULL, NULL, NULL) < 0) {
 592                         if (errno == EINTR) {
 593                                 /* alarm may have happened. */
 594                                 continue;
 595                         }
 596                         bb_perror_msg_and_die("select error");
 597                 }
 598
 599                 if (FD_ISSET(sock_fd, &fds)) {
 600                         int i;
 601 #if MAXLINE > BUFSIZ
 602 # define TMP_BUF_SZ BUFSIZ
 603 #else
 604 # define TMP_BUF_SZ MAXLINE
 605 #endif
 606 #define tmpbuf bb_common_bufsiz1
 607
 608                         if ((i = recv(sock_fd, tmpbuf, TMP_BUF_SZ, 0)) > 0) {
 609                                 tmpbuf[i] = '\0';
 610                                 serveConnection(tmpbuf, i);
 611                         } else {
 612                                 bb_perror_msg_and_die("UNIX socket error");
 613                         }
 614                 }                               /* FD_ISSET() */
 615         }                                       /* for main loop */
 616 }
 617
 618 extern int syslogd_main(int argc, char **argv)
 619 {
 620         int opt;
 621
 622         int doFork = TRUE;
 623
 624         char *p;
 625
 626         /* do normal option parsing */
 627         while ((opt = getopt(argc, argv, "m:nO:s:Sb:R:LC::")) > 0) {
 628                 switch (opt) {
 629                 case 'm':
 630                         MarkInterval = atoi(optarg) * 60;
 631                         break;
 632                 case 'n':
 633                         doFork = FALSE;
 634                         break;
 635                 case 'O':
 636                         logFilePath = optarg;
 637                         break;
 638 #ifdef CONFIG_FEATURE_ROTATE_LOGFILE
 639                 case 's':
 640                         logFileSize = atoi(optarg) * 1024;
 641                         break;
 642                 case 'b':
 643                         logFileRotate = atoi(optarg);
 644                         if( logFileRotate > 99 ) logFileRotate = 99;
 645                         break;
 646 #endif
 647 #ifdef CONFIG_FEATURE_REMOTE_LOG
 648                 case 'R':
 649                         RemoteHost = bb_xstrdup(optarg);
 650                         if ((p = strchr(RemoteHost, ':'))) {
 651                                 RemotePort = atoi(p + 1);
 652                                 *p = '\0';
 653                         }
 654                         doRemoteLog = TRUE;
 655                         break;
 656                 case 'L':
 657                         local_logging = TRUE;
 658                         break;
 659 #endif
 660 #ifdef CONFIG_FEATURE_IPC_SYSLOG
 661                 case 'C':
 662                         if (optarg) {
 663                                 int buf_size = atoi(optarg);
 664                                 if (buf_size >= 4) {
 665                                         shm_size = buf_size * 1024;
 666                                 }
 667                         }
 668                         circular_logging = TRUE;
 669                         break;
 670 #endif
 671                 case 'S':
 672                         small = true;
 673                         break;
 674                 default:
 675                         bb_show_usage();
 676                 }
 677         }
 678
 679 #ifdef CONFIG_FEATURE_REMOTE_LOG
 680         /* If they have not specified remote logging, then log locally */
 681         if (doRemoteLog == FALSE)
 682                 local_logging = TRUE;
 683 #endif
 684
 685
 686         /* Store away localhost's name before the fork */
 687         gethostname(LocalHostName, sizeof(LocalHostName));
 688         if ((p = strchr(LocalHostName, '.'))) {
 689                 *p = '\0';
 690         }
 691
 692         umask(0);
 693
 694         if (doFork == TRUE) {
 695 #if defined(__uClinux__)
 696                 vfork_daemon_rexec(0, 1, argc, argv, "-n");
 697 #else /* __uClinux__ */
 698                 if(daemon(0, 1) < 0)
 699                         bb_perror_msg_and_die("daemon");
 700 #endif /* __uClinux__ */
 701         }
 702         doSyslogd();
 703
 704         return EXIT_SUCCESS;
 705 }
 706
 707 /*
 708 Local Variables
 709 c-file-style: "linux"
 710 c-basic-offset: 4
 711 tab-width: 4
 712 End:
 713 */