syslogd by Madhur Verma.
diff --git a/toys/pending/syslogd.c b/toys/pending/syslogd.c
new file mode 100644
index 0000000..5ac96c6
--- /dev/null
+++ b/toys/pending/syslogd.c
@@ -0,0 +1,770 @@
+/* syslogd.c - a system logging utility.
+ *
+ * Copyright 2013 Madhur Verma <mad.flexi@gmail.com>
+ *
+ * No Standard
+
+USE_SYSLOGD(NEWTOY(syslogd,">0l#<1>8=8R:b#<0>99=1s#<0=200m#<0>71582787=20O:p:f:a:nSKLD", TOYFLAG_SBIN|TOYFLAG_STAYROOT))
+
+config SYSLOGD
+ bool "syslogd"
+ default n
+ help
+ Usage: syslogd [-a socket] [-p socket] [-O logfile] [-f config file] [-m interval]
+ [-p socket] [-s SIZE] [-b N] [-R HOST] [-l N] [-nSLKD]
+
+ System logging utility
+
+ -a Extra unix socket for listen
+ -O FILE Default log file <DEFAULT: /var/log/messages>
+ -f FILE Config file <DEFAULT: /etc/syslog.conf>
+ -p Alternative unix domain socket <DEFAULT : /dev/log>
+ -n Avoid auto-backgrounding.
+ -S Smaller output
+ -m MARK interval <DEFAULT: 20 minutes> (RANGE: 0 to 71582787)
+ -R HOST Log to IP or hostname on PORT (default PORT=514/UDP)"
+ -L Log locally and via network (default is network only if -R)"
+ -s SIZE Max size (KB) before rotation (default:200KB, 0=off)
+ -b N rotated logs to keep (default:1, max=99, 0=purge)
+ -K Log to kernel printk buffer (use dmesg to read it)
+ -l N Log only messages more urgent than prio(default:8 max:8 min:1)
+ -D Drop duplicates
+*/
+
+#define FOR_syslogd
+#include "toys.h"
+#include "toynet.h"
+
+GLOBALS(
+ char *socket;
+ char *config_file;
+ char *unix_socket;
+ char *logfile;
+ long interval;
+ long rot_size;
+ long rot_count;
+ char *remote_log;
+ long log_prio;
+
+ struct arg_list *lsocks; // list of listen sockets
+ struct arg_list *lfiles; // list of write logfiles
+ fd_set rfds; // fds for reading
+ int sd; // socket for logging remote messeges.
+)
+
+#define flag_get(f,v,d) ((toys.optflags & f) ? v : d)
+#define flag_chk(f) ((toys.optflags & f) ? 1 : 0)
+
+#ifndef SYSLOG_NAMES
+#define INTERNAL_NOPRI 0x10
+#define INTERNAL_MARK LOG_MAKEPRI(LOG_NFACILITIES, 0)
+
+typedef struct _code {
+ char *c_name;
+ int c_val;
+} CODE;
+
+static CODE prioritynames[] =
+{
+ { "alert", LOG_ALERT },
+ { "crit", LOG_CRIT },
+ { "debug", LOG_DEBUG },
+ { "emerg", LOG_EMERG },
+ { "err", LOG_ERR },
+ { "error", LOG_ERR }, /* DEPRECATED */
+ { "info", LOG_INFO },
+ { "none", INTERNAL_NOPRI }, /* INTERNAL */
+ { "notice", LOG_NOTICE },
+ { "panic", LOG_EMERG }, /* DEPRECATED */
+ { "warn", LOG_WARNING }, /* DEPRECATED */
+ { "warning", LOG_WARNING },
+ { NULL, -1 }
+};
+
+static CODE facilitynames[] =
+{
+ { "auth", LOG_AUTH },
+ { "authpriv", LOG_AUTHPRIV },
+ { "cron", LOG_CRON },
+ { "daemon", LOG_DAEMON },
+ { "ftp", LOG_FTP },
+ { "kern", LOG_KERN },
+ { "lpr", LOG_LPR },
+ { "mail", LOG_MAIL },
+ { "mark", INTERNAL_MARK }, /* INTERNAL */
+ { "news", LOG_NEWS },
+ { "security", LOG_AUTH }, /* DEPRECATED */
+ { "syslog", LOG_SYSLOG },
+ { "user", LOG_USER },
+ { "uucp", LOG_UUCP },
+ { "local0", LOG_LOCAL0 },
+ { "local1", LOG_LOCAL1 },
+ { "local2", LOG_LOCAL2 },
+ { "local3", LOG_LOCAL3 },
+ { "local4", LOG_LOCAL4 },
+ { "local5", LOG_LOCAL5 },
+ { "local6", LOG_LOCAL6 },
+ { "local7", LOG_LOCAL7 },
+ { NULL, -1 }
+};
+#endif
+
+
+// Signal handling
+struct fd_pair { int rd; int wr; };
+static struct fd_pair sigfd;
+
+// UNIX Sockets for listening
+typedef struct unsocks_s {
+ char *path;
+ struct sockaddr_un sdu;
+ int sd;
+} unsocks_t;
+
+// Log file entry to log into.
+typedef struct logfile_s {
+ char *filename;
+ char *config;
+ uint8_t isNetwork;
+ uint32_t facility[8];
+ uint8_t level[LOG_NFACILITIES];
+ int logfd;
+ struct sockaddr_in saddr;
+} logfile_t;
+
+// Adds opened socks to rfds for select()
+static int addrfds(void)
+{
+ unsocks_t *sock;
+ int ret = 0;
+ struct arg_list *node = TT.lsocks;
+ FD_ZERO(&TT.rfds);
+
+ while (node) {
+ sock = (unsocks_t*) node->arg;
+ if (sock->sd > 2) {
+ FD_SET(sock->sd, &TT.rfds);
+ ret = sock->sd;
+ }
+ node = node->next;
+ }
+ FD_SET(sigfd.rd, &TT.rfds);
+ return (sigfd.rd > ret)?sigfd.rd:ret;
+}
+
+/*
+ * initializes unsock_t structure
+ * and opens socket for reading
+ * and adds to global lsock list.
+ */
+static int open_unix_socks(void)
+{
+ struct arg_list *node;
+ unsocks_t *sock;
+ int ret = 0;
+
+ for(node = TT.lsocks; node; node = node->next) {
+ sock = (unsocks_t*) node->arg;
+ sock->sdu.sun_family = AF_UNIX;
+ strcpy(sock->sdu.sun_path, sock->path);
+ sock->sd = socket(AF_UNIX, SOCK_DGRAM, 0);
+ if (sock->sd < 0) {
+ perror_msg("OPEN SOCKS : failed");
+ continue;
+ }
+ unlink(sock->sdu.sun_path);
+ if (bind(sock->sd, (struct sockaddr *) &sock->sdu, sizeof(sock->sdu))) {
+ perror_msg("BIND SOCKS : failed sock : %s", sock->sdu.sun_path);
+ close(sock->sd);
+ continue;
+ }
+ chmod(sock->path, 0777);
+ ret++;
+ }
+ return ret;
+}
+
+/*
+ * creates a socket of family INET and protocol UDP
+ * if successful then returns SOCK othrwise error
+ */
+static int open_udp_socks(char *host, int port, struct sockaddr_in *sadd)
+{
+ struct addrinfo *info, rp;
+
+ memset(&rp, 0, sizeof(rp));
+ rp.ai_family = AF_INET;
+ rp.ai_socktype = SOCK_DGRAM;
+ rp.ai_protocol = IPPROTO_UDP;
+
+ if (getaddrinfo(host, NULL, &rp, &info) || !info)
+ perror_exit("BAD ADDRESS: can't find : %s ", host);
+ ((struct sockaddr_in*)info->ai_addr)->sin_port = htons(port);
+ memcpy(sadd, info->ai_addr, info->ai_addrlen);
+ freeaddrinfo(info);
+
+ return xsocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+}
+
+// Returns node having filename
+static struct arg_list *get_file_node(char *filename, struct arg_list *list)
+{
+ while (list) {
+ if (!strcmp(((logfile_t*) list->arg)->filename, filename)) return list;
+ list = list->next;
+ }
+ return list;
+}
+
+/*
+ * recurses the logfile list and resolves config
+ * for evry file and updates facilty and log level bits.
+ */
+static int resolve_config(logfile_t *file)
+{
+ char *tk, *fac, *lvl, *tmp, *nfac;
+ int count = 0;
+ unsigned facval = 0;
+ uint8_t set, levval, neg;
+ CODE *val = NULL;
+
+ tmp = xstrdup(file->config);
+ for (tk = strtok(tmp, "; \0"); tk; tk = strtok(NULL, "; \0")) {
+ fac = tk;
+ tk = strchr(fac, '.');
+ if (!tk) return -1;
+ *tk = '\0';
+ lvl = tk + 1;
+
+ while(1) {
+ count = 0;
+ if (*fac == '*') {
+ facval = 0xFFFFFFFF;
+ fac++;
+ }
+ nfac = strchr(fac, ',');
+ if (nfac) *nfac = '\0';
+ while (*fac && ((CODE*) &facilitynames[count])->c_name) {
+ val = (CODE*) &facilitynames[count];
+ if (!strcmp(fac, val->c_name)) {
+ facval |= (1<<LOG_FAC(val->c_val));
+ break;
+ }
+ count++;
+ }
+ if (((CODE*) &facilitynames[count])->c_val == -1)
+ return -1;
+
+ if (nfac) fac = nfac+1;
+ else break;
+ }
+
+ count = 0;
+ set = 0;
+ levval = 0;
+ neg = 0;
+ if (*lvl == '!') {
+ neg = 1;
+ lvl++;
+ }
+ if (*lvl == '=') {
+ set = 1;
+ lvl++;
+ }
+ if (*lvl == '*') {
+ levval = 0xFF;
+ lvl++;
+ }
+ while (*lvl && ((CODE*) &prioritynames[count])->c_name) {
+ val = (CODE*) &prioritynames[count];
+ if (!strcmp(lvl, val->c_name)) {
+ levval |= set ? LOG_MASK(val->c_val):LOG_UPTO(val->c_val);
+ if (neg) levval = ~levval;
+ break;
+ }
+ count++;
+ }
+ if (((CODE*) &prioritynames[count])->c_val == -1) return -1;
+
+ count = 0;
+ set = levval;
+ while(set) {
+ if (set & 0x1) file->facility[count] |= facval;
+ set >>= 1;
+ count++;
+ }
+ for (count = 0; count < LOG_NFACILITIES; count++) {
+ if (facval & 0x1) file->level[count] |= levval;
+ facval >>= 1;
+ }
+ }
+ free(tmp);
+
+ return 0;
+}
+
+// Parse config file and update the log file list.
+static int parse_config_file(void)
+{
+ logfile_t *file;
+ FILE *fp = NULL;
+ char *confline = NULL, *tk = NULL, *tokens[2] = {NULL, NULL};
+ int len, linelen, tcount, lineno = 0;
+ struct arg_list *node;
+ /*
+ * if -K then open only /dev/kmsg
+ * all other log files are neglected
+ * thus no need to open config either.
+ */
+ if (flag_chk(FLAG_K)) {
+ node = xzalloc(sizeof(struct arg_list));
+ file = xzalloc(sizeof(logfile_t));
+ file->filename = "/dev/kmsg";
+ file->config = "*.*";
+ memset(file->level, 0xFF, sizeof(file->level));
+ memset(file->facility, 0xFFFFFFFF, sizeof(file->facility));
+ node->arg = (char*) file;
+ TT.lfiles = node;
+ return 0;
+ }
+ /*
+ * if -R then add remote host to log list
+ * if -L is not provided all other log
+ * files are neglected thus no need to
+ * open config either so just return.
+ */
+ if (flag_chk(FLAG_R)) {
+ node = xzalloc(sizeof(struct arg_list));
+ file = xzalloc(sizeof(logfile_t));
+ file->filename = xmsprintf("@%s",TT.remote_log);
+ file->isNetwork = 1;
+ file->config = "*.*";
+ memset(file->level, 0xFF, sizeof(file->level));
+ memset(file->facility, 0xFFFFFFFF, sizeof(file->facility));
+ node->arg = (char*) file;
+ TT.lfiles = node;
+ if (!flag_chk(FLAG_L))return 0;
+ }
+ /*
+ * Read config file and add logfiles to the list
+ * with their configuration.
+ */
+ fp = fopen(TT.config_file, "r");
+ if (!fp && flag_chk(FLAG_f))
+ perror_exit("can't open '%s'", TT.config_file);
+
+ for (len = 0, linelen = 0; fp;) {
+ len = getline(&confline, (size_t*) &linelen, fp);
+ if (len <= 0) break;
+ lineno++;
+ for (; *confline == ' '; confline++, len--) ;
+ if ((confline[0] == '#') || (confline[0] == '\n')) continue;
+ for (tcount = 0, tk = strtok(confline, " \t"); tk && (tcount < 2); tk =
+ strtok(NULL, " \t"), tcount++) {
+ if (tcount == 2) {
+ error_msg("error in '%s' at line %d", TT.config_file, lineno);
+ return -1;
+ }
+ tokens[tcount] = xstrdup(tk);
+ }
+ if (tcount <= 1 || tcount > 2) {
+ if (tokens[0]) free(tokens[0]);
+ error_msg("bad line %d: 1 tokens found, 2 needed", lineno);
+ return -1;
+ }
+ tk = (tokens[1] + (strlen(tokens[1]) - 1));
+ if (*tk == '\n') *tk = '\0';
+ if (*tokens[1] == '\0') {
+ error_msg("bad line %d: 1 tokens found, 2 needed", lineno);
+ return -1;
+ }
+ if (*tokens[1] == '*') goto loop_again;
+
+ node = get_file_node(tokens[1], TT.lfiles);
+ if (!node) {
+ node = xzalloc(sizeof(struct arg_list));
+ file = xzalloc(sizeof(logfile_t));
+ file->config = xstrdup(tokens[0]);
+ if (resolve_config(file)==-1) {
+ error_msg("error in '%s' at line %d", TT.config_file, lineno);
+ return -1;
+ }
+ file->filename = xstrdup(tokens[1]);
+ if (*file->filename == '@') file->isNetwork = 1;
+ node->arg = (char*) file;
+ node->next = TT.lfiles;
+ TT.lfiles = node;
+ } else {
+ file = (logfile_t*) node->arg;
+ int rel = strlen(file->config) + strlen(tokens[0]) + 2;
+ file->config = xrealloc(file->config, rel);
+ sprintf(file->config, "%s;%s", file->config, tokens[0]);
+ }
+loop_again:
+ if (tokens[0]) free(tokens[0]);
+ if (tokens[1]) free(tokens[1]);
+ free(confline);
+ confline = NULL;
+ }
+ /*
+ * Can't open config file or support is not enabled
+ * adding default logfile to the head of list.
+ */
+ if (!fp){
+ node = xzalloc(sizeof(struct arg_list));
+ file = xzalloc(sizeof(logfile_t));
+ file->filename = flag_get(FLAG_O, TT.logfile, "/var/log/messages"); //DEFLOGFILE
+ file->isNetwork = 0;
+ file->config = "*.*";
+ memset(file->level, 0xFF, sizeof(file->level));
+ memset(file->facility, 0xFFFFFFFF, sizeof(file->facility));
+ node->arg = (char*) file;
+ node->next = TT.lfiles;
+ TT.lfiles = node;
+ }
+ if (fp) {
+ fclose(fp);
+ fp = NULL;
+ }
+ return 0;
+}
+
+static int getport(char *str, char *filename)
+{
+ char *endptr = NULL;
+ int base = 10;
+ errno = 0;
+ if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
+ base = 16;
+ str += 2;
+ }
+ long port = strtol(str, &endptr, base);
+ if (errno || *endptr!='\0'|| endptr == str
+ || port < 0 || port > 65535) error_exit("wrong port no in %s", filename);
+ return (int)port;
+}
+
+// open every log file in list.
+static void open_logfiles(void)
+{
+ logfile_t *tfd;
+ char *p, *tmpfile;
+ int port = -1;
+ struct arg_list *node = TT.lfiles;
+
+ while (node) {
+ tfd = (logfile_t*) node->arg;
+ if (tfd->isNetwork) {
+ tmpfile = xstrdup(tfd->filename +1);
+ if ((p = strchr(tmpfile, ':'))) {
+ *p = '\0';
+ port = getport(p + 1, tfd->filename);
+ }
+ tfd->logfd = open_udp_socks(tmpfile, (port>=0)?port:514, &tfd->saddr);
+ free(tmpfile);
+ } else tfd->logfd = open(tfd->filename, O_CREAT | O_WRONLY | O_APPEND, 0666);
+ if (tfd->logfd < 0) {
+ tfd->filename = "/dev/console";
+ tfd->logfd = open(tfd->filename, O_APPEND);
+ }
+ node = node->next;
+ }
+}
+
+//write to file with rotation
+static int write_rotate( logfile_t *tf, int len)
+{
+ int size, isreg;
+ struct stat statf;
+ isreg = (!fstat(tf->logfd, &statf) && S_ISREG(statf.st_mode));
+ size = statf.st_size;
+
+ if (flag_chk(FLAG_s) || flag_chk(FLAG_b)) {
+ if (TT.rot_size && isreg && (size + len) > (TT.rot_size*1024)) {
+ if (TT.rot_count) { /* always 0..99 */
+ int i = strlen(tf->filename) + 3 + 1;
+ char old_file[i];
+ char new_file[i];
+ i = TT.rot_count - 1;
+ while (1) {
+ sprintf(new_file, "%s.%d", tf->filename, i);
+ if (!i) break;
+ sprintf(old_file, "%s.%d", tf->filename, --i);
+ rename(old_file, new_file);
+ }
+ rename(tf->filename, new_file);
+ unlink(tf->filename);
+ close(tf->logfd);
+ tf->logfd = open(tf->filename, O_CREAT | O_WRONLY | O_APPEND, 0666);
+ }
+ ftruncate(tf->logfd, 0);
+ }
+ }
+ return write(tf->logfd, toybuf, len);
+}
+
+//search the given name and return its value
+static char *dec(int val, CODE *clist)
+{
+ const CODE *c;
+
+ for (c = clist; c->c_name; c++)
+ if (val == c->c_val) return c->c_name;
+ return itoa(val);
+}
+
+// Compute priority from "facility.level" pair
+static void priority_to_string(int pri, char **facstr, char **lvlstr)
+{
+ int fac,lev;
+
+ fac = LOG_FAC(pri);
+ lev = LOG_PRI(pri);
+ *facstr = dec(fac<<3, facilitynames);
+ *lvlstr = dec(lev, prioritynames);
+}
+
+//Parse messege and write to file.
+static void logmsg(char *msg, int len)
+{
+ time_t now;
+ char *p, *ts, *lvlstr, *facstr;
+ struct utsname uts;
+ int pri = 0;
+ struct arg_list *lnode = TT.lfiles;
+
+ char *omsg = msg;
+ int olen = len, fac, lvl;
+
+ if (*msg == '<') { // Extract the priority no.
+ pri = (int) strtoul(msg + 1, &p, 10);
+ if (*p == '>') msg = p + 1;
+ }
+ /* Jan 18 00:11:22 msg...
+ * 01234567890123456
+ */
+ if (len < 16 || msg[3] != ' ' || msg[6] != ' ' || msg[9] != ':'
+ || msg[12] != ':' || msg[15] != ' ') {
+ time(&now);
+ ts = ctime(&now) + 4; /* skip day of week */
+ } else {
+ now = 0;
+ ts = msg;
+ msg += 16;
+ }
+ ts[15] = '\0';
+ fac = LOG_FAC(pri);
+ lvl = LOG_PRI(pri);
+
+ if (flag_chk(FLAG_K)) {
+ len = sprintf(toybuf, "<%d> %s\n", pri, msg);
+ goto do_log;
+ }
+ priority_to_string(pri, &facstr, &lvlstr);
+
+ p = "local";
+ if (!uname(&uts)) p = uts.nodename;
+ if (flag_chk(FLAG_S)) len = sprintf(toybuf, "%s %s\n", ts, msg);
+ else len = sprintf(toybuf, "%s %s %s.%s %s\n", ts, p, facstr, lvlstr, msg);
+
+do_log:
+ if (lvl >= TT.log_prio) return;
+
+ while (lnode) {
+ logfile_t *tf = (logfile_t*) lnode->arg;
+ if (tf->logfd > 0) {
+ if ((tf->facility[lvl] & (1 << fac)) && (tf->level[fac] & (1<<lvl))) {
+ int wlen;
+ if (tf->isNetwork)
+ wlen = sendto(tf->logfd, omsg, olen, 0, (struct sockaddr*)&tf->saddr, sizeof(tf->saddr));
+ else wlen = write_rotate(tf, len);
+ if (wlen < 0) perror_msg("write failed file : %s ", (tf->isNetwork)?(tf->filename+1):tf->filename);
+ }
+ }
+ lnode = lnode->next;
+ }
+}
+
+/*
+ * closes all read and write fds
+ * and frees all nodes and lists
+ */
+static void cleanup(void)
+{
+ struct arg_list *fnode;
+ while (TT.lsocks) {
+ fnode = TT.lsocks;
+ if (((unsocks_t*) fnode->arg)->sd >= 0)
+ close(((unsocks_t*) fnode->arg)->sd);
+ free(fnode->arg);
+ TT.lsocks = fnode->next;
+ free(fnode);
+ }
+ unlink("/dev/log");
+
+ while (TT.lfiles) {
+ fnode = TT.lfiles;
+ if (((logfile_t*) fnode->arg)->logfd >= 0)
+ close(((logfile_t*) fnode->arg)->logfd);
+ free(fnode->arg);
+ TT.lfiles = fnode->next;
+ free(fnode);
+ }
+}
+
+static void signal_handler(int sig)
+{
+ unsigned char ch = sig;
+ if (write(sigfd.wr, &ch, 1) != 1) error_msg("can't send signal");
+}
+
+static void setup_signal()
+{
+ if (pipe((int *)&sigfd) < 0) error_exit("pipe failed\n");
+
+ fcntl(sigfd.wr , F_SETFD, FD_CLOEXEC);
+ fcntl(sigfd.rd , F_SETFD, FD_CLOEXEC);
+ int flags = fcntl(sigfd.wr, F_GETFL);
+ fcntl(sigfd.wr, F_SETFL, flags | O_NONBLOCK);
+ signal(SIGHUP, signal_handler);
+ signal(SIGTERM, signal_handler);
+ signal(SIGINT, signal_handler);
+ signal(SIGQUIT, signal_handler);
+}
+
+static void syslog_daemon(void)
+{
+ int fd = open("/dev/null", O_RDWR);
+ if (fd < 0) fd = xcreate("/", O_RDONLY, 0666);
+
+ pid_t pid = fork();
+ if (pid < 0) perror_exit("DAEMON: failed to fork");
+ if (pid) exit(EXIT_SUCCESS);
+
+ setsid();
+ dup2(fd, 0);
+ dup2(fd, 1);
+ dup2(fd, 2);
+ if (fd > 2) close(fd);
+
+ //don't daemonize again if SIGHUP received.
+ toys.optflags |= FLAG_n;
+}
+
+void syslogd_main(void)
+{
+ unsocks_t *tsd;
+ int maxfd, retval, last_len=0;
+ struct timeval tv;
+ struct arg_list *node;
+ char *temp, *buffer = (toybuf +2048), *last_buf = (toybuf + 3072); //these two buffs are of 1K each
+
+ if (flag_chk(FLAG_p) && strlen(TT.unix_socket) > 108)
+ error_exit("Socket path should not be more than 108");
+
+ TT.config_file = flag_get(FLAG_f, TT.config_file, "/etc/syslog.conf"); //DEFCONFFILE
+init_jumpin:
+ TT.lsocks = xzalloc(sizeof(struct arg_list));
+ tsd = xzalloc(sizeof(unsocks_t));
+
+ tsd->path = flag_get(FLAG_p, TT.unix_socket , "/dev/log"); // DEFLOGSOCK
+ TT.lsocks->arg = (char*) tsd;
+
+ if (flag_chk(FLAG_a)) {
+ for (temp = strtok(TT.socket, ":"); temp; temp = strtok(NULL, ":")) {
+ struct arg_list *ltemp = xzalloc(sizeof(struct arg_list));
+ if (strlen(temp) > 107) temp[108] = '\0';
+ tsd = xzalloc(sizeof(unsocks_t));
+ tsd->path = temp;
+ ltemp->arg = (char*) tsd;
+ ltemp->next = TT.lsocks;
+ TT.lsocks = ltemp;
+ }
+ }
+ if (!open_unix_socks()) {
+ error_msg("Can't open single socket for listenning.");
+ goto clean_and_exit;
+ }
+ setup_signal();
+ if (parse_config_file() == -1) goto clean_and_exit;
+ open_logfiles();
+ if (!flag_chk(FLAG_n)) syslog_daemon();
+ {
+ int pid_fd = open("/var/run/syslogd.pid", O_CREAT | O_WRONLY | O_TRUNC, 0666);
+ if (pid_fd > 0) {
+ unsigned pid = getpid();
+ int len = sprintf(toybuf, "%u\n", pid);
+ write(pid_fd, toybuf, len);
+ close(pid_fd);
+ }
+ }
+
+ logmsg("<46>Toybox: syslogd started", 27); //27 : the length of message
+ for (;;) {
+ maxfd = addrfds();
+ tv.tv_usec = 0;
+ tv.tv_sec = TT.interval*60;
+
+ retval = select(maxfd + 1, &TT.rfds, NULL, NULL, (TT.interval)?&tv:NULL);
+ if (retval < 0) { /* Some error. */
+ if (errno == EINTR) continue;
+ perror_msg("Error in select ");
+ continue;
+ }
+ if (!retval) { /* Timed out */
+ logmsg("<46>-- MARK --", 14);
+ continue;
+ }
+ if (FD_ISSET(sigfd.rd, &TT.rfds)) { /* May be a signal */
+ unsigned char sig;
+
+ if (read(sigfd.rd, &sig, 1) != 1) {
+ error_msg("signal read failed.\n");
+ continue;
+ }
+ switch(sig) {
+ case SIGTERM: /* FALLTHROUGH */
+ case SIGINT: /* FALLTHROUGH */
+ case SIGQUIT:
+ logmsg("<46>syslogd exiting", 19);
+ if (CFG_TOYBOX_FREE ) cleanup();
+ signal(sig, SIG_DFL);
+ sigset_t ss;
+ sigemptyset(&ss);
+ sigaddset(&ss, sig);
+ sigprocmask(SIG_UNBLOCK, &ss, NULL);
+ raise(sig);
+ _exit(1); /* Should not reach it */
+ break;
+ case SIGHUP:
+ logmsg("<46>syslogd exiting", 19);
+ cleanup(); //cleanup is done, as we restart syslog.
+ goto init_jumpin;
+ default: break;
+ }
+ }
+ if (retval > 0) { /* Some activity on listen sockets. */
+ node = TT.lsocks;
+ while (node) {
+ int sd = ((unsocks_t*) node->arg)->sd;
+ if (FD_ISSET(sd, &TT.rfds)) {
+ int len = read(sd, buffer, 1023); //buffer is of 1K, hence readingonly 1023 bytes, 1 for NUL
+ if (len > 0) {
+ buffer[len] = '\0';
+ if(flag_chk(FLAG_D) && (len == last_len))
+ if (!memcmp(last_buf, buffer, len)) break;
+
+ memcpy(last_buf, buffer, len);
+ last_len = len;
+ logmsg(buffer, len);
+ }
+ break;
+ }
+ node = node->next;
+ }
+ }
+ }
+clean_and_exit:
+ logmsg("<46>syslogd exiting", 19);
+ if (CFG_TOYBOX_FREE ) cleanup();
+}