2 Copyright (c) 2001-2006, Gerrit Pape
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
8 1. Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13 3. The name of the author may not be used to endorse or promote products
14 derived from this software without specific prior written permission.
16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR IMPLIED
17 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 /* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
33 On startup, and after receiving a HUP signal, svlogd checks for each
34 log directory log if the configuration file log/config exists,
35 and if so, reads the file line by line and adjusts configuration
38 If the line is empty, or starts with a #, it is ignored. A line
42 sets the maximum file size of current when svlogd should rotate
43 the current log file to size bytes. Default is 1000000.
44 If size is zero, svlogd doesnt rotate log files
45 You should set size to at least (2 * len).
47 sets the number of old log files svlogd should maintain to num.
48 If svlogd sees more that num old log files in log after log file
49 rotation, it deletes the oldest one. Default is 10.
50 If num is zero, svlogd doesnt remove old log files.
52 sets the minimum number of old log files svlogd should maintain
53 to min. min must be less than num. If min is set, and svlogd
54 cannot write to current because the filesystem is full,
55 and it sees more than min old log files, it deletes the oldest one.
57 sets the maximum age of the current log file when svlogd should
58 rotate the current log file to timeout seconds. If current
59 is timeout seconds old, and is not empty, svlogd forces log file rotation.
61 tells svlogd to feed each recent log file through processor
62 (see above) on log file rotation. By default log files are not processed.
64 tells svlogd to transmit the first len characters of selected
65 log messages to the IP address a.b.c.d, port number port.
66 If port isnt set, the default port for syslog is used (514).
67 len can be set through the -l option, see below. If svlogd
68 has trouble sending udp packets, it writes error messages
69 to the log directory. Attention: logging through udp is unreliable,
70 and should be used in private networks only.
72 is the same as the u line above, but the log messages are no longer
73 written to the log directory, but transmitted through udp only.
74 Error messages from svlogd concerning sending udp packages still go
77 tells svlogd to prefix each line to be written to the log directory,
78 to standard error, or through UDP, with prefix.
80 If a line starts with a -, +, e, or E, svlogd matches the first len characters
81 of each log message against pattern and acts accordingly:
84 the log message is deselected.
86 the log message is selected.
88 the log message is selected to be printed to standard error.
90 the log message is deselected to be printed to standard error.
92 Initially each line is selected to be written to log/current. Deselected
93 log messages are discarded from log. Initially each line is deselected
94 to be written to standard err. Log messages selected for standard error
95 are written to standard error.
99 svlogd matches a log message against the string pattern as follows:
101 pattern is applied to the log message one character by one, starting
102 with the first. A character not a star (*) and not a plus (+) matches itself.
103 A plus matches the next character in pattern in the log message one
104 or more times. A star before the end of pattern matches any string
105 in the log message that does not include the next character in pattern.
106 A star at the end of pattern matches any string.
108 Timestamps optionally added by svlogd are not considered part
111 An svlogd pattern is not a regular expression. For example consider
112 a log message like this
114 2005-12-18_09:13:50.97618 tcpsvd: info: pid 1977 from 10.4.1.14
116 The following pattern doesnt match
120 because the first star matches up to the first p in tcpsvd,
121 and then the match fails because i is not s. To match this
122 log message, you can use a pattern like this instead
126 //config:config SVLOGD
127 //config: bool "svlogd (15 kb)"
130 //config: svlogd continuously reads log data from its standard input, optionally
131 //config: filters log messages, and writes the data to one or more automatically
132 //config: rotated logs.
134 //applet:IF_SVLOGD(APPLET(svlogd, BB_DIR_USR_SBIN, BB_SUID_DROP))
136 //kbuild:lib-$(CONFIG_SVLOGD) += svlogd.o
138 //usage:#define svlogd_trivial_usage
139 //usage: "[-tttv] [-r C] [-R CHARS] [-l MATCHLEN] [-b BUFLEN] DIR..."
140 //usage:#define svlogd_full_usage "\n\n"
141 //usage: "Read log data from stdin and write to rotated log files in DIRs"
143 //usage: "\n""-r C Replace non-printable characters with C"
144 //usage: "\n""-R CHARS Also replace CHARS with C (default _)"
145 //usage: "\n""-t Timestamp with @tai64n"
146 //usage: "\n""-tt Timestamp with yyyy-mm-dd_hh:mm:ss.sssss"
147 //usage: "\n""-ttt Timestamp with yyyy-mm-ddThh:mm:ss.sssss"
148 //usage: "\n""-v Verbose"
150 //usage: "\n""DIR/config file modifies behavior:"
151 //usage: "\n""sSIZE - when to rotate logs (default 1000000, 0 disables)"
152 //usage: "\n""nNUM - number of files to retain"
153 ///////: "\n""NNUM - min number files to retain" - confusing
154 ///////: "\n""tSEC - rotate file if it get SEC seconds old" - confusing
155 //usage: "\n""!PROG - process rotated log with PROG"
156 ///////: "\n""uIPADDR - send log over UDP" - unsupported
157 ///////: "\n""UIPADDR - send log over UDP and DONT log" - unsupported
158 ///////: "\n""pPFX - prefix each line with PFX" - unsupported
159 //usage: "\n""+,-PATTERN - (de)select line for logging"
160 //usage: "\n""E,ePATTERN - (de)select line for stderr"
162 #include <sys/file.h>
164 #include "common_bufsiz.h"
165 #include "runit_lib.h"
167 #define LESS(a,b) ((int)((unsigned)(b) - (unsigned)(a)) > 0)
173 /* pattern list to match, in "aa\0bb\0\cc\0\0" form */
181 unsigned rotate_period;
187 unsigned next_rotate;
188 char fnsave[FMT_PTIME];
204 unsigned nearest_rotate;
206 void* (*memRchr)(const void *, int, size_t);
212 smallint linecomplete;
220 sigset_t blocked_sigset;
222 #define G (*ptr_to_globals)
224 #define verbose (G.verbose )
225 #define linemax (G.linemax )
226 #define buflen (G.buflen )
227 #define linelen (G.linelen )
228 #define fndir (G.fndir )
229 #define fdwdir (G.fdwdir )
230 #define wstat (G.wstat )
231 #define memRchr (G.memRchr )
232 #define nearest_rotate (G.nearest_rotate)
233 #define exitasap (G.exitasap )
234 #define rotateasap (G.rotateasap )
235 #define reopenasap (G.reopenasap )
236 #define linecomplete (G.linecomplete )
237 #define tmaxflag (G.tmaxflag )
238 #define repl (G.repl )
239 #define replace (G.replace )
240 #define blocked_sigset (G.blocked_sigset)
241 #define fl_flag_0 (G.fl_flag_0 )
242 #define dirn (G.dirn )
243 #define line bb_common_bufsiz1
244 #define INIT_G() do { \
245 setup_common_bufsiz(); \
246 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
254 #define FATAL "fatal: "
255 #define WARNING "warning: "
256 #define PAUSE "pausing: "
257 #define INFO "info: "
259 static void fatalx(const char *m0)
261 bb_error_msg_and_die(FATAL"%s", m0);
263 static void warn(const char *m0)
265 bb_perror_msg(WARNING"%s", m0);
267 static void warn2(const char *m0, const char *m1)
269 bb_perror_msg(WARNING"%s: %s", m0, m1);
271 static void warnx(const char *m0, const char *m1)
273 bb_error_msg(WARNING"%s: %s", m0, m1);
275 static void pause_nomem(void)
277 bb_error_msg(PAUSE"out of memory");
280 static void pause1cannot(const char *m0)
282 bb_perror_msg(PAUSE"can't %s", m0);
285 static void pause2cannot(const char *m0, const char *m1)
287 bb_perror_msg(PAUSE"can't %s %s", m0, m1);
291 static char* wstrdup(const char *str)
294 while (!(s = strdup(str)))
299 static unsigned pmatch(const char *p, const char *s, unsigned len)
317 if (c != *s) return 0;
328 if (*s != '?') return 0;
336 if (*s != c) return 0;
345 /*** ex fmt_ptime.[ch] ***/
348 static void fmt_time_human_30nul(char *s, char dt_delim)
354 gettimeofday(&tv, NULL);
355 ptm = gmtime_r(&tv.tv_sec, &tm);
356 /* ^^^ using gmtime_r() instead of gmtime() to not use static data */
357 sprintf(s, "%04u-%02u-%02u%c%02u:%02u:%02u.%06u000",
358 (unsigned)(1900 + ptm->tm_year),
359 (unsigned)(ptm->tm_mon + 1),
360 (unsigned)(ptm->tm_mday),
362 (unsigned)(ptm->tm_hour),
363 (unsigned)(ptm->tm_min),
364 (unsigned)(ptm->tm_sec),
365 (unsigned)(tv.tv_usec)
367 /* 4+1 + 2+1 + 2+1 + 2+1 + 2+1 + 2+1 + 9 = */
368 /* 5 + 3 + 3 + 3 + 3 + 3 + 9 = */
369 /* 20 (up to '.' inclusive) + 9 (not including '\0') */
372 /* NOT terminated! */
373 static void fmt_time_bernstein_25(char *s)
379 gettimeofday(&tv, NULL);
380 sec_hi = (0x400000000000000aULL + tv.tv_sec) >> 32;
381 tv.tv_sec = (time_t)(0x400000000000000aULL) + tv.tv_sec;
383 /* Network order is big-endian: most significant byte first.
384 * This is exactly what we want here */
385 pack[0] = htonl(sec_hi);
386 pack[1] = htonl(tv.tv_sec);
387 pack[2] = htonl(tv.tv_usec);
389 bin2hex(s, (char*)pack, 12);
392 static void processorstart(struct logdir *ld)
397 if (!ld->processor) return;
399 warnx("processor already running", ld->name);
403 /* vfork'ed child trashes this byte, save... */
404 sv_ch = ld->fnsave[26];
407 G.shell = xstrdup(get_shell_name());
409 while ((pid = vfork()) == -1)
410 pause2cannot("vfork for processor", ld->name);
415 /* Non-ignored signals revert to SIG_DFL on exec anyway */
421 sig_unblock(SIGTERM);
422 sig_unblock(SIGALRM);
426 bb_error_msg(INFO"processing: %s/%s", ld->name, ld->fnsave);
427 fd = xopen(ld->fnsave, O_RDONLY|O_NDELAY);
429 ld->fnsave[26] = 't'; /* <- that's why we need sv_ch! */
430 fd = xopen(ld->fnsave, O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
432 fd = open("state", O_RDONLY|O_NDELAY);
435 bb_perror_msg_and_die(FATAL"can't %s processor %s", "open state for", ld->name);
436 close(xopen("state", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT));
437 fd = xopen("state", O_RDONLY|O_NDELAY);
440 fd = xopen("newstate", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
443 execl(G.shell, G.shell, "-c", ld->processor, (char*) NULL);
444 bb_perror_msg_and_die(FATAL"can't %s processor %s", "run", ld->name);
446 ld->fnsave[26] = sv_ch; /* ...restore */
450 static unsigned processorstop(struct logdir *ld)
456 while (safe_waitpid(ld->ppid, &wstat, 0) == -1)
457 pause2cannot("wait for processor", ld->name);
463 while (fchdir(ld->fddir) == -1)
464 pause2cannot("change directory, want processor", ld->name);
465 if (WEXITSTATUS(wstat) != 0) {
466 warnx("processor failed, restart", ld->name);
467 ld->fnsave[26] = 't';
469 ld->fnsave[26] = 'u';
471 while (fchdir(fdwdir) == -1)
472 pause1cannot("change to initial working directory");
473 return ld->processor ? 0 : 1;
475 ld->fnsave[26] = 't';
476 memcpy(f, ld->fnsave, 26);
479 while (rename(ld->fnsave, f) == -1)
480 pause2cannot("rename processed", ld->name);
481 while (chmod(f, 0744) == -1)
482 pause2cannot("set mode of processed", ld->name);
483 ld->fnsave[26] = 'u';
484 if (unlink(ld->fnsave) == -1)
485 bb_error_msg(WARNING"can't unlink: %s/%s", ld->name, ld->fnsave);
486 while (rename("newstate", "state") == -1)
487 pause2cannot("rename state", ld->name);
489 bb_error_msg(INFO"processed: %s/%s", ld->name, f);
490 while (fchdir(fdwdir) == -1)
491 pause1cannot("change to initial working directory");
495 static void rmoldest(struct logdir *ld)
499 char oldest[FMT_PTIME];
502 oldest[0] = 'A'; oldest[1] = oldest[27] = 0;
503 while (!(d = opendir(".")))
504 pause2cannot("open directory, want rotate", ld->name);
506 while ((f = readdir(d))) {
507 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
508 if (f->d_name[26] == 't') {
509 if (unlink(f->d_name) == -1)
510 warn2("can't unlink processor leftover", f->d_name);
513 if (strcmp(f->d_name, oldest) < 0)
514 memcpy(oldest, f->d_name, 27);
520 warn2("can't read directory", ld->name);
523 if (ld->nmax && (n > ld->nmax)) {
525 bb_error_msg(INFO"delete: %s/%s", ld->name, oldest);
526 if ((*oldest == '@') && (unlink(oldest) == -1))
527 warn2("can't unlink oldest logfile", ld->name);
531 static unsigned rotate(struct logdir *ld)
536 if (ld->fddir == -1) {
537 ld->rotate_period = 0;
541 while (!processorstop(ld))
544 while (fchdir(ld->fddir) == -1)
545 pause2cannot("change directory, want rotate", ld->name);
547 /* create new filename */
548 ld->fnsave[25] = '.';
549 ld->fnsave[26] = 's';
551 ld->fnsave[26] = 'u';
552 ld->fnsave[27] = '\0';
554 fmt_time_bernstein_25(ld->fnsave);
556 stat(ld->fnsave, &st);
557 } while (errno != ENOENT);
559 now = monotonic_sec();
560 if (ld->rotate_period && LESS(ld->next_rotate, now)) {
561 ld->next_rotate = now + ld->rotate_period;
562 if (LESS(ld->next_rotate, nearest_rotate))
563 nearest_rotate = ld->next_rotate;
567 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
568 pause2cannot("fsync current logfile", ld->name);
569 while (fchmod(ld->fdcur, 0744) == -1)
570 pause2cannot("set mode of current", ld->name);
571 ////close(ld->fdcur);
575 bb_error_msg(INFO"rename: %s/current %s %u", ld->name,
576 ld->fnsave, ld->size);
578 while (rename("current", ld->fnsave) == -1)
579 pause2cannot("rename current", ld->name);
580 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
581 pause2cannot("create new current", ld->name);
582 while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL) ////
583 pause2cannot("create new current", ld->name); /* very unlikely */
584 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
585 close_on_exec_on(ld->fdcur);
587 while (fchmod(ld->fdcur, 0644) == -1)
588 pause2cannot("set mode of current", ld->name);
594 while (fchdir(fdwdir) == -1)
595 pause1cannot("change to initial working directory");
599 static int buffer_pwrite(int n, char *s, unsigned len)
602 struct logdir *ld = &dir[n];
605 if (ld->size >= ld->sizemax)
607 if (len > (ld->sizemax - ld->size))
608 len = ld->sizemax - ld->size;
611 ////i = full_write(ld->fdcur, s, len);
612 ////if (i != -1) break;
613 i = fwrite(s, 1, len, ld->filecur);
616 if ((errno == ENOSPC) && (ld->nmin < ld->nmax)) {
619 char oldest[FMT_PTIME];
622 while (fchdir(ld->fddir) == -1)
623 pause2cannot("change directory, want remove old logfile",
626 oldest[1] = oldest[27] = '\0';
627 while (!(d = opendir(".")))
628 pause2cannot("open directory, want remove old logfile",
631 while ((f = readdir(d)))
632 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
634 if (strcmp(f->d_name, oldest) < 0)
635 memcpy(oldest, f->d_name, 27);
637 if (errno) warn2("can't read directory, want remove old logfile",
642 if (*oldest == '@') {
643 bb_error_msg(WARNING"out of disk space, delete: %s/%s",
646 if (unlink(oldest) == -1) {
647 warn2("can't unlink oldest logfile", ld->name);
650 while (fchdir(fdwdir) == -1)
651 pause1cannot("change to initial working directory");
656 pause2cannot("write to current", ld->name);
662 if (ld->size >= (ld->sizemax - linemax))
667 static void logdir_close(struct logdir *ld)
672 bb_error_msg(INFO"close: %s", ld->name);
676 return; /* impossible */
677 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
678 pause2cannot("fsync current logfile", ld->name);
679 while (fchmod(ld->fdcur, 0744) == -1)
680 pause2cannot("set mode of current", ld->name);
681 ////close(ld->fdcur);
684 if (ld->fdlock == -1)
685 return; /* impossible */
689 ld->processor = NULL;
692 static NOINLINE unsigned logdir_open(struct logdir *ld, const char *fn)
700 now = monotonic_sec();
702 ld->fddir = open(fn, O_RDONLY|O_NDELAY);
703 if (ld->fddir == -1) {
704 warn2("can't open log directory", (char*)fn);
707 close_on_exec_on(ld->fddir);
708 if (fchdir(ld->fddir) == -1) {
710 warn2("can't change directory", (char*)fn);
713 ld->fdlock = open("lock", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
714 if ((ld->fdlock == -1)
715 || (flock(ld->fdlock, LOCK_EX | LOCK_NB) == -1)
718 warn2("can't lock directory", (char*)fn);
719 while (fchdir(fdwdir) == -1)
720 pause1cannot("change to initial working directory");
723 close_on_exec_on(ld->fdlock);
726 ld->sizemax = 1000000;
727 ld->nmax = ld->nmin = 10;
728 ld->rotate_period = 0;
729 ld->name = (char*)fn;
732 free(ld->inst); ld->inst = NULL;
733 free(ld->processor); ld->processor = NULL;
736 i = open_read_close("config", buf, sizeof(buf) - 1);
737 if (i < 0 && errno != ENOENT)
738 bb_perror_msg(WARNING"%s/config", ld->name);
742 bb_error_msg(INFO"read: %s/config", ld->name);
745 np = strchr(s, '\n');
753 /* Filtering requires one-line buffering,
754 * resetting the "find newline" function
757 /* Add '\n'-terminated line to ld->inst */
759 int l = asprintf(&new, "%s%s\n", ld->inst ? ld->inst : "", s);
768 ld->sizemax = xatou_sfx(&s[1], km_suffixes);
772 ld->nmax = xatoi_positive(&s[1]);
775 ld->nmin = xatoi_positive(&s[1]);
778 static const struct suffix_mult mh_suffixes[] = {
781 /*{ "d", 24*60*60 },*/
784 ld->rotate_period = xatou_sfx(&s[1], mh_suffixes);
785 if (ld->rotate_period) {
786 ld->next_rotate = now + ld->rotate_period;
787 if (!tmaxflag || LESS(ld->next_rotate, nearest_rotate))
788 nearest_rotate = ld->next_rotate;
796 ld->processor = wstrdup(&s[1]);
802 /* Convert "aa\nbb\ncc\n\0" to "aa\0bb\0cc\0\0" */
805 np = strchr(s, '\n');
813 i = stat("current", &st);
815 if (st.st_size && !(st.st_mode & S_IXUSR)) {
816 ld->fnsave[25] = '.';
817 ld->fnsave[26] = 'u';
818 ld->fnsave[27] = '\0';
820 fmt_time_bernstein_25(ld->fnsave);
822 stat(ld->fnsave, &st);
823 } while (errno != ENOENT);
824 while (rename("current", ld->fnsave) == -1)
825 pause2cannot("rename current", ld->name);
829 /* st.st_size can be not just bigger, but WIDER!
830 * This code is safe: if st.st_size > 4GB, we select
831 * ld->sizemax (because it's "unsigned") */
832 ld->size = (st.st_size > ld->sizemax) ? ld->sizemax : st.st_size;
835 if (errno != ENOENT) {
837 warn2("can't stat current", ld->name);
838 while (fchdir(fdwdir) == -1)
839 pause1cannot("change to initial working directory");
843 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
844 pause2cannot("open current", ld->name);
845 while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL)
846 pause2cannot("open current", ld->name); ////
847 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
849 close_on_exec_on(ld->fdcur);
850 while (fchmod(ld->fdcur, 0644) == -1)
851 pause2cannot("set mode of current", ld->name);
854 if (i == 0) bb_error_msg(INFO"append: %s/current", ld->name);
855 else bb_error_msg(INFO"new: %s/current", ld->name);
858 while (fchdir(fdwdir) == -1)
859 pause1cannot("change to initial working directory");
863 static void logdirs_reopen(void)
869 for (l = 0; l < dirn; ++l) {
870 logdir_close(&dir[l]);
871 if (logdir_open(&dir[l], fndir[l]))
875 fatalx("no functional log directories");
878 /* Will look good in libbb one day */
879 static ssize_t ndelay_read(int fd, void *buf, size_t count)
881 if (!(fl_flag_0 & O_NONBLOCK))
882 fcntl(fd, F_SETFL, fl_flag_0 | O_NONBLOCK);
883 count = safe_read(fd, buf, count);
884 if (!(fl_flag_0 & O_NONBLOCK))
885 fcntl(fd, F_SETFL, fl_flag_0);
889 /* Used for reading stdin */
890 static int buffer_pread(/*int fd, */char *s, unsigned len)
896 input.fd = STDIN_FILENO;
897 input.events = POLLIN;
901 for (i = 0; i < dirn; ++i)
914 now = monotonic_sec();
915 nearest_rotate = now + (45 * 60 + 45);
916 for (i = 0; i < dirn; ++i) {
917 if (dir[i].rotate_period) {
918 if (LESS(dir[i].next_rotate, now))
920 if (LESS(dir[i].next_rotate, nearest_rotate))
921 nearest_rotate = dir[i].next_rotate;
925 sigprocmask(SIG_UNBLOCK, &blocked_sigset, NULL);
926 i = nearest_rotate - now;
931 poll(&input, 1, i * 1000);
932 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
934 i = ndelay_read(STDIN_FILENO, s, len);
939 if (errno != EAGAIN) {
940 warn("can't read standard input");
943 /* else: EAGAIN - normal, repeat silently */
948 linecomplete = (s[i-1] == '\n');
956 if (ch < 32 || ch > 126)
960 for (j = 0; replace[j]; ++j) {
961 if (ch == replace[j]) {
974 static void sig_term_handler(int sig_no UNUSED_PARAM)
977 bb_error_msg(INFO"sig%s received", "term");
981 static void sig_child_handler(int sig_no UNUSED_PARAM)
987 bb_error_msg(INFO"sig%s received", "child");
988 while ((pid = wait_any_nohang(&wstat)) > 0) {
989 for (l = 0; l < dirn; ++l) {
990 if (dir[l].ppid == pid) {
992 processorstop(&dir[l]);
999 static void sig_alarm_handler(int sig_no UNUSED_PARAM)
1002 bb_error_msg(INFO"sig%s received", "alarm");
1006 static void sig_hangup_handler(int sig_no UNUSED_PARAM)
1009 bb_error_msg(INFO"sig%s received", "hangup");
1013 static void logmatch(struct logdir *ld)
1024 if (pmatch(s+1, line, linelen))
1029 if (pmatch(s+1, line, linelen))
1030 ld->matcherr = s[0];
1037 int svlogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1038 int svlogd_main(int argc, char **argv)
1041 ssize_t stdin_cnt = 0;
1044 unsigned timestamp = 0;
1048 opt = getopt32(argv, "^"
1049 "r:R:l:b:tv" "\0" "tt:vv",
1050 &r, &replace, &l, &b, ×tamp, &verbose
1052 if (opt & 1) { // -r
1057 if (opt & 2) if (!repl) repl = '_'; // -R
1058 if (opt & 4) { // -l
1059 linemax = xatou_range(l, 0, COMMON_BUFSIZE-26);
1061 linemax = COMMON_BUFSIZE-26;
1065 ////if (opt & 8) { // -b
1066 //// buflen = xatoi_positive(b);
1067 //// if (buflen == 0) buflen = 1024;
1069 //if (opt & 0x10) timestamp++; // -t
1070 //if (opt & 0x20) verbose++; // -v
1071 //if (timestamp > 2) timestamp = 2;
1078 ////if (buflen <= linemax) bb_show_usage();
1079 fdwdir = xopen(".", O_RDONLY|O_NDELAY);
1080 close_on_exec_on(fdwdir);
1081 dir = xzalloc(dirn * sizeof(dir[0]));
1082 for (i = 0; i < dirn; ++i) {
1085 ////dir[i].btmp = xmalloc(buflen);
1086 /*dir[i].ppid = 0;*/
1088 /* line = xmalloc(linemax + (timestamp ? 26 : 0)); */
1090 /* We cannot set NONBLOCK on fd #0 permanently - this setting
1091 * _isn't_ per-process! It is shared among all other processes
1092 * with the same stdin */
1093 fl_flag_0 = fcntl(0, F_GETFL);
1095 sigemptyset(&blocked_sigset);
1096 sigaddset(&blocked_sigset, SIGTERM);
1097 sigaddset(&blocked_sigset, SIGCHLD);
1098 sigaddset(&blocked_sigset, SIGALRM);
1099 sigaddset(&blocked_sigset, SIGHUP);
1100 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
1101 bb_signals_recursive_norestart(1 << SIGTERM, sig_term_handler);
1102 bb_signals_recursive_norestart(1 << SIGCHLD, sig_child_handler);
1103 bb_signals_recursive_norestart(1 << SIGALRM, sig_alarm_handler);
1104 bb_signals_recursive_norestart(1 << SIGHUP, sig_hangup_handler);
1106 /* Without timestamps, we don't have to print each line
1107 * separately, so we can look for _last_ newline, not first,
1108 * thus batching writes. If filtering is enabled in config,
1109 * logdirs_reopen resets it to memchr.
1111 memRchr = (timestamp ? memchr : memrchr);
1115 setvbuf(stderr, NULL, _IOFBF, linelen);
1117 /* Each iteration processes one or more lines */
1119 char stamp[FMT_PTIME];
1130 /* lineptr[0..linemax-1] - buffer for stdin */
1131 /* (possibly has some unprocessed data from prev loop) */
1133 /* Refill the buffer if needed */
1134 np = memRchr(lineptr, '\n', stdin_cnt);
1135 if (!np && !exitasap) {
1136 i = linemax - stdin_cnt; /* avail. bytes at tail */
1138 i = buffer_pread(/*0, */lineptr + stdin_cnt, i);
1139 if (i <= 0) /* EOF or error on stdin */
1142 np = memRchr(lineptr + stdin_cnt, '\n', i);
1147 if (stdin_cnt <= 0 && exitasap)
1150 /* Search for '\n' (in fact, np already holds the result) */
1151 linelen = stdin_cnt;
1154 /* NB: starting from here lineptr may point
1155 * farther out into line[] */
1156 linelen = np - lineptr + 1;
1158 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
1159 ch = lineptr[linelen-1];
1161 /* Biggest performance hit was coming from the fact
1162 * that we did not buffer writes. We were reading many lines
1163 * in one read() above, but wrote one line per write().
1164 * We are using stdio to fix that */
1166 /* write out lineptr[0..linelen-1] to each log destination
1167 * (or lineptr[-26..linelen-1] if timestamping) */
1172 fmt_time_bernstein_25(stamp);
1174 fmt_time_human_30nul(stamp, timestamp == 2 ? '_' : 'T');
1177 memcpy(printptr, stamp, 25);
1180 for (i = 0; i < dirn; ++i) {
1181 struct logdir *ld = &dir[i];
1182 if (ld->fddir == -1)
1186 if (ld->matcherr == 'e') {
1187 /* runit-1.8.0 compat: if timestamping, do it on stderr too */
1188 ////full_write(STDERR_FILENO, printptr, printlen);
1189 fwrite(printptr, 1, printlen, stderr);
1191 if (ld->match != '+')
1193 buffer_pwrite(i, printptr, printlen);
1196 /* If we didn't see '\n' (long input line), */
1197 /* read/write repeatedly until we see it */
1198 while (ch != '\n') {
1199 /* lineptr is emptied now, safe to use as buffer */
1200 stdin_cnt = exitasap ? -1 : buffer_pread(/*0, */lineptr, linemax);
1201 if (stdin_cnt <= 0) { /* EOF or error on stdin */
1203 lineptr[0] = ch = '\n';
1207 linelen = stdin_cnt;
1208 np = memRchr(lineptr, '\n', stdin_cnt);
1210 linelen = np - lineptr + 1;
1211 ch = lineptr[linelen-1];
1213 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
1214 for (i = 0; i < dirn; ++i) {
1215 if (dir[i].fddir == -1)
1217 if (dir[i].matcherr == 'e') {
1218 ////full_write(STDERR_FILENO, lineptr, linelen);
1219 fwrite(lineptr, 1, linelen, stderr);
1221 if (dir[i].match != '+')
1223 buffer_pwrite(i, lineptr, linelen);
1227 stdin_cnt -= linelen;
1228 if (stdin_cnt > 0) {
1230 /* If we see another '\n', we don't need to read
1231 * next piece of input: can print what we have */
1232 np = memRchr(lineptr, '\n', stdin_cnt);
1235 /* Move unprocessed data to the front of line */
1236 memmove((timestamp ? line+26 : line), lineptr, stdin_cnt);
1241 for (i = 0; i < dirn; ++i) {
1243 while (!processorstop(&dir[i]))
1245 logdir_close(&dir[i]);