[apple/syslog.git] / syslogd.tproj / syslogd.c

/*
 * Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/fcntl.h>
#include <sys/queue.h>
#include <sys/time.h>
#include <dirent.h>
#include <dlfcn.h>
#include <libgen.h>
#include <notify.h>
#include "daemon.h"

#define DEFAULT_MARK_SEC 0
#define DEFAULT_PRUNE_DAYS 7
#define PRUNE_AFTER_START_DELAY 300

#define NOTIFY_DELAY 1

#define streq(A,B) (strcmp(A,B)==0)
#define forever for(;;)

static int debug = 0;
static int reset = 0;

static TAILQ_HEAD(ml, module_list) Moduleq;

/* global */
int asl_log_filter = ASL_FILTER_MASK_UPTO(ASL_LEVEL_NOTICE);
int prune = 0;

extern int __notify_78945668_info__;

/* Static Modules */
int asl_in_init();
int asl_in_reset();
int asl_in_close();
static int activate_asl_in = 1;

int asl_action_init();
int asl_action_reset();
int asl_action_close();
static int activate_asl_action = 1;

int klog_in_init();
int klog_in_reset();
int klog_in_close();
static int activate_klog_in = 1;

int bsd_in_init();
int bsd_in_reset();
int bsd_in_close();
static int activate_bsd_in = 1;

int bsd_out_init();
int bsd_out_reset();
int bsd_out_close();
static int activate_bsd_out = 1;

int udp_in_init();
int udp_in_reset();
int udp_in_close();
static int activate_udp_in = 0;

/*
 * Module approach: only one type of module.  This module may implement
 * the set of functions necessary for any of the functions (input, output,
 * etc.)  Prior to using the modules, dlsym() is consulted to see what it
 * implements.
 */

static int
static_modules()
{
	struct module_list *tmp;

	if (activate_asl_in != 0)
	{
		tmp = calloc(1, sizeof(struct module_list));
		if (tmp == NULL) return 1;
		tmp->name = strdup("asl_in");
		tmp->module = NULL;
		tmp->init = asl_in_init;
		tmp->reset = asl_in_reset;
		tmp->close = asl_in_close;
		TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
	}

	if (activate_asl_action != 0)
	{
		tmp = calloc(1, sizeof(struct module_list));
		if (tmp == NULL) return 1;
		tmp->name = strdup("asl_action");
		tmp->module = NULL;
		tmp->init = asl_action_init;
		tmp->reset = asl_action_reset;
		tmp->close = asl_action_close;
		TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
	}

	if (activate_klog_in != 0)
	{
		tmp = calloc(1, sizeof(struct module_list));
		if (tmp == NULL) return 1;
		tmp->name = strdup("klog_in");
		tmp->module = NULL;
		tmp->init = klog_in_init;
		tmp->reset = klog_in_reset;
		tmp->close = klog_in_close;
		TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
	}

	if (activate_bsd_in != 0)
	{
		tmp = calloc(1, sizeof(struct module_list));
		if (tmp == NULL) return 1;
		tmp->name = strdup("bsd_in");
		tmp->module = NULL;
		tmp->init = bsd_in_init;
		tmp->reset = bsd_in_reset;
		tmp->close = bsd_in_close;
		TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
	}

	if (activate_bsd_out != 0)
	{
		tmp = calloc(1, sizeof(struct module_list));
		if (tmp == NULL) return 1;
		tmp->name = strdup("bsd_out");
		tmp->module = NULL;
		tmp->init = bsd_out_init;
		tmp->reset = bsd_out_reset;
		tmp->close = bsd_out_close;
		TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
	}

	if (activate_udp_in != 0)
	{
		tmp = calloc(1, sizeof(struct module_list));
		if (tmp == NULL) return 1;
		tmp->name = strdup("udp_in");
		tmp->module = NULL;
		tmp->init = udp_in_init;
		tmp->reset = udp_in_reset;
		tmp->close = udp_in_close;
		TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
	}

	return 0;
}

/*
 * Loads all the modules.  This DOES NOT call the modules initializer
 * functions.  It simply scans the modules directory looking for modules
 * and loads them.  This does not mean the module will be used.  
 */
