xref: /titanic_44/usr/src/cmd/syslogd/syslogd.c (revision e2dcee5754c56d91c6e1ff847db294541069ca0d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  * Copyright 2012 Milan Jurik. All rights reserved.
25  * Copyright (c) 2013 Gary Mills
26  */
27 
28 /*
29  *	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T
30  *	All Rights Reserved
31  */
32 
33 /*
34  * University Copyright- Copyright (c) 1982, 1986, 1988
35  * The Regents of the University of California
36  * All Rights Reserved
37  *
38  * University Acknowledgment- Portions of this document are derived from
39  * software developed by the University of California, Berkeley, and its
40  * contributors.
41  */
42 
43 /*
44  *  syslogd -- log system messages
45  *
46  * This program implements a system log. It takes a series of lines.
47  * Each line may have a priority, signified as "<n>" as
48  * the first characters of the line.  If this is
49  * not present, a default priority is used.
50  *
51  * To kill syslogd, send a signal 15 (terminate).  A signal 1 (hup) will
52  * cause it to reconfigure.
53  *
54  * Defined Constants:
55  *
56  * MAXLINE -- the maximimum line length that can be handled.
57  * DEFUPRI -- the default priority for user messages.
58  * DEFSPRI -- the default priority for kernel messages.
59  *
60  */
61 
62 #include <unistd.h>
63 #include <note.h>
64 #include <errno.h>
65 #include <sys/types.h>
66 #include <stdio.h>
67 #include <stdio_ext.h>
68 #include <stdlib.h>
69 #include <ctype.h>
70 #include <signal.h>
71 #include <string.h>
72 #include <strings.h>
73 #include <libscf.h>
74 #include <netconfig.h>
75 #include <netdir.h>
76 #include <pwd.h>
77 #include <sys/socket.h>
78 #include <tiuser.h>
79 #include <utmpx.h>
80 #include <limits.h>
81 #include <pthread.h>
82 #include <fcntl.h>
83 #include <stropts.h>
84 #include <assert.h>
85 #include <sys/statvfs.h>
86 
87 #include <sys/param.h>
88 #include <sys/sysmacros.h>
89 #include <sys/syslog.h>
90 #include <sys/strlog.h>
91 #include <sys/stat.h>
92 #include <sys/time.h>
93 #include <sys/utsname.h>
94 #include <sys/poll.h>
95 #include <sys/wait.h>
96 #include <sys/resource.h>
97 #include <sys/mman.h>
98 #include <sys/note.h>
99 #include <door.h>
100 
101 #include <wchar.h>
102 #include <locale.h>
103 #include <stdarg.h>
104 
105 #include "dataq.h"
106 #include "conf.h"
107 #include "syslogd.h"
108 
109 #define	DOORFILE		"/var/run/syslog_door"
110 #define	RELATIVE_DOORFILE	"../var/run/syslog_door"
111 #define	OLD_DOORFILE		"/etc/.syslog_door"
112 
113 #define	PIDFILE			"/var/run/syslog.pid"
114 #define	RELATIVE_PIDFILE	"../var/run/syslog.pid"
115 #define	OLD_PIDFILE		"/etc/syslog.pid"
116 
117 static char		*LogName = "/dev/log";
118 static char		*ConfFile = "/etc/syslog.conf";
119 static char		ctty[] = "/dev/console";
120 static char		sysmsg[] = "/dev/sysmsg";
121 static int		DoorFd = -1;
122 static int		DoorCreated = 0;
123 static int		PidfileCreated = 0;
124 static char		*DoorFileName = DOORFILE;
125 static char		*PidFileName = PIDFILE;
126 
127 /*
128  * configuration file directives
129  */
130 
131 static struct code	PriNames[] = {
132 	"panic",	LOG_EMERG,
133 	"emerg",	LOG_EMERG,
134 	"alert",	LOG_ALERT,
135 	"crit",		LOG_CRIT,
136 	"err",		LOG_ERR,
137 	"error",	LOG_ERR,
138 	"warn",		LOG_WARNING,
139 	"warning",	LOG_WARNING,
140 	"notice",	LOG_NOTICE,
141 	"info",		LOG_INFO,
142 	"debug",	LOG_DEBUG,
143 	"none",		NOPRI,
144 	NULL,		-1
145 };
146 
147 static struct code	FacNames[] = {
148 	"kern",		LOG_KERN,
149 	"user",		LOG_USER,
150 	"mail",		LOG_MAIL,
151 	"daemon",	LOG_DAEMON,
152 	"auth",		LOG_AUTH,
153 	"security",	LOG_AUTH,
154 	"mark",		LOG_MARK,
155 	"syslog",	LOG_SYSLOG,
156 	"lpr",		LOG_LPR,
157 	"news",		LOG_NEWS,
158 	"uucp",		LOG_UUCP,
159 	"altcron",	LOG_ALTCRON,
160 	"authpriv",	LOG_AUTHPRIV,
161 	"ftp",		LOG_FTP,
162 	"ntp",		LOG_NTP,
163 	"audit",	LOG_AUDIT,
164 	"console",	LOG_CONSOLE,
165 	"cron",		LOG_CRON,
166 	"local0",	LOG_LOCAL0,
167 	"local1",	LOG_LOCAL1,
168 	"local2",	LOG_LOCAL2,
169 	"local3",	LOG_LOCAL3,
170 	"local4",	LOG_LOCAL4,
171 	"local5",	LOG_LOCAL5,
172 	"local6",	LOG_LOCAL6,
173 	"local7",	LOG_LOCAL7,
174 	NULL,		-1
175 };
176 
177 static char		*TypeNames[7] = {
178 	"UNUSED",	"FILE",		"TTY",		"CONSOLE",
179 	"FORW",		"USERS",	"WALL"
180 };
181 
182 /*
183  * we allocate our own thread stacks so we can create them
184  * without the MAP_NORESERVE option. We need to be sure
185  * we have stack space even if the machine runs out of swap
186  */
187 
188 #define	DEFAULT_STACKSIZE (100 * 1024)  /* 100 k stack */
189 #define	DEFAULT_REDZONESIZE (8 * 1024)	/* 8k redzone */
190 
191 static pthread_mutex_t wmp = PTHREAD_MUTEX_INITIALIZER;	/* wallmsg lock */
192 
193 static pthread_mutex_t cft = PTHREAD_MUTEX_INITIALIZER;
194 static int conf_threads = 0;
195 
196 static pthread_mutex_t hup_lock = PTHREAD_MUTEX_INITIALIZER;
197 static pthread_cond_t hup_done = PTHREAD_COND_INITIALIZER;
198 
199 static pthread_mutex_t logerror_lock = PTHREAD_MUTEX_INITIALIZER;
200 
201 #define	HUP_ACCEPTABLE		0x0000	/* can start SIGHUP process */
202 #define	HUP_INPROGRESS		0x0001	/* SIGHUP process in progress */
203 #define	HUP_COMPLETED		0x0002	/* SIGHUP process completed */
204 #define	HUP_SUSP_LOGMSG_REQD	0x1000	/* request to suspend */
205 #define	HUP_LOGMSG_SUSPENDED	0x2000	/* logmsg is suspended */
206 static int hup_state = HUP_ACCEPTABLE;
207 
208 static size_t stacksize;		/* thread stack size */
209 static size_t redzonesize;		/* thread stack redzone size */
210 static char *stack_ptr;			/* ptr to allocated stacks */
211 static char *cstack_ptr;		/* ptr to conf_thr stacks */
212 
213 static time_t start_time;
214 
215 static pthread_t sys_thread;		/* queues messages from us */
216 static pthread_t net_thread;		/* queues messages from the net */
217 static pthread_t log_thread;		/* message processing thread */
218 static pthread_t hnl_thread;		/* hostname lookup thread */
219 
220 static dataq_t inputq;			/* the input queue */
221 static dataq_t tmpq;			/* temporary queue for err msg */
222 static dataq_t hnlq;			/* hostname lookup queue */
223 
224 static struct filed fallback[2];
225 static struct filed *Files;
226 static int nlogs;
227 static int Debug;			/* debug flag */
228 static host_list_t LocalHostName;	/* our hostname */
229 static host_list_t NullHostName;	/* in case of lookup failure */
230 static int debuglev = 1;		/* debug print level */
231 static int interrorlog;			/* internal error logging */
232 
233 static int MarkInterval = 20;		/* interval between marks (mins) */
234 static int Marking = 0;			/* non-zero if marking some file */
235 static int Ninputs = 0;			/* number of network inputs */
236 static int curalarm = 0;		/* current timeout value (secs) */
237 static int sys_msg_count = 0;		/* total msgs rcvd from local log */
238 static int sys_init_msg_count = 0;	/* initially received */
239 static int net_msg_count = 0;		/* total msgs rcvd from net */
240 
241 static struct pollfd Pfd;		/* Pollfd for local the log device */
242 static struct pollfd *Nfd;		/* Array of pollfds for udp ports */
243 static struct netconfig *Ncf;
244 static struct netbuf **Myaddrs;
245 static struct t_unitdata **Udp;
246 static struct t_uderr **Errp;
247 static int turnoff = 0;
248 static int shutting_down;
249 
250 /* for managing door server threads */
251 static pthread_mutex_t door_server_cnt_lock = PTHREAD_MUTEX_INITIALIZER;
252 static uint_t door_server_cnt = 0;
253 static pthread_attr_t door_thr_attr;
254 
255 static struct hostname_cache **hnc_cache;
256 static pthread_mutex_t hnc_mutex = PTHREAD_MUTEX_INITIALIZER;
257 static size_t hnc_size = DEF_HNC_SIZE;
258 static unsigned int hnc_ttl = DEF_HNC_TTL;
259 
260 #define	DPRINT0(d, m)		if ((Debug) && debuglev >= (d)) \
261 				(void) fprintf(stderr, m)
262 #define	DPRINT1(d, m, a)	if ((Debug) && debuglev >= (d)) \
263 				(void) fprintf(stderr, m, a)
264 #define	DPRINT2(d, m, a, b)	if ((Debug) && debuglev >= (d)) \
265 				(void) fprintf(stderr, m, a, b)
266 #define	DPRINT3(d, m, a, b, c)	if ((Debug) && debuglev >= (d)) \
267 				(void) fprintf(stderr, m, a, b, c)
268 #define	DPRINT4(d, m, a, b, c, e)	if ((Debug) && debuglev >= (d)) \
269 				(void) fprintf(stderr, m, a, b, c, e)
270 #define	MALLOC_FAIL(x)	\
271 		logerror("malloc failed: " x)
272 #define	MALLOC_FAIL_EXIT	\
273 		logerror("malloc failed - fatal"); \
274 		exit(1)
275 
276 
277 #define	MAILCMD "mailx -s \"syslogd shut down\" root"
278 
279 /*
280  * Number of seconds to wait before giving up on threads that won't
281  * shutdown: (that's right, 10 minutes!)
282  */
283 #define	LOOP_MAX	(10 * 60)
284 
285 /*
286  * Interval(sec) to check the status of output queue while processing
287  * HUP signal.
288  */
289 #define	LOOP_INTERVAL	(15)
290 
291 int
292 main(int argc, char **argv)
293 {
294 	int i;
295 	char *pstr;
296 	int sig, fd;
297 	int tflag = 0, Tflag = 0;
298 	sigset_t sigs, allsigs;
299 	struct rlimit rlim;
300 	char *debugstr;
301 	int mcount = 0;
302 	struct sigaction act;
303 	pthread_t mythreadno = 0;
304 	char cbuf [30];
305 	struct stat sb;
306 
307 #ifdef DEBUG
308 #define	DEBUGDIR "/var/tmp"
309 	if (chdir(DEBUGDIR))
310 		DPRINT2(1, "main(%u): Unable to cd to %s\n", mythreadno,
311 		    DEBUGDIR);
312 #endif /* DEBUG */
313 
314 	(void) setlocale(LC_ALL, "");
315 
316 	if ((debugstr = getenv("SYSLOGD_DEBUG")) != NULL)
317 		if ((debuglev = atoi(debugstr)) == 0)
318 			debuglev = 1;
319 
320 #if ! defined(TEXT_DOMAIN)	/* should be defined by cc -D */
321 #define	TEXT_DOMAIN "SYS_TEST"
322 #endif
323 	(void) textdomain(TEXT_DOMAIN);
324 
325 	(void) time(&start_time);
326 
327 	if (lstat("/var/run", &sb) != 0 || !(S_ISDIR(sb.st_mode))) {
328 		DoorFileName = OLD_DOORFILE;
329 		PidFileName  = OLD_PIDFILE;
330 	}
331 
332 	properties();
333 
334 	while ((i = getopt(argc, argv, "df:p:m:tT")) != EOF) {
335 		switch (i) {
336 		case 'f':		/* configuration file */
337 			ConfFile = optarg;
338 			break;
339 
340 		case 'd':		/* debug */
341 			Debug++;
342 			break;
343 
344 		case 'p':		/* path */
345 			LogName = optarg;
346 			break;
347 
348 		case 'm':		/* mark interval */
349 			for (pstr = optarg; *pstr; pstr++) {
350 				if (! (isdigit(*pstr))) {
351 					(void) fprintf(stderr,
352 					    "Illegal interval\n");
353 					usage();
354 				}
355 			}
356 			MarkInterval = atoi(optarg);
357 			if (MarkInterval < 1 || MarkInterval > INT_MAX) {
358 				(void) fprintf(stderr,
359 				    "Interval must be between 1 and %d\n",
360 				    INT_MAX);
361 				usage();
362 			}
363 			break;
364 		case 't':		/* turn off remote reception */
365 			tflag++;
366 			turnoff++;
367 			break;
368 		case 'T':		/* turn on remote reception */
369 			Tflag++;
370 			turnoff = 0;
371 			break;
372 		default:
373 			usage();
374 		}
375 	}
376 
377 	if (optind < argc)
378 		usage();
379 
380 	if (tflag && Tflag) {
381 		(void) fprintf(stderr, "specify only one of -t and -T\n");
382 		usage();
383 	}
384 
385 	/*
386 	 * close all fd's except 0-2
387 	 */
388 
389 	closefrom(3);
390 
391 	if (!Debug) {
392 		if (fork())
393 			return (0);
394 		(void) close(0);
395 		(void) open("/", 0);
396 		(void) dup2(0, 1);
397 		(void) dup2(0, 2);
398 		untty();
399 	}
400 
401 	if (Debug) {
402 		mythreadno = pthread_self();
403 	}
404 
405 	/*
406 	 * DO NOT call logerror() until tmpq is initialized.
407 	 */
408 	disable_errorlog();
409 
410 	/*
411 	 * ensure that file descriptor limit is "high enough"
412 	 */
413 	(void) getrlimit(RLIMIT_NOFILE, &rlim);
414 	if (rlim.rlim_cur < rlim.rlim_max)
415 		rlim.rlim_cur = rlim.rlim_max;
416 	if (setrlimit(RLIMIT_NOFILE, &rlim) < 0)
417 		logerror("Unable to increase file descriptor limit.");
418 	(void) enable_extended_FILE_stdio(-1, -1);
419 
420 	/* block all signals from all threads initially */
421 	(void) sigfillset(&allsigs);
422 	(void) pthread_sigmask(SIG_BLOCK, &allsigs, NULL);
423 
424 	DPRINT2(1, "main(%u): Started at time %s", mythreadno,
425 	    ctime_r(&start_time, cbuf));
426 
427 	init();			/* read configuration, start threads */
428 
429 	DPRINT1(1, "main(%u): off & running....\n", mythreadno);
430 
431 	/* now set up to catch signals we care about */
432 
433 	(void) sigemptyset(&sigs);
434 	(void) sigaddset(&sigs, SIGHUP);	/* reconfigure */
435 	(void) sigaddset(&sigs, SIGALRM);	/* mark & flush timer */
436 	(void) sigaddset(&sigs, SIGTERM);	/* exit */
437 	(void) sigaddset(&sigs, SIGINT);	/* exit if debugging */
438 	(void) sigaddset(&sigs, SIGQUIT);	/* exit if debugging */
439 	(void) sigaddset(&sigs, SIGPIPE);	/* catch & discard */
440 	(void) sigaddset(&sigs, SIGUSR1);	/* dump debug stats */
441 
442 	/*
443 	 * We must set up to catch these signals, even though sigwait
444 	 * will get them before the isr does.  Setting SA_SIGINFO ensures
445 	 * that signals will be enqueued.
446 	 */
447 
448 	act.sa_flags = SA_SIGINFO;
449 	act.sa_sigaction = signull;
450 
451 	(void) sigaction(SIGHUP, &act, NULL);
452 	(void) sigaction(SIGALRM, &act, NULL);
453 	(void) sigaction(SIGTERM, &act, NULL);
454 	(void) sigaction(SIGINT, &act, NULL);
455 	(void) sigaction(SIGQUIT, &act, NULL);
456 	(void) sigaction(SIGPIPE, &act, NULL);
457 	(void) sigaction(SIGUSR1, &act, NULL);
458 
459 	/* we now turn into the signal handling thread */
460 
461 	DPRINT1(2, "main(%u): now handling signals\n", mythreadno);
462 	for (;;) {
463 		(void) sigwait(&sigs, &sig);
464 		DPRINT2(2, "main(%u): received signal %d\n", mythreadno, sig);
465 		switch (sig) {
466 		case SIGALRM:
467 			DPRINT1(1, "main(%u): Got SIGALRM\n",
468 			    mythreadno);
469 			flushmsg(NOCOPY);
470 			if (Marking && (++mcount % MARKCOUNT == 0)) {
471 				if (logmymsg(LOG_INFO, "-- MARK --",
472 				    ADDDATE|MARK|NOCOPY, 0) == -1) {
473 					MALLOC_FAIL(
474 					    "dropping MARK message");
475 				}
476 
477 				mcount = 0;
478 			}
479 			curalarm = MarkInterval * 60 / MARKCOUNT;
480 			(void) alarm((unsigned)curalarm);
481 			DPRINT2(2, "main(%u): Next alarm in %d "
482 			    "seconds\n", mythreadno, curalarm);
483 			break;
484 		case SIGHUP:
485 			DPRINT1(1, "main(%u): got SIGHUP - "
486 			    "reconfiguring\n", mythreadno);
487 
488 			reconfigure();
489 
490 			DPRINT1(1, "main(%u): done processing SIGHUP\n",
491 			    mythreadno);
492 			break;
493 		case SIGQUIT:
494 		case SIGINT:
495 			if (!Debug) {
496 				/* allow these signals if debugging */
497 				break;
498 			}
499 			/* FALLTHROUGH */
500 		case SIGTERM:
501 			DPRINT2(1, "main(%u): going down on signal %d\n",
502 			    mythreadno, sig);
503 			(void) alarm(0);
504 			flushmsg(0);
505 			errno = 0;
506 			t_errno = 0;
507 			logerror("going down on signal %d", sig);
508 			disable_errorlog();	/* force msg to console */
509 			(void) shutdown_msg();	/* stop threads */
510 			shutdown_input();
511 			close_door();
512 			delete_doorfiles();
513 			return (0);
514 		case SIGUSR1:			/* secret debug dump mode */
515 			/* if in debug mode, use stdout */
516 
517 			if (Debug) {
518 				dumpstats(STDOUT_FILENO);
519 				break;
520 			}
521 			/* otherwise dump to a debug file */
522 			if ((fd = open(DEBUGFILE,
523 			    (O_WRONLY|O_CREAT|O_TRUNC|O_EXCL),
524 			    0644)) < 0)
525 				break;
526 			dumpstats(fd);
527 			(void) close(fd);
528 			break;
529 		default:
530 			DPRINT2(2, "main(%u): unexpected signal %d\n",
531 			    mythreadno, sig);
532 			break;
533 		}
534 	}
535 }
536 
537 /*
538  * Attempts to open the local log device
539  * and return a file descriptor.
540  */
541 static int
542 openklog(char *name, int mode)
543 {
544 	int fd;
545 	struct strioctl str;
546 	pthread_t mythreadno;
547 
548 	if (Debug) {
549 		mythreadno = pthread_self();
550 	}
551 
552 	if ((fd = open(name, mode)) < 0) {
553 		logerror("cannot open %s", name);
554 		DPRINT3(1, "openklog(%u): cannot create %s (%d)\n",
555 		    mythreadno, name, errno);
556 		return (-1);
557 	}
558 	str.ic_cmd = I_CONSLOG;
559 	str.ic_timout = 0;
560 	str.ic_len = 0;
561 	str.ic_dp = NULL;
562 	if (ioctl(fd, I_STR, &str) < 0) {
563 		logerror("cannot register to log console messages");
564 		DPRINT2(1, "openklog(%u): cannot register to log "
565 		    "console messages (%d)\n", mythreadno, errno);
566 		return (-1);
567 	}
568 	return (fd);
569 }
570 
571 
572 /*
573  * Open the log device, and pull up all pending messages.
574  */
575 static void
576 prepare_sys_poll()
577 {
578 	int nfds, funix;
579 
580 	if ((funix = openklog(LogName, O_RDONLY)) < 0) {
581 		logerror("can't open kernel log device - fatal");
582 		exit(1);
583 	}
584 
585 	Pfd.fd = funix;
586 	Pfd.events = POLLIN;
587 
588 	for (;;) {
589 		nfds = poll(&Pfd, 1, 0);
590 		if (nfds <= 0) {
591 			if (sys_init_msg_count > 0)
592 				flushmsg(SYNC_FILE);
593 			break;
594 		}
595 
596 		if (Pfd.revents & POLLIN) {
597 			getkmsg(0);
598 		} else if (Pfd.revents & (POLLNVAL|POLLHUP|POLLERR)) {
599 			logerror("kernel log driver poll error");
600 			break;
601 		}
602 	}
603 
604 }
605 
606 /*
607  * this thread listens to the local stream log driver for log messages
608  * generated by this host, formats them, and queues them to the logger
609  * thread.
610  */
611 /*ARGSUSED*/
612 static void *
613 sys_poll(void *ap)
614 {
615 	int nfds;
616 	static int klogerrs = 0;
617 	pthread_t mythreadno;
618 
619 	if (Debug) {
620 		mythreadno = pthread_self();
621 	}
622 
623 	DPRINT1(1, "sys_poll(%u): sys_thread started\n", mythreadno);
624 
625 	/*
626 	 * Process messages, blocking on poll because timeout is set
627 	 * to INFTIM.  When poll returns with a message, call getkmsg
628 	 * to pull up one message from the log driver and enqueue it
629 	 * with the sync flag set.
630 	 */
631 
632 	sys_init_msg_count = 0;
633 
634 	for (;;) {
635 		errno = 0;
636 		t_errno = 0;
637 
638 		nfds = poll(&Pfd, 1, INFTIM);
639 
640 		if (nfds == 0)
641 			continue;
642 
643 		if (nfds < 0) {
644 			if (errno != EINTR)
645 				logerror("poll");
646 			continue;
647 		}
648 		if (Pfd.revents & POLLIN) {
649 			getkmsg(INFTIM);
650 		} else {
651 			if (shutting_down) {
652 				pthread_exit(0);
653 			}
654 			if (Pfd.revents & (POLLNVAL|POLLHUP|POLLERR)) {
655 				logerror("kernel log driver poll error");
656 				(void) close(Pfd.fd);
657 				Pfd.fd = -1;
658 			}
659 		}
660 
661 		while (Pfd.fd == -1 && klogerrs++ < 10) {
662 			Pfd.fd = openklog(LogName, O_RDONLY);
663 		}
664 		if (klogerrs >= 10) {
665 			logerror("can't reopen kernel log device - fatal");
666 			exit(1);
667 		}
668 	}
669 	/*NOTREACHED*/
670 	return (NULL);
671 }
672 
673 /*
674  * Pull up one message from log driver.
675  */
676 static void
677 getkmsg(int timeout)
678 {
679 	int flags = 0, i;
680 	char *lastline;
681 	struct strbuf ctl, dat;
682 	struct log_ctl hdr;
683 	char buf[MAXLINE+1];
684 	size_t buflen;
685 	size_t len;
686 	char tmpbuf[MAXLINE+1];
687 	pthread_t mythreadno;
688 
689 	if (Debug) {
690 		mythreadno = pthread_self();
691 	}
692 
693 	dat.maxlen = MAXLINE;
694 	dat.buf = buf;
695 	ctl.maxlen = sizeof (struct log_ctl);
696 	ctl.buf = (caddr_t)&hdr;
697 
698 	while ((i = getmsg(Pfd.fd, &ctl, &dat, &flags)) == MOREDATA) {
699 		lastline = &dat.buf[dat.len];
700 		*lastline = '\0';
701 
702 		DPRINT2(5, "getkmsg:(%u): getmsg: dat.len = %d\n",
703 		    mythreadno, dat.len);
704 		buflen = strlen(buf);
705 		len = findnl_bkwd(buf, buflen);
706 
707 		(void) memcpy(tmpbuf, buf, len);
708 		tmpbuf[len] = '\0';
709 
710 		/*
711 		 * Format sys will enqueue the log message.
712 		 * Set the sync flag if timeout != 0, which
713 		 * means that we're done handling all the
714 		 * initial messages ready during startup.
715 		 */
716 		if (timeout == 0) {
717 			formatsys(&hdr, tmpbuf, 0);
718 			sys_init_msg_count++;
719 		} else {
720 			formatsys(&hdr, tmpbuf, 1);
721 		}
722 		sys_msg_count++;
723 
724 		if (len != buflen) {
725 			/* If anything remains in buf */
726 			size_t remlen;
727 
728 			if (buf[len] == '\n') {
729 				/* skip newline */
730 				len++;
731 			}
732 
733 			/*
734 			 *  Move the remaining bytes to
735 			 * the beginnning of buf.
736 			 */
737 
738 			remlen = buflen - len;
739 			(void) memcpy(buf, &buf[len], remlen);
740 			dat.maxlen = MAXLINE - remlen;
741 			dat.buf = &buf[remlen];
742 		} else {
743 			dat.maxlen = MAXLINE;
744 			dat.buf = buf;
745 		}
746 	}
747 
748 	if (i == 0 && dat.len > 0) {
749 		dat.buf[dat.len] = '\0';
750 		/*
751 		 * Format sys will enqueue the log message.
752 		 * Set the sync flag if timeout != 0, which
753 		 * means that we're done handling all the
754 		 * initial messages ready during startup.
755 		 */
756 		DPRINT2(5, "getkmsg(%u): getmsg: dat.maxlen = %d\n",
757 		    mythreadno, dat.maxlen);
758 		DPRINT2(5, "getkmsg(%u): getmsg: dat.len = %d\n",
759 		    mythreadno, dat.len);
760 		DPRINT2(5, "getkmsg(%u): getmsg: strlen(dat.buf) = %d\n",
761 		    mythreadno, strlen(dat.buf));
762 		DPRINT2(5, "getkmsg(%u): getmsg: dat.buf = \"%s\"\n",
763 		    mythreadno, dat.buf);
764 		DPRINT2(5, "getkmsg(%u): buf len = %d\n",
765 		    mythreadno, strlen(buf));
766 		if (timeout == 0) {
767 			formatsys(&hdr, buf, 0);
768 			sys_init_msg_count++;
769 		} else {
770 			formatsys(&hdr, buf, 1);
771 		}
772 		sys_msg_count++;
773 	} else if (i < 0 && errno != EINTR) {
774 		if (!shutting_down) {
775 			logerror("kernel log driver read error");
776 		}
777 		(void) close(Pfd.fd);
778 		Pfd.fd = -1;
779 	}
780 }
781 
782 /*
783  * this thread polls all the network interfaces for syslog messages
784  * forwarded to us, tags them with the hostname they are received
785  * from, and queues them to the logger thread.
786  */
787 /*ARGSUSED*/
788 static void *
789 net_poll(void *ap)
790 {
791 	int nfds, i;
792 	int flags = 0;
793 	struct t_unitdata *udp;
794 	struct t_uderr *errp;
795 	char buf[MAXLINE+1];
796 	char *uap;
797 	log_message_t *mp;
798 	host_info_t *hinfo;
799 	pthread_t mythreadno;
800 
801 	if (Debug) {
802 		mythreadno = pthread_self();
803 	}
804 
805 	DPRINT1(1, "net_poll(%u): net_thread started\n", mythreadno);
806 
807 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp))
808 
809 	for (;;) {
810 		errno = 0;
811 		t_errno = 0;
812 		nfds = poll(Nfd, Ninputs, -1);
813 		if (nfds == 0)
814 			continue;
815 
816 		if (nfds < 0) {
817 			if (errno != EINTR)
818 				logerror("poll");
819 			continue;
820 		}
821 		for (i = 0; nfds > 0 && i < Ninputs; i++) {
822 			if ((Nfd[i].revents & POLLIN) == 0) {
823 				if (shutting_down) {
824 					pthread_exit(0);
825 				}
826 				if (Nfd[i].revents &
827 				    (POLLNVAL|POLLHUP|POLLERR)) {
828 					logerror("POLLNVAL|POLLHUP|POLLERR");
829 					(void) t_close(Nfd[i].fd);
830 					Nfd[i].fd = -1;
831 					nfds--;
832 				}
833 				continue;
834 			}
835 
836 			udp = Udp[i];
837 			udp->udata.buf = buf;
838 			udp->udata.maxlen = MAXLINE;
839 			udp->udata.len = 0;
840 			flags = 0;
841 			if (t_rcvudata(Nfd[i].fd, udp, &flags) < 0) {
842 				errp = Errp[i];
843 				if (t_errno == TLOOK) {
844 					if (t_rcvuderr(Nfd[i].fd, errp) < 0) {
845 						if (!shutting_down) {
846 							logerror("t_rcvuderr");
847 						}
848 						(void) t_close(Nfd[i].fd);
849 						Nfd[i].fd = -1;
850 					}
851 				} else {
852 					if (!shutting_down) {
853 						logerror("t_rcvudata");
854 					}
855 					(void) t_close(Nfd[i].fd);
856 					Nfd[i].fd = -1;
857 				}
858 				nfds--;
859 				if (shutting_down) {
860 					pthread_exit(0);
861 				}
862 				continue;
863 			}
864 			nfds--;
865 
866 			if (udp->udata.len == 0) {
867 				if (Debug) {
868 					uap = NULL;
869 					if (udp->addr.len > 0) {
870 						uap = taddr2uaddr(&Ncf[i],
871 						    &udp->addr);
872 					}
873 					DPRINT2(1, "net_poll(%u):"
874 					    " received empty packet"
875 					    " from %s\n", mythreadno,
876 					    uap ? uap : "<unknown>");
877 					if (uap)
878 						free(uap);
879 				}
880 				continue;	/* No data */
881 			}
882 			if (udp->addr.len == 0) {
883 				/*
884 				 * The previous message was larger than
885 				 * MAXLINE, and T_MORE should have been set.
886 				 * Further data needs to be discarded as
887 				 * we've already received MAXLINE.
888 				 */
889 				DPRINT1(1, "net_poll(%u): discarding packet "
890 				    "exceeds max line size\n", mythreadno);
891 				continue;
892 			}
893 
894 			net_msg_count++;
895 
896 			if ((mp = new_msg()) == NULL) {
897 				MALLOC_FAIL("dropping message from "
898 				    "remote");
899 				continue;
900 			}
901 
902 			buf[udp->udata.len] = '\0';
903 			formatnet(&udp->udata, mp);
904 
905 			if (Debug) {
906 				uap = taddr2uaddr(&Ncf[i], &udp->addr);
907 				DPRINT2(1, "net_poll(%u): received message"
908 				    " from %s\n", mythreadno,
909 				    uap ? uap : "<unknown>");
910 				free(uap);
911 			}
912 			if ((hinfo = malloc(sizeof (*hinfo))) == NULL ||
913 			    (hinfo->addr.buf =
914 			    malloc(udp->addr.len)) == NULL) {
915 				MALLOC_FAIL("dropping message from "
916 				    "remote");
917 				if (hinfo) {
918 					free(hinfo);
919 				}
920 				free_msg(mp);
921 				continue;
922 			}
923 
924 			hinfo->ncp = &Ncf[i];
925 			hinfo->addr.len = udp->addr.len;
926 			(void) memcpy(hinfo->addr.buf, udp->addr.buf,
927 			    udp->addr.len);
928 			mp->ptr = hinfo;
929 			if (dataq_enqueue(&hnlq, (void *)mp) == -1) {
930 				MALLOC_FAIL("dropping message from "
931 				    "remote");
932 				free_msg(mp);
933 				free(hinfo->addr.buf);
934 				free(hinfo);
935 				continue;
936 			}
937 			DPRINT3(5, "net_poll(%u): enqueued msg %p "
938 			    "on queue %p\n", mythreadno, (void *)mp,
939 			    (void *)&hnlq);
940 		}
941 	}
942 	/*NOTREACHED*/
943 	return (NULL);
944 }
945 
946 static void
947 usage(void)
948 {
949 	(void) fprintf(stderr,
950 	    "usage: syslogd [-d] [-t|-T] [-mmarkinterval] [-ppath]"
951 	    " [-fconffile]\n");
952 	exit(1);
953 }
954 
955 static void
956 untty(void)
957 {
958 	if (!Debug)
959 		(void) setsid();
960 }
961 
962 /*
963  * generate a log message internally. The original version of syslogd
964  * simply called logmsg directly, but because everything is now based
965  * on message passing, we need an internal way to generate and queue
966  * log messages from within syslogd itself.
967  */
968 static int
969 logmymsg(int pri, char *msg, int flags, int pending)
970 {
971 	log_message_t *mp;
972 	pthread_t mythreadno;
973 	dataq_t *qptr;
974 
975 	if (Debug) {
976 		mythreadno = pthread_self();
977 	}
978 
979 	if ((mp = new_msg()) == NULL) {
980 		return (-1);
981 	}
982 
983 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp))
984 	mp->pri = pri;
985 	mp->hlp = &LocalHostName;
986 	(void) strlcpy(mp->msg, msg, MAXLINE+1);
987 	mp->flags = flags;
988 	(void) time(&mp->ts);
989 
990 	qptr = pending ? &tmpq : &inputq;
991 	if (dataq_enqueue(qptr, (void *)mp) == -1) {
992 		free_msg(mp);
993 		return (-1);
994 	}
995 
996 	DPRINT3(5, "logmymsg(%u): enqueued msg %p on queue %p\n",
997 	    mythreadno, (void *)mp, (void *)qptr);
998 	DPRINT2(5, "logmymsg(%u): Message content: %s\n", mythreadno, msg);
999 	return (0);
1000 }
1001 
1002 /*
1003  * Generate an internal shutdown message
1004  */
1005 static int
1006 shutdown_msg(void)
1007 {
1008 	pthread_t mythreadno;
1009 	log_message_t *mp;
1010 
1011 	if (Debug) {
1012 		mythreadno = pthread_self();
1013 	}
1014 
1015 	if ((mp = new_msg()) == NULL) {
1016 		return (-1);
1017 	}
1018 
1019 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp));
1020 	mp->flags = SHUTDOWN;
1021 	mp->hlp = &LocalHostName;
1022 
1023 	if (dataq_enqueue(&inputq, (void *)mp) == -1) {
1024 		free_msg(mp);
1025 		return (-1);
1026 	}
1027 
1028 	DPRINT3(5, "shutdown_msg(%u): enqueued msg %p on queue %p\n",
1029 	    mythreadno, (void *)mp, (void *)&inputq);
1030 	return (0);
1031 }
1032 
1033 /*
1034  * Generate an internal flush message
1035  */
1036 static void
1037 flushmsg(int flags)
1038 {
1039 	log_message_t *mp;
1040 	pthread_t mythreadno;
1041 
1042 	if (Debug) {
1043 		mythreadno = pthread_self();
1044 	}
1045 
1046 	if ((mp = new_msg()) == NULL) {
1047 		MALLOC_FAIL("dropping flush msg");
1048 		return;
1049 	}
1050 
1051 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp));
1052 	mp->flags = FLUSHMSG | flags;
1053 	mp->hlp = &LocalHostName;
1054 
1055 	if (dataq_enqueue(&inputq, (void *)mp) == -1) {
1056 		free_msg(mp);
1057 		MALLOC_FAIL("dropping flush msg");
1058 		return;
1059 	}
1060 
1061 	DPRINT4(5, "flush_msg(%u): enqueued msg %p on queue %p, flags "
1062 	    "0x%x\n", mythreadno, (void *)mp, (void *)&inputq, flags);
1063 }
1064 
1065 /*
1066  * Do some processing on messages received from the net
1067  */
1068 static void
1069 formatnet(struct netbuf *nbp, log_message_t *mp)
1070 {
1071 	char *p;
1072 	int pri;
1073 	pthread_t mythreadno;
1074 
1075 	if (Debug) {
1076 		mythreadno = pthread_self();
1077 	}
1078 
1079 	DPRINT2(5, "formatnet(%u): called for msg %p\n", mythreadno,
1080 	    (void *)mp);
1081 
1082 	mp->flags = NETWORK;
1083 	(void) time(&mp->ts);
1084 
1085 	/* test for special codes */
1086 	pri = DEFUPRI;
1087 	p = nbp->buf;
1088 	DPRINT2(9, "formatnet(%u): Message content:\n>%s<\n", mythreadno,
1089 	    p);
1090 	if (*p == '<' && isdigit(*(p+1))) {
1091 		pri = 0;
1092 		while (isdigit(*++p))
1093 			pri = 10 * pri + (*p - '0');
1094 		if (*p == '>')
1095 			++p;
1096 		if (pri <= 0 || pri >= (LOG_NFACILITIES << 3))
1097 			pri = DEFUPRI;
1098 	}
1099 
1100 	mp->pri = pri;
1101 	(void) strlcpy(mp->msg, p, MAXLINE+1);
1102 }
1103 
1104 /*
1105  * Do some processing on messages generated by this host
1106  * and then enqueue the log message.
1107  */
1108 static void
1109 formatsys(struct log_ctl *lp, char *msg, int sync)
1110 {
1111 	char *p, *q;
1112 	char line[MAXLINE + 1];
1113 	size_t msglen;
1114 	log_message_t	*mp;
1115 	char cbuf[30];
1116 	pthread_t mythreadno;
1117 
1118 	if (Debug) {
1119 		mythreadno = pthread_self();
1120 	}
1121 
1122 	DPRINT3(3, "formatsys(%u): log_ctl.mid = %d, log_ctl.sid = %d\n",
1123 	    mythreadno, lp->mid, lp->sid);
1124 	DPRINT2(9, "formatsys(%u): Message Content:\n>%s<\n", mythreadno,
1125 	    msg);
1126 
1127 	/* msglen includes the null termination */
1128 	msglen = strlen(msg) + 1;
1129 
1130 	for (p = msg; *p != '\0'; ) {
1131 		size_t linelen;
1132 		size_t len;
1133 
1134 		/*
1135 		 * Allocate a log_message_t structure.
1136 		 * We should do it here since a single message (msg)
1137 		 * could be composed of many lines.
1138 		 */
1139 		_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp));
1140 
1141 		if ((mp = new_msg()) == NULL) {
1142 			MALLOC_FAIL("dropping message");
1143 			/*
1144 			 * Should bail out from the loop.
1145 			 */
1146 			break;
1147 		}
1148 
1149 		mp->flags &= ~NETWORK;
1150 		mp->hlp = &LocalHostName;
1151 		mp->ts = lp->ttime;
1152 		if (lp->flags & SL_LOGONLY)
1153 			mp->flags |= IGN_CONS;
1154 		if (lp->flags & SL_CONSONLY)
1155 			mp->flags |= IGN_FILE;
1156 
1157 		/* extract facility */
1158 		if ((lp->pri & LOG_FACMASK) == LOG_KERN) {
1159 			(void) sprintf(line, "%.15s ",
1160 			    ctime_r(&mp->ts, cbuf) + 4);
1161 		} else {
1162 			(void) sprintf(line, "");
1163 		}
1164 
1165 		linelen = strlen(line);
1166 		q = line + linelen;
1167 
1168 		DPRINT2(5, "formatsys(%u): msglen = %d\n", mythreadno, msglen);
1169 		len = copynl_frwd(q, MAXLINE + 1 - linelen, p, msglen);
1170 		DPRINT2(5, "formatsys(%u): len (copynl_frwd) = %d\n",
1171 		    mythreadno, len);
1172 
1173 		p += len;
1174 		msglen -= len;
1175 
1176 		if (*p == '\n') {
1177 			/* skip newline */
1178 			p++;
1179 		}
1180 
1181 		if (sync && ((lp->pri & LOG_FACMASK) == LOG_KERN))
1182 			mp->flags |= SYNC_FILE;	/* fsync file after write */
1183 
1184 		if (len != 0) {
1185 			(void) strlcpy(mp->msg, line, MAXLINE+1);
1186 			mp->pri = lp->pri;
1187 
1188 			if (dataq_enqueue(&inputq, (void *)mp) == -1) {
1189 				free_msg(mp);
1190 				MALLOC_FAIL("dropping message");
1191 				break;
1192 			}
1193 
1194 			DPRINT3(5, "formatsys(%u): sys_thread enqueued msg "
1195 			    "%p on queue %p\n", mythreadno, (void *)mp,
1196 			    (void *)&inputq);
1197 		} else
1198 			free_msg(mp);
1199 	}
1200 }
1201 
1202 /*
1203  * Log a message to the appropriate log files, users, etc. based on
1204  * the priority.
1205  */
1206 /*ARGSUSED*/
1207 static void *
1208 logmsg(void *ap)
1209 {
1210 	struct filed *f;
1211 	int fac, prilev, flags, refcnt;
1212 	int fake_shutdown, skip_shutdown;
1213 	log_message_t *mp, *save_mp;
1214 	pthread_t mythreadno;
1215 
1216 	if (Debug) {
1217 		mythreadno = pthread_self();
1218 	}
1219 
1220 	DPRINT1(1, "logmsg(%u): msg dispatcher started\n", mythreadno);
1221 
1222 	fake_shutdown = skip_shutdown = 0;
1223 	save_mp = NULL;
1224 	for (;;) {
1225 		if (save_mp) {
1226 			/*
1227 			 * If we have set aside a message in order to fake a
1228 			 * SHUTDOWN, use that message before picking from the
1229 			 * queue again.
1230 			 */
1231 			mp = save_mp;
1232 			save_mp = NULL;
1233 		} else {
1234 			(void) dataq_dequeue(&inputq, (void **)&mp, 0);
1235 		}
1236 		_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp))
1237 		DPRINT3(5, "logmsg(%u): msg dispatcher dequeued %p from "
1238 		    "queue %p\n", mythreadno, (void *)mp,
1239 		    (void *)&inputq);
1240 
1241 		/*
1242 		 * In most cases, if the message traffic is low, logmsg() wakes
1243 		 * up when it receives the SHUTDOWN msg, and will sleep until
1244 		 * HUP process is complete.  However, if the inputq is too
1245 		 * long, logmsg() may not receive SHUTDOWN before reconfigure()
1246 		 * releases the logger fds, filed and logit threads.  That, in
1247 		 * turn, will cause logmsg to refer to invalid fileds.
1248 		 *
1249 		 * logmsg() needs to respond to the SHUTDOWN message within
1250 		 * LOOP_INTERVAL seconds when reconfigure() enqueues it. It
1251 		 * does so in most cases.  When it does not respond in time,
1252 		 * logmsg() needs to be in suspended state immediately, since
1253 		 * filed may have been invalidated. reconfigure() will set the
1254 		 * HUP_SUSP_LOGMSG_REQD bit in hup_state and wait another
1255 		 * LOOP_INTERVAL seconds before proceeding.
1256 		 *
1257 		 * When HUP_SUSP_LOGMSG_REQD is set, we will create a fake
1258 		 * SHUTDOWN message, and dispatch it to the various logit
1259 		 * threads, and logmsg() itself will suspend.  In order to
1260 		 * ignore the real SHUTDOWN which will arrive later, we keep a
1261 		 * counter (skip_shutdown) and decrement it when the SHUTDOWN
1262 		 * message arrives.
1263 		 */
1264 		if ((hup_state & HUP_SUSP_LOGMSG_REQD) &&
1265 		    (mp->flags & SHUTDOWN) == 0) {
1266 			DPRINT1(3, "logmsg(%u): suspend request\n",
1267 			    mythreadno);
1268 
1269 			save_mp = mp;
1270 
1271 			/* create a fake SHUTDOWN msg */
1272 			if ((mp = new_msg()) == NULL) {
1273 				MALLOC_FAIL("dropping message");
1274 				if (mp->flags & SHUTDOWN) {
1275 					(void) logerror_to_console(1,
1276 					    "unable to shutdown "
1277 					    "logger thread");
1278 				}
1279 				continue;
1280 			}
1281 			mp->flags = SHUTDOWN;
1282 			mp->hlp = &LocalHostName;
1283 			fake_shutdown = 1;
1284 			skip_shutdown++;
1285 			DPRINT2(3, "logmsg(%u): pending SHUTDOWN %d\n",
1286 			    mythreadno, skip_shutdown);
1287 		}
1288 
1289 		/*
1290 		 * is it a shutdown or flush message ?
1291 		 */
1292 		if ((mp->flags & SHUTDOWN) || (mp->flags & FLUSHMSG)) {
1293 			(void) pthread_mutex_lock(&mp->msg_mutex);
1294 
1295 			if ((mp->flags & SHUTDOWN) &&
1296 			    !fake_shutdown && skip_shutdown > 0) {
1297 				skip_shutdown--;
1298 				(void) pthread_mutex_unlock(&mp->msg_mutex);
1299 				free_msg(mp);
1300 				DPRINT2(3, "logmsg(%u): released late "
1301 				    "arrived SHUTDOWN. pending %d\n",
1302 				    mythreadno, skip_shutdown);
1303 				continue;
1304 			}
1305 
1306 			for (f = Files; f < &Files[nlogs]; f++) {
1307 				(void) pthread_mutex_lock(&f->filed_mutex);
1308 
1309 				if (f->f_type == F_UNUSED) {
1310 					(void) pthread_mutex_unlock(
1311 					    &f->filed_mutex);
1312 					continue;
1313 				}
1314 
1315 				f->f_queue_count++;
1316 				mp->refcnt++;
1317 
1318 				if (dataq_enqueue(&f->f_queue,
1319 				    (void *)mp) == -1) {
1320 					f->f_queue_count--;
1321 					mp->refcnt--;
1322 					(void) pthread_mutex_unlock(
1323 					    &f->filed_mutex);
1324 					MALLOC_FAIL("dropping message");
1325 
1326 					if (mp->flags & SHUTDOWN) {
1327 						(void) logerror_to_console(1,
1328 						    "unable to shutdown "
1329 						    "logger thread");
1330 					}
1331 
1332 					continue;
1333 				}
1334 				DPRINT3(5, "logmsg(%u): enqueued msg %p "
1335 				    "on queue %p\n", mythreadno,
1336 				    (void *)mp, (void *)&f->f_queue);
1337 				(void) pthread_mutex_unlock(&f->filed_mutex);
1338 			}
1339 
1340 			/*
1341 			 * flags value needs to be saved because mp may
1342 			 * have been freed before SHUTDOWN test below.
1343 			 */
1344 			flags = mp->flags;
1345 			refcnt = mp->refcnt;
1346 
1347 			(void) pthread_mutex_unlock(&mp->msg_mutex);
1348 			if (refcnt == 0)
1349 				free_msg(mp);
1350 
1351 			if (flags & SHUTDOWN) {
1352 				(void) pthread_mutex_lock(&hup_lock);
1353 				while (hup_state != HUP_COMPLETED) {
1354 					hup_state |= HUP_LOGMSG_SUSPENDED;
1355 					(void) pthread_cond_wait(&hup_done,
1356 					    &hup_lock);
1357 					hup_state &= ~HUP_LOGMSG_SUSPENDED;
1358 				}
1359 				hup_state = HUP_ACCEPTABLE;
1360 				(void) pthread_mutex_unlock(&hup_lock);
1361 				fake_shutdown = 0;
1362 			}
1363 			continue;
1364 		}
1365 
1366 		/*
1367 		 * Check to see if msg looks non-standard.
1368 		 */
1369 		if ((int)strlen(mp->msg) < 16 || mp->msg[3] != ' ' ||
1370 		    mp->msg[6] != ' ' || mp->msg[9] != ':' ||
1371 		    mp->msg[12] != ':' || mp->msg[15] != ' ')
1372 			mp->flags |= ADDDATE;
1373 
1374 		/* extract facility and priority level */
1375 		fac = (mp->pri & LOG_FACMASK) >> 3;
1376 		if (mp->flags & MARK)
1377 			fac = LOG_NFACILITIES;
1378 		prilev = mp->pri & LOG_PRIMASK;
1379 
1380 		DPRINT3(3, "logmsg(%u): fac = %d, pri = %d\n",
1381 		    mythreadno, fac, prilev);
1382 
1383 		/*
1384 		 * Because different devices log at different speeds,
1385 		 * it's important to hold the mutex for the current
1386 		 * message until it's been enqueued to all log files,
1387 		 * so the reference count is accurate before any
1388 		 * of the log threads can decrement it.
1389 		 */
1390 		_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mp))
1391 		_NOTE(COMPETING_THREADS_NOW)
1392 		(void) pthread_mutex_lock(&mp->msg_mutex);
1393 
1394 		for (f = Files; f < &Files[nlogs]; f++) {
1395 			/* skip messages that are incorrect priority */
1396 			if (f->f_pmask[fac] < (unsigned)prilev ||
1397 			    f->f_pmask[fac] == NOPRI)
1398 				continue;
1399 			if (f->f_queue_count > Q_HIGHWATER_MARK) {
1400 				DPRINT4(5, "logmsg(%u): Dropping message "
1401 				    "%p on file %p, count = %d\n",
1402 				    mythreadno, (void *)mp, (void *)f,
1403 				    f->f_queue_count);
1404 				continue;
1405 			}
1406 
1407 			/*
1408 			 * Need to grab filed_mutex before testing the f_type.
1409 			 * Otherwise logit() may set F_UNUSED after the test
1410 			 * below, and start pulling out the pending messages.
1411 			 */
1412 
1413 			(void) pthread_mutex_lock(&f->filed_mutex);
1414 
1415 			if (f->f_type == F_UNUSED ||
1416 			    (f->f_type == F_FILE && (mp->flags & IGN_FILE)) ||
1417 			    (f->f_type == F_CONSOLE &&
1418 			    (mp->flags & IGN_CONS))) {
1419 				(void) pthread_mutex_unlock(&f->filed_mutex);
1420 				continue;
1421 			}
1422 
1423 			f->f_queue_count++;
1424 			mp->refcnt++;
1425 
1426 			if (dataq_enqueue(&f->f_queue, (void *)mp) == -1) {
1427 				f->f_queue_count--;
1428 				mp->refcnt--;
1429 				(void) pthread_mutex_unlock(&f->filed_mutex);
1430 				MALLOC_FAIL("dropping message");
1431 				continue;
1432 			}
1433 
1434 			DPRINT3(5, "logmsg(%u): enqueued msg %p on queue "
1435 			    "%p\n", mythreadno, (void *)mp,
1436 			    (void *)&f->f_queue);
1437 			(void) pthread_mutex_unlock(&f->filed_mutex);
1438 		}
1439 		refcnt = mp->refcnt;
1440 		(void) pthread_mutex_unlock(&mp->msg_mutex);
1441 		if (refcnt == 0)
1442 			free_msg(mp);
1443 	}
1444 	/*NOTREACHED*/
1445 	return (NULL);
1446 }
1447 
1448 /*
1449  * function to actually write the log message to the selected file.
1450  * each file has a logger thread that runs this routine. The function
1451  * is called with a pointer to its file structure.
1452  */
1453 static void *
1454 logit(void *ap)
1455 {
1456 	struct filed *f = ap;
1457 	log_message_t *mp;
1458 	int forwardingloop = 0;
1459 	const char *errmsg = "logit(%u): %s to %s forwarding loop detected\n";
1460 	int i, currofst, prevofst, refcnt;
1461 	host_list_t *hlp;
1462 
1463 	assert(f != NULL);
1464 
1465 	DPRINT4(5, "logit(%u): logger started for \"%s\" (queue %p, filed "
1466 	    "%p)\n", f->f_thread, f->f_un.f_fname, (void *)&f->f_queue,
1467 	    (void *)f);
1468 	_NOTE(COMPETING_THREADS_NOW);
1469 
1470 	while (f->f_type != F_UNUSED) {
1471 		(void) dataq_dequeue(&f->f_queue, (void **)&mp, 0);
1472 		DPRINT3(5, "logit(%u): logger dequeued msg %p from queue "
1473 		    "%p\n", f->f_thread, (void *)mp, (void *)&f->f_queue);
1474 		(void) pthread_mutex_lock(&f->filed_mutex);
1475 		assert(f->f_queue_count > 0);
1476 		f->f_queue_count--;
1477 		(void) pthread_mutex_unlock(&f->filed_mutex);
1478 		assert(mp->refcnt > 0);
1479 
1480 		/*
1481 		 * is it a shutdown message ?
1482 		 */
1483 		if (mp->flags & SHUTDOWN) {
1484 			(void) pthread_mutex_lock(&mp->msg_mutex);
1485 			refcnt = --mp->refcnt;
1486 			(void) pthread_mutex_unlock(&mp->msg_mutex);
1487 			if (refcnt == 0)
1488 				free_msg(mp);
1489 			break;
1490 		}
1491 
1492 		/*
1493 		 * Is it a logsync message?
1494 		 */
1495 		if ((mp->flags & (FLUSHMSG | LOGSYNC)) ==
1496 		    (FLUSHMSG | LOGSYNC)) {
1497 			if (f->f_type != F_FILE)
1498 				goto out;	/* nothing to do */
1499 			(void) close(f->f_file);
1500 			f->f_file = open64(f->f_un.f_fname,
1501 			    O_WRONLY|O_APPEND|O_NOCTTY);
1502 			if (f->f_file < 0) {
1503 				f->f_type = F_UNUSED;
1504 				logerror(f->f_un.f_fname);
1505 				f->f_stat.errs++;
1506 			}
1507 			goto out;
1508 		}
1509 
1510 		/*
1511 		 * If the message flags include both flush and sync,
1512 		 * then just sync the file out to disk if appropriate.
1513 		 */
1514 		if ((mp->flags & (FLUSHMSG | SYNC_FILE)) ==
1515 		    (FLUSHMSG | SYNC_FILE)) {
1516 			if (f->f_type == F_FILE) {
1517 				DPRINT2(5, "logit(%u): got FLUSH|SYNC "
1518 				    "for filed %p\n", f->f_thread,
1519 				    (void *)f);
1520 				(void) fsync(f->f_file);
1521 			}
1522 			goto out;
1523 		}
1524 
1525 		/*
1526 		 * Otherwise if it's a standard flush message, write
1527 		 * out any saved messages to the file.
1528 		 */
1529 		if ((mp->flags & FLUSHMSG) && (f->f_prevcount > 0)) {
1530 			set_flush_msg(f);
1531 			writemsg(SAVED, f);
1532 			goto out;
1533 		}
1534 
1535 		(void) strlcpy(f->f_current.msg, mp->msg, MAXLINE+1);
1536 		(void) strlcpy(f->f_current.host, mp->hlp->hl_hosts[0],
1537 		    SYS_NMLN);
1538 		f->f_current.pri = mp->pri;
1539 		f->f_current.flags = mp->flags;
1540 		f->f_current.time = mp->ts;
1541 		f->f_msgflag &= ~CURRENT_VALID;
1542 		hlp = mp->hlp;
1543 
1544 		prevofst = (f->f_prevmsg.flags & ADDDATE) ? 0 : 16;
1545 		currofst = (f->f_current.flags & ADDDATE) ? 0 : 16;
1546 
1547 		if (f->f_type == F_FORW) {
1548 			/*
1549 			 * Should not forward MARK messages, as they are
1550 			 * not defined outside of the current system.
1551 			 */
1552 
1553 			if (mp->flags & MARK) {
1554 				DPRINT1(1, "logit(%u): cannot forward "
1555 				    "Mark\n", f->f_thread);
1556 				goto out;
1557 			}
1558 
1559 			/*
1560 			 * can not forward message if we do
1561 			 * not have a host to forward to
1562 			 */
1563 			if (hlp == (host_list_t *)NULL)
1564 				goto out;
1565 			/*
1566 			 * a forwarding loop is created on machines
1567 			 * with multiple interfaces because the
1568 			 * network address of the sender is different
1569 			 * to the receiver even though it is the
1570 			 * same machine. Instead, if the
1571 			 * hostname the source and target are
1572 			 * the same the message if thrown away
1573 			 */
1574 			forwardingloop = 0;
1575 			for (i = 0; i < hlp->hl_cnt; i++) {
1576 				if (strcmp(hlp->hl_hosts[i],
1577 				    f->f_un.f_forw.f_hname) == 0) {
1578 					DPRINT3(1, errmsg, f->f_thread,
1579 					    f->f_un.f_forw.f_hname,
1580 					    hlp->hl_hosts[i]);
1581 					forwardingloop = 1;
1582 					break;
1583 				}
1584 			}
1585 
1586 			if (forwardingloop == 1) {
1587 				f->f_stat.cantfwd++;
1588 				goto out;
1589 			}
1590 		}
1591 
1592 		f->f_msgflag |= CURRENT_VALID;
1593 
1594 		/* check for dup message */
1595 		if (f->f_type != F_FORW &&
1596 		    (f->f_msgflag & OLD_VALID) &&
1597 		    prevofst == currofst &&
1598 		    (strcmp(f->f_prevmsg.msg + prevofst,
1599 		    f->f_current.msg + currofst) == 0) &&
1600 		    (strcmp(f->f_prevmsg.host,
1601 		    f->f_current.host) == 0)) {
1602 			/* a dup */
1603 			DPRINT2(2, "logit(%u): msg is dup - %p\n",
1604 			    f->f_thread, (void *)mp);
1605 			if (currofst == 16) {
1606 				(void) strncpy(f->f_prevmsg.msg,
1607 				    f->f_current.msg, 15); /* update time */
1608 			}
1609 			f->f_prevcount++;
1610 			f->f_stat.dups++;
1611 			f->f_stat.total++;
1612 			f->f_msgflag &= ~CURRENT_VALID;
1613 		} else {
1614 			/* new: mark or prior dups exist */
1615 			if (f->f_current.flags & MARK || f->f_prevcount > 0) {
1616 				if (f->f_prevcount > 0 && f->f_type != F_FORW) {
1617 					set_flush_msg(f);
1618 					if (f->f_msgflag & OLD_VALID) {
1619 						writemsg(SAVED, f);
1620 					}
1621 				}
1622 				if (f->f_msgflag & CURRENT_VALID)
1623 					writemsg(CURRENT, f);
1624 				if (!(mp->flags & NOCOPY))
1625 					copy_msg(f);
1626 				if (f->f_current.flags & MARK) {
1627 					DPRINT2(2, "logit(%u): msg is "
1628 					    "mark - %p)\n", f->f_thread,
1629 					    (void *)mp);
1630 					f->f_msgflag &= ~OLD_VALID;
1631 				} else {
1632 					DPRINT2(2, "logit(%u): saving "
1633 					    "message - %p\n", f->f_thread,
1634 					    (void *)mp);
1635 				}
1636 				f->f_stat.total++;
1637 			} else { /* new message */
1638 				DPRINT2(2, "logit(%u): msg is new "
1639 				    "- %p\n", f->f_thread, (void *)mp);
1640 				writemsg(CURRENT, f);
1641 				if (!(mp->flags & NOCOPY))
1642 					copy_msg(f);
1643 				f->f_stat.total++;
1644 			}
1645 		}
1646 		/*
1647 		 * if message refcnt goes to zero after we decrement
1648 		 * it here, we are the last consumer of the message,
1649 		 * and we should free it.  We need to hold the lock
1650 		 * between decrementing the count and checking for
1651 		 * zero so another thread doesn't beat us to it.
1652 		 */
1653 out:
1654 		(void) pthread_mutex_lock(&mp->msg_mutex);
1655 		refcnt = --mp->refcnt;
1656 		(void) pthread_mutex_unlock(&mp->msg_mutex);
1657 		if (refcnt == 0)
1658 			free_msg(mp);
1659 	}
1660 	/* register our exit */
1661 
1662 	/*
1663 	 * Pull out all pending messages, if they exist.
1664 	 */
1665 
1666 	(void) pthread_mutex_lock(&f->filed_mutex);
1667 
1668 	while (f->f_queue_count > 0) {
1669 		(void) dataq_dequeue(&f->f_queue, (void **)&mp, 0);
1670 		DPRINT3(5, "logit(%u): logger dequeued msg %p from queue "
1671 		    "%p\n",
1672 		    f->f_thread, (void *)mp, (void *)&f->f_queue);
1673 		(void) pthread_mutex_lock(&mp->msg_mutex);
1674 		refcnt = --mp->refcnt;
1675 		(void) pthread_mutex_unlock(&mp->msg_mutex);
1676 		if (refcnt == 0)
1677 			free_msg(mp);
1678 		f->f_queue_count--;
1679 	}
1680 
1681 	(void) pthread_mutex_unlock(&f->filed_mutex);
1682 
1683 	if (f->f_type != F_USERS && f->f_type != F_WALL &&
1684 	    f->f_type != F_UNUSED) {
1685 		if (f->f_type == F_FORW)
1686 			(void) t_close(f->f_file);
1687 		else
1688 			(void) close(f->f_file);
1689 	}
1690 
1691 	/*
1692 	 * Since f_type may have been changed before this point, we need
1693 	 * to test orig_type.
1694 	 */
1695 	if (f->f_orig_type == F_FORW) {
1696 		free(f->f_un.f_forw.f_addr.buf);
1697 	}
1698 
1699 	f->f_type = F_UNUSED;
1700 	(void) pthread_mutex_lock(&cft);
1701 	--conf_threads;
1702 	(void) pthread_mutex_unlock(&cft);
1703 	DPRINT1(5, "logit(%u): logging thread exited\n", f->f_thread);
1704 	return (NULL);
1705 }
1706 
1707 /*
1708  * change the previous message to a flush message, stating how
1709  * many repeats occurred since the last flush
1710  */
1711 static void
1712 set_flush_msg(struct filed *f)
1713 {
1714 	char tbuf[10];
1715 	int prevofst = (f->f_prevmsg.flags & ADDDATE) ? 0 : 16;
1716 
1717 	if (f->f_prevcount == 1)
1718 		(void) strncpy(tbuf, "time", sizeof (tbuf));
1719 	else
1720 		(void) strncpy(tbuf, "times", sizeof (tbuf));
1721 
1722 	(void) snprintf(f->f_prevmsg.msg+prevofst,
1723 	    sizeof (f->f_prevmsg.msg) - prevofst,
1724 	    "last message repeated %d %s", f->f_prevcount, tbuf);
1725 	f->f_prevcount = 0;
1726 	f->f_msgflag |= OLD_VALID;
1727 }
1728 
1729 
1730 /*
1731  * the actual writing of the message is broken into a separate function
1732  * because each file has a current and saved message associated with
1733  * it (for duplicate message detection). It is necessary to be able
1734  * to write either the saved message or the current message.
1735  */
1736 static void
1737 writemsg(int selection, struct filed *f)
1738 {
1739 	char *cp, *p;
1740 	int pri;
1741 	int flags;
1742 	int l;
1743 	time_t ts;
1744 	struct t_unitdata ud;
1745 	char *eomp, *eomp2, *from, *text, *msg;
1746 	char line[MAXLINE*2];
1747 	char head[MAXLINE+1];
1748 	char tmpbuf[MAXLINE+1];
1749 	char cbuf[30];
1750 	char *filtered;
1751 	char *msgid_start, *msgid_end;
1752 	pthread_t mythreadno;
1753 	size_t	hlen, filter_len;
1754 
1755 	if (Debug) {
1756 		mythreadno = pthread_self();
1757 	}
1758 
1759 	switch (selection) {
1760 	default:
1761 	case CURRENT:		/* print current message */
1762 		msg = f->f_current.msg;
1763 		from = f->f_current.host;
1764 		pri = f->f_current.pri;
1765 		flags = f->f_current.flags;
1766 		ts = f->f_current.time;
1767 		f->f_msgflag &= ~CURRENT_VALID;
1768 		break;
1769 	case SAVED:		/* print saved message */
1770 		msg = f->f_prevmsg.msg;
1771 		from = f->f_prevmsg.host;
1772 		pri = f->f_prevmsg.pri;
1773 		flags = f->f_prevmsg.flags;
1774 		ts = f->f_prevmsg.time;
1775 		f->f_msgflag &= ~OLD_VALID;
1776 		break;
1777 	}
1778 
1779 	if (msg[0] == '\0')
1780 		return;
1781 
1782 	cp = line;
1783 
1784 	if (flags & ADDDATE)
1785 		(void) strncpy(cp, ctime_r(&ts, cbuf) + 4, 15);
1786 	else
1787 		(void) strncpy(cp, msg, 15);
1788 
1789 	line[15] = '\0';
1790 	(void) strcat(cp, " ");
1791 	(void) strcat(cp, from);
1792 	(void) strcat(cp, " ");
1793 	text = cp + strlen(cp);
1794 
1795 	if (flags & ADDDATE)
1796 		(void) strcat(cp, msg);
1797 	else
1798 		(void) strcat(cp, msg+16);
1799 	DPRINT2(5, "writemsg(%u): text = \"%s\"\n", mythreadno, text);
1800 
1801 	errno = 0;
1802 	t_errno = 0;
1803 	switch (f->f_type) {
1804 	case F_UNUSED:
1805 		DPRINT1(1, "writemsg(%u): UNUSED\n", mythreadno);
1806 		break;
1807 	case F_FORW:
1808 		DPRINT4(1, "writemsg(%u): Logging msg '%s' to %s %s\n",
1809 		    mythreadno, msg, TypeNames[f->f_type],
1810 		    f->f_un.f_forw.f_hname);
1811 
1812 		hlen = snprintf(head, sizeof (head),
1813 		    "<%d>%.15s ", pri, cp);
1814 
1815 		DPRINT2(5, "writemsg(%u): head = \"%s\"\n", mythreadno, head);
1816 		DPRINT2(5, "writemsg(%u): hlen = %d\n", mythreadno, hlen);
1817 
1818 		l = strlen(text);
1819 		p = text;
1820 
1821 		DPRINT2(5, "writemsg(%u): text = \"%s\"\n", mythreadno, text);
1822 		DPRINT2(5, "writemsg(%u): strlen(text) = %d\n", mythreadno, l);
1823 
1824 		(void) strncpy(tmpbuf, head, hlen);
1825 
1826 		while (l > 0) {
1827 			size_t	len;
1828 
1829 			len = copy_frwd(tmpbuf + hlen, sizeof (tmpbuf) - hlen,
1830 			    p, l);
1831 
1832 			DPRINT2(5, "writemsg(%u): tmpbuf = \"%s\"\n",
1833 			    mythreadno, tmpbuf);
1834 			DPRINT2(5, "writemsg(%u): len = %d\n", mythreadno,
1835 			    len);
1836 			DPRINT2(5, "writemsg(%u): strlen(tmpbuf) = %d\n",
1837 			    mythreadno, strlen(tmpbuf));
1838 
1839 			ud.opt.buf = NULL;
1840 			ud.opt.len = 0;
1841 			ud.udata.buf = tmpbuf;
1842 			ud.udata.len = len + hlen;
1843 			ud.addr.maxlen = f->f_un.f_forw.f_addr.maxlen;
1844 			ud.addr.buf = f->f_un.f_forw.f_addr.buf;
1845 			ud.addr.len = f->f_un.f_forw.f_addr.len;
1846 			if (t_sndudata(f->f_file, &ud) < 0) {
1847 				if ((hup_state & HUP_INPROGRESS) &&
1848 				    f->f_type == F_UNUSED) {
1849 					break;
1850 				}
1851 				(void) t_close(f->f_file);
1852 				f->f_type = F_UNUSED;
1853 				logerror("t_sndudata");
1854 
1855 				/*
1856 				 * Since it has already failed, it's not worth
1857 				 * continuing output from the middle of
1858 				 * message string.
1859 				 */
1860 				break;
1861 			}
1862 			p += len;
1863 			l -= len;
1864 		}
1865 		break;
1866 	case F_CONSOLE:
1867 	case F_TTY:
1868 	case F_FILE:
1869 	case F_USERS:
1870 	case F_WALL:
1871 		DPRINT4(1, "writemsg(%u): Logging msg '%s' to %s %s\n",
1872 		    mythreadno, msg, TypeNames[f->f_type],
1873 		    ((f->f_type == F_USERS) || (f->f_type == F_WALL)) ?
1874 		    "" : f->f_un.f_fname);
1875 		/*
1876 		 * filter the string in preparation for writing it
1877 		 * save the original for possible forwarding.
1878 		 * In case every byte in cp is a control character,
1879 		 * allocates large enough buffer for filtered.
1880 		 */
1881 
1882 		filter_len = strlen(cp) * 4 + 1;
1883 		filtered = (char *)malloc(filter_len);
1884 		if (!filtered) {
1885 			MALLOC_FAIL("dropping message");
1886 			/* seems we can just return */
1887 			return;
1888 		}
1889 		DPRINT3(5, "writemsg(%u): "
1890 		    "filtered allocated (%p: %d bytes)\n",
1891 		    mythreadno, (void *)filtered, filter_len);
1892 		/* -3 : we may add "\r\n" to ecomp(filtered) later */
1893 		filter_string(cp, filtered, filter_len - 3);
1894 
1895 		DPRINT2(5, "writemsg(%u): strlen(filtered) = %d\n",
1896 		    mythreadno, strlen(filtered));
1897 		/*
1898 		 * If we're writing to the console, strip out the message ID
1899 		 * to reduce visual clutter.
1900 		 */
1901 		if ((msgid_start = strstr(filtered, "[ID ")) != NULL &&
1902 		    (msgid_end = strstr(msgid_start, "] ")) != NULL &&
1903 		    f->f_type == F_CONSOLE)
1904 			(void) strcpy(msgid_start, msgid_end + 2);
1905 
1906 		eomp = filtered + strlen(filtered);
1907 
1908 		if ((f->f_type == F_USERS) || (f->f_type == F_WALL)) {
1909 			/* CSTYLED */
1910 			(void) strcat(eomp, "\r\n"); /*lint !e669*/
1911 			/*
1912 			 * Since wallmsg messes with utmpx we need
1913 			 * to guarantee single threadedness...
1914 			 */
1915 			(void) pthread_mutex_lock(&wmp);
1916 			wallmsg(f, from, filtered);
1917 			(void) pthread_mutex_unlock(&wmp);
1918 
1919 			/*
1920 			 * The contents of filtered have been copied
1921 			 * out to the struct walldev. We should free it here.
1922 			 */
1923 
1924 			free(filtered);
1925 
1926 			/* exiting the switch */
1927 			break;
1928 		} else if (f->f_type != F_FILE) {
1929 			/* CSTYLED */
1930 			(void) strncpy(eomp, "\r\n", 3); /*lint !e669*/
1931 		} else {
1932 			if ((eomp2 = strchr(filtered, '\r')) != NULL) {
1933 				(void) strncpy(eomp2, "\n", 2);
1934 			} else {
1935 				/* CSTYLED */
1936 				(void) strncpy(eomp, "\n", 2); /*lint !e669*/
1937 			}
1938 		}
1939 		if (write(f->f_file, filtered, strlen(filtered)) < 0) {
1940 			int e = errno;
1941 
1942 			if ((hup_state & HUP_INPROGRESS) &&
1943 			    f->f_type == F_UNUSED) {
1944 				free(filtered);
1945 				break;
1946 			}
1947 			(void) close(f->f_file);
1948 			/*
1949 			 * Check for EBADF on TTY's due
1950 			 * to vhangup() XXX
1951 			 */
1952 			if (e == EBADF && f->f_type != F_FILE) {
1953 				f->f_file = open(f->f_un.f_fname,
1954 				    O_WRONLY|O_APPEND|O_NOCTTY);
1955 				if (f->f_file < 0) {
1956 					f->f_type = F_UNUSED;
1957 					logerror(f->f_un.f_fname);
1958 					f->f_stat.errs++;
1959 				}
1960 				untty();
1961 			} else {
1962 				f->f_type = F_UNUSED;
1963 				f->f_stat.errs++;
1964 				errno = e;
1965 				logerror(f->f_un.f_fname);
1966 			}
1967 		} else if (flags & SYNC_FILE)
1968 			if (((pri & LOG_FACMASK) >> 3) == LOG_KERN)
1969 				(void) fsync(f->f_file);
1970 
1971 		DPRINT2(5, "writemsg(%u): freeing filtered (%p)\n",
1972 		    mythreadno, (void *)filtered);
1973 
1974 		free(filtered);
1975 		break;
1976 	}
1977 }
1978 
1979 /*
1980  *  WALLMSG -- Write a message to the world at large
1981  *
1982  *	Write the specified message to either the entire
1983  *	world, or a list of approved users.
1984  */
1985 static void
1986 wallmsg(struct filed *f, char *from, char *msg)
1987 {
1988 	int i;
1989 	size_t	len, clen;
1990 	char *buf = NULL;
1991 	struct utmpx *utxp;
1992 	time_t now;
1993 	char line[512], dev[100];
1994 	char cp[MAXLINE+1];
1995 	struct stat statbuf;
1996 	walldev_t *w;
1997 	char cbuf[30];
1998 	pthread_t mythreadno;
1999 
2000 	if (Debug) {
2001 		mythreadno = pthread_self();
2002 	}
2003 
2004 	if (access(UTMPX_FILE, R_OK) != 0 || stat(UTMPX_FILE, &statbuf) != 0) {
2005 		logerror(UTMPX_FILE);
2006 		return;
2007 	} else if (statbuf.st_uid != 0 || (statbuf.st_mode & 07777) != 0644) {
2008 		(void) snprintf(line, sizeof (line), "%s %s", UTMPX_FILE,
2009 		    "not owned by root or not mode 644.\n"
2010 		    "This file must be owned by root "
2011 		    "and not writable by\n"
2012 		    "anyone other than root.  This alert is being "
2013 		    "dropped because of\n"
2014 		    "this problem.");
2015 		logerror(line);
2016 		return;
2017 	}
2018 
2019 	if (f->f_type == F_WALL) {
2020 		(void) time(&now);
2021 		len = snprintf(line, sizeof (line),
2022 		    "\r\n\7Message from syslogd@%s "
2023 		    "at %.24s ...\r\n", from, ctime_r(&now, cbuf));
2024 		len += strlen(msg + 16);
2025 		buf = (char *)malloc(len + 1);
2026 		if (!buf) {
2027 			MALLOC_FAIL("dropping message");
2028 			return;
2029 		}
2030 		DPRINT3(5, "wallmsg(%u): buf allocated (%p: %d bytes)\n",
2031 		    mythreadno, (void *)buf, len + 1);
2032 		(void) strcpy(buf, line);
2033 		(void) strcat(buf, msg + 16);
2034 		clen = copy_frwd(cp, sizeof (cp), buf, len);
2035 		DPRINT2(5, "wallmsg(%u): clen = %d\n",
2036 		    mythreadno, clen);
2037 		DPRINT2(5, "wallmsg(%u): freeing buf (%p)\n",
2038 		    mythreadno, (void *)buf);
2039 		free(buf);
2040 	} else {
2041 		clen = copy_frwd(cp, sizeof (cp), msg, strlen(msg));
2042 		DPRINT2(5, "wallmsg(%u): clen = %d\n",
2043 		    mythreadno, clen);
2044 	}
2045 	/* scan the user login file */
2046 	setutxent();
2047 	while ((utxp = getutxent()) != NULL) {
2048 		/* is this slot used? */
2049 		if (utxp->ut_name[0] == '\0' ||
2050 		    utxp->ut_line[0] == '\0' ||
2051 		    utxp->ut_type != USER_PROCESS)
2052 			continue;
2053 		/* should we send the message to this user? */
2054 		if (f->f_type == F_USERS) {
2055 			for (i = 0; i < MAXUNAMES; i++) {
2056 				if (!f->f_un.f_uname[i][0]) {
2057 					i = MAXUNAMES;
2058 					break;
2059 				}
2060 				if (strncmp(f->f_un.f_uname[i],
2061 				    utxp->ut_name, UNAMESZ) == 0)
2062 					break;
2063 			}
2064 			if (i >= MAXUNAMES)
2065 				continue;
2066 		}
2067 
2068 		/* compute the device name */
2069 		if (utxp->ut_line[0] == '/') {
2070 			(void) strncpy(dev, utxp->ut_line, UDEVSZ);
2071 		} else {
2072 			(void) strcpy(dev, "/dev/");
2073 			(void) strncat(dev, utxp->ut_line, UDEVSZ);
2074 		}
2075 		DPRINT2(1, "wallmsg(%u): write to '%s'\n", mythreadno,
2076 		    dev);
2077 
2078 		if ((w = malloc(sizeof (walldev_t))) != NULL) {
2079 			int rc;
2080 			(void) pthread_attr_init(&w->thread_attr);
2081 			(void) pthread_attr_setdetachstate(&w->thread_attr,
2082 			    PTHREAD_CREATE_DETACHED);
2083 			(void) strncpy(w->dev, dev, PATH_MAX);
2084 			(void) strncpy(w->msg, cp, MAXLINE+1);
2085 			(void) strncpy(w->ut_name, utxp->ut_name,
2086 			    sizeof (w->ut_name));
2087 
2088 			if ((rc = pthread_create(&w->thread, &w->thread_attr,
2089 			    writetodev, (void *) w)) != 0) {
2090 				DPRINT2(5, "wallmsg(%u): wallmsg thread "
2091 				    "create failed rc = %d\n",
2092 				    mythreadno, rc);
2093 				free(w);
2094 				break;
2095 			}
2096 		} else {
2097 			MALLOC_FAIL("dropping message to user");
2098 		}
2099 	}
2100 	/* close the user login file */
2101 	endutxent();
2102 }
2103 
2104 /*
2105  * Each time we need to write to a tty device (a potentially expensive
2106  * or long-running operation) this routine gets called as a new
2107  * detached, unbound thread. This allows writes to many devices
2108  * to proceed nearly in parallel, without having to resort to
2109  * asynchronous I/O or forking.
2110  */
2111 static void *
2112 writetodev(void *ap)
2113 {
2114 	walldev_t *w = ap;
2115 	int ttyf;
2116 	int len;
2117 	struct stat statb;
2118 	struct passwd pw, *pwp;
2119 	char pwbuf[MAXLINE];
2120 	pthread_t mythreadno;
2121 
2122 	if (Debug) {
2123 		mythreadno = pthread_self();
2124 	}
2125 
2126 	DPRINT1(1, "writetodev(%u): Device writer thread started\n",
2127 	    mythreadno);
2128 
2129 	len = strlen(w->msg);
2130 
2131 	ttyf = open(w->dev, O_WRONLY|O_NOCTTY|O_NDELAY);
2132 	if (ttyf >= 0) {
2133 		if (fstat(ttyf, &statb) != 0) {
2134 			DPRINT2(1, "writetodev(%u): Can't stat '%s'\n",
2135 			    mythreadno, w->dev);
2136 			errno = 0;
2137 			logerror("Can't stat '%s'", w->dev);
2138 		} else if (!(statb.st_mode & S_IWRITE)) {
2139 			DPRINT2(1, "writetodev(%u): Can't write to "
2140 			    "'%s'\n", mythreadno, w->dev);
2141 		} else if (!isatty(ttyf)) {
2142 			DPRINT2(1, "writetodev(%u): '%s' not a tty\n",
2143 			    mythreadno, w->dev);
2144 			/*
2145 			 * We might hit dtremote here. Don't generate
2146 			 * error message.
2147 			 */
2148 		} else if (getpwuid_r(statb.st_uid, &pw, pwbuf,
2149 		    sizeof (pwbuf), &pwp) != 0) {
2150 			DPRINT2(1, "writetodev(%u): Can't determine owner "
2151 			    "of '%s'\n", mythreadno, w->dev);
2152 			errno = 0;
2153 			logerror("Can't determine owner of '%s'", w->dev);
2154 		} else if (strncmp(pw.pw_name, w->ut_name, UNAMESZ) != 0) {
2155 			DPRINT2(1, "writetodev(%u): Bad terminal owner '%s'"
2156 			    "\n", mythreadno, w->dev);
2157 			errno = 0;
2158 			logerror("%s %s owns '%s' %s %.*s",
2159 			    "Bad terminal owner;", pw.pw_name, w->dev,
2160 			    "but utmpx says", UNAMESZ, w->ut_name);
2161 		} else if (write(ttyf, w->msg, len) != len) {
2162 			DPRINT2(1, "writetodev(%u): Write failed to "
2163 			    "'%s'\n", mythreadno, w->dev);
2164 			errno = 0;
2165 			logerror("Write failed to '%s'", w->dev);
2166 		}
2167 
2168 		DPRINT2(1, "writetodev(%u): write to '%s' succeeded\n",
2169 		    mythreadno, w->dev);
2170 
2171 		(void) close(ttyf);
2172 	} else {
2173 		DPRINT2(1, "writetodev(%u): Can't open '%s'\n",
2174 		    mythreadno, w->dev);
2175 	}
2176 
2177 	(void) pthread_attr_destroy(&w->thread_attr);
2178 	free(w);
2179 
2180 	DPRINT1(1, "writetodev(%u): Device writer thread exiting\n",
2181 	    mythreadno);
2182 
2183 	pthread_exit(0);
2184 	return (NULL);
2185 	/*NOTREACHED*/
2186 }
2187 
2188 /*
2189  * Return a printable representation of a host address. If unable to
2190  * look up hostname, format the numeric address for display instead.
2191  *
2192  * First calls hnc_lookup to see if there is valid cache entry for
2193  * given network address. If it failed, cvthname looks up hostname,
2194  * and push the results into the hostname cache.
2195  */
2196 static host_list_t *
2197 cvthname(struct netbuf *nbp, struct netconfig *ncp, char *failsafe_addr)
2198 {
2199 	int i;
2200 	host_list_t *h;
2201 	struct nd_hostservlist *hsp;
2202 	struct nd_hostserv *hspp;
2203 	pthread_t mythreadno;
2204 	int hindex;
2205 	char *uap;
2206 
2207 	if (Debug) {
2208 		mythreadno = pthread_self();
2209 	}
2210 
2211 	if (Debug)
2212 		uap = taddr2uaddr(ncp, nbp);
2213 
2214 	DPRINT2(2, "cvthname(%u): looking up hostname for %s\n",
2215 	    mythreadno, uap ? uap : "<unknown>");
2216 
2217 	if ((h = hnc_lookup(nbp, ncp, &hindex)) != NULL) {
2218 		DPRINT4(2, "cvthname(%u): Cache found %p for %s (%s)\n",
2219 		    mythreadno, (void *)h, uap ? uap : "<unknown>",
2220 		    h->hl_hosts[0]);
2221 		return (h);
2222 	}
2223 	DPRINT2(2, "cvthname(%u): No cache found for %s\n",
2224 	    mythreadno, uap ? uap : "<unknown>");
2225 
2226 	if (Debug)
2227 		free(uap);
2228 
2229 	if (ncp->nc_semantics != NC_TPI_CLTS) {
2230 		return (NULL);
2231 	}
2232 
2233 	/* memory allocation failure here is fatal */
2234 	if ((h = malloc(sizeof (host_list_t))) == NULL) {
2235 		MALLOC_FAIL("host name conversion");
2236 		return (NULL);
2237 	}
2238 
2239 	if (netdir_getbyaddr(ncp, &hsp, nbp) == 0) {
2240 		if (hsp->h_cnt <= 0) {
2241 out:			netdir_free((void *)hsp, ND_HOSTSERVLIST);
2242 			free(h);
2243 			return (NULL);
2244 		}
2245 
2246 		hspp = hsp->h_hostservs;
2247 		h->hl_cnt = hsp->h_cnt;
2248 		h->hl_hosts = (char **)malloc(sizeof (char *) * (h->hl_cnt));
2249 		if (h->hl_hosts == NULL) {
2250 			MALLOC_FAIL("host name conversion");
2251 			goto out;
2252 		}
2253 
2254 		DPRINT2(2, "cvthname(%u): Found %d hostnames\n",
2255 		    mythreadno, h->hl_cnt);
2256 		for (i = 0; i < h->hl_cnt; i++) {
2257 			h->hl_hosts[i] = (char *)
2258 			    malloc(sizeof (char) * (strlen(hspp->h_host) + 1));
2259 			if (h->hl_hosts[i] == NULL) {
2260 				int j;
2261 				for (j = 0; j < i; j++) {
2262 					free(h->hl_hosts[j]);
2263 				}
2264 				free(h->hl_hosts);
2265 				MALLOC_FAIL("host name conversion");
2266 				goto out;
2267 			}
2268 			(void) strcpy(h->hl_hosts[i], hspp->h_host);
2269 			hspp++;
2270 		}
2271 		netdir_free((void *)hsp, ND_HOSTSERVLIST);
2272 	} else { /* unknown address */
2273 		h->hl_cnt = 1;
2274 		h->hl_hosts = (char **)malloc(sizeof (char *));
2275 		if (h->hl_hosts == NULL) {
2276 			free(h);
2277 			MALLOC_FAIL("host name conversion");
2278 			return (NULL);
2279 		}
2280 		h->hl_hosts[0] = (char *)malloc(strlen(failsafe_addr) + 3);
2281 		if (h->hl_hosts[0] == NULL) {
2282 			free(h->hl_hosts);
2283 			free(h);
2284 			MALLOC_FAIL("host name conversion");
2285 			return (NULL);
2286 		}
2287 		/*LINTED*/
2288 		(void) sprintf(h->hl_hosts[0], "[%s]", failsafe_addr);
2289 		DPRINT2(1, "cvthname(%u): Hostname lookup failed "
2290 		    "- using address %s instead\n",
2291 		    mythreadno, h->hl_hosts[0]);
2292 	}
2293 
2294 	h->hl_refcnt = 1;
2295 	if (pthread_mutex_init(&h->hl_mutex, NULL) != 0) {
2296 		logerror("pthread_mutex_init failed");
2297 		/* This host_list won't be shared by the cache. */
2298 		return (h);
2299 	}
2300 	hnc_register(nbp, ncp, h, hindex);
2301 	DPRINT3(2, "cvthname(%u): returning %p for %s\n",
2302 	    mythreadno, (void *)h, h->hl_hosts[0]);
2303 	return (h);
2304 }
2305 
2306 /*
2307  * Print syslogd errors some place. Need to be careful here, because
2308  * this routine is called at times when we're not initialized and
2309  * ready to log messages...in this case, fall back to using the console.
2310  */
2311 void
2312 logerror(const char *type, ...)
2313 {
2314 	char buf[MAXLINE+1];
2315 	pthread_t mythreadno;
2316 	int flag;
2317 	va_list ap;
2318 
2319 	if (Debug) {
2320 		mythreadno = pthread_self();
2321 	}
2322 
2323 	va_start(ap, type);
2324 	logerror_format(type, buf, ap);
2325 	va_end(ap);
2326 	DPRINT2(1, "logerror(%u): %s\n", mythreadno, buf);
2327 
2328 	(void) pthread_mutex_lock(&logerror_lock);
2329 	if (!interrorlog) {
2330 		flag = 0;
2331 		if (logerror_to_console(1, buf) == 0) {
2332 			/* has written to the console */
2333 			flag = IGN_CONS;
2334 		}
2335 		(void) logmymsg(LOG_SYSLOG|LOG_ERR, buf, ADDDATE|flag, 1);
2336 	} else {
2337 		if (logmymsg(LOG_SYSLOG|LOG_ERR, buf, ADDDATE, 0) == -1) {
2338 			(void) logerror_to_console(1, buf);
2339 		}
2340 	}
2341 	(void) pthread_mutex_unlock(&logerror_lock);
2342 
2343 	errno = 0;
2344 	t_errno = 0;
2345 }
2346 
2347 static void
2348 logerror_format(const char *type, char *buf, va_list ap)
2349 {
2350 	char tmpbuf[MAXLINE + 1];
2351 	pthread_t mythreadno;
2352 
2353 	if (Debug) {
2354 		mythreadno = pthread_self();
2355 	}
2356 
2357 	(void) vsnprintf(tmpbuf, MAXLINE, type, ap);
2358 
2359 	if (t_errno == 0 || t_errno == TSYSERR) {
2360 		char *errstr;
2361 
2362 		if (errno == 0) {
2363 			(void) snprintf(buf, MAXLINE, "syslogd: %.*s",
2364 			    MAXLINE, tmpbuf);
2365 		} else if ((errstr = strerror(errno)) == (char *)NULL) {
2366 			(void) snprintf(buf, MAXLINE, "syslogd: %s: error"
2367 			    " %d", tmpbuf, errno);
2368 		} else {
2369 			(void) snprintf(buf, MAXLINE, "syslogd: %s: %s",
2370 			    tmpbuf, errstr);
2371 		}
2372 	} else {
2373 		if (t_errno > t_nerr) {
2374 			(void) snprintf(buf, MAXLINE, "syslogd: %s:"
2375 			    " t_error %d", tmpbuf, t_errno);
2376 		} else {
2377 			(void) snprintf(buf, MAXLINE, "syslogd: %s: %s",
2378 			    tmpbuf, t_errlist[t_errno]);
2379 		}
2380 	}
2381 
2382 	DPRINT2(5, "logerror_format(%u): out %s\n", mythreadno, buf);
2383 }
2384 
2385 static int
2386 logerror_to_console(int nonblock, const char *buf)
2387 {
2388 	int cfd, modes;
2389 	pthread_t mythreadno;
2390 	int ret = 0, len;
2391 	char tmpbuf[MAXLINE + 1];
2392 
2393 	if (Debug) {
2394 		mythreadno = pthread_self();
2395 	}
2396 
2397 	DPRINT2(1, "logerror_to_console(%u): %s\n", mythreadno, buf);
2398 
2399 	/*
2400 	 * must use open here instead of fopen, because
2401 	 * we need the O_NOCTTY behavior - otherwise we
2402 	 * could hang the console at boot time
2403 	 */
2404 
2405 	modes = (nonblock) ?
2406 	    O_WRONLY|O_APPEND|O_NOCTTY|O_NONBLOCK :
2407 	    O_WRONLY|O_APPEND|O_NOCTTY;
2408 
2409 	if (((cfd = open(sysmsg, modes)) >= 0) ||
2410 	    ((cfd = open(ctty, modes)) >= 0)) {
2411 		(void) snprintf(tmpbuf, MAXLINE, "%s\n", buf);
2412 		len = strlen(tmpbuf);
2413 		if (write(cfd, tmpbuf, len) != len) {
2414 			ret = 1;
2415 		}
2416 		(void) close(cfd);
2417 	} else {
2418 		ret = 1;
2419 
2420 		/* punt */
2421 		DPRINT1(1, "logerror_console(%u): can't open console\n",
2422 		    mythreadno);
2423 	}
2424 	return (ret);
2425 }
2426 
2427 /*
2428  * copy current message to saved message in filed structure.
2429  */
2430 static void
2431 copy_msg(struct filed *f)
2432 {
2433 	(void) strlcpy(f->f_prevmsg.msg, f->f_current.msg, MAXLINE+1);
2434 	(void) strlcpy(f->f_prevmsg.host, f->f_current.host, SYS_NMLN);
2435 	f->f_prevmsg.pri = f->f_current.pri;
2436 	f->f_prevmsg.flags = f->f_current.flags;
2437 	f->f_prevmsg.time = f->f_current.time;
2438 	f->f_msgflag |= OLD_VALID;
2439 }
2440 
2441 
2442 /*
2443  * function to free a host_list_t struct that was allocated
2444  * out of cvthname(). There is a special case where we don't
2445  * free the hostname list in LocalHostName, because that's
2446  * our own addresses, and we just want to have to look it
2447  * up once and save it.  Also don't free it if it's
2448  * NullHostName, because that's a special one we use if
2449  * name service lookup fails.
2450  *
2451  * By having hostname cache, now host_list_t will be shared
2452  * by messages and hostname cache. hl_refcnt is used for
2453  * the purpose.
2454  */
2455 static void
2456 freehl(host_list_t *h)
2457 {
2458 	int i, refcnt;
2459 	pthread_t mythreadno;
2460 
2461 	if (Debug) {
2462 		mythreadno = pthread_self();
2463 	}
2464 
2465 	DPRINT2(2, "freehl(%u): releasing %p\n", mythreadno, (void *)h);
2466 
2467 	if (h == NULL || h == &LocalHostName || h == &NullHostName) {
2468 		return;
2469 	}
2470 
2471 	(void) pthread_mutex_lock(&h->hl_mutex);
2472 	refcnt = --h->hl_refcnt;
2473 	(void) pthread_mutex_unlock(&h->hl_mutex);
2474 
2475 	if (refcnt != 0) {
2476 		DPRINT3(5, "freehl(%u): %p has reference %d\n",
2477 		    mythreadno, (void *)h, refcnt);
2478 		return;
2479 	}
2480 
2481 	(void) pthread_mutex_destroy(&h->hl_mutex);
2482 
2483 	DPRINT2(5, "freehl(%u): freeing %p\n", mythreadno, (void *)h);
2484 
2485 	for (i = 0; i < h->hl_cnt; i++) {
2486 		free(h->hl_hosts[i]);
2487 	}
2488 
2489 	free(h->hl_hosts);
2490 	free(h);
2491 }
2492 
2493 /*
2494  * Create the door file and the pid file in /var/run.  If the filesystem
2495  * containing /etc is writable, create symlinks /etc/.syslog_door and
2496  * /etc/syslog.pid to them.  On systems that do not support /var/run, create
2497  * /etc/.syslog_door and /etc/syslog.pid directly.
2498  *
2499  * Note: it is not considered fatal to fail to create the pid file or its
2500  * symlink.  Attempts to use them in the usual way will fail, of course, but
2501  * syslogd will function nicely without it (not so for the door file).
2502  */
2503 
2504 static void
2505 open_door(void)
2506 {
2507 	struct stat buf;
2508 	door_info_t info;
2509 	char line[MAXLINE+1];
2510 	pthread_t mythreadno;
2511 	int err;
2512 
2513 	if (Debug) {
2514 		mythreadno = pthread_self();
2515 	}
2516 
2517 	/*
2518 	 * first see if another syslogd is running by trying
2519 	 * a door call - if it succeeds, there is already
2520 	 * a syslogd process active
2521 	 */
2522 
2523 	if (!DoorCreated) {
2524 		int door;
2525 
2526 		if ((door = open(DoorFileName, O_RDONLY)) >= 0) {
2527 			DPRINT2(5, "open_door(%u): %s opened "
2528 			    "successfully\n", mythreadno, DoorFileName);
2529 
2530 			if (door_info(door, &info) >= 0) {
2531 				DPRINT2(5, "open_door(%u): "
2532 				    "door_info:info.di_target = %ld\n",
2533 				    mythreadno, info.di_target);
2534 
2535 				if (info.di_target > 0) {
2536 					(void) sprintf(line, "syslogd pid %ld"
2537 					    " already running. Cannot "
2538 					    "start another syslogd pid %ld",
2539 					    info.di_target, getpid());
2540 					DPRINT2(5, "open_door(%u): error: "
2541 					    "%s\n", mythreadno, line);
2542 					errno = 0;
2543 					logerror(line);
2544 					exit(1);
2545 				}
2546 			}
2547 
2548 			(void) close(door);
2549 		} else {
2550 			if (lstat(DoorFileName, &buf) < 0) {
2551 				err = errno;
2552 
2553 				DPRINT3(5, "open_door(%u): lstat() of %s "
2554 				    "failed, errno=%d\n",
2555 				    mythreadno, DoorFileName, err);
2556 
2557 				if ((door = creat(DoorFileName, 0644)) < 0) {
2558 					err = errno;
2559 					(void) snprintf(line, sizeof (line),
2560 					    "creat() of %s failed - fatal",
2561 					    DoorFileName);
2562 					DPRINT3(1, "open_door(%u): error: %s, "
2563 					    "errno=%d\n", mythreadno, line,
2564 					    err);
2565 					errno = err;
2566 					logerror(line);
2567 					delete_doorfiles();
2568 					exit(1);
2569 				}
2570 
2571 				(void) fchmod(door,
2572 				    S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
2573 
2574 				DPRINT2(5, "open_door(%u): creat() of %s "
2575 				    "succeeded\n", mythreadno,
2576 				    DoorFileName);
2577 
2578 				(void) close(door);
2579 			}
2580 		}
2581 
2582 		if (strcmp(DoorFileName, DOORFILE) == 0) {
2583 			if (lstat(OLD_DOORFILE, &buf) == 0) {
2584 				DPRINT2(5, "open_door(%u): lstat() of %s "
2585 				    "succeeded\n", mythreadno,
2586 				    OLD_DOORFILE);
2587 
2588 				if (S_ISDIR(buf.st_mode)) {
2589 					(void) snprintf(line, sizeof (line),
2590 					    "%s is a directory - fatal",
2591 					    OLD_DOORFILE);
2592 					DPRINT2(1, "open_door(%u): error: "
2593 					    "%s\n", mythreadno, line);
2594 					errno = 0;
2595 					logerror(line);
2596 					delete_doorfiles();
2597 					exit(1);
2598 				}
2599 
2600 				DPRINT2(5, "open_door(%u): %s is not a "
2601 				    "directory\n",
2602 				    mythreadno, OLD_DOORFILE);
2603 
2604 				if (unlink(OLD_DOORFILE) < 0) {
2605 					err = errno;
2606 					(void) snprintf(line, sizeof (line),
2607 					    "unlink() of %s failed",
2608 					    OLD_DOORFILE);
2609 					DPRINT2(5, "open_door(%u): %s\n",
2610 					    mythreadno, line);
2611 
2612 					if (err != EROFS) {
2613 						DPRINT3(1, "open_door(%u): "
2614 						    "error: %s, "
2615 						    "errno=%d\n",
2616 						    mythreadno, line, err);
2617 						(void) strcat(line, " - fatal");
2618 						errno = err;
2619 						logerror(line);
2620 						delete_doorfiles();
2621 						exit(1);
2622 					}
2623 
2624 					DPRINT1(5, "open_door(%u): unlink "
2625 					    "failure OK on RO file "
2626 					    "system\n", mythreadno);
2627 				}
2628 			} else {
2629 				DPRINT2(5, "open_door(%u): file %s doesn't "
2630 				    "exist\n", mythreadno, OLD_DOORFILE);
2631 			}
2632 
2633 			if (symlink(RELATIVE_DOORFILE, OLD_DOORFILE) < 0) {
2634 				err = errno;
2635 				(void) snprintf(line, sizeof (line),
2636 				    "symlink %s -> %s failed", OLD_DOORFILE,
2637 				    RELATIVE_DOORFILE);
2638 				DPRINT2(5, "open_door(%u): %s\n", mythreadno,
2639 				    line);
2640 
2641 				if (err != EROFS) {
2642 					DPRINT3(1, "open_door(%u): error: %s, "
2643 					    "errno=%d\n", mythreadno, line,
2644 					    err);
2645 					errno = err;
2646 					(void) strcat(line, " - fatal");
2647 					logerror(line);
2648 					delete_doorfiles();
2649 					exit(1);
2650 				}
2651 
2652 				DPRINT1(5, "open_door(%u): symlink failure OK "
2653 				    "on RO file system\n", mythreadno);
2654 			} else {
2655 				DPRINT3(5, "open_door(%u): symlink %s -> %s "
2656 				    "succeeded\n", mythreadno,
2657 				    OLD_DOORFILE, RELATIVE_DOORFILE);
2658 			}
2659 		}
2660 
2661 		if ((DoorFd = door_create(server, 0,
2662 		    DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) < 0) {
2663 			err = errno;
2664 			(void) sprintf(line, "door_create() failed - fatal");
2665 			DPRINT3(1, "open_door(%u): error: %s, errno=%d\n",
2666 			    mythreadno, line, err);
2667 			errno = err;
2668 			logerror(line);
2669 			delete_doorfiles();
2670 			exit(1);
2671 		}
2672 		(void) door_setparam(DoorFd, DOOR_PARAM_DATA_MAX, 0);
2673 		DPRINT2(5, "open_door(%u): door_create() succeeded, "
2674 		    "DoorFd=%d\n", mythreadno, DoorFd);
2675 
2676 		DoorCreated = 1;
2677 	}
2678 
2679 	(void) fdetach(DoorFileName);	/* just in case... */
2680 
2681 	(void) door_server_create(door_server_pool);
2682 
2683 	if (fattach(DoorFd, DoorFileName) < 0) {
2684 		err = errno;
2685 		(void) snprintf(line, sizeof (line), "fattach() of fd"
2686 		    " %d to %s failed - fatal", DoorFd, DoorFileName);
2687 		DPRINT3(1, "open_door(%u): error: %s, errno=%d\n", mythreadno,
2688 		    line, err);
2689 		errno = err;
2690 		logerror(line);
2691 		delete_doorfiles();
2692 		exit(1);
2693 	}
2694 
2695 	DPRINT2(5, "open_door(%u): attached server() to %s\n", mythreadno,
2696 	    DoorFileName);
2697 
2698 	/*
2699 	 * create pidfile anyway, so those using it to control
2700 	 * syslogd (with kill `cat /etc/syslog.pid` perhaps)
2701 	 * don't get broken.
2702 	 */
2703 
2704 	if (!PidfileCreated) {
2705 		int pidfd;
2706 
2707 		PidfileCreated = 1;
2708 
2709 		if ((pidfd = open(PidFileName, O_RDWR|O_CREAT|O_TRUNC, 0644))
2710 		    < 0) {
2711 			err = errno;
2712 			(void) snprintf(line, sizeof (line),
2713 			    "open() of %s failed", PidFileName);
2714 			DPRINT3(1, "open_door(%u): warning: %s, errno=%d\n",
2715 			    mythreadno, line, err);
2716 			errno = err;
2717 			logerror(line);
2718 			return;
2719 		}
2720 
2721 		(void) fchmod(pidfd, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
2722 		(void) sprintf(line, "%ld\n", getpid());
2723 
2724 		if (write(pidfd, line, strlen(line)) < 0) {
2725 			err = errno;
2726 			(void) snprintf(line, sizeof (line),
2727 			    "write to %s on fd %d failed", PidFileName, pidfd);
2728 			DPRINT3(1, "open_door(%u): warning: %s, errno=%d\n",
2729 			    mythreadno, line, err);
2730 			errno = err;
2731 			logerror(line);
2732 			return;
2733 		}
2734 
2735 		(void) close(pidfd);
2736 
2737 		DPRINT2(5, "open_door(%u): %s created\n",
2738 		    mythreadno, PidFileName);
2739 
2740 		if (strcmp(PidFileName, PIDFILE) == 0) {
2741 			if (lstat(OLD_PIDFILE, &buf) == 0) {
2742 				DPRINT2(5, "open_door(%u): lstat() of %s "
2743 				    "succeded\n", mythreadno, OLD_PIDFILE);
2744 
2745 				if (S_ISDIR(buf.st_mode)) {
2746 					(void) snprintf(line, sizeof (line),
2747 					    "file %s is a directory",
2748 					    OLD_PIDFILE);
2749 					DPRINT2(1, "open_door(%u): warning: "
2750 					    "%s\n", mythreadno, line);
2751 					errno = 0;
2752 					logerror(line);
2753 					return;
2754 				}
2755 
2756 				if (unlink(OLD_PIDFILE) < 0) {
2757 					err = errno;
2758 					(void) snprintf(line, sizeof (line),
2759 					    "unlink() of %s failed",
2760 					    OLD_PIDFILE);
2761 					DPRINT2(5, "open_door(%u): %s\n",
2762 					    mythreadno, line);
2763 
2764 					if (err != EROFS) {
2765 						DPRINT3(1, "open_door (%u): "
2766 						    "warning: %s, "
2767 						    "errno=%d\n",
2768 						    mythreadno, line, err);
2769 						errno = err;
2770 						logerror(line);
2771 						return;
2772 					}
2773 
2774 					DPRINT1(5, "open_door(%u): unlink "
2775 					    "failure OK on RO file "
2776 					    "system\n", mythreadno);
2777 				}
2778 			} else {
2779 				DPRINT2(5, "open_door(%u): file %s doesn't "
2780 				    "exist\n", mythreadno, OLD_PIDFILE);
2781 			}
2782 
2783 			if (symlink(RELATIVE_PIDFILE, OLD_PIDFILE) < 0) {
2784 				err = errno;
2785 				(void) snprintf(line, sizeof (line),
2786 				    "symlink %s -> %s failed", OLD_PIDFILE,
2787 				    RELATIVE_PIDFILE);
2788 				DPRINT2(5, "open_door(%u): %s\n", mythreadno,
2789 				    line);
2790 
2791 				if (err != EROFS) {
2792 					DPRINT3(1, "open_door(%u): warning: "
2793 					    "%s, errno=%d\n", mythreadno,
2794 					    line, err);
2795 					errno = err;
2796 					logerror(line);
2797 					return;
2798 				}
2799 
2800 				DPRINT1(5, "open_door(%u): symlink failure OK "
2801 				    "on RO file system\n", mythreadno);
2802 				return;
2803 			}
2804 
2805 			DPRINT3(5, "open_door(%u): symlink %s -> %s "
2806 			    "succeeded\n", mythreadno, OLD_PIDFILE,
2807 			    RELATIVE_PIDFILE);
2808 		}
2809 	}
2810 }
2811 
2812 /*
2813  * the 'server' function that we export via the door. It does
2814  * nothing but return.
2815  */
2816 /*ARGSUSED*/
2817 static void
2818 server(void *cookie, char *argp, size_t arg_size,
2819     door_desc_t *dp, uint_t n)
2820 {
2821 	(void) door_return(NULL, 0, NULL, 0);
2822 	/* NOTREACHED */
2823 }
2824 
2825 /*ARGSUSED*/
2826 static void *
2827 create_door_thr(void *arg)
2828 {
2829 	(void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
2830 	(void) door_return(NULL, 0, NULL, 0);
2831 
2832 	/*
2833 	 * If there is an error in door_return(), it will return here and
2834 	 * the thread will exit. Hence we need to decrement door_server_cnt.
2835 	 */
2836 	(void) pthread_mutex_lock(&door_server_cnt_lock);
2837 	door_server_cnt--;
2838 	(void) pthread_mutex_unlock(&door_server_cnt_lock);
2839 	return (NULL);
2840 }
2841 
2842 /*
2843  * Max number of door server threads for syslogd. Since door is used
2844  * to check the health of syslogd, we don't need large number of
2845  * server threads.
2846  */
2847 #define	MAX_DOOR_SERVER_THR	3
2848 
2849 /*
2850  * Manage door server thread pool.
2851  */
2852 /*ARGSUSED*/
2853 static void
2854 door_server_pool(door_info_t *dip)
2855 {
2856 	(void) pthread_mutex_lock(&door_server_cnt_lock);
2857 	if (door_server_cnt <= MAX_DOOR_SERVER_THR &&
2858 	    pthread_create(NULL, &door_thr_attr, create_door_thr, NULL) == 0) {
2859 		door_server_cnt++;
2860 		(void) pthread_mutex_unlock(&door_server_cnt_lock);
2861 		return;
2862 	}
2863 
2864 	(void) pthread_mutex_unlock(&door_server_cnt_lock);
2865 }
2866 
2867 /*
2868  * checkm4 - used to verify that the external utilities that
2869  * syslogd depends on are where we expect them to be.
2870  * Returns 0 if all utilities are found, > 0 if any are missing.
2871  * Also logs errors so user knows what's missing
2872  */
2873 static int
2874 checkm4(void)
2875 {
2876 	int notfound = 0;
2877 	int saverrno;
2878 	pthread_t mythreadno;
2879 
2880 	if (Debug) {
2881 		mythreadno = pthread_self();
2882 	}
2883 
2884 	if (access("/usr/ccs/bin/m4", X_OK) < 0) {
2885 		saverrno = errno;
2886 		logerror("/usr/ccs/bin/m4");
2887 		DPRINT2(1, "checkm4(%u): /usr/ccs/bin/m4 - access "
2888 		    "returned %d\n", mythreadno, saverrno);
2889 		notfound++;
2890 	}
2891 
2892 	return (notfound);
2893 }
2894 
2895 /*
2896  *  INIT -- Initialize syslogd from configuration table, start up
2897  *  input and logger threads. This routine is called only once.
2898  */
2899 static void
2900 init(void)
2901 {
2902 	struct utsname *up;
2903 	pthread_attr_t sys_attr, net_attr, log_attr, hnl_attr;
2904 	int nthread;
2905 	pthread_t mythreadno;
2906 
2907 	if (Debug) {
2908 		mythreadno = pthread_self();
2909 	}
2910 
2911 	DPRINT1(2, "init(%u): initializing\n", mythreadno);
2912 
2913 	/* hand-craft a host_list_t entry for our local host name */
2914 	if ((up = malloc(sizeof (struct utsname))) == NULL) {
2915 		MALLOC_FAIL_EXIT;
2916 	}
2917 	(void) uname(up);
2918 	LocalHostName.hl_cnt = 1;
2919 	if ((LocalHostName.hl_hosts = malloc(sizeof (char *))) == NULL) {
2920 		MALLOC_FAIL_EXIT;
2921 	}
2922 	if ((LocalHostName.hl_hosts[0] = strdup(up->nodename)) == NULL) {
2923 		free(LocalHostName.hl_hosts);
2924 		MALLOC_FAIL_EXIT;
2925 	}
2926 	free(up);
2927 	/* also hand craft one for use if name resolution fails */
2928 	NullHostName.hl_cnt = 1;
2929 	if ((NullHostName.hl_hosts = malloc(sizeof (char *))) == NULL) {
2930 		MALLOC_FAIL_EXIT;
2931 	}
2932 	if ((NullHostName.hl_hosts[0] = strdup("name lookup failed")) == NULL) {
2933 		MALLOC_FAIL_EXIT;
2934 	}
2935 
2936 	hnc_init(0);
2937 
2938 	/*
2939 	 * Note that getnets will allocate network resources, but won't be
2940 	 * binding UDP port. This is because, there could be a race
2941 	 * condition between door. If we bind here, one syslogd could grab
2942 	 * UDP port first, but later another syslogd could take over without
2943 	 * getting UDP port but grab the door file. The 2nd syslogd could
2944 	 * continue to run without listening network.
2945 	 * bindnet() will be called after door was successfully opened.
2946 	 */
2947 	getnets();
2948 
2949 	/*
2950 	 * Start up configured theads
2951 	 */
2952 	conf_init();
2953 
2954 	/*
2955 	 * allocate thread stacks for the persistant threads
2956 	 */
2957 	nthread = (turnoff == 0) ? 4 : 2;
2958 
2959 	if ((stack_ptr = alloc_stacks(nthread)) == NULL) {
2960 		logerror("alloc_stacks failed - fatal");
2961 		exit(1);
2962 	}
2963 
2964 	if (Debug) {
2965 		dumpstats(STDOUT_FILENO);
2966 	}
2967 
2968 	(void) dataq_init(&inputq);	/* init the input queue */
2969 
2970 	if (pthread_attr_init(&sys_attr) != 0 ||
2971 	    pthread_attr_init(&log_attr) != 0 ||
2972 	    pthread_attr_init(&net_attr) != 0 ||
2973 	    pthread_attr_init(&hnl_attr) != 0 ||
2974 	    pthread_attr_init(&door_thr_attr) != 0) {
2975 		logerror("pthread_attr_init failed - fatal");
2976 		exit(1);
2977 	}
2978 
2979 	(void) pthread_attr_setscope(&sys_attr, PTHREAD_SCOPE_PROCESS);
2980 	(void) pthread_attr_setscope(&log_attr, PTHREAD_SCOPE_PROCESS);
2981 	(void) pthread_attr_setscope(&net_attr, PTHREAD_SCOPE_PROCESS);
2982 	(void) pthread_attr_setscope(&hnl_attr, PTHREAD_SCOPE_PROCESS);
2983 	(void) pthread_attr_setscope(&door_thr_attr, PTHREAD_SCOPE_SYSTEM);
2984 	(void) pthread_attr_setdetachstate(&door_thr_attr,
2985 	    PTHREAD_CREATE_DETACHED);
2986 
2987 	/* 1: logmsg thread */
2988 	(void) pthread_attr_setstacksize(&log_attr, stacksize);
2989 	(void) pthread_attr_setstackaddr(&log_attr, stack_ptr);
2990 	stack_ptr += stacksize + redzonesize;
2991 	if (pthread_create(&log_thread, &log_attr, logmsg, NULL) != 0) {
2992 		logerror("pthread_create failed - fatal");
2993 		exit(1);
2994 	}
2995 
2996 	/*
2997 	 * open the log device, and pull up all pending message
2998 	 * from the log driver.
2999 	 */
3000 	prepare_sys_poll();
3001 
3002 	/*
3003 	 * Now we can deliver the pending internal error messages.
3004 	 */
3005 	enable_errorlog();
3006 
3007 	/* 2: sys_poll thread */
3008 	(void) pthread_attr_setstacksize(&sys_attr, stacksize);
3009 	(void) pthread_attr_setstackaddr(&sys_attr, stack_ptr);
3010 	stack_ptr += stacksize + redzonesize;
3011 	if (pthread_create(&sys_thread, &sys_attr, sys_poll, NULL) != 0) {
3012 		logerror("pthread_create failed - fatal");
3013 		exit(1);
3014 	}
3015 
3016 	/*
3017 	 * We've started the sys_poll() and logmsg() threads.  Now we are ready
3018 	 * to open the door.  This cannot happen before spawning sys_poll(),
3019 	 * because after opening the door, syslog() will no longer take care of
3020 	 * LOG_CONS.  Therefor, we should pull up all pending log messages and
3021 	 * activate sys_poll() before opening the door, so that log driver
3022 	 * won't drop messages.
3023 	 */
3024 	open_door();
3025 
3026 	DPRINT1(1, "init(%u): accepting messages from local system\n",
3027 	    mythreadno);
3028 
3029 	if (turnoff == 0) {
3030 		/* init the hostname lookup queue */
3031 		(void) dataq_init(&hnlq);
3032 
3033 		/* 3: hostname lookup thread */
3034 		(void) pthread_attr_setstacksize(&hnl_attr, stacksize);
3035 		(void) pthread_attr_setstackaddr(&hnl_attr, stack_ptr);
3036 		stack_ptr += stacksize + redzonesize;
3037 		if (pthread_create(&hnl_thread, &hnl_attr,
3038 		    hostname_lookup, NULL) != 0) {
3039 			logerror("pthread_create failed - fatal");
3040 			exit(1);
3041 		}
3042 
3043 		/* 4: net_poll thread */
3044 		(void) pthread_attr_setstacksize(&net_attr, stacksize);
3045 		(void) pthread_attr_setstackaddr(&net_attr, stack_ptr);
3046 		stack_ptr += stacksize + redzonesize;
3047 
3048 		/* grab UDP port */
3049 		bindnet();
3050 
3051 		if (pthread_create(&net_thread, &net_attr, net_poll,
3052 		    NULL) != 0) {
3053 			logerror("pthread_create failed - fatal");
3054 			exit(1);
3055 		}
3056 		DPRINT1(1, "init(%u): accepting messages from remote\n",
3057 		    mythreadno);
3058 	}
3059 
3060 	(void) pthread_attr_destroy(&sys_attr);
3061 	(void) pthread_attr_destroy(&net_attr);
3062 	(void) pthread_attr_destroy(&log_attr);
3063 	(void) pthread_attr_destroy(&hnl_attr);
3064 
3065 	curalarm = MarkInterval * 60 / MARKCOUNT;
3066 	(void) alarm((unsigned)curalarm);
3067 	DPRINT2(2, "init(%u): Next alarm in %d seconds\n",
3068 	    mythreadno, curalarm);
3069 	DPRINT1(1, "init(%u): syslogd: started\n", mythreadno);
3070 }
3071 
3072 /*
3073  * will print a bunch of debugging stats on 'fd'
3074  */
3075 static void
3076 dumpstats(int fd)
3077 {
3078 	FILE *out;
3079 	struct filed *f;
3080 	int i;
3081 	char users[1024];
3082 	char cbuf[30];
3083 	char *dashes = "------------------------";
3084 	static int conversion_printed;
3085 
3086 	if ((out = fdopen(fd, "w+")) == NULL)
3087 		return;
3088 
3089 	(void) fprintf(out, "\nSyslogd started: %s",
3090 	    ctime_r(&start_time, cbuf));
3091 	(void) fprintf(out, "Input message count: system %d, network %d\n",
3092 	    sys_msg_count, net_msg_count);
3093 	(void) fprintf(out, "# Outputs: %d\n\n", nlogs);
3094 
3095 	(void) fprintf(out, "%s priority = [file, facility] %s\n\n",
3096 	    dashes, dashes);
3097 
3098 	for (i = 0; i < LOG_NFACILITIES + 1; i++) {
3099 		(void) fprintf(out, "%d ", i / 10);
3100 	}
3101 	(void) fprintf(out, "\n");
3102 	for (i = 0; i < LOG_NFACILITIES + 1; i++) {
3103 		(void) fprintf(out, "%d ", i % 10);
3104 	}
3105 	(void) fprintf(out, "\n");
3106 	for (i = 0; i < LOG_NFACILITIES + 1; i++) {
3107 		(void) fprintf(out, "--");
3108 	}
3109 	(void) fprintf(out, "\n");
3110 
3111 	for (f = Files; f < &Files[nlogs]; f++) {
3112 		for (i = 0; i < LOG_NFACILITIES + 1; i++) {
3113 			if (f->f_pmask[i] == NOPRI)
3114 				(void) fprintf(out, "X ");
3115 			else
3116 				(void) fprintf(out, "%d ",
3117 				    f->f_pmask[i]);
3118 		}
3119 		(void) fprintf(out, "%s: ", TypeNames[f->f_type]);
3120 		switch (f->f_type) {
3121 		case F_FILE:
3122 		case F_TTY:
3123 		case F_CONSOLE:
3124 			(void) fprintf(out, "%s", f->f_un.f_fname);
3125 			break;
3126 		case F_FORW:
3127 			(void) fprintf(out, "%s", f->f_un.f_forw.f_hname);
3128 			break;
3129 		case F_USERS:
3130 			for (i = 0; i < MAXUNAMES &&
3131 			    *f->f_un.f_uname[i]; i++) {
3132 				if (!i)
3133 					(void) fprintf(out, "%s",
3134 					    f->f_un.f_uname[i]);
3135 				else
3136 					(void) fprintf(out, ", %s",
3137 					    f->f_un.f_uname[i]);
3138 			}
3139 			break;
3140 		}
3141 		(void) fprintf(out, "\n");
3142 	}
3143 
3144 	if (!conversion_printed) {
3145 		(void) fprintf(out, "\nFacilities:\n");
3146 
3147 		for (i = 0; FacNames[i].c_val != -1; i++) {
3148 			(void) fprintf(out, "  [%02d] %s: %3d\n", i,
3149 			    FacNames[i].c_name, FacNames[i].c_val);
3150 		}
3151 
3152 		(void) fprintf(out, "\nPriorities:\n");
3153 
3154 		for (i = 0; PriNames[i].c_val != -1; i++) {
3155 			(void) fprintf(out, "  [%02d] %s: %3d\n", i,
3156 			    PriNames[i].c_name, PriNames[i].c_val);
3157 		}
3158 
3159 		conversion_printed = 1;
3160 	}
3161 
3162 	(void) fprintf(out, "\n\n\n\t\tPer File Statistics\n");
3163 	(void) fprintf(out, "%-24s\tTot\tDups\tNofwd\tErrs\n", "File");
3164 	(void) fprintf(out, "%-24s\t---\t----\t-----\t----\n", "----");
3165 	for (f = Files; f < &Files[nlogs]; f++) {
3166 		switch (f->f_type) {
3167 		case F_FILE:
3168 		case F_TTY:
3169 		case F_CONSOLE:
3170 			(void) fprintf(out, "%-24s", f->f_un.f_fname);
3171 			break;
3172 		case F_WALL:
3173 			(void) fprintf(out, "%-24s", TypeNames[f->f_type]);
3174 			break;
3175 		case F_FORW:
3176 			(void) fprintf(out, "%-24s", f->f_un.f_forw.f_hname);
3177 			break;
3178 		case F_USERS:
3179 			for (i = 0; i < MAXUNAMES &&
3180 			    *f->f_un.f_uname[i]; i++) {
3181 				if (!i)
3182 					(void) strcpy(users,
3183 					    f->f_un.f_uname[i]);
3184 				else {
3185 					(void) strcat(users, ",");
3186 					(void) strcat(users,
3187 					    f->f_un.f_uname[i]);
3188 				}
3189 			}
3190 			(void) fprintf(out, "%-24s", users);
3191 			break;
3192 		}
3193 		(void) fprintf(out, "\t%d\t%d\t%d\t%d\n",
3194 		    f->f_stat.total, f->f_stat.dups,
3195 		    f->f_stat.cantfwd, f->f_stat.errs);
3196 	}
3197 	(void) fprintf(out, "\n\n");
3198 	if (Debug && fd == 1)
3199 		return;
3200 	(void) fclose(out);
3201 }
3202 
3203 /*
3204  * conf_init - This routine is code seperated from the
3205  * init routine in order to be re-callable when we get
3206  * a SIGHUP signal.
3207  */
3208 static void
3209 conf_init(void)
3210 {
3211 	char *p;
3212 	int i;
3213 	struct filed *f;
3214 	char *m4argv[4];
3215 	int m4argc = 0;
3216 	conf_t cf;
3217 	pthread_t mythreadno;
3218 
3219 	if (Debug) {
3220 		mythreadno = pthread_self();
3221 	}
3222 
3223 	DPRINT1(2, "conf_init(%u): starting logger threads\n",
3224 	    mythreadno);
3225 
3226 	m4argv[m4argc++] = "m4";
3227 
3228 	if (amiloghost() == 1) {
3229 		DPRINT1(1, "conf_init(%u): I am loghost\n", mythreadno);
3230 		m4argv[m4argc++] = "-DLOGHOST=1";
3231 	}
3232 
3233 	m4argv[m4argc++] = ConfFile;
3234 	m4argv[m4argc] = NULL;
3235 
3236 	/*
3237 	 * Make sure the configuration file and m4 exist, and then parse
3238 	 * the configuration file with m4.  If any of these fail, resort
3239 	 * to our hardcoded fallback configuration.
3240 	 */
3241 
3242 	if (access(ConfFile, R_OK) == -1) {
3243 		DPRINT2(1, "conf_init(%u): %s does not exist\n", mythreadno,
3244 		    ConfFile);
3245 		logerror("can't open configuration file");
3246 		/* CSTYLED */
3247 		Files = (struct filed *) &fallback; /*lint !e545 */
3248 		cfline("*.ERR\t/dev/sysmsg", 0, &Files[0]);
3249 		cfline("*.PANIC\t*", 0, &Files[1]);
3250 		nlogs = 2;
3251 		goto nofile;
3252 	}
3253 
3254 	if (checkm4() != 0 || conf_open(&cf, "/usr/ccs/bin/m4", m4argv) == -1) {
3255 		DPRINT2(1, "conf_init(%u): cannot open %s\n", mythreadno,
3256 		    ConfFile);
3257 		/* CSTYLED */
3258 		Files = (struct filed *) &fallback; /*lint !e545 */
3259 		cfline("*.ERR\t/dev/sysmsg", 0, &Files[0]);
3260 		cfline("*.PANIC\t*", 0, &Files[1]);
3261 		nlogs = 2;
3262 		goto nofile;
3263 	}
3264 
3265 	/* Count the number of lines which are not blanks or comments */
3266 	nlogs = 0;
3267 	while ((p = conf_read(&cf)) != NULL) {
3268 		if (p[0] != '\0' && p[0] != '#')
3269 			nlogs++;
3270 	}
3271 
3272 	Files = (struct filed *)malloc(sizeof (struct filed) * nlogs);
3273 
3274 	if (!Files) {
3275 		DPRINT1(1, "conf_init(%u): malloc failed - can't "
3276 		    "allocate 'Files' array\n", mythreadno);
3277 		MALLOC_FAIL("loading minimum configuration");
3278 		/* CSTYLED */
3279 		Files = (struct filed *) &fallback; /*lint !e545 */
3280 		cfline("*.ERR\t/dev/sysmsg", 0, &Files[0]);
3281 		cfline("*.PANIC\t*", 0, &Files[1]);
3282 		nlogs = 2;
3283 		conf_close(&cf);
3284 		goto nofile;
3285 	}
3286 
3287 	/*
3288 	 *  Foreach line in the conf table, open that file.
3289 	 */
3290 	conf_rewind(&cf);
3291 	f = Files;
3292 	i = 0;
3293 	while (((p = conf_read(&cf)) != NULL) && (f < &Files[nlogs])) {
3294 		i++;
3295 		/* check for end-of-section */
3296 		if (p[0] == '\0' || p[0] == '#')
3297 			continue;
3298 
3299 		cfline(p, i, f);
3300 		if (f->f_type == F_UNUSED)
3301 			nlogs--;
3302 		else
3303 			f++;
3304 	}
3305 
3306 	conf_close(&cf);
3307 
3308 	/*
3309 	 * See if marks are to be written to any files.  If so, set up a
3310 	 * timeout for marks.
3311 	 */
3312 nofile:
3313 	Marking = 0;
3314 
3315 	/*
3316 	 * allocate thread stacks - one for each logger thread.
3317 	 */
3318 	if ((cstack_ptr = alloc_stacks(nlogs)) == NULL) {
3319 		logerror("alloc_stacks failed - fatal");
3320 		exit(1);
3321 	}
3322 
3323 	/* And now one thread for each configured file */
3324 	for (f = Files; f < &Files[nlogs]; f++) {
3325 		if (filed_init(f) != 0) {
3326 			logerror("pthread_create failed - fatal");
3327 			exit(1);
3328 		}
3329 
3330 		(void) pthread_mutex_lock(&cft);
3331 		++conf_threads;
3332 		(void) pthread_mutex_unlock(&cft);
3333 
3334 		if (f->f_type != F_UNUSED &&
3335 		    f->f_pmask[LOG_NFACILITIES] != NOPRI)
3336 			Marking = 1;
3337 	}
3338 }
3339 
3340 /*
3341  * filed init - initialize fields in a file descriptor struct
3342  * this is called before multiple threads are running, so no mutex
3343  * needs to be held at this time.
3344  */
3345 static int
3346 filed_init(struct filed *f)
3347 {
3348 	pthread_attr_t stack_attr;
3349 	pthread_t mythreadno;
3350 
3351 	if (Debug) {
3352 		mythreadno = pthread_self();
3353 	}
3354 
3355 	if (pthread_mutex_init(&f->filed_mutex, NULL) != 0) {
3356 		logerror("pthread_mutex_init failed");
3357 		return (-1);
3358 	}
3359 
3360 	DPRINT2(5, "filed_init(%u): dataq_init for queue %p\n",
3361 	    mythreadno, (void *)&f->f_queue);
3362 	(void) dataq_init(&f->f_queue);
3363 
3364 	if (pthread_attr_init(&stack_attr) != 0) {
3365 		logerror("pthread_attr_init failed");
3366 		return (-1);
3367 	}
3368 
3369 	(void) pthread_attr_setstacksize(&stack_attr, stacksize);
3370 	(void) pthread_attr_setstackaddr(&stack_attr, cstack_ptr);
3371 	cstack_ptr += stacksize + redzonesize;
3372 
3373 	f->f_msgflag = 0;
3374 	f->f_prevmsg.msg[0] = '\0';
3375 	f->f_prevmsg.flags = 0;
3376 	f->f_prevmsg.pri = 0;
3377 	f->f_prevmsg.host[0] = '\0';
3378 
3379 	f->f_current.msg[0] = '\0';
3380 	f->f_current.flags = 0;
3381 	f->f_current.pri = 0;
3382 	f->f_current.host[0] = '\0';
3383 
3384 	f->f_prevcount = 0;
3385 
3386 	f->f_stat.flag = 0;
3387 	f->f_stat.total = 0;
3388 	f->f_stat.dups = 0;
3389 	f->f_stat.cantfwd = 0;
3390 	f->f_stat.errs = 0;
3391 
3392 	if (pthread_create(&f->f_thread, NULL, logit, (void *)f) != 0) {
3393 		logerror("pthread_create failed");
3394 		(void) pthread_attr_destroy(&stack_attr);
3395 		return (-1);
3396 	}
3397 
3398 	(void) pthread_attr_destroy(&stack_attr);
3399 	return (0);
3400 }
3401 
3402 
3403 /*
3404  * Crack a configuration file line
3405  */
3406 static void
3407 cfline(char *line, int lineno, struct filed *f)
3408 {
3409 	char *p;
3410 	char *q;
3411 	int i;
3412 	char *bp;
3413 	int pri;
3414 	char buf[MAXLINE];
3415 	char ebuf[SYS_NMLN+1+40];
3416 	mode_t fmode, omode = O_WRONLY|O_APPEND|O_NOCTTY;
3417 	struct stat64 sbuf;
3418 	pthread_t mythreadno;
3419 
3420 	if (Debug) {
3421 		mythreadno = pthread_self();
3422 	}
3423 
3424 	DPRINT2(1, "cfline(%u): (%s)\n", mythreadno, line);
3425 
3426 	errno = 0;	/* keep errno related stuff out of logerror messages */
3427 
3428 	/* clear out file entry */
3429 	bzero((char *)f, sizeof (*f));
3430 	for (i = 0; i <= LOG_NFACILITIES; i++)
3431 		f->f_pmask[i] = NOPRI;
3432 
3433 	/* scan through the list of selectors */
3434 	for (p = line; *p && *p != '\t'; ) {
3435 
3436 		/* find the end of this facility name list */
3437 		for (q = p; *q && *q != '\t' && *q++ != '.'; )
3438 			continue;
3439 
3440 		/* collect priority name */
3441 		for (bp = buf; *q && !strchr("\t,;", *q); )
3442 			*bp++ = *q++;
3443 		*bp = '\0';
3444 
3445 		/* skip cruft */
3446 		while (strchr(", ;", *q))
3447 			q++;
3448 
3449 		/* decode priority name */
3450 		pri = decode(buf, PriNames);
3451 		if (pri < 0) {
3452 			logerror("line %d: unknown priority name \"%s\"",
3453 			    lineno, buf);
3454 			return;
3455 		}
3456 
3457 		/* scan facilities */
3458 		while (*p && !strchr("\t.;", *p)) {
3459 			for (bp = buf; *p && !strchr("\t,;.", *p); )
3460 				*bp++ = *p++;
3461 			*bp = '\0';
3462 			if (*buf == '*')
3463 				for (i = 0; i < LOG_NFACILITIES; i++)
3464 					f->f_pmask[i] = (uchar_t)pri;
3465 			else {
3466 				i = decode(buf, FacNames);
3467 				if (i < 0) {
3468 					logerror("line %d: unknown facility"
3469 					    " name \"%s\"", lineno, buf);
3470 					return;
3471 				}
3472 				f->f_pmask[i >> 3] = (uchar_t)pri;
3473 			}
3474 			while (*p == ',' || *p == ' ')
3475 				p++;
3476 		}
3477 
3478 		p = q;
3479 	}
3480 
3481 	/* skip to action part */
3482 	while (*p == '\t' || *p == ' ')
3483 		p++;
3484 
3485 	switch (*p) {
3486 	case '\0':
3487 		errno = 0;
3488 		logerror("line %d: no action part", lineno);
3489 		break;
3490 
3491 	case '@':
3492 		(void) strlcpy(f->f_un.f_forw.f_hname, ++p, SYS_NMLN);
3493 		if (logforward(f, ebuf, sizeof (ebuf)) != 0) {
3494 			logerror("line %d: %s", lineno, ebuf);
3495 			break;
3496 		}
3497 		f->f_type = F_FORW;
3498 		break;
3499 
3500 	case '/':
3501 		(void) strlcpy(f->f_un.f_fname, p, MAXPATHLEN);
3502 		if (stat64(p, &sbuf) < 0) {
3503 			logerror(p);
3504 			break;
3505 		}
3506 		/*
3507 		 * don't block trying to open a pipe
3508 		 * with no reader on the other end
3509 		 */
3510 		fmode = 0; 	/* reset each pass */
3511 		if (S_ISFIFO(sbuf.st_mode))
3512 			fmode = O_NONBLOCK;
3513 
3514 		f->f_file = open64(p, omode|fmode);
3515 		if (f->f_file < 0) {
3516 			if (fmode && errno == ENXIO) {
3517 				errno = 0;
3518 				logerror("%s - no reader", p);
3519 			} else
3520 				logerror(p);
3521 			break;
3522 		}
3523 
3524 		/*
3525 		 * Fifos are initially opened NONBLOCK
3526 		 * to insure we don't hang, but once
3527 		 * we are open, we need to change the
3528 		 * behavior back to blocking, otherwise
3529 		 * we may get write errors, and the log
3530 		 * will get closed down the line.
3531 		 */
3532 		if (S_ISFIFO(sbuf.st_mode))
3533 			(void) fcntl(f->f_file, F_SETFL, omode);
3534 
3535 		if (isatty(f->f_file)) {
3536 			f->f_type = F_TTY;
3537 			untty();
3538 		} else
3539 			f->f_type = F_FILE;
3540 
3541 		if ((strcmp(p, ctty) == 0) || (strcmp(p, sysmsg) == 0))
3542 			f->f_type = F_CONSOLE;
3543 		break;
3544 
3545 	case '*':
3546 		f->f_type = F_WALL;
3547 		break;
3548 
3549 	default:
3550 		for (i = 0; i < MAXUNAMES && *p; i++) {
3551 			for (q = p; *q && *q != ','; )
3552 				q++;
3553 			(void) strlcpy(f->f_un.f_uname[i], p, UNAMESZ);
3554 			if ((q - p) > UNAMESZ)
3555 				f->f_un.f_uname[i][UNAMESZ] = '\0';
3556 			else
3557 				f->f_un.f_uname[i][q - p] = '\0';
3558 			while (*q == ',' || *q == ' ')
3559 				q++;
3560 			p = q;
3561 		}
3562 		f->f_type = F_USERS;
3563 		break;
3564 	}
3565 	f->f_orig_type = f->f_type;
3566 }
3567 
3568 
3569 /*
3570  *  Decode a symbolic name to a numeric value
3571  */
3572 static int
3573 decode(char *name, struct code *codetab)
3574 {
3575 	struct code *c;
3576 	char *p;
3577 	char buf[40];
3578 
3579 	if (isdigit(*name))
3580 		return (atoi(name));
3581 
3582 	(void) strncpy(buf, name, sizeof (buf) - 1);
3583 	for (p = buf; *p; p++)
3584 		if (isupper(*p))
3585 			*p = tolower(*p);
3586 	for (c = codetab; c->c_name; c++)
3587 		if (!(strcmp(buf, c->c_name)))
3588 			return (c->c_val);
3589 
3590 	return (-1);
3591 }
3592 
3593 static int
3594 ismyaddr(struct netbuf *nbp)
3595 {
3596 	int i;
3597 
3598 	if (nbp == NULL)
3599 		return (0);
3600 
3601 	for (i = 1; i < Ninputs; i++) {
3602 		if (same_addr(nbp, Myaddrs[i]))
3603 			return (1);
3604 	}
3605 	return (0);
3606 }
3607 
3608 static void
3609 getnets(void)
3610 {
3611 	struct nd_hostserv hs;
3612 	struct netconfig *ncp;
3613 	struct nd_addrlist *nap;
3614 	struct netbuf *nbp;
3615 	int i, inputs;
3616 	void *handle;
3617 	char *uap;
3618 	pthread_t mythreadno;
3619 
3620 	if (Debug) {
3621 		mythreadno = pthread_self();
3622 	}
3623 
3624 	if (turnoff) {
3625 		DPRINT1(1, "getnets(%u): network is being turned off\n",
3626 		    mythreadno);
3627 		return;
3628 	}
3629 
3630 	hs.h_host = HOST_SELF;
3631 	hs.h_serv = "syslog";
3632 
3633 	if ((handle = setnetconfig()) == NULL) {
3634 		return;
3635 	}
3636 
3637 	while ((ncp = getnetconfig(handle)) != NULL) {
3638 		if (ncp->nc_semantics != NC_TPI_CLTS) {
3639 			continue;
3640 		}
3641 
3642 		if (netdir_getbyname(ncp, &hs, &nap) != 0) {
3643 			continue;
3644 		}
3645 
3646 		if (nap == NULL || nap->n_cnt <= 0) {
3647 			DPRINT1(1, "getnets(%u): found no address\n",
3648 			    mythreadno);
3649 			netdir_free((void *)nap, ND_ADDRLIST);
3650 			continue;
3651 		}
3652 
3653 		if (Debug) {
3654 			DPRINT2(1, "getnets(%u): found %d addresses",
3655 			    mythreadno, nap->n_cnt);
3656 			DPRINT0(1, ", they are: ");
3657 			nbp = nap->n_addrs;
3658 
3659 			for (i = 0; i < nap->n_cnt; i++) {
3660 				if ((uap = taddr2uaddr(ncp, nbp)) != NULL) {
3661 					DPRINT1(1, "%s ", uap);
3662 					free(uap);
3663 				}
3664 				nbp++;
3665 			}
3666 
3667 			DPRINT0(1, "\n");
3668 		}
3669 
3670 		inputs = Ninputs + nap->n_cnt;
3671 
3672 		Nfd = realloc(Nfd, inputs * sizeof (struct pollfd));
3673 		Ncf = realloc(Ncf, inputs * sizeof (struct netconfig));
3674 		Myaddrs = realloc(Myaddrs, inputs * sizeof (struct netbuf *));
3675 		Udp = realloc(Udp, inputs * sizeof (struct t_unitdata *));
3676 		Errp = realloc(Errp, inputs * sizeof (struct t_uderr *));
3677 
3678 		/*
3679 		 * all malloc failures here are fatal
3680 		 */
3681 		if (Nfd == NULL || Ncf == NULL || Myaddrs == NULL ||
3682 		    Udp == NULL || Errp == NULL) {
3683 			MALLOC_FAIL_EXIT;
3684 		}
3685 
3686 		nbp = nap->n_addrs;
3687 
3688 		for (i = 0; i < nap->n_cnt; i++, nbp++) {
3689 			char ebuf[128];
3690 
3691 			if (addnet(ncp, nbp) == 0) {
3692 				/* no error */
3693 				continue;
3694 			}
3695 
3696 			(void) strcpy(ebuf, "Unable to configure syslog port");
3697 
3698 			if ((uap = taddr2uaddr(ncp, nbp)) != NULL) {
3699 				size_t l = strlen(ebuf);
3700 				(void) snprintf(ebuf + l, sizeof (ebuf) - l,
3701 				    " for %s", uap);
3702 			}
3703 
3704 			DPRINT2(1, "getnets(%u): %s",
3705 			    mythreadno, ebuf);
3706 
3707 			if (uap) {
3708 				free(uap);
3709 			}
3710 
3711 			logerror(ebuf);
3712 			/*
3713 			 * Here maybe syslogd can quit. However, syslogd
3714 			 * has been ignoring this error and keep running.
3715 			 * So we won't break it.
3716 			 */
3717 		}
3718 
3719 		netdir_free((void *)nap, ND_ADDRLIST);
3720 	}
3721 
3722 	(void) endnetconfig(handle);
3723 }
3724 
3725 /*
3726  * Open the network device, and allocate necessary resources.
3727  * Myaddrs will also be filled, so that we can call ismyaddr() before
3728  * being bound to the network.
3729  */
3730 static int
3731 addnet(struct netconfig *ncp, struct netbuf *nbp)
3732 {
3733 	int fd;
3734 	struct netbuf *bp;
3735 
3736 	fd = t_open(ncp->nc_device, O_RDWR, NULL);
3737 
3738 	if (fd < 0) {
3739 		return (1);
3740 	}
3741 
3742 	(void) memcpy(&Ncf[Ninputs], ncp, sizeof (struct netconfig));
3743 
3744 	/*LINTED*/
3745 	Udp[Ninputs] = (struct t_unitdata *)t_alloc(fd, T_UNITDATA, T_ADDR);
3746 
3747 	if (Udp[Ninputs] == NULL) {
3748 		(void) t_close(fd);
3749 		return (1);
3750 	}
3751 
3752 	/*LINTED*/
3753 	Errp[Ninputs] = (struct t_uderr *)t_alloc(fd, T_UDERROR, T_ADDR);
3754 
3755 	if (Errp[Ninputs] == NULL) {
3756 		(void) t_close(fd);
3757 		(void) t_free((char *)Udp[Ninputs], T_UNITDATA);
3758 		return (1);
3759 	}
3760 
3761 	if ((bp = malloc(sizeof (struct netbuf))) == NULL ||
3762 	    (bp->buf = malloc(nbp->len)) == NULL) {
3763 		MALLOC_FAIL("allocating address buffer");
3764 		(void) t_close(fd);
3765 		(void) t_free((char *)Udp[Ninputs], T_UNITDATA);
3766 		(void) t_free((char *)Errp[Ninputs], T_UDERROR);
3767 
3768 		if (bp) {
3769 			free(bp);
3770 		}
3771 
3772 		return (1);
3773 	}
3774 
3775 	bp->len = nbp->len;
3776 	(void) memcpy(bp->buf, nbp->buf, nbp->len);
3777 	Myaddrs[Ninputs] = bp;
3778 
3779 	Nfd[Ninputs].fd = fd;
3780 	Nfd[Ninputs].events = POLLIN;
3781 	Ninputs++;
3782 	return (0);
3783 }
3784 
3785 /*
3786  * Allocate UDP buffer to minimize packet loss.
3787  */
3788 static void
3789 set_udp_buffer(int fd)
3790 {
3791 	struct t_optmgmt req, resp;
3792 	struct opthdr *opt;
3793 	size_t optsize, bsize = 256 * 1024;
3794 	pthread_t mythreadno;
3795 
3796 	if (Debug) {
3797 		mythreadno = pthread_self();
3798 	}
3799 
3800 	optsize = sizeof (struct opthdr) + sizeof (int);
3801 	if ((opt = malloc(optsize)) == NULL) {
3802 		MALLOC_FAIL("will have no udp buffer");
3803 		return;
3804 	}
3805 	opt->level = SOL_SOCKET;
3806 	opt->name = SO_RCVBUF;
3807 	opt->len = sizeof (int);
3808 	*(int *)(opt + 1) = bsize;
3809 
3810 	req.flags = T_NEGOTIATE;
3811 	req.opt.len = optsize;
3812 	req.opt.buf = (char *)opt;
3813 
3814 	resp.flags = 0;
3815 	resp.opt.maxlen = optsize;
3816 	resp.opt.buf = (char *)opt;
3817 
3818 	while (t_optmgmt(fd, &req, &resp) == -1 || resp.flags != T_SUCCESS) {
3819 		if (t_errno != TSYSERR || errno != ENOBUFS) {
3820 			bsize = 0;
3821 			break;
3822 		}
3823 		bsize >>= 1;
3824 		if (bsize < 8192) {
3825 			break;
3826 		}
3827 		*(int *)(opt + 1) = bsize;
3828 	}
3829 	if (bsize == 0) {
3830 		logerror("failed to allocate UDP buffer");
3831 	}
3832 	DPRINT3(1, "set_udp_buffer(%u): allocate %d for fd %d\n",
3833 	    mythreadno, bsize, fd);
3834 	free(opt);
3835 }
3836 
3837 /*
3838  * Attach the network, and allocate UDP buffer for the interface.
3839  */
3840 static void
3841 bindnet(void)
3842 {
3843 	struct t_bind bind, *bound;
3844 	int cnt, i;
3845 	char *uap;
3846 	pthread_t mythreadno;
3847 
3848 	if (Debug) {
3849 		mythreadno = pthread_self();
3850 	}
3851 
3852 	cnt = 0;
3853 
3854 	while (cnt < Ninputs) {
3855 		char ebuf[128];
3856 
3857 		/*LINTED*/
3858 		bound  = (struct t_bind *)t_alloc(Nfd[cnt].fd, T_BIND, T_ADDR);
3859 		bind.addr = *Myaddrs[cnt];
3860 		bind.qlen = 0;
3861 
3862 		if (t_bind(Nfd[cnt].fd, &bind, bound) == 0) {
3863 			if (same_addr(&bind.addr, &bound->addr)) {
3864 				(void) t_free((char *)bound, T_BIND);
3865 				set_udp_buffer(Nfd[cnt].fd);
3866 				cnt++;
3867 				continue;
3868 			}
3869 		}
3870 
3871 		/* failed to bind port */
3872 		(void) t_free((char *)bound, T_BIND);
3873 
3874 		(void) strcpy(ebuf, "Unable to bind syslog port");
3875 
3876 		uap = taddr2uaddr(&Ncf[cnt], Myaddrs[cnt]);
3877 		if (uap) {
3878 			i = strlen(ebuf);
3879 			(void) snprintf(ebuf + i, sizeof (ebuf) - i,
3880 			    " for %s", uap);
3881 		}
3882 
3883 		DPRINT2(1, "bindnet(%u): failed to bind port (%s)\n",
3884 		    mythreadno, uap ? uap : "<unknown>");
3885 
3886 		if (uap) {
3887 			free(uap);
3888 		}
3889 
3890 		errno = 0;
3891 		logerror(ebuf);
3892 
3893 		(void) t_close(Nfd[cnt].fd);
3894 		free(Myaddrs[cnt]->buf);
3895 		free(Myaddrs[cnt]);
3896 		(void) t_free((char *)Udp[cnt], T_UNITDATA);
3897 		(void) t_free((char *)Errp[cnt], T_UDERROR);
3898 
3899 		for (i = cnt; i < (Ninputs-1); i++) {
3900 			Nfd[i] = Nfd[i + 1];
3901 			Ncf[i] = Ncf[i + 1];
3902 			Myaddrs[i] = Myaddrs[i + 1];
3903 			Udp[i] = Udp[i + 1];
3904 			Errp[i] = Errp[i + 1];
3905 		}
3906 
3907 		Ninputs--;
3908 	}
3909 }
3910 
3911 static int
3912 logforward(struct filed *f, char *ebuf, size_t elen)
3913 {
3914 	struct nd_hostserv hs;
3915 	struct netbuf *nbp;
3916 	struct netconfig *ncp;
3917 	struct nd_addrlist *nap;
3918 	void *handle;
3919 	char *hp;
3920 
3921 	hp = f->f_un.f_forw.f_hname;
3922 	hs.h_host = hp;
3923 	hs.h_serv = "syslog";
3924 
3925 	if ((handle = setnetconfig()) == NULL) {
3926 		(void) strlcpy(ebuf,
3927 		    "unable to rewind the netconfig database", elen);
3928 		errno = 0;
3929 		return (-1);
3930 	}
3931 	nap = (struct nd_addrlist *)NULL;
3932 	while ((ncp = getnetconfig(handle)) != NULL) {
3933 		if (ncp->nc_semantics == NC_TPI_CLTS) {
3934 			if (netdir_getbyname(ncp, &hs, &nap) == 0) {
3935 				if (!nap)
3936 					continue;
3937 				nbp = nap->n_addrs;
3938 				break;
3939 			}
3940 		}
3941 	}
3942 	if (ncp == NULL) {
3943 		(void) endnetconfig(handle);
3944 		(void) snprintf(ebuf, elen,
3945 		    "WARNING: %s could not be resolved", hp);
3946 		errno = 0;
3947 		return (-1);
3948 	}
3949 	if (nap == (struct nd_addrlist *)NULL) {
3950 		(void) endnetconfig(handle);
3951 		(void) snprintf(ebuf, elen, "unknown host %s", hp);
3952 		errno = 0;
3953 		return (-1);
3954 	}
3955 	/* CSTYLED */
3956 	if (ismyaddr(nbp)) { /*lint !e644 */
3957 		netdir_free((void *)nap, ND_ADDRLIST);
3958 		(void) endnetconfig(handle);
3959 		(void) snprintf(ebuf, elen,
3960 		    "host %s is this host - logging loop", hp);
3961 		errno = 0;
3962 		return (-1);
3963 	}
3964 	f->f_un.f_forw.f_addr.buf = malloc(nbp->len);
3965 	if (f->f_un.f_forw.f_addr.buf == NULL) {
3966 		netdir_free((void *)nap, ND_ADDRLIST);
3967 		(void) endnetconfig(handle);
3968 		(void) strlcpy(ebuf, "malloc failed", elen);
3969 		return (-1);
3970 	}
3971 	bcopy(nbp->buf, f->f_un.f_forw.f_addr.buf, nbp->len);
3972 	f->f_un.f_forw.f_addr.len = nbp->len;
3973 	f->f_file = t_open(ncp->nc_device, O_RDWR, NULL);
3974 	if (f->f_file < 0) {
3975 		netdir_free((void *)nap, ND_ADDRLIST);
3976 		(void) endnetconfig(handle);
3977 		free(f->f_un.f_forw.f_addr.buf);
3978 		(void) strlcpy(ebuf, "t_open", elen);
3979 		return (-1);
3980 	}
3981 	netdir_free((void *)nap, ND_ADDRLIST);
3982 	(void) endnetconfig(handle);
3983 	if (t_bind(f->f_file, NULL, NULL) < 0) {
3984 		(void) strlcpy(ebuf, "t_bind", elen);
3985 		free(f->f_un.f_forw.f_addr.buf);
3986 		(void) t_close(f->f_file);
3987 		return (-1);
3988 	}
3989 	return (0);
3990 }
3991 
3992 static int
3993 amiloghost(void)
3994 {
3995 	struct nd_hostserv hs;
3996 	struct netconfig *ncp;
3997 	struct nd_addrlist *nap;
3998 	struct netbuf *nbp;
3999 	int i, fd;
4000 	void *handle;
4001 	char *uap;
4002 	struct t_bind bind, *bound;
4003 	pthread_t mythreadno;
4004 
4005 	if (Debug) {
4006 		mythreadno = pthread_self();
4007 	}
4008 
4009 	/*
4010 	 * we need to know if we are running on the loghost. This is
4011 	 * checked by binding to the address associated with "loghost"
4012 	 * and "syslogd" service over the connectionless transport
4013 	 */
4014 	hs.h_host = "loghost";
4015 	hs.h_serv = "syslog";
4016 
4017 	if ((handle = setnetconfig()) == NULL) {
4018 		return (0);
4019 	}
4020 
4021 	while ((ncp = getnetconfig(handle)) != NULL) {
4022 		if (ncp->nc_semantics != NC_TPI_CLTS) {
4023 			continue;
4024 		}
4025 
4026 		if (netdir_getbyname(ncp, &hs, &nap) != 0) {
4027 			continue;
4028 		}
4029 
4030 		if (nap == NULL) {
4031 			continue;
4032 		}
4033 
4034 		nbp = nap->n_addrs;
4035 
4036 		for (i = 0; i < nap->n_cnt; i++) {
4037 			if ((uap = taddr2uaddr(ncp, nbp)) != (char *)NULL) {
4038 				DPRINT2(1, "amiloghost(%u): testing %s\n",
4039 				    mythreadno, uap);
4040 			}
4041 
4042 			free(uap);
4043 
4044 			fd = t_open(ncp->nc_device, O_RDWR, NULL);
4045 
4046 			if (fd < 0) {
4047 				netdir_free((void *)nap, ND_ADDRLIST);
4048 				(void) endnetconfig(handle);
4049 				return (0);
4050 			}
4051 
4052 			/*LINTED*/
4053 			bound = (struct t_bind *)t_alloc(fd, T_BIND, T_ADDR);
4054 			bind.addr = *nbp;
4055 			bind.qlen = 0;
4056 
4057 			if (t_bind(fd, &bind, bound) == 0) {
4058 				(void) t_close(fd);
4059 				(void) t_free((char *)bound, T_BIND);
4060 				netdir_free((void *)nap, ND_ADDRLIST);
4061 				(void) endnetconfig(handle);
4062 				return (1);
4063 			} else {
4064 				(void) t_close(fd);
4065 				(void) t_free((char *)bound, T_BIND);
4066 			}
4067 
4068 			nbp++;
4069 		}
4070 
4071 		netdir_free((void *)nap, ND_ADDRLIST);
4072 	}
4073 
4074 	(void) endnetconfig(handle);
4075 	return (0);
4076 }
4077 
4078 int
4079 same_addr(struct netbuf *na, struct netbuf *nb)
4080 {
4081 	char *a, *b;
4082 	size_t n;
4083 
4084 	assert(na->buf != NULL && nb->buf != NULL);
4085 
4086 	if (na->len != nb->len) {
4087 		return (0);
4088 	}
4089 
4090 	a = na->buf;
4091 	b = nb->buf;
4092 	n = nb->len;
4093 
4094 	while (n-- > 0) {
4095 		if (*a++ != *b++) {
4096 			return (0);
4097 		}
4098 	}
4099 
4100 	return (1);
4101 }
4102 
4103 /*
4104  * allocates a new message structure, initializes it
4105  * and returns a pointer to it
4106  */
4107 static log_message_t *
4108 new_msg(void)
4109 {
4110 	log_message_t *lm;
4111 	pthread_t mythreadno;
4112 
4113 	if (Debug) {
4114 		mythreadno = pthread_self();
4115 	}
4116 
4117 	if ((lm = malloc(sizeof (log_message_t))) == NULL)
4118 		return ((log_message_t *)NULL);
4119 
4120 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*lm))
4121 
4122 	if (pthread_mutex_init(&lm->msg_mutex, NULL) != 0)
4123 		return ((log_message_t *)NULL);
4124 	lm->refcnt = 0;
4125 	lm->pri = 0;
4126 	lm->flags = 0;
4127 	lm->hlp = NULL;
4128 	lm->msg[0] = '\0';
4129 	lm->ptr = NULL;
4130 
4131 	DPRINT2(3, "new_msg(%u): creating msg %p\n", mythreadno, (void *)lm);
4132 	return (lm);
4133 }
4134 
4135 /*
4136  * frees a message structure - should only be called if
4137  * the refcount is 0
4138  */
4139 static void
4140 free_msg(log_message_t *lm)
4141 {
4142 	pthread_t mythreadno;
4143 
4144 	if (Debug) {
4145 		mythreadno = pthread_self();
4146 	}
4147 
4148 	assert(lm != NULL && lm->refcnt == 0);
4149 	if (lm->hlp != NULL)
4150 		freehl(lm->hlp);
4151 	DPRINT2(3, "free_msg(%u): freeing msg %p\n", mythreadno, (void *)lm);
4152 	free(lm);
4153 }
4154 
4155 /*
4156  *  Make sure that the message makes sense in the current locale, and
4157  *  does not contain stray control characters.
4158  */
4159 static void
4160 filter_string(char *mbstr, char *filtered, size_t max)
4161 {
4162 	size_t	cs = 0;
4163 	size_t	mb_cur_max;
4164 	unsigned char	*p = (unsigned char *)mbstr;
4165 	pthread_t mythreadno = 0;
4166 
4167 	if (Debug) {
4168 		mythreadno = pthread_self();
4169 	}
4170 
4171 	assert(mbstr != NULL && filtered != NULL);
4172 
4173 	/*
4174 	 * Since the access to MB_CUR_MAX is expensive (because
4175 	 * MB_CUR_MAX lives in a global area), it should be
4176 	 * restrained for the better performance.
4177 	 */
4178 	mb_cur_max = (size_t)MB_CUR_MAX;
4179 	if (mb_cur_max > 1) {
4180 		/* multibyte locale */
4181 		int	mlen;
4182 		wchar_t	wc;
4183 
4184 		while (*p != '\0') {
4185 			if ((mlen = mbtowc(&wc, (char *)p,
4186 			    mb_cur_max)) == -1) {
4187 				/*
4188 				 * Invalid byte sequence found.
4189 				 *
4190 				 * try to print one byte
4191 				 * in ASCII format.
4192 				 */
4193 				DPRINT2(9, "filter_string(%u): Invalid "
4194 				    "MB sequence: %ld\n", mythreadno,
4195 				    wc);
4196 
4197 				if (!putctrlc(*p++, &filtered, &cs, max)) {
4198 					/* not enough buffer */
4199 					goto end;
4200 				} else {
4201 					continue;
4202 				}
4203 			} else {
4204 				/*
4205 				 * Since *p is not a null byte here,
4206 				 * mbtowc should have never returned 0.
4207 				 *
4208 				 * A valid wide character found.
4209 				 */
4210 
4211 				if (wc != L'\t' && iswcntrl(wc)) {
4212 					/*
4213 					 * non-tab, non-newline, and
4214 					 * control character found.
4215 					 *
4216 					 * try to print this wide character
4217 					 * in ASCII-format.
4218 					 */
4219 					char	*q = filtered;
4220 
4221 					DPRINT2(9, "filter_string(%u): MB"
4222 					    " control character: %ld\n",
4223 					    mythreadno, wc);
4224 
4225 					while (mlen--) {
4226 						if (!putctrlc(*p++, &filtered,
4227 						    &cs, max)) {
4228 							/*
4229 							 * not enough buffer in
4230 							 * filtered
4231 							 *
4232 							 * cancel already
4233 							 * stored bytes in
4234 							 * filtered for this
4235 							 * wide character.
4236 							 */
4237 							filtered = q;
4238 							goto end;
4239 						}
4240 					}
4241 					continue;
4242 				} else {
4243 					/*
4244 					 * tab, newline, or non-control
4245 					 * character found.
4246 					 */
4247 					if (cs + mlen < max) {
4248 						/* enough buffer */
4249 						cs += mlen;
4250 						while (mlen--) {
4251 							*filtered++ = *p++;
4252 						}
4253 						continue;
4254 					} else {
4255 						/* not enough buffer */
4256 						goto end;
4257 					}
4258 				}
4259 			}
4260 		}
4261 	} else {
4262 		/* singlebyte locale */
4263 
4264 		while (*p != '\0') {
4265 			if (*p != '\t' && iscntrl(*p)) {
4266 				/*
4267 				 * non-tab, non-newline,
4268 				 * and control character found.
4269 				 *
4270 				 * try to print this singlebyte character
4271 				 * in ASCII format.
4272 				 */
4273 				DPRINT2(9, "filter_string(%u): control "
4274 				    "character: %d\n", mythreadno, *p);
4275 
4276 				if (!putctrlc(*p++, &filtered, &cs, max)) {
4277 					/* not enough buffer */
4278 					goto end;
4279 				} else {
4280 					continue;
4281 				}
4282 			} else if (*p != '\t' && !isprint(*p)) {
4283 				/*
4284 				 * non-tab and non printable character found
4285 				 * this check is required for the C locale
4286 				 */
4287 				DPRINT2(9, "filter_string(%u): non-printable "
4288 				    "character: %d\n", mythreadno, *p);
4289 				if (!putctrlc(*p++, &filtered, &cs, max)) {
4290 					/* not enough buffer */
4291 					goto end;
4292 				} else {
4293 					continue;
4294 				}
4295 			} else {
4296 				/*
4297 				 * tab, newline, non-control character, or
4298 				 * printable found.
4299 				 */
4300 				if (cs + 1 < max) {
4301 					*filtered++ = *p++;
4302 					cs++;
4303 					continue;
4304 				} else {
4305 					/* not enough buffer */
4306 					goto end;
4307 				}
4308 			}
4309 		}
4310 	}
4311 
4312 end:
4313 	*filtered = '\0';
4314 
4315 	if (cs >= 2 &&
4316 	    filtered[-2] == '\\' && filtered[-1] == 'n') {
4317 		filtered[-2] = '\0';
4318 	}
4319 }
4320 
4321 static char *
4322 alloc_stacks(int numstacks)
4323 {
4324 	size_t pagesize, mapsize;
4325 	char *stack_top;
4326 	char *addr;
4327 	int i;
4328 
4329 	pagesize = (size_t)sysconf(_SC_PAGESIZE);
4330 	/*
4331 	 * stacksize and redzonesize are global so threads
4332 	 * can be created elsewhere and refer to the sizes
4333 	 */
4334 	stacksize = (size_t)roundup(sysconf(_SC_THREAD_STACK_MIN) +
4335 	    DEFAULT_STACKSIZE, pagesize);
4336 	redzonesize = (size_t)roundup(DEFAULT_REDZONESIZE, pagesize);
4337 
4338 	/*
4339 	 * allocate an additional "redzonesize" chunk in addition
4340 	 * to what we require, so we can create a redzone at the
4341 	 * bottom of the last stack as well.
4342 	 */
4343 	mapsize = redzonesize + numstacks * (stacksize + redzonesize);
4344 	stack_top = mmap(NULL, mapsize, PROT_READ|PROT_WRITE,
4345 	    MAP_PRIVATE|MAP_ANON, -1, 0);
4346 	if (stack_top == MAP_FAILED)
4347 		return (NULL);
4348 
4349 	addr = stack_top;
4350 	/*
4351 	 * this loop is intentionally <= instead of <, so we can
4352 	 * protect the redzone at the bottom of the last stack
4353 	 */
4354 	for (i = 0; i <= numstacks; i++) {
4355 		(void) mprotect(addr, redzonesize, PROT_NONE);
4356 		addr += stacksize + redzonesize;
4357 	}
4358 	return ((char *)(stack_top + redzonesize));
4359 }
4360 
4361 static void
4362 dealloc_stacks(int numstacks)
4363 {
4364 	size_t pagesize, mapsize;
4365 
4366 	pagesize = (size_t)sysconf(_SC_PAGESIZE);
4367 
4368 	stacksize = (size_t)roundup(sysconf(_SC_THREAD_STACK_MIN) +
4369 	    DEFAULT_STACKSIZE, pagesize);
4370 
4371 	redzonesize = (size_t)roundup(DEFAULT_REDZONESIZE, pagesize);
4372 
4373 	mapsize = redzonesize + numstacks * (stacksize + redzonesize);
4374 	(void) munmap(cstack_ptr - mapsize, mapsize);
4375 }
4376 
4377 static void
4378 filed_destroy(struct filed *f)
4379 {
4380 	(void) dataq_destroy(&f->f_queue);
4381 	(void) pthread_mutex_destroy(&f->filed_mutex);
4382 }
4383 
4384 static void
4385 close_door(void)
4386 {
4387 	pthread_t mythreadno;
4388 
4389 	if (Debug) {
4390 		mythreadno = pthread_self();
4391 	}
4392 
4393 	(void) fdetach(DoorFileName);
4394 
4395 	DPRINT2(5, "close_door(%u): detached server() from %s\n",
4396 	    mythreadno, DoorFileName);
4397 }
4398 
4399 static void
4400 delete_doorfiles(void)
4401 {
4402 	pthread_t mythreadno;
4403 	struct stat sb;
4404 	int err;
4405 	char line[MAXLINE+1];
4406 
4407 	if (Debug) {
4408 		mythreadno = pthread_self();
4409 	}
4410 
4411 
4412 	if (lstat(DoorFileName, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
4413 		if (unlink(DoorFileName) < 0) {
4414 			err = errno;
4415 			(void) snprintf(line, sizeof (line),
4416 			    "unlink() of %s failed - fatal", DoorFileName);
4417 			errno = err;
4418 			logerror(line);
4419 			DPRINT3(1, "delete_doorfiles(%u): error: %s, "
4420 			    "errno=%d\n", mythreadno, line, err);
4421 			exit(1);
4422 		}
4423 
4424 		DPRINT2(5, "delete_doorfiles(%u): deleted %s\n",
4425 		    mythreadno, DoorFileName);
4426 	}
4427 
4428 	if (strcmp(DoorFileName, DOORFILE) == 0) {
4429 		if (lstat(OLD_DOORFILE, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
4430 			if (unlink(OLD_DOORFILE) < 0) {
4431 				err = errno;
4432 				(void) snprintf(line, sizeof (line),
4433 				    "unlink() of %s failed", OLD_DOORFILE);
4434 				DPRINT2(5, "delete_doorfiles(%u): %s\n",
4435 				    mythreadno, line);
4436 
4437 				if (err != EROFS) {
4438 					errno = err;
4439 					(void) strlcat(line, " - fatal",
4440 					    sizeof (line));
4441 					logerror(line);
4442 					DPRINT3(1, "delete_doorfiles(%u): "
4443 					    "error: %s, errno=%d\n",
4444 					    mythreadno, line, err);
4445 					exit(1);
4446 				}
4447 
4448 				DPRINT1(5, "delete_doorfiles(%u): unlink() "
4449 				    "failure OK on RO file system\n",
4450 				    mythreadno);
4451 			}
4452 
4453 			DPRINT2(5, "delete_doorfiles(%u): deleted %s\n",
4454 			    mythreadno, OLD_DOORFILE);
4455 		}
4456 	}
4457 
4458 	if (lstat(PidFileName, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
4459 		if (unlink(PidFileName) < 0) {
4460 			err = errno;
4461 			(void) snprintf(line, sizeof (line),
4462 			    "unlink() of %s failed - fatal", PidFileName);
4463 			errno = err;
4464 			logerror(line);
4465 			DPRINT3(1, "delete_doorfiles(%u): error: %s, "
4466 			    "errno=%d\n", mythreadno, line, err);
4467 			exit(1);
4468 		}
4469 
4470 		DPRINT2(5, "delete_doorfiles(%u): deleted %s\n", mythreadno,
4471 		    PidFileName);
4472 	}
4473 
4474 	if (strcmp(PidFileName, PIDFILE) == 0) {
4475 		if (lstat(OLD_PIDFILE, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
4476 			if (unlink(OLD_PIDFILE) < 0) {
4477 				err = errno;
4478 				(void) snprintf(line, sizeof (line),
4479 				    "unlink() of %s failed", OLD_PIDFILE);
4480 				DPRINT2(5, "delete_doorfiles(%u): %s, \n",
4481 				    mythreadno, line);
4482 
4483 				if (err != EROFS) {
4484 					errno = err;
4485 					(void) strlcat(line, " - fatal",
4486 					    sizeof (line));
4487 					logerror(line);
4488 					DPRINT3(1, "delete_doorfiles(%u): "
4489 					    "error: %s, errno=%d\n",
4490 					    mythreadno, line, err);
4491 					exit(1);
4492 				}
4493 
4494 				DPRINT1(5, "delete_doorfiles(%u): unlink "
4495 				    "failure OK on RO file system\n",
4496 				    mythreadno);
4497 			}
4498 
4499 			DPRINT2(5, "delete_doorfiles(%u): deleted %s\n",
4500 			    mythreadno, OLD_PIDFILE);
4501 		}
4502 	}
4503 
4504 	if (DoorFd != -1) {
4505 		(void) door_revoke(DoorFd);
4506 	}
4507 
4508 	DPRINT2(1, "delete_doorfiles(%u): revoked door: DoorFd=%d\n",
4509 	    mythreadno, DoorFd);
4510 }
4511 
4512 
4513 /*ARGSUSED*/
4514 static void
4515 signull(int sig, siginfo_t *sip, void *utp)
4516 {
4517 	DPRINT1(1, "signull(%u): THIS CALL SHOULD NEVER HAPPEN\n",
4518 	    pthread_self());
4519 	/*
4520 	 * Do nothing, as this is a place-holder used in conjunction with
4521 	 * sigaction()/sigwait() to ensure that the proper disposition is
4522 	 * given to the signals we handle in main().
4523 	 */
4524 }
4525 
4526 /*
4527  * putctrlc returns zero, if failed due to not enough buffer.
4528  * Otherwise, putctrlc returns non-zero.
4529  *
4530  * c:     a byte to print in ASCII format
4531  * **buf: a pointer to the pointer to the output buffer.
4532  * *cl:   current length of characters in the output buffer
4533  * max:   maximum length of the buffer
4534  */
4535 
4536 static int
4537 putctrlc(int c, char **buf, size_t *cl, size_t max)
4538 {
4539 	char	*p = *buf;
4540 
4541 	if (c == '\n') {
4542 		if (*cl + 2 < max) {
4543 			*p++ = '\\';
4544 			*p++ = 'n';
4545 			*cl += 2;
4546 			*buf = p;
4547 			return (2);
4548 		} else {
4549 			return (0);
4550 		}
4551 	} else if (c < 0200) {
4552 		/* ascii control character */
4553 		if (*cl + 2 < max) {
4554 			*p++ = '^';
4555 			*p++ = c ^ 0100;
4556 			*cl += 2;
4557 			*buf = p;
4558 			return (2);
4559 		} else {
4560 			return (0);
4561 		}
4562 	} else {
4563 		if (*cl + 4 < max) {
4564 			*p++ = '\\';
4565 			*p++ = ((c >> 6) & 07) + '0';
4566 			*p++ = ((c >> 3) & 07) + '0';
4567 			*p++ = (c & 07) + '0';
4568 			*cl += 4;
4569 			*buf = p;
4570 			return (4);
4571 		} else {
4572 			return (0);
4573 		}
4574 	}
4575 }
4576 
4577 /*
4578  * findnl_bkwd:
4579  *	Scans each character in buf until it finds the last newline in buf,
4580  *	or the scanned character becomes the last COMPLETE character in buf.
4581  *	Returns the number of scanned bytes.
4582  *
4583  *	buf - pointer to a buffer containing the message string
4584  *	len - the length of the buffer
4585  */
4586 size_t
4587 findnl_bkwd(const char *buf, const size_t len)
4588 {
4589 	const char *p;
4590 	size_t	mb_cur_max;
4591 	pthread_t mythreadno;
4592 
4593 	if (Debug) {
4594 		mythreadno = pthread_self();
4595 	}
4596 
4597 	if (len == 0) {
4598 		return (0);
4599 	}
4600 
4601 	mb_cur_max = MB_CUR_MAX;
4602 
4603 	if (mb_cur_max == 1) {
4604 		/* single-byte locale */
4605 		for (p = buf + len - 1; p != buf; p--) {
4606 			if (*p == '\n') {
4607 				return ((size_t)(p - buf));
4608 			}
4609 		}
4610 		return ((size_t)len);
4611 	} else {
4612 		/* multi-byte locale */
4613 		int mlen;
4614 		const char *nl;
4615 		size_t	rem;
4616 
4617 		p = buf;
4618 		nl = NULL;
4619 		for (rem = len; rem >= mb_cur_max; ) {
4620 			mlen = mblen(p, mb_cur_max);
4621 			if (mlen == -1) {
4622 				/*
4623 				 * Invalid character found.
4624 				 */
4625 				DPRINT1(9, "findnl_bkwd(%u): Invalid MB "
4626 				    "sequence\n", mythreadno);
4627 				/*
4628 				 * handle as a single byte character.
4629 				 */
4630 				p++;
4631 				rem--;
4632 			} else {
4633 				/*
4634 				 * It's guaranteed that *p points to
4635 				 * the 1st byte of a multibyte character.
4636 				 */
4637 				if (*p == '\n') {
4638 					nl = p;
4639 				}
4640 				p += mlen;
4641 				rem -= mlen;
4642 			}
4643 		}
4644 		if (nl) {
4645 			return ((size_t)(nl - buf));
4646 		}
4647 		/*
4648 		 * no newline nor null byte found.
4649 		 * Also it's guaranteed that *p points to
4650 		 * the 1st byte of a (multibyte) character
4651 		 * at this point.
4652 		 */
4653 		return (len - rem);
4654 	}
4655 }
4656 
4657 /*
4658  * copynl_frwd:
4659  *	Scans each character in buf and copies the scanned character to obuf
4660  *	until it finds a null byte or a newline, or
4661  *	the number of the remaining bytes in obuf gets to exceed obuflen
4662  *	if copying the scanned character to obuf.
4663  *	Returns the number of scanned bytes.
4664  *
4665  *	obuf - buffer to be copied the scanned character
4666  *	obuflen - the size of obuf
4667  *	buf - pointer to a buffer containing the message string
4668  *	len - the length of the buffer
4669  */
4670 size_t
4671 copynl_frwd(char *obuf, const size_t obuflen,
4672 	    const char *buf, const size_t len)
4673 {
4674 	const char *p;
4675 	char	*q = obuf;
4676 	size_t	olen = 0;
4677 	size_t	mb_cur_max;
4678 	pthread_t mythreadno;
4679 
4680 	if (Debug) {
4681 		mythreadno = pthread_self();
4682 	}
4683 
4684 	if (len == 0) {
4685 		return (0);
4686 	}
4687 
4688 	mb_cur_max = MB_CUR_MAX;
4689 
4690 	if (mb_cur_max == 1) {
4691 		/* single-byte locale */
4692 		for (p = buf; *p; ) {
4693 			if (obuflen > olen + 1) {
4694 				if (*p != '\n') {
4695 					*q++ = *p++;
4696 					olen++;
4697 				} else {
4698 					*q = '\0';
4699 					return ((size_t)(p - buf));
4700 				}
4701 			} else {
4702 				*q = '\0';
4703 				return ((size_t)(p - buf));
4704 			}
4705 		}
4706 		*q = '\0';
4707 		return ((size_t)(p - buf));
4708 	} else {
4709 		/* multi-byte locale */
4710 		int mlen;
4711 
4712 		for (p = buf; *p; ) {
4713 			mlen = mblen(p, mb_cur_max);
4714 			if (mlen == -1) {
4715 				/*
4716 				 * Invalid character found.
4717 				 */
4718 				DPRINT1(9, "copynl_frwd(%u): Invalid MB "
4719 				    "sequence\n", mythreadno);
4720 				/*
4721 				 * handle as a single byte character.
4722 				 */
4723 				if (obuflen > olen + 1) {
4724 					*q++ = *p++;
4725 					olen++;
4726 				} else {
4727 					*q = '\0';
4728 					return ((size_t)(p - buf));
4729 				}
4730 			} else {
4731 				/*
4732 				 * It's guaranteed that *p points to
4733 				 * the 1st byte of a multibyte character.
4734 				 */
4735 				if (*p == '\n') {
4736 					*q = '\0';
4737 					return ((size_t)(p - buf));
4738 				}
4739 				if (obuflen > olen + mlen) {
4740 					int	n;
4741 					for (n = 0; n < mlen; n++) {
4742 						*q++ = *p++;
4743 					}
4744 					olen += mlen;
4745 				} else {
4746 					*q = '\0';
4747 					return ((size_t)(p - buf));
4748 				}
4749 			}
4750 		}
4751 		/*
4752 		 * no newline nor null byte found.
4753 		 * Also it's guaranteed that *p points to
4754 		 * the 1st byte of a (multibyte) character
4755 		 * at this point.
4756 		 */
4757 		*q = '\0';
4758 		return ((size_t)(p - buf));
4759 	}
4760 }
4761 
4762 /*
4763  * copy_frwd:
4764  *	Scans each character in buf and copies the scanned character to obuf
4765  *	until the number of the remaining bytes in obuf gets to exceed obuflen
4766  *	if copying the scanned character to obuf.
4767  *	Returns the number of scanned (copied) bytes.
4768  *
4769  *	obuf - buffer to be copied the scanned character
4770  *	obuflen - the size of obuf
4771  *	buf - pointer to a buffer containing the message string
4772  *	len - the length of the buffer
4773  */
4774 size_t
4775 copy_frwd(char *obuf, const size_t obuflen,
4776 	const char *buf, const size_t len)
4777 {
4778 	const char *p;
4779 	char	*q = obuf;
4780 	size_t	olen = 0;
4781 	size_t	mb_cur_max;
4782 	pthread_t mythreadno;
4783 
4784 	if (Debug) {
4785 		mythreadno = pthread_self();
4786 	}
4787 
4788 	if (len == 0) {
4789 		return (0);
4790 	}
4791 
4792 	mb_cur_max = MB_CUR_MAX;
4793 
4794 	if (mb_cur_max == 1) {
4795 		/* single-byte locale */
4796 		if (obuflen > len) {
4797 			(void) memcpy(obuf, buf, len);
4798 			obuf[len] = '\0';
4799 			return ((size_t)len);
4800 		} else {
4801 			(void) memcpy(obuf, buf, obuflen - 1);
4802 			obuf[obuflen - 1] = '\0';
4803 			return (obuflen - 1);
4804 		}
4805 	} else {
4806 		/* multi-byte locale */
4807 		int mlen;
4808 
4809 		for (p = buf; *p; ) {
4810 			mlen = mblen(p, mb_cur_max);
4811 			if (mlen == -1) {
4812 				/*
4813 				 * Invalid character found.
4814 				 */
4815 				DPRINT1(9, "copy_frwd(%u): Invalid MB "
4816 				    "sequence\n", mythreadno);
4817 				/*
4818 				 * handle as a single byte character.
4819 				 */
4820 				if (obuflen > olen + 1) {
4821 					*q++ = *p++;
4822 					olen++;
4823 				} else {
4824 					*q = '\0';
4825 					return ((size_t)(p - buf));
4826 				}
4827 			} else {
4828 				if (obuflen > olen + mlen) {
4829 					int	n;
4830 					for (n = 0; n < mlen; n++) {
4831 						*q++ = *p++;
4832 					}
4833 					olen += mlen;
4834 				} else {
4835 					*q = '\0';
4836 					return ((size_t)(p - buf));
4837 				}
4838 			}
4839 		}
4840 		*q = '\0';
4841 		return ((size_t)(p - buf));
4842 	}
4843 }
4844 
4845 /*
4846  * properties:
4847  *	Get properties from SMF framework.
4848  */
4849 static void
4850 properties(void)
4851 {
4852 	scf_simple_prop_t *prop;
4853 	uint8_t *bool;
4854 
4855 	if ((prop = scf_simple_prop_get(NULL, NULL, "config",
4856 	    "log_from_remote")) != NULL) {
4857 		if ((bool = scf_simple_prop_next_boolean(prop)) != NULL) {
4858 			if (*bool == 0)
4859 				turnoff = 1; /* log_from_remote = false */
4860 			else
4861 				turnoff = 0; /* log_from_remote = true */
4862 		}
4863 		scf_simple_prop_free(prop);
4864 		DPRINT1(1, "properties: setting turnoff to %s\n",
4865 		    turnoff ? "true" : "false");
4866 	}
4867 }
4868 
4869 /*
4870  * close all the input devices.
4871  */
4872 static void
4873 shutdown_input(void)
4874 {
4875 	int cnt;
4876 
4877 	shutting_down = 1;
4878 
4879 	for (cnt = 0; cnt < Ninputs; cnt++) {
4880 		(void) t_close(Nfd[cnt].fd);
4881 	}
4882 
4883 	(void) close(Pfd.fd);
4884 }
4885 
4886 /*
4887  * This is for the one thread that dedicates to resolve the
4888  * hostname. This will get the messages from net_poll() through
4889  * hnlq, and resolve the hostname, and push the messages back
4890  * into the inputq.
4891  */
4892 /*ARGSUSED*/
4893 static void *
4894 hostname_lookup(void *ap)
4895 {
4896 	char *uap;
4897 	log_message_t *mp;
4898 	host_info_t *hip;
4899 	char failsafe_addr[SYS_NMLN + 1];
4900 	pthread_t mythreadno;
4901 
4902 	if (Debug) {
4903 		mythreadno = pthread_self();
4904 	}
4905 
4906 	DPRINT1(1, "hostname_lookup(%u): hostname_lookup started\n",
4907 	    mythreadno);
4908 
4909 	for (;;) {
4910 		(void) dataq_dequeue(&hnlq, (void **)&mp, 0);
4911 
4912 		DPRINT3(5, "hostname_lookup(%u): dequeued msg %p"
4913 		    " from queue %p\n", mythreadno, (void *)mp,
4914 		    (void *)&hnlq);
4915 
4916 		hip = (host_info_t *)mp->ptr;
4917 		if ((uap = taddr2uaddr(hip->ncp, &hip->addr)) != NULL) {
4918 			(void) strlcpy(failsafe_addr, uap, SYS_NMLN);
4919 			free(uap);
4920 		} else {
4921 			(void) strlcpy(failsafe_addr, "<unknown>", SYS_NMLN);
4922 		}
4923 
4924 		mp->hlp = cvthname(&hip->addr, hip->ncp, failsafe_addr);
4925 
4926 		if (mp->hlp == NULL) {
4927 			mp->hlp = &NullHostName;
4928 		}
4929 
4930 		free(hip->addr.buf);
4931 		free(hip);
4932 		mp->ptr = NULL;
4933 
4934 		if (dataq_enqueue(&inputq, (void *)mp) == -1) {
4935 			MALLOC_FAIL("dropping message from remote");
4936 			free_msg(mp);
4937 			continue;
4938 		}
4939 
4940 		DPRINT3(5, "hostname_lookup(%u): enqueued msg %p on queue "
4941 		    "%p\n", mythreadno, (void *)mp, (void *)&inputq);
4942 	}
4943 
4944 	/*NOTREACHED*/
4945 	return (NULL);
4946 }
4947 
4948 /*
4949  * Does all HUP(re-configuration) process.
4950  */
4951 static void
4952 reconfigure()
4953 {
4954 	int cnt, loop, drops;
4955 	int really_stuck;
4956 	int console_stuck = 0;
4957 	struct filed *f;
4958 	char buf[LINE_MAX];
4959 	struct utsname up;
4960 	char cbuf[30];
4961 	time_t tim;
4962 	pthread_t mythreadno;
4963 
4964 	if (Debug) {
4965 		mythreadno = pthread_self();
4966 	}
4967 
4968 	/* If we get here then we must need to regen */
4969 	flushmsg(0);
4970 
4971 	if (logmymsg(LOG_SYSLOG|LOG_INFO, "syslogd: configuration restart",
4972 	    ADDDATE, 0) == -1) {
4973 		MALLOC_FAIL("dropping message");
4974 	}
4975 
4976 	/*
4977 	 * make sure the logmsg thread is not in the waiting state.
4978 	 * Otherwise, changing hup_state will prevent the logmsg thread
4979 	 * getting out from the waiting loop.
4980 	 */
4981 
4982 	if (Debug) {
4983 		tim = time(NULL);
4984 		DPRINT2(3, "reconfigure(%u): %.15s: awaiting logmsg()"
4985 		    " moving to the safe place\n",
4986 		    mythreadno, ctime_r(&tim, cbuf)+4);
4987 	}
4988 
4989 	for (loop = 0; loop < LOOP_MAX; loop++) {
4990 		/* we don't need the mutex to read */
4991 		if (hup_state == HUP_ACCEPTABLE)
4992 			break;
4993 		(void) sleep(1);
4994 	}
4995 	if (hup_state != HUP_ACCEPTABLE) {
4996 		goto thread_stuck;
4997 	}
4998 
4999 	if (Debug) {
5000 		tim = time(NULL);
5001 		DPRINT2(3, "reconfigure(%u): %.15s: logmsg() will accept HUP\n",
5002 		    mythreadno, ctime_r(&tim, cbuf)+4);
5003 	}
5004 
5005 	/*
5006 	 * Prevent logging until we are truly done processing the HUP
5007 	 */
5008 	(void) pthread_mutex_lock(&hup_lock);
5009 	hup_state = HUP_INPROGRESS;
5010 	(void) pthread_mutex_unlock(&hup_lock);
5011 
5012 	/*
5013 	 * We will be going into a critical state. Any error message
5014 	 * from syslogd needs to be dumped to the console by default
5015 	 * immediately. Also, those error messages are quened in a temporary
5016 	 * queue to be able to post into the regular stream later.
5017 	 */
5018 	disable_errorlog();
5019 
5020 	if (Debug) {
5021 		tim = time(NULL);
5022 		DPRINT2(3, "reconfigure(%u): %.15s: sending SHUTDOWN\n",
5023 		    mythreadno, ctime_r(&tim, cbuf)+4);
5024 	}
5025 
5026 	/* stop configured threads */
5027 	if (shutdown_msg() == -1) {
5028 		/*
5029 		 * No memory, message will be dumped to the console.
5030 		 */
5031 		MALLOC_FAIL("unable to restart syslogd");
5032 		goto out;
5033 	}
5034 
5035 	/* make sure logmsg() is in suspended state */
5036 	for (loop = 0; loop < LOOP_INTERVAL; loop++) {
5037 		if (hup_state & HUP_LOGMSG_SUSPENDED)
5038 			break;
5039 		(void) sleep(1);
5040 	}
5041 
5042 	if ((hup_state & HUP_LOGMSG_SUSPENDED) == 0) {
5043 		if (Debug) {
5044 			tim = time(NULL);
5045 			DPRINT2(3, "reconfigure(%u): %.15s: logmsg() does not "
5046 			    "stop. enforcing\n",
5047 			    mythreadno, ctime_r(&tim, cbuf)+4);
5048 		}
5049 
5050 		/* probably we have too long input queue, or really stuck */
5051 		(void) pthread_mutex_lock(&hup_lock);
5052 		hup_state |= HUP_SUSP_LOGMSG_REQD;
5053 		(void) pthread_mutex_unlock(&hup_lock);
5054 
5055 		for (loop = 0; loop < LOOP_MAX; loop++) {
5056 			if (hup_state & HUP_LOGMSG_SUSPENDED)
5057 				break;
5058 			(void) sleep(1);
5059 		}
5060 		if ((hup_state & HUP_LOGMSG_SUSPENDED) == 0) {
5061 			if (Debug) {
5062 				tim = time(NULL);
5063 				DPRINT2(3, "reconfigure(%u): %.15s: logmsg()"
5064 				    " does not stop. give up\n",
5065 				    mythreadno, ctime_r(&tim, cbuf)+4);
5066 			}
5067 			logerror("could not suspend logmsg - fatal");
5068 			goto thread_stuck;
5069 		}
5070 	}
5071 
5072 	if (Debug) {
5073 		tim = time(NULL);
5074 		DPRINT2(3, "reconfigure(%u): %.15s: logmsg() suspended\n",
5075 		    mythreadno, ctime_r(&tim, cbuf)+4);
5076 	}
5077 
5078 	/*
5079 	 * Will wait for LOOP_MAX secs with watching queue lengths for the
5080 	 * each logger threads. If they have backlogs, and no change in the
5081 	 * length of queue found in 30 seconds, those will be counted as
5082 	 * "really stuck".
5083 	 * If all running logger threads become "really stuck" state, there
5084 	 * should be no worth waiting for them to quit.
5085 	 * In that case, we will go ahead and close out file descriptors to
5086 	 * have them pull out from hanging system call, and give them a last
5087 	 * chance(LOOP_INTERVAL sec) to quit.
5088 	 */
5089 
5090 	if (Debug) {
5091 		tim = time(NULL);
5092 		DPRINT2(3, "reconfigure(%u): %.15s: awaiting logit() to be"
5093 		    " shutdown\n", mythreadno, ctime_r(&tim, cbuf)+4);
5094 	}
5095 
5096 	cnt = 0;
5097 	really_stuck = 0;
5098 	while (cnt < (LOOP_MAX/LOOP_INTERVAL) &&
5099 	    conf_threads > really_stuck) {
5100 
5101 		/* save initial queue count */
5102 		for (f = Files; f < &Files[nlogs]; f++) {
5103 			f->f_prev_queue_count = (f->f_type == F_UNUSED) ?
5104 			    -1 : f->f_queue_count;
5105 		}
5106 
5107 		for (loop = 0; loop < LOOP_INTERVAL; loop++) {
5108 			if (conf_threads == 0)
5109 				break;
5110 			(void) sleep(1);
5111 		}
5112 
5113 		if (conf_threads == 0)
5114 			break;
5115 
5116 		if (Debug) {
5117 			tim = time(NULL);
5118 			DPRINT3(3, "reconfigure(%u): %.15s: "
5119 			    "%d threads are still alive.\n",
5120 			    mythreadno, ctime_r(&tim, cbuf)+4,
5121 			    conf_threads);
5122 		}
5123 
5124 		really_stuck = 0;
5125 		for (f = Files; f < &Files[nlogs]; f++) {
5126 			if (f->f_type == F_UNUSED) {
5127 				f->f_prev_queue_count = -1;
5128 				continue;
5129 			}
5130 			if (f->f_prev_queue_count == f->f_queue_count) {
5131 				really_stuck++;
5132 				f->f_prev_queue_count = 1;
5133 				DPRINT2(3, "reconfigure(%u): "
5134 				    "tid=%d is really stuck.\n",
5135 				    mythreadno, f->f_thread);
5136 			} else {
5137 				f->f_prev_queue_count = 0;
5138 				DPRINT2(3, "reconfigure(%u): "
5139 				    "tid=%d is still active.\n",
5140 				    mythreadno, f->f_thread);
5141 			}
5142 		}
5143 		/*
5144 		 * Here we have one of following values in the
5145 		 * f_prev_queue_count:
5146 		 *  0: logger thread is still actively working.
5147 		 *  1: logger thread is really stuck.
5148 		 * -1: logger thread has already died.
5149 		 */
5150 
5151 		cnt++;
5152 	}
5153 
5154 	if (Debug) {
5155 		tim = time(NULL);
5156 		DPRINT2(3, "reconfigure(%u): %.15s:"
5157 		    " complete awaiting logit()\n",
5158 		    mythreadno, ctime_r(&tim, cbuf)+4);
5159 		DPRINT3(3, "reconfigure(%u): %d threads alive."
5160 		    " %d threads stuck\n",
5161 		    mythreadno, conf_threads, really_stuck);
5162 	}
5163 
5164 	/*
5165 	 * Still running? If so, mark it as UNUSED, and close
5166 	 * the fd so that logger threads can bail out from the loop.
5167 	 */
5168 	drops = 0;
5169 	if (conf_threads) {
5170 		for (f = Files; f < &Files[nlogs]; f++) {
5171 			if (f->f_type == F_CONSOLE &&
5172 			    f->f_prev_queue_count == 1) {
5173 				/* console is really stuck */
5174 				console_stuck = 1;
5175 			}
5176 			if (f->f_type == F_USERS || f->f_type == F_WALL ||
5177 			    f->f_type == F_UNUSED)
5178 				continue;
5179 			cnt = f->f_queue_count;
5180 			drops += (cnt > 0) ? cnt - 1: 0;
5181 			f->f_type = F_UNUSED;
5182 
5183 			if (f->f_orig_type == F_FORW)
5184 				(void) t_close(f->f_file);
5185 			else
5186 				(void) close(f->f_file);
5187 		}
5188 
5189 		if (Debug) {
5190 			tim = time(NULL);
5191 			DPRINT1(3, "reconfigure(%u): terminating logit()\n",
5192 			    mythreadno);
5193 		}
5194 
5195 		/* last chance to exit */
5196 		for (loop = 0; loop < LOOP_MAX; loop++) {
5197 			if (conf_threads == 0)
5198 				break;
5199 			(void) sleep(1);
5200 		}
5201 
5202 		if (Debug) {
5203 			tim = time(NULL);
5204 			DPRINT3(3, "reconfigure(%u): %.15s: %d alive\n",
5205 			    mythreadno, ctime_r(&tim, cbuf)+4,
5206 			    conf_threads);
5207 		}
5208 	}
5209 
5210 	if (conf_threads == 0 && drops) {
5211 		errno = 0;
5212 		logerror("Could not completely output pending messages"
5213 		    " while preparing re-configuration");
5214 		logerror("discarded %d messages and restart configuration.",
5215 		    drops);
5216 		if (Debug) {
5217 			tim = time(NULL);
5218 			DPRINT3(3, "reconfigure(%u): %.15s: "
5219 			    "discarded %d messages\n",
5220 			    mythreadno, ctime_r(&tim, cbuf)+4, drops);
5221 		}
5222 	}
5223 
5224 	/*
5225 	 * If all threads still haven't exited
5226 	 * something is stuck or hosed. We just
5227 	 * have no option but to exit.
5228 	 */
5229 	if (conf_threads) {
5230 thread_stuck:
5231 		if (Debug) {
5232 			tim = time(NULL);
5233 			DPRINT2(3, "reconfigure(%u): %.15s: really stuck\n",
5234 			    mythreadno, ctime_r(&tim, cbuf)+4);
5235 		}
5236 
5237 		shutdown_input();
5238 		delete_doorfiles();
5239 		(void) uname(&up);
5240 
5241 		(void) snprintf(buf, sizeof (buf),
5242 		    "syslogd(%s): some logger thread(s) "
5243 		    "are stuck%s; syslogd is shutting down.",
5244 		    up.nodename,
5245 		    console_stuck ? " (including the console)" : "");
5246 
5247 		if (console_stuck) {
5248 			FILE *m = popen(MAILCMD, "w");
5249 
5250 			if (m != NULL) {
5251 				(void) fprintf(m, "%s\n", buf);
5252 				(void) pclose(m);
5253 			}
5254 		}
5255 
5256 		disable_errorlog();
5257 		logerror(buf);
5258 		exit(1);
5259 	}
5260 
5261 	/* Free up some resources */
5262 	if (Files != (struct filed *)&fallback) {
5263 		for (f = Files; f < &Files[nlogs]; f++) {
5264 			(void) pthread_join(f->f_thread, NULL);
5265 			filed_destroy(f);
5266 		}
5267 		free(Files);
5268 	}
5269 
5270 	dealloc_stacks(nlogs);
5271 
5272 	if (Debug) {
5273 		tim = time(NULL);
5274 		DPRINT2(3, "reconfigure(%u): %.15s: cleanup complete\n",
5275 		    mythreadno, ctime_r(&tim, cbuf)+4);
5276 	}
5277 
5278 	hnc_init(1);	/* purge hostname cache */
5279 	conf_init();	/* start reconfigure */
5280 
5281 out:;
5282 	/* Now should be ready to dispatch error messages from syslogd. */
5283 	enable_errorlog();
5284 
5285 	/* Wake up the log thread */
5286 
5287 	if (Debug) {
5288 		tim = time(NULL);
5289 		DPRINT2(3, "reconfigure(%u): %.15s: resuming logmsg()\n",
5290 		    mythreadno, ctime_r(&tim, cbuf)+4);
5291 	}
5292 
5293 	(void) pthread_mutex_lock(&hup_lock);
5294 	hup_state = HUP_COMPLETED;
5295 	(void) pthread_cond_signal(&hup_done);
5296 	(void) pthread_mutex_unlock(&hup_lock);
5297 }
5298 
5299 /*
5300  * The following function implements simple hostname cache mechanism.
5301  * Host name cache is implemented through hash table bucket chaining method.
5302  * Collisions are handled by bucket chaining.
5303  *
5304  * hnc_init():
5305  * 	allocate and initialize the cache. If reinit is set,
5306  *	invalidate all cache entries.
5307  * hnc_look():
5308  *	It hashes the ipaddress gets the index and walks thru the
5309  *	single linked list. if cached entry was found, it will
5310  *	put in the head of the list, and return.While going through
5311  *	the entries, an entry which has already expired will be invalidated.
5312  * hnc_register():
5313  *	Hashes the ipaddress finds the index and puts current entry to the list.
5314  * hnc_unreg():
5315  *	invalidate the cachep.
5316  */
5317 
5318 static void
5319 hnc_init(int reinit)
5320 {
5321 	struct hostname_cache **hpp;
5322 	pthread_t mythreadno;
5323 	int i;
5324 
5325 	if (Debug) {
5326 		mythreadno = pthread_self();
5327 	}
5328 
5329 	if (reinit) {
5330 		(void) pthread_mutex_lock(&hnc_mutex);
5331 
5332 		for (i = 0; i < hnc_size; i++) {
5333 			for (hpp = &hnc_cache[i]; *hpp != NULL; ) {
5334 				hnc_unreg(hpp);
5335 			}
5336 		}
5337 
5338 		(void) pthread_mutex_unlock(&hnc_mutex);
5339 		DPRINT1(2, "hnc_init(%u): hostname cache re-configured\n",
5340 		    mythreadno);
5341 	} else {
5342 
5343 		hnc_cache = calloc(hnc_size, sizeof (struct hostname_cache *));
5344 
5345 		if (hnc_cache == NULL) {
5346 			MALLOC_FAIL("hostname cache");
5347 			logerror("hostname cache disabled");
5348 			return;
5349 		}
5350 
5351 		DPRINT3(1, "hnc_init(%u): hostname cache configured %d entry"
5352 		    " ttl:%d\n", mythreadno, hnc_size, hnc_ttl);
5353 	}
5354 }
5355 
5356 static host_list_t *
5357 hnc_lookup(struct netbuf *nbp, struct netconfig *ncp, int *hindex)
5358 {
5359 	struct hostname_cache **hpp, *hp;
5360 	time_t now;
5361 	pthread_t mythreadno;
5362 	int index;
5363 
5364 	if (Debug) {
5365 		mythreadno = pthread_self();
5366 	}
5367 
5368 	if (hnc_cache == NULL) {
5369 		return (NULL);
5370 	}
5371 
5372 	(void) pthread_mutex_lock(&hnc_mutex);
5373 	now = time(0);
5374 
5375 	*hindex = index = addr_hash(nbp);
5376 
5377 	for (hpp = &hnc_cache[index]; (hp = *hpp) != NULL; ) {
5378 		DPRINT4(10, "hnc_lookup(%u): check %p on %p for %s\n",
5379 		    mythreadno, (void *)hp->h, (void *)hp,
5380 		    hp->h->hl_hosts[0]);
5381 
5382 		if (hp->expire < now) {
5383 			DPRINT2(9, "hnc_lookup(%u): purge %p\n",
5384 			    mythreadno, (void *)hp);
5385 			hnc_unreg(hpp);
5386 			continue;
5387 		}
5388 
5389 		if (ncp == hp->ncp && same_addr(&hp->addr, nbp)) {
5390 			/*
5391 			 * found!
5392 			 * Put the entry at the top.
5393 			 */
5394 
5395 			if (hp != hnc_cache[index]) {
5396 				/* unlink from active list */
5397 				*hpp = (*hpp)->next;
5398 				/* push it onto the top */
5399 				hp->next = hnc_cache[index];
5400 				hnc_cache[index] = hp;
5401 			}
5402 
5403 			(void) pthread_mutex_lock(&hp->h->hl_mutex);
5404 			hp->h->hl_refcnt++;
5405 			(void) pthread_mutex_unlock(&hp->h->hl_mutex);
5406 
5407 			DPRINT4(9, "hnc_lookup(%u): found %p on %p for %s\n",
5408 			    mythreadno, (void *)hp->h, (void *)hp,
5409 			    hp->h->hl_hosts[0]);
5410 
5411 			(void) pthread_mutex_unlock(&hnc_mutex);
5412 			return (hp->h);
5413 		}
5414 
5415 		hpp = &hp->next;
5416 	}
5417 
5418 	(void) pthread_mutex_unlock(&hnc_mutex);
5419 	return (NULL);
5420 }
5421 
5422 static void
5423 hnc_register(struct netbuf *nbp, struct netconfig *ncp,
5424 		    host_list_t *h, int hindex)
5425 {
5426 	struct hostname_cache **hpp, **tailp, *hp, *entry;
5427 	void *addrbuf;
5428 	time_t now;
5429 	pthread_t mythreadno;
5430 	int i;
5431 
5432 	if (Debug) {
5433 		mythreadno = pthread_self();
5434 	}
5435 
5436 	if (hnc_cache == NULL) {
5437 		return;
5438 	}
5439 
5440 	if ((addrbuf = malloc(nbp->len)) == NULL) {
5441 		MALLOC_FAIL("pushing hostname cache");
5442 		return;
5443 	}
5444 
5445 	if ((entry = malloc(sizeof (struct hostname_cache))) == NULL) {
5446 		MALLOC_FAIL("pushing hostname entry");
5447 		free(addrbuf);
5448 		return;
5449 	}
5450 
5451 	(void) pthread_mutex_lock(&hnc_mutex);
5452 
5453 	i = 0;
5454 
5455 	now = time(0);
5456 	/*
5457 	 * first go through active list, and discard the
5458 	 * caches which has been invalid. Count number of
5459 	 * non-expired buckets.
5460 	 */
5461 
5462 	for (hpp = &hnc_cache[hindex]; (hp = *hpp) != NULL; ) {
5463 		tailp = hpp;
5464 
5465 		if (hp->expire < now) {
5466 			DPRINT2(9, "hnc_register(%u): discard %p\n",
5467 			    mythreadno, (void *)hp);
5468 			hnc_unreg(hpp);
5469 		} else {
5470 			i++;
5471 			hpp = &hp->next;
5472 		}
5473 	}
5474 
5475 	/*
5476 	 * If max limit of chained hash buckets has been used up
5477 	 * delete the least active element in the chain.
5478 	 */
5479 	if (i == MAX_BUCKETS) {
5480 		hnc_unreg(tailp);
5481 	}
5482 
5483 	(void) memcpy(addrbuf, nbp->buf, nbp->len);
5484 	entry->addr.len = nbp->len;
5485 	entry->addr.buf = addrbuf;
5486 	entry->ncp = ncp;
5487 	entry->h = h;
5488 	entry->expire = time(NULL) + hnc_ttl;
5489 
5490 	/* insert it at the top */
5491 	entry->next = hnc_cache[hindex];
5492 	hnc_cache[hindex] = entry;
5493 
5494 	/*
5495 	 * As far as cache is valid, corresponding host_list must
5496 	 * also be valid. Increments the refcnt to avoid freeing
5497 	 * host_list.
5498 	 */
5499 	h->hl_refcnt++;
5500 	DPRINT4(9, "hnc_register(%u): reg %p onto %p for %s\n",
5501 	    mythreadno, (void *)entry->h, (void *)entry, entry->h->hl_hosts[0]);
5502 	(void) pthread_mutex_unlock(&hnc_mutex);
5503 }
5504 
5505 static void
5506 hnc_unreg(struct hostname_cache **hpp)
5507 {
5508 	struct hostname_cache *hp = *hpp;
5509 	pthread_t mythreadno;
5510 
5511 	if (Debug) {
5512 		mythreadno = pthread_self();
5513 	}
5514 
5515 	DPRINT4(9, "hnc_unreg(%u): unreg %p on %p for %s\n",
5516 	    mythreadno, (void *)hp->h, (void *)hp, hp->h->hl_hosts[0]);
5517 	free(hp->addr.buf);
5518 	freehl(hp->h);
5519 
5520 	/* unlink from active list */
5521 	*hpp = (*hpp)->next;
5522 
5523 	free(hp);
5524 }
5525 
5526 /*
5527  * Once this is called, error messages through logerror() will go to
5528  * the console immediately. Also, messages are queued into the tmpq
5529  * to be able to later put them into inputq.
5530  */
5531 static void
5532 disable_errorlog()
5533 {
5534 	(void) dataq_init(&tmpq);
5535 
5536 	(void) pthread_mutex_lock(&logerror_lock);
5537 	interrorlog = 0;
5538 	(void) pthread_mutex_unlock(&logerror_lock);
5539 }
5540 
5541 /*
5542  * Turn internal error messages to regular input stream.
5543  * All pending messages are pulled and pushed into the regular
5544  * input queue.
5545  */
5546 static void
5547 enable_errorlog()
5548 {
5549 	log_message_t *mp;
5550 
5551 	(void) pthread_mutex_lock(&logerror_lock);
5552 	interrorlog = 1;
5553 	(void) pthread_mutex_unlock(&logerror_lock);
5554 
5555 	/*
5556 	 * push all the pending messages into inputq.
5557 	 */
5558 	while (dataq_dequeue(&tmpq, (void **)&mp, 1) == 0) {
5559 		(void) dataq_enqueue(&inputq, mp);
5560 	}
5561 	(void) dataq_destroy(&tmpq);
5562 }
5563 
5564 /*
5565  * Generate a hash value of the given address and derive
5566  * an index into the hnc_cache hashtable.
5567  * The hashing method is similar to what Java does for strings.
5568  */
5569 static int
5570 addr_hash(struct netbuf *nbp)
5571 {
5572 	char *uap;
5573 	int i;
5574 	unsigned long hcode = 0;
5575 
5576 	uap = nbp->buf;
5577 
5578 	if (uap == NULL) {
5579 		return (0);
5580 	}
5581 
5582 	/*
5583 	 * Compute a hashcode of the address string
5584 	 */
5585 	for (i = 0; i < nbp->len; i++)
5586 		hcode = (31 * hcode) + uap[i];
5587 
5588 	/*
5589 	 * Scramble the hashcode for better distribution
5590 	 */
5591 	hcode += ~(hcode << 9);
5592 	hcode ^=  (hcode >> 14);
5593 	hcode +=  (hcode << 4);
5594 	hcode ^=  (hcode >> 10);
5595 
5596 	return ((int)(hcode % hnc_size));
5597 }
5598