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> */
29 /* TODO: depends on runit_lib.c - review and reduce/eliminate */
34 On startup, and after receiving a HUP signal, svlogd checks for each
35 log directory log if the configuration file log/config exists,
36 and if so, reads the file line by line and adjusts configuration
39 If the line is empty, or starts with a #, it is ignored. A line
43 sets the maximum file size of current when svlogd should rotate
44 the current log file to size bytes. Default is 1000000.
45 If size is zero, svlogd doesnt rotate log files
46 You should set size to at least (2 * len).
48 sets the number of old log files svlogd should maintain to num.
49 If svlogd sees more that num old log files in log after log file
50 rotation, it deletes the oldest one. Default is 10.
51 If num is zero, svlogd doesnt remove old log files.
53 sets the minimum number of old log files svlogd should maintain
54 to min. min must be less than num. If min is set, and svlogd
55 cannot write to current because the filesystem is full,
56 and it sees more than min old log files, it deletes the oldest one.
58 sets the maximum age of the current log file when svlogd should
59 rotate the current log file to timeout seconds. If current
60 is timeout seconds old, and is not empty, svlogd forces log file rotation.
62 tells svlogd to feed each recent log file through processor
63 (see above) on log file rotation. By default log files are not processed.
65 tells svlogd to transmit the first len characters of selected
66 log messages to the IP address a.b.c.d, port number port.
67 If port isnt set, the default port for syslog is used (514).
68 len can be set through the -l option, see below. If svlogd
69 has trouble sending udp packets, it writes error messages
70 to the log directory. Attention: logging through udp is unreliable,
71 and should be used in private networks only.
73 is the same as the u line above, but the log messages are no longer
74 written to the log directory, but transmitted through udp only.
75 Error messages from svlogd concerning sending udp packages still go
78 tells svlogd to prefix each line to be written to the log directory,
79 to standard error, or through UDP, with prefix.
81 If a line starts with a -, +, e, or E, svlogd matches the first len characters
82 of each log message against pattern and acts accordingly:
85 the log message is deselected.
87 the log message is selected.
89 the log message is selected to be printed to standard error.
91 the log message is deselected to be printed to standard error.
93 Initially each line is selected to be written to log/current. Deselected
94 log messages are discarded from log. Initially each line is deselected
95 to be written to standard err. Log messages selected for standard error
96 are written to standard error.
100 svlogd matches a log message against the string pattern as follows:
102 pattern is applied to the log message one character by one, starting
103 with the first. A character not a star (*) and not a plus (+) matches itself.
104 A plus matches the next character in pattern in the log message one
105 or more times. A star before the end of pattern matches any string
106 in the log message that does not include the next character in pattern.
107 A star at the end of pattern matches any string.
109 Timestamps optionally added by svlogd are not considered part
112 An svlogd pattern is not a regular expression. For example consider
113 a log message like this
115 2005-12-18_09:13:50.97618 tcpsvd: info: pid 1977 from 10.4.1.14
117 The following pattern doesnt match
121 because the first star matches up to the first p in tcpsvd,
122 and then the match fails because i is not s. To match this
123 log message, you can use a pattern like this instead
128 //usage:#define svlogd_trivial_usage
129 //usage: "[-ttv] [-r C] [-R CHARS] [-l MATCHLEN] [-b BUFLEN] DIR..."
130 //usage:#define svlogd_full_usage "\n\n"
131 //usage: "Continuously read log data from stdin and write to rotated log files in DIRs"
133 //usage: "\n""DIR/config file modifies behavior:"
134 //usage: "\n""sSIZE - when to rotate logs"
135 //usage: "\n""nNUM - number of files to retain"
136 /*usage: "\n""NNUM - min number files to retain" - confusing */
137 /*usage: "\n""tSEC - rotate file if it get SEC seconds old" - confusing */
138 //usage: "\n""!PROG - process rotated log with PROG"
139 /*usage: "\n""uIPADDR - send log over UDP" - unsupported */
140 /*usage: "\n""UIPADDR - send log over UDP and DONT log" - unsupported */
141 /*usage: "\n""pPFX - prefix each line with PFX" - unsupported */
142 //usage: "\n""+,-PATTERN - (de)select line for logging"
143 //usage: "\n""E,ePATTERN - (de)select line for stderr"
145 #include <sys/poll.h>
146 #include <sys/file.h>
148 #include "runit_lib.h"
150 #define LESS(a,b) ((int)((unsigned)(b) - (unsigned)(a)) > 0)
156 /* pattern list to match, in "aa\0bb\0\cc\0\0" form */
164 unsigned rotate_period;
170 unsigned next_rotate;
171 char fnsave[FMT_PTIME];
187 unsigned nearest_rotate;
189 void* (*memRchr)(const void *, int, size_t);
195 smallint linecomplete;
203 sigset_t blocked_sigset;
205 #define G (*ptr_to_globals)
207 #define verbose (G.verbose )
208 #define linemax (G.linemax )
209 #define buflen (G.buflen )
210 #define linelen (G.linelen )
211 #define fndir (G.fndir )
212 #define fdwdir (G.fdwdir )
213 #define wstat (G.wstat )
214 #define memRchr (G.memRchr )
215 #define nearest_rotate (G.nearest_rotate)
216 #define exitasap (G.exitasap )
217 #define rotateasap (G.rotateasap )
218 #define reopenasap (G.reopenasap )
219 #define linecomplete (G.linecomplete )
220 #define tmaxflag (G.tmaxflag )
221 #define repl (G.repl )
222 #define replace (G.replace )
223 #define blocked_sigset (G.blocked_sigset)
224 #define fl_flag_0 (G.fl_flag_0 )
225 #define dirn (G.dirn )
226 #define INIT_G() do { \
227 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
234 #define line bb_common_bufsiz1
237 #define FATAL "fatal: "
238 #define WARNING "warning: "
239 #define PAUSE "pausing: "
240 #define INFO "info: "
242 static void fatalx(const char *m0)
244 bb_error_msg_and_die(FATAL"%s", m0);
246 static void warn(const char *m0)
248 bb_perror_msg(WARNING"%s", m0);
250 static void warn2(const char *m0, const char *m1)
252 bb_perror_msg(WARNING"%s: %s", m0, m1);
254 static void warnx(const char *m0, const char *m1)
256 bb_error_msg(WARNING"%s: %s", m0, m1);
258 static void pause_nomem(void)
260 bb_error_msg(PAUSE"out of memory");
263 static void pause1cannot(const char *m0)
265 bb_perror_msg(PAUSE"can't %s", m0);
268 static void pause2cannot(const char *m0, const char *m1)
270 bb_perror_msg(PAUSE"can't %s %s", m0, m1);
274 static char* wstrdup(const char *str)
277 while (!(s = strdup(str)))
282 static unsigned pmatch(const char *p, const char *s, unsigned len)
300 if (c != *s) return 0;
311 if (*s != '?') return 0;
319 if (*s != c) return 0;
328 /*** ex fmt_ptime.[ch] ***/
331 static void fmt_time_human_30nul(char *s)
336 gettimeofday(&tv, NULL);
337 ptm = gmtime(&tv.tv_sec);
338 sprintf(s, "%04u-%02u-%02u_%02u:%02u:%02u.%06u000",
339 (unsigned)(1900 + ptm->tm_year),
340 (unsigned)(ptm->tm_mon + 1),
341 (unsigned)(ptm->tm_mday),
342 (unsigned)(ptm->tm_hour),
343 (unsigned)(ptm->tm_min),
344 (unsigned)(ptm->tm_sec),
345 (unsigned)(tv.tv_usec)
347 /* 4+1 + 2+1 + 2+1 + 2+1 + 2+1 + 2+1 + 9 = */
348 /* 5 + 3 + 3 + 3 + 3 + 3 + 9 = */
349 /* 20 (up to '.' inclusive) + 9 (not including '\0') */
352 /* NOT terminated! */
353 static void fmt_time_bernstein_25(char *s)
359 gettimeofday(&tv, NULL);
360 sec_hi = (0x400000000000000aULL + tv.tv_sec) >> 32;
361 tv.tv_sec = (time_t)(0x400000000000000aULL) + tv.tv_sec;
363 /* Network order is big-endian: most significant byte first.
364 * This is exactly what we want here */
365 pack[0] = htonl(sec_hi);
366 pack[1] = htonl(tv.tv_sec);
367 pack[2] = htonl(tv.tv_usec);
369 bin2hex(s, (char*)pack, 12);
372 static void processorstart(struct logdir *ld)
377 if (!ld->processor) return;
379 warnx("processor already running", ld->name);
383 /* vfork'ed child trashes this byte, save... */
384 sv_ch = ld->fnsave[26];
387 G.shell = xstrdup(get_shell_name());
389 while ((pid = vfork()) == -1)
390 pause2cannot("vfork for processor", ld->name);
395 /* Non-ignored signals revert to SIG_DFL on exec anyway */
401 sig_unblock(SIGTERM);
402 sig_unblock(SIGALRM);
406 bb_error_msg(INFO"processing: %s/%s", ld->name, ld->fnsave);
407 fd = xopen(ld->fnsave, O_RDONLY|O_NDELAY);
409 ld->fnsave[26] = 't'; /* <- that's why we need sv_ch! */
410 fd = xopen(ld->fnsave, O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
412 fd = open("state", O_RDONLY|O_NDELAY);
415 bb_perror_msg_and_die(FATAL"can't %s processor %s", "open state for", ld->name);
416 close(xopen("state", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT));
417 fd = xopen("state", O_RDONLY|O_NDELAY);
420 fd = xopen("newstate", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
423 execl(G.shell, G.shell, "-c", ld->processor, (char*) NULL);
424 bb_perror_msg_and_die(FATAL"can't %s processor %s", "run", ld->name);
426 ld->fnsave[26] = sv_ch; /* ...restore */
430 static unsigned processorstop(struct logdir *ld)
436 while (safe_waitpid(ld->ppid, &wstat, 0) == -1)
437 pause2cannot("wait for processor", ld->name);
443 while (fchdir(ld->fddir) == -1)
444 pause2cannot("change directory, want processor", ld->name);
445 if (WEXITSTATUS(wstat) != 0) {
446 warnx("processor failed, restart", ld->name);
447 ld->fnsave[26] = 't';
449 ld->fnsave[26] = 'u';
451 while (fchdir(fdwdir) == -1)
452 pause1cannot("change to initial working directory");
453 return ld->processor ? 0 : 1;
455 ld->fnsave[26] = 't';
456 memcpy(f, ld->fnsave, 26);
459 while (rename(ld->fnsave, f) == -1)
460 pause2cannot("rename processed", ld->name);
461 while (chmod(f, 0744) == -1)
462 pause2cannot("set mode of processed", ld->name);
463 ld->fnsave[26] = 'u';
464 if (unlink(ld->fnsave) == -1)
465 bb_error_msg(WARNING"can't unlink: %s/%s", ld->name, ld->fnsave);
466 while (rename("newstate", "state") == -1)
467 pause2cannot("rename state", ld->name);
469 bb_error_msg(INFO"processed: %s/%s", ld->name, f);
470 while (fchdir(fdwdir) == -1)
471 pause1cannot("change to initial working directory");
475 static void rmoldest(struct logdir *ld)
479 char oldest[FMT_PTIME];
482 oldest[0] = 'A'; oldest[1] = oldest[27] = 0;
483 while (!(d = opendir(".")))
484 pause2cannot("open directory, want rotate", ld->name);
486 while ((f = readdir(d))) {
487 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
488 if (f->d_name[26] == 't') {
489 if (unlink(f->d_name) == -1)
490 warn2("can't unlink processor leftover", f->d_name);
493 if (strcmp(f->d_name, oldest) < 0)
494 memcpy(oldest, f->d_name, 27);
500 warn2("can't read directory", ld->name);
503 if (ld->nmax && (n > ld->nmax)) {
505 bb_error_msg(INFO"delete: %s/%s", ld->name, oldest);
506 if ((*oldest == '@') && (unlink(oldest) == -1))
507 warn2("can't unlink oldest logfile", ld->name);
511 static unsigned rotate(struct logdir *ld)
516 if (ld->fddir == -1) {
517 ld->rotate_period = 0;
521 while (!processorstop(ld))
524 while (fchdir(ld->fddir) == -1)
525 pause2cannot("change directory, want rotate", ld->name);
527 /* create new filename */
528 ld->fnsave[25] = '.';
529 ld->fnsave[26] = 's';
531 ld->fnsave[26] = 'u';
532 ld->fnsave[27] = '\0';
534 fmt_time_bernstein_25(ld->fnsave);
536 stat(ld->fnsave, &st);
537 } while (errno != ENOENT);
539 now = monotonic_sec();
540 if (ld->rotate_period && LESS(ld->next_rotate, now)) {
541 ld->next_rotate = now + ld->rotate_period;
542 if (LESS(ld->next_rotate, nearest_rotate))
543 nearest_rotate = ld->next_rotate;
547 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
548 pause2cannot("fsync current logfile", ld->name);
549 while (fchmod(ld->fdcur, 0744) == -1)
550 pause2cannot("set mode of current", ld->name);
551 ////close(ld->fdcur);
555 bb_error_msg(INFO"rename: %s/current %s %u", ld->name,
556 ld->fnsave, ld->size);
558 while (rename("current", ld->fnsave) == -1)
559 pause2cannot("rename current", ld->name);
560 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
561 pause2cannot("create new current", ld->name);
562 while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL) ////
563 pause2cannot("create new current", ld->name); /* very unlikely */
564 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
565 close_on_exec_on(ld->fdcur);
567 while (fchmod(ld->fdcur, 0644) == -1)
568 pause2cannot("set mode of current", ld->name);
574 while (fchdir(fdwdir) == -1)
575 pause1cannot("change to initial working directory");
579 static int buffer_pwrite(int n, char *s, unsigned len)
582 struct logdir *ld = &dir[n];
585 if (ld->size >= ld->sizemax)
587 if (len > (ld->sizemax - ld->size))
588 len = ld->sizemax - ld->size;
591 ////i = full_write(ld->fdcur, s, len);
592 ////if (i != -1) break;
593 i = fwrite(s, 1, len, ld->filecur);
596 if ((errno == ENOSPC) && (ld->nmin < ld->nmax)) {
599 char oldest[FMT_PTIME];
602 while (fchdir(ld->fddir) == -1)
603 pause2cannot("change directory, want remove old logfile",
606 oldest[1] = oldest[27] = '\0';
607 while (!(d = opendir(".")))
608 pause2cannot("open directory, want remove old logfile",
611 while ((f = readdir(d)))
612 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
614 if (strcmp(f->d_name, oldest) < 0)
615 memcpy(oldest, f->d_name, 27);
617 if (errno) warn2("can't read directory, want remove old logfile",
622 if (*oldest == '@') {
623 bb_error_msg(WARNING"out of disk space, delete: %s/%s",
626 if (unlink(oldest) == -1) {
627 warn2("can't unlink oldest logfile", ld->name);
630 while (fchdir(fdwdir) == -1)
631 pause1cannot("change to initial working directory");
636 pause2cannot("write to current", ld->name);
642 if (ld->size >= (ld->sizemax - linemax))
647 static void logdir_close(struct logdir *ld)
652 bb_error_msg(INFO"close: %s", ld->name);
656 return; /* impossible */
657 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
658 pause2cannot("fsync current logfile", ld->name);
659 while (fchmod(ld->fdcur, 0744) == -1)
660 pause2cannot("set mode of current", ld->name);
661 ////close(ld->fdcur);
664 if (ld->fdlock == -1)
665 return; /* impossible */
669 ld->processor = NULL;
672 static NOINLINE unsigned logdir_open(struct logdir *ld, const char *fn)
680 now = monotonic_sec();
682 ld->fddir = open(fn, O_RDONLY|O_NDELAY);
683 if (ld->fddir == -1) {
684 warn2("can't open log directory", (char*)fn);
687 close_on_exec_on(ld->fddir);
688 if (fchdir(ld->fddir) == -1) {
690 warn2("can't change directory", (char*)fn);
693 ld->fdlock = open("lock", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
694 if ((ld->fdlock == -1)
695 || (flock(ld->fdlock, LOCK_EX | LOCK_NB) == -1)
698 warn2("can't lock directory", (char*)fn);
699 while (fchdir(fdwdir) == -1)
700 pause1cannot("change to initial working directory");
703 close_on_exec_on(ld->fdlock);
706 ld->sizemax = 1000000;
707 ld->nmax = ld->nmin = 10;
708 ld->rotate_period = 0;
709 ld->name = (char*)fn;
712 free(ld->inst); ld->inst = NULL;
713 free(ld->processor); ld->processor = NULL;
716 i = open_read_close("config", buf, sizeof(buf) - 1);
717 if (i < 0 && errno != ENOENT)
718 bb_perror_msg(WARNING"%s/config", ld->name);
722 bb_error_msg(INFO"read: %s/config", ld->name);
725 np = strchr(s, '\n');
733 /* Filtering requires one-line buffering,
734 * resetting the "find newline" function
737 /* Add '\n'-terminated line to ld->inst */
739 int l = asprintf(&new, "%s%s\n", ld->inst ? ld->inst : "", s);
748 static const struct suffix_mult km_suffixes[] = {
753 ld->sizemax = xatou_sfx(&s[1], km_suffixes);
757 ld->nmax = xatoi_positive(&s[1]);
760 ld->nmin = xatoi_positive(&s[1]);
763 static const struct suffix_mult mh_suffixes[] = {
766 /*{ "d", 24*60*60 },*/
769 ld->rotate_period = xatou_sfx(&s[1], mh_suffixes);
770 if (ld->rotate_period) {
771 ld->next_rotate = now + ld->rotate_period;
772 if (!tmaxflag || LESS(ld->next_rotate, nearest_rotate))
773 nearest_rotate = ld->next_rotate;
781 ld->processor = wstrdup(s);
787 /* Convert "aa\nbb\ncc\n\0" to "aa\0bb\0cc\0\0" */
790 np = strchr(s, '\n');
798 i = stat("current", &st);
800 if (st.st_size && !(st.st_mode & S_IXUSR)) {
801 ld->fnsave[25] = '.';
802 ld->fnsave[26] = 'u';
803 ld->fnsave[27] = '\0';
805 fmt_time_bernstein_25(ld->fnsave);
807 stat(ld->fnsave, &st);
808 } while (errno != ENOENT);
809 while (rename("current", ld->fnsave) == -1)
810 pause2cannot("rename current", ld->name);
814 /* st.st_size can be not just bigger, but WIDER!
815 * This code is safe: if st.st_size > 4GB, we select
816 * ld->sizemax (because it's "unsigned") */
817 ld->size = (st.st_size > ld->sizemax) ? ld->sizemax : st.st_size;
820 if (errno != ENOENT) {
822 warn2("can't stat current", ld->name);
823 while (fchdir(fdwdir) == -1)
824 pause1cannot("change to initial working directory");
828 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
829 pause2cannot("open current", ld->name);
830 while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL)
831 pause2cannot("open current", ld->name); ////
832 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
834 close_on_exec_on(ld->fdcur);
835 while (fchmod(ld->fdcur, 0644) == -1)
836 pause2cannot("set mode of current", ld->name);
839 if (i == 0) bb_error_msg(INFO"append: %s/current", ld->name);
840 else bb_error_msg(INFO"new: %s/current", ld->name);
843 while (fchdir(fdwdir) == -1)
844 pause1cannot("change to initial working directory");
848 static void logdirs_reopen(void)
854 for (l = 0; l < dirn; ++l) {
855 logdir_close(&dir[l]);
856 if (logdir_open(&dir[l], fndir[l]))
860 fatalx("no functional log directories");
863 /* Will look good in libbb one day */
864 static ssize_t ndelay_read(int fd, void *buf, size_t count)
866 if (!(fl_flag_0 & O_NONBLOCK))
867 fcntl(fd, F_SETFL, fl_flag_0 | O_NONBLOCK);
868 count = safe_read(fd, buf, count);
869 if (!(fl_flag_0 & O_NONBLOCK))
870 fcntl(fd, F_SETFL, fl_flag_0);
874 /* Used for reading stdin */
875 static int buffer_pread(/*int fd, */char *s, unsigned len)
881 input.fd = STDIN_FILENO;
882 input.events = POLLIN;
886 for (i = 0; i < dirn; ++i)
899 now = monotonic_sec();
900 nearest_rotate = now + (45 * 60 + 45);
901 for (i = 0; i < dirn; ++i) {
902 if (dir[i].rotate_period) {
903 if (LESS(dir[i].next_rotate, now))
905 if (LESS(dir[i].next_rotate, nearest_rotate))
906 nearest_rotate = dir[i].next_rotate;
910 sigprocmask(SIG_UNBLOCK, &blocked_sigset, NULL);
911 i = nearest_rotate - now;
916 poll(&input, 1, i * 1000);
917 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
919 i = ndelay_read(STDIN_FILENO, s, len);
924 if (errno != EAGAIN) {
925 warn("can't read standard input");
928 /* else: EAGAIN - normal, repeat silently */
933 linecomplete = (s[i-1] == '\n');
941 if (ch < 32 || ch > 126)
945 for (j = 0; replace[j]; ++j) {
946 if (ch == replace[j]) {
959 static void sig_term_handler(int sig_no UNUSED_PARAM)
962 bb_error_msg(INFO"sig%s received", "term");
966 static void sig_child_handler(int sig_no UNUSED_PARAM)
972 bb_error_msg(INFO"sig%s received", "child");
973 while ((pid = wait_any_nohang(&wstat)) > 0) {
974 for (l = 0; l < dirn; ++l) {
975 if (dir[l].ppid == pid) {
977 processorstop(&dir[l]);
984 static void sig_alarm_handler(int sig_no UNUSED_PARAM)
987 bb_error_msg(INFO"sig%s received", "alarm");
991 static void sig_hangup_handler(int sig_no UNUSED_PARAM)
994 bb_error_msg(INFO"sig%s received", "hangup");
998 static void logmatch(struct logdir *ld)
1009 if (pmatch(s+1, line, linelen))
1014 if (pmatch(s+1, line, linelen))
1015 ld->matcherr = s[0];
1022 int svlogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1023 int svlogd_main(int argc, char **argv)
1026 ssize_t stdin_cnt = 0;
1029 unsigned timestamp = 0;
1033 opt_complementary = "tt:vv";
1034 opt = getopt32(argv, "r:R:l:b:tv",
1035 &r, &replace, &l, &b, ×tamp, &verbose);
1036 if (opt & 1) { // -r
1041 if (opt & 2) if (!repl) repl = '_'; // -R
1042 if (opt & 4) { // -l
1043 linemax = xatou_range(l, 0, BUFSIZ-26);
1045 linemax = BUFSIZ-26;
1049 ////if (opt & 8) { // -b
1050 //// buflen = xatoi_positive(b);
1051 //// if (buflen == 0) buflen = 1024;
1053 //if (opt & 0x10) timestamp++; // -t
1054 //if (opt & 0x20) verbose++; // -v
1055 //if (timestamp > 2) timestamp = 2;
1062 ////if (buflen <= linemax) bb_show_usage();
1063 fdwdir = xopen(".", O_RDONLY|O_NDELAY);
1064 close_on_exec_on(fdwdir);
1065 dir = xzalloc(dirn * sizeof(dir[0]));
1066 for (i = 0; i < dirn; ++i) {
1069 ////dir[i].btmp = xmalloc(buflen);
1070 /*dir[i].ppid = 0;*/
1072 /* line = xmalloc(linemax + (timestamp ? 26 : 0)); */
1074 /* We cannot set NONBLOCK on fd #0 permanently - this setting
1075 * _isn't_ per-process! It is shared among all other processes
1076 * with the same stdin */
1077 fl_flag_0 = fcntl(0, F_GETFL);
1079 sigemptyset(&blocked_sigset);
1080 sigaddset(&blocked_sigset, SIGTERM);
1081 sigaddset(&blocked_sigset, SIGCHLD);
1082 sigaddset(&blocked_sigset, SIGALRM);
1083 sigaddset(&blocked_sigset, SIGHUP);
1084 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
1085 bb_signals_recursive_norestart(1 << SIGTERM, sig_term_handler);
1086 bb_signals_recursive_norestart(1 << SIGCHLD, sig_child_handler);
1087 bb_signals_recursive_norestart(1 << SIGALRM, sig_alarm_handler);
1088 bb_signals_recursive_norestart(1 << SIGHUP, sig_hangup_handler);
1090 /* Without timestamps, we don't have to print each line
1091 * separately, so we can look for _last_ newline, not first,
1092 * thus batching writes. If filtering is enabled in config,
1093 * logdirs_reopen resets it to memchr.
1095 memRchr = (timestamp ? memchr : memrchr);
1099 setvbuf(stderr, NULL, _IOFBF, linelen);
1101 /* Each iteration processes one or more lines */
1103 char stamp[FMT_PTIME];
1114 /* lineptr[0..linemax-1] - buffer for stdin */
1115 /* (possibly has some unprocessed data from prev loop) */
1117 /* Refill the buffer if needed */
1118 np = memRchr(lineptr, '\n', stdin_cnt);
1119 if (!np && !exitasap) {
1120 i = linemax - stdin_cnt; /* avail. bytes at tail */
1122 i = buffer_pread(/*0, */lineptr + stdin_cnt, i);
1123 if (i <= 0) /* EOF or error on stdin */
1126 np = memRchr(lineptr + stdin_cnt, '\n', i);
1131 if (stdin_cnt <= 0 && exitasap)
1134 /* Search for '\n' (in fact, np already holds the result) */
1135 linelen = stdin_cnt;
1138 /* NB: starting from here lineptr may point
1139 * farther out into line[] */
1140 linelen = np - lineptr + 1;
1142 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
1143 ch = lineptr[linelen-1];
1145 /* Biggest performance hit was coming from the fact
1146 * that we did not buffer writes. We were reading many lines
1147 * in one read() above, but wrote one line per write().
1148 * We are using stdio to fix that */
1150 /* write out lineptr[0..linelen-1] to each log destination
1151 * (or lineptr[-26..linelen-1] if timestamping) */
1156 fmt_time_bernstein_25(stamp);
1158 fmt_time_human_30nul(stamp);
1161 memcpy(printptr, stamp, 25);
1164 for (i = 0; i < dirn; ++i) {
1165 struct logdir *ld = &dir[i];
1166 if (ld->fddir == -1)
1170 if (ld->matcherr == 'e') {
1171 /* runit-1.8.0 compat: if timestamping, do it on stderr too */
1172 ////full_write(STDERR_FILENO, printptr, printlen);
1173 fwrite(printptr, 1, printlen, stderr);
1175 if (ld->match != '+')
1177 buffer_pwrite(i, printptr, printlen);
1180 /* If we didn't see '\n' (long input line), */
1181 /* read/write repeatedly until we see it */
1182 while (ch != '\n') {
1183 /* lineptr is emptied now, safe to use as buffer */
1184 stdin_cnt = exitasap ? -1 : buffer_pread(/*0, */lineptr, linemax);
1185 if (stdin_cnt <= 0) { /* EOF or error on stdin */
1187 lineptr[0] = ch = '\n';
1191 linelen = stdin_cnt;
1192 np = memRchr(lineptr, '\n', stdin_cnt);
1194 linelen = np - lineptr + 1;
1195 ch = lineptr[linelen-1];
1197 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
1198 for (i = 0; i < dirn; ++i) {
1199 if (dir[i].fddir == -1)
1201 if (dir[i].matcherr == 'e') {
1202 ////full_write(STDERR_FILENO, lineptr, linelen);
1203 fwrite(lineptr, 1, linelen, stderr);
1205 if (dir[i].match != '+')
1207 buffer_pwrite(i, lineptr, linelen);
1211 stdin_cnt -= linelen;
1212 if (stdin_cnt > 0) {
1214 /* If we see another '\n', we don't need to read
1215 * next piece of input: can print what we have */
1216 np = memRchr(lineptr, '\n', stdin_cnt);
1219 /* Move unprocessed data to the front of line */
1220 memmove((timestamp ? line+26 : line), lineptr, stdin_cnt);
1225 for (i = 0; i < dirn; ++i) {
1227 while (!processorstop(&dir[i]))
1229 logdir_close(&dir[i]);