[apple/syslog.git] / syslogd.tproj / asl_in.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 <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/uio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include "daemon.h"

#define forever for(;;)

#define MY_ID "asl"

static int sock = -1;
static FILE *aslfile = NULL;
static asl_msg_t *query = NULL;

extern int asl_log_filter;

#define MATCH_EOF -1
#define MATCH_NULL 0
#define MATCH_TRUE 1
#define MATCH_FALSE 2

extern int prune;

static int filter_token = -1;

struct prune_query_entry
{
	asl_msg_t *query;
	TAILQ_ENTRY(prune_query_entry) entries;
};

static TAILQ_HEAD(pql, prune_query_entry) pquery;

static int
_search_next(FILE *log, char **outstr)
{
	char *str;
	aslmsg m;
	int match, i;
	struct prune_query_entry *p;

	*outstr = NULL;

	if (log == NULL) return MATCH_EOF;

	str = get_line_from_file(log);
	if (str == NULL) return MATCH_EOF;

	m = asl_msg_from_string(str);
	if (m == NULL)
	{
		free(str);
		return MATCH_NULL;
	}

	*outstr = str;

	for (i = 0, p = pquery.tqh_first; p != NULL; p = p->entries.tqe_next, i++)
	{
		match = asl_msg_cmp(p->query, m);
		if (match == 1)
		{
			asl_free(m);
			return MATCH_TRUE;
		}
	}

	asl_free(m);
	return MATCH_FALSE;
}

/*
 * Pruning the main output file (asl.log)
 *
 * The prune file (_PATH_ASL_PRUNE) is set up by the syslog command-line utiliy.
 * It contains a set of queries.  The main output file is read, and each
 * message is matched against these queries.  If any query matches, we save
 * that message.  Anything that doesn't match is discarded.
 *
 */
int
asl_prune(asl_msg_t *inq)
{
	char *pname, *str;
	FILE *pfile, *qfile;
	struct prune_query_entry *p, *n;
	asl_msg_t *q;
	int status, incount, outcount;

	asldebug("syslogd: pruning %s\n", _PATH_ASL_OUT);

	if (inq != NULL)
	{
		TAILQ_INIT(&pquery);
		p = (struct prune_query_entry *)calloc(1, sizeof(struct prune_query_entry));
		if (p == NULL) return -1;

		p->query = inq;
		TAILQ_INSERT_TAIL(&pquery, p, entries);
	}
	else
	{
		qfile = fopen(_PATH_ASL_PRUNE, "r");
		if (qfile == NULL)
		{
			asldebug("syslogd: can't read %s: %s\n", _PATH_ASL_PRUNE, strerror(errno));
			return 0;
		}

		TAILQ_INIT(&pquery);

		forever
		{
			str = get_line_from_file(qfile);
			if (str == NULL) break;

			q = asl_msg_from_string(str);
			asldebug("syslogd: prune line %s\n", str);

			free(str);
			if (q == NULL) continue;

			if (q->type != ASL_TYPE_QUERY)
			{
				asl_free(q);
				continue;
			}

			p = (struct prune_query_entry *)calloc(1, sizeof(struct prune_query_entry));
			if (p == NULL) return -1;

			p->query = q;
			TAILQ_INSERT_TAIL(&pquery, p, entries);
		}
	}

	pname = NULL;
	asprintf(&pname, "%s.%d", _PATH_ASL_OUT, getpid());
	if (pname == NULL) return -1;

	pfile = fopen(pname, "w");
	if (pfile == NULL)
	{
		asldebug("syslogd: can't write %s: %s\n", pname, strerror(errno));
		free(pname);
		return -1;
	}

	fclose(aslfile);
	aslfile = fopen(_PATH_ASL_OUT, "r");
	if (aslfile == NULL)
	{
		asldebug("syslogd: can't read %s: %s\n", _PATH_ASL_OUT, strerror(errno));
		free(pname);
		aslfile = fopen(_PATH_ASL_OUT, "a");
		return -1;
	}

	incount = 0;
	outcount = 0;

	do
	{
		str = NULL;
		incount++;
		status = _search_next(aslfile, &str);

		/*
		 * Pruning deletes records that match the search.
		 * If the match fails, we keep the record.
		 */
		if (status == MATCH_FALSE)
		{
			outcount++;
			fprintf(pfile, "%s\n", str);
		}

		if (str != NULL) free(str);
	}
	while (status != MATCH_EOF);

	fclose(pfile);
	fclose(aslfile);

	unlink(_PATH_ASL_OUT);
	rename(pname, _PATH_ASL_OUT);
	free(pname);
	unlink(_PATH_ASL_PRUNE);
	aslfile = fopen(_PATH_ASL_OUT, "a");

	n = NULL;
	for (p = pquery.tqh_first; p != NULL; p = n)
	{
		n = p->entries.tqe_next;

		if (p->query != NULL) asl_free(p->query);

		TAILQ_REMOVE(&pquery, p, entries);
		free(p);
	}

	asldebug("syslogd: prune %d records in, %d records out\n", incount, outcount);

	return 0;
}

