?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Tomato 1.28
[tomato.git] / release / src / router / busybox / runit / svlogd.c
blob9609fa37c72d6a30ab753cb84ce96d721cf1024a
1 /*
2 Copyright (c) 2001-2006, Gerrit Pape
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7
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.
15
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.
26 */
27
28 /* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
29 /* TODO: depends on runit_lib.c - review and reduce/eliminate */
30
31 #include <sys/poll.h>
32 #include <sys/file.h>
33 #include "libbb.h"
34 #include "runit_lib.h"
35
36 #define LESS(a,b) ((int)((unsigned)(b) - (unsigned)(a)) > 0)
37
38 #define FMT_PTIME 30
39
40 struct logdir {
41 ////char *btmp;
42 /* pattern list to match, in "aa\0bb\0\cc\0\0" form */
43 char *inst;
44 char *processor;
45 char *name;
46 unsigned size;
47 unsigned sizemax;
48 unsigned nmax;
49 unsigned nmin;
50 unsigned rotate_period;
51 int ppid;
52 int fddir;
53 int fdcur;
54 FILE* filecur; ////
55 int fdlock;
56 unsigned next_rotate;
57 char fnsave[FMT_PTIME];
58 char match;
59 char matcherr;
60 };
61
62
63 struct globals {
64 struct logdir *dir;
65 unsigned verbose;
66 int linemax;
67 ////int buflen;
68 int linelen;
69
70 int fdwdir;
71 char **fndir;
72 int wstat;
73 unsigned nearest_rotate;
74
75 smallint exitasap;
76 smallint rotateasap;
77 smallint reopenasap;
78 smallint linecomplete;
79 smallint tmaxflag;
80
81 char repl;
82 const char *replace;
83 int fl_flag_0;
84 unsigned dirn;
85
86 sigset_t blocked_sigset;
87 };
88 #define G (*(struct globals*)ptr_to_globals)
89 #define dir (G.dir )
90 #define verbose (G.verbose )
91 #define linemax (G.linemax )
92 #define buflen (G.buflen )
93 #define linelen (G.linelen )
94 #define fndir (G.fndir )
95 #define fdwdir (G.fdwdir )
96 #define wstat (G.wstat )
97 #define nearest_rotate (G.nearest_rotate)
98 #define exitasap (G.exitasap )
99 #define rotateasap (G.rotateasap )
100 #define reopenasap (G.reopenasap )
101 #define linecomplete (G.linecomplete )
102 #define tmaxflag (G.tmaxflag )
103 #define repl (G.repl )
104 #define replace (G.replace )
105 #define blocked_sigset (G.blocked_sigset)
106 #define fl_flag_0 (G.fl_flag_0 )
107 #define dirn (G.dirn )
108 #define INIT_G() do { \
109 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
110 linemax = 1000; \
111 /*buflen = 1024;*/ \
112 linecomplete = 1; \
113 replace = ""; \
114 } while (0)
115
116 #define line bb_common_bufsiz1
117
118
119 #define FATAL "fatal: "
120 #define WARNING "warning: "
121 #define PAUSE "pausing: "
122 #define INFO "info: "
123
124 #define usage() bb_show_usage()
125 static void fatalx(const char *m0)
126 {
127 bb_error_msg_and_die(FATAL"%s", m0);
128 }
129 static void warn(const char *m0)
130 {
131 bb_perror_msg(WARNING"%s", m0);
132 }
133 static void warn2(const char *m0, const char *m1)
134 {
135 bb_perror_msg(WARNING"%s: %s", m0, m1);
136 }
137 static void warnx(const char *m0, const char *m1)
138 {
139 bb_error_msg(WARNING"%s: %s", m0, m1);
140 }
141 static void pause_nomem(void)
142 {
143 bb_error_msg(PAUSE"out of memory");
144 sleep(3);
145 }
146 static void pause1cannot(const char *m0)
147 {
148 bb_perror_msg(PAUSE"can't %s", m0);
149 sleep(3);
150 }
151 static void pause2cannot(const char *m0, const char *m1)
152 {
153 bb_perror_msg(PAUSE"can't %s %s", m0, m1);
154 sleep(3);
155 }
156
157 static char* wstrdup(const char *str)
158 {
159 char *s;
160 while (!(s = strdup(str)))
161 pause_nomem();
162 return s;
163 }
164
165 /*** ex fmt_ptime.[ch] ***/
166
167 /* NUL terminated */
168 static void fmt_time_human_30nul(char *s)
169 {
170 struct tm *t;
171 struct timeval tv;
172
173 gettimeofday(&tv, NULL);
174 t = gmtime(&(tv.tv_sec));
175 sprintf(s, "%04u-%02u-%02u_%02u:%02u:%02u.%06u000",
176 (unsigned)(1900 + t->tm_year),
177 (unsigned)(t->tm_mon + 1),
178 (unsigned)(t->tm_mday),
179 (unsigned)(t->tm_hour),
180 (unsigned)(t->tm_min),
181 (unsigned)(t->tm_sec),
182 (unsigned)(tv.tv_usec)
183 );
184 /* 4+1 + 2+1 + 2+1 + 2+1 + 2+1 + 2+1 + 9 = */
185 /* 5 + 3 + 3 + 3 + 3 + 3 + 9 = */
186 /* 20 (up to '.' inclusive) + 9 (not including '\0') */
187 }
188
189 /* NOT terminated! */
190 static void fmt_time_bernstein_25(char *s)
191 {
192 uint32_t pack[3];
193 struct timeval tv;
194 unsigned sec_hi;
195
196 gettimeofday(&tv, NULL);
197 sec_hi = (0x400000000000000aULL + tv.tv_sec) >> 32;
198 tv.tv_sec = (time_t)(0x400000000000000aULL) + tv.tv_sec;
199 tv.tv_usec *= 1000;
200 /* Network order is big-endian: most significant byte first.
201 * This is exactly what we want here */
202 pack[0] = htonl(sec_hi);
203 pack[1] = htonl(tv.tv_sec);
204 pack[2] = htonl(tv.tv_usec);
205 *s++ = '@';
206 bin2hex(s, (char*)pack, 12);
207 }
208
209 static void processorstart(struct logdir *ld)
210 {
211 char sv_ch;
212 int pid;
213
214 if (!ld->processor) return;
215 if (ld->ppid) {
216 warnx("processor already running", ld->name);
217 return;
218 }
219
220 /* vfork'ed child trashes this byte, save... */
221 sv_ch = ld->fnsave[26];
222
223 while ((pid = vfork()) == -1)
224 pause2cannot("vfork for processor", ld->name);
225 if (!pid) {
226 char *prog[4];
227 int fd;
228
229 /* child */
230 /* Non-ignored signals revert to SIG_DFL on exec anyway */
231 /*bb_signals(0
232 + (1 << SIGTERM)
233 + (1 << SIGALRM)
234 + (1 << SIGHUP)
235 , SIG_DFL);*/
236 sig_unblock(SIGTERM);
237 sig_unblock(SIGALRM);
238 sig_unblock(SIGHUP);
239
240 if (verbose)
241 bb_error_msg(INFO"processing: %s/%s", ld->name, ld->fnsave);
242 fd = xopen(ld->fnsave, O_RDONLY|O_NDELAY);
243 xmove_fd(fd, 0);
244 ld->fnsave[26] = 't'; /* <- that's why we need sv_ch! */
245 fd = xopen(ld->fnsave, O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
246 xmove_fd(fd, 1);
247 fd = open_read("state");
248 if (fd == -1) {
249 if (errno != ENOENT)
250 bb_perror_msg_and_die(FATAL"can't %s processor %s", "open state for", ld->name);
251 close(xopen("state", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT));
252 fd = xopen("state", O_RDONLY|O_NDELAY);
253 }
254 xmove_fd(fd, 4);
255 fd = xopen("newstate", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
256 xmove_fd(fd, 5);
257
258 // getenv("SHELL")?
259 prog[0] = (char*)"sh";
260 prog[1] = (char*)"-c";
261 prog[2] = ld->processor;
262 prog[3] = NULL;
263 execv("/bin/sh", prog);
264 bb_perror_msg_and_die(FATAL"can't %s processor %s", "run", ld->name);
265 }
266 ld->fnsave[26] = sv_ch; /* ...restore */
267 ld->ppid = pid;
268 }
269
270 static unsigned processorstop(struct logdir *ld)
271 {
272 char f[28];
273
274 if (ld->ppid) {
275 sig_unblock(SIGHUP);
276 while (safe_waitpid(ld->ppid, &wstat, 0) == -1)
277 pause2cannot("wait for processor", ld->name);
278 sig_block(SIGHUP);
279 ld->ppid = 0;
280 }
281 if (ld->fddir == -1) return 1;
282 while (fchdir(ld->fddir) == -1)
283 pause2cannot("change directory, want processor", ld->name);
284 if (wait_exitcode(wstat) != 0) {
285 warnx("processor failed, restart", ld->name);
286 ld->fnsave[26] = 't';
287 unlink(ld->fnsave);
288 ld->fnsave[26] = 'u';
289 processorstart(ld);
290 while (fchdir(fdwdir) == -1)
291 pause1cannot("change to initial working directory");
292 return ld->processor ? 0 : 1;
293 }
294 ld->fnsave[26] = 't';
295 memcpy(f, ld->fnsave, 26);
296 f[26] = 's';
297 f[27] = '\0';
298 while (rename(ld->fnsave, f) == -1)
299 pause2cannot("rename processed", ld->name);
300 while (chmod(f, 0744) == -1)
301 pause2cannot("set mode of processed", ld->name);
302 ld->fnsave[26] = 'u';
303 if (unlink(ld->fnsave) == -1)
304 bb_error_msg(WARNING"can't unlink: %s/%s", ld->name, ld->fnsave);
305 while (rename("newstate", "state") == -1)
306 pause2cannot("rename state", ld->name);
307 if (verbose)
308 bb_error_msg(INFO"processed: %s/%s", ld->name, f);
309 while (fchdir(fdwdir) == -1)
310 pause1cannot("change to initial working directory");
311 return 1;
312 }
313
314 static void rmoldest(struct logdir *ld)
315 {
316 DIR *d;
317 struct dirent *f;
318 char oldest[FMT_PTIME];
319 int n = 0;
320
321 oldest[0] = 'A'; oldest[1] = oldest[27] = 0;
322 while (!(d = opendir(".")))
323 pause2cannot("open directory, want rotate", ld->name);
324 errno = 0;
325 while ((f = readdir(d))) {
326 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
327 if (f->d_name[26] == 't') {
328 if (unlink(f->d_name) == -1)
329 warn2("can't unlink processor leftover", f->d_name);
330 } else {
331 ++n;
332 if (strcmp(f->d_name, oldest) < 0)
333 memcpy(oldest, f->d_name, 27);
334 }
335 errno = 0;
336 }
337 }
338 if (errno)
339 warn2("can't read directory", ld->name);
340 closedir(d);
341
342 if (ld->nmax && (n > ld->nmax)) {
343 if (verbose)
344 bb_error_msg(INFO"delete: %s/%s", ld->name, oldest);
345 if ((*oldest == '@') && (unlink(oldest) == -1))
346 warn2("can't unlink oldest logfile", ld->name);
347 }
348 }
349
350 static unsigned rotate(struct logdir *ld)
351 {
352 struct stat st;
353 unsigned now;
354
355 if (ld->fddir == -1) {
356 ld->rotate_period = 0;
357 return 0;
358 }
359 if (ld->ppid)
360 while (!processorstop(ld))
361 continue;
362
363 while (fchdir(ld->fddir) == -1)
364 pause2cannot("change directory, want rotate", ld->name);
365
366 /* create new filename */
367 ld->fnsave[25] = '.';
368 ld->fnsave[26] = 's';
369 if (ld->processor)
370 ld->fnsave[26] = 'u';
371 ld->fnsave[27] = '\0';
372 do {
373 fmt_time_bernstein_25(ld->fnsave);
374 errno = 0;
375 stat(ld->fnsave, &st);
376 } while (errno != ENOENT);
377
378 now = monotonic_sec();
379 if (ld->rotate_period && LESS(ld->next_rotate, now)) {
380 ld->next_rotate = now + ld->rotate_period;
381 if (LESS(ld->next_rotate, nearest_rotate))
382 nearest_rotate = ld->next_rotate;
383 }
384
385 if (ld->size > 0) {
386 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
387 pause2cannot("fsync current logfile", ld->name);
388 while (fchmod(ld->fdcur, 0744) == -1)
389 pause2cannot("set mode of current", ld->name);
390 ////close(ld->fdcur);
391 fclose(ld->filecur);
392
393 if (verbose) {
394 bb_error_msg(INFO"rename: %s/current %s %u", ld->name,
395 ld->fnsave, ld->size);
396 }
397 while (rename("current", ld->fnsave) == -1)
398 pause2cannot("rename current", ld->name);
399 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
400 pause2cannot("create new current", ld->name);
401 /* we presume this cannot fail */
402 ld->filecur = fdopen(ld->fdcur, "a"); ////
403 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
404 close_on_exec_on(ld->fdcur);
405 ld->size = 0;
406 while (fchmod(ld->fdcur, 0644) == -1)
407 pause2cannot("set mode of current", ld->name);
408 rmoldest(ld);
409 processorstart(ld);
410 }
411
412 while (fchdir(fdwdir) == -1)
413 pause1cannot("change to initial working directory");
414 return 1;
415 }
416
417 static int buffer_pwrite(int n, char *s, unsigned len)
418 {
419 int i;
420 struct logdir *ld = &dir[n];
421
422 if (ld->sizemax) {
423 if (ld->size >= ld->sizemax)
424 rotate(ld);
425 if (len > (ld->sizemax - ld->size))
426 len = ld->sizemax - ld->size;
427 }
428 while (1) {
429 ////i = full_write(ld->fdcur, s, len);
430 ////if (i != -1) break;
431 i = fwrite(s, 1, len, ld->filecur);
432 if (i == len) break;
433
434 if ((errno == ENOSPC) && (ld->nmin < ld->nmax)) {
435 DIR *d;
436 struct dirent *f;
437 char oldest[FMT_PTIME];
438 int j = 0;
439
440 while (fchdir(ld->fddir) == -1)
441 pause2cannot("change directory, want remove old logfile",
442 ld->name);
443 oldest[0] = 'A';
444 oldest[1] = oldest[27] = '\0';
445 while (!(d = opendir(".")))
446 pause2cannot("open directory, want remove old logfile",
447 ld->name);
448 errno = 0;
449 while ((f = readdir(d)))
450 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
451 ++j;
452 if (strcmp(f->d_name, oldest) < 0)
453 memcpy(oldest, f->d_name, 27);
454 }
455 if (errno) warn2("can't read directory, want remove old logfile",
456 ld->name);
457 closedir(d);
458 errno = ENOSPC;
459 if (j > ld->nmin) {
460 if (*oldest == '@') {
461 bb_error_msg(WARNING"out of disk space, delete: %s/%s",
462 ld->name, oldest);
463 errno = 0;
464 if (unlink(oldest) == -1) {
465 warn2("can't unlink oldest logfile", ld->name);
466 errno = ENOSPC;
467 }
468 while (fchdir(fdwdir) == -1)
469 pause1cannot("change to initial working directory");
470 }
471 }
472 }
473 if (errno)
474 pause2cannot("write to current", ld->name);
475 }
476
477 ld->size += i;
478 if (ld->sizemax)
479 if (s[i-1] == '\n')
480 if (ld->size >= (ld->sizemax - linemax))
481 rotate(ld);
482 return i;
483 }
484
485 static void logdir_close(struct logdir *ld)
486 {
487 if (ld->fddir == -1)
488 return;
489 if (verbose)
490 bb_error_msg(INFO"close: %s", ld->name);
491 close(ld->fddir);
492 ld->fddir = -1;
493 if (ld->fdcur == -1)
494 return; /* impossible */
495 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
496 pause2cannot("fsync current logfile", ld->name);
497 while (fchmod(ld->fdcur, 0744) == -1)
498 pause2cannot("set mode of current", ld->name);
499 ////close(ld->fdcur);
500 fclose(ld->filecur);
501 ld->fdcur = -1;
502 if (ld->fdlock == -1)
503 return; /* impossible */
504 close(ld->fdlock);
505 ld->fdlock = -1;
506 free(ld->processor);
507 ld->processor = NULL;
508 }
509
510 static unsigned logdir_open(struct logdir *ld, const char *fn)
511 {
512 char buf[128];
513 unsigned now;
514 char *new, *s, *np;
515 int i;
516 struct stat st;
517
518 now = monotonic_sec();
519
520 ld->fddir = open(fn, O_RDONLY|O_NDELAY);
521 if (ld->fddir == -1) {
522 warn2("can't open log directory", (char*)fn);
523 return 0;
524 }
525 close_on_exec_on(ld->fddir);
526 if (fchdir(ld->fddir) == -1) {
527 logdir_close(ld);
528 warn2("can't change directory", (char*)fn);
529 return 0;
530 }
531 ld->fdlock = open("lock", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
532 if ((ld->fdlock == -1)
533 || (lock_exnb(ld->fdlock) == -1)
534 ) {
535 logdir_close(ld);
536 warn2("can't lock directory", (char*)fn);
537 while (fchdir(fdwdir) == -1)
538 pause1cannot("change to initial working directory");
539 return 0;
540 }
541 close_on_exec_on(ld->fdlock);
542
543 ld->size = 0;
544 ld->sizemax = 1000000;
545 ld->nmax = ld->nmin = 10;
546 ld->rotate_period = 0;
547 ld->name = (char*)fn;
548 ld->ppid = 0;
549 ld->match = '+';
550 free(ld->inst); ld->inst = NULL;
551 free(ld->processor); ld->processor = NULL;
552
553 /* read config */
554 i = open_read_close("config", buf, sizeof(buf));
555 if (i < 0 && errno != ENOENT)
556 bb_perror_msg(WARNING"%s/config", ld->name);
557 if (i > 0) {
558 if (verbose)
559 bb_error_msg(INFO"read: %s/config", ld->name);
560 s = buf;
561 while (s) {
562 np = strchr(s, '\n');
563 if (np)
564 *np++ = '\0';
565 switch (s[0]) {
566 case '+':
567 case '-':
568 case 'e':
569 case 'E':
570 /* Add '\n'-terminated line to ld->inst */
571 while (1) {
572 int l = asprintf(&new, "%s%s\n", ld->inst ? : "", s);
573 if (l >= 0 && new)
574 break;
575 pause_nomem();
576 }
577 free(ld->inst);
578 ld->inst = new;
579 break;
580 case 's': {
581 static const struct suffix_mult km_suffixes[] = {
582 { "k", 1024 },
583 { "m", 1024*1024 },
584 { }
585 };
586 ld->sizemax = xatou_sfx(&s[1], km_suffixes);
587 break;
588 }
589 case 'n':
590 ld->nmax = xatoi_u(&s[1]);
591 break;
592 case 'N':
593 ld->nmin = xatoi_u(&s[1]);
594 break;
595 case 't': {
596 static const struct suffix_mult mh_suffixes[] = {
597 { "m", 60 },
598 { "h", 60*60 },
599 /*{ "d", 24*60*60 },*/
600 { }
601 };
602 ld->rotate_period = xatou_sfx(&s[1], mh_suffixes);
603 if (ld->rotate_period) {
604 ld->next_rotate = now + ld->rotate_period;
605 if (!tmaxflag || LESS(ld->next_rotate, nearest_rotate))
606 nearest_rotate = ld->next_rotate;
607 tmaxflag = 1;
608 }
609 break;
610 }
611 case '!':
612 if (s[1]) {
613 free(ld->processor);
614 ld->processor = wstrdup(s);
615 }
616 break;
617 }
618 s = np;
619 }
620 /* Convert "aa\nbb\ncc\n\0" to "aa\0bb\0cc\0\0" */
621 s = ld->inst;
622 while (s) {
623 np = strchr(s, '\n');
624 if (np)
625 *np++ = '\0';
626 s = np;
627 }
628 }
629
630 /* open current */
631 i = stat("current", &st);
632 if (i != -1) {
633 if (st.st_size && !(st.st_mode & S_IXUSR)) {
634 ld->fnsave[25] = '.';
635 ld->fnsave[26] = 'u';
636 ld->fnsave[27] = '\0';
637 do {
638 fmt_time_bernstein_25(ld->fnsave);
639 errno = 0;
640 stat(ld->fnsave, &st);
641 } while (errno != ENOENT);
642 while (rename("current", ld->fnsave) == -1)
643 pause2cannot("rename current", ld->name);
644 rmoldest(ld);
645 i = -1;
646 } else {
647 /* st.st_size can be not just bigger, but WIDER!
648 * This code is safe: if st.st_size > 4GB, we select
649 * ld->sizemax (because it's "unsigned") */
650 ld->size = (st.st_size > ld->sizemax) ? ld->sizemax : st.st_size;
651 }
652 } else {
653 if (errno != ENOENT) {
654 logdir_close(ld);
655 warn2("can't stat current", ld->name);
656 while (fchdir(fdwdir) == -1)
657 pause1cannot("change to initial working directory");
658 return 0;
659 }
660 }
661 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
662 pause2cannot("open current", ld->name);
663 /* we presume this cannot fail */
664 ld->filecur = fdopen(ld->fdcur, "a"); ////
665 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
666
667 close_on_exec_on(ld->fdcur);
668 while (fchmod(ld->fdcur, 0644) == -1)
669 pause2cannot("set mode of current", ld->name);
670
671 if (verbose) {
672 if (i == 0) bb_error_msg(INFO"append: %s/current", ld->name);
673 else bb_error_msg(INFO"new: %s/current", ld->name);
674 }
675
676 while (fchdir(fdwdir) == -1)
677 pause1cannot("change to initial working directory");
678 return 1;
679 }
680
681 static void logdirs_reopen(void)
682 {
683 int l;
684 int ok = 0;
685
686 tmaxflag = 0;
687 for (l = 0; l < dirn; ++l) {
688 logdir_close(&dir[l]);
689 if (logdir_open(&dir[l], fndir[l]))
690 ok = 1;
691 }
692 if (!ok)
693 fatalx("no functional log directories");
694 }
695
696 /* Will look good in libbb one day */
697 static ssize_t ndelay_read(int fd, void *buf, size_t count)
698 {
699 if (!(fl_flag_0 & O_NONBLOCK))
700 fcntl(fd, F_SETFL, fl_flag_0 | O_NONBLOCK);
701 count = safe_read(fd, buf, count);
702 if (!(fl_flag_0 & O_NONBLOCK))
703 fcntl(fd, F_SETFL, fl_flag_0);
704 return count;
705 }
706
707 /* Used for reading stdin */
708 static int buffer_pread(/*int fd, */char *s, unsigned len)
709 {
710 unsigned now;
711 struct pollfd input;
712 int i;
713
714 input.fd = 0;
715 input.events = POLLIN;
716
717 do {
718 if (rotateasap) {
719 for (i = 0; i < dirn; ++i)
720 rotate(dir + i);
721 rotateasap = 0;
722 }
723 if (exitasap) {
724 if (linecomplete)
725 return 0;
726 len = 1;
727 }
728 if (reopenasap) {
729 logdirs_reopen();
730 reopenasap = 0;
731 }
732 now = monotonic_sec();
733 nearest_rotate = now + (45 * 60 + 45);
734 for (i = 0; i < dirn; ++i) {
735 if (dir[i].rotate_period) {
736 if (LESS(dir[i].next_rotate, now))
737 rotate(dir + i);
738 if (LESS(dir[i].next_rotate, nearest_rotate))
739 nearest_rotate = dir[i].next_rotate;
740 }
741 }
742
743 sigprocmask(SIG_UNBLOCK, &blocked_sigset, NULL);
744 i = nearest_rotate - now;
745 if (i > 1000000)
746 i = 1000000;
747 if (i <= 0)
748 i = 1;
749 poll(&input, 1, i * 1000);
750 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
751
752 i = ndelay_read(STDIN_FILENO, s, len);
753 if (i >= 0)
754 break;
755 if (errno == EINTR)
756 continue;
757 if (errno != EAGAIN) {
758 warn("can't read standard input");
759 break;
760 }
761 /* else: EAGAIN - normal, repeat silently */
762 } while (!exitasap);
763
764 if (i > 0) {
765 int cnt;
766 linecomplete = (s[i-1] == '\n');
767 if (!repl)
768 return i;
769
770 cnt = i;
771 while (--cnt >= 0) {
772 char ch = *s;
773 if (ch != '\n') {
774 if (ch < 32 || ch > 126)
775 *s = repl;
776 else {
777 int j;
778 for (j = 0; replace[j]; ++j) {
779 if (ch == replace[j]) {
780 *s = repl;
781 break;
782 }
783 }
784 }
785 }
786 s++;
787 }
788 }
789 return i;
790 }
791
792 static void sig_term_handler(int sig_no UNUSED_PARAM)
793 {
794 if (verbose)
795 bb_error_msg(INFO"sig%s received", "term");
796 exitasap = 1;
797 }
798
799 static void sig_child_handler(int sig_no UNUSED_PARAM)
800 {
801 pid_t pid;
802 int l;
803
804 if (verbose)
805 bb_error_msg(INFO"sig%s received", "child");
806 while ((pid = wait_any_nohang(&wstat)) > 0) {
807 for (l = 0; l < dirn; ++l) {
808 if (dir[l].ppid == pid) {
809 dir[l].ppid = 0;
810 processorstop(&dir[l]);
811 break;
812 }
813 }
814 }
815 }
816
817 static void sig_alarm_handler(int sig_no UNUSED_PARAM)
818 {
819 if (verbose)
820 bb_error_msg(INFO"sig%s received", "alarm");
821 rotateasap = 1;
822 }
823
824 static void sig_hangup_handler(int sig_no UNUSED_PARAM)
825 {
826 if (verbose)
827 bb_error_msg(INFO"sig%s received", "hangup");
828 reopenasap = 1;
829 }
830
831 static void logmatch(struct logdir *ld)
832 {
833 char *s;
834
835 ld->match = '+';
836 ld->matcherr = 'E';
837 s = ld->inst;
838 while (s && s[0]) {
839 switch (s[0]) {
840 case '+':
841 case '-':
842 if (pmatch(s+1, line, linelen))
843 ld->match = s[0];
844 break;
845 case 'e':
846 case 'E':
847 if (pmatch(s+1, line, linelen))
848 ld->matcherr = s[0];
849 break;
850 }
851 s += strlen(s) + 1;
852 }
853 }
854
855 int svlogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
856 int svlogd_main(int argc, char **argv)
857 {
858 char *r,*l,*b;
859 ssize_t stdin_cnt = 0;
860 int i;
861 unsigned opt;
862 unsigned timestamp = 0;
863 void* (*memRchr)(const void *, int, size_t) = memchr;
864
865 INIT_G();
866
867 opt_complementary = "tt:vv";
868 opt = getopt32(argv, "r:R:l:b:tv",
869 &r, &replace, &l, &b, &timestamp, &verbose);
870 if (opt & 1) { // -r
871 repl = r[0];
872 if (!repl || r[1]) usage();
873 }
874 if (opt & 2) if (!repl) repl = '_'; // -R
875 if (opt & 4) { // -l
876 linemax = xatou_range(l, 0, BUFSIZ-26);
877 if (linemax == 0) linemax = BUFSIZ-26;
878 if (linemax < 256) linemax = 256;
879 }
880 ////if (opt & 8) { // -b
881 //// buflen = xatoi_u(b);
882 //// if (buflen == 0) buflen = 1024;
883 ////}
884 //if (opt & 0x10) timestamp++; // -t
885 //if (opt & 0x20) verbose++; // -v
886 //if (timestamp > 2) timestamp = 2;
887 argv += optind;
888 argc -= optind;
889
890 dirn = argc;
891 if (dirn <= 0) usage();
892 ////if (buflen <= linemax) usage();
893 fdwdir = xopen(".", O_RDONLY|O_NDELAY);
894 close_on_exec_on(fdwdir);
895 dir = xzalloc(dirn * sizeof(struct logdir));
896 for (i = 0; i < dirn; ++i) {
897 dir[i].fddir = -1;
898 dir[i].fdcur = -1;
899 ////dir[i].btmp = xmalloc(buflen);
900 /*dir[i].ppid = 0;*/
901 }
902 /* line = xmalloc(linemax + (timestamp ? 26 : 0)); */
903 fndir = argv;
904 /* We cannot set NONBLOCK on fd #0 permanently - this setting
905 * _isn't_ per-process! It is shared among all other processes
906 * with the same stdin */
907 fl_flag_0 = fcntl(0, F_GETFL);
908
909 sigemptyset(&blocked_sigset);
910 sigaddset(&blocked_sigset, SIGTERM);
911 sigaddset(&blocked_sigset, SIGCHLD);
912 sigaddset(&blocked_sigset, SIGALRM);
913 sigaddset(&blocked_sigset, SIGHUP);
914 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
915 bb_signals_recursive_norestart(1 << SIGTERM, sig_term_handler);
916 bb_signals_recursive_norestart(1 << SIGCHLD, sig_child_handler);
917 bb_signals_recursive_norestart(1 << SIGALRM, sig_alarm_handler);
918 bb_signals_recursive_norestart(1 << SIGHUP, sig_hangup_handler);
919
920 logdirs_reopen();
921
922 /* Without timestamps, we don't have to print each line
923 * separately, so we can look for _last_ newline, not first,
924 * thus batching writes */
925 if (!timestamp)
926 memRchr = memrchr;
927
928 setvbuf(stderr, NULL, _IOFBF, linelen);
929
930 /* Each iteration processes one or more lines */
931 while (1) {
932 char stamp[FMT_PTIME];
933 char *lineptr;
934 char *printptr;
935 char *np;
936 int printlen;
937 char ch;
938
939 lineptr = line;
940 if (timestamp)
941 lineptr += 26;
942
943 /* lineptr[0..linemax-1] - buffer for stdin */
944 /* (possibly has some unprocessed data from prev loop) */
945
946 /* Refill the buffer if needed */
947 np = memRchr(lineptr, '\n', stdin_cnt);
948 if (!np && !exitasap) {
949 i = linemax - stdin_cnt; /* avail. bytes at tail */
950 if (i >= 128) {
951 i = buffer_pread(/*0, */lineptr + stdin_cnt, i);
952 if (i <= 0) /* EOF or error on stdin */
953 exitasap = 1;
954 else {
955 np = memRchr(lineptr + stdin_cnt, '\n', i);
956 stdin_cnt += i;
957 }
958 }
959 }
960 if (stdin_cnt <= 0 && exitasap)
961 break;
962
963 /* Search for '\n' (in fact, np already holds the result) */
964 linelen = stdin_cnt;
965 if (np) {
966 print_to_nl: /* NB: starting from here lineptr may point
967 * farther out into line[] */
968 linelen = np - lineptr + 1;
969 }
970 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
971 ch = lineptr[linelen-1];
972
973 /* Biggest performance hit was coming from the fact
974 * that we did not buffer writes. We were reading many lines
975 * in one read() above, but wrote one line per write().
976 * We are using stdio to fix that */
977
978 /* write out lineptr[0..linelen-1] to each log destination
979 * (or lineptr[-26..linelen-1] if timestamping) */
980 printlen = linelen;
981 printptr = lineptr;
982 if (timestamp) {
983 if (timestamp == 1)
984 fmt_time_bernstein_25(stamp);
985 else /* 2: */
986 fmt_time_human_30nul(stamp);
987 printlen += 26;
988 printptr -= 26;
989 memcpy(printptr, stamp, 25);
990 printptr[25] = ' ';
991 }
992 for (i = 0; i < dirn; ++i) {
993 struct logdir *ld = &dir[i];
994 if (ld->fddir == -1) continue;
995 if (ld->inst)
996 logmatch(ld);
997 if (ld->matcherr == 'e') {
998 /* runit-1.8.0 compat: if timestamping, do it on stderr too */
999 ////full_write(STDERR_FILENO, printptr, printlen);
1000 fwrite(printptr, 1, printlen, stderr);
1001 }
1002 if (ld->match != '+') continue;
1003 buffer_pwrite(i, printptr, printlen);
1004 }
1005
1006 /* If we didn't see '\n' (long input line), */
1007 /* read/write repeatedly until we see it */
1008 while (ch != '\n') {
1009 /* lineptr is emptied now, safe to use as buffer */
1010 stdin_cnt = exitasap ? -1 : buffer_pread(/*0, */lineptr, linemax);
1011 if (stdin_cnt <= 0) { /* EOF or error on stdin */
1012 exitasap = 1;
1013 lineptr[0] = ch = '\n';
1014 linelen = 1;
1015 stdin_cnt = 1;
1016 } else {
1017 linelen = stdin_cnt;
1018 np = memRchr(lineptr, '\n', stdin_cnt);
1019 if (np)
1020 linelen = np - lineptr + 1;
1021 ch = lineptr[linelen-1];
1022 }
1023 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
1024 for (i = 0; i < dirn; ++i) {
1025 if (dir[i].fddir == -1) continue;
1026 if (dir[i].matcherr == 'e') {
1027 ////full_write(STDERR_FILENO, lineptr, linelen);
1028 fwrite(lineptr, 1, linelen, stderr);
1029 }
1030 if (dir[i].match != '+') continue;
1031 buffer_pwrite(i, lineptr, linelen);
1032 }
1033 }
1034
1035 stdin_cnt -= linelen;
1036 if (stdin_cnt > 0) {
1037 lineptr += linelen;
1038 /* If we see another '\n', we don't need to read
1039 * next piece of input: can print what we have */
1040 np = memRchr(lineptr, '\n', stdin_cnt);
1041 if (np)
1042 goto print_to_nl;
1043 /* Move unprocessed data to the front of line */
1044 memmove((timestamp ? line+26 : line), lineptr, stdin_cnt);
1045 }
1046 fflush(NULL);////
1047 }
1048
1049 for (i = 0; i < dirn; ++i) {
1050 if (dir[i].ppid)
1051 while (!processorstop(&dir[i]))
1052 /* repeat */;
1053 logdir_close(&dir[i]);
1054 }
1055 return 0;
1056 }
Tomato firmware and modifications.