static int
load_modules(char *mp)
{
	DIR *d;
	struct dirent *de;
	struct module_list *tmp;
	void *c, *bn;
	char *modulepath = NULL;

	d = opendir(mp);
	if (d == NULL) return -1;

	while (NULL != (de = readdir(d)))
	{
		if (de->d_name[0] == '.') continue;

		/* Must have ".so" in the name" */
		if (!strstr(de->d_name, ".so")) continue;

		asprintf(&modulepath, "%s/%s", mp, de->d_name);
		if (!modulepath) continue;

		c = dlopen(modulepath, RTLD_LOCAL);
		if (c == NULL)
		{
			free(modulepath);
			continue;
		}

		tmp = calloc(1, sizeof(struct module_list));
		if (tmp == NULL)
		{
			free(modulepath);
			dlclose(c);
			continue;
		}

		bn = basename(modulepath);
		tmp->name = strdup(bn);
		tmp->module = c;
		TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);

		tmp->init = dlsym(tmp->module, "aslmod_init");
		tmp->reset = dlsym(tmp->module, "aslmod_reset");
		tmp->close = dlsym(tmp->module, "aslmod_close");

		free(modulepath);
	}

	closedir(d);

	return 0;
}

static void
writepid(void)
{
	FILE *fp;

	fp = fopen(_PATH_PIDFILE, "w");
	if (fp != NULL)
	{
		fprintf(fp, "%d\n", getpid());
		fclose(fp);
	}
}

static void
closeall(void)
{
	int i;

	for (i = getdtablesize() - 1; i >= 0; i--) close(i);

	open("/dev/null", O_RDWR, 0);
	dup(0);
	dup(0);
}

static void
detach(void)
{
	signal(SIGINT, SIG_IGN);
	signal(SIGPIPE, SIG_IGN);
	setsid();
}

static void
catch_sighup(int x)
{
	reset = 1;
}

static void
catch_sigwinch(int x)
{
	prune = 1;
}

static void
send_reset(void)
{
	struct module_list *mod;

	for (mod = Moduleq.tqh_first; mod != NULL; mod = mod->entries.tqe_next)
	{
		if (mod->reset != NULL) mod->reset();
	}
}