asl_msg_t *
asl_in_getmsg(int fd)
{
	char *out;
	asl_msg_t *m;
	uint32_t len, n;
	char ls[16];

	n = read(fd, ls, 11);
	if (n < 11)
	{
		if (n <= 0)
		{
			asldebug("%s: read error (len): %s\n", MY_ID, strerror(errno));
			if (errno != EINTR)
			{
				close(fd);
				aslevent_removefd(fd);
				return NULL;
			}
		}

		return NULL;
	}

	len = atoi(ls);
	asldebug("%s: expecting message length %d bytes\n", MY_ID, len);
	out = malloc(len);
	if (out == NULL) return NULL;

	n = read(fd, out, len);
	if (n < len)
	{
		if (n <= 0)
		{
			asldebug("%s: read error (body): %s\n", MY_ID, strerror(errno));
			if (errno != EINTR)
			{
				close(fd);
				aslevent_removefd(fd);
				free(out);
				return NULL;
			}
		}
	}

	m = asl_msg_from_string(out);
	free(out);
	return m;
}

asl_msg_t *
asl_in_acceptmsg(int fd)
{
	int clientfd;

	asldebug("%s: accepting message\n", MY_ID);
	clientfd = accept(fd, NULL, 0);
	if (clientfd < 0)
	{
		asldebug("%s: error accepting socket fd %d: %s\n", MY_ID, fd, strerror(errno));
		return NULL;
	}

	if (fcntl(clientfd, F_SETFL, O_NONBLOCK) < 0)
	{
		close(clientfd);
		clientfd = -1;
		asldebug("%s: couldn't set O_NONBLOCK for fd %d: %s\n", MY_ID, clientfd, strerror(errno));
		return NULL;
	}

	aslevent_addfd(clientfd, asl_in_getmsg, NULL, NULL);
	return NULL;
}

int
aslmod_sendmsg(asl_msg_t *msg, const char *outid)
{
	const char *vlevel;
	char *mstr;
	uint32_t n, lmask;
	int status, x, level;

	if (aslfile == NULL) return -1;

	/* set up com.apple.syslog.asl_filter */
	if (filter_token == -1)
	{
		status = notify_register_check(NOTIFY_SYSTEM_ASL_FILTER, &filter_token);
		if (status != NOTIFY_STATUS_OK)
		{
			filter_token = -1;
		}
		else
		{
			status = notify_check(filter_token, &x);
			if (status == NOTIFY_STATUS_OK) status = notify_set_state(filter_token, asl_log_filter);
			if (status != NOTIFY_STATUS_OK)
			{
				notify_cancel(filter_token);
				filter_token = -1;
			}
		}
	}

	if (filter_token >= 0)
	{
		x = 1;
		status = notify_check(filter_token, &x);
		if ((status == NOTIFY_STATUS_OK) && (x == 1))
		{
			x = asl_log_filter;
			status = notify_get_state(filter_token, &x);
			if ((status == NOTIFY_STATUS_OK) && (x != 0)) asl_log_filter = x;
		}
	}

	vlevel = asl_get(msg, ASL_KEY_LEVEL);
	level = 7;
	if (vlevel != NULL) level = atoi(vlevel);
	lmask = ASL_FILTER_MASK(level);
	if ((lmask & asl_log_filter) == 0) return 0;

	mstr = asl_msg_to_string(msg, &n);
	if (mstr != NULL)
	{
		fprintf(aslfile, "%s\n", mstr);
		fflush(aslfile);
		free(mstr);
	}

	return 0;
}

