blob: aecd35d588e050375e5be76ab3ef1debfd501815 [file] [log] [blame]
Erik Andersene49d5ec2000-02-08 19:58:47 +00001/* vi: set sw=4 ts=4: */
Eric Andersen3843e961999-11-25 07:30:46 +00002/*
3 * Mini syslogd implementation for busybox
4 *
Eric Andersenc7bda1c2004-03-15 08:29:22 +00005 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
Eric Andersen3843e961999-11-25 07:30:46 +00006 *
Erik Andersenf13df372000-04-18 23:51:51 +00007 * Copyright (C) 2000 by Karl M. Hegbloom <karlheg@debian.org>
8 *
Glenn L McGrath6ed77592002-12-12 10:54:48 +00009 * "circular buffer" Copyright (C) 2001 by Gennady Feldman <gfeldman@gena01.com>
Mark Whitley6317c4b2001-03-12 22:51:50 +000010 *
Glenn L McGrath6ed77592002-12-12 10:54:48 +000011 * Maintainer: Gennady Feldman <gfeldman@gena01.com> as of Mar 12, 2001
Mark Whitley6bff9cc2001-03-12 23:41:34 +000012 *
Eric Andersen3843e961999-11-25 07:30:46 +000013 * 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 */
Eric Andersenb99df0f1999-11-24 09:04:33 +000028
Eric Andersen67e32302000-06-19 17:48:02 +000029#include <stdio.h>
30#include <stdlib.h>
Eric Andersen3843e961999-11-25 07:30:46 +000031#include <ctype.h>
Eric Andersenb186d981999-12-03 09:19:54 +000032#include <errno.h>
Erik Andersen983b51b2000-04-04 18:14:25 +000033#include <fcntl.h>
Glenn L McGrath5529b7b2004-07-22 04:23:18 +000034#include <getopt.h>
Erik Andersen983b51b2000-04-04 18:14:25 +000035#include <netdb.h>
Eric Andersenb186d981999-12-03 09:19:54 +000036#include <paths.h>
Erik Andersen983b51b2000-04-04 18:14:25 +000037#include <signal.h>
38#include <stdarg.h>
Eric Andersen7f94a5c2004-06-22 10:12:59 +000039#include <stdbool.h>
Eric Andersen67e32302000-06-19 17:48:02 +000040#include <time.h>
Eric Andersened3ef502001-01-27 08:24:39 +000041#include <string.h>
Eric Andersen67e32302000-06-19 17:48:02 +000042#include <unistd.h>
Erik Andersen983b51b2000-04-04 18:14:25 +000043#include <sys/socket.h>
Erik Andersen983b51b2000-04-04 18:14:25 +000044#include <sys/types.h>
45#include <sys/un.h>
Erik Andersen7d6ba572000-04-19 20:02:50 +000046#include <sys/param.h>
Eric Andersenb186d981999-12-03 09:19:54 +000047
Eric Andersencbe31da2001-02-20 06:14:08 +000048#include "busybox.h"
Eric Andersen67e32302000-06-19 17:48:02 +000049
Eric Andersen3843e961999-11-25 07:30:46 +000050/* SYSLOG_NAMES defined to pull some extra junk from syslog.h */
51#define SYSLOG_NAMES
52#include <sys/syslog.h>
Eric Andersenced2cef2000-07-20 23:41:24 +000053#include <sys/uio.h>
Eric Andersen3843e961999-11-25 07:30:46 +000054
55/* Path for the file where all log messages are written */
Erik Andersen983b51b2000-04-04 18:14:25 +000056#define __LOG_FILE "/var/log/messages"
Eric Andersen3843e961999-11-25 07:30:46 +000057
Erik Andersen983b51b2000-04-04 18:14:25 +000058/* Path to the unix socket */
Eric Andersen871d93c2002-09-17 20:06:29 +000059static char lfile[MAXPATHLEN];
Eric Andersen3843e961999-11-25 07:30:46 +000060
Glenn L McGrathfe538ba2003-09-10 23:35:45 +000061static const char *logFilePath = __LOG_FILE;
Erik Andersene49d5ec2000-02-08 19:58:47 +000062
Eric Andersen29c77f72003-10-09 09:43:18 +000063#ifdef CONFIG_FEATURE_ROTATE_LOGFILE
Eric Andersenaff114c2004-04-14 17:51:38 +000064/* max size of message file before being rotated */
Eric Andersen29c77f72003-10-09 09:43:18 +000065static int logFileSize = 200 * 1024;
66
67/* number of rotated message files */
68static int logFileRotate = 1;
69#endif
70
Eric Andersen3843e961999-11-25 07:30:46 +000071/* interval between marks in seconds */
Erik Andersene49d5ec2000-02-08 19:58:47 +000072static int MarkInterval = 20 * 60;
73
Eric Andersen3843e961999-11-25 07:30:46 +000074/* localhost's name */
Eric Andersen871d93c2002-09-17 20:06:29 +000075static char LocalHostName[64];
Eric Andersen3843e961999-11-25 07:30:46 +000076
Eric Andersenbdfd0d72001-10-24 05:00:29 +000077#ifdef CONFIG_FEATURE_REMOTE_LOG
Eric Andersenced2cef2000-07-20 23:41:24 +000078#include <netinet/in.h>
79/* udp socket for logging to remote host */
Eric Andersenbf2b8ae2000-12-08 19:52:01 +000080static int remotefd = -1;
Eric Andersen75813ee2004-08-26 23:15:29 +000081static struct sockaddr_in remoteaddr;
Glenn L McGrath912d8f42002-11-10 22:46:45 +000082
Eric Andersenced2cef2000-07-20 23:41:24 +000083/* where do we log? */
84static char *RemoteHost;
Glenn L McGrath912d8f42002-11-10 22:46:45 +000085
Eric Andersenced2cef2000-07-20 23:41:24 +000086/* what port to log to? */
Eric Andersenbf2b8ae2000-12-08 19:52:01 +000087static int RemotePort = 514;
Glenn L McGrath912d8f42002-11-10 22:46:45 +000088
Eric Andersenced2cef2000-07-20 23:41:24 +000089/* To remote log or not to remote log, that is the question. */
Eric Andersenbf2b8ae2000-12-08 19:52:01 +000090static int doRemoteLog = FALSE;
Eric Andersen70d09ed2000-12-11 16:24:16 +000091static int local_logging = FALSE;
Eric Andersenced2cef2000-07-20 23:41:24 +000092#endif
93
Eric Andersen7f94a5c2004-06-22 10:12:59 +000094/* Make loging output smaller. */
95static bool small = false;
96
Eric Andersen871d93c2002-09-17 20:06:29 +000097
Glenn L McGrath912d8f42002-11-10 22:46:45 +000098#define MAXLINE 1024 /* maximum line length */
Eric Andersen871d93c2002-09-17 20:06:29 +000099
100
Mark Whitley6317c4b2001-03-12 22:51:50 +0000101/* circular buffer variables/structures */
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000102#ifdef CONFIG_FEATURE_IPC_SYSLOG
Eric Andersend4a5e252003-12-19 11:32:14 +0000103
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
Mark Whitley6317c4b2001-03-12 22:51:50 +0000109#include <sys/ipc.h>
110#include <sys/sem.h>
111#include <sys/shm.h>
112
113/* our shared key */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000114static const long KEY_ID = 0x414e4547; /*"GENA" */
Mark Whitley6317c4b2001-03-12 22:51:50 +0000115
116// Semaphore operation structures
117static struct shbuf_ds {
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000118 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
Mark Whitley6317c4b2001-03-12 22:51:50 +0000123
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000124static struct sembuf SMwup[1] = { {1, -1, IPC_NOWAIT} }; // set SMwup
125static struct sembuf SMwdn[3] = { {0, 0}, {1, 0}, {1, +1} }; // set SMwdn
Mark Whitley6317c4b2001-03-12 22:51:50 +0000126
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000127static int shmid = -1; // ipc shared memory id
128static int s_semid = -1; // ipc semaphore id
Eric Andersend4a5e252003-12-19 11:32:14 +0000129static int shm_size = ((CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE)*1024); // default shm size
Mark Whitley6317c4b2001-03-12 22:51:50 +0000130static int circular_logging = FALSE;
131
132/*
133 * sem_up - up()'s a semaphore.
134 */
135static inline void sem_up(int semid)
136{
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000137 if (semop(semid, SMwup, 1) == -1) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000138 bb_perror_msg_and_die("semop[SMwup]");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000139 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000140}
141
142/*
143 * sem_down - down()'s a semaphore
144 */
145static inline void sem_down(int semid)
146{
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000147 if (semop(semid, SMwdn, 3) == -1) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000148 bb_perror_msg_and_die("semop[SMwdn]");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000149 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000150}
151
Eric Andersen871d93c2002-09-17 20:06:29 +0000152
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000153void ipcsyslog_cleanup(void)
154{
Mark Whitley6317c4b2001-03-12 22:51:50 +0000155 printf("Exiting Syslogd!\n");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000156 if (shmid != -1) {
Mark Whitley6317c4b2001-03-12 22:51:50 +0000157 shmdt(buf);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000158 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000159
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000160 if (shmid != -1) {
Mark Whitley6317c4b2001-03-12 22:51:50 +0000161 shmctl(shmid, IPC_RMID, NULL);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000162 }
163 if (s_semid != -1) {
Mark Whitley6317c4b2001-03-12 22:51:50 +0000164 semctl(s_semid, 0, IPC_RMID, 0);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000165 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000166}
167
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000168void ipcsyslog_init(void)
169{
170 if (buf == NULL) {
Eric Andersend4a5e252003-12-19 11:32:14 +0000171 if ((shmid = shmget(KEY_ID, shm_size, IPC_CREAT | 1023)) == -1) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000172 bb_perror_msg_and_die("shmget");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000173 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000174
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000175 if ((buf = shmat(shmid, NULL, 0)) == NULL) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000176 bb_perror_msg_and_die("shmat");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000177 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000178
Eric Andersend4a5e252003-12-19 11:32:14 +0000179 buf->size = shm_size - sizeof(*buf);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000180 buf->head = buf->tail = 0;
Mark Whitley6317c4b2001-03-12 22:51:50 +0000181
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000182 // 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) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000186 bb_perror_msg_and_die("semget");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000187 }
188 } else {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000189 bb_perror_msg_and_die("semget");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000190 }
191 }
192 } else {
Mark Whitley6317c4b2001-03-12 22:51:50 +0000193 printf("Buffer already allocated just grab the semaphore?");
194 }
195}
196
197/* write message to buffer */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000198void circ_message(const char *msg)
199{
200 int l = strlen(msg) + 1; /* count the whole message w/ '\0' included */
Mark Whitley6317c4b2001-03-12 22:51:50 +0000201
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:
Eric Andersen871d93c2002-09-17 20:06:29 +0000216 * 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.
Mark Whitley6317c4b2001-03-12 22:51:50 +0000223 *
224 * Note: This algorithm uses Linux IPC mechanism w/ shared memory and semaphores to provide
Eric Andersen871d93c2002-09-17 20:06:29 +0000225 * a threasafe way of handling shared memory operations.
Mark Whitley6317c4b2001-03-12 22:51:50 +0000226 */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000227 if ((buf->tail + l) < buf->size) {
Mark Whitley6317c4b2001-03-12 22:51:50 +0000228 /* 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! */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000231 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 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000255 }
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000256 }
Mark Whitley6317c4b2001-03-12 22:51:50 +0000257
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000258 /* in other cases no overflows have been done yet, so we don't care! */
Mark Whitley6317c4b2001-03-12 22:51:50 +0000259 /* we should be ok to append the message now */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000260 strncpy(buf->data + buf->tail, msg, l); /* append our message */
261 buf->tail += l; /* count full message w/ '\0' terminating char */
262 } else {
Mark Whitley6317c4b2001-03-12 22:51:50 +0000263 /* we need to break up the message and "circle" it around */
264 char *c;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000265 int k = buf->tail + l - buf->size; /* count # of bytes we don't fit */
Eric Andersen871d93c2002-09-17 20:06:29 +0000266
Mark Whitley6317c4b2001-03-12 22:51:50 +0000267 /* We need to move HEAD! This is always the case since we are going
268 * to "circle" the message.
269 */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000270 c = memchr(buf->data + k, '\0', buf->size - k);
Eric Andersen871d93c2002-09-17 20:06:29 +0000271
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000272 if (c != NULL) { /* if we don't have '\0'??? weird!!! */
273 /* move head pointer */
274 buf->head = c - buf->data + 1;
Eric Andersen871d93c2002-09-17 20:06:29 +0000275
276 /* now write the first part of the message */
Mark Whitley6317c4b2001-03-12 22:51:50 +0000277 strncpy(buf->data + buf->tail, msg, l - k - 1);
Eric Andersen871d93c2002-09-17 20:06:29 +0000278
Mark Whitley6317c4b2001-03-12 22:51:50 +0000279 /* ALWAYS terminate end of buffer w/ '\0' */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000280 buf->data[buf->size - 1] = '\0';
Eric Andersen871d93c2002-09-17 20:06:29 +0000281
Mark Whitley6317c4b2001-03-12 22:51:50 +0000282 /* now write out the rest of the string to the beginning of the buffer */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000283 strcpy(buf->data, &msg[l - k - 1]);
Mark Whitley6317c4b2001-03-12 22:51:50 +0000284
285 /* we need to place the TAIL at the end of the message */
286 buf->tail = k + 1;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000287 } 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 */
Mark Whitley6317c4b2001-03-12 22:51:50 +0000291 }
Eric Andersen871d93c2002-09-17 20:06:29 +0000292
Mark Whitley6317c4b2001-03-12 22:51:50 +0000293 }
294 sem_up(s_semid);
295}
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000296#endif /* CONFIG_FEATURE_IPC_SYSLOG */
Eric Andersen871d93c2002-09-17 20:06:29 +0000297
Erik Andersenc053e412000-03-21 01:31:24 +0000298/* Note: There is also a function called "message()" in init.c */
Erik Andersen983b51b2000-04-04 18:14:25 +0000299/* Print a message to the log file. */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000300static void message(char *fmt, ...) __attribute__ ((format(printf, 1, 2)));
301static void message(char *fmt, ...)
Eric Andersen3843e961999-11-25 07:30:46 +0000302{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000303 int fd;
Erik Andersene3ed1562000-04-19 18:52:56 +0000304 struct flock fl;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000305 va_list arguments;
Eric Andersen3843e961999-11-25 07:30:46 +0000306
Erik Andersene3ed1562000-04-19 18:52:56 +0000307 fl.l_whence = SEEK_SET;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000308 fl.l_start = 0;
309 fl.l_len = 1;
Erik Andersene3ed1562000-04-19 18:52:56 +0000310
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000311#ifdef CONFIG_FEATURE_IPC_SYSLOG
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000312 if ((circular_logging == TRUE) && (buf != NULL)) {
313 char b[1024];
Mark Whitley6317c4b2001-03-12 22:51:50 +0000314
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000315 va_start(arguments, fmt);
316 vsnprintf(b, sizeof(b) - 1, fmt, arguments);
317 va_end(arguments);
318 circ_message(b);
319
320 } else
Mark Whitley6317c4b2001-03-12 22:51:50 +0000321#endif
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000322 if ((fd =
323 device_open(logFilePath,
324 O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND |
325 O_NONBLOCK)) >= 0) {
Erik Andersene3ed1562000-04-19 18:52:56 +0000326 fl.l_type = F_WRLCK;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000327 fcntl(fd, F_SETLKW, &fl);
Eric Andersen29c77f72003-10-09 09:43:18 +0000328#ifdef CONFIG_FEATURE_ROTATE_LOGFILE
329 if ( logFileSize > 0 ) {
330 struct stat statf;
331 int r = fstat(fd, &statf);
332 if( !r && (statf.st_mode & S_IFREG)
333 && (lseek(fd,0,SEEK_END) > logFileSize) ) {
334 if(logFileRotate > 0) {
335 int i;
336 char oldFile[(strlen(logFilePath)+3)], newFile[(strlen(logFilePath)+3)];
337 for(i=logFileRotate-1;i>0;i--) {
338 sprintf(oldFile, "%s.%d", logFilePath, i-1);
339 sprintf(newFile, "%s.%d", logFilePath, i);
340 rename(oldFile, newFile);
341 }
342 sprintf(newFile, "%s.%d", logFilePath, 0);
343 fl.l_type = F_UNLCK;
344 fcntl (fd, F_SETLKW, &fl);
345 close(fd);
346 rename(logFilePath, newFile);
347 fd = device_open (logFilePath,
348 O_WRONLY | O_CREAT | O_NOCTTY | O_APPEND |
349 O_NONBLOCK);
350 fl.l_type = F_WRLCK;
351 fcntl (fd, F_SETLKW, &fl);
352 } else {
353 ftruncate( fd, 0 );
354 }
355 }
356 }
357#endif
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000358 va_start(arguments, fmt);
359 vdprintf(fd, fmt, arguments);
360 va_end(arguments);
Erik Andersene3ed1562000-04-19 18:52:56 +0000361 fl.l_type = F_UNLCK;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000362 fcntl(fd, F_SETLKW, &fl);
363 close(fd);
Eric Andersen3843e961999-11-25 07:30:46 +0000364 } else {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000365 /* Always send console messages to /dev/console so people will see them. */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000366 if ((fd =
367 device_open(_PATH_CONSOLE,
368 O_WRONLY | O_NOCTTY | O_NONBLOCK)) >= 0) {
369 va_start(arguments, fmt);
370 vdprintf(fd, fmt, arguments);
371 va_end(arguments);
372 close(fd);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000373 } else {
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000374 fprintf(stderr, "Bummer, can't print: ");
375 va_start(arguments, fmt);
376 vfprintf(stderr, fmt, arguments);
377 fflush(stderr);
378 va_end(arguments);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000379 }
Eric Andersen3843e961999-11-25 07:30:46 +0000380 }
Eric Andersenb99df0f1999-11-24 09:04:33 +0000381}
382
Eric Andersenf91b9282004-09-08 10:56:06 +0000383#ifdef CONFIG_FEATURE_REMOTE_LOG
384static void init_RemoteLog(void)
385{
386 memset(&remoteaddr, 0, sizeof(remoteaddr));
387 remotefd = socket(AF_INET, SOCK_DGRAM, 0);
388
389 if (remotefd < 0) {
390 bb_error_msg("cannot create socket");
391 }
392
393 remoteaddr.sin_family = AF_INET;
394 remoteaddr.sin_addr = *(struct in_addr *) *(xgethostbyname(RemoteHost))->h_addr_list;
395 remoteaddr.sin_port = htons(RemotePort);
396}
397#endif
398
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000399static void logMessage(int pri, char *msg)
Eric Andersen3843e961999-11-25 07:30:46 +0000400{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000401 time_t now;
402 char *timestamp;
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000403 static char res[20] = "";
Eric Andersen192c35f2004-09-02 22:22:17 +0000404#ifdef CONFIG_FEATURE_REMOTE_LOG
Eric Andersenf91b9282004-09-08 10:56:06 +0000405 static char line[MAXLINE + 1];
Eric Andersen192c35f2004-09-02 22:22:17 +0000406#endif
Erik Andersene49d5ec2000-02-08 19:58:47 +0000407 CODE *c_pri, *c_fac;
Eric Andersenb99df0f1999-11-24 09:04:33 +0000408
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000409 if (pri != 0) {
410 for (c_fac = facilitynames;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000411 c_fac->c_name && !(c_fac->c_val == LOG_FAC(pri) << 3); c_fac++);
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000412 for (c_pri = prioritynames;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000413 c_pri->c_name && !(c_pri->c_val == LOG_PRI(pri)); c_pri++);
414 if (c_fac->c_name == NULL || c_pri->c_name == NULL) {
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000415 snprintf(res, sizeof(res), "<%d>", pri);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000416 } else {
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000417 snprintf(res, sizeof(res), "%s.%s", c_fac->c_name, c_pri->c_name);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000418 }
Erik Andersen9ffdaa62000-02-11 21:55:04 +0000419 }
Eric Andersen3843e961999-11-25 07:30:46 +0000420
Erik Andersene49d5ec2000-02-08 19:58:47 +0000421 if (strlen(msg) < 16 || msg[3] != ' ' || msg[6] != ' ' ||
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000422 msg[9] != ':' || msg[12] != ':' || msg[15] != ' ') {
Erik Andersene49d5ec2000-02-08 19:58:47 +0000423 time(&now);
424 timestamp = ctime(&now) + 4;
425 timestamp[15] = '\0';
426 } else {
427 timestamp = msg;
428 timestamp[15] = '\0';
429 msg += 16;
430 }
Eric Andersen3843e961999-11-25 07:30:46 +0000431
Erik Andersene49d5ec2000-02-08 19:58:47 +0000432 /* todo: supress duplicates */
Eric Andersen3843e961999-11-25 07:30:46 +0000433
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000434#ifdef CONFIG_FEATURE_REMOTE_LOG
Glenn L McGrath73ebb882004-09-14 18:12:13 +0000435 if (doRemoteLog == TRUE) {
436 /* trying connect the socket */
437 if (-1 == remotefd) {
438 init_RemoteLog();
439 }
Eric Andersenced2cef2000-07-20 23:41:24 +0000440
Glenn L McGrath73ebb882004-09-14 18:12:13 +0000441 /* if we have a valid socket, send the message */
442 if (-1 != remotefd) {
443 now = 1;
Paul Fox27cbffd2005-07-20 18:02:11 +0000444 snprintf(line, sizeof(line), "<%d>%s", pri, msg);
Eric Andersenced2cef2000-07-20 23:41:24 +0000445
Glenn L McGrath73ebb882004-09-14 18:12:13 +0000446 retry:
447 /* send message to remote logger */
448 if(( -1 == sendto(remotefd, line, strlen(line), 0,
449 (struct sockaddr *) &remoteaddr,
450 sizeof(remoteaddr))) && (errno == EINTR)) {
451 /* sleep now seconds and retry (with now * 2) */
452 sleep(now);
453 now *= 2;
454 goto retry;
455 }
Eric Andersenbf2b8ae2000-12-08 19:52:01 +0000456 }
457 }
Glenn L McGrath73ebb882004-09-14 18:12:13 +0000458
Eric Andersen871d93c2002-09-17 20:06:29 +0000459 if (local_logging == TRUE)
Eric Andersenced2cef2000-07-20 23:41:24 +0000460#endif
Eric Andersen7f94a5c2004-06-22 10:12:59 +0000461 {
Eric Andersenbf2b8ae2000-12-08 19:52:01 +0000462 /* now spew out the message to wherever it is supposed to go */
Eric Andersen7f94a5c2004-06-22 10:12:59 +0000463 if (small)
464 message("%s %s\n", timestamp, msg);
465 else
466 message("%s %s %s %s\n", timestamp, LocalHostName, res, msg);
467 }
Eric Andersen3843e961999-11-25 07:30:46 +0000468}
469
470static void quit_signal(int sig)
471{
Eric Andersen238bc402001-05-07 17:55:05 +0000472 logMessage(LOG_SYSLOG | LOG_INFO, "System log daemon exiting.");
Erik Andersen983b51b2000-04-04 18:14:25 +0000473 unlink(lfile);
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000474#ifdef CONFIG_FEATURE_IPC_SYSLOG
Mark Whitley6317c4b2001-03-12 22:51:50 +0000475 ipcsyslog_cleanup();
476#endif
477
Erik Andersene49d5ec2000-02-08 19:58:47 +0000478 exit(TRUE);
Eric Andersen3843e961999-11-25 07:30:46 +0000479}
480
Eric Andersen3843e961999-11-25 07:30:46 +0000481static void domark(int sig)
482{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000483 if (MarkInterval > 0) {
484 logMessage(LOG_SYSLOG | LOG_INFO, "-- MARK --");
485 alarm(MarkInterval);
486 }
Eric Andersen3843e961999-11-25 07:30:46 +0000487}
488
Eric Andersene5272072003-07-22 22:15:21 +0000489/* This must be a #define, since when CONFIG_DEBUG and BUFFERS_GO_IN_BSS are
Eric Andersen22ecf042001-07-02 17:32:40 +0000490 * enabled, we otherwise get a "storage size isn't constant error. */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000491static int serveConnection(char *tmpbuf, int n_read)
Pavel Roskinda10ec02000-06-07 21:08:25 +0000492{
Matt Kraaib6ec7812001-08-14 17:32:23 +0000493 char *p = tmpbuf;
Pavel Roskinda10ec02000-06-07 21:08:25 +0000494
Matt Kraaib6ec7812001-08-14 17:32:23 +0000495 while (p < tmpbuf + n_read) {
Pavel Roskinda10ec02000-06-07 21:08:25 +0000496
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000497 int pri = (LOG_USER | LOG_NOTICE);
Eric Andersend4f90ed2003-05-23 09:28:01 +0000498 int num_lt = 0;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000499 char line[MAXLINE + 1];
Pavel Roskinda10ec02000-06-07 21:08:25 +0000500 unsigned char c;
Matt Kraaib6ec7812001-08-14 17:32:23 +0000501 char *q = line;
Pavel Roskinda10ec02000-06-07 21:08:25 +0000502
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000503 while ((c = *p) && q < &line[sizeof(line) - 1]) {
Eric Andersend4f90ed2003-05-23 09:28:01 +0000504 if (c == '<' && num_lt == 0) {
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000505 /* Parse the magic priority number. */
Eric Andersend4f90ed2003-05-23 09:28:01 +0000506 num_lt++;
Pavel Roskinda10ec02000-06-07 21:08:25 +0000507 pri = 0;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000508 while (isdigit(*(++p))) {
Pavel Roskinda10ec02000-06-07 21:08:25 +0000509 pri = 10 * pri + (*p - '0');
510 }
Eric Andersen46ba5682003-05-23 09:29:57 +0000511 if (pri & ~(LOG_FACMASK | LOG_PRIMASK)) {
Eric Andersend4f90ed2003-05-23 09:28:01 +0000512 pri = (LOG_USER | LOG_NOTICE);
Eric Andersen46ba5682003-05-23 09:29:57 +0000513 }
Pavel Roskinda10ec02000-06-07 21:08:25 +0000514 } else if (c == '\n') {
515 *q++ = ' ';
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000516 } else if (iscntrl(c) && (c < 0177)) {
Pavel Roskinda10ec02000-06-07 21:08:25 +0000517 *q++ = '^';
518 *q++ = c ^ 0100;
519 } else {
520 *q++ = c;
521 }
522 p++;
523 }
524 *q = '\0';
Matt Kraaib6ec7812001-08-14 17:32:23 +0000525 p++;
Pavel Roskinda10ec02000-06-07 21:08:25 +0000526 /* Now log it */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000527 logMessage(pri, line);
Pavel Roskinda10ec02000-06-07 21:08:25 +0000528 }
Mark Whitleybff6b182001-03-27 20:17:58 +0000529 return n_read;
Pavel Roskinda10ec02000-06-07 21:08:25 +0000530}
531
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000532static void doSyslogd(void) __attribute__ ((noreturn));
533static void doSyslogd(void)
Eric Andersen3843e961999-11-25 07:30:46 +0000534{
Erik Andersene49d5ec2000-02-08 19:58:47 +0000535 struct sockaddr_un sunx;
Erik Andersen1d1d9502000-04-21 01:26:49 +0000536 socklen_t addrLength;
537
Erik Andersen983b51b2000-04-04 18:14:25 +0000538 int sock_fd;
Erik Andersenf13df372000-04-18 23:51:51 +0000539 fd_set fds;
540
Erik Andersenf13df372000-04-18 23:51:51 +0000541 /* Set up signal handlers. */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000542 signal(SIGINT, quit_signal);
543 signal(SIGTERM, quit_signal);
544 signal(SIGQUIT, quit_signal);
545 signal(SIGHUP, SIG_IGN);
546 signal(SIGCHLD, SIG_IGN);
Pavel Roskind39d1202000-09-13 14:14:29 +0000547#ifdef SIGCLD
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000548 signal(SIGCLD, SIG_IGN);
Pavel Roskind39d1202000-09-13 14:14:29 +0000549#endif
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000550 signal(SIGALRM, domark);
551 alarm(MarkInterval);
Eric Andersenb99df0f1999-11-24 09:04:33 +0000552
Erik Andersenf13df372000-04-18 23:51:51 +0000553 /* Create the syslog file so realpath() can work. */
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000554 if (realpath(_PATH_LOG, lfile) != NULL) {
555 unlink(lfile);
556 }
Erik Andersen983b51b2000-04-04 18:14:25 +0000557
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000558 memset(&sunx, 0, sizeof(sunx));
Erik Andersen983b51b2000-04-04 18:14:25 +0000559 sunx.sun_family = AF_UNIX;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000560 strncpy(sunx.sun_path, lfile, sizeof(sunx.sun_path));
561 if ((sock_fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000562 bb_perror_msg_and_die("Couldn't get file descriptor for socket "
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000563 _PATH_LOG);
564 }
Eric Andersenb99df0f1999-11-24 09:04:33 +0000565
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000566 addrLength = sizeof(sunx.sun_family) + strlen(sunx.sun_path);
567 if (bind(sock_fd, (struct sockaddr *) &sunx, addrLength) < 0) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000568 bb_perror_msg_and_die("Could not connect to socket " _PATH_LOG);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000569 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000570
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000571 if (chmod(lfile, 0666) < 0) {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000572 bb_perror_msg_and_die("Could not set permission on " _PATH_LOG);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000573 }
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000574#ifdef CONFIG_FEATURE_IPC_SYSLOG
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000575 if (circular_logging == TRUE) {
576 ipcsyslog_init();
Eric Andersenea906502001-04-05 20:55:17 +0000577 }
578#endif
579
Eric Andersen871d93c2002-09-17 20:06:29 +0000580#ifdef CONFIG_FEATURE_REMOTE_LOG
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000581 if (doRemoteLog == TRUE) {
582 init_RemoteLog();
Eric Andersen871d93c2002-09-17 20:06:29 +0000583 }
584#endif
Eric Andersenced2cef2000-07-20 23:41:24 +0000585
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000586 logMessage(LOG_SYSLOG | LOG_INFO, "syslogd started: " BB_BANNER);
Erik Andersene49d5ec2000-02-08 19:58:47 +0000587
Erik Andersen983b51b2000-04-04 18:14:25 +0000588 for (;;) {
Erik Andersenf13df372000-04-18 23:51:51 +0000589
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000590 FD_ZERO(&fds);
591 FD_SET(sock_fd, &fds);
Erik Andersenf13df372000-04-18 23:51:51 +0000592
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000593 if (select(sock_fd + 1, &fds, NULL, NULL, NULL) < 0) {
Eric Andersen871d93c2002-09-17 20:06:29 +0000594 if (errno == EINTR) {
595 /* alarm may have happened. */
596 continue;
597 }
Manuel Novoa III cad53642003-03-19 09:13:01 +0000598 bb_perror_msg_and_die("select error");
Erik Andersene49d5ec2000-02-08 19:58:47 +0000599 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000600
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000601 if (FD_ISSET(sock_fd, &fds)) {
602 int i;
Erik Andersene3ed1562000-04-19 18:52:56 +0000603
Eric Andersen900c8f32003-05-16 08:35:02 +0000604 RESERVE_CONFIG_BUFFER(tmpbuf, MAXLINE + 1);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000605
Eric Andersen900c8f32003-05-16 08:35:02 +0000606 memset(tmpbuf, '\0', MAXLINE + 1);
607 if ((i = recv(sock_fd, tmpbuf, MAXLINE, 0)) > 0) {
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000608 serveConnection(tmpbuf, i);
609 } else {
Manuel Novoa III cad53642003-03-19 09:13:01 +0000610 bb_perror_msg_and_die("UNIX socket error");
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000611 }
612 RELEASE_CONFIG_BUFFER(tmpbuf);
613 } /* FD_ISSET() */
614 } /* for main loop */
Eric Andersenb99df0f1999-11-24 09:04:33 +0000615}
616
Eric Andersen3843e961999-11-25 07:30:46 +0000617extern int syslogd_main(int argc, char **argv)
618{
Eric Andersene5c24df2001-03-29 21:58:33 +0000619 int opt;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000620
Erik Andersene49d5ec2000-02-08 19:58:47 +0000621 int doFork = TRUE;
622
Erik Andersene49d5ec2000-02-08 19:58:47 +0000623 char *p;
Erik Andersene49d5ec2000-02-08 19:58:47 +0000624
Eric Andersen394cf222000-12-11 16:48:50 +0000625 /* do normal option parsing */
Glenn L McGrath5529b7b2004-07-22 04:23:18 +0000626 while ((opt = getopt(argc, argv, "m:nO:s:Sb:R:LC::")) > 0) {
Eric Andersen394cf222000-12-11 16:48:50 +0000627 switch (opt) {
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000628 case 'm':
629 MarkInterval = atoi(optarg) * 60;
630 break;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000631 case 'n':
632 doFork = FALSE;
633 break;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000634 case 'O':
Glenn L McGrathfe538ba2003-09-10 23:35:45 +0000635 logFilePath = optarg;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000636 break;
Eric Andersen29c77f72003-10-09 09:43:18 +0000637#ifdef CONFIG_FEATURE_ROTATE_LOGFILE
638 case 's':
639 logFileSize = atoi(optarg) * 1024;
640 break;
641 case 'b':
642 logFileRotate = atoi(optarg);
643 if( logFileRotate > 99 ) logFileRotate = 99;
644 break;
645#endif
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000646#ifdef CONFIG_FEATURE_REMOTE_LOG
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000647 case 'R':
Manuel Novoa III cad53642003-03-19 09:13:01 +0000648 RemoteHost = bb_xstrdup(optarg);
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000649 if ((p = strchr(RemoteHost, ':'))) {
650 RemotePort = atoi(p + 1);
651 *p = '\0';
652 }
653 doRemoteLog = TRUE;
654 break;
655 case 'L':
656 local_logging = TRUE;
657 break;
Eric Andersenced2cef2000-07-20 23:41:24 +0000658#endif
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000659#ifdef CONFIG_FEATURE_IPC_SYSLOG
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000660 case 'C':
Glenn L McGratha79220d2003-09-26 00:49:05 +0000661 if (optarg) {
662 int buf_size = atoi(optarg);
663 if (buf_size >= 4) {
Glenn L McGrathdf2c5652004-02-22 12:17:33 +0000664 shm_size = buf_size * 1024;
Glenn L McGratha79220d2003-09-26 00:49:05 +0000665 }
666 }
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000667 circular_logging = TRUE;
668 break;
Mark Whitley6317c4b2001-03-12 22:51:50 +0000669#endif
Eric Andersen7f94a5c2004-06-22 10:12:59 +0000670 case 'S':
671 small = true;
672 break;
Glenn L McGrath912d8f42002-11-10 22:46:45 +0000673 default:
Manuel Novoa III cad53642003-03-19 09:13:01 +0000674 bb_show_usage();
Eric Andersen3843e961999-11-25 07:30:46 +0000675 }
Erik Andersene49d5ec2000-02-08 19:58:47 +0000676 }
677
Eric Andersenbdfd0d72001-10-24 05:00:29 +0000678#ifdef CONFIG_FEATURE_REMOTE_LOG
Eric Andersen4ed17822000-12-11 19:28:29 +0000679 /* If they have not specified remote logging, then log locally */
Eric Andersen871d93c2002-09-17 20:06:29 +0000680 if (doRemoteLog == FALSE)
Eric Andersen4ed17822000-12-11 19:28:29 +0000681 local_logging = TRUE;
682#endif
683
Mark Whitley6317c4b2001-03-12 22:51:50 +0000684
Erik Andersene49d5ec2000-02-08 19:58:47 +0000685 /* Store away localhost's name before the fork */
686 gethostname(LocalHostName, sizeof(LocalHostName));
687 if ((p = strchr(LocalHostName, '.'))) {
Glenn L McGrathfe538ba2003-09-10 23:35:45 +0000688 *p = '\0';
Erik Andersene49d5ec2000-02-08 19:58:47 +0000689 }
690
Erik Andersen983b51b2000-04-04 18:14:25 +0000691 umask(0);
692
Glenn L McGrathfe538ba2003-09-10 23:35:45 +0000693 if (doFork == TRUE) {
Glenn L McGrathdc72f3a2003-08-29 07:35:08 +0000694#if defined(__uClinux__)
Russ Dilla1fece22003-12-15 21:57:44 +0000695 vfork_daemon_rexec(0, 1, argc, argv, "-n");
696#else /* __uClinux__ */
697 if(daemon(0, 1) < 0)
698 bb_perror_msg_and_die("daemon");
699#endif /* __uClinux__ */
Eric Andersen35e643b2003-07-28 07:40:39 +0000700 }
Eric Andersene5c24df2001-03-29 21:58:33 +0000701 doSyslogd();
Eric Andersenb186d981999-12-03 09:19:54 +0000702
Matt Kraai3e856ce2000-12-01 02:55:13 +0000703 return EXIT_SUCCESS;
Eric Andersen3843e961999-11-25 07:30:46 +0000704}
Erik Andersen983b51b2000-04-04 18:14:25 +0000705
706/*
Erik Andersene3ed1562000-04-19 18:52:56 +0000707Local Variables
708c-file-style: "linux"
709c-basic-offset: 4
710tab-width: 4
711End:
712*/