int
main(int argc, char *argv[])
{
	struct module_list *mod;
	fd_set rd, wr, ex;
	int fd, i, max, status, pdays, daemonize;
	time_t lastmark, msec, ssec, tick, delta, ptime, notify_time;
	char *mp, *str;
	struct timeval timeout, *pto;
	asl_msg_t *pq;

	mp = _PATH_MODULE_LIB;
	msec = DEFAULT_MARK_SEC;
	pdays = DEFAULT_PRUNE_DAYS;
	daemonize = 0;
	__notify_78945668_info__ = -1;

	for (i = 1; i < argc; i++)
	{
		if (streq(argv[i], "-d"))
		{
			debug = 1;
		}
		if (streq(argv[i], "-D"))
		{
			daemonize = 1;
		}
		if (streq(argv[i], "-u"))
		{
			activate_udp_in = 1;
		}
		else if (streq(argv[i], "-m"))
		{
			if ((i + 1) < argc) msec = 60 * atoi(argv[++i]);
		}
		else if (streq(argv[i], "-p"))
		{
			if ((i + 1) < argc) pdays = atoi(argv[++i]);
		}
		else if (streq(argv[i], "-l"))
		{
			if ((i + 1) < argc) mp = argv[++i];
		}
		else if (streq(argv[i], "-c"))
		{
			if ((i + 1) < argc)
			{
				i++;
				if ((argv[i][0] >= '0') && (argv[i][0] <= '7') && (argv[i][1] == '\0')) asl_log_filter = ASL_FILTER_MASK_UPTO(atoi(argv[i]));
			}
		}
		else if (streq(argv[i], "-asl_in"))
		{
			if ((i + 1) < argc) activate_asl_in = atoi(argv[++i]);
		}
		else if (streq(argv[i], "-asl_action"))
		{
			if ((i + 1) < argc) activate_asl_action = atoi(argv[++i]);
		}
		else if (streq(argv[i], "-klog_in"))
		{
			if ((i + 1) < argc) activate_klog_in = atoi(argv[++i]);
		}
		else if (streq(argv[i], "-bsd_in"))
		{
			if ((i + 1) < argc) activate_bsd_in = atoi(argv[++i]);
		}
		else if (streq(argv[i], "-bsd_out"))
		{
			if ((i + 1) < argc) activate_bsd_out = atoi(argv[++i]);
		}
		else if (streq(argv[i], "-udp_in"))
		{
			if ((i + 1) < argc) activate_udp_in = atoi(argv[++i]);
		}
	}

	TAILQ_INIT(&Moduleq);
	static_modules();
	load_modules(mp);
	aslevent_init();

	if (debug == 0)
	{
		if (daemonize != 0)
		{
			if (fork() != 0) exit(0);
			
			detach();
			closeall();
		}

		writepid();
	}

	signal(SIGHUP, catch_sighup);
	signal(SIGWINCH, catch_sigwinch);

	FD_ZERO(&rd);
	FD_ZERO(&wr);
	FD_ZERO(&ex);

	for (mod = Moduleq.tqh_first; mod != NULL; mod = mod->entries.tqe_next)
	{
		fd = mod->init();
		if (fd < 0) continue;
	}

	lastmark = time(NULL);
	notify_time = lastmark;
	memset(&timeout, 0, sizeof(struct timeval));
	pto = NULL;

	ssec = msec;
	if (ssec > 0)
	{
		timeout.tv_sec = ssec;
		pto = &timeout;
	}

	ptime = 0;
	if (pdays > 0) ptime = lastmark + PRUNE_AFTER_START_DELAY;

	forever
	{
		if (pto != NULL) pto->tv_sec = ssec;
		max = aslevent_fdsets(&rd, &wr, &ex);

		status = select(max+1, &rd, &wr, &ex, pto);

		if (reset != 0)
		{
			send_reset();
			reset = 0;
		}

		if (pto != NULL)
		{
			tick = time(NULL);
			delta = tick - lastmark;
			if (delta >= msec)
			{
				lastmark = tick;
				aslmark();
			}
		}

		if (prune != 0)
		{
			asl_prune(NULL);
			prune = 0;
			ptime = 0;
		}
		else if (ptime != 0)
		{
			tick = time(NULL);
			if (tick >= ptime)
			{
				pq = asl_new(ASL_TYPE_QUERY);
				str = NULL;
				asprintf(&str, "-%dd", pdays);
				asl_set_query(pq, ASL_KEY_TIME, str, ASL_QUERY_OP_LESS);
				if (str != NULL) free(str);
			
				/* asl_prune frees the query */
				asl_prune(pq);
				ptime = 0;
			}
		}

		if (__notify_78945668_info__ < 0)
		{
			tick = time(NULL);
			if (tick >= notify_time)
			{
				if (notify_post("com.apple.system.syslogd") == NOTIFY_STATUS_OK) __notify_78945668_info__ = 0;
				else notify_time = tick + NOTIFY_DELAY;
			}
		}

		if (status != 0) aslevent_handleevent(rd, wr, ex, NULL);
 	}
}

int
asldebug(const char *str, ...)
{
	va_list v;

	if (debug == 0) return 0;

	va_start(v, str);
	return vprintf(str, v);
}
Commit	Line	Data
b16a592a A	1	/*
	2	* Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
02b408bf A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
b16a592a A	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
02b408bf A	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
b16a592a A	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24	#include <stdio.h>
	25	#include <stdlib.h>
	26	#include <unistd.h>
	27	#include <string.h>
	28	#include <signal.h>
	29	#include <sys/types.h>
	30	#include <sys/socket.h>
	31	#include <sys/fcntl.h>
	32	#include <sys/queue.h>
	33	#include <sys/time.h>
	34	#include <dirent.h>
	35	#include <dlfcn.h>
	36	#include <libgen.h>
	37	#include <notify.h>
	38	#include "daemon.h"
	39
	40	#define DEFAULT_MARK_SEC 0
	41	#define DEFAULT_PRUNE_DAYS 7
	42	#define PRUNE_AFTER_START_DELAY 300
	43
	44	#define NOTIFY_DELAY 1
	45
	46	#define streq(A,B) (strcmp(A,B)==0)
	47	#define forever for(;;)
	48
	49	static int debug = 0;
	50	static int reset = 0;
	51
	52	static TAILQ_HEAD(ml, module_list) Moduleq;
	53
	54	/* global */
	55	int asl_log_filter = ASL_FILTER_MASK_UPTO(ASL_LEVEL_NOTICE);
	56	int prune = 0;
	57
	58	extern int __notify_78945668_info__;
	59
	60	/* Static Modules */
	61	int asl_in_init();
	62	int asl_in_reset();
	63	int asl_in_close();
	64	static int activate_asl_in = 1;
	65
	66	int asl_action_init();
	67	int asl_action_reset();
	68	int asl_action_close();
	69	static int activate_asl_action = 1;
	70
	71	int klog_in_init();
	72	int klog_in_reset();
	73	int klog_in_close();
	74	static int activate_klog_in = 1;
	75
	76	int bsd_in_init();
	77	int bsd_in_reset();
	78	int bsd_in_close();
	79	static int activate_bsd_in = 1;
	80
	81	int bsd_out_init();
	82	int bsd_out_reset();
	83	int bsd_out_close();
