path: root/runit/svlogd.c (plain)
blob: c080b9acc703a7053c3fae5ac162327e3935f37b

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