int
asl_in_init(void)
{
	struct sockaddr_un sun;
	int rbufsize;
	int len;

	asldebug("%s: init\n", MY_ID);
	if (sock >= 0) return sock;

	unlink(_PATH_ASL_IN);
	sock = socket(AF_UNIX, SOCK_STREAM, 0);
	if (sock < 0)
	{
		asldebug("%s: couldn't create socket for %s: %s\n", MY_ID, _PATH_ASL_IN, strerror(errno));
		return -1;
	}

	asldebug("%s: creating %s for fd %d\n", MY_ID, _PATH_ASL_IN, sock);

	memset(&sun, 0, sizeof(sun));
	sun.sun_family = AF_UNIX;
	strcpy(sun.sun_path, _PATH_ASL_IN);

	len = sizeof(struct sockaddr_un);
	if (bind(sock, (struct sockaddr *)&sun, len) < 0)
	{
		asldebug("%s: couldn't bind socket %d for %s: %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
		close(sock);
		sock = -1;
		return -1;
	}

	rbufsize = 128 * 1024;
	len = sizeof(rbufsize);

	if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &rbufsize, len) < 0)
	{
		asldebug("%s: couldn't set receive buffer size for %s: %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
		close(sock);
		sock = -1;
		return -1;
	}
	
	if (listen(sock, SOMAXCONN) < 0)
	{
		asldebug("%s: couldn't listen on socket %d for %s: %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
		close(sock);
		sock = -1;
		unlink(_PATH_ASL_IN);
		return -1;
	}

	if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0)
	{
		asldebug("%s: couldn't set O_NONBLOCK for socket %d (%s): %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
		close(sock);
		sock = -1;
		return -1;
	}

	chmod(_PATH_ASL_IN, 0666);

	/* Add logger routine for main output file */
	aslfile = fopen(_PATH_ASL_OUT, "a");
	if (aslfile != NULL)
	{
		query = asl_new(ASL_TYPE_QUERY);
		aslevent_addmatch(query, MY_ID);
		aslevent_addoutput(aslmod_sendmsg, MY_ID);
	}

	return aslevent_addfd(sock, asl_in_acceptmsg, NULL, NULL);
}

int
asl_in_reset(void)
{
	return 0;
}

int
asl_in_close(void)
{
	if (sock < 0) return 1;

	if (filter_token >= 0) notify_cancel(filter_token);
	filter_token = -1;
	asl_log_filter = 0;

	asl_free(query);
	close(sock);
	if (aslfile != NULL) fclose(aslfile);
	unlink(_PATH_ASL_IN);

	return 0;
}
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 <sys/types.h>
	25	#include <sys/stat.h>
	26	#include <sys/fcntl.h>
	27	#include <sys/socket.h>
	28	#include <sys/un.h>
	29	#include <sys/uio.h>
	30	#include <stdio.h>
	31	#include <stdlib.h>
	32	#include <string.h>
	33	#include <unistd.h>
	34	#include <errno.h>
	35	#include "daemon.h"
	36
	37	#define forever for(;;)
	38
	39	#define MY_ID "asl"
	40
	41	static int sock = -1;
	42	static FILE *aslfile = NULL;
	43	static asl_msg_t *query = NULL;
	44
	45	extern int asl_log_filter;
	46
	47	#define MATCH_EOF -1
	48	#define MATCH_NULL 0
	49	#define MATCH_TRUE 1
	50	#define MATCH_FALSE 2
	51
	52	extern int prune;
	53
	54	static int filter_token = -1;
	55
	56	struct prune_query_entry
	57	{
	58	asl_msg_t *query;
	59	TAILQ_ENTRY(prune_query_entry) entries;
	60	};
	61
	62	static TAILQ_HEAD(pql, prune_query_entry) pquery;
	63
	64	static int
	65	_search_next(FILE log, char *outstr)
	66	{
	67	char *str;
	68	aslmsg m;
	69	int match, i;
	70	struct prune_query_entry *p;
	71
	72	*outstr = NULL;
	73
	74	if (log == NULL) return MATCH_EOF;
	75
	76	str = get_line_from_file(log);
	77	if (str == NULL) return MATCH_EOF;
	78
	79	m = asl_msg_from_string(str);
	80	if (m == NULL)
	81	{
	82	free(str);
	83	return MATCH_NULL;
84	}
85
86	*outstr = str;
87
88	for (i = 0, p = pquery.tqh_first; p != NULL; p = p->entries.tqe_next, i++)
89	{
90	match = asl_msg_cmp(p->query, m);
91	if (match == 1)
92	{
93	asl_free(m);
94	return MATCH_TRUE;
95	}
96	}
97
98	asl_free(m);
99	return MATCH_FALSE;
100	}
101
102	/*
103	* Pruning the main output file (asl.log)
104	*
105	* The prune file (_PATH_ASL_PRUNE) is set up by the syslog command-line utiliy.
106	* It contains a set of queries. The main output file is read, and each
107	* message is matched against these queries. If any query matches, we save
108	* that message. Anything that doesn't match is discarded.
109	*
110	*/
111	int
112	asl_prune(asl_msg_t *inq)
113	{
114	char pname, str;
115	FILE pfile, qfile;
116	struct prune_query_entry p, n;
117	asl_msg_t *q;
118	int status, incount, outcount;
119
120	asldebug("syslogd: pruning %s\n", _PATH_ASL_OUT);
121
122	if (inq != NULL)
123	{
124	TAILQ_INIT(&pquery);
125	p = (struct prune_query_entry *)calloc(1, sizeof(struct prune_query_entry));
126	if (p == NULL) return -1;
127
128	p->query = inq;
129	TAILQ_INSERT_TAIL(&pquery, p, entries);
130	}
131	else
132	{
133	qfile = fopen(_PATH_ASL_PRUNE, "r");
134	if (qfile == NULL)
135	{
136	asldebug("syslogd: can't read %s: %s\n", _PATH_ASL_PRUNE, strerror(errno));
137	return 0;
138	}
139
140	TAILQ_INIT(&pquery);
141
142	forever
143	{
144	str = get_line_from_file(qfile);
145	if (str == NULL) break;
146
147	q = asl_msg_from_string(str);
148	asldebug("syslogd: prune line %s\n", str);
149
150	free(str);
151	if (q == NULL) continue;
152
153	if (q->type != ASL_TYPE_QUERY)
154	{
155	asl_free(q);
156	continue;
157	}
158
159	p = (struct prune_query_entry *)calloc(1, sizeof(struct prune_query_entry));
160	if (p == NULL) return -1;
161
162	p->query = q;
163	TAILQ_INSERT_TAIL(&pquery, p, entries);
164	}
165	}
166
167	pname = NULL;
168	asprintf(&pname, "%s.%d", _PATH_ASL_OUT, getpid());
169	if (pname == NULL) return -1;
170
171	pfile = fopen(pname, "w");
172	if (pfile == NULL)
173	{
174	asldebug("syslogd: can't write %s: %s\n", pname, strerror(errno));
175	free(pname);
176	return -1;
177	}
178
179	fclose(aslfile);
180	aslfile = fopen(_PATH_ASL_OUT, "r");
181	if (aslfile == NULL)
182	{
183	asldebug("syslogd: can't read %s: %s\n", _PATH_ASL_OUT, strerror(errno));
184	free(pname);
185	aslfile = fopen(_PATH_ASL_OUT, "a");
186	return -1;
187	}
188
189	incount = 0;
190	outcount = 0;
191
192	do
193	{
194	str = NULL;
195	incount++;
196	status = _search_next(aslfile, &str);
197
198	/*
199	* Pruning deletes records that match the search.
200	* If the match fails, we keep the record.
201	*/
202	if (status == MATCH_FALSE)
203	{
204	outcount++;
205	fprintf(pfile, "%s\n", str);
206	}
207
208	if (str != NULL) free(str);
209	}
210	while (status != MATCH_EOF);
211
212	fclose(pfile);
213	fclose(aslfile);
214
215	unlink(_PATH_ASL_OUT);
216	rename(pname, _PATH_ASL_OUT);
217	free(pname);
218	unlink(_PATH_ASL_PRUNE);
219	aslfile = fopen(_PATH_ASL_OUT, "a");
220
221	n = NULL;
222	for (p = pquery.tqh_first; p != NULL; p = n)
223	{
224	n = p->entries.tqe_next;
225
226	if (p->query != NULL) asl_free(p->query);
227
228	TAILQ_REMOVE(&pquery, p, entries);
229	free(p);
230	}
231
232	asldebug("syslogd: prune %d records in, %d records out\n", incount, outcount);
233
234	return 0;
235	}
236
237	asl_msg_t *
238	asl_in_getmsg(int fd)
239	{
240	char *out;
241	asl_msg_t *m;
242	uint32_t len, n;
243	char ls[16];
244
245	n = read(fd, ls, 11);
246	if (n < 11)
247	{
248	if (n <= 0)
249	{
250	asldebug("%s: read error (len): %s\n", MY_ID, strerror(errno));
251	if (errno != EINTR)
252	{
253	close(fd);
254	aslevent_removefd(fd);
255	return NULL;
256	}
257	}
258
259	return NULL;
260	}
261
262	len = atoi(ls);
263	asldebug("%s: expecting message length %d bytes\n", MY_ID, len);
264	out = malloc(len);
265	if (out == NULL) return NULL;
266
267	n = read(fd, out, len);
268	if (n < len)
269	{
270	if (n <= 0)
271	{
272	asldebug("%s: read error (body): %s\n", MY_ID, strerror(errno));
273	if (errno != EINTR)
274	{
275	close(fd);
276	aslevent_removefd(fd);
277	free(out);
278	return NULL;
279	}
280	}
281	}
282
283	m = asl_msg_from_string(out);
284	free(out);
285	return m;
286	}
287
288	asl_msg_t *
289	asl_in_acceptmsg(int fd)
290	{
291	int clientfd;
292
293	asldebug("%s: accepting message\n", MY_ID);
294	clientfd = accept(fd, NULL, 0);
295	if (clientfd < 0)
296	{
297	asldebug("%s: error accepting socket fd %d: %s\n", MY_ID, fd, strerror(errno));
298	return NULL;
299	}
300
301	if (fcntl(clientfd, F_SETFL, O_NONBLOCK) < 0)
302	{
303	close(clientfd);
304	clientfd = -1;
305	asldebug("%s: couldn't set O_NONBLOCK for fd %d: %s\n", MY_ID, clientfd, strerror(errno));
306	return NULL;
307	}
308
309	aslevent_addfd(clientfd, asl_in_getmsg, NULL, NULL);
310	return NULL;
311	}
312
313	int
314	aslmod_sendmsg(asl_msg_t msg, const char outid)
315	{
316	const char *vlevel;
317	char *mstr;
318	uint32_t n, lmask;
319	int status, x, level;
320
321	if (aslfile == NULL) return -1;
322
323	/* set up com.apple.syslog.asl_filter */
324	if (filter_token == -1)
325	{
326	status = notify_register_check(NOTIFY_SYSTEM_ASL_FILTER, &filter_token);
327	if (status != NOTIFY_STATUS_OK)
328	{
329	filter_token = -1;
330	}
331	else
332	{
333	status = notify_check(filter_token, &x);
334	if (status == NOTIFY_STATUS_OK) status = notify_set_state(filter_token, asl_log_filter);
335	if (status != NOTIFY_STATUS_OK)
336	{
337	notify_cancel(filter_token);
338	filter_token = -1;
339	}
340	}
341	}
342
343	if (filter_token >= 0)
344	{
345	x = 1;
346	status = notify_check(filter_token, &x);
347	if ((status == NOTIFY_STATUS_OK) && (x == 1))
348	{
349	x = asl_log_filter;
350	status = notify_get_state(filter_token, &x);
351	if ((status == NOTIFY_STATUS_OK) && (x != 0)) asl_log_filter = x;
352	}
353	}
354
355	vlevel = asl_get(msg, ASL_KEY_LEVEL);
356	level = 7;
357	if (vlevel != NULL) level = atoi(vlevel);
358	lmask = ASL_FILTER_MASK(level);
359	if ((lmask & asl_log_filter) == 0) return 0;
360
361	mstr = asl_msg_to_string(msg, &n);
362	if (mstr != NULL)
363	{
364	fprintf(aslfile, "%s\n", mstr);
365	fflush(aslfile);
366	free(mstr);
367	}
368
369	return 0;
370	}
371
372	int
373	asl_in_init(void)
374	{
375	struct sockaddr_un sun;
376	int rbufsize;
377	int len;
378
379	asldebug("%s: init\n", MY_ID);
380	if (sock >= 0) return sock;
381
382	unlink(_PATH_ASL_IN);
383	sock = socket(AF_UNIX, SOCK_STREAM, 0);
384	if (sock < 0)
385	{
386	asldebug("%s: couldn't create socket for %s: %s\n", MY_ID, _PATH_ASL_IN, strerror(errno));
387	return -1;
388	}
389
390	asldebug("%s: creating %s for fd %d\n", MY_ID, _PATH_ASL_IN, sock);
391
392	memset(&sun, 0, sizeof(sun));
393	sun.sun_family = AF_UNIX;
394	strcpy(sun.sun_path, _PATH_ASL_IN);
395
396	len = sizeof(struct sockaddr_un);
397	if (bind(sock, (struct sockaddr *)&sun, len) < 0)
398	{
399	asldebug("%s: couldn't bind socket %d for %s: %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
400	close(sock);
401	sock = -1;
402	return -1;
403	}
404
405	rbufsize = 128 * 1024;
406	len = sizeof(rbufsize);
407
408	if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &rbufsize, len) < 0)
409	{
410	asldebug("%s: couldn't set receive buffer size for %s: %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
411	close(sock);
412	sock = -1;
413	return -1;
414	}
415
416	if (listen(sock, SOMAXCONN) < 0)
417	{
418	asldebug("%s: couldn't listen on socket %d for %s: %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
419	close(sock);
420	sock = -1;
421	unlink(_PATH_ASL_IN);
422	return -1;
423	}
424
425	if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0)
426	{
427	asldebug("%s: couldn't set O_NONBLOCK for socket %d (%s): %s\n", MY_ID, sock, _PATH_ASL_IN, strerror(errno));
428	close(sock);
429	sock = -1;
430	return -1;
431	}
432
433	chmod(_PATH_ASL_IN, 0666);
434
435	/* Add logger routine for main output file */
436	aslfile = fopen(_PATH_ASL_OUT, "a");
437	if (aslfile != NULL)
438	{
439	query = asl_new(ASL_TYPE_QUERY);
440	aslevent_addmatch(query, MY_ID);
441	aslevent_addoutput(aslmod_sendmsg, MY_ID);
442	}
443
444	return aslevent_addfd(sock, asl_in_acceptmsg, NULL, NULL);
445	}
446
447	int
448	asl_in_reset(void)
449	{
450	return 0;
451	}
452
453	int
454	asl_in_close(void)
455	{
456	if (sock < 0) return 1;
457
458	if (filter_token >= 0) notify_cancel(filter_token);
459	filter_token = -1;
460	asl_log_filter = 0;
461
462	asl_free(query);
463	close(sock);
464	if (aslfile != NULL) fclose(aslfile);
465	unlink(_PATH_ASL_IN);
466
467	return 0;
468	}