84	static int activate_bsd_out = 1;
85
86	int udp_in_init();
87	int udp_in_reset();
88	int udp_in_close();
89	static int activate_udp_in = 0;
90
91	/*
92	* Module approach: only one type of module. This module may implement
93	* the set of functions necessary for any of the functions (input, output,
94	* etc.) Prior to using the modules, dlsym() is consulted to see what it
95	* implements.
96	*/
97
98	static int
99	static_modules()
100	{
101	struct module_list *tmp;
102
103	if (activate_asl_in != 0)
104	{
105	tmp = calloc(1, sizeof(struct module_list));
106	if (tmp == NULL) return 1;
107	tmp->name = strdup("asl_in");
108	tmp->module = NULL;
109	tmp->init = asl_in_init;
110	tmp->reset = asl_in_reset;
111	tmp->close = asl_in_close;
112	TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
113	}
114
115	if (activate_asl_action != 0)
116	{
117	tmp = calloc(1, sizeof(struct module_list));
118	if (tmp == NULL) return 1;
119	tmp->name = strdup("asl_action");
120	tmp->module = NULL;
121	tmp->init = asl_action_init;
122	tmp->reset = asl_action_reset;
123	tmp->close = asl_action_close;
124	TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
125	}
126
127	if (activate_klog_in != 0)
128	{
129	tmp = calloc(1, sizeof(struct module_list));
130	if (tmp == NULL) return 1;
131	tmp->name = strdup("klog_in");
132	tmp->module = NULL;
133	tmp->init = klog_in_init;
134	tmp->reset = klog_in_reset;
135	tmp->close = klog_in_close;
136	TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
137	}
138
139	if (activate_bsd_in != 0)
140	{
141	tmp = calloc(1, sizeof(struct module_list));
142	if (tmp == NULL) return 1;
143	tmp->name = strdup("bsd_in");
144	tmp->module = NULL;
145	tmp->init = bsd_in_init;
146	tmp->reset = bsd_in_reset;
147	tmp->close = bsd_in_close;
148	TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
149	}
150
151	if (activate_bsd_out != 0)
152	{
153	tmp = calloc(1, sizeof(struct module_list));
154	if (tmp == NULL) return 1;
155	tmp->name = strdup("bsd_out");
156	tmp->module = NULL;
157	tmp->init = bsd_out_init;
158	tmp->reset = bsd_out_reset;
159	tmp->close = bsd_out_close;
160	TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
161	}
162
163	if (activate_udp_in != 0)
164	{
165	tmp = calloc(1, sizeof(struct module_list));
166	if (tmp == NULL) return 1;
167	tmp->name = strdup("udp_in");
168	tmp->module = NULL;
169	tmp->init = udp_in_init;
170	tmp->reset = udp_in_reset;
171	tmp->close = udp_in_close;
172	TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
173	}
174
175	return 0;
176	}
177
178	/*
179	* Loads all the modules. This DOES NOT call the modules initializer
180	* functions. It simply scans the modules directory looking for modules
181	* and loads them. This does not mean the module will be used.
182	*/
183	static int
184	load_modules(char *mp)
185	{
186	DIR *d;
187	struct dirent *de;
188	struct module_list *tmp;
189	void c, bn;
190	char *modulepath = NULL;
191
192	d = opendir(mp);
193	if (d == NULL) return -1;
194
195	while (NULL != (de = readdir(d)))
196	{
197	if (de->d_name[0] == '.') continue;
198
199	/* Must have ".so" in the name" */
200	if (!strstr(de->d_name, ".so")) continue;
201
202	asprintf(&modulepath, "%s/%s", mp, de->d_name);
203	if (!modulepath) continue;
204
205	c = dlopen(modulepath, RTLD_LOCAL);
206	if (c == NULL)
207	{
208	free(modulepath);
209	continue;
210	}
211
212	tmp = calloc(1, sizeof(struct module_list));
213	if (tmp == NULL)
214	{
215	free(modulepath);
216	dlclose(c);
217	continue;
218	}
219
220	bn = basename(modulepath);
221	tmp->name = strdup(bn);
222	tmp->module = c;
223	TAILQ_INSERT_TAIL(&Moduleq, tmp, entries);
224
225	tmp->init = dlsym(tmp->module, "aslmod_init");
226	tmp->reset = dlsym(tmp->module, "aslmod_reset");
227	tmp->close = dlsym(tmp->module, "aslmod_close");
228
229	free(modulepath);
230	}
231
232	closedir(d);
233
234	return 0;
235	}
236
237	static void
238	writepid(void)
239	{
240	FILE *fp;
241
242	fp = fopen(_PATH_PIDFILE, "w");
243	if (fp != NULL)
244	{
245	fprintf(fp, "%d\n", getpid());
246	fclose(fp);
247	}
248	}
249
250	static void
251	closeall(void)
252	{
253	int i;
254
255	for (i = getdtablesize() - 1; i >= 0; i--) close(i);
256
257	open("/dev/null", O_RDWR, 0);
258	dup(0);
259	dup(0);
260	}
261
262	static void
263	detach(void)
264	{
265	signal(SIGINT, SIG_IGN);
266	signal(SIGPIPE, SIG_IGN);
267	setsid();
268	}
269
270	static void
271	catch_sighup(int x)
272	{
273	reset = 1;
274	}
275
276	static void
277	catch_sigwinch(int x)
278	{
279	prune = 1;
280	}
281
282	static void
283	send_reset(void)
284	{
285	struct module_list *mod;
286
287	for (mod = Moduleq.tqh_first; mod != NULL; mod = mod->entries.tqe_next)
288	{
289	if (mod->reset != NULL) mod->reset();
290	}
291	}
292
293	int
294	main(int argc, char *argv[])
295	{
296	struct module_list *mod;
297	fd_set rd, wr, ex;
298	int fd, i, max, status, pdays, daemonize;
299	time_t lastmark, msec, ssec, tick, delta, ptime, notify_time;
300	char mp, str;
301	struct timeval timeout, *pto;
302	asl_msg_t *pq;
303
304	mp = _PATH_MODULE_LIB;
305	msec = DEFAULT_MARK_SEC;
306	pdays = DEFAULT_PRUNE_DAYS;
307	daemonize = 0;
308	__notify_78945668_info__ = -1;
309
310	for (i = 1; i < argc; i++)
311	{
312	if (streq(argv[i], "-d"))
313	{
314	debug = 1;
315	}
316	if (streq(argv[i], "-D"))
317	{
318	daemonize = 1;
319	}
320	if (streq(argv[i], "-u"))
321	{
322	activate_udp_in = 1;
323	}
324	else if (streq(argv[i], "-m"))
325	{
326	if ((i + 1) < argc) msec = 60 * atoi(argv[++i]);
327	}
328	else if (streq(argv[i], "-p"))
329	{
330	if ((i + 1) < argc) pdays = atoi(argv[++i]);
331	}
332	else if (streq(argv[i], "-l"))
333	{
334	if ((i + 1) < argc) mp = argv[++i];
335	}
336	else if (streq(argv[i], "-c"))
337	{
338	if ((i + 1) < argc)
339	{
340	i++;
341	if ((argv[i][0] >= '0') && (argv[i][0] <= '7') && (argv[i][1] == '\0')) asl_log_filter = ASL_FILTER_MASK_UPTO(atoi(argv[i]));
342	}
343	}
344	else if (streq(argv[i], "-asl_in"))
345	{
346	if ((i + 1) < argc) activate_asl_in = atoi(argv[++i]);
347	}
348	else if (streq(argv[i], "-asl_action"))
349	{
350	if ((i + 1) < argc) activate_asl_action = atoi(argv[++i]);
351	}
352	else if (streq(argv[i], "-klog_in"))
353	{
354	if ((i + 1) < argc) activate_klog_in = atoi(argv[++i]);
355	}
356	else if (streq(argv[i], "-bsd_in"))
357	{
358	if ((i + 1) < argc) activate_bsd_in = atoi(argv[++i]);
359	}
360	else if (streq(argv[i], "-bsd_out"))
361	{
362	if ((i + 1) < argc) activate_bsd_out = atoi(argv[++i]);
363	}
364	else if (streq(argv[i], "-udp_in"))
365	{
366	if ((i + 1) < argc) activate_udp_in = atoi(argv[++i]);
367	}
368	}
369
370	TAILQ_INIT(&Moduleq);
371	static_modules();
372	load_modules(mp);
373	aslevent_init();
374
375	if (debug == 0)
376	{
377	if (daemonize != 0)
378	{
379	if (fork() != 0) exit(0);
380
381	detach();
382	closeall();
383	}
384
385	writepid();
386	}
387
388	signal(SIGHUP, catch_sighup);
389	signal(SIGWINCH, catch_sigwinch);
390
391	FD_ZERO(&rd);
392	FD_ZERO(&wr);
393	FD_ZERO(&ex);
394
395	for (mod = Moduleq.tqh_first; mod != NULL; mod = mod->entries.tqe_next)
396	{
397	fd = mod->init();
398	if (fd < 0) continue;
399	}
400
401	lastmark = time(NULL);
402	notify_time = lastmark;
403	memset(&timeout, 0, sizeof(struct timeval));
404	pto = NULL;
405
406	ssec = msec;
407	if (ssec > 0)
408	{
409	timeout.tv_sec = ssec;
410	pto = &timeout;
411	}
412
413	ptime = 0;
414	if (pdays > 0) ptime = lastmark + PRUNE_AFTER_START_DELAY;
415
416	forever
417	{
418	if (pto != NULL) pto->tv_sec = ssec;
419	max = aslevent_fdsets(&rd, &wr, &ex);
420
421	status = select(max+1, &rd, &wr, &ex, pto);
422
423	if (reset != 0)
424	{
425	send_reset();
426	reset = 0;
427	}
428
429	if (pto != NULL)
430	{
431	tick = time(NULL);
432	delta = tick - lastmark;
433	if (delta >= msec)
434	{
435	lastmark = tick;
436	aslmark();
437	}
438	}
439
440	if (prune != 0)
441	{
442	asl_prune(NULL);
443	prune = 0;
444	ptime = 0;
445	}
446	else if (ptime != 0)
447	{
448	tick = time(NULL);
449	if (tick >= ptime)
450	{
451	pq = asl_new(ASL_TYPE_QUERY);
452	str = NULL;
453	asprintf(&str, "-%dd", pdays);
454	asl_set_query(pq, ASL_KEY_TIME, str, ASL_QUERY_OP_LESS);
455	if (str != NULL) free(str);
456
457	/* asl_prune frees the query */
458	asl_prune(pq);
459	ptime = 0;
460	}
461	}
462
463	if (__notify_78945668_info__ < 0)
464	{
465	tick = time(NULL);
466	if (tick >= notify_time)
467	{
468	if (notify_post("com.apple.system.syslogd") == NOTIFY_STATUS_OK) __notify_78945668_info__ = 0;
469	else notify_time = tick + NOTIFY_DELAY;
470	}
471	}
472
473	if (status != 0) aslevent_handleevent(rd, wr, ex, NULL);
474	}
475	}
476
477	int
478	asldebug(const char *str, ...)
479	{
480	va_list v;
481
482	if (debug == 0) return 0;
483
484	va_start(v, str);
485	return vprintf(str, v);
486	}