xref: /titanic_50/usr/src/cmd/syslogd/syslogd.c (revision 004388ebfdfe2ed7dfd2d153a876dfcc22d2c006)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5*004388ebScasper  * Common Development and Distribution License (the "License").
6*004388ebScasper  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
22*004388ebScasper  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate /*
277c478bd9Sstevel@tonic-gate  *	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T
287c478bd9Sstevel@tonic-gate  *	All Rights Reserved
297c478bd9Sstevel@tonic-gate  */
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate /*
327c478bd9Sstevel@tonic-gate  * University Copyright- Copyright (c) 1982, 1986, 1988
337c478bd9Sstevel@tonic-gate  * The Regents of the University of California
347c478bd9Sstevel@tonic-gate  * All Rights Reserved
357c478bd9Sstevel@tonic-gate  *
367c478bd9Sstevel@tonic-gate  * University Acknowledgment- Portions of this document are derived from
377c478bd9Sstevel@tonic-gate  * software developed by the University of California, Berkeley, and its
387c478bd9Sstevel@tonic-gate  * contributors.
397c478bd9Sstevel@tonic-gate  */
407c478bd9Sstevel@tonic-gate 
417c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
427c478bd9Sstevel@tonic-gate 
437c478bd9Sstevel@tonic-gate /*
447c478bd9Sstevel@tonic-gate  *  syslogd -- log system messages
457c478bd9Sstevel@tonic-gate  *
467c478bd9Sstevel@tonic-gate  * This program implements a system log. It takes a series of lines.
477c478bd9Sstevel@tonic-gate  * Each line may have a priority, signified as "<n>" as
487c478bd9Sstevel@tonic-gate  * the first characters of the line.  If this is
497c478bd9Sstevel@tonic-gate  * not present, a default priority is used.
507c478bd9Sstevel@tonic-gate  *
517c478bd9Sstevel@tonic-gate  * To kill syslogd, send a signal 15 (terminate).  A signal 1 (hup) will
527c478bd9Sstevel@tonic-gate  * cause it to reconfigure.
537c478bd9Sstevel@tonic-gate  *
547c478bd9Sstevel@tonic-gate  * Defined Constants:
557c478bd9Sstevel@tonic-gate  *
567c478bd9Sstevel@tonic-gate  * MAXLINE -- the maximimum line length that can be handled.
577c478bd9Sstevel@tonic-gate  * DEFUPRI -- the default priority for user messages.
587c478bd9Sstevel@tonic-gate  * DEFSPRI -- the default priority for kernel messages.
597c478bd9Sstevel@tonic-gate  *
607c478bd9Sstevel@tonic-gate  */
617c478bd9Sstevel@tonic-gate 
627c478bd9Sstevel@tonic-gate #include <unistd.h>
637c478bd9Sstevel@tonic-gate #include <note.h>
647c478bd9Sstevel@tonic-gate #include <errno.h>
657c478bd9Sstevel@tonic-gate #include <sys/types.h>
667c478bd9Sstevel@tonic-gate #include <stdio.h>
67*004388ebScasper #include <stdio_ext.h>
687c478bd9Sstevel@tonic-gate #include <stdlib.h>
697c478bd9Sstevel@tonic-gate #include <ctype.h>
707c478bd9Sstevel@tonic-gate #include <signal.h>
717c478bd9Sstevel@tonic-gate #include <string.h>
727c478bd9Sstevel@tonic-gate #include <strings.h>
737c478bd9Sstevel@tonic-gate #include <deflt.h>
747c478bd9Sstevel@tonic-gate #include <netconfig.h>
757c478bd9Sstevel@tonic-gate #include <netdir.h>
767c478bd9Sstevel@tonic-gate #include <pwd.h>
777c478bd9Sstevel@tonic-gate #include <sys/socket.h>
787c478bd9Sstevel@tonic-gate #include <tiuser.h>
797c478bd9Sstevel@tonic-gate #include <utmpx.h>
807c478bd9Sstevel@tonic-gate #include <limits.h>
817c478bd9Sstevel@tonic-gate #include <pthread.h>
827c478bd9Sstevel@tonic-gate #include <fcntl.h>
837c478bd9Sstevel@tonic-gate #include <stropts.h>
847c478bd9Sstevel@tonic-gate #include <assert.h>
857c478bd9Sstevel@tonic-gate #include <sys/statvfs.h>
867c478bd9Sstevel@tonic-gate 
877c478bd9Sstevel@tonic-gate #include <sys/param.h>
887c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
897c478bd9Sstevel@tonic-gate #include <sys/syslog.h>
907c478bd9Sstevel@tonic-gate #include <sys/strlog.h>
917c478bd9Sstevel@tonic-gate #include <sys/stat.h>
927c478bd9Sstevel@tonic-gate #include <sys/time.h>
937c478bd9Sstevel@tonic-gate #include <sys/utsname.h>
947c478bd9Sstevel@tonic-gate #include <sys/poll.h>
957c478bd9Sstevel@tonic-gate #include <sys/wait.h>
967c478bd9Sstevel@tonic-gate #include <sys/resource.h>
977c478bd9Sstevel@tonic-gate #include <sys/mman.h>
987c478bd9Sstevel@tonic-gate #include <sys/note.h>
997c478bd9Sstevel@tonic-gate #include <door.h>
1007c478bd9Sstevel@tonic-gate 
1017c478bd9Sstevel@tonic-gate #include <wchar.h>
1027c478bd9Sstevel@tonic-gate #include <locale.h>
1037c478bd9Sstevel@tonic-gate #include <stdarg.h>
1047c478bd9Sstevel@tonic-gate 
1057c478bd9Sstevel@tonic-gate #include "dataq.h"
1067c478bd9Sstevel@tonic-gate #include "conf.h"
1077c478bd9Sstevel@tonic-gate #include "syslogd.h"
1087c478bd9Sstevel@tonic-gate 
1097c478bd9Sstevel@tonic-gate #define	DOORFILE		"/var/run/syslog_door"
1107c478bd9Sstevel@tonic-gate #define	RELATIVE_DOORFILE	"../var/run/syslog_door"
1117c478bd9Sstevel@tonic-gate #define	OLD_DOORFILE		"/etc/.syslog_door"
1127c478bd9Sstevel@tonic-gate 
1137c478bd9Sstevel@tonic-gate #define	PIDFILE			"/var/run/syslog.pid"
1147c478bd9Sstevel@tonic-gate #define	RELATIVE_PIDFILE	"../var/run/syslog.pid"
1157c478bd9Sstevel@tonic-gate #define	OLD_PIDFILE		"/etc/syslog.pid"
1167c478bd9Sstevel@tonic-gate 
1177c478bd9Sstevel@tonic-gate static char		*Version = "%I%";
1187c478bd9Sstevel@tonic-gate static char		*LogName = "/dev/log";
1197c478bd9Sstevel@tonic-gate static char		*ConfFile = "/etc/syslog.conf";
1207c478bd9Sstevel@tonic-gate static char		*DflFile = "/etc/default/syslogd";
1217c478bd9Sstevel@tonic-gate static char		ctty[] = "/dev/console";
1227c478bd9Sstevel@tonic-gate static char		sysmsg[] = "/dev/sysmsg";
1237c478bd9Sstevel@tonic-gate static int		DoorFd = -1;
1247c478bd9Sstevel@tonic-gate static int		DoorCreated = 0;
1257c478bd9Sstevel@tonic-gate static int		PidfileCreated = 0;
1267c478bd9Sstevel@tonic-gate static char		*DoorFileName = DOORFILE;
1277c478bd9Sstevel@tonic-gate static char		*PidFileName = PIDFILE;
1287c478bd9Sstevel@tonic-gate 
1297c478bd9Sstevel@tonic-gate /*
1307c478bd9Sstevel@tonic-gate  * configuration file directives
1317c478bd9Sstevel@tonic-gate  */
1327c478bd9Sstevel@tonic-gate 
1337c478bd9Sstevel@tonic-gate static struct code	PriNames[] = {
1347c478bd9Sstevel@tonic-gate 	"panic",	LOG_EMERG,
1357c478bd9Sstevel@tonic-gate 	"emerg",	LOG_EMERG,
1367c478bd9Sstevel@tonic-gate 	"alert",	LOG_ALERT,
1377c478bd9Sstevel@tonic-gate 	"crit",		LOG_CRIT,
1387c478bd9Sstevel@tonic-gate 	"err",		LOG_ERR,
1397c478bd9Sstevel@tonic-gate 	"error",	LOG_ERR,
1407c478bd9Sstevel@tonic-gate 	"warn",		LOG_WARNING,
1417c478bd9Sstevel@tonic-gate 	"warning",	LOG_WARNING,
1427c478bd9Sstevel@tonic-gate 	"notice",	LOG_NOTICE,
1437c478bd9Sstevel@tonic-gate 	"info",		LOG_INFO,
1447c478bd9Sstevel@tonic-gate 	"debug",	LOG_DEBUG,
1457c478bd9Sstevel@tonic-gate 	"none",		NOPRI,
1467c478bd9Sstevel@tonic-gate 	NULL,		-1
1477c478bd9Sstevel@tonic-gate };
1487c478bd9Sstevel@tonic-gate 
1497c478bd9Sstevel@tonic-gate static struct code	FacNames[] = {
1507c478bd9Sstevel@tonic-gate 	"kern",		LOG_KERN,
1517c478bd9Sstevel@tonic-gate 	"user",		LOG_USER,
1527c478bd9Sstevel@tonic-gate 	"mail",		LOG_MAIL,
1537c478bd9Sstevel@tonic-gate 	"daemon",	LOG_DAEMON,
1547c478bd9Sstevel@tonic-gate 	"auth",		LOG_AUTH,
1557c478bd9Sstevel@tonic-gate 	"security",	LOG_AUTH,
1567c478bd9Sstevel@tonic-gate 	"mark",		LOG_MARK,
1577c478bd9Sstevel@tonic-gate 	"syslog",	LOG_SYSLOG,
1587c478bd9Sstevel@tonic-gate 	"lpr",		LOG_LPR,
1597c478bd9Sstevel@tonic-gate 	"news",		LOG_NEWS,
1607c478bd9Sstevel@tonic-gate 	"uucp",		LOG_UUCP,
1617c478bd9Sstevel@tonic-gate 	"audit",	LOG_AUDIT,
1627c478bd9Sstevel@tonic-gate 	"cron",		LOG_CRON,
1637c478bd9Sstevel@tonic-gate 	"local0",	LOG_LOCAL0,
1647c478bd9Sstevel@tonic-gate 	"local1",	LOG_LOCAL1,
1657c478bd9Sstevel@tonic-gate 	"local2",	LOG_LOCAL2,
1667c478bd9Sstevel@tonic-gate 	"local3",	LOG_LOCAL3,
1677c478bd9Sstevel@tonic-gate 	"local4",	LOG_LOCAL4,
1687c478bd9Sstevel@tonic-gate 	"local5",	LOG_LOCAL5,
1697c478bd9Sstevel@tonic-gate 	"local6",	LOG_LOCAL6,
1707c478bd9Sstevel@tonic-gate 	"local7",	LOG_LOCAL7,
1717c478bd9Sstevel@tonic-gate 	NULL,		-1
1727c478bd9Sstevel@tonic-gate };
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate static char		*TypeNames[7] = {
1757c478bd9Sstevel@tonic-gate 	"UNUSED",	"FILE",		"TTY",		"CONSOLE",
1767c478bd9Sstevel@tonic-gate 	"FORW",		"USERS",	"WALL"
1777c478bd9Sstevel@tonic-gate };
1787c478bd9Sstevel@tonic-gate 
1797c478bd9Sstevel@tonic-gate /*
1807c478bd9Sstevel@tonic-gate  * we allocate our own thread stacks so we can create them
1817c478bd9Sstevel@tonic-gate  * without the MAP_NORESERVE option. We need to be sure
1827c478bd9Sstevel@tonic-gate  * we have stack space even if the machine runs out of swap
1837c478bd9Sstevel@tonic-gate  */
1847c478bd9Sstevel@tonic-gate 
1857c478bd9Sstevel@tonic-gate #define	DEFAULT_STACKSIZE (100 * 1024)  /* 100 k stack */
1867c478bd9Sstevel@tonic-gate #define	DEFAULT_REDZONESIZE (8 * 1024)	/* 8k redzone */
1877c478bd9Sstevel@tonic-gate 
1887c478bd9Sstevel@tonic-gate static pthread_mutex_t wmp = PTHREAD_MUTEX_INITIALIZER;	/* wallmsg lock */
1897c478bd9Sstevel@tonic-gate 
1907c478bd9Sstevel@tonic-gate static pthread_mutex_t cft = PTHREAD_MUTEX_INITIALIZER;
1917c478bd9Sstevel@tonic-gate static int conf_threads = 0;
1927c478bd9Sstevel@tonic-gate 
1937c478bd9Sstevel@tonic-gate static pthread_mutex_t hup_lock = PTHREAD_MUTEX_INITIALIZER;
1947c478bd9Sstevel@tonic-gate static pthread_cond_t hup_done = PTHREAD_COND_INITIALIZER;
1957c478bd9Sstevel@tonic-gate 
1967c478bd9Sstevel@tonic-gate static pthread_mutex_t logerror_lock = PTHREAD_MUTEX_INITIALIZER;
1977c478bd9Sstevel@tonic-gate 
1987c478bd9Sstevel@tonic-gate #define	HUP_ACCEPTABLE		0x0000	/* can start SIGHUP process */
1997c478bd9Sstevel@tonic-gate #define	HUP_INPROGRESS		0x0001	/* SIGHUP process in progress */
2007c478bd9Sstevel@tonic-gate #define	HUP_COMPLETED		0x0002	/* SIGHUP process completed */
2017c478bd9Sstevel@tonic-gate #define	HUP_SUSP_LOGMSG_REQD	0x1000	/* request to suspend */
2027c478bd9Sstevel@tonic-gate #define	HUP_LOGMSG_SUSPENDED	0x2000	/* logmsg is suspended */
2037c478bd9Sstevel@tonic-gate static int hup_state = HUP_ACCEPTABLE;
2047c478bd9Sstevel@tonic-gate 
2057c478bd9Sstevel@tonic-gate static size_t stacksize;		/* thread stack size */
2067c478bd9Sstevel@tonic-gate static size_t redzonesize;		/* thread stack redzone size */
2077c478bd9Sstevel@tonic-gate static char *stack_ptr;			/* ptr to allocated stacks */
2087c478bd9Sstevel@tonic-gate static char *cstack_ptr;		/* ptr to conf_thr stacks */
2097c478bd9Sstevel@tonic-gate 
2107c478bd9Sstevel@tonic-gate static time_t start_time;
2117c478bd9Sstevel@tonic-gate 
2127c478bd9Sstevel@tonic-gate static pthread_t sys_thread;		/* queues messages from us */
2137c478bd9Sstevel@tonic-gate static pthread_t net_thread;		/* queues messages from the net */
2147c478bd9Sstevel@tonic-gate static pthread_t log_thread;		/* message processing thread */
2157c478bd9Sstevel@tonic-gate static pthread_t hnl_thread;		/* hostname lookup thread */
2167c478bd9Sstevel@tonic-gate 
2177c478bd9Sstevel@tonic-gate static dataq_t inputq;			/* the input queue */
2187c478bd9Sstevel@tonic-gate static dataq_t tmpq;			/* temporary queue for err msg */
2197c478bd9Sstevel@tonic-gate static dataq_t hnlq;			/* hostname lookup queue */
2207c478bd9Sstevel@tonic-gate 
2217c478bd9Sstevel@tonic-gate static struct filed fallback[2];
2227c478bd9Sstevel@tonic-gate static struct filed *Files;
2237c478bd9Sstevel@tonic-gate static int nlogs;
2247c478bd9Sstevel@tonic-gate static int Debug;			/* debug flag */
2257c478bd9Sstevel@tonic-gate static host_list_t LocalHostName;	/* our hostname */
2267c478bd9Sstevel@tonic-gate static host_list_t NullHostName;	/* in case of lookup failure */
2277c478bd9Sstevel@tonic-gate static int debuglev = 1;		/* debug print level */
2287c478bd9Sstevel@tonic-gate static int interrorlog;			/* internal error logging */
2297c478bd9Sstevel@tonic-gate 
2307c478bd9Sstevel@tonic-gate static int MarkInterval = 20;		/* interval between marks (mins) */
2317c478bd9Sstevel@tonic-gate static int Marking = 0;			/* non-zero if marking some file */
2327c478bd9Sstevel@tonic-gate static int Ninputs = 0;			/* number of network inputs */
2337c478bd9Sstevel@tonic-gate static int curalarm = 0;		/* current timeout value (secs) */
2347c478bd9Sstevel@tonic-gate static int sys_msg_count = 0;		/* total msgs rcvd from local log */
2357c478bd9Sstevel@tonic-gate static int sys_init_msg_count = 0;	/* initially received */
2367c478bd9Sstevel@tonic-gate static int net_msg_count = 0;		/* total msgs rcvd from net */
2377c478bd9Sstevel@tonic-gate 
2387c478bd9Sstevel@tonic-gate static struct pollfd Pfd;		/* Pollfd for local the log device */
2397c478bd9Sstevel@tonic-gate static struct pollfd *Nfd;		/* Array of pollfds for udp ports */
2407c478bd9Sstevel@tonic-gate static struct netconfig *Ncf;
2417c478bd9Sstevel@tonic-gate static struct netbuf **Myaddrs;
2427c478bd9Sstevel@tonic-gate static struct t_unitdata **Udp;
2437c478bd9Sstevel@tonic-gate static struct t_uderr **Errp;
2447c478bd9Sstevel@tonic-gate static int turnoff = 0;
2457c478bd9Sstevel@tonic-gate static int shutting_down;
2467c478bd9Sstevel@tonic-gate 
247293d1fc4Spd155743 static struct hostname_cache **hnc_cache;
2487c478bd9Sstevel@tonic-gate static pthread_mutex_t hnc_mutex = PTHREAD_MUTEX_INITIALIZER;
2497c478bd9Sstevel@tonic-gate static size_t hnc_size = DEF_HNC_SIZE;
2507c478bd9Sstevel@tonic-gate static unsigned int hnc_ttl = DEF_HNC_TTL;
2517c478bd9Sstevel@tonic-gate 
2527c478bd9Sstevel@tonic-gate #define	DPRINT0(d, m)		if ((Debug) && debuglev >= (d)) \
2537c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr, m)
2547c478bd9Sstevel@tonic-gate #define	DPRINT1(d, m, a)	if ((Debug) && debuglev >= (d)) \
2557c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr, m, a)
2567c478bd9Sstevel@tonic-gate #define	DPRINT2(d, m, a, b)	if ((Debug) && debuglev >= (d)) \
2577c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr, m, a, b)
2587c478bd9Sstevel@tonic-gate #define	DPRINT3(d, m, a, b, c)	if ((Debug) && debuglev >= (d)) \
2597c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr, m, a, b, c)
2607c478bd9Sstevel@tonic-gate #define	DPRINT4(d, m, a, b, c, e)	if ((Debug) && debuglev >= (d)) \
2617c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr, m, a, b, c, e)
2627c478bd9Sstevel@tonic-gate #define	MALLOC_FAIL(x)	\
2637c478bd9Sstevel@tonic-gate 		logerror("malloc failed: " x)
2647c478bd9Sstevel@tonic-gate #define	MALLOC_FAIL_EXIT	\
2657c478bd9Sstevel@tonic-gate 		logerror("malloc failed - fatal"); \
2667c478bd9Sstevel@tonic-gate 		exit(1)
2677c478bd9Sstevel@tonic-gate 
2687c478bd9Sstevel@tonic-gate 
2697c478bd9Sstevel@tonic-gate #define	MAILCMD "mailx -s \"syslogd shut down\" root"
2707c478bd9Sstevel@tonic-gate 
2717c478bd9Sstevel@tonic-gate /*
2727c478bd9Sstevel@tonic-gate  * Number of seconds to wait before giving up on threads that won't
2737c478bd9Sstevel@tonic-gate  * shutdown: (that's right, 10 minutes!)
2747c478bd9Sstevel@tonic-gate  */
2757c478bd9Sstevel@tonic-gate #define	LOOP_MAX	(10 * 60)
2767c478bd9Sstevel@tonic-gate 
2777c478bd9Sstevel@tonic-gate /*
2787c478bd9Sstevel@tonic-gate  * Interval(sec) to check the status of output queue while processing
2797c478bd9Sstevel@tonic-gate  * HUP signal.
2807c478bd9Sstevel@tonic-gate  */
2817c478bd9Sstevel@tonic-gate #define	LOOP_INTERVAL	(15)
2827c478bd9Sstevel@tonic-gate 
2837c478bd9Sstevel@tonic-gate int
2847c478bd9Sstevel@tonic-gate main(int argc, char **argv)
2857c478bd9Sstevel@tonic-gate {
2867c478bd9Sstevel@tonic-gate 	int i;
2877c478bd9Sstevel@tonic-gate 	char *pstr;
2887c478bd9Sstevel@tonic-gate 	int sig, fd;
2897c478bd9Sstevel@tonic-gate 	int tflag = 0, Tflag = 0;
2907c478bd9Sstevel@tonic-gate 	sigset_t sigs, allsigs;
2917c478bd9Sstevel@tonic-gate 	struct rlimit rlim;
2927c478bd9Sstevel@tonic-gate 	char *debugstr;
2937c478bd9Sstevel@tonic-gate 	int mcount = 0;
2947c478bd9Sstevel@tonic-gate 	struct sigaction act;
2957c478bd9Sstevel@tonic-gate 	pthread_t mythreadno = 0;
2967c478bd9Sstevel@tonic-gate 	char cbuf [30];
2977c478bd9Sstevel@tonic-gate 	struct stat sb;
2987c478bd9Sstevel@tonic-gate 
2997c478bd9Sstevel@tonic-gate #ifdef DEBUG
3007c478bd9Sstevel@tonic-gate #define	DEBUGDIR "/var/tmp"
3017c478bd9Sstevel@tonic-gate 	if (chdir(DEBUGDIR))
3027c478bd9Sstevel@tonic-gate 		DPRINT2(1, "main(%u): Unable to cd to %s\n", mythreadno,
3037c478bd9Sstevel@tonic-gate 			DEBUGDIR);
3047c478bd9Sstevel@tonic-gate #endif /* DEBUG */
3057c478bd9Sstevel@tonic-gate 
3067c478bd9Sstevel@tonic-gate 	(void) setlocale(LC_ALL, "");
3077c478bd9Sstevel@tonic-gate 
3087c478bd9Sstevel@tonic-gate 	if ((debugstr = getenv("SYSLOGD_DEBUG")) != NULL)
3097c478bd9Sstevel@tonic-gate 		if ((debuglev = atoi(debugstr)) == 0)
3107c478bd9Sstevel@tonic-gate 			debuglev = 1;
3117c478bd9Sstevel@tonic-gate 
3127c478bd9Sstevel@tonic-gate #if ! defined(TEXT_DOMAIN)	/* should be defined by cc -D */
3137c478bd9Sstevel@tonic-gate #define	TEXT_DOMAIN "SYS_TEST"
3147c478bd9Sstevel@tonic-gate #endif
3157c478bd9Sstevel@tonic-gate 	(void) textdomain(TEXT_DOMAIN);
3167c478bd9Sstevel@tonic-gate 
3177c478bd9Sstevel@tonic-gate 	(void) time(&start_time);
3187c478bd9Sstevel@tonic-gate 
3197c478bd9Sstevel@tonic-gate 	if (lstat("/var/run", &sb) != 0 || !(S_ISDIR(sb.st_mode))) {
3207c478bd9Sstevel@tonic-gate 		DoorFileName = OLD_DOORFILE;
3217c478bd9Sstevel@tonic-gate 		PidFileName  = OLD_PIDFILE;
3227c478bd9Sstevel@tonic-gate 	}
3237c478bd9Sstevel@tonic-gate 
3247c478bd9Sstevel@tonic-gate 	defaults();
3257c478bd9Sstevel@tonic-gate 
3267c478bd9Sstevel@tonic-gate 	while ((i = getopt(argc, argv, "df:p:m:tT")) != EOF) {
3277c478bd9Sstevel@tonic-gate 		switch (i) {
3287c478bd9Sstevel@tonic-gate 		case 'f':		/* configuration file */
3297c478bd9Sstevel@tonic-gate 			ConfFile = optarg;
3307c478bd9Sstevel@tonic-gate 			break;
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate 		case 'd':		/* debug */
3337c478bd9Sstevel@tonic-gate 			Debug++;
3347c478bd9Sstevel@tonic-gate 			break;
3357c478bd9Sstevel@tonic-gate 
3367c478bd9Sstevel@tonic-gate 		case 'p':		/* path */
3377c478bd9Sstevel@tonic-gate 			LogName = optarg;
3387c478bd9Sstevel@tonic-gate 			break;
3397c478bd9Sstevel@tonic-gate 
3407c478bd9Sstevel@tonic-gate 		case 'm':		/* mark interval */
3417c478bd9Sstevel@tonic-gate 			for (pstr = optarg; *pstr; pstr++) {
3427c478bd9Sstevel@tonic-gate 				if (! (isdigit(*pstr))) {
3437c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
3447c478bd9Sstevel@tonic-gate 						"Illegal interval\n");
3457c478bd9Sstevel@tonic-gate 					usage();
3467c478bd9Sstevel@tonic-gate 				}
3477c478bd9Sstevel@tonic-gate 			}
3487c478bd9Sstevel@tonic-gate 			MarkInterval = atoi(optarg);
3497c478bd9Sstevel@tonic-gate 			if (MarkInterval < 1 || MarkInterval > INT_MAX) {
3507c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
3517c478bd9Sstevel@tonic-gate 					"Interval must be between 1 and %d\n",
3527c478bd9Sstevel@tonic-gate 					INT_MAX);
3537c478bd9Sstevel@tonic-gate 				usage();
3547c478bd9Sstevel@tonic-gate 			}
3557c478bd9Sstevel@tonic-gate 			break;
3567c478bd9Sstevel@tonic-gate 		case 't':		/* turn off remote reception */
3577c478bd9Sstevel@tonic-gate 			tflag++;
3587c478bd9Sstevel@tonic-gate 			turnoff++;
3597c478bd9Sstevel@tonic-gate 			break;
3607c478bd9Sstevel@tonic-gate 		case 'T':		/* turn on remote reception */
3617c478bd9Sstevel@tonic-gate 			Tflag++;
3627c478bd9Sstevel@tonic-gate 			turnoff = 0;
3637c478bd9Sstevel@tonic-gate 			break;
3647c478bd9Sstevel@tonic-gate 		default:
3657c478bd9Sstevel@tonic-gate 			usage();
3667c478bd9Sstevel@tonic-gate 		}
3677c478bd9Sstevel@tonic-gate 	}
3687c478bd9Sstevel@tonic-gate 
3697c478bd9Sstevel@tonic-gate 	if (optind < argc)
3707c478bd9Sstevel@tonic-gate 		usage();
3717c478bd9Sstevel@tonic-gate 
3727c478bd9Sstevel@tonic-gate 	if (tflag && Tflag) {
3737c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, "specify only one of -t and -T\n");
3747c478bd9Sstevel@tonic-gate 		usage();
3757c478bd9Sstevel@tonic-gate 	}
3767c478bd9Sstevel@tonic-gate 
3777c478bd9Sstevel@tonic-gate 	/*
3787c478bd9Sstevel@tonic-gate 	 * close all fd's except 0-2
3797c478bd9Sstevel@tonic-gate 	 */
3807c478bd9Sstevel@tonic-gate 
3817c478bd9Sstevel@tonic-gate 	closefrom(3);
3827c478bd9Sstevel@tonic-gate 
3837c478bd9Sstevel@tonic-gate 	if (!Debug) {
3847c478bd9Sstevel@tonic-gate 		if (fork())
3857c478bd9Sstevel@tonic-gate 			return (0);
3867c478bd9Sstevel@tonic-gate 		(void) close(0);
3877c478bd9Sstevel@tonic-gate 		(void) open("/", 0);
3887c478bd9Sstevel@tonic-gate 		(void) dup2(0, 1);
3897c478bd9Sstevel@tonic-gate 		(void) dup2(0, 2);
3907c478bd9Sstevel@tonic-gate 		untty();
3917c478bd9Sstevel@tonic-gate 	}
3927c478bd9Sstevel@tonic-gate 
3937c478bd9Sstevel@tonic-gate 	if (Debug) {
3947c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
3957c478bd9Sstevel@tonic-gate 	}
3967c478bd9Sstevel@tonic-gate 
3977c478bd9Sstevel@tonic-gate 	/*
3987c478bd9Sstevel@tonic-gate 	 * DO NOT call logerror() until tmpq is initialized.
3997c478bd9Sstevel@tonic-gate 	 */
4007c478bd9Sstevel@tonic-gate 	disable_errorlog();
4017c478bd9Sstevel@tonic-gate 
4027c478bd9Sstevel@tonic-gate 	/*
4037c478bd9Sstevel@tonic-gate 	 * ensure that file descriptor limit is "high enough"
4047c478bd9Sstevel@tonic-gate 	 */
4057c478bd9Sstevel@tonic-gate 	(void) getrlimit(RLIMIT_NOFILE, &rlim);
4067c478bd9Sstevel@tonic-gate 	if (rlim.rlim_cur < rlim.rlim_max)
4077c478bd9Sstevel@tonic-gate 		rlim.rlim_cur = rlim.rlim_max;
4087c478bd9Sstevel@tonic-gate 	if (setrlimit(RLIMIT_NOFILE, &rlim) < 0)
4097c478bd9Sstevel@tonic-gate 		logerror("Unable to increase file descriptor limit.");
410*004388ebScasper 	(void) enable_extended_FILE_stdio(-1, -1);
4117c478bd9Sstevel@tonic-gate 
4127c478bd9Sstevel@tonic-gate 	/* block all signals from all threads initially */
4137c478bd9Sstevel@tonic-gate 	(void) sigfillset(&allsigs);
4147c478bd9Sstevel@tonic-gate 	(void) pthread_sigmask(SIG_BLOCK, &allsigs, NULL);
4157c478bd9Sstevel@tonic-gate 
4167c478bd9Sstevel@tonic-gate 	DPRINT2(1, "main(%u): Started at time %s", mythreadno,
4177c478bd9Sstevel@tonic-gate 		ctime_r(&start_time, cbuf));
4187c478bd9Sstevel@tonic-gate 
4197c478bd9Sstevel@tonic-gate 	init();			/* read configuration, start threads */
4207c478bd9Sstevel@tonic-gate 
4217c478bd9Sstevel@tonic-gate 	DPRINT1(1, "main(%u): off & running....\n", mythreadno);
4227c478bd9Sstevel@tonic-gate 
4237c478bd9Sstevel@tonic-gate 	/* now set up to catch signals we care about */
4247c478bd9Sstevel@tonic-gate 
4257c478bd9Sstevel@tonic-gate 	(void) sigemptyset(&sigs);
4267c478bd9Sstevel@tonic-gate 	(void) sigaddset(&sigs, SIGHUP);	/* reconfigure */
4277c478bd9Sstevel@tonic-gate 	(void) sigaddset(&sigs, SIGALRM);	/* mark & flush timer */
4287c478bd9Sstevel@tonic-gate 	(void) sigaddset(&sigs, SIGTERM);	/* exit */
4297c478bd9Sstevel@tonic-gate 	(void) sigaddset(&sigs, SIGINT);	/* exit if debugging */
4307c478bd9Sstevel@tonic-gate 	(void) sigaddset(&sigs, SIGQUIT);	/* exit if debugging */
4317c478bd9Sstevel@tonic-gate 	(void) sigaddset(&sigs, SIGPIPE);	/* catch & discard */
4327c478bd9Sstevel@tonic-gate 	(void) sigaddset(&sigs, SIGUSR1);	/* dump debug stats */
4337c478bd9Sstevel@tonic-gate 
4347c478bd9Sstevel@tonic-gate 	/*
4357c478bd9Sstevel@tonic-gate 	 * We must set up to catch these signals, even though sigwait
4367c478bd9Sstevel@tonic-gate 	 * will get them before the isr does.  Setting SA_SIGINFO ensures
4377c478bd9Sstevel@tonic-gate 	 * that signals will be enqueued.
4387c478bd9Sstevel@tonic-gate 	 */
4397c478bd9Sstevel@tonic-gate 
4407c478bd9Sstevel@tonic-gate 	act.sa_flags = SA_SIGINFO;
4417c478bd9Sstevel@tonic-gate 	act.sa_sigaction = signull;
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate 	(void) sigaction(SIGHUP, &act, NULL);
4447c478bd9Sstevel@tonic-gate 	(void) sigaction(SIGALRM, &act, NULL);
4457c478bd9Sstevel@tonic-gate 	(void) sigaction(SIGTERM, &act, NULL);
4467c478bd9Sstevel@tonic-gate 	(void) sigaction(SIGINT, &act, NULL);
4477c478bd9Sstevel@tonic-gate 	(void) sigaction(SIGQUIT, &act, NULL);
4487c478bd9Sstevel@tonic-gate 	(void) sigaction(SIGPIPE, &act, NULL);
4497c478bd9Sstevel@tonic-gate 	(void) sigaction(SIGUSR1, &act, NULL);
4507c478bd9Sstevel@tonic-gate 
4517c478bd9Sstevel@tonic-gate 	/* we now turn into the signal handling thread */
4527c478bd9Sstevel@tonic-gate 
4537c478bd9Sstevel@tonic-gate 	DPRINT1(2, "main(%u): now handling signals\n", mythreadno);
4547c478bd9Sstevel@tonic-gate 	for (;;) {
4557c478bd9Sstevel@tonic-gate 		(void) sigwait(&sigs, &sig);
4567c478bd9Sstevel@tonic-gate 		DPRINT2(2, "main(%u): received signal %d\n", mythreadno, sig);
4577c478bd9Sstevel@tonic-gate 		switch (sig) {
4587c478bd9Sstevel@tonic-gate 		case SIGALRM:
4597c478bd9Sstevel@tonic-gate 			DPRINT1(1, "main(%u): Got SIGALRM\n",
4607c478bd9Sstevel@tonic-gate 				mythreadno);
4617c478bd9Sstevel@tonic-gate 			flushmsg(NOCOPY);
4627c478bd9Sstevel@tonic-gate 			if (Marking && (++mcount % MARKCOUNT == 0)) {
4637c478bd9Sstevel@tonic-gate 				if (logmymsg(LOG_INFO, "-- MARK --",
4647c478bd9Sstevel@tonic-gate 					ADDDATE|MARK|NOCOPY, 0) == -1) {
4657c478bd9Sstevel@tonic-gate 					MALLOC_FAIL(
4667c478bd9Sstevel@tonic-gate 						"dropping MARK message");
4677c478bd9Sstevel@tonic-gate 				}
4687c478bd9Sstevel@tonic-gate 
4697c478bd9Sstevel@tonic-gate 				mcount = 0;
4707c478bd9Sstevel@tonic-gate 			}
4717c478bd9Sstevel@tonic-gate 			curalarm = MarkInterval * 60 / MARKCOUNT;
4727c478bd9Sstevel@tonic-gate 			(void) alarm((unsigned)curalarm);
4737c478bd9Sstevel@tonic-gate 			DPRINT2(2, "main(%u): Next alarm in %d "
4747c478bd9Sstevel@tonic-gate 				"seconds\n", mythreadno, curalarm);
4757c478bd9Sstevel@tonic-gate 			break;
4767c478bd9Sstevel@tonic-gate 		case SIGHUP:
4777c478bd9Sstevel@tonic-gate 			DPRINT1(1, "main(%u): got SIGHUP - "
4787c478bd9Sstevel@tonic-gate 				"reconfiguring\n", mythreadno);
4797c478bd9Sstevel@tonic-gate 
4807c478bd9Sstevel@tonic-gate 			reconfigure();
4817c478bd9Sstevel@tonic-gate 
4827c478bd9Sstevel@tonic-gate 			DPRINT1(1, "main(%u): done processing SIGHUP\n",
4837c478bd9Sstevel@tonic-gate 				mythreadno);
4847c478bd9Sstevel@tonic-gate 			break;
4857c478bd9Sstevel@tonic-gate 		case SIGQUIT:
4867c478bd9Sstevel@tonic-gate 		case SIGINT:
4877c478bd9Sstevel@tonic-gate 			if (!Debug) {
4887c478bd9Sstevel@tonic-gate 				/* allow these signals if debugging */
4897c478bd9Sstevel@tonic-gate 				break;
4907c478bd9Sstevel@tonic-gate 			}
4917c478bd9Sstevel@tonic-gate 			/* FALLTHROUGH */
4927c478bd9Sstevel@tonic-gate 		case SIGTERM:
4937c478bd9Sstevel@tonic-gate 			DPRINT2(1, "main(%u): going down on signal %d\n",
4947c478bd9Sstevel@tonic-gate 				mythreadno, sig);
4957c478bd9Sstevel@tonic-gate 			(void) alarm(0);
4967c478bd9Sstevel@tonic-gate 			flushmsg(0);
4977c478bd9Sstevel@tonic-gate 			errno = 0;
4987c478bd9Sstevel@tonic-gate 			t_errno = 0;
4997c478bd9Sstevel@tonic-gate 			logerror("going down on signal %d", sig);
5007c478bd9Sstevel@tonic-gate 			disable_errorlog();	/* force msg to console */
5017c478bd9Sstevel@tonic-gate 			(void) shutdown_msg();	/* stop threads */
5027c478bd9Sstevel@tonic-gate 			shutdown_input();
5037c478bd9Sstevel@tonic-gate 			close_door();
5047c478bd9Sstevel@tonic-gate 			delete_doorfiles();
5057c478bd9Sstevel@tonic-gate 			return (0);
5067c478bd9Sstevel@tonic-gate 			break;
5077c478bd9Sstevel@tonic-gate 		case SIGUSR1:			/* secret debug dump mode */
5087c478bd9Sstevel@tonic-gate 			/* if in debug mode, use stdout */
5097c478bd9Sstevel@tonic-gate 
5107c478bd9Sstevel@tonic-gate 			if (Debug) {
5117c478bd9Sstevel@tonic-gate 				dumpstats(STDOUT_FILENO);
5127c478bd9Sstevel@tonic-gate 				break;
5137c478bd9Sstevel@tonic-gate 			}
5147c478bd9Sstevel@tonic-gate 			/* otherwise dump to a debug file */
5157c478bd9Sstevel@tonic-gate 			if ((fd = open(DEBUGFILE,
5167c478bd9Sstevel@tonic-gate 				(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL),
5177c478bd9Sstevel@tonic-gate 					0644)) < 0)
5187c478bd9Sstevel@tonic-gate 				break;
5197c478bd9Sstevel@tonic-gate 			dumpstats(fd);
5207c478bd9Sstevel@tonic-gate 			(void) close(fd);
5217c478bd9Sstevel@tonic-gate 			break;
5227c478bd9Sstevel@tonic-gate 		default:
5237c478bd9Sstevel@tonic-gate 			DPRINT2(2, "main(%u): unexpected signal %d\n",
5247c478bd9Sstevel@tonic-gate 				mythreadno, sig);
5257c478bd9Sstevel@tonic-gate 			break;
5267c478bd9Sstevel@tonic-gate 		}
5277c478bd9Sstevel@tonic-gate 	}
5287c478bd9Sstevel@tonic-gate }
5297c478bd9Sstevel@tonic-gate 
5307c478bd9Sstevel@tonic-gate /*
5317c478bd9Sstevel@tonic-gate  * Attempts to open the local log device
5327c478bd9Sstevel@tonic-gate  * and return a file descriptor.
5337c478bd9Sstevel@tonic-gate  */
5347c478bd9Sstevel@tonic-gate static int
5357c478bd9Sstevel@tonic-gate openklog(char *name, int mode)
5367c478bd9Sstevel@tonic-gate {
5377c478bd9Sstevel@tonic-gate 	int fd;
5387c478bd9Sstevel@tonic-gate 	struct strioctl str;
5397c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
5407c478bd9Sstevel@tonic-gate 
5417c478bd9Sstevel@tonic-gate 	if (Debug) {
5427c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
5437c478bd9Sstevel@tonic-gate 	}
5447c478bd9Sstevel@tonic-gate 
5457c478bd9Sstevel@tonic-gate 	if ((fd = open(name, mode)) < 0) {
5467c478bd9Sstevel@tonic-gate 		logerror("cannot open %s", name);
5477c478bd9Sstevel@tonic-gate 		DPRINT3(1, "openklog(%u): cannot create %s (%d)\n",
5487c478bd9Sstevel@tonic-gate 			mythreadno, name, errno);
5497c478bd9Sstevel@tonic-gate 		return (-1);
5507c478bd9Sstevel@tonic-gate 	}
5517c478bd9Sstevel@tonic-gate 	str.ic_cmd = I_CONSLOG;
5527c478bd9Sstevel@tonic-gate 	str.ic_timout = 0;
5537c478bd9Sstevel@tonic-gate 	str.ic_len = 0;
5547c478bd9Sstevel@tonic-gate 	str.ic_dp = NULL;
5557c478bd9Sstevel@tonic-gate 	if (ioctl(fd, I_STR, &str) < 0) {
5567c478bd9Sstevel@tonic-gate 		logerror("cannot register to log console messages");
5577c478bd9Sstevel@tonic-gate 		DPRINT2(1, "openklog(%u): cannot register to log "
5587c478bd9Sstevel@tonic-gate 			"console messages (%d)\n", mythreadno, errno);
5597c478bd9Sstevel@tonic-gate 		return (-1);
5607c478bd9Sstevel@tonic-gate 	}
5617c478bd9Sstevel@tonic-gate 	return (fd);
5627c478bd9Sstevel@tonic-gate }
5637c478bd9Sstevel@tonic-gate 
5647c478bd9Sstevel@tonic-gate 
5657c478bd9Sstevel@tonic-gate /*
5667c478bd9Sstevel@tonic-gate  * Open the log device, and pull up all pending messages.
5677c478bd9Sstevel@tonic-gate  */
5687c478bd9Sstevel@tonic-gate static void
5697c478bd9Sstevel@tonic-gate prepare_sys_poll()
5707c478bd9Sstevel@tonic-gate {
5717c478bd9Sstevel@tonic-gate 	int nfds, funix;
5727c478bd9Sstevel@tonic-gate 
5737c478bd9Sstevel@tonic-gate 	if ((funix = openklog(LogName, O_RDONLY)) < 0) {
5747c478bd9Sstevel@tonic-gate 		logerror("can't open kernel log device - fatal");
5757c478bd9Sstevel@tonic-gate 		exit(1);
5767c478bd9Sstevel@tonic-gate 	}
5777c478bd9Sstevel@tonic-gate 
5787c478bd9Sstevel@tonic-gate 	Pfd.fd = funix;
5797c478bd9Sstevel@tonic-gate 	Pfd.events = POLLIN;
5807c478bd9Sstevel@tonic-gate 
5817c478bd9Sstevel@tonic-gate 	for (;;) {
5827c478bd9Sstevel@tonic-gate 		nfds = poll(&Pfd, 1, 0);
5837c478bd9Sstevel@tonic-gate 		if (nfds <= 0) {
5847c478bd9Sstevel@tonic-gate 			if (sys_init_msg_count > 0)
5857c478bd9Sstevel@tonic-gate 				flushmsg(SYNC_FILE);
5867c478bd9Sstevel@tonic-gate 			break;
5877c478bd9Sstevel@tonic-gate 		}
5887c478bd9Sstevel@tonic-gate 
5897c478bd9Sstevel@tonic-gate 		if (Pfd.revents & POLLIN) {
5907c478bd9Sstevel@tonic-gate 			getkmsg(0);
5917c478bd9Sstevel@tonic-gate 		} else if (Pfd.revents & (POLLNVAL|POLLHUP|POLLERR)) {
5927c478bd9Sstevel@tonic-gate 			logerror("kernel log driver poll error");
5937c478bd9Sstevel@tonic-gate 			break;
5947c478bd9Sstevel@tonic-gate 		}
5957c478bd9Sstevel@tonic-gate 	}
5967c478bd9Sstevel@tonic-gate 
5977c478bd9Sstevel@tonic-gate }
5987c478bd9Sstevel@tonic-gate 
5997c478bd9Sstevel@tonic-gate /*
6007c478bd9Sstevel@tonic-gate  * this thread listens to the local stream log driver for log messages
6017c478bd9Sstevel@tonic-gate  * generated by this host, formats them, and queues them to the logger
6027c478bd9Sstevel@tonic-gate  * thread.
6037c478bd9Sstevel@tonic-gate  */
6047c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6057c478bd9Sstevel@tonic-gate static void *
6067c478bd9Sstevel@tonic-gate sys_poll(void *ap)
6077c478bd9Sstevel@tonic-gate {
6087c478bd9Sstevel@tonic-gate 	int nfds;
6097c478bd9Sstevel@tonic-gate 	static int klogerrs = 0;
6107c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate 	if (Debug) {
6137c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
6147c478bd9Sstevel@tonic-gate 	}
6157c478bd9Sstevel@tonic-gate 
6167c478bd9Sstevel@tonic-gate 	DPRINT1(1, "sys_poll(%u): sys_thread started\n", mythreadno);
6177c478bd9Sstevel@tonic-gate 
6187c478bd9Sstevel@tonic-gate 	/*
6197c478bd9Sstevel@tonic-gate 	 * Try to process as many messages as we can without blocking on poll.
6207c478bd9Sstevel@tonic-gate 	 * We count such "initial" messages with sys_init_msg_count and
6217c478bd9Sstevel@tonic-gate 	 * enqueue them without the SYNC_FILE flag.  When no more data is
6227c478bd9Sstevel@tonic-gate 	 * waiting on the local log device, we set timeout to INFTIM,
6237c478bd9Sstevel@tonic-gate 	 * clear sys_init_msg_count, and generate a flush message to sync
6247c478bd9Sstevel@tonic-gate 	 * the previously counted initial messages out to disk.
6257c478bd9Sstevel@tonic-gate 	 */
6267c478bd9Sstevel@tonic-gate 
6277c478bd9Sstevel@tonic-gate 	sys_init_msg_count = 0;
6287c478bd9Sstevel@tonic-gate 
6297c478bd9Sstevel@tonic-gate 	for (;;) {
6307c478bd9Sstevel@tonic-gate 		errno = 0;
6317c478bd9Sstevel@tonic-gate 		t_errno = 0;
6327c478bd9Sstevel@tonic-gate 
6337c478bd9Sstevel@tonic-gate 		nfds = poll(&Pfd, 1, INFTIM);
6347c478bd9Sstevel@tonic-gate 
6357c478bd9Sstevel@tonic-gate 		if (nfds == 0)
6367c478bd9Sstevel@tonic-gate 			continue;
6377c478bd9Sstevel@tonic-gate 
6387c478bd9Sstevel@tonic-gate 		if (nfds < 0) {
6397c478bd9Sstevel@tonic-gate 			if (errno != EINTR)
6407c478bd9Sstevel@tonic-gate 				logerror("poll");
6417c478bd9Sstevel@tonic-gate 			continue;
6427c478bd9Sstevel@tonic-gate 		}
6437c478bd9Sstevel@tonic-gate 		if (Pfd.revents & POLLIN) {
6447c478bd9Sstevel@tonic-gate 			getkmsg(INFTIM);
6457c478bd9Sstevel@tonic-gate 		} else {
6467c478bd9Sstevel@tonic-gate 			if (shutting_down) {
6477c478bd9Sstevel@tonic-gate 				pthread_exit(0);
6487c478bd9Sstevel@tonic-gate 			}
6497c478bd9Sstevel@tonic-gate 			if (Pfd.revents & (POLLNVAL|POLLHUP|POLLERR)) {
6507c478bd9Sstevel@tonic-gate 				logerror("kernel log driver poll error");
6517c478bd9Sstevel@tonic-gate 				(void) close(Pfd.fd);
6527c478bd9Sstevel@tonic-gate 				Pfd.fd = -1;
6537c478bd9Sstevel@tonic-gate 			}
6547c478bd9Sstevel@tonic-gate 		}
6557c478bd9Sstevel@tonic-gate 
6567c478bd9Sstevel@tonic-gate 		while (Pfd.fd == -1 && klogerrs++ < 10) {
6577c478bd9Sstevel@tonic-gate 			Pfd.fd = openklog(LogName, O_RDONLY);
6587c478bd9Sstevel@tonic-gate 		}
6597c478bd9Sstevel@tonic-gate 		if (klogerrs >= 10) {
6607c478bd9Sstevel@tonic-gate 			logerror("can't reopen kernel log device - fatal");
6617c478bd9Sstevel@tonic-gate 			exit(1);
6627c478bd9Sstevel@tonic-gate 		}
6637c478bd9Sstevel@tonic-gate 	}
6647c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
6657c478bd9Sstevel@tonic-gate 	return (NULL);
6667c478bd9Sstevel@tonic-gate }
6677c478bd9Sstevel@tonic-gate 
6687c478bd9Sstevel@tonic-gate /*
6697c478bd9Sstevel@tonic-gate  * Pull up one message from log driver.
6707c478bd9Sstevel@tonic-gate  */
6717c478bd9Sstevel@tonic-gate static void
6727c478bd9Sstevel@tonic-gate getkmsg(int timeout)
6737c478bd9Sstevel@tonic-gate {
6747c478bd9Sstevel@tonic-gate 	int flags = 0, i;
6757c478bd9Sstevel@tonic-gate 	char *lastline;
6767c478bd9Sstevel@tonic-gate 	struct strbuf ctl, dat;
6777c478bd9Sstevel@tonic-gate 	struct log_ctl hdr;
6787c478bd9Sstevel@tonic-gate 	char buf[MAXLINE+1];
6797c478bd9Sstevel@tonic-gate 	size_t buflen;
6807c478bd9Sstevel@tonic-gate 	size_t len;
6817c478bd9Sstevel@tonic-gate 	char tmpbuf[MAXLINE+1];
6827c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
6837c478bd9Sstevel@tonic-gate 
6847c478bd9Sstevel@tonic-gate 	if (Debug) {
6857c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
6867c478bd9Sstevel@tonic-gate 	}
6877c478bd9Sstevel@tonic-gate 
6887c478bd9Sstevel@tonic-gate 	dat.maxlen = MAXLINE;
6897c478bd9Sstevel@tonic-gate 	dat.buf = buf;
6907c478bd9Sstevel@tonic-gate 	ctl.maxlen = sizeof (struct log_ctl);
6917c478bd9Sstevel@tonic-gate 	ctl.buf = (caddr_t)&hdr;
6927c478bd9Sstevel@tonic-gate 
6937c478bd9Sstevel@tonic-gate 	while ((i = getmsg(Pfd.fd, &ctl, &dat, &flags)) == MOREDATA) {
6947c478bd9Sstevel@tonic-gate 		lastline = &dat.buf[dat.len];
6957c478bd9Sstevel@tonic-gate 		*lastline = '\0';
6967c478bd9Sstevel@tonic-gate 
6977c478bd9Sstevel@tonic-gate 		DPRINT2(5, "sys_poll:(%u): getmsg: dat.len = %d\n",
6987c478bd9Sstevel@tonic-gate 			mythreadno, dat.len);
6997c478bd9Sstevel@tonic-gate 		buflen = strlen(buf);
7007c478bd9Sstevel@tonic-gate 		len = findnl_bkwd(buf, buflen);
7017c478bd9Sstevel@tonic-gate 
7027c478bd9Sstevel@tonic-gate 		(void) memcpy(tmpbuf, buf, len);
7037c478bd9Sstevel@tonic-gate 		tmpbuf[len] = '\0';
7047c478bd9Sstevel@tonic-gate 
7057c478bd9Sstevel@tonic-gate 		/*
7067c478bd9Sstevel@tonic-gate 		 * Format sys will enqueue the log message.
7077c478bd9Sstevel@tonic-gate 		 * Set the sync flag if timeout != 0, which
7087c478bd9Sstevel@tonic-gate 		 * means that we're done handling all the
7097c478bd9Sstevel@tonic-gate 		 * initial messages ready during startup.
7107c478bd9Sstevel@tonic-gate 		 */
7117c478bd9Sstevel@tonic-gate 		if (timeout == 0) {
7127c478bd9Sstevel@tonic-gate 			formatsys(&hdr, tmpbuf, 0);
7137c478bd9Sstevel@tonic-gate 			sys_init_msg_count++;
7147c478bd9Sstevel@tonic-gate 		} else {
7157c478bd9Sstevel@tonic-gate 			formatsys(&hdr, tmpbuf, 1);
7167c478bd9Sstevel@tonic-gate 		}
7177c478bd9Sstevel@tonic-gate 		sys_msg_count++;
7187c478bd9Sstevel@tonic-gate 
7197c478bd9Sstevel@tonic-gate 		if (len != buflen) {
7207c478bd9Sstevel@tonic-gate 			/* If anything remains in buf */
7217c478bd9Sstevel@tonic-gate 			size_t remlen;
7227c478bd9Sstevel@tonic-gate 
7237c478bd9Sstevel@tonic-gate 			if (buf[len] == '\n') {
7247c478bd9Sstevel@tonic-gate 				/* skip newline */
7257c478bd9Sstevel@tonic-gate 				len++;
7267c478bd9Sstevel@tonic-gate 			}
7277c478bd9Sstevel@tonic-gate 
7287c478bd9Sstevel@tonic-gate 			/*
7297c478bd9Sstevel@tonic-gate 			 *  Move the remaining bytes to
7307c478bd9Sstevel@tonic-gate 			 * the beginnning of buf.
7317c478bd9Sstevel@tonic-gate 			 */
7327c478bd9Sstevel@tonic-gate 
7337c478bd9Sstevel@tonic-gate 			remlen = buflen - len;
7347c478bd9Sstevel@tonic-gate 			(void) memcpy(buf, &buf[len], remlen);
7357c478bd9Sstevel@tonic-gate 			dat.maxlen = MAXLINE - remlen;
7367c478bd9Sstevel@tonic-gate 			dat.buf = &buf[remlen];
7377c478bd9Sstevel@tonic-gate 		} else {
7387c478bd9Sstevel@tonic-gate 			dat.maxlen = MAXLINE;
7397c478bd9Sstevel@tonic-gate 			dat.buf = buf;
7407c478bd9Sstevel@tonic-gate 		}
7417c478bd9Sstevel@tonic-gate 	}
7427c478bd9Sstevel@tonic-gate 
7437c478bd9Sstevel@tonic-gate 	if (i == 0 && dat.len > 0) {
7447c478bd9Sstevel@tonic-gate 		dat.buf[dat.len] = '\0';
7457c478bd9Sstevel@tonic-gate 		/*
7467c478bd9Sstevel@tonic-gate 		 * Format sys will enqueue the log message.
7477c478bd9Sstevel@tonic-gate 		 * Set the sync flag if timeout != 0, which
7487c478bd9Sstevel@tonic-gate 		 * means that we're done handling all the
7497c478bd9Sstevel@tonic-gate 		 * initial messages ready during startup.
7507c478bd9Sstevel@tonic-gate 		 */
7517c478bd9Sstevel@tonic-gate 		DPRINT2(5, "getkmsg(%u): getmsg: dat.maxlen = %d\n",
7527c478bd9Sstevel@tonic-gate 			mythreadno, dat.maxlen);
7537c478bd9Sstevel@tonic-gate 		DPRINT2(5, "getkmsg(%u): getmsg: dat.len = %d\n",
7547c478bd9Sstevel@tonic-gate 			mythreadno, dat.len);
7557c478bd9Sstevel@tonic-gate 		DPRINT2(5, "getkmsg(%u): getmsg: strlen(dat.buf) = %d\n",
7567c478bd9Sstevel@tonic-gate 			mythreadno, strlen(dat.buf));
7577c478bd9Sstevel@tonic-gate 		DPRINT2(5, "getkmsg(%u): getmsg: dat.buf = \"%s\"\n",
7587c478bd9Sstevel@tonic-gate 			mythreadno, dat.buf);
7597c478bd9Sstevel@tonic-gate 		DPRINT2(5, "getkmsg(%u): buf len = %d\n",
7607c478bd9Sstevel@tonic-gate 			mythreadno, strlen(buf));
7617c478bd9Sstevel@tonic-gate 		if (timeout == 0) {
7627c478bd9Sstevel@tonic-gate 			formatsys(&hdr, buf, 0);
7637c478bd9Sstevel@tonic-gate 			sys_init_msg_count++;
7647c478bd9Sstevel@tonic-gate 		} else {
7657c478bd9Sstevel@tonic-gate 			formatsys(&hdr, buf, 1);
7667c478bd9Sstevel@tonic-gate 		}
7677c478bd9Sstevel@tonic-gate 		sys_msg_count++;
7687c478bd9Sstevel@tonic-gate 	} else if (i < 0 && errno != EINTR) {
7697c478bd9Sstevel@tonic-gate 		if (!shutting_down) {
7707c478bd9Sstevel@tonic-gate 			logerror("kernel log driver read error");
7717c478bd9Sstevel@tonic-gate 		}
7727c478bd9Sstevel@tonic-gate 		(void) close(Pfd.fd);
7737c478bd9Sstevel@tonic-gate 		Pfd.fd = -1;
7747c478bd9Sstevel@tonic-gate 	}
7757c478bd9Sstevel@tonic-gate }
7767c478bd9Sstevel@tonic-gate 
7777c478bd9Sstevel@tonic-gate /*
7787c478bd9Sstevel@tonic-gate  * this thread polls all the network interfaces for syslog messages
7797c478bd9Sstevel@tonic-gate  * forwarded to us, tags them with the hostname they are received
7807c478bd9Sstevel@tonic-gate  * from, and queues them to the logger thread.
7817c478bd9Sstevel@tonic-gate  */
7827c478bd9Sstevel@tonic-gate /*ARGSUSED*/
7837c478bd9Sstevel@tonic-gate static void *
7847c478bd9Sstevel@tonic-gate net_poll(void *ap)
7857c478bd9Sstevel@tonic-gate {
7867c478bd9Sstevel@tonic-gate 	int nfds, i;
7877c478bd9Sstevel@tonic-gate 	int flags = 0;
7887c478bd9Sstevel@tonic-gate 	struct t_unitdata *udp;
7897c478bd9Sstevel@tonic-gate 	struct t_uderr *errp;
7907c478bd9Sstevel@tonic-gate 	char buf[MAXLINE+1];
7917c478bd9Sstevel@tonic-gate 	char *uap;
7927c478bd9Sstevel@tonic-gate 	log_message_t *mp;
7937c478bd9Sstevel@tonic-gate 	host_info_t *hinfo;
7947c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
7957c478bd9Sstevel@tonic-gate 
7967c478bd9Sstevel@tonic-gate 	if (Debug) {
7977c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
7987c478bd9Sstevel@tonic-gate 	}
7997c478bd9Sstevel@tonic-gate 
8007c478bd9Sstevel@tonic-gate 	DPRINT1(1, "net_poll(%u): net_thread started\n", mythreadno);
8017c478bd9Sstevel@tonic-gate 
8027c478bd9Sstevel@tonic-gate 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp))
8037c478bd9Sstevel@tonic-gate 
8047c478bd9Sstevel@tonic-gate 	for (;;) {
8057c478bd9Sstevel@tonic-gate 		errno = 0;
8067c478bd9Sstevel@tonic-gate 		t_errno = 0;
8077c478bd9Sstevel@tonic-gate 		nfds = poll(Nfd, Ninputs, -1);
8087c478bd9Sstevel@tonic-gate 		if (nfds == 0)
8097c478bd9Sstevel@tonic-gate 			continue;
8107c478bd9Sstevel@tonic-gate 
8117c478bd9Sstevel@tonic-gate 		if (nfds < 0) {
8127c478bd9Sstevel@tonic-gate 			if (errno != EINTR)
8137c478bd9Sstevel@tonic-gate 				logerror("poll");
8147c478bd9Sstevel@tonic-gate 			continue;
8157c478bd9Sstevel@tonic-gate 		}
8167c478bd9Sstevel@tonic-gate 		for (i = 0; nfds > 0 && i < Ninputs; i++) {
8177c478bd9Sstevel@tonic-gate 			if ((Nfd[i].revents & POLLIN) == 0) {
8187c478bd9Sstevel@tonic-gate 				if (shutting_down) {
8197c478bd9Sstevel@tonic-gate 					pthread_exit(0);
8207c478bd9Sstevel@tonic-gate 				}
8217c478bd9Sstevel@tonic-gate 				if (Nfd[i].revents &
8227c478bd9Sstevel@tonic-gate 					(POLLNVAL|POLLHUP|POLLERR)) {
8237c478bd9Sstevel@tonic-gate 					logerror("POLLNVAL|POLLHUP|POLLERR");
8247c478bd9Sstevel@tonic-gate 					(void) t_close(Nfd[i].fd);
8257c478bd9Sstevel@tonic-gate 					Nfd[i].fd = -1;
8267c478bd9Sstevel@tonic-gate 					nfds--;
8277c478bd9Sstevel@tonic-gate 				}
8287c478bd9Sstevel@tonic-gate 				continue;
8297c478bd9Sstevel@tonic-gate 			}
8307c478bd9Sstevel@tonic-gate 
8317c478bd9Sstevel@tonic-gate 			udp = Udp[i];
8327c478bd9Sstevel@tonic-gate 			udp->udata.buf = buf;
8337c478bd9Sstevel@tonic-gate 			udp->udata.maxlen = MAXLINE;
8347c478bd9Sstevel@tonic-gate 			udp->udata.len = 0;
8357c478bd9Sstevel@tonic-gate 			flags = 0;
8367c478bd9Sstevel@tonic-gate 			if (t_rcvudata(Nfd[i].fd, udp, &flags) < 0) {
8377c478bd9Sstevel@tonic-gate 				errp = Errp[i];
8387c478bd9Sstevel@tonic-gate 				if (t_errno == TLOOK) {
8397c478bd9Sstevel@tonic-gate 					if (t_rcvuderr(Nfd[i].fd, errp) < 0) {
8407c478bd9Sstevel@tonic-gate 						if (!shutting_down) {
8417c478bd9Sstevel@tonic-gate 							logerror("t_rcvuderr");
8427c478bd9Sstevel@tonic-gate 						}
8437c478bd9Sstevel@tonic-gate 						t_close(Nfd[i].fd);
8447c478bd9Sstevel@tonic-gate 						Nfd[i].fd = -1;
8457c478bd9Sstevel@tonic-gate 					}
8467c478bd9Sstevel@tonic-gate 				} else {
8477c478bd9Sstevel@tonic-gate 					if (!shutting_down) {
8487c478bd9Sstevel@tonic-gate 						logerror("t_rcvudata");
8497c478bd9Sstevel@tonic-gate 					}
8507c478bd9Sstevel@tonic-gate 					t_close(Nfd[i].fd);
8517c478bd9Sstevel@tonic-gate 					Nfd[i].fd = -1;
8527c478bd9Sstevel@tonic-gate 				}
8537c478bd9Sstevel@tonic-gate 				nfds--;
8547c478bd9Sstevel@tonic-gate 				if (shutting_down) {
8557c478bd9Sstevel@tonic-gate 					pthread_exit(0);
8567c478bd9Sstevel@tonic-gate 				}
8577c478bd9Sstevel@tonic-gate 				continue;
8587c478bd9Sstevel@tonic-gate 			}
8597c478bd9Sstevel@tonic-gate 			nfds--;
8607c478bd9Sstevel@tonic-gate 
8617c478bd9Sstevel@tonic-gate 			if (udp->udata.len == 0) {
8627c478bd9Sstevel@tonic-gate 				if (Debug) {
8637c478bd9Sstevel@tonic-gate 					uap = NULL;
8647c478bd9Sstevel@tonic-gate 					if (udp->addr.len > 0) {
8657c478bd9Sstevel@tonic-gate 						uap = taddr2uaddr(&Ncf[i],
8667c478bd9Sstevel@tonic-gate 							&udp->addr);
8677c478bd9Sstevel@tonic-gate 					}
8687c478bd9Sstevel@tonic-gate 					DPRINT2(1, "net_poll(%u):"
8697c478bd9Sstevel@tonic-gate 						" received empty packet"
8707c478bd9Sstevel@tonic-gate 						" from %s\n", mythreadno,
8717c478bd9Sstevel@tonic-gate 						uap ? uap : "<unknown>");
8727c478bd9Sstevel@tonic-gate 					if (uap)
8737c478bd9Sstevel@tonic-gate 						free(uap);
8747c478bd9Sstevel@tonic-gate 				}
8757c478bd9Sstevel@tonic-gate 				continue;	/* No data */
8767c478bd9Sstevel@tonic-gate 			}
8777c478bd9Sstevel@tonic-gate 			if (udp->addr.len == 0) {
8787c478bd9Sstevel@tonic-gate 				/*
8797c478bd9Sstevel@tonic-gate 				 * The previous message was larger than
8807c478bd9Sstevel@tonic-gate 				 * MAXLINE, and T_MORE should have been set.
8817c478bd9Sstevel@tonic-gate 				 * Further data needs to be discarded as
8827c478bd9Sstevel@tonic-gate 				 * we've already received MAXLINE.
8837c478bd9Sstevel@tonic-gate 				 */
8847c478bd9Sstevel@tonic-gate 				DPRINT1(1, "net_poll(%u): discarding packet "
8857c478bd9Sstevel@tonic-gate 					"exceeds max line size\n", mythreadno);
8867c478bd9Sstevel@tonic-gate 				continue;
8877c478bd9Sstevel@tonic-gate 			}
8887c478bd9Sstevel@tonic-gate 
8897c478bd9Sstevel@tonic-gate 			net_msg_count++;
8907c478bd9Sstevel@tonic-gate 
8917c478bd9Sstevel@tonic-gate 			if ((mp = new_msg()) == NULL) {
8927c478bd9Sstevel@tonic-gate 				MALLOC_FAIL("dropping message from "
8937c478bd9Sstevel@tonic-gate 					"remote");
8947c478bd9Sstevel@tonic-gate 				continue;
8957c478bd9Sstevel@tonic-gate 			}
8967c478bd9Sstevel@tonic-gate 
8977c478bd9Sstevel@tonic-gate 			buf[udp->udata.len] = '\0';
8987c478bd9Sstevel@tonic-gate 			formatnet(&udp->udata, mp);
8997c478bd9Sstevel@tonic-gate 
9007c478bd9Sstevel@tonic-gate 			if (Debug) {
9017c478bd9Sstevel@tonic-gate 				uap = taddr2uaddr(&Ncf[i], &udp->addr);
9027c478bd9Sstevel@tonic-gate 				DPRINT2(1, "net_poll(%u): received message"
9037c478bd9Sstevel@tonic-gate 					" from %s\n", mythreadno,
9047c478bd9Sstevel@tonic-gate 					uap ? uap : "<unknown>");
9057c478bd9Sstevel@tonic-gate 				free(uap);
9067c478bd9Sstevel@tonic-gate 			}
9077c478bd9Sstevel@tonic-gate 			if ((hinfo = malloc(sizeof (*hinfo))) == NULL ||
9087c478bd9Sstevel@tonic-gate 				(hinfo->addr.buf =
9097c478bd9Sstevel@tonic-gate 					malloc(udp->addr.len)) == NULL) {
9107c478bd9Sstevel@tonic-gate 				MALLOC_FAIL("dropping message from "
9117c478bd9Sstevel@tonic-gate 					"remote");
9127c478bd9Sstevel@tonic-gate 				if (hinfo) {
9137c478bd9Sstevel@tonic-gate 					free(hinfo);
9147c478bd9Sstevel@tonic-gate 				}
9157c478bd9Sstevel@tonic-gate 				free_msg(mp);
9167c478bd9Sstevel@tonic-gate 				continue;
9177c478bd9Sstevel@tonic-gate 			}
9187c478bd9Sstevel@tonic-gate 
9197c478bd9Sstevel@tonic-gate 			hinfo->ncp = &Ncf[i];
9207c478bd9Sstevel@tonic-gate 			hinfo->addr.len = udp->addr.len;
9217c478bd9Sstevel@tonic-gate 			(void) memcpy(hinfo->addr.buf, udp->addr.buf,
9227c478bd9Sstevel@tonic-gate 					udp->addr.len);
9237c478bd9Sstevel@tonic-gate 			mp->ptr = hinfo;
9247c478bd9Sstevel@tonic-gate 			if (dataq_enqueue(&hnlq, (void *)mp) == -1) {
9257c478bd9Sstevel@tonic-gate 				MALLOC_FAIL("dropping message from "
9267c478bd9Sstevel@tonic-gate 					"remote");
9277c478bd9Sstevel@tonic-gate 				free_msg(mp);
9287c478bd9Sstevel@tonic-gate 				free(hinfo->addr.buf);
9297c478bd9Sstevel@tonic-gate 				free(hinfo);
9307c478bd9Sstevel@tonic-gate 				continue;
9317c478bd9Sstevel@tonic-gate 			}
9327c478bd9Sstevel@tonic-gate 			DPRINT3(5, "net_poll(%u): enqueued msg %p "
9337c478bd9Sstevel@tonic-gate 				"on queue %p\n", mythreadno, mp, &hnlq);
9347c478bd9Sstevel@tonic-gate 		}
9357c478bd9Sstevel@tonic-gate 	}
9367c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
9377c478bd9Sstevel@tonic-gate 	return (NULL);
9387c478bd9Sstevel@tonic-gate }
9397c478bd9Sstevel@tonic-gate 
9407c478bd9Sstevel@tonic-gate static void
9417c478bd9Sstevel@tonic-gate usage(void)
9427c478bd9Sstevel@tonic-gate {
9437c478bd9Sstevel@tonic-gate 	(void) fprintf(stderr,
9447c478bd9Sstevel@tonic-gate 	    "usage: syslogd [-d] [-t|-T] [-mmarkinterval] [-ppath]"
9457c478bd9Sstevel@tonic-gate 	    " [-fconffile]\n");
9467c478bd9Sstevel@tonic-gate 	exit(1);
9477c478bd9Sstevel@tonic-gate }
9487c478bd9Sstevel@tonic-gate 
9497c478bd9Sstevel@tonic-gate static void
9507c478bd9Sstevel@tonic-gate untty(void)
9517c478bd9Sstevel@tonic-gate {
9527c478bd9Sstevel@tonic-gate 	if (!Debug)
9537c478bd9Sstevel@tonic-gate 		(void) setsid();
9547c478bd9Sstevel@tonic-gate }
9557c478bd9Sstevel@tonic-gate 
9567c478bd9Sstevel@tonic-gate /*
9577c478bd9Sstevel@tonic-gate  * generate a log message internally. The original version of syslogd
9587c478bd9Sstevel@tonic-gate  * simply called logmsg directly, but because everything is now based
9597c478bd9Sstevel@tonic-gate  * on message passing, we need an internal way to generate and queue
9607c478bd9Sstevel@tonic-gate  * log messages from within syslogd itself.
9617c478bd9Sstevel@tonic-gate  */
9627c478bd9Sstevel@tonic-gate static int
9637c478bd9Sstevel@tonic-gate logmymsg(int pri, char *msg, int flags, int pending)
9647c478bd9Sstevel@tonic-gate {
9657c478bd9Sstevel@tonic-gate 	log_message_t *mp;
9667c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
9677c478bd9Sstevel@tonic-gate 	dataq_t *qptr;
9687c478bd9Sstevel@tonic-gate 
9697c478bd9Sstevel@tonic-gate 	if (Debug) {
9707c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
9717c478bd9Sstevel@tonic-gate 	}
9727c478bd9Sstevel@tonic-gate 
9737c478bd9Sstevel@tonic-gate 	if ((mp = new_msg()) == NULL) {
9747c478bd9Sstevel@tonic-gate 		return (-1);
9757c478bd9Sstevel@tonic-gate 	}
9767c478bd9Sstevel@tonic-gate 
9777c478bd9Sstevel@tonic-gate 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp))
9787c478bd9Sstevel@tonic-gate 	mp->pri = pri;
9797c478bd9Sstevel@tonic-gate 	mp->hlp = &LocalHostName;
9807c478bd9Sstevel@tonic-gate 	(void) strlcpy(mp->msg, msg, MAXLINE+1);
9817c478bd9Sstevel@tonic-gate 	mp->flags = flags;
9827c478bd9Sstevel@tonic-gate 	(void) time(&mp->ts);
9837c478bd9Sstevel@tonic-gate 
9847c478bd9Sstevel@tonic-gate 	qptr = pending ? &tmpq : &inputq;
9857c478bd9Sstevel@tonic-gate 	if (dataq_enqueue(qptr, (void *)mp) == -1) {
9867c478bd9Sstevel@tonic-gate 		free_msg(mp);
9877c478bd9Sstevel@tonic-gate 		return (-1);
9887c478bd9Sstevel@tonic-gate 	}
9897c478bd9Sstevel@tonic-gate 
9907c478bd9Sstevel@tonic-gate 	DPRINT3(5, "logmymsg(%u): enqueued msg %p on queue %p\n",
9917c478bd9Sstevel@tonic-gate 		mythreadno, mp, qptr);
9927c478bd9Sstevel@tonic-gate 	DPRINT2(5, "logmymsg(%u): Message content: %s\n", mythreadno, msg);
9937c478bd9Sstevel@tonic-gate 	return (0);
9947c478bd9Sstevel@tonic-gate }
9957c478bd9Sstevel@tonic-gate 
9967c478bd9Sstevel@tonic-gate /*
9977c478bd9Sstevel@tonic-gate  * Generate an internal shutdown message
9987c478bd9Sstevel@tonic-gate  */
9997c478bd9Sstevel@tonic-gate static int
10007c478bd9Sstevel@tonic-gate shutdown_msg(void)
10017c478bd9Sstevel@tonic-gate {
10027c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
10037c478bd9Sstevel@tonic-gate 	log_message_t *mp;
10047c478bd9Sstevel@tonic-gate 
10057c478bd9Sstevel@tonic-gate 	if (Debug) {
10067c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
10077c478bd9Sstevel@tonic-gate 	}
10087c478bd9Sstevel@tonic-gate 
10097c478bd9Sstevel@tonic-gate 	if ((mp = new_msg()) == NULL) {
10107c478bd9Sstevel@tonic-gate 		return (-1);
10117c478bd9Sstevel@tonic-gate 	}
10127c478bd9Sstevel@tonic-gate 
10137c478bd9Sstevel@tonic-gate 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp));
10147c478bd9Sstevel@tonic-gate 	mp->flags = SHUTDOWN;
10157c478bd9Sstevel@tonic-gate 	mp->hlp = &LocalHostName;
10167c478bd9Sstevel@tonic-gate 
10177c478bd9Sstevel@tonic-gate 	if (dataq_enqueue(&inputq, (void *)mp) == -1) {
10187c478bd9Sstevel@tonic-gate 		free_msg(mp);
10197c478bd9Sstevel@tonic-gate 		return (-1);
10207c478bd9Sstevel@tonic-gate 	}
10217c478bd9Sstevel@tonic-gate 
10227c478bd9Sstevel@tonic-gate 	DPRINT3(5, "shutdown_msg(%u): enqueued msg %p on queue %p\n",
10237c478bd9Sstevel@tonic-gate 		mythreadno, mp, &inputq);
10247c478bd9Sstevel@tonic-gate 	return (0);
10257c478bd9Sstevel@tonic-gate }
10267c478bd9Sstevel@tonic-gate 
10277c478bd9Sstevel@tonic-gate /*
10287c478bd9Sstevel@tonic-gate  * Generate an internal flush message
10297c478bd9Sstevel@tonic-gate  */
10307c478bd9Sstevel@tonic-gate static void
10317c478bd9Sstevel@tonic-gate flushmsg(int flags)
10327c478bd9Sstevel@tonic-gate {
10337c478bd9Sstevel@tonic-gate 	log_message_t *mp;
10347c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
10357c478bd9Sstevel@tonic-gate 
10367c478bd9Sstevel@tonic-gate 	if (Debug) {
10377c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
10387c478bd9Sstevel@tonic-gate 	}
10397c478bd9Sstevel@tonic-gate 
10407c478bd9Sstevel@tonic-gate 	if ((mp = new_msg()) == NULL) {
10417c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("dropping flush msg");
10427c478bd9Sstevel@tonic-gate 		return;
10437c478bd9Sstevel@tonic-gate 	}
10447c478bd9Sstevel@tonic-gate 
10457c478bd9Sstevel@tonic-gate 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp));
10467c478bd9Sstevel@tonic-gate 	mp->flags = FLUSHMSG | flags;
10477c478bd9Sstevel@tonic-gate 	mp->hlp = &LocalHostName;
10487c478bd9Sstevel@tonic-gate 
10497c478bd9Sstevel@tonic-gate 	if (dataq_enqueue(&inputq, (void *)mp) == -1) {
10507c478bd9Sstevel@tonic-gate 		free_msg(mp);
10517c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("dropping flush msg");
10527c478bd9Sstevel@tonic-gate 		return;
10537c478bd9Sstevel@tonic-gate 	}
10547c478bd9Sstevel@tonic-gate 
10557c478bd9Sstevel@tonic-gate 	DPRINT4(5, "flush_msg(%u): enqueued msg %p on queue %p, flags "
10567c478bd9Sstevel@tonic-gate 		"0x%x\n", mythreadno, mp, &inputq, flags);
10577c478bd9Sstevel@tonic-gate }
10587c478bd9Sstevel@tonic-gate 
10597c478bd9Sstevel@tonic-gate /*
10607c478bd9Sstevel@tonic-gate  * Do some processing on messages received from the net
10617c478bd9Sstevel@tonic-gate  */
10627c478bd9Sstevel@tonic-gate static void
10637c478bd9Sstevel@tonic-gate formatnet(struct netbuf *nbp, log_message_t *mp)
10647c478bd9Sstevel@tonic-gate {
10657c478bd9Sstevel@tonic-gate 	char *p;
10667c478bd9Sstevel@tonic-gate 	int pri;
10677c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
10687c478bd9Sstevel@tonic-gate 
10697c478bd9Sstevel@tonic-gate 	if (Debug) {
10707c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
10717c478bd9Sstevel@tonic-gate 	}
10727c478bd9Sstevel@tonic-gate 
10737c478bd9Sstevel@tonic-gate 	DPRINT2(5, "formatnet(%u): called for msg %p\n", mythreadno, mp);
10747c478bd9Sstevel@tonic-gate 
10757c478bd9Sstevel@tonic-gate 	mp->flags = NETWORK;
10767c478bd9Sstevel@tonic-gate 	(void) time(&mp->ts);
10777c478bd9Sstevel@tonic-gate 
10787c478bd9Sstevel@tonic-gate 	/* test for special codes */
10797c478bd9Sstevel@tonic-gate 	pri = DEFUPRI;
10807c478bd9Sstevel@tonic-gate 	p = nbp->buf;
10817c478bd9Sstevel@tonic-gate 	DPRINT2(9, "formatnet(%u): Message content:\n>%s<\n", mythreadno,
10827c478bd9Sstevel@tonic-gate 		p);
10837c478bd9Sstevel@tonic-gate 	if (*p == '<' && isdigit(*(p+1))) {
10847c478bd9Sstevel@tonic-gate 		pri = 0;
10857c478bd9Sstevel@tonic-gate 		while (isdigit(*++p))
10867c478bd9Sstevel@tonic-gate 			pri = 10 * pri + (*p - '0');
10877c478bd9Sstevel@tonic-gate 		if (*p == '>')
10887c478bd9Sstevel@tonic-gate 			++p;
10897c478bd9Sstevel@tonic-gate 		if (pri <= 0 || pri >= (LOG_NFACILITIES << 3))
10907c478bd9Sstevel@tonic-gate 			pri = DEFUPRI;
10917c478bd9Sstevel@tonic-gate 	}
10927c478bd9Sstevel@tonic-gate 
10937c478bd9Sstevel@tonic-gate 	mp->pri = pri;
10947c478bd9Sstevel@tonic-gate 	(void) strlcpy(mp->msg, p, MAXLINE+1);
10957c478bd9Sstevel@tonic-gate }
10967c478bd9Sstevel@tonic-gate 
10977c478bd9Sstevel@tonic-gate /*
10987c478bd9Sstevel@tonic-gate  * Do some processing on messages generated by this host
10997c478bd9Sstevel@tonic-gate  * and then enqueue the log message.
11007c478bd9Sstevel@tonic-gate  */
11017c478bd9Sstevel@tonic-gate static void
11027c478bd9Sstevel@tonic-gate formatsys(struct log_ctl *lp, char *msg, int sync)
11037c478bd9Sstevel@tonic-gate {
11047c478bd9Sstevel@tonic-gate 	char *p, *q;
11057c478bd9Sstevel@tonic-gate 	char line[MAXLINE + 1];
11067c478bd9Sstevel@tonic-gate 	size_t msglen;
11077c478bd9Sstevel@tonic-gate 	log_message_t	*mp;
11087c478bd9Sstevel@tonic-gate 	char cbuf[30];
11097c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
11107c478bd9Sstevel@tonic-gate 
11117c478bd9Sstevel@tonic-gate 	if (Debug) {
11127c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
11137c478bd9Sstevel@tonic-gate 	}
11147c478bd9Sstevel@tonic-gate 
11157c478bd9Sstevel@tonic-gate 	DPRINT3(3, "formatsys(%u): log_ctl.mid = %d, log_ctl.sid = %d\n",
11167c478bd9Sstevel@tonic-gate 		mythreadno, lp->mid, lp->sid);
11177c478bd9Sstevel@tonic-gate 	DPRINT2(9, "formatsys(%u): Message Content:\n>%s<\n", mythreadno,
11187c478bd9Sstevel@tonic-gate 		msg);
11197c478bd9Sstevel@tonic-gate 
11207c478bd9Sstevel@tonic-gate 	/* msglen includes the null termination */
11217c478bd9Sstevel@tonic-gate 	msglen = strlen(msg) + 1;
11227c478bd9Sstevel@tonic-gate 
11237c478bd9Sstevel@tonic-gate 	for (p = msg; *p != '\0'; ) {
11247c478bd9Sstevel@tonic-gate 		size_t linelen;
11257c478bd9Sstevel@tonic-gate 		size_t len;
11267c478bd9Sstevel@tonic-gate 
11277c478bd9Sstevel@tonic-gate 		/*
11287c478bd9Sstevel@tonic-gate 		 * Allocate a log_message_t structure.
11297c478bd9Sstevel@tonic-gate 		 * We should do it here since a single message (msg)
11307c478bd9Sstevel@tonic-gate 		 * could be composed of many lines.
11317c478bd9Sstevel@tonic-gate 		 */
11327c478bd9Sstevel@tonic-gate 		_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp));
11337c478bd9Sstevel@tonic-gate 
11347c478bd9Sstevel@tonic-gate 		if ((mp = new_msg()) == NULL) {
11357c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("dropping message");
11367c478bd9Sstevel@tonic-gate 			/*
11377c478bd9Sstevel@tonic-gate 			 * Should bail out from the loop.
11387c478bd9Sstevel@tonic-gate 			 */
11397c478bd9Sstevel@tonic-gate 			break;
11407c478bd9Sstevel@tonic-gate 		}
11417c478bd9Sstevel@tonic-gate 
11427c478bd9Sstevel@tonic-gate 		mp->flags &= ~NETWORK;
11437c478bd9Sstevel@tonic-gate 		mp->hlp = &LocalHostName;
11447c478bd9Sstevel@tonic-gate 		mp->ts = lp->ttime;
11457c478bd9Sstevel@tonic-gate 		if (lp->flags & SL_LOGONLY)
11467c478bd9Sstevel@tonic-gate 			mp->flags |= IGN_CONS;
11477c478bd9Sstevel@tonic-gate 		if (lp->flags & SL_CONSONLY)
11487c478bd9Sstevel@tonic-gate 			mp->flags |= IGN_FILE;
11497c478bd9Sstevel@tonic-gate 
11507c478bd9Sstevel@tonic-gate 		/* extract facility */
11517c478bd9Sstevel@tonic-gate 		if ((lp->pri & LOG_FACMASK) == LOG_KERN) {
11527c478bd9Sstevel@tonic-gate 			(void) sprintf(line, "%.15s ",
11537c478bd9Sstevel@tonic-gate 				ctime_r(&mp->ts, cbuf) + 4);
11547c478bd9Sstevel@tonic-gate 		} else {
11557c478bd9Sstevel@tonic-gate 			(void) sprintf(line, "");
11567c478bd9Sstevel@tonic-gate 		}
11577c478bd9Sstevel@tonic-gate 
11587c478bd9Sstevel@tonic-gate 		linelen = strlen(line);
11597c478bd9Sstevel@tonic-gate 		q = line + linelen;
11607c478bd9Sstevel@tonic-gate 
11617c478bd9Sstevel@tonic-gate 		DPRINT2(5, "formatsys(%u): msglen = %d\n", mythreadno, msglen);
11627c478bd9Sstevel@tonic-gate 		len = copynl_frwd(q, MAXLINE + 1 - linelen, p, msglen);
11637c478bd9Sstevel@tonic-gate 		DPRINT2(5, "formatsys(%u): len (copynl_frwd) = %d\n",
11647c478bd9Sstevel@tonic-gate 			mythreadno, len);
11657c478bd9Sstevel@tonic-gate 
11667c478bd9Sstevel@tonic-gate 		p += len;
11677c478bd9Sstevel@tonic-gate 		msglen -= len;
11687c478bd9Sstevel@tonic-gate 
11697c478bd9Sstevel@tonic-gate 		if (*p == '\n') {
11707c478bd9Sstevel@tonic-gate 			/* skip newline */
11717c478bd9Sstevel@tonic-gate 			p++;
11727c478bd9Sstevel@tonic-gate 		}
11737c478bd9Sstevel@tonic-gate 
11747c478bd9Sstevel@tonic-gate 		if (sync && ((lp->pri & LOG_FACMASK) == LOG_KERN))
11757c478bd9Sstevel@tonic-gate 			mp->flags |= SYNC_FILE;	/* fsync file after write */
11767c478bd9Sstevel@tonic-gate 
11777c478bd9Sstevel@tonic-gate 		if (len != 0) {
11787c478bd9Sstevel@tonic-gate 			(void) strlcpy(mp->msg, line, MAXLINE+1);
11797c478bd9Sstevel@tonic-gate 			mp->pri = lp->pri;
11807c478bd9Sstevel@tonic-gate 
11817c478bd9Sstevel@tonic-gate 			if (dataq_enqueue(&inputq, (void *)mp) == -1) {
11827c478bd9Sstevel@tonic-gate 				free_msg(mp);
11837c478bd9Sstevel@tonic-gate 				MALLOC_FAIL("dropping message");
11847c478bd9Sstevel@tonic-gate 				break;
11857c478bd9Sstevel@tonic-gate 			}
11867c478bd9Sstevel@tonic-gate 
11877c478bd9Sstevel@tonic-gate 			DPRINT3(5, "formatsys(%u): sys_thread enqueued msg "
11887c478bd9Sstevel@tonic-gate 				"%p on queue %p\n", mythreadno, mp, &inputq);
11897c478bd9Sstevel@tonic-gate 		} else
11907c478bd9Sstevel@tonic-gate 			free_msg(mp);
11917c478bd9Sstevel@tonic-gate 	}
11927c478bd9Sstevel@tonic-gate }
11937c478bd9Sstevel@tonic-gate 
11947c478bd9Sstevel@tonic-gate /*
11957c478bd9Sstevel@tonic-gate  * Log a message to the appropriate log files, users, etc. based on
11967c478bd9Sstevel@tonic-gate  * the priority.
11977c478bd9Sstevel@tonic-gate  */
11987c478bd9Sstevel@tonic-gate /*ARGSUSED*/
11997c478bd9Sstevel@tonic-gate static void *
12007c478bd9Sstevel@tonic-gate logmsg(void *ap)
12017c478bd9Sstevel@tonic-gate {
12027c478bd9Sstevel@tonic-gate 	struct filed *f;
12037c478bd9Sstevel@tonic-gate 	int fac, prilev, flags, refcnt;
12047c478bd9Sstevel@tonic-gate 	int fake_shutdown, skip_shutdown;
12057c478bd9Sstevel@tonic-gate 	log_message_t *mp, *save_mp;
12067c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
12077c478bd9Sstevel@tonic-gate 
12087c478bd9Sstevel@tonic-gate 	if (Debug) {
12097c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
12107c478bd9Sstevel@tonic-gate 	}
12117c478bd9Sstevel@tonic-gate 
12127c478bd9Sstevel@tonic-gate 	DPRINT1(1, "logmsg(%u): msg dispatcher started\n", mythreadno);
12137c478bd9Sstevel@tonic-gate 
12147c478bd9Sstevel@tonic-gate 	fake_shutdown = skip_shutdown = 0;
12157c478bd9Sstevel@tonic-gate 	save_mp = NULL;
12167c478bd9Sstevel@tonic-gate 	for (;;) {
12177c478bd9Sstevel@tonic-gate 		if (save_mp) {
12187c478bd9Sstevel@tonic-gate 			/*
12197c478bd9Sstevel@tonic-gate 			 * If we have set aside a message in order to fake a
12207c478bd9Sstevel@tonic-gate 			 * SHUTDOWN, use that message before picking from the
12217c478bd9Sstevel@tonic-gate 			 * queue again.
12227c478bd9Sstevel@tonic-gate 			 */
12237c478bd9Sstevel@tonic-gate 			mp = save_mp;
12247c478bd9Sstevel@tonic-gate 			save_mp = NULL;
12257c478bd9Sstevel@tonic-gate 		} else {
12267c478bd9Sstevel@tonic-gate 			(void) dataq_dequeue(&inputq, (void **)&mp, 0);
12277c478bd9Sstevel@tonic-gate 		}
12287c478bd9Sstevel@tonic-gate 		_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mp))
12297c478bd9Sstevel@tonic-gate 		DPRINT3(5, "logmsg(%u): msg dispatcher dequeued %p from "
12307c478bd9Sstevel@tonic-gate 			"queue %p\n", mythreadno, mp, &inputq);
12317c478bd9Sstevel@tonic-gate 
12327c478bd9Sstevel@tonic-gate 		/*
12337c478bd9Sstevel@tonic-gate 		 * In most cases, if the message traffic is low, logmsg() wakes
12347c478bd9Sstevel@tonic-gate 		 * up when it receives the SHUTDOWN msg, and will sleep until
12357c478bd9Sstevel@tonic-gate 		 * HUP process is complete.  However, if the inputq is too
12367c478bd9Sstevel@tonic-gate 		 * long, logmsg() may not receive SHUTDOWN before reconfigure()
12377c478bd9Sstevel@tonic-gate 		 * releases the logger fds, filed and logit threads.  That, in
12387c478bd9Sstevel@tonic-gate 		 * turn, will cause logmsg to refer to invalid fileds.
12397c478bd9Sstevel@tonic-gate 		 *
12407c478bd9Sstevel@tonic-gate 		 * logmsg() needs to respond to the SHUTDOWN message within
12417c478bd9Sstevel@tonic-gate 		 * LOOP_INTERVAL seconds when reconfigure() enqueues it. It
12427c478bd9Sstevel@tonic-gate 		 * does so in most cases.  When it does not respond in time,
12437c478bd9Sstevel@tonic-gate 		 * logmsg() needs to be in suspended state immediately, since
12447c478bd9Sstevel@tonic-gate 		 * filed may have been invalidated. reconfigure() will set the
12457c478bd9Sstevel@tonic-gate 		 * HUP_SUSP_LOGMSG_REQD bit in hup_state and wait another
12467c478bd9Sstevel@tonic-gate 		 * LOOP_INTERVAL seconds before proceeding.
12477c478bd9Sstevel@tonic-gate 		 *
12487c478bd9Sstevel@tonic-gate 		 * When HUP_SUSP_LOGMSG_REQD is set, we will create a fake
12497c478bd9Sstevel@tonic-gate 		 * SHUTDOWN message, and dispatch it to the various logit
12507c478bd9Sstevel@tonic-gate 		 * threads, and logmsg() itself will suspend.  In order to
12517c478bd9Sstevel@tonic-gate 		 * ignore the real SHUTDOWN which will arrive later, we keep a
12527c478bd9Sstevel@tonic-gate 		 * counter (skip_shutdown) and decrement it when the SHUTDOWN
12537c478bd9Sstevel@tonic-gate 		 * message arrives.
12547c478bd9Sstevel@tonic-gate 		 */
12557c478bd9Sstevel@tonic-gate 		if ((hup_state & HUP_SUSP_LOGMSG_REQD) &&
12567c478bd9Sstevel@tonic-gate 			(mp->flags & SHUTDOWN) == 0) {
12577c478bd9Sstevel@tonic-gate 			DPRINT1(3, "logmsg(%u): suspend request\n",
12587c478bd9Sstevel@tonic-gate 				mythreadno);
12597c478bd9Sstevel@tonic-gate 
12607c478bd9Sstevel@tonic-gate 			save_mp = mp;
12617c478bd9Sstevel@tonic-gate 
12627c478bd9Sstevel@tonic-gate 			/* create a fake SHUTDOWN msg */
12637c478bd9Sstevel@tonic-gate 			if ((mp = new_msg()) == NULL) {
12647c478bd9Sstevel@tonic-gate 				MALLOC_FAIL("dropping message");
12657c478bd9Sstevel@tonic-gate 				if (mp->flags & SHUTDOWN) {
12667c478bd9Sstevel@tonic-gate 					(void) logerror_to_console(1,
12677c478bd9Sstevel@tonic-gate 						"unable to shutdown "
12687c478bd9Sstevel@tonic-gate 						"logger thread");
12697c478bd9Sstevel@tonic-gate 				}
12707c478bd9Sstevel@tonic-gate 				continue;
12717c478bd9Sstevel@tonic-gate 			}
12727c478bd9Sstevel@tonic-gate 			mp->flags = SHUTDOWN;
12737c478bd9Sstevel@tonic-gate 			mp->hlp = &LocalHostName;
12747c478bd9Sstevel@tonic-gate 			fake_shutdown = 1;
12757c478bd9Sstevel@tonic-gate 			skip_shutdown++;
12767c478bd9Sstevel@tonic-gate 			DPRINT2(3, "logmsg(%u): pending SHUTDOWN %d\n",
12777c478bd9Sstevel@tonic-gate 				mythreadno, skip_shutdown);
12787c478bd9Sstevel@tonic-gate 		}
12797c478bd9Sstevel@tonic-gate 
12807c478bd9Sstevel@tonic-gate 		/*
12817c478bd9Sstevel@tonic-gate 		 * is it a shutdown or flush message ?
12827c478bd9Sstevel@tonic-gate 		 */
12837c478bd9Sstevel@tonic-gate 		if ((mp->flags & SHUTDOWN) || (mp->flags & FLUSHMSG)) {
12847c478bd9Sstevel@tonic-gate 			pthread_mutex_lock(&mp->msg_mutex);
12857c478bd9Sstevel@tonic-gate 
12867c478bd9Sstevel@tonic-gate 			if ((mp->flags & SHUTDOWN) &&
12877c478bd9Sstevel@tonic-gate 				!fake_shutdown && skip_shutdown > 0) {
12887c478bd9Sstevel@tonic-gate 				skip_shutdown--;
12897c478bd9Sstevel@tonic-gate 				pthread_mutex_unlock(&mp->msg_mutex);
12907c478bd9Sstevel@tonic-gate 				free_msg(mp);
12917c478bd9Sstevel@tonic-gate 				DPRINT2(3, "logmsg(%u): released late "
12927c478bd9Sstevel@tonic-gate 					"arrived SHUTDOWN. pending %d\n",
12937c478bd9Sstevel@tonic-gate 					mythreadno, skip_shutdown);
12947c478bd9Sstevel@tonic-gate 				continue;
12957c478bd9Sstevel@tonic-gate 			}
12967c478bd9Sstevel@tonic-gate 
12977c478bd9Sstevel@tonic-gate 			for (f = Files; f < &Files[nlogs]; f++) {
12987c478bd9Sstevel@tonic-gate 				pthread_mutex_lock(&f->filed_mutex);
12997c478bd9Sstevel@tonic-gate 
13007c478bd9Sstevel@tonic-gate 				if (f->f_type == F_UNUSED) {
13017c478bd9Sstevel@tonic-gate 					pthread_mutex_unlock(&f->filed_mutex);
13027c478bd9Sstevel@tonic-gate 					continue;
13037c478bd9Sstevel@tonic-gate 				}
13047c478bd9Sstevel@tonic-gate 
13057c478bd9Sstevel@tonic-gate 				f->f_queue_count++;
13067c478bd9Sstevel@tonic-gate 				mp->refcnt++;
13077c478bd9Sstevel@tonic-gate 
13087c478bd9Sstevel@tonic-gate 				if (dataq_enqueue(&f->f_queue,
13097c478bd9Sstevel@tonic-gate 					(void *)mp) == -1) {
13107c478bd9Sstevel@tonic-gate 					f->f_queue_count--;
13117c478bd9Sstevel@tonic-gate 					mp->refcnt--;
13127c478bd9Sstevel@tonic-gate 					pthread_mutex_unlock(&f->filed_mutex);
13137c478bd9Sstevel@tonic-gate 					MALLOC_FAIL("dropping message");
13147c478bd9Sstevel@tonic-gate 
13157c478bd9Sstevel@tonic-gate 					if (mp->flags & SHUTDOWN) {
13167c478bd9Sstevel@tonic-gate 						(void) logerror_to_console(1,
13177c478bd9Sstevel@tonic-gate 							"unable to shutdown "
13187c478bd9Sstevel@tonic-gate 							"logger thread");
13197c478bd9Sstevel@tonic-gate 					}
13207c478bd9Sstevel@tonic-gate 
13217c478bd9Sstevel@tonic-gate 					continue;
13227c478bd9Sstevel@tonic-gate 				}
13237c478bd9Sstevel@tonic-gate 				DPRINT3(5, "logmsg(%u): enqueued msg %p "
13247c478bd9Sstevel@tonic-gate 					"on queue %p\n", mythreadno, mp,
13257c478bd9Sstevel@tonic-gate 					&f->f_queue);
13267c478bd9Sstevel@tonic-gate 				pthread_mutex_unlock(&f->filed_mutex);
13277c478bd9Sstevel@tonic-gate 			}
13287c478bd9Sstevel@tonic-gate 
13297c478bd9Sstevel@tonic-gate 			/*
13307c478bd9Sstevel@tonic-gate 			 * flags value needs to be saved because mp may
13317c478bd9Sstevel@tonic-gate 			 * have been freed before SHUTDOWN test below.
13327c478bd9Sstevel@tonic-gate 			 */
13337c478bd9Sstevel@tonic-gate 			flags = mp->flags;
13347c478bd9Sstevel@tonic-gate 			refcnt = mp->refcnt;
13357c478bd9Sstevel@tonic-gate 
13367c478bd9Sstevel@tonic-gate 			pthread_mutex_unlock(&mp->msg_mutex);
13377c478bd9Sstevel@tonic-gate 			if (refcnt == 0)
13387c478bd9Sstevel@tonic-gate 				free_msg(mp);
13397c478bd9Sstevel@tonic-gate 
13407c478bd9Sstevel@tonic-gate 			if (flags & SHUTDOWN) {
13417c478bd9Sstevel@tonic-gate 				pthread_mutex_lock(&hup_lock);
13427c478bd9Sstevel@tonic-gate 				while (hup_state != HUP_COMPLETED) {
13437c478bd9Sstevel@tonic-gate 					hup_state |= HUP_LOGMSG_SUSPENDED;
13447c478bd9Sstevel@tonic-gate 					(void) pthread_cond_wait(&hup_done,
13457c478bd9Sstevel@tonic-gate 						&hup_lock);
13467c478bd9Sstevel@tonic-gate 					hup_state &= ~HUP_LOGMSG_SUSPENDED;
13477c478bd9Sstevel@tonic-gate 				}
13487c478bd9Sstevel@tonic-gate 				hup_state = HUP_ACCEPTABLE;
13497c478bd9Sstevel@tonic-gate 				pthread_mutex_unlock(&hup_lock);
13507c478bd9Sstevel@tonic-gate 				fake_shutdown = 0;
13517c478bd9Sstevel@tonic-gate 			}
13527c478bd9Sstevel@tonic-gate 			continue;
13537c478bd9Sstevel@tonic-gate 		}
13547c478bd9Sstevel@tonic-gate 
13557c478bd9Sstevel@tonic-gate 		/*
13567c478bd9Sstevel@tonic-gate 		 * Check to see if msg looks non-standard.
13577c478bd9Sstevel@tonic-gate 		 */
13587c478bd9Sstevel@tonic-gate 		if ((int)strlen(mp->msg) < 16 || mp->msg[3] != ' ' ||
13597c478bd9Sstevel@tonic-gate 			mp->msg[6] != ' ' || mp->msg[9] != ':' ||
13607c478bd9Sstevel@tonic-gate 			mp->msg[12] != ':' || mp->msg[15] != ' ')
13617c478bd9Sstevel@tonic-gate 			mp->flags |= ADDDATE;
13627c478bd9Sstevel@tonic-gate 
13637c478bd9Sstevel@tonic-gate 		/* extract facility and priority level */
13647c478bd9Sstevel@tonic-gate 		fac = (mp->pri & LOG_FACMASK) >> 3;
13657c478bd9Sstevel@tonic-gate 		if (mp->flags & MARK)
13667c478bd9Sstevel@tonic-gate 			fac = LOG_NFACILITIES;
13677c478bd9Sstevel@tonic-gate 		prilev = mp->pri & LOG_PRIMASK;
13687c478bd9Sstevel@tonic-gate 
13697c478bd9Sstevel@tonic-gate 		DPRINT3(3, "logmsg(%u): fac = %d, pri = %d\n",
13707c478bd9Sstevel@tonic-gate 			mythreadno, fac, prilev);
13717c478bd9Sstevel@tonic-gate 
13727c478bd9Sstevel@tonic-gate 		/*
13737c478bd9Sstevel@tonic-gate 		 * Because different devices log at different speeds,
13747c478bd9Sstevel@tonic-gate 		 * it's important to hold the mutex for the current
13757c478bd9Sstevel@tonic-gate 		 * message until it's been enqueued to all log files,
13767c478bd9Sstevel@tonic-gate 		 * so the reference count is accurate before any
13777c478bd9Sstevel@tonic-gate 		 * of the log threads can decrement it.
13787c478bd9Sstevel@tonic-gate 		 */
13797c478bd9Sstevel@tonic-gate 		_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mp))
13807c478bd9Sstevel@tonic-gate 		_NOTE(COMPETING_THREADS_NOW)
13817c478bd9Sstevel@tonic-gate 		pthread_mutex_lock(&mp->msg_mutex);
13827c478bd9Sstevel@tonic-gate 
13837c478bd9Sstevel@tonic-gate 		for (f = Files; f < &Files[nlogs]; f++) {
13847c478bd9Sstevel@tonic-gate 			/* skip messages that are incorrect priority */
13857c478bd9Sstevel@tonic-gate 			if (f->f_pmask[fac] < (unsigned)prilev ||
13867c478bd9Sstevel@tonic-gate 				f->f_pmask[fac] == NOPRI)
13877c478bd9Sstevel@tonic-gate 				continue;
13887c478bd9Sstevel@tonic-gate 			if (f->f_queue_count > Q_HIGHWATER_MARK) {
13897c478bd9Sstevel@tonic-gate 				DPRINT4(5, "logmsg(%u): Dropping message "
13907c478bd9Sstevel@tonic-gate 					"%p on file %p, count = %d\n",
13917c478bd9Sstevel@tonic-gate 					mythreadno, mp, f,
13927c478bd9Sstevel@tonic-gate 					f->f_queue_count);
13937c478bd9Sstevel@tonic-gate 				continue;
13947c478bd9Sstevel@tonic-gate 			}
13957c478bd9Sstevel@tonic-gate 
13967c478bd9Sstevel@tonic-gate 			/*
13977c478bd9Sstevel@tonic-gate 			 * Need to grab filed_mutex before testing the f_type.
13987c478bd9Sstevel@tonic-gate 			 * Otherwise logit() may set F_UNUSED after the test
13997c478bd9Sstevel@tonic-gate 			 * below, and start pulling out the pending messages.
14007c478bd9Sstevel@tonic-gate 			 */
14017c478bd9Sstevel@tonic-gate 
14027c478bd9Sstevel@tonic-gate 			pthread_mutex_lock(&f->filed_mutex);
14037c478bd9Sstevel@tonic-gate 
14047c478bd9Sstevel@tonic-gate 			if (f->f_type == F_UNUSED ||
14057c478bd9Sstevel@tonic-gate 			    (f->f_type == F_FILE && (mp->flags & IGN_FILE)) ||
14067c478bd9Sstevel@tonic-gate 			    (f->f_type == F_CONSOLE &&
14077c478bd9Sstevel@tonic-gate 				(mp->flags & IGN_CONS))) {
14087c478bd9Sstevel@tonic-gate 				pthread_mutex_unlock(&f->filed_mutex);
14097c478bd9Sstevel@tonic-gate 				continue;
14107c478bd9Sstevel@tonic-gate 			}
14117c478bd9Sstevel@tonic-gate 
14127c478bd9Sstevel@tonic-gate 			f->f_queue_count++;
14137c478bd9Sstevel@tonic-gate 			mp->refcnt++;
14147c478bd9Sstevel@tonic-gate 
14157c478bd9Sstevel@tonic-gate 			if (dataq_enqueue(&f->f_queue, (void *)mp) == -1) {
14167c478bd9Sstevel@tonic-gate 				f->f_queue_count--;
14177c478bd9Sstevel@tonic-gate 				mp->refcnt--;
14187c478bd9Sstevel@tonic-gate 				pthread_mutex_unlock(&f->filed_mutex);
14197c478bd9Sstevel@tonic-gate 				MALLOC_FAIL("dropping message");
14207c478bd9Sstevel@tonic-gate 				continue;
14217c478bd9Sstevel@tonic-gate 			}
14227c478bd9Sstevel@tonic-gate 
14237c478bd9Sstevel@tonic-gate 			DPRINT3(5, "logmsg(%u): enqueued msg %p on queue "
14247c478bd9Sstevel@tonic-gate 				"%p\n", mythreadno, mp, &f->f_queue);
14257c478bd9Sstevel@tonic-gate 			pthread_mutex_unlock(&f->filed_mutex);
14267c478bd9Sstevel@tonic-gate 		}
14277c478bd9Sstevel@tonic-gate 		refcnt = mp->refcnt;
14287c478bd9Sstevel@tonic-gate 		pthread_mutex_unlock(&mp->msg_mutex);
14297c478bd9Sstevel@tonic-gate 		if (refcnt == 0)
14307c478bd9Sstevel@tonic-gate 			free_msg(mp);
14317c478bd9Sstevel@tonic-gate 	}
14327c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
14337c478bd9Sstevel@tonic-gate 	return (NULL);
14347c478bd9Sstevel@tonic-gate }
14357c478bd9Sstevel@tonic-gate 
14367c478bd9Sstevel@tonic-gate /*
14377c478bd9Sstevel@tonic-gate  * function to actually write the log message to the selected file.
14387c478bd9Sstevel@tonic-gate  * each file has a logger thread that runs this routine. The function
14397c478bd9Sstevel@tonic-gate  * is called with a pointer to its file structure.
14407c478bd9Sstevel@tonic-gate  */
14417c478bd9Sstevel@tonic-gate static void *
14427c478bd9Sstevel@tonic-gate logit(void *ap)
14437c478bd9Sstevel@tonic-gate {
14447c478bd9Sstevel@tonic-gate 	struct filed *f = ap;
14457c478bd9Sstevel@tonic-gate 	log_message_t *mp;
14467c478bd9Sstevel@tonic-gate 	int forwardingloop = 0;
14477c478bd9Sstevel@tonic-gate 	char *errmsg = "logit(%u): %s to %s forwarding loop detected\n";
14487c478bd9Sstevel@tonic-gate 	int i, currofst, prevofst, refcnt;
14497c478bd9Sstevel@tonic-gate 	host_list_t *hlp;
14507c478bd9Sstevel@tonic-gate 
14517c478bd9Sstevel@tonic-gate 	assert(f != NULL);
14527c478bd9Sstevel@tonic-gate 
14537c478bd9Sstevel@tonic-gate 	DPRINT4(5, "logit(%u): logger started for \"%s\" (queue %p, filed "
14547c478bd9Sstevel@tonic-gate 		"%p)\n", f->f_thread, f->f_un.f_fname, &f->f_queue, f);
14557c478bd9Sstevel@tonic-gate 	_NOTE(COMPETING_THREADS_NOW);
14567c478bd9Sstevel@tonic-gate 
14577c478bd9Sstevel@tonic-gate 	while (f->f_type != F_UNUSED) {
14587c478bd9Sstevel@tonic-gate 		(void) dataq_dequeue(&f->f_queue, (void **)&mp, 0);
14597c478bd9Sstevel@tonic-gate 		DPRINT3(5, "logit(%u): logger dequeued msg %p from queue "
14607c478bd9Sstevel@tonic-gate 			"%p\n",
14617c478bd9Sstevel@tonic-gate 			f->f_thread, mp, &f->f_queue);
14627c478bd9Sstevel@tonic-gate 		pthread_mutex_lock(&f->filed_mutex);
14637c478bd9Sstevel@tonic-gate 		assert(f->f_queue_count > 0);
14647c478bd9Sstevel@tonic-gate 		f->f_queue_count--;
14657c478bd9Sstevel@tonic-gate 		pthread_mutex_unlock(&f->filed_mutex);
14667c478bd9Sstevel@tonic-gate 		assert(mp->refcnt > 0);
14677c478bd9Sstevel@tonic-gate 
14687c478bd9Sstevel@tonic-gate 		/*
14697c478bd9Sstevel@tonic-gate 		 * is it a shutdown message ?
14707c478bd9Sstevel@tonic-gate 		 */
14717c478bd9Sstevel@tonic-gate 		if (mp->flags & SHUTDOWN) {
14727c478bd9Sstevel@tonic-gate 			pthread_mutex_lock(&mp->msg_mutex);
14737c478bd9Sstevel@tonic-gate 			refcnt = --mp->refcnt;
14747c478bd9Sstevel@tonic-gate 			pthread_mutex_unlock(&mp->msg_mutex);
14757c478bd9Sstevel@tonic-gate 			if (refcnt == 0)
14767c478bd9Sstevel@tonic-gate 				free_msg(mp);
14777c478bd9Sstevel@tonic-gate 			break;
14787c478bd9Sstevel@tonic-gate 		}
14797c478bd9Sstevel@tonic-gate 
14807c478bd9Sstevel@tonic-gate 		/*
14817c478bd9Sstevel@tonic-gate 		 * Is it a logsync message?
14827c478bd9Sstevel@tonic-gate 		 */
14837c478bd9Sstevel@tonic-gate 		if ((mp->flags & (FLUSHMSG | LOGSYNC)) ==
14847c478bd9Sstevel@tonic-gate 		    (FLUSHMSG | LOGSYNC)) {
14857c478bd9Sstevel@tonic-gate 			if (f->f_type != F_FILE)
14867c478bd9Sstevel@tonic-gate 				goto out;	/* nothing to do */
14877c478bd9Sstevel@tonic-gate 			(void) close(f->f_file);
14887c478bd9Sstevel@tonic-gate 			f->f_file = open64(f->f_un.f_fname,
14897c478bd9Sstevel@tonic-gate 					O_WRONLY|O_APPEND|O_NOCTTY);
14907c478bd9Sstevel@tonic-gate 			if (f->f_file < 0) {
14917c478bd9Sstevel@tonic-gate 				f->f_type = F_UNUSED;
14927c478bd9Sstevel@tonic-gate 				logerror(f->f_un.f_fname);
14937c478bd9Sstevel@tonic-gate 				f->f_stat.errs++;
14947c478bd9Sstevel@tonic-gate 			}
14957c478bd9Sstevel@tonic-gate 			goto out;
14967c478bd9Sstevel@tonic-gate 		}
14977c478bd9Sstevel@tonic-gate 
14987c478bd9Sstevel@tonic-gate 		/*
14997c478bd9Sstevel@tonic-gate 		 * If the message flags include both flush and sync,
15007c478bd9Sstevel@tonic-gate 		 * then just sync the file out to disk if appropriate.
15017c478bd9Sstevel@tonic-gate 		 */
15027c478bd9Sstevel@tonic-gate 		if ((mp->flags & (FLUSHMSG | SYNC_FILE)) ==
15037c478bd9Sstevel@tonic-gate 		    (FLUSHMSG | SYNC_FILE)) {
15047c478bd9Sstevel@tonic-gate 			if (f->f_type == F_FILE) {
15057c478bd9Sstevel@tonic-gate 				DPRINT2(5, "logit(%u): got FLUSH|SYNC "
15067c478bd9Sstevel@tonic-gate 					"for filed %p\n", f->f_thread,
15077c478bd9Sstevel@tonic-gate 					f);
15087c478bd9Sstevel@tonic-gate 				(void) fsync(f->f_file);
15097c478bd9Sstevel@tonic-gate 			}
15107c478bd9Sstevel@tonic-gate 			goto out;
15117c478bd9Sstevel@tonic-gate 		}
15127c478bd9Sstevel@tonic-gate 
15137c478bd9Sstevel@tonic-gate 		/*
15147c478bd9Sstevel@tonic-gate 		 * Otherwise if it's a standard flush message, write
15157c478bd9Sstevel@tonic-gate 		 * out any saved messages to the file.
15167c478bd9Sstevel@tonic-gate 		 */
15177c478bd9Sstevel@tonic-gate 		if ((mp->flags & FLUSHMSG) && (f->f_prevcount > 0)) {
15187c478bd9Sstevel@tonic-gate 			set_flush_msg(f);
15197c478bd9Sstevel@tonic-gate 			writemsg(SAVED, f);
15207c478bd9Sstevel@tonic-gate 			goto out;
15217c478bd9Sstevel@tonic-gate 		}
15227c478bd9Sstevel@tonic-gate 
15237c478bd9Sstevel@tonic-gate 		(void) strlcpy(f->f_current.msg, mp->msg, MAXLINE+1);
15247c478bd9Sstevel@tonic-gate 		(void) strlcpy(f->f_current.host, mp->hlp->hl_hosts[0],
15257c478bd9Sstevel@tonic-gate 				SYS_NMLN);
15267c478bd9Sstevel@tonic-gate 		f->f_current.pri = mp->pri;
15277c478bd9Sstevel@tonic-gate 		f->f_current.flags = mp->flags;
15287c478bd9Sstevel@tonic-gate 		f->f_current.time = mp->ts;
15297c478bd9Sstevel@tonic-gate 		f->f_msgflag &= ~CURRENT_VALID;
15307c478bd9Sstevel@tonic-gate 		hlp = mp->hlp;
15317c478bd9Sstevel@tonic-gate 
15327c478bd9Sstevel@tonic-gate 		prevofst = (f->f_prevmsg.flags & ADDDATE) ? 0 : 16;
15337c478bd9Sstevel@tonic-gate 		currofst = (f->f_current.flags & ADDDATE) ? 0 : 16;
15347c478bd9Sstevel@tonic-gate 
15357c478bd9Sstevel@tonic-gate 		if (f->f_type == F_FORW) {
15367c478bd9Sstevel@tonic-gate 			/*
15377c478bd9Sstevel@tonic-gate 			 * Should not forward MARK messages, as they are
15387c478bd9Sstevel@tonic-gate 			 * not defined outside of the current system.
15397c478bd9Sstevel@tonic-gate 			 */
15407c478bd9Sstevel@tonic-gate 
15417c478bd9Sstevel@tonic-gate 			if (mp->flags & MARK) {
15427c478bd9Sstevel@tonic-gate 				DPRINT1(1, "logit(%u): cannot forward "
15437c478bd9Sstevel@tonic-gate 					"Mark\n", f->f_thread);
15447c478bd9Sstevel@tonic-gate 				goto out;
15457c478bd9Sstevel@tonic-gate 			}
15467c478bd9Sstevel@tonic-gate 
15477c478bd9Sstevel@tonic-gate 			/*
15487c478bd9Sstevel@tonic-gate 			 * can not forward message if we do
15497c478bd9Sstevel@tonic-gate 			 * not have a host to forward to
15507c478bd9Sstevel@tonic-gate 			 */
15517c478bd9Sstevel@tonic-gate 			if (hlp == (host_list_t *)NULL)
15527c478bd9Sstevel@tonic-gate 				goto out;
15537c478bd9Sstevel@tonic-gate 			/*
15547c478bd9Sstevel@tonic-gate 			 * a forwarding loop is created on machines
15557c478bd9Sstevel@tonic-gate 			 * with multiple interfaces because the
15567c478bd9Sstevel@tonic-gate 			 * network address of the sender is different
15577c478bd9Sstevel@tonic-gate 			 * to the receiver even though it is the
15587c478bd9Sstevel@tonic-gate 			 * same machine. Instead, if the
15597c478bd9Sstevel@tonic-gate 			 * hostname the source and target are
15607c478bd9Sstevel@tonic-gate 			 * the same the message if thrown away
15617c478bd9Sstevel@tonic-gate 			 */
15627c478bd9Sstevel@tonic-gate 			forwardingloop = 0;
15637c478bd9Sstevel@tonic-gate 			for (i = 0; i < hlp->hl_cnt; i++) {
15647c478bd9Sstevel@tonic-gate 				if (strcmp(hlp->hl_hosts[i],
15657c478bd9Sstevel@tonic-gate 					f->f_un.f_forw.f_hname) == 0) {
15667c478bd9Sstevel@tonic-gate 					DPRINT3(1, errmsg, f->f_thread,
15677c478bd9Sstevel@tonic-gate 						f->f_un.f_forw.f_hname,
15687c478bd9Sstevel@tonic-gate 						hlp->hl_hosts[i]);
15697c478bd9Sstevel@tonic-gate 					forwardingloop = 1;
15707c478bd9Sstevel@tonic-gate 					break;
15717c478bd9Sstevel@tonic-gate 				}
15727c478bd9Sstevel@tonic-gate 			}
15737c478bd9Sstevel@tonic-gate 
15747c478bd9Sstevel@tonic-gate 			if (forwardingloop == 1) {
15757c478bd9Sstevel@tonic-gate 				f->f_stat.cantfwd++;
15767c478bd9Sstevel@tonic-gate 				goto out;
15777c478bd9Sstevel@tonic-gate 			}
15787c478bd9Sstevel@tonic-gate 		}
15797c478bd9Sstevel@tonic-gate 
15807c478bd9Sstevel@tonic-gate 		f->f_msgflag |= CURRENT_VALID;
15817c478bd9Sstevel@tonic-gate 
15827c478bd9Sstevel@tonic-gate 		/* check for dup message */
15837c478bd9Sstevel@tonic-gate 		if (f->f_type != F_FORW &&
15847c478bd9Sstevel@tonic-gate 			(f->f_msgflag & OLD_VALID) &&
15857c478bd9Sstevel@tonic-gate 			prevofst == currofst &&
15867c478bd9Sstevel@tonic-gate 			(strcmp(f->f_prevmsg.msg + prevofst,
15877c478bd9Sstevel@tonic-gate 				f->f_current.msg + currofst) == 0) &&
15887c478bd9Sstevel@tonic-gate 			(strcmp(f->f_prevmsg.host,
15897c478bd9Sstevel@tonic-gate 				f->f_current.host) == 0)) {
15907c478bd9Sstevel@tonic-gate 			/* a dup */
15917c478bd9Sstevel@tonic-gate 			DPRINT2(2, "logit(%u): msg is dup - %p\n",
15927c478bd9Sstevel@tonic-gate 				f->f_thread, mp);
15937c478bd9Sstevel@tonic-gate 			if (currofst == 16) {
15947c478bd9Sstevel@tonic-gate 				(void) strncpy(f->f_prevmsg.msg,
15957c478bd9Sstevel@tonic-gate 				f->f_current.msg, 15); /* update time */
15967c478bd9Sstevel@tonic-gate 			}
15977c478bd9Sstevel@tonic-gate 			f->f_prevcount++;
15987c478bd9Sstevel@tonic-gate 			f->f_stat.dups++;
15997c478bd9Sstevel@tonic-gate 			f->f_stat.total++;
16007c478bd9Sstevel@tonic-gate 			f->f_msgflag &= ~CURRENT_VALID;
16017c478bd9Sstevel@tonic-gate 		} else {
16027c478bd9Sstevel@tonic-gate 			/* new: mark or prior dups exist */
16037c478bd9Sstevel@tonic-gate 			if (f->f_current.flags & MARK || f->f_prevcount > 0) {
16047c478bd9Sstevel@tonic-gate 				if (f->f_prevcount > 0 && f->f_type != F_FORW) {
16057c478bd9Sstevel@tonic-gate 					set_flush_msg(f);
16067c478bd9Sstevel@tonic-gate 					if (f->f_msgflag & OLD_VALID) {
16077c478bd9Sstevel@tonic-gate 						writemsg(SAVED, f);
16087c478bd9Sstevel@tonic-gate 					}
16097c478bd9Sstevel@tonic-gate 				}
16107c478bd9Sstevel@tonic-gate 				if (f->f_msgflag & CURRENT_VALID)
16117c478bd9Sstevel@tonic-gate 					writemsg(CURRENT, f);
16127c478bd9Sstevel@tonic-gate 				if (!(mp->flags & NOCOPY))
16137c478bd9Sstevel@tonic-gate 					copy_msg(f);
16147c478bd9Sstevel@tonic-gate 				if (f->f_current.flags & MARK) {
16157c478bd9Sstevel@tonic-gate 					DPRINT2(2, "logit(%u): msg is "
16167c478bd9Sstevel@tonic-gate 						"mark - %p)\n",
16177c478bd9Sstevel@tonic-gate 						f->f_thread, mp);
16187c478bd9Sstevel@tonic-gate 					f->f_msgflag &= ~OLD_VALID;
16197c478bd9Sstevel@tonic-gate 				} else {
16207c478bd9Sstevel@tonic-gate 					DPRINT2(2, "logit(%u): saving "
16217c478bd9Sstevel@tonic-gate 						"message - %p\n",
16227c478bd9Sstevel@tonic-gate 						f->f_thread, mp);
16237c478bd9Sstevel@tonic-gate 				}
16247c478bd9Sstevel@tonic-gate 				f->f_stat.total++;
16257c478bd9Sstevel@tonic-gate 			} else { /* new message */
16267c478bd9Sstevel@tonic-gate 				DPRINT2(2, "logit(%u): msg is new "
16277c478bd9Sstevel@tonic-gate 					"- %p\n", f->f_thread, mp);
16287c478bd9Sstevel@tonic-gate 				writemsg(CURRENT, f);
16297c478bd9Sstevel@tonic-gate 				if (!(mp->flags & NOCOPY))
16307c478bd9Sstevel@tonic-gate 					copy_msg(f);
16317c478bd9Sstevel@tonic-gate 				f->f_stat.total++;
16327c478bd9Sstevel@tonic-gate 			}
16337c478bd9Sstevel@tonic-gate 		}
16347c478bd9Sstevel@tonic-gate 		/*
16357c478bd9Sstevel@tonic-gate 		 * if message refcnt goes to zero after we decrement
16367c478bd9Sstevel@tonic-gate 		 * it here, we are the last consumer of the message,
16377c478bd9Sstevel@tonic-gate 		 * and we should free it.  We need to hold the lock
16387c478bd9Sstevel@tonic-gate 		 * between decrementing the count and checking for
16397c478bd9Sstevel@tonic-gate 		 * zero so another thread doesn't beat us to it.
16407c478bd9Sstevel@tonic-gate 		 */
16417c478bd9Sstevel@tonic-gate out:
16427c478bd9Sstevel@tonic-gate 		pthread_mutex_lock(&mp->msg_mutex);
16437c478bd9Sstevel@tonic-gate 		refcnt = --mp->refcnt;
16447c478bd9Sstevel@tonic-gate 		pthread_mutex_unlock(&mp->msg_mutex);
16457c478bd9Sstevel@tonic-gate 		if (refcnt == 0)
16467c478bd9Sstevel@tonic-gate 			free_msg(mp);
16477c478bd9Sstevel@tonic-gate 	}
16487c478bd9Sstevel@tonic-gate 	/* register our exit */
16497c478bd9Sstevel@tonic-gate 
16507c478bd9Sstevel@tonic-gate 	/*
16517c478bd9Sstevel@tonic-gate 	 * Pull out all pending messages, if they exist.
16527c478bd9Sstevel@tonic-gate 	 */
16537c478bd9Sstevel@tonic-gate 
16547c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&f->filed_mutex);
16557c478bd9Sstevel@tonic-gate 
16567c478bd9Sstevel@tonic-gate 	while (f->f_queue_count > 0) {
16577c478bd9Sstevel@tonic-gate 		(void) dataq_dequeue(&f->f_queue, (void **)&mp, 0);
16587c478bd9Sstevel@tonic-gate 		DPRINT3(5, "logit(%u): logger dequeued msg %p from queue "
16597c478bd9Sstevel@tonic-gate 			"%p\n",
16607c478bd9Sstevel@tonic-gate 			f->f_thread, mp, &f->f_queue);
16617c478bd9Sstevel@tonic-gate 		pthread_mutex_lock(&mp->msg_mutex);
16627c478bd9Sstevel@tonic-gate 		refcnt = --mp->refcnt;
16637c478bd9Sstevel@tonic-gate 		pthread_mutex_unlock(&mp->msg_mutex);
16647c478bd9Sstevel@tonic-gate 		if (refcnt == 0)
16657c478bd9Sstevel@tonic-gate 			free_msg(mp);
16667c478bd9Sstevel@tonic-gate 		f->f_queue_count--;
16677c478bd9Sstevel@tonic-gate 	}
16687c478bd9Sstevel@tonic-gate 
16697c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&f->filed_mutex);
16707c478bd9Sstevel@tonic-gate 
16717c478bd9Sstevel@tonic-gate 	if (f->f_type != F_USERS && f->f_type != F_WALL &&
16727c478bd9Sstevel@tonic-gate 		f->f_type != F_UNUSED) {
16737c478bd9Sstevel@tonic-gate 		if (f->f_type == F_FORW)
16747c478bd9Sstevel@tonic-gate 			(void) t_close(f->f_file);
16757c478bd9Sstevel@tonic-gate 		else
16767c478bd9Sstevel@tonic-gate 			(void) close(f->f_file);
16777c478bd9Sstevel@tonic-gate 	}
16787c478bd9Sstevel@tonic-gate 
16797c478bd9Sstevel@tonic-gate 	/*
16807c478bd9Sstevel@tonic-gate 	 * Since f_type may have been changed before this point, we need
16817c478bd9Sstevel@tonic-gate 	 * to test orig_type.
16827c478bd9Sstevel@tonic-gate 	 */
16837c478bd9Sstevel@tonic-gate 	if (f->f_orig_type == F_FORW) {
16847c478bd9Sstevel@tonic-gate 		free(f->f_un.f_forw.f_addr.buf);
16857c478bd9Sstevel@tonic-gate 	}
16867c478bd9Sstevel@tonic-gate 
16877c478bd9Sstevel@tonic-gate 	f->f_type = F_UNUSED;
16887c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&cft);
16897c478bd9Sstevel@tonic-gate 	--conf_threads;
16907c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&cft);
16917c478bd9Sstevel@tonic-gate 	DPRINT1(5, "logit(%u): logging thread exited\n", f->f_thread);
16927c478bd9Sstevel@tonic-gate 	return (NULL);
16937c478bd9Sstevel@tonic-gate }
16947c478bd9Sstevel@tonic-gate 
16957c478bd9Sstevel@tonic-gate /*
16967c478bd9Sstevel@tonic-gate  * change the previous message to a flush message, stating how
16977c478bd9Sstevel@tonic-gate  * many repeats occurred since the last flush
16987c478bd9Sstevel@tonic-gate  */
16997c478bd9Sstevel@tonic-gate static void
17007c478bd9Sstevel@tonic-gate set_flush_msg(struct filed *f)
17017c478bd9Sstevel@tonic-gate {
17027c478bd9Sstevel@tonic-gate 	char tbuf[10];
17037c478bd9Sstevel@tonic-gate 	int prevofst = (f->f_prevmsg.flags & ADDDATE) ? 0 : 16;
17047c478bd9Sstevel@tonic-gate 
17057c478bd9Sstevel@tonic-gate 	if (f->f_prevcount == 1)
17067c478bd9Sstevel@tonic-gate 		(void) strncpy(tbuf, "time", sizeof (tbuf));
17077c478bd9Sstevel@tonic-gate 	else
17087c478bd9Sstevel@tonic-gate 		(void) strncpy(tbuf, "times", sizeof (tbuf));
17097c478bd9Sstevel@tonic-gate 
17107c478bd9Sstevel@tonic-gate 	(void) sprintf(f->f_prevmsg.msg+prevofst,
17117c478bd9Sstevel@tonic-gate 		"last message repeated %d %s", f->f_prevcount, tbuf);
17127c478bd9Sstevel@tonic-gate 	f->f_prevcount = 0;
17137c478bd9Sstevel@tonic-gate 	f->f_msgflag |= OLD_VALID;
17147c478bd9Sstevel@tonic-gate }
17157c478bd9Sstevel@tonic-gate 
17167c478bd9Sstevel@tonic-gate 
17177c478bd9Sstevel@tonic-gate /*
17187c478bd9Sstevel@tonic-gate  * the actual writing of the message is broken into a separate function
17197c478bd9Sstevel@tonic-gate  * because each file has a current and saved message associated with
17207c478bd9Sstevel@tonic-gate  * it (for duplicate message detection). It is necessary to be able
17217c478bd9Sstevel@tonic-gate  * to write either the saved message or the current message.
17227c478bd9Sstevel@tonic-gate  */
17237c478bd9Sstevel@tonic-gate static void
17247c478bd9Sstevel@tonic-gate writemsg(int selection, struct filed *f)
17257c478bd9Sstevel@tonic-gate {
17267c478bd9Sstevel@tonic-gate 	char *cp, *p;
17277c478bd9Sstevel@tonic-gate 	int pri;
17287c478bd9Sstevel@tonic-gate 	int flags;
17297c478bd9Sstevel@tonic-gate 	int l;
17307c478bd9Sstevel@tonic-gate 	time_t ts;
17317c478bd9Sstevel@tonic-gate 	struct t_unitdata ud;
17327c478bd9Sstevel@tonic-gate 	char *eomp, *eomp2, *from, *text, *msg;
17337c478bd9Sstevel@tonic-gate 	char line[MAXLINE*2];
17347c478bd9Sstevel@tonic-gate 	char head[MAXLINE+1];
17357c478bd9Sstevel@tonic-gate 	char tmpbuf[MAXLINE+1];
17367c478bd9Sstevel@tonic-gate 	char cbuf[30];
17377c478bd9Sstevel@tonic-gate 	char *filtered;
17387c478bd9Sstevel@tonic-gate 	char *msgid_start, *msgid_end;
17397c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
17407c478bd9Sstevel@tonic-gate 	size_t	hlen, filter_len;
17417c478bd9Sstevel@tonic-gate 
17427c478bd9Sstevel@tonic-gate 	if (Debug) {
17437c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
17447c478bd9Sstevel@tonic-gate 	}
17457c478bd9Sstevel@tonic-gate 
17467c478bd9Sstevel@tonic-gate 	switch (selection) {
17477c478bd9Sstevel@tonic-gate 	default:
17487c478bd9Sstevel@tonic-gate 	case CURRENT:		/* print current message */
17497c478bd9Sstevel@tonic-gate 		msg = f->f_current.msg;
17507c478bd9Sstevel@tonic-gate 		from = f->f_current.host;
17517c478bd9Sstevel@tonic-gate 		pri = f->f_current.pri;
17527c478bd9Sstevel@tonic-gate 		flags = f->f_current.flags;
17537c478bd9Sstevel@tonic-gate 		ts = f->f_current.time;
17547c478bd9Sstevel@tonic-gate 		f->f_msgflag &= ~CURRENT_VALID;
17557c478bd9Sstevel@tonic-gate 		break;
17567c478bd9Sstevel@tonic-gate 	case SAVED:		/* print saved message */
17577c478bd9Sstevel@tonic-gate 		msg = f->f_prevmsg.msg;
17587c478bd9Sstevel@tonic-gate 		from = f->f_prevmsg.host;
17597c478bd9Sstevel@tonic-gate 		pri = f->f_prevmsg.pri;
17607c478bd9Sstevel@tonic-gate 		flags = f->f_prevmsg.flags;
17617c478bd9Sstevel@tonic-gate 		ts = f->f_prevmsg.time;
17627c478bd9Sstevel@tonic-gate 		f->f_msgflag &= ~OLD_VALID;
17637c478bd9Sstevel@tonic-gate 		break;
17647c478bd9Sstevel@tonic-gate 	}
17657c478bd9Sstevel@tonic-gate 
17667c478bd9Sstevel@tonic-gate 	if (msg[0] == '\0')
17677c478bd9Sstevel@tonic-gate 		return;
17687c478bd9Sstevel@tonic-gate 
17697c478bd9Sstevel@tonic-gate 	cp = line;
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 	if (flags & ADDDATE)
17727c478bd9Sstevel@tonic-gate 		(void) strncpy(cp, ctime_r(&ts, cbuf) + 4, 15);
17737c478bd9Sstevel@tonic-gate 	else
17747c478bd9Sstevel@tonic-gate 		(void) strncpy(cp, msg, 15);
17757c478bd9Sstevel@tonic-gate 
17767c478bd9Sstevel@tonic-gate 	line[15] = '\0';
17777c478bd9Sstevel@tonic-gate 	(void) strcat(cp, " ");
17787c478bd9Sstevel@tonic-gate 	(void) strcat(cp, from);
17797c478bd9Sstevel@tonic-gate 	(void) strcat(cp, " ");
17807c478bd9Sstevel@tonic-gate 	text = cp + strlen(cp);
17817c478bd9Sstevel@tonic-gate 
17827c478bd9Sstevel@tonic-gate 	if (flags & ADDDATE)
17837c478bd9Sstevel@tonic-gate 		(void) strcat(cp, msg);
17847c478bd9Sstevel@tonic-gate 	else
17857c478bd9Sstevel@tonic-gate 		(void) strcat(cp, msg+16);
17867c478bd9Sstevel@tonic-gate 	DPRINT2(5, "writemsg(%u): text = \"%s\"\n", mythreadno, text);
17877c478bd9Sstevel@tonic-gate 
17887c478bd9Sstevel@tonic-gate 	errno = 0;
17897c478bd9Sstevel@tonic-gate 	t_errno = 0;
17907c478bd9Sstevel@tonic-gate 	switch (f->f_type) {
17917c478bd9Sstevel@tonic-gate 	case F_UNUSED:
17927c478bd9Sstevel@tonic-gate 		DPRINT1(1, "writemsg(%u): UNUSED\n", mythreadno);
17937c478bd9Sstevel@tonic-gate 		break;
17947c478bd9Sstevel@tonic-gate 	case F_FORW:
17957c478bd9Sstevel@tonic-gate 		DPRINT4(1, "writemsg(%u): Logging msg '%s' to %s %s\n",
17967c478bd9Sstevel@tonic-gate 			mythreadno, msg, TypeNames[f->f_type],
17977c478bd9Sstevel@tonic-gate 			f->f_un.f_forw.f_hname);
17987c478bd9Sstevel@tonic-gate 
17997c478bd9Sstevel@tonic-gate 		hlen = snprintf(head, sizeof (head),
18007c478bd9Sstevel@tonic-gate 			"<%d>%.15s ", pri, cp);
18017c478bd9Sstevel@tonic-gate 
18027c478bd9Sstevel@tonic-gate 		DPRINT2(5, "writemsg(%u): head = \"%s\"\n", mythreadno, head);
18037c478bd9Sstevel@tonic-gate 		DPRINT2(5, "writemsg(%u): hlen = %d\n", mythreadno, hlen);
18047c478bd9Sstevel@tonic-gate 
18057c478bd9Sstevel@tonic-gate 		l = strlen(text);
18067c478bd9Sstevel@tonic-gate 		p = text;
18077c478bd9Sstevel@tonic-gate 
18087c478bd9Sstevel@tonic-gate 		DPRINT2(5, "writemsg(%u): text = \"%s\"\n", mythreadno, text);
18097c478bd9Sstevel@tonic-gate 		DPRINT2(5, "writemsg(%u): strlen(text) = %d\n", mythreadno, l);
18107c478bd9Sstevel@tonic-gate 
18117c478bd9Sstevel@tonic-gate 		(void) strncpy(tmpbuf, head, hlen);
18127c478bd9Sstevel@tonic-gate 
18137c478bd9Sstevel@tonic-gate 		while (l > 0) {
18147c478bd9Sstevel@tonic-gate 			size_t	len;
18157c478bd9Sstevel@tonic-gate 
18167c478bd9Sstevel@tonic-gate 			len = copy_frwd(tmpbuf + hlen, sizeof (tmpbuf) - hlen,
18177c478bd9Sstevel@tonic-gate 					p, l);
18187c478bd9Sstevel@tonic-gate 
18197c478bd9Sstevel@tonic-gate 			DPRINT2(5, "writemsg(%u): tmpbuf = \"%s\"\n",
18207c478bd9Sstevel@tonic-gate 				mythreadno, tmpbuf);
18217c478bd9Sstevel@tonic-gate 			DPRINT2(5, "writemsg(%u): len = %d\n", mythreadno,
18227c478bd9Sstevel@tonic-gate 				len);
18237c478bd9Sstevel@tonic-gate 			DPRINT2(5, "writemsg(%u): strlen(tmpbuf) = %d\n",
18247c478bd9Sstevel@tonic-gate 				mythreadno, strlen(tmpbuf));
18257c478bd9Sstevel@tonic-gate 
18267c478bd9Sstevel@tonic-gate 			ud.opt.buf = NULL;
18277c478bd9Sstevel@tonic-gate 			ud.opt.len = 0;
18287c478bd9Sstevel@tonic-gate 			ud.udata.buf = tmpbuf;
18297c478bd9Sstevel@tonic-gate 			ud.udata.len = len + hlen;
18307c478bd9Sstevel@tonic-gate 			ud.addr.maxlen = f->f_un.f_forw.f_addr.maxlen;
18317c478bd9Sstevel@tonic-gate 			ud.addr.buf = f->f_un.f_forw.f_addr.buf;
18327c478bd9Sstevel@tonic-gate 			ud.addr.len = f->f_un.f_forw.f_addr.len;
18337c478bd9Sstevel@tonic-gate 			if (t_sndudata(f->f_file, &ud) < 0) {
18347c478bd9Sstevel@tonic-gate 				if ((hup_state & HUP_INPROGRESS) &&
18357c478bd9Sstevel@tonic-gate 					f->f_type == F_UNUSED) {
18367c478bd9Sstevel@tonic-gate 					break;
18377c478bd9Sstevel@tonic-gate 				}
18387c478bd9Sstevel@tonic-gate 				(void) t_close(f->f_file);
18397c478bd9Sstevel@tonic-gate 				f->f_type = F_UNUSED;
18407c478bd9Sstevel@tonic-gate 				logerror("t_sndudata");
18417c478bd9Sstevel@tonic-gate 
18427c478bd9Sstevel@tonic-gate 				/*
18437c478bd9Sstevel@tonic-gate 				 * Since it has already failed, it's not worth
18447c478bd9Sstevel@tonic-gate 				 * continuing output from the middle of
18457c478bd9Sstevel@tonic-gate 				 * message string.
18467c478bd9Sstevel@tonic-gate 				 */
18477c478bd9Sstevel@tonic-gate 				break;
18487c478bd9Sstevel@tonic-gate 			}
18497c478bd9Sstevel@tonic-gate 			p += len;
18507c478bd9Sstevel@tonic-gate 			l -= len;
18517c478bd9Sstevel@tonic-gate 		}
18527c478bd9Sstevel@tonic-gate 		break;
18537c478bd9Sstevel@tonic-gate 	case F_CONSOLE:
18547c478bd9Sstevel@tonic-gate 	case F_TTY:
18557c478bd9Sstevel@tonic-gate 	case F_FILE:
18567c478bd9Sstevel@tonic-gate 	case F_USERS:
18577c478bd9Sstevel@tonic-gate 	case F_WALL:
18587c478bd9Sstevel@tonic-gate 		DPRINT4(1, "writemsg(%u): Logging msg '%s' to %s %s\n",
18597c478bd9Sstevel@tonic-gate 			mythreadno, msg, TypeNames[f->f_type],
18607c478bd9Sstevel@tonic-gate 			((f->f_type == F_USERS) || (f->f_type == F_WALL)) ?
18617c478bd9Sstevel@tonic-gate 			"" : f->f_un.f_fname);
18627c478bd9Sstevel@tonic-gate 		/*
18637c478bd9Sstevel@tonic-gate 		 * filter the string in preparation for writing it
18647c478bd9Sstevel@tonic-gate 		 * save the original for possible forwarding.
18657c478bd9Sstevel@tonic-gate 		 * In case every byte in cp is a control character,
18667c478bd9Sstevel@tonic-gate 		 * allocates large enough buffer for filtered.
18677c478bd9Sstevel@tonic-gate 		 */
18687c478bd9Sstevel@tonic-gate 
18697c478bd9Sstevel@tonic-gate 		filter_len = strlen(cp) * 4 + 1;
18707c478bd9Sstevel@tonic-gate 		filtered = (char *)malloc(filter_len);
18717c478bd9Sstevel@tonic-gate 		if (!filtered) {
18727c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("dropping message");
18737c478bd9Sstevel@tonic-gate 			/* seems we can just return */
18747c478bd9Sstevel@tonic-gate 			return;
18757c478bd9Sstevel@tonic-gate 		}
18767c478bd9Sstevel@tonic-gate 		DPRINT3(5, "writemsg(%u): "
18777c478bd9Sstevel@tonic-gate 			"filtered allocated (%p: %d bytes)\n",
18787c478bd9Sstevel@tonic-gate 			mythreadno, filtered, filter_len);
18797c478bd9Sstevel@tonic-gate 		/* -3 : we may add "\r\n" to ecomp(filtered) later */
18807c478bd9Sstevel@tonic-gate 		filter_string(cp, filtered, filter_len - 3);
18817c478bd9Sstevel@tonic-gate 
18827c478bd9Sstevel@tonic-gate 		DPRINT2(5, "writemsg(%u): strlen(filtered) = %d\n",
18837c478bd9Sstevel@tonic-gate 			mythreadno, strlen(filtered));
18847c478bd9Sstevel@tonic-gate 		/*
18857c478bd9Sstevel@tonic-gate 		 * If we're writing to the console, strip out the message ID
18867c478bd9Sstevel@tonic-gate 		 * to reduce visual clutter.
18877c478bd9Sstevel@tonic-gate 		 */
18887c478bd9Sstevel@tonic-gate 		if ((msgid_start = strstr(filtered, "[ID ")) != NULL &&
18897c478bd9Sstevel@tonic-gate 			(msgid_end = strstr(msgid_start, "] ")) != NULL &&
18907c478bd9Sstevel@tonic-gate 			f->f_type == F_CONSOLE)
18917c478bd9Sstevel@tonic-gate 			(void) strcpy(msgid_start, msgid_end + 2);
18927c478bd9Sstevel@tonic-gate 
18937c478bd9Sstevel@tonic-gate 		eomp = filtered + strlen(filtered);
18947c478bd9Sstevel@tonic-gate 
18957c478bd9Sstevel@tonic-gate 		if ((f->f_type == F_USERS) || (f->f_type == F_WALL)) {
18967c478bd9Sstevel@tonic-gate 			/* CSTYLED */
18977c478bd9Sstevel@tonic-gate 			(void) strcat(eomp, "\r\n"); /*lint !e669*/
18987c478bd9Sstevel@tonic-gate 			/*
18997c478bd9Sstevel@tonic-gate 			 * Since wallmsg messes with utmpx we need
19007c478bd9Sstevel@tonic-gate 			 * to guarantee single threadedness...
19017c478bd9Sstevel@tonic-gate 			 */
19027c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_lock(&wmp);
19037c478bd9Sstevel@tonic-gate 			wallmsg(f, from, filtered);
19047c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&wmp);
19057c478bd9Sstevel@tonic-gate 
19067c478bd9Sstevel@tonic-gate 			/*
19077c478bd9Sstevel@tonic-gate 			 * The contents of filtered have been copied
19087c478bd9Sstevel@tonic-gate 			 * out to the struct walldev. We should free it here.
19097c478bd9Sstevel@tonic-gate 			 */
19107c478bd9Sstevel@tonic-gate 
19117c478bd9Sstevel@tonic-gate 			free(filtered);
19127c478bd9Sstevel@tonic-gate 
19137c478bd9Sstevel@tonic-gate 			/* exiting the switch */
19147c478bd9Sstevel@tonic-gate 			break;
19157c478bd9Sstevel@tonic-gate 		} else if (f->f_type != F_FILE) {
19167c478bd9Sstevel@tonic-gate 			/* CSTYLED */
19177c478bd9Sstevel@tonic-gate 			(void) strncpy(eomp, "\r\n", 3); /*lint !e669*/
19187c478bd9Sstevel@tonic-gate 		} else {
19197c478bd9Sstevel@tonic-gate 			if ((eomp2 = strchr(filtered, '\r')) != NULL) {
19207c478bd9Sstevel@tonic-gate 				(void) strncpy(eomp2, "\n", 2);
19217c478bd9Sstevel@tonic-gate 			} else {
19227c478bd9Sstevel@tonic-gate 				/* CSTYLED */
19237c478bd9Sstevel@tonic-gate 				(void) strncpy(eomp, "\n", 2); /*lint !e669*/
19247c478bd9Sstevel@tonic-gate 			}
19257c478bd9Sstevel@tonic-gate 		}
19267c478bd9Sstevel@tonic-gate 		if (write(f->f_file, filtered, strlen(filtered)) < 0) {
19277c478bd9Sstevel@tonic-gate 			int e = errno;
19287c478bd9Sstevel@tonic-gate 
19297c478bd9Sstevel@tonic-gate 			if ((hup_state & HUP_INPROGRESS) &&
19307c478bd9Sstevel@tonic-gate 				f->f_type == F_UNUSED) {
19317c478bd9Sstevel@tonic-gate 				free(filtered);
19327c478bd9Sstevel@tonic-gate 				break;
19337c478bd9Sstevel@tonic-gate 			}
19347c478bd9Sstevel@tonic-gate 			(void) close(f->f_file);
19357c478bd9Sstevel@tonic-gate 			/*
19367c478bd9Sstevel@tonic-gate 			 * Check for EBADF on TTY's due
19377c478bd9Sstevel@tonic-gate 			 * to vhangup() XXX
19387c478bd9Sstevel@tonic-gate 			 */
19397c478bd9Sstevel@tonic-gate 			if (e == EBADF && f->f_type != F_FILE) {
19407c478bd9Sstevel@tonic-gate 				f->f_file = open(f->f_un.f_fname,
19417c478bd9Sstevel@tonic-gate 					O_WRONLY|O_APPEND|O_NOCTTY);
19427c478bd9Sstevel@tonic-gate 				if (f->f_file < 0) {
19437c478bd9Sstevel@tonic-gate 					f->f_type = F_UNUSED;
19447c478bd9Sstevel@tonic-gate 					logerror(f->f_un.f_fname);
19457c478bd9Sstevel@tonic-gate 					f->f_stat.errs++;
19467c478bd9Sstevel@tonic-gate 				}
19477c478bd9Sstevel@tonic-gate 				untty();
19487c478bd9Sstevel@tonic-gate 			} else {
19497c478bd9Sstevel@tonic-gate 				f->f_type = F_UNUSED;
19507c478bd9Sstevel@tonic-gate 				f->f_stat.errs++;
19517c478bd9Sstevel@tonic-gate 				errno = e;
19527c478bd9Sstevel@tonic-gate 				logerror(f->f_un.f_fname);
19537c478bd9Sstevel@tonic-gate 			}
19547c478bd9Sstevel@tonic-gate 		} else if (flags & SYNC_FILE)
19557c478bd9Sstevel@tonic-gate 			if (((pri & LOG_FACMASK) >> 3) == LOG_KERN)
19567c478bd9Sstevel@tonic-gate 				(void) fsync(f->f_file);
19577c478bd9Sstevel@tonic-gate 
19587c478bd9Sstevel@tonic-gate 		DPRINT2(5, "writemsg(%u): freeing filtered (%p)\n",
19597c478bd9Sstevel@tonic-gate 			mythreadno, filtered);
19607c478bd9Sstevel@tonic-gate 
19617c478bd9Sstevel@tonic-gate 		free(filtered);
19627c478bd9Sstevel@tonic-gate 		break;
19637c478bd9Sstevel@tonic-gate 	}
19647c478bd9Sstevel@tonic-gate }
19657c478bd9Sstevel@tonic-gate 
19667c478bd9Sstevel@tonic-gate /*
19677c478bd9Sstevel@tonic-gate  *  WALLMSG -- Write a message to the world at large
19687c478bd9Sstevel@tonic-gate  *
19697c478bd9Sstevel@tonic-gate  *	Write the specified message to either the entire
19707c478bd9Sstevel@tonic-gate  *	world, or a list of approved users.
19717c478bd9Sstevel@tonic-gate  */
19727c478bd9Sstevel@tonic-gate static void
19737c478bd9Sstevel@tonic-gate wallmsg(struct filed *f, char *from, char *msg)
19747c478bd9Sstevel@tonic-gate {
19757c478bd9Sstevel@tonic-gate 	int i;
19767c478bd9Sstevel@tonic-gate 	size_t	len, clen;
19777c478bd9Sstevel@tonic-gate 	char *buf = NULL;
19787c478bd9Sstevel@tonic-gate 	struct utmpx *utxp;
19797c478bd9Sstevel@tonic-gate 	time_t now;
19807c478bd9Sstevel@tonic-gate 	char line[512], dev[100];
19817c478bd9Sstevel@tonic-gate 	char cp[MAXLINE+1];
19827c478bd9Sstevel@tonic-gate 	struct stat statbuf;
19837c478bd9Sstevel@tonic-gate 	walldev_t *w;
19847c478bd9Sstevel@tonic-gate 	char cbuf[30];
19857c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
19867c478bd9Sstevel@tonic-gate 
19877c478bd9Sstevel@tonic-gate 	if (Debug) {
19887c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
19897c478bd9Sstevel@tonic-gate 	}
19907c478bd9Sstevel@tonic-gate 
19917c478bd9Sstevel@tonic-gate 	if (access(UTMPX_FILE, R_OK) != 0 || stat(UTMPX_FILE, &statbuf) != 0) {
19927c478bd9Sstevel@tonic-gate 		logerror(UTMPX_FILE);
19937c478bd9Sstevel@tonic-gate 		return;
19947c478bd9Sstevel@tonic-gate 	} else if (statbuf.st_uid != 0 || (statbuf.st_mode & 07777) != 0644) {
19957c478bd9Sstevel@tonic-gate 		(void) sprintf(line, "%s %s", UTMPX_FILE,
19967c478bd9Sstevel@tonic-gate 			"not owned by root or not mode 644.\n"
19977c478bd9Sstevel@tonic-gate 			"This file must be owned by root "
19987c478bd9Sstevel@tonic-gate 			"and not writable by\n"
19997c478bd9Sstevel@tonic-gate 			"anyone other than root.  This alert is being "
20007c478bd9Sstevel@tonic-gate 			"dropped because of\n"
20017c478bd9Sstevel@tonic-gate 			"this problem.");
20027c478bd9Sstevel@tonic-gate 		logerror(line);
20037c478bd9Sstevel@tonic-gate 		return;
20047c478bd9Sstevel@tonic-gate 	}
20057c478bd9Sstevel@tonic-gate 
20067c478bd9Sstevel@tonic-gate 	if (f->f_type == F_WALL) {
20077c478bd9Sstevel@tonic-gate 		(void) time(&now);
20087c478bd9Sstevel@tonic-gate 		len = snprintf(line, sizeof (line),
20097c478bd9Sstevel@tonic-gate 			"\r\n\7Message from syslogd@%s "
20107c478bd9Sstevel@tonic-gate 			"at %.24s ...\r\n", from, ctime_r(&now, cbuf));
20117c478bd9Sstevel@tonic-gate 		len += strlen(msg + 16);
20127c478bd9Sstevel@tonic-gate 		buf = (char *)malloc(len + 1);
20137c478bd9Sstevel@tonic-gate 		if (!buf) {
20147c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("dropping message");
20157c478bd9Sstevel@tonic-gate 			return;
20167c478bd9Sstevel@tonic-gate 		}
20177c478bd9Sstevel@tonic-gate 		DPRINT3(5, "wallmsg(%u): buf allocated (%p: %d bytes)\n",
20187c478bd9Sstevel@tonic-gate 			mythreadno, buf, len + 1);
20197c478bd9Sstevel@tonic-gate 		(void) strcpy(buf, line);
20207c478bd9Sstevel@tonic-gate 		(void) strcat(buf, msg + 16);
20217c478bd9Sstevel@tonic-gate 		clen = copy_frwd(cp, sizeof (cp), buf, len);
20227c478bd9Sstevel@tonic-gate 		DPRINT2(5, "wallmsg(%u): clen = %d\n",
20237c478bd9Sstevel@tonic-gate 			mythreadno, clen);
20247c478bd9Sstevel@tonic-gate 		DPRINT2(5, "wallmsg(%u): freeing buf (%p)\n",
20257c478bd9Sstevel@tonic-gate 			mythreadno, buf);
20267c478bd9Sstevel@tonic-gate 		free(buf);
20277c478bd9Sstevel@tonic-gate 	} else {
20287c478bd9Sstevel@tonic-gate 		clen = copy_frwd(cp, sizeof (cp), msg, strlen(msg));
20297c478bd9Sstevel@tonic-gate 		DPRINT2(5, "wallmsg(%u): clen = %d\n",
20307c478bd9Sstevel@tonic-gate 			mythreadno, clen);
20317c478bd9Sstevel@tonic-gate 	}
20327c478bd9Sstevel@tonic-gate 	/* scan the user login file */
20337c478bd9Sstevel@tonic-gate 	setutxent();
20347c478bd9Sstevel@tonic-gate 	while ((utxp = getutxent()) != NULL) {
20357c478bd9Sstevel@tonic-gate 		/* is this slot used? */
20367c478bd9Sstevel@tonic-gate 		if (utxp->ut_name[0] == '\0' ||
20377c478bd9Sstevel@tonic-gate 			utxp->ut_line[0] == '\0' ||
20387c478bd9Sstevel@tonic-gate 			utxp->ut_type != USER_PROCESS)
20397c478bd9Sstevel@tonic-gate 			continue;
20407c478bd9Sstevel@tonic-gate 		/* should we send the message to this user? */
20417c478bd9Sstevel@tonic-gate 		if (f->f_type == F_USERS) {
20427c478bd9Sstevel@tonic-gate 			for (i = 0; i < MAXUNAMES; i++) {
20437c478bd9Sstevel@tonic-gate 				if (!f->f_un.f_uname[i][0]) {
20447c478bd9Sstevel@tonic-gate 					i = MAXUNAMES;
20457c478bd9Sstevel@tonic-gate 					break;
20467c478bd9Sstevel@tonic-gate 				}
20477c478bd9Sstevel@tonic-gate 				if (strncmp(f->f_un.f_uname[i],
20487c478bd9Sstevel@tonic-gate 					utxp->ut_name, UNAMESZ) == 0)
20497c478bd9Sstevel@tonic-gate 					break;
20507c478bd9Sstevel@tonic-gate 			}
20517c478bd9Sstevel@tonic-gate 			if (i >= MAXUNAMES)
20527c478bd9Sstevel@tonic-gate 				continue;
20537c478bd9Sstevel@tonic-gate 		}
20547c478bd9Sstevel@tonic-gate 
20557c478bd9Sstevel@tonic-gate 		/* compute the device name */
20567c478bd9Sstevel@tonic-gate 		if (utxp->ut_line[0] == '/') {
20577c478bd9Sstevel@tonic-gate 			(void) strncpy(dev, utxp->ut_line, UDEVSZ);
20587c478bd9Sstevel@tonic-gate 		} else {
20597c478bd9Sstevel@tonic-gate 			(void) strcpy(dev, "/dev/");
20607c478bd9Sstevel@tonic-gate 			(void) strncat(dev, utxp->ut_line, UDEVSZ);
20617c478bd9Sstevel@tonic-gate 		}
20627c478bd9Sstevel@tonic-gate 		DPRINT2(1, "wallmsg(%u): write to '%s'\n", mythreadno,
20637c478bd9Sstevel@tonic-gate 			dev);
20647c478bd9Sstevel@tonic-gate 
20657c478bd9Sstevel@tonic-gate 		if ((w = malloc(sizeof (walldev_t))) != NULL) {
20667c478bd9Sstevel@tonic-gate 			int rc;
20677c478bd9Sstevel@tonic-gate 			(void) pthread_attr_init(&w->thread_attr);
20687c478bd9Sstevel@tonic-gate 			(void) pthread_attr_setdetachstate(&w->thread_attr,
20697c478bd9Sstevel@tonic-gate 				PTHREAD_CREATE_DETACHED);
20707c478bd9Sstevel@tonic-gate 			(void) strncpy(w->dev, dev, PATH_MAX);
20717c478bd9Sstevel@tonic-gate 			(void) strncpy(w->msg, cp, MAXLINE+1);
20727c478bd9Sstevel@tonic-gate 			(void) strncpy(w->ut_name, utxp->ut_name,
20737c478bd9Sstevel@tonic-gate 			    sizeof (w->ut_name));
20747c478bd9Sstevel@tonic-gate 
20757c478bd9Sstevel@tonic-gate 			if ((rc = pthread_create(&w->thread, &w->thread_attr,
20767c478bd9Sstevel@tonic-gate 				writetodev, (void *) w)) != 0) {
20777c478bd9Sstevel@tonic-gate 				DPRINT2(5, "wallmsg(%u): wallmsg thread "
20787c478bd9Sstevel@tonic-gate 					"create failed rc = %d\n",
20797c478bd9Sstevel@tonic-gate 					mythreadno, rc);
20807c478bd9Sstevel@tonic-gate 				free(w);
20817c478bd9Sstevel@tonic-gate 				break;
20827c478bd9Sstevel@tonic-gate 			}
20837c478bd9Sstevel@tonic-gate 		} else {
20847c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("dropping message to user");
20857c478bd9Sstevel@tonic-gate 		}
20867c478bd9Sstevel@tonic-gate 	}
20877c478bd9Sstevel@tonic-gate 	/* close the user login file */
20887c478bd9Sstevel@tonic-gate 	endutxent();
20897c478bd9Sstevel@tonic-gate }
20907c478bd9Sstevel@tonic-gate 
20917c478bd9Sstevel@tonic-gate /*
20927c478bd9Sstevel@tonic-gate  * Each time we need to write to a tty device (a potentially expensive
20937c478bd9Sstevel@tonic-gate  * or long-running operation) this routine gets called as a new
20947c478bd9Sstevel@tonic-gate  * detached, unbound thread. This allows writes to many devices
20957c478bd9Sstevel@tonic-gate  * to proceed nearly in parallel, without having to resort to
20967c478bd9Sstevel@tonic-gate  * asynchronous I/O or forking.
20977c478bd9Sstevel@tonic-gate  */
20987c478bd9Sstevel@tonic-gate static void *
20997c478bd9Sstevel@tonic-gate writetodev(void *ap)
21007c478bd9Sstevel@tonic-gate {
21017c478bd9Sstevel@tonic-gate 	walldev_t *w = ap;
21027c478bd9Sstevel@tonic-gate 	int ttyf;
21037c478bd9Sstevel@tonic-gate 	int len;
21047c478bd9Sstevel@tonic-gate 	struct stat statb;
21057c478bd9Sstevel@tonic-gate 	struct passwd pw, *pwp;
21067c478bd9Sstevel@tonic-gate 	char pwbuf[MAXLINE];
21077c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
21087c478bd9Sstevel@tonic-gate 
21097c478bd9Sstevel@tonic-gate 	if (Debug) {
21107c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
21117c478bd9Sstevel@tonic-gate 	}
21127c478bd9Sstevel@tonic-gate 
21137c478bd9Sstevel@tonic-gate 	DPRINT1(1, "writetodev(%u): Device writer thread started\n",
21147c478bd9Sstevel@tonic-gate 		mythreadno);
21157c478bd9Sstevel@tonic-gate 
21167c478bd9Sstevel@tonic-gate 	len = strlen(w->msg);
21177c478bd9Sstevel@tonic-gate 
21187c478bd9Sstevel@tonic-gate 	ttyf = open(w->dev, O_WRONLY|O_NOCTTY|O_NDELAY);
21197c478bd9Sstevel@tonic-gate 	if (ttyf >= 0) {
21207c478bd9Sstevel@tonic-gate 		if (fstat(ttyf, &statb) != 0) {
21217c478bd9Sstevel@tonic-gate 			DPRINT2(1, "writetodev(%u): Can't stat '%s'\n",
21227c478bd9Sstevel@tonic-gate 				mythreadno, w->dev);
21237c478bd9Sstevel@tonic-gate 			errno = 0;
21247c478bd9Sstevel@tonic-gate 			logerror("Can't stat '%s'", w->dev);
21257c478bd9Sstevel@tonic-gate 		} else if (!(statb.st_mode & S_IWRITE)) {
21267c478bd9Sstevel@tonic-gate 			DPRINT2(1, "writetodev(%u): Can't write to "
21277c478bd9Sstevel@tonic-gate 				"'%s'\n", mythreadno, w->dev);
21287c478bd9Sstevel@tonic-gate 		} else if (!isatty(ttyf)) {
21297c478bd9Sstevel@tonic-gate 			DPRINT2(1, "writetodev(%u): '%s' not a tty\n",
21307c478bd9Sstevel@tonic-gate 				mythreadno, w->dev);
21317c478bd9Sstevel@tonic-gate 			/*
21327c478bd9Sstevel@tonic-gate 			 * We might hit dtremote here. Don't generate
21337c478bd9Sstevel@tonic-gate 			 * error message.
21347c478bd9Sstevel@tonic-gate 			 */
21357c478bd9Sstevel@tonic-gate 		} else if (getpwuid_r(statb.st_uid, &pw, pwbuf,
21367c478bd9Sstevel@tonic-gate 				sizeof (pwbuf), &pwp) != 0) {
21377c478bd9Sstevel@tonic-gate 			DPRINT2(1, "writetodev(%u): Can't determine owner "
21387c478bd9Sstevel@tonic-gate 				"of '%s'\n", mythreadno, w->dev);
21397c478bd9Sstevel@tonic-gate 			errno = 0;
21407c478bd9Sstevel@tonic-gate 			logerror("Can't determine owner of '%s'", w->dev);
21417c478bd9Sstevel@tonic-gate 		} else if (strncmp(pw.pw_name, w->ut_name, UNAMESZ) != 0) {
21427c478bd9Sstevel@tonic-gate 			DPRINT2(1, "writetodev(%u): Bad terminal owner '%s'"
21437c478bd9Sstevel@tonic-gate 				"\n", mythreadno, w->dev);
21447c478bd9Sstevel@tonic-gate 			errno = 0;
21457c478bd9Sstevel@tonic-gate 			logerror("%s %s owns '%s' %s %.*s",
21467c478bd9Sstevel@tonic-gate 				"Bad terminal owner;", pw.pw_name, w->dev,
21477c478bd9Sstevel@tonic-gate 				"but utmpx says", UNAMESZ, w->ut_name);
21487c478bd9Sstevel@tonic-gate 		} else if (write(ttyf, w->msg, len) != len) {
21497c478bd9Sstevel@tonic-gate 			DPRINT2(1, "writetodev(%u): Write failed to "
21507c478bd9Sstevel@tonic-gate 				"'%s'\n", mythreadno, w->dev);
21517c478bd9Sstevel@tonic-gate 			errno = 0;
21527c478bd9Sstevel@tonic-gate 			logerror("Write failed to '%s'", w->dev);
21537c478bd9Sstevel@tonic-gate 		}
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 		DPRINT2(1, "writetodev(%u): write to '%s' succeeded\n",
21567c478bd9Sstevel@tonic-gate 			mythreadno, w->dev);
21577c478bd9Sstevel@tonic-gate 
21587c478bd9Sstevel@tonic-gate 		(void) close(ttyf);
21597c478bd9Sstevel@tonic-gate 	} else {
21607c478bd9Sstevel@tonic-gate 		DPRINT2(1, "writetodev(%u): Can't open '%s'\n",
21617c478bd9Sstevel@tonic-gate 			mythreadno, w->dev);
21627c478bd9Sstevel@tonic-gate 	}
21637c478bd9Sstevel@tonic-gate 
21647c478bd9Sstevel@tonic-gate 	pthread_attr_destroy(&w->thread_attr);
21657c478bd9Sstevel@tonic-gate 	free(w);
21667c478bd9Sstevel@tonic-gate 
21677c478bd9Sstevel@tonic-gate 	DPRINT1(1, "writetodev(%u): Device writer thread exiting\n",
21687c478bd9Sstevel@tonic-gate 		mythreadno);
21697c478bd9Sstevel@tonic-gate 
21707c478bd9Sstevel@tonic-gate 	pthread_exit(0);
21717c478bd9Sstevel@tonic-gate 	return (NULL);
21727c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
21737c478bd9Sstevel@tonic-gate }
21747c478bd9Sstevel@tonic-gate 
21757c478bd9Sstevel@tonic-gate /*
21767c478bd9Sstevel@tonic-gate  * Return a printable representation of a host address. If unable to
21777c478bd9Sstevel@tonic-gate  * look up hostname, format the numeric address for display instead.
21787c478bd9Sstevel@tonic-gate  *
21797c478bd9Sstevel@tonic-gate  * First calls hnc_lookup to see if there is valid cache entry for
21807c478bd9Sstevel@tonic-gate  * given network address. If it failed, cvthname looks up hostname,
21817c478bd9Sstevel@tonic-gate  * and push the results into the hostname cache.
21827c478bd9Sstevel@tonic-gate  */
21837c478bd9Sstevel@tonic-gate static host_list_t *
21847c478bd9Sstevel@tonic-gate cvthname(struct netbuf *nbp, struct netconfig *ncp, char *failsafe_addr)
21857c478bd9Sstevel@tonic-gate {
21867c478bd9Sstevel@tonic-gate 	int i;
21877c478bd9Sstevel@tonic-gate 	host_list_t *h;
21887c478bd9Sstevel@tonic-gate 	struct nd_hostservlist *hsp;
21897c478bd9Sstevel@tonic-gate 	struct nd_hostserv *hspp;
21907c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
2191293d1fc4Spd155743 	int hindex;
21927c478bd9Sstevel@tonic-gate 	char *uap;
21937c478bd9Sstevel@tonic-gate 
21947c478bd9Sstevel@tonic-gate 	if (Debug) {
21957c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
21967c478bd9Sstevel@tonic-gate 	}
21977c478bd9Sstevel@tonic-gate 
21987c478bd9Sstevel@tonic-gate 	if (Debug)
21997c478bd9Sstevel@tonic-gate 		uap = taddr2uaddr(ncp, nbp);
22007c478bd9Sstevel@tonic-gate 
22017c478bd9Sstevel@tonic-gate 	DPRINT2(2, "cvthname(%u): looking up hostname for %s\n",
22027c478bd9Sstevel@tonic-gate 			mythreadno, uap ? uap : "<unknown>");
22037c478bd9Sstevel@tonic-gate 
2204293d1fc4Spd155743 	if ((h = hnc_lookup(nbp, ncp, &hindex)) != NULL) {
22057c478bd9Sstevel@tonic-gate 		DPRINT4(2, "cvthname(%u): Cache found %p for %s (%s)\n",
22067c478bd9Sstevel@tonic-gate 				mythreadno, h, uap ? uap : "<unknown>",
22077c478bd9Sstevel@tonic-gate 				h->hl_hosts[0]);
22087c478bd9Sstevel@tonic-gate 		return (h);
22097c478bd9Sstevel@tonic-gate 	}
22107c478bd9Sstevel@tonic-gate 	DPRINT2(2, "cvthname(%u): No cache found for %s\n",
22117c478bd9Sstevel@tonic-gate 			mythreadno, uap ? uap : "<unknown>");
22127c478bd9Sstevel@tonic-gate 
22137c478bd9Sstevel@tonic-gate 	if (Debug)
22147c478bd9Sstevel@tonic-gate 		free(uap);
22157c478bd9Sstevel@tonic-gate 
22167c478bd9Sstevel@tonic-gate 	if (ncp->nc_semantics != NC_TPI_CLTS) {
22177c478bd9Sstevel@tonic-gate 		return (NULL);
22187c478bd9Sstevel@tonic-gate 	}
22197c478bd9Sstevel@tonic-gate 
22207c478bd9Sstevel@tonic-gate 	/* memory allocation failure here is fatal */
22217c478bd9Sstevel@tonic-gate 	if ((h = malloc(sizeof (host_list_t))) == NULL) {
22227c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("host name conversion");
22237c478bd9Sstevel@tonic-gate 		return (NULL);
22247c478bd9Sstevel@tonic-gate 	}
22257c478bd9Sstevel@tonic-gate 
22267c478bd9Sstevel@tonic-gate 	if (netdir_getbyaddr(ncp, &hsp, nbp) == 0) {
22277c478bd9Sstevel@tonic-gate 		if (hsp->h_cnt <= 0) {
22287c478bd9Sstevel@tonic-gate out:			netdir_free((void *)hsp, ND_HOSTSERVLIST);
22297c478bd9Sstevel@tonic-gate 			free(h);
22307c478bd9Sstevel@tonic-gate 			return (NULL);
22317c478bd9Sstevel@tonic-gate 		}
22327c478bd9Sstevel@tonic-gate 
22337c478bd9Sstevel@tonic-gate 		hspp = hsp->h_hostservs;
22347c478bd9Sstevel@tonic-gate 		h->hl_cnt = hsp->h_cnt;
22357c478bd9Sstevel@tonic-gate 		h->hl_hosts = (char **)malloc(sizeof (char *) * (h->hl_cnt));
22367c478bd9Sstevel@tonic-gate 		if (h->hl_hosts == NULL) {
22377c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("host name conversion");
22387c478bd9Sstevel@tonic-gate 			goto out;
22397c478bd9Sstevel@tonic-gate 		}
22407c478bd9Sstevel@tonic-gate 
22417c478bd9Sstevel@tonic-gate 		DPRINT2(2, "cvthname(%u): Found %d hostnames\n",
22427c478bd9Sstevel@tonic-gate 					mythreadno, h->hl_cnt);
22437c478bd9Sstevel@tonic-gate 		for (i = 0; i < h->hl_cnt; i++) {
22447c478bd9Sstevel@tonic-gate 			h->hl_hosts[i] = (char *)
22457c478bd9Sstevel@tonic-gate 			    malloc(sizeof (char) * (strlen(hspp->h_host) + 1));
22467c478bd9Sstevel@tonic-gate 			if (h->hl_hosts[i] == NULL) {
22477c478bd9Sstevel@tonic-gate 				int j;
22487c478bd9Sstevel@tonic-gate 				for (j = 0; j < i; j++) {
22497c478bd9Sstevel@tonic-gate 					free(h->hl_hosts[j]);
22507c478bd9Sstevel@tonic-gate 				}
22517c478bd9Sstevel@tonic-gate 				free(h->hl_hosts);
22527c478bd9Sstevel@tonic-gate 				MALLOC_FAIL("host name conversion");
22537c478bd9Sstevel@tonic-gate 				goto out;
22547c478bd9Sstevel@tonic-gate 			}
22557c478bd9Sstevel@tonic-gate 			(void) strcpy(h->hl_hosts[i], hspp->h_host);
22567c478bd9Sstevel@tonic-gate 			hspp++;
22577c478bd9Sstevel@tonic-gate 		}
22587c478bd9Sstevel@tonic-gate 		netdir_free((void *)hsp, ND_HOSTSERVLIST);
22597c478bd9Sstevel@tonic-gate 	} else { /* unknown address */
22607c478bd9Sstevel@tonic-gate 		h->hl_cnt = 1;
22617c478bd9Sstevel@tonic-gate 		h->hl_hosts = (char **)malloc(sizeof (char *));
22627c478bd9Sstevel@tonic-gate 		if (h->hl_hosts == NULL) {
22637c478bd9Sstevel@tonic-gate 			free(h);
22647c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("host name conversion");
22657c478bd9Sstevel@tonic-gate 			return (NULL);
22667c478bd9Sstevel@tonic-gate 		}
22677c478bd9Sstevel@tonic-gate 		h->hl_hosts[0] = (char *)malloc(strlen(failsafe_addr) + 3);
22687c478bd9Sstevel@tonic-gate 		if (h->hl_hosts[0] == NULL) {
22697c478bd9Sstevel@tonic-gate 			free(h->hl_hosts);
22707c478bd9Sstevel@tonic-gate 			free(h);
22717c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("host name conversion");
22727c478bd9Sstevel@tonic-gate 			return (NULL);
22737c478bd9Sstevel@tonic-gate 		}
22747c478bd9Sstevel@tonic-gate 		(void) sprintf(h->hl_hosts[0], "[%s]", failsafe_addr);
22757c478bd9Sstevel@tonic-gate 		DPRINT2(1, "cvthname(%u): Hostname lookup failed "
22767c478bd9Sstevel@tonic-gate 			"- using address %s instead\n",
22777c478bd9Sstevel@tonic-gate 			mythreadno, h->hl_hosts[0]);
22787c478bd9Sstevel@tonic-gate 	}
22797c478bd9Sstevel@tonic-gate 
22807c478bd9Sstevel@tonic-gate 	h->hl_refcnt = 1;
22817c478bd9Sstevel@tonic-gate 	if (pthread_mutex_init(&h->hl_mutex, NULL) != 0) {
22827c478bd9Sstevel@tonic-gate 		logerror("pthread_mutex_init failed");
22837c478bd9Sstevel@tonic-gate 		/* This host_list won't be shared by the cache. */
22847c478bd9Sstevel@tonic-gate 		return (h);
22857c478bd9Sstevel@tonic-gate 	}
2286293d1fc4Spd155743 	hnc_register(nbp, ncp, h, hindex);
22877c478bd9Sstevel@tonic-gate 	DPRINT3(2, "cvthname(%u): returning %p for %s\n",
22887c478bd9Sstevel@tonic-gate 			mythreadno, h, h->hl_hosts[0]);
22897c478bd9Sstevel@tonic-gate 	return (h);
22907c478bd9Sstevel@tonic-gate }
22917c478bd9Sstevel@tonic-gate 
22927c478bd9Sstevel@tonic-gate /*
22937c478bd9Sstevel@tonic-gate  * Print syslogd errors some place. Need to be careful here, because
22947c478bd9Sstevel@tonic-gate  * this routine is called at times when we're not initialized and
22957c478bd9Sstevel@tonic-gate  * ready to log messages...in this case, fall back to using the console.
22967c478bd9Sstevel@tonic-gate  */
22977c478bd9Sstevel@tonic-gate void
22987c478bd9Sstevel@tonic-gate logerror(const char *type, ...)
22997c478bd9Sstevel@tonic-gate {
23007c478bd9Sstevel@tonic-gate 	char buf[MAXLINE+1];
23017c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
23027c478bd9Sstevel@tonic-gate 	int flag;
23037c478bd9Sstevel@tonic-gate 	va_list ap;
23047c478bd9Sstevel@tonic-gate 
23057c478bd9Sstevel@tonic-gate 	if (Debug) {
23067c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
23077c478bd9Sstevel@tonic-gate 	}
23087c478bd9Sstevel@tonic-gate 
23097c478bd9Sstevel@tonic-gate 	va_start(ap, type);
23107c478bd9Sstevel@tonic-gate 	logerror_format(type, buf, ap);
23117c478bd9Sstevel@tonic-gate 	va_end(ap);
23127c478bd9Sstevel@tonic-gate 	DPRINT2(1, "logerror(%u): %s\n", mythreadno, buf);
23137c478bd9Sstevel@tonic-gate 
23147c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&logerror_lock);
23157c478bd9Sstevel@tonic-gate 	if (!interrorlog) {
23167c478bd9Sstevel@tonic-gate 		flag = 0;
23177c478bd9Sstevel@tonic-gate 		if (logerror_to_console(1, buf) == 0) {
23187c478bd9Sstevel@tonic-gate 			/* has written to the console */
23197c478bd9Sstevel@tonic-gate 			flag = IGN_CONS;
23207c478bd9Sstevel@tonic-gate 		}
23217c478bd9Sstevel@tonic-gate 		(void) logmymsg(LOG_SYSLOG|LOG_ERR, buf, ADDDATE|flag, 1);
23227c478bd9Sstevel@tonic-gate 	} else {
23237c478bd9Sstevel@tonic-gate 		if (logmymsg(LOG_SYSLOG|LOG_ERR, buf, ADDDATE, 0) == -1) {
23247c478bd9Sstevel@tonic-gate 			(void) logerror_to_console(1, buf);
23257c478bd9Sstevel@tonic-gate 		}
23267c478bd9Sstevel@tonic-gate 	}
23277c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&logerror_lock);
23287c478bd9Sstevel@tonic-gate 
23297c478bd9Sstevel@tonic-gate 	errno = 0;
23307c478bd9Sstevel@tonic-gate 	t_errno = 0;
23317c478bd9Sstevel@tonic-gate }
23327c478bd9Sstevel@tonic-gate 
23337c478bd9Sstevel@tonic-gate static void
23347c478bd9Sstevel@tonic-gate logerror_format(const char *type, char *buf, va_list ap)
23357c478bd9Sstevel@tonic-gate {
23367c478bd9Sstevel@tonic-gate 	char tmpbuf[MAXLINE + 1];
23377c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
23387c478bd9Sstevel@tonic-gate 
23397c478bd9Sstevel@tonic-gate 	if (Debug) {
23407c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
23417c478bd9Sstevel@tonic-gate 	}
23427c478bd9Sstevel@tonic-gate 
23437c478bd9Sstevel@tonic-gate 	(void) vsnprintf(tmpbuf, MAXLINE, type, ap);
23447c478bd9Sstevel@tonic-gate 
23457c478bd9Sstevel@tonic-gate 	if (t_errno == 0 || t_errno == TSYSERR) {
23467c478bd9Sstevel@tonic-gate 		char *errstr;
23477c478bd9Sstevel@tonic-gate 
23487c478bd9Sstevel@tonic-gate 		if (errno == 0) {
23497c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, MAXLINE, "syslogd: %.*s",
23507c478bd9Sstevel@tonic-gate 				MAXLINE, tmpbuf);
23517c478bd9Sstevel@tonic-gate 		} else if ((errstr = strerror(errno)) == (char *)NULL) {
23527c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, MAXLINE, "syslogd: %s: error"
23537c478bd9Sstevel@tonic-gate 				" %d", tmpbuf, errno);
23547c478bd9Sstevel@tonic-gate 		} else {
23557c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, MAXLINE, "syslogd: %s: %s",
23567c478bd9Sstevel@tonic-gate 				tmpbuf, errstr);
23577c478bd9Sstevel@tonic-gate 		}
23587c478bd9Sstevel@tonic-gate 	} else {
23597c478bd9Sstevel@tonic-gate 		if (t_errno > t_nerr) {
23607c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, MAXLINE, "syslogd: %s:"
23617c478bd9Sstevel@tonic-gate 				" t_error %d", tmpbuf, t_errno);
23627c478bd9Sstevel@tonic-gate 		} else {
23637c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, MAXLINE, "syslogd: %s: %s",
23647c478bd9Sstevel@tonic-gate 				tmpbuf, t_errlist[t_errno]);
23657c478bd9Sstevel@tonic-gate 		}
23667c478bd9Sstevel@tonic-gate 	}
23677c478bd9Sstevel@tonic-gate 
23687c478bd9Sstevel@tonic-gate 	DPRINT2(5, "logerror_format(%u): out %s\n", mythreadno, buf);
23697c478bd9Sstevel@tonic-gate }
23707c478bd9Sstevel@tonic-gate 
23717c478bd9Sstevel@tonic-gate static int
23727c478bd9Sstevel@tonic-gate logerror_to_console(int nonblock, const char *buf)
23737c478bd9Sstevel@tonic-gate {
23747c478bd9Sstevel@tonic-gate 	int cfd, modes;
23757c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
23767c478bd9Sstevel@tonic-gate 	int ret = 0, len;
23777c478bd9Sstevel@tonic-gate 	char tmpbuf[MAXLINE + 1];
23787c478bd9Sstevel@tonic-gate 
23797c478bd9Sstevel@tonic-gate 	if (Debug) {
23807c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
23817c478bd9Sstevel@tonic-gate 	}
23827c478bd9Sstevel@tonic-gate 
23837c478bd9Sstevel@tonic-gate 	DPRINT2(1, "logerror_to_console(%u): %s\n", mythreadno, buf);
23847c478bd9Sstevel@tonic-gate 
23857c478bd9Sstevel@tonic-gate 	/*
23867c478bd9Sstevel@tonic-gate 	 * must use open here instead of fopen, because
23877c478bd9Sstevel@tonic-gate 	 * we need the O_NOCTTY behavior - otherwise we
23887c478bd9Sstevel@tonic-gate 	 * could hang the console at boot time
23897c478bd9Sstevel@tonic-gate 	 */
23907c478bd9Sstevel@tonic-gate 
23917c478bd9Sstevel@tonic-gate 	modes = (nonblock) ?
23927c478bd9Sstevel@tonic-gate 		O_WRONLY|O_APPEND|O_NOCTTY|O_NONBLOCK :
23937c478bd9Sstevel@tonic-gate 		O_WRONLY|O_APPEND|O_NOCTTY;
23947c478bd9Sstevel@tonic-gate 
23957c478bd9Sstevel@tonic-gate 	if (((cfd = open(sysmsg, modes)) >= 0) ||
23967c478bd9Sstevel@tonic-gate 	    ((cfd = open(ctty, modes)) >= 0)) {
23977c478bd9Sstevel@tonic-gate 		(void) snprintf(tmpbuf, MAXLINE, "%s\n", buf);
23987c478bd9Sstevel@tonic-gate 		len = strlen(tmpbuf);
23997c478bd9Sstevel@tonic-gate 		if (write(cfd, tmpbuf, len) != len) {
24007c478bd9Sstevel@tonic-gate 			ret = 1;
24017c478bd9Sstevel@tonic-gate 		}
24027c478bd9Sstevel@tonic-gate 		(void) close(cfd);
24037c478bd9Sstevel@tonic-gate 	} else {
24047c478bd9Sstevel@tonic-gate 		ret = 1;
24057c478bd9Sstevel@tonic-gate 
24067c478bd9Sstevel@tonic-gate 		/* punt */
24077c478bd9Sstevel@tonic-gate 		DPRINT1(1, "logerror_console(%u): can't open console\n",
24087c478bd9Sstevel@tonic-gate 			mythreadno);
24097c478bd9Sstevel@tonic-gate 	}
24107c478bd9Sstevel@tonic-gate 	return (ret);
24117c478bd9Sstevel@tonic-gate }
24127c478bd9Sstevel@tonic-gate 
24137c478bd9Sstevel@tonic-gate /*
24147c478bd9Sstevel@tonic-gate  * copy current message to saved message in filed structure.
24157c478bd9Sstevel@tonic-gate  */
24167c478bd9Sstevel@tonic-gate static void
24177c478bd9Sstevel@tonic-gate copy_msg(struct filed *f)
24187c478bd9Sstevel@tonic-gate {
24197c478bd9Sstevel@tonic-gate 	(void) strlcpy(f->f_prevmsg.msg, f->f_current.msg, MAXLINE+1);
24207c478bd9Sstevel@tonic-gate 	(void) strlcpy(f->f_prevmsg.host, f->f_current.host, SYS_NMLN);
24217c478bd9Sstevel@tonic-gate 	f->f_prevmsg.pri = f->f_current.pri;
24227c478bd9Sstevel@tonic-gate 	f->f_prevmsg.flags = f->f_current.flags;
24237c478bd9Sstevel@tonic-gate 	f->f_prevmsg.time = f->f_current.time;
24247c478bd9Sstevel@tonic-gate 	f->f_msgflag |= OLD_VALID;
24257c478bd9Sstevel@tonic-gate }
24267c478bd9Sstevel@tonic-gate 
24277c478bd9Sstevel@tonic-gate 
24287c478bd9Sstevel@tonic-gate /*
24297c478bd9Sstevel@tonic-gate  * function to free a host_list_t struct that was allocated
24307c478bd9Sstevel@tonic-gate  * out of cvthname(). There is a special case where we don't
24317c478bd9Sstevel@tonic-gate  * free the hostname list in LocalHostName, because that's
24327c478bd9Sstevel@tonic-gate  * our own addresses, and we just want to have to look it
24337c478bd9Sstevel@tonic-gate  * up once and save it.  Also don't free it if it's
24347c478bd9Sstevel@tonic-gate  * NullHostName, because that's a special one we use if
24357c478bd9Sstevel@tonic-gate  * name service lookup fails.
24367c478bd9Sstevel@tonic-gate  *
24377c478bd9Sstevel@tonic-gate  * By having hostname cache, now host_list_t will be shared
24387c478bd9Sstevel@tonic-gate  * by messages and hostname cache. hl_refcnt is used for
24397c478bd9Sstevel@tonic-gate  * the purpose.
24407c478bd9Sstevel@tonic-gate  */
24417c478bd9Sstevel@tonic-gate static void
24427c478bd9Sstevel@tonic-gate freehl(host_list_t *h)
24437c478bd9Sstevel@tonic-gate {
24447c478bd9Sstevel@tonic-gate 	int i, refcnt;
24457c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
24467c478bd9Sstevel@tonic-gate 
24477c478bd9Sstevel@tonic-gate 	if (Debug) {
24487c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
24497c478bd9Sstevel@tonic-gate 	}
24507c478bd9Sstevel@tonic-gate 
24517c478bd9Sstevel@tonic-gate 	DPRINT2(2, "freehl(%u): releasing %p\n", mythreadno, h);
24527c478bd9Sstevel@tonic-gate 
24537c478bd9Sstevel@tonic-gate 	if (h == NULL || h == &LocalHostName || h == &NullHostName) {
24547c478bd9Sstevel@tonic-gate 		return;
24557c478bd9Sstevel@tonic-gate 	}
24567c478bd9Sstevel@tonic-gate 
24577c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&h->hl_mutex);
24587c478bd9Sstevel@tonic-gate 	refcnt = --h->hl_refcnt;
24597c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&h->hl_mutex);
24607c478bd9Sstevel@tonic-gate 
24617c478bd9Sstevel@tonic-gate 	if (refcnt != 0) {
24627c478bd9Sstevel@tonic-gate 		DPRINT3(5, "freehl(%u): %p has reference %d\n",
24637c478bd9Sstevel@tonic-gate 				mythreadno, h, refcnt);
24647c478bd9Sstevel@tonic-gate 		return;
24657c478bd9Sstevel@tonic-gate 	}
24667c478bd9Sstevel@tonic-gate 
24677c478bd9Sstevel@tonic-gate 	pthread_mutex_destroy(&h->hl_mutex);
24687c478bd9Sstevel@tonic-gate 
24697c478bd9Sstevel@tonic-gate 	DPRINT2(5, "freehl(%u): freeing %p\n", mythreadno, h);
24707c478bd9Sstevel@tonic-gate 
24717c478bd9Sstevel@tonic-gate 	for (i = 0; i < h->hl_cnt; i++) {
24727c478bd9Sstevel@tonic-gate 		free(h->hl_hosts[i]);
24737c478bd9Sstevel@tonic-gate 	}
24747c478bd9Sstevel@tonic-gate 
24757c478bd9Sstevel@tonic-gate 	free(h->hl_hosts);
24767c478bd9Sstevel@tonic-gate 	free(h);
24777c478bd9Sstevel@tonic-gate }
24787c478bd9Sstevel@tonic-gate 
24797c478bd9Sstevel@tonic-gate /*
24807c478bd9Sstevel@tonic-gate  * Create the door file and the pid file in /var/run.  If the filesystem
24817c478bd9Sstevel@tonic-gate  * containing /etc is writable, create symlinks /etc/.syslog_door and
24827c478bd9Sstevel@tonic-gate  * /etc/syslog.pid to them.  On systems that do not support /var/run, create
24837c478bd9Sstevel@tonic-gate  * /etc/.syslog_door and /etc/syslog.pid directly.
24847c478bd9Sstevel@tonic-gate  *
24857c478bd9Sstevel@tonic-gate  * Note: it is not considered fatal to fail to create the pid file or its
24867c478bd9Sstevel@tonic-gate  * symlink.  Attempts to use them in the usual way will fail, of course, but
24877c478bd9Sstevel@tonic-gate  * syslogd will function nicely without it (not so for the door file).
24887c478bd9Sstevel@tonic-gate  */
24897c478bd9Sstevel@tonic-gate 
24907c478bd9Sstevel@tonic-gate static void
24917c478bd9Sstevel@tonic-gate open_door(void)
24927c478bd9Sstevel@tonic-gate {
24937c478bd9Sstevel@tonic-gate 	struct stat buf;
24947c478bd9Sstevel@tonic-gate 	door_info_t info;
24957c478bd9Sstevel@tonic-gate 	char line[MAXLINE+1];
24967c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
24977c478bd9Sstevel@tonic-gate 	int err;
24987c478bd9Sstevel@tonic-gate 
24997c478bd9Sstevel@tonic-gate 	if (Debug) {
25007c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
25017c478bd9Sstevel@tonic-gate 	}
25027c478bd9Sstevel@tonic-gate 
25037c478bd9Sstevel@tonic-gate 	/*
25047c478bd9Sstevel@tonic-gate 	 * first see if another syslogd is running by trying
25057c478bd9Sstevel@tonic-gate 	 * a door call - if it succeeds, there is already
25067c478bd9Sstevel@tonic-gate 	 * a syslogd process active
25077c478bd9Sstevel@tonic-gate 	 */
25087c478bd9Sstevel@tonic-gate 
25097c478bd9Sstevel@tonic-gate 	if (!DoorCreated) {
25107c478bd9Sstevel@tonic-gate 		int door;
25117c478bd9Sstevel@tonic-gate 
25127c478bd9Sstevel@tonic-gate 		if ((door = open(DoorFileName, O_RDONLY)) >= 0) {
25137c478bd9Sstevel@tonic-gate 			DPRINT2(5, "open_door(%u): %s opened "
25147c478bd9Sstevel@tonic-gate 				"successfully\n", mythreadno, DoorFileName);
25157c478bd9Sstevel@tonic-gate 
25167c478bd9Sstevel@tonic-gate 			if (door_info(door, &info) >= 0) {
25177c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): "
25187c478bd9Sstevel@tonic-gate 					"door_info:info.di_target = %ld\n",
25197c478bd9Sstevel@tonic-gate 					mythreadno, info.di_target);
25207c478bd9Sstevel@tonic-gate 
25217c478bd9Sstevel@tonic-gate 				if (info.di_target > 0) {
25227c478bd9Sstevel@tonic-gate 					(void) sprintf(line, "syslogd pid %ld"
25237c478bd9Sstevel@tonic-gate 						" already running. Cannot "
25247c478bd9Sstevel@tonic-gate 						"start another syslogd pid %ld",
25257c478bd9Sstevel@tonic-gate 						info.di_target, getpid());
25267c478bd9Sstevel@tonic-gate 					DPRINT2(5, "open_door(%u): error: "
25277c478bd9Sstevel@tonic-gate 						"%s\n", mythreadno, line);
25287c478bd9Sstevel@tonic-gate 					errno = 0;
25297c478bd9Sstevel@tonic-gate 					logerror(line);
25307c478bd9Sstevel@tonic-gate 					exit(1);
25317c478bd9Sstevel@tonic-gate 				}
25327c478bd9Sstevel@tonic-gate 			}
25337c478bd9Sstevel@tonic-gate 
25347c478bd9Sstevel@tonic-gate 			(void) close(door);
25357c478bd9Sstevel@tonic-gate 		} else {
25367c478bd9Sstevel@tonic-gate 			if (lstat(DoorFileName, &buf) < 0) {
25377c478bd9Sstevel@tonic-gate 				err = errno;
25387c478bd9Sstevel@tonic-gate 
25397c478bd9Sstevel@tonic-gate 				DPRINT3(5, "open_door(%u): lstat() of %s "
25407c478bd9Sstevel@tonic-gate 					"failed, errno=%d\n",
25417c478bd9Sstevel@tonic-gate 					mythreadno, DoorFileName, err);
25427c478bd9Sstevel@tonic-gate 
25437c478bd9Sstevel@tonic-gate 				if ((door = creat(DoorFileName, 0644)) < 0) {
25447c478bd9Sstevel@tonic-gate 					err = errno;
25457c478bd9Sstevel@tonic-gate 					(void) sprintf(line, "creat() of %s "
25467c478bd9Sstevel@tonic-gate 						"failed - fatal", DoorFileName);
25477c478bd9Sstevel@tonic-gate 					DPRINT3(1, "open_door(%u): error: %s, "
25487c478bd9Sstevel@tonic-gate 						"errno=%d\n", mythreadno, line,
25497c478bd9Sstevel@tonic-gate 						err);
25507c478bd9Sstevel@tonic-gate 					errno = err;
25517c478bd9Sstevel@tonic-gate 					logerror(line);
25527c478bd9Sstevel@tonic-gate 					delete_doorfiles();
25537c478bd9Sstevel@tonic-gate 					exit(1);
25547c478bd9Sstevel@tonic-gate 				}
25557c478bd9Sstevel@tonic-gate 
25567c478bd9Sstevel@tonic-gate 				(void) fchmod(door,
25577c478bd9Sstevel@tonic-gate 					S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
25587c478bd9Sstevel@tonic-gate 
25597c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): creat() of %s "
25607c478bd9Sstevel@tonic-gate 					"succeeded\n", mythreadno,
25617c478bd9Sstevel@tonic-gate 					DoorFileName);
25627c478bd9Sstevel@tonic-gate 
25637c478bd9Sstevel@tonic-gate 				(void) close(door);
25647c478bd9Sstevel@tonic-gate 			}
25657c478bd9Sstevel@tonic-gate 		}
25667c478bd9Sstevel@tonic-gate 
25677c478bd9Sstevel@tonic-gate 		if (strcmp(DoorFileName, DOORFILE) == 0) {
25687c478bd9Sstevel@tonic-gate 			if (lstat(OLD_DOORFILE, &buf) == 0) {
25697c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): lstat() of %s "
25707c478bd9Sstevel@tonic-gate 					"succeeded\n", mythreadno,
25717c478bd9Sstevel@tonic-gate 					OLD_DOORFILE);
25727c478bd9Sstevel@tonic-gate 
25737c478bd9Sstevel@tonic-gate 				if (S_ISDIR(buf.st_mode)) {
25747c478bd9Sstevel@tonic-gate 					(void) sprintf(line, "%s is a "
25757c478bd9Sstevel@tonic-gate 						"directory - fatal",
25767c478bd9Sstevel@tonic-gate 						OLD_DOORFILE);
25777c478bd9Sstevel@tonic-gate 					DPRINT2(1, "open_door(%u): error: "
25787c478bd9Sstevel@tonic-gate 						"%s\n", mythreadno, line);
25797c478bd9Sstevel@tonic-gate 					errno = 0;
25807c478bd9Sstevel@tonic-gate 					logerror(line);
25817c478bd9Sstevel@tonic-gate 					delete_doorfiles();
25827c478bd9Sstevel@tonic-gate 					exit(1);
25837c478bd9Sstevel@tonic-gate 				}
25847c478bd9Sstevel@tonic-gate 
25857c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): %s is not a "
25867c478bd9Sstevel@tonic-gate 					"directory\n",
25877c478bd9Sstevel@tonic-gate 					mythreadno, OLD_DOORFILE);
25887c478bd9Sstevel@tonic-gate 
25897c478bd9Sstevel@tonic-gate 				if (unlink(OLD_DOORFILE) < 0) {
25907c478bd9Sstevel@tonic-gate 					err = errno;
25917c478bd9Sstevel@tonic-gate 					(void) sprintf(line, "unlink() of %s "
25927c478bd9Sstevel@tonic-gate 						"failed", OLD_DOORFILE);
25937c478bd9Sstevel@tonic-gate 					DPRINT2(5, "open_door(%u): %s\n",
25947c478bd9Sstevel@tonic-gate 						mythreadno, line);
25957c478bd9Sstevel@tonic-gate 
25967c478bd9Sstevel@tonic-gate 					if (err != EROFS) {
25977c478bd9Sstevel@tonic-gate 						DPRINT3(1, "open_door(%u): "
25987c478bd9Sstevel@tonic-gate 							"error: %s, "
25997c478bd9Sstevel@tonic-gate 							"errno=%d\n",
26007c478bd9Sstevel@tonic-gate 							mythreadno, line, err);
26017c478bd9Sstevel@tonic-gate 						(void) strcat(line, " - fatal");
26027c478bd9Sstevel@tonic-gate 						errno = err;
26037c478bd9Sstevel@tonic-gate 						logerror(line);
26047c478bd9Sstevel@tonic-gate 						delete_doorfiles();
26057c478bd9Sstevel@tonic-gate 						exit(1);
26067c478bd9Sstevel@tonic-gate 					}
26077c478bd9Sstevel@tonic-gate 
26087c478bd9Sstevel@tonic-gate 					DPRINT1(5, "open_door(%u): unlink "
26097c478bd9Sstevel@tonic-gate 						"failure OK on RO file "
26107c478bd9Sstevel@tonic-gate 						"system\n", mythreadno);
26117c478bd9Sstevel@tonic-gate 				}
26127c478bd9Sstevel@tonic-gate 			} else {
26137c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): file %s doesn't "
26147c478bd9Sstevel@tonic-gate 					"exist\n", mythreadno, OLD_DOORFILE);
26157c478bd9Sstevel@tonic-gate 			}
26167c478bd9Sstevel@tonic-gate 
26177c478bd9Sstevel@tonic-gate 			if (symlink(RELATIVE_DOORFILE, OLD_DOORFILE) < 0) {
26187c478bd9Sstevel@tonic-gate 				err = errno;
26197c478bd9Sstevel@tonic-gate 				(void) sprintf(line, "symlink %s -> %s "
26207c478bd9Sstevel@tonic-gate 					"failed", OLD_DOORFILE,
26217c478bd9Sstevel@tonic-gate 					RELATIVE_DOORFILE);
26227c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): %s\n", mythreadno,
26237c478bd9Sstevel@tonic-gate 					line);
26247c478bd9Sstevel@tonic-gate 
26257c478bd9Sstevel@tonic-gate 				if (err != EROFS) {
26267c478bd9Sstevel@tonic-gate 					DPRINT3(1, "open_door(%u): error: %s, "
26277c478bd9Sstevel@tonic-gate 						"errno=%d\n", mythreadno, line,
26287c478bd9Sstevel@tonic-gate 						err);
26297c478bd9Sstevel@tonic-gate 					errno = err;
26307c478bd9Sstevel@tonic-gate 					(void) strcat(line, " - fatal");
26317c478bd9Sstevel@tonic-gate 					logerror(line);
26327c478bd9Sstevel@tonic-gate 					delete_doorfiles();
26337c478bd9Sstevel@tonic-gate 					exit(1);
26347c478bd9Sstevel@tonic-gate 				}
26357c478bd9Sstevel@tonic-gate 
26367c478bd9Sstevel@tonic-gate 				DPRINT1(5, "open_door(%u): symlink failure OK "
26377c478bd9Sstevel@tonic-gate 					"on RO file system\n", mythreadno);
26387c478bd9Sstevel@tonic-gate 			} else {
26397c478bd9Sstevel@tonic-gate 				DPRINT3(5, "open_door(%u): symlink %s -> %s "
26407c478bd9Sstevel@tonic-gate 					"succeeded\n", mythreadno,
26417c478bd9Sstevel@tonic-gate 					OLD_DOORFILE, RELATIVE_DOORFILE);
26427c478bd9Sstevel@tonic-gate 			}
26437c478bd9Sstevel@tonic-gate 		}
26447c478bd9Sstevel@tonic-gate 
26457c478bd9Sstevel@tonic-gate 		if ((DoorFd = door_create(server, 0,
26467c478bd9Sstevel@tonic-gate 		    DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) < 0) {
26477c478bd9Sstevel@tonic-gate 			err = errno;
26487c478bd9Sstevel@tonic-gate 			(void) sprintf(line, "door_create() failed - fatal");
26497c478bd9Sstevel@tonic-gate 			DPRINT3(1, "open_door(%u): error: %s, errno=%d\n",
26507c478bd9Sstevel@tonic-gate 				mythreadno, line, err);
26517c478bd9Sstevel@tonic-gate 			errno = err;
26527c478bd9Sstevel@tonic-gate 			logerror(line);
26537c478bd9Sstevel@tonic-gate 			delete_doorfiles();
26547c478bd9Sstevel@tonic-gate 			exit(1);
26557c478bd9Sstevel@tonic-gate 		}
26567c478bd9Sstevel@tonic-gate 		(void) door_setparam(DoorFd, DOOR_PARAM_DATA_MAX, 0);
26577c478bd9Sstevel@tonic-gate 		DPRINT2(5, "open_door(%u): door_create() succeeded, "
26587c478bd9Sstevel@tonic-gate 			"DoorFd=%d\n", mythreadno, DoorFd);
26597c478bd9Sstevel@tonic-gate 
26607c478bd9Sstevel@tonic-gate 		DoorCreated = 1;
26617c478bd9Sstevel@tonic-gate 	}
26627c478bd9Sstevel@tonic-gate 
26637c478bd9Sstevel@tonic-gate 	(void) fdetach(DoorFileName);	/* just in case... */
26647c478bd9Sstevel@tonic-gate 
26657c478bd9Sstevel@tonic-gate 	if (fattach(DoorFd, DoorFileName) < 0) {
26667c478bd9Sstevel@tonic-gate 		err = errno;
26677c478bd9Sstevel@tonic-gate 		(void) sprintf(line, "fattach() of fd"
26687c478bd9Sstevel@tonic-gate 			" %d to %s failed - fatal",
26697c478bd9Sstevel@tonic-gate 			DoorFd, DoorFileName);
26707c478bd9Sstevel@tonic-gate 		DPRINT3(1, "open_door(%u): error: %s, errno=%d\n", mythreadno,
26717c478bd9Sstevel@tonic-gate 			line, err);
26727c478bd9Sstevel@tonic-gate 		errno = err;
26737c478bd9Sstevel@tonic-gate 		logerror(line);
26747c478bd9Sstevel@tonic-gate 		delete_doorfiles();
26757c478bd9Sstevel@tonic-gate 		exit(1);
26767c478bd9Sstevel@tonic-gate 	}
26777c478bd9Sstevel@tonic-gate 
26787c478bd9Sstevel@tonic-gate 	DPRINT2(5, "open_door(%u): attached server() to %s\n", mythreadno,
26797c478bd9Sstevel@tonic-gate 		DoorFileName);
26807c478bd9Sstevel@tonic-gate 
26817c478bd9Sstevel@tonic-gate 	/*
26827c478bd9Sstevel@tonic-gate 	 * create pidfile anyway, so those using it to control
26837c478bd9Sstevel@tonic-gate 	 * syslogd (with kill `cat /etc/syslog.pid` perhaps)
26847c478bd9Sstevel@tonic-gate 	 * don't get broken.
26857c478bd9Sstevel@tonic-gate 	 */
26867c478bd9Sstevel@tonic-gate 
26877c478bd9Sstevel@tonic-gate 	if (!PidfileCreated) {
26887c478bd9Sstevel@tonic-gate 		int pidfd;
26897c478bd9Sstevel@tonic-gate 
26907c478bd9Sstevel@tonic-gate 		PidfileCreated = 1;
26917c478bd9Sstevel@tonic-gate 
26927c478bd9Sstevel@tonic-gate 		if ((pidfd = open(PidFileName, O_RDWR|O_CREAT|O_TRUNC, 0644))
26937c478bd9Sstevel@tonic-gate 		    < 0) {
26947c478bd9Sstevel@tonic-gate 			err = errno;
26957c478bd9Sstevel@tonic-gate 			(void) sprintf(line, "open() of %s failed",
26967c478bd9Sstevel@tonic-gate 				PidFileName);
26977c478bd9Sstevel@tonic-gate 			DPRINT3(1, "open_door(%u): warning: %s, errno=%d\n",
26987c478bd9Sstevel@tonic-gate 				mythreadno, line, err);
26997c478bd9Sstevel@tonic-gate 			errno = err;
27007c478bd9Sstevel@tonic-gate 			logerror(line);
27017c478bd9Sstevel@tonic-gate 			return;
27027c478bd9Sstevel@tonic-gate 		}
27037c478bd9Sstevel@tonic-gate 
27047c478bd9Sstevel@tonic-gate 		(void) fchmod(pidfd, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
27057c478bd9Sstevel@tonic-gate 		(void) sprintf(line, "%ld\n", getpid());
27067c478bd9Sstevel@tonic-gate 
27077c478bd9Sstevel@tonic-gate 		if (write(pidfd, line, strlen(line)) < 0) {
27087c478bd9Sstevel@tonic-gate 			err = errno;
27097c478bd9Sstevel@tonic-gate 			(void) sprintf(line, "write to %s on fd %d failed",
27107c478bd9Sstevel@tonic-gate 				PidFileName, pidfd);
27117c478bd9Sstevel@tonic-gate 			DPRINT3(1, "open_door(%u): warning: %s, errno=%d\n",
27127c478bd9Sstevel@tonic-gate 				mythreadno, line, err);
27137c478bd9Sstevel@tonic-gate 			errno = err;
27147c478bd9Sstevel@tonic-gate 			logerror(line);
27157c478bd9Sstevel@tonic-gate 			return;
27167c478bd9Sstevel@tonic-gate 		}
27177c478bd9Sstevel@tonic-gate 
27187c478bd9Sstevel@tonic-gate 		(void) close(pidfd);
27197c478bd9Sstevel@tonic-gate 
27207c478bd9Sstevel@tonic-gate 		DPRINT2(5, "open_door(%u): %s created\n",
27217c478bd9Sstevel@tonic-gate 			mythreadno, PidFileName);
27227c478bd9Sstevel@tonic-gate 
27237c478bd9Sstevel@tonic-gate 		if (strcmp(PidFileName, PIDFILE) == 0) {
27247c478bd9Sstevel@tonic-gate 			if (lstat(OLD_PIDFILE, &buf) == 0) {
27257c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): lstat() of %s "
27267c478bd9Sstevel@tonic-gate 					"succeded\n", mythreadno, OLD_PIDFILE);
27277c478bd9Sstevel@tonic-gate 
27287c478bd9Sstevel@tonic-gate 				if (S_ISDIR(buf.st_mode)) {
27297c478bd9Sstevel@tonic-gate 					(void) sprintf(line, "file %s is a "
27307c478bd9Sstevel@tonic-gate 						"directory",
27317c478bd9Sstevel@tonic-gate 						OLD_PIDFILE);
27327c478bd9Sstevel@tonic-gate 					DPRINT2(1, "open_door(%u): warning: "
27337c478bd9Sstevel@tonic-gate 						"%s\n", mythreadno, line);
27347c478bd9Sstevel@tonic-gate 					errno = 0;
27357c478bd9Sstevel@tonic-gate 					logerror(line);
27367c478bd9Sstevel@tonic-gate 					return;
27377c478bd9Sstevel@tonic-gate 				}
27387c478bd9Sstevel@tonic-gate 
27397c478bd9Sstevel@tonic-gate 				if (unlink(OLD_PIDFILE) < 0) {
27407c478bd9Sstevel@tonic-gate 					err = errno;
27417c478bd9Sstevel@tonic-gate 					(void) sprintf(line, "unlink() "
27427c478bd9Sstevel@tonic-gate 						"of %s failed", OLD_PIDFILE);
27437c478bd9Sstevel@tonic-gate 					DPRINT2(5, "open_door(%u): %s\n",
27447c478bd9Sstevel@tonic-gate 						mythreadno, line);
27457c478bd9Sstevel@tonic-gate 
27467c478bd9Sstevel@tonic-gate 					if (err != EROFS) {
27477c478bd9Sstevel@tonic-gate 						DPRINT3(1, "open_door (%u): "
27487c478bd9Sstevel@tonic-gate 							"warning: %s, "
27497c478bd9Sstevel@tonic-gate 							"errno=%d\n",
27507c478bd9Sstevel@tonic-gate 							mythreadno, line, err);
27517c478bd9Sstevel@tonic-gate 						errno = err;
27527c478bd9Sstevel@tonic-gate 						logerror(line);
27537c478bd9Sstevel@tonic-gate 						return;
27547c478bd9Sstevel@tonic-gate 					}
27557c478bd9Sstevel@tonic-gate 
27567c478bd9Sstevel@tonic-gate 					DPRINT1(5, "open_door(%u): unlink "
27577c478bd9Sstevel@tonic-gate 						"failure OK on RO file "
27587c478bd9Sstevel@tonic-gate 						"system\n", mythreadno);
27597c478bd9Sstevel@tonic-gate 				}
27607c478bd9Sstevel@tonic-gate 			} else {
27617c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): file %s doesn't "
27627c478bd9Sstevel@tonic-gate 					"exist\n", mythreadno, OLD_PIDFILE);
27637c478bd9Sstevel@tonic-gate 			}
27647c478bd9Sstevel@tonic-gate 
27657c478bd9Sstevel@tonic-gate 			if (symlink(RELATIVE_PIDFILE, OLD_PIDFILE) < 0) {
27667c478bd9Sstevel@tonic-gate 				err = errno;
27677c478bd9Sstevel@tonic-gate 				(void) sprintf(line, "symlink %s -> %s "
27687c478bd9Sstevel@tonic-gate 					"failed", OLD_PIDFILE,
27697c478bd9Sstevel@tonic-gate 					RELATIVE_PIDFILE);
27707c478bd9Sstevel@tonic-gate 				DPRINT2(5, "open_door(%u): %s\n", mythreadno,
27717c478bd9Sstevel@tonic-gate 					line);
27727c478bd9Sstevel@tonic-gate 
27737c478bd9Sstevel@tonic-gate 				if (err != EROFS) {
27747c478bd9Sstevel@tonic-gate 					DPRINT3(1, "open_door(%u): warning: "
27757c478bd9Sstevel@tonic-gate 						"%s, errno=%d\n", mythreadno,
27767c478bd9Sstevel@tonic-gate 						line, err);
27777c478bd9Sstevel@tonic-gate 					errno = err;
27787c478bd9Sstevel@tonic-gate 					logerror(line);
27797c478bd9Sstevel@tonic-gate 					return;
27807c478bd9Sstevel@tonic-gate 				}
27817c478bd9Sstevel@tonic-gate 
27827c478bd9Sstevel@tonic-gate 				DPRINT1(5, "open_door(%u): symlink failure OK "
27837c478bd9Sstevel@tonic-gate 					"on RO file system\n", mythreadno);
27847c478bd9Sstevel@tonic-gate 				return;
27857c478bd9Sstevel@tonic-gate 			}
27867c478bd9Sstevel@tonic-gate 
27877c478bd9Sstevel@tonic-gate 			DPRINT3(5, "open_door(%u): symlink %s -> %s "
27887c478bd9Sstevel@tonic-gate 				"succeeded\n", mythreadno, OLD_PIDFILE,
27897c478bd9Sstevel@tonic-gate 				RELATIVE_PIDFILE);
27907c478bd9Sstevel@tonic-gate 		}
27917c478bd9Sstevel@tonic-gate 	}
27927c478bd9Sstevel@tonic-gate }
27937c478bd9Sstevel@tonic-gate 
27947c478bd9Sstevel@tonic-gate /*
27957c478bd9Sstevel@tonic-gate  * the 'server' function that we export via the door. It does
27967c478bd9Sstevel@tonic-gate  * nothing but return.
27977c478bd9Sstevel@tonic-gate  */
27987c478bd9Sstevel@tonic-gate /*ARGSUSED*/
27997c478bd9Sstevel@tonic-gate static void
28007c478bd9Sstevel@tonic-gate server(void *cookie, char *argp, size_t arg_size,
28017c478bd9Sstevel@tonic-gate     door_desc_t *dp, uint_t n)
28027c478bd9Sstevel@tonic-gate {
28037c478bd9Sstevel@tonic-gate 	(void) door_return(NULL, 0, NULL, 0);
28047c478bd9Sstevel@tonic-gate 	/* NOTREACHED */
28057c478bd9Sstevel@tonic-gate }
28067c478bd9Sstevel@tonic-gate 
28077c478bd9Sstevel@tonic-gate /*
28087c478bd9Sstevel@tonic-gate  * checkm4 - used to verify that the external utilities that
28097c478bd9Sstevel@tonic-gate  * syslogd depends on are where we expect them to be.
28107c478bd9Sstevel@tonic-gate  * Returns 0 if all utilities are found, > 0 if any are missing.
28117c478bd9Sstevel@tonic-gate  * Also logs errors so user knows what's missing
28127c478bd9Sstevel@tonic-gate  */
28137c478bd9Sstevel@tonic-gate static int
28147c478bd9Sstevel@tonic-gate checkm4(void)
28157c478bd9Sstevel@tonic-gate {
28167c478bd9Sstevel@tonic-gate 	int notfound = 0;
28177c478bd9Sstevel@tonic-gate 	int saverrno;
28187c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
28197c478bd9Sstevel@tonic-gate 
28207c478bd9Sstevel@tonic-gate 	if (Debug) {
28217c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
28227c478bd9Sstevel@tonic-gate 	}
28237c478bd9Sstevel@tonic-gate 
28247c478bd9Sstevel@tonic-gate 	if (access("/usr/ccs/bin/m4", X_OK) < 0) {
28257c478bd9Sstevel@tonic-gate 		saverrno = errno;
28267c478bd9Sstevel@tonic-gate 		logerror("/usr/ccs/bin/m4");
28277c478bd9Sstevel@tonic-gate 		DPRINT2(1, "checkm4(%u): /usr/ccs/bin/m4 - access "
28287c478bd9Sstevel@tonic-gate 			"returned %d\n", mythreadno, saverrno);
28297c478bd9Sstevel@tonic-gate 		notfound++;
28307c478bd9Sstevel@tonic-gate 	}
28317c478bd9Sstevel@tonic-gate 
28327c478bd9Sstevel@tonic-gate 	return (notfound);
28337c478bd9Sstevel@tonic-gate }
28347c478bd9Sstevel@tonic-gate 
28357c478bd9Sstevel@tonic-gate /*
28367c478bd9Sstevel@tonic-gate  *  INIT -- Initialize syslogd from configuration table, start up
28377c478bd9Sstevel@tonic-gate  *  input and logger threads. This routine is called only once.
28387c478bd9Sstevel@tonic-gate  */
28397c478bd9Sstevel@tonic-gate static void
28407c478bd9Sstevel@tonic-gate init(void)
28417c478bd9Sstevel@tonic-gate {
28427c478bd9Sstevel@tonic-gate 	struct utsname *up;
28437c478bd9Sstevel@tonic-gate 	pthread_attr_t sys_attr, net_attr, log_attr, hnl_attr;
28447c478bd9Sstevel@tonic-gate 	int nthread;
28457c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
28467c478bd9Sstevel@tonic-gate 
28477c478bd9Sstevel@tonic-gate 	if (Debug) {
28487c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
28497c478bd9Sstevel@tonic-gate 	}
28507c478bd9Sstevel@tonic-gate 
28517c478bd9Sstevel@tonic-gate 	DPRINT1(2, "init(%u): initializing\n", mythreadno);
28527c478bd9Sstevel@tonic-gate 
28537c478bd9Sstevel@tonic-gate 	/* hand-craft a host_list_t entry for our local host name */
28547c478bd9Sstevel@tonic-gate 	if ((up = malloc(sizeof (struct utsname))) == NULL) {
28557c478bd9Sstevel@tonic-gate 		MALLOC_FAIL_EXIT;
28567c478bd9Sstevel@tonic-gate 	}
28577c478bd9Sstevel@tonic-gate 	(void) uname(up);
28587c478bd9Sstevel@tonic-gate 	LocalHostName.hl_cnt = 1;
28597c478bd9Sstevel@tonic-gate 	if ((LocalHostName.hl_hosts = malloc(sizeof (char *))) == NULL) {
28607c478bd9Sstevel@tonic-gate 		MALLOC_FAIL_EXIT;
28617c478bd9Sstevel@tonic-gate 	}
28627c478bd9Sstevel@tonic-gate 	if ((LocalHostName.hl_hosts[0] = strdup(up->nodename)) == NULL) {
28637c478bd9Sstevel@tonic-gate 		free(LocalHostName.hl_hosts);
28647c478bd9Sstevel@tonic-gate 		MALLOC_FAIL_EXIT;
28657c478bd9Sstevel@tonic-gate 	}
28667c478bd9Sstevel@tonic-gate 	free(up);
28677c478bd9Sstevel@tonic-gate 	/* also hand craft one for use if name resolution fails */
28687c478bd9Sstevel@tonic-gate 	NullHostName.hl_cnt = 1;
28697c478bd9Sstevel@tonic-gate 	if ((NullHostName.hl_hosts = malloc(sizeof (char *))) == NULL) {
28707c478bd9Sstevel@tonic-gate 		MALLOC_FAIL_EXIT;
28717c478bd9Sstevel@tonic-gate 	}
28727c478bd9Sstevel@tonic-gate 	if ((NullHostName.hl_hosts[0] = strdup("name lookup failed")) == NULL) {
28737c478bd9Sstevel@tonic-gate 		MALLOC_FAIL_EXIT;
28747c478bd9Sstevel@tonic-gate 	}
28757c478bd9Sstevel@tonic-gate 
28767c478bd9Sstevel@tonic-gate 	hnc_init(0);
28777c478bd9Sstevel@tonic-gate 
28787c478bd9Sstevel@tonic-gate 	/*
28797c478bd9Sstevel@tonic-gate 	 * Note that getnets will allocate network resources, but won't be
28807c478bd9Sstevel@tonic-gate 	 * binding UDP port. This is because, there could be a race
28817c478bd9Sstevel@tonic-gate 	 * condition between door. If we bind here, one syslogd could grab
28827c478bd9Sstevel@tonic-gate 	 * UDP port first, but later another syslogd could take over without
28837c478bd9Sstevel@tonic-gate 	 * getting UDP port but grab the door file. The 2nd syslogd could
28847c478bd9Sstevel@tonic-gate 	 * continue to run without listening network.
28857c478bd9Sstevel@tonic-gate 	 * bindnet() will be called after door was successfully opened.
28867c478bd9Sstevel@tonic-gate 	 */
28877c478bd9Sstevel@tonic-gate 	getnets();
28887c478bd9Sstevel@tonic-gate 
28897c478bd9Sstevel@tonic-gate 	/*
28907c478bd9Sstevel@tonic-gate 	 * Start up configured theads
28917c478bd9Sstevel@tonic-gate 	 */
28927c478bd9Sstevel@tonic-gate 	conf_init();
28937c478bd9Sstevel@tonic-gate 
28947c478bd9Sstevel@tonic-gate 	/*
28957c478bd9Sstevel@tonic-gate 	 * allocate thread stacks for the persistant threads
28967c478bd9Sstevel@tonic-gate 	 */
28977c478bd9Sstevel@tonic-gate 	nthread = (turnoff == 0) ? 4 : 2;
28987c478bd9Sstevel@tonic-gate 
28997c478bd9Sstevel@tonic-gate 	if ((stack_ptr = alloc_stacks(nthread)) == NULL) {
29007c478bd9Sstevel@tonic-gate 		logerror("alloc_stacks failed - fatal");
29017c478bd9Sstevel@tonic-gate 		exit(1);
29027c478bd9Sstevel@tonic-gate 	}
29037c478bd9Sstevel@tonic-gate 
29047c478bd9Sstevel@tonic-gate 	if (Debug) {
29057c478bd9Sstevel@tonic-gate 		dumpstats(STDOUT_FILENO);
29067c478bd9Sstevel@tonic-gate 	}
29077c478bd9Sstevel@tonic-gate 
29087c478bd9Sstevel@tonic-gate 	(void) dataq_init(&inputq);	/* init the input queue */
29097c478bd9Sstevel@tonic-gate 
29107c478bd9Sstevel@tonic-gate 	if (pthread_attr_init(&sys_attr) != 0 ||
29117c478bd9Sstevel@tonic-gate 	    pthread_attr_init(&log_attr) != 0 ||
29127c478bd9Sstevel@tonic-gate 	    pthread_attr_init(&net_attr) != 0 ||
29137c478bd9Sstevel@tonic-gate 	    pthread_attr_init(&hnl_attr) != 0) {
29147c478bd9Sstevel@tonic-gate 		logerror("pthread_attr_init failed - fatal");
29157c478bd9Sstevel@tonic-gate 		exit(1);
29167c478bd9Sstevel@tonic-gate 	}
29177c478bd9Sstevel@tonic-gate 
29187c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setscope(&sys_attr, PTHREAD_SCOPE_PROCESS);
29197c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setscope(&log_attr, PTHREAD_SCOPE_PROCESS);
29207c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setscope(&net_attr, PTHREAD_SCOPE_PROCESS);
29217c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setscope(&hnl_attr, PTHREAD_SCOPE_PROCESS);
29227c478bd9Sstevel@tonic-gate 
29237c478bd9Sstevel@tonic-gate 	/* 1: logmsg thread */
29247c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setstacksize(&log_attr, stacksize);
29257c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setstackaddr(&log_attr, stack_ptr);
29267c478bd9Sstevel@tonic-gate 	stack_ptr += stacksize + redzonesize;
29277c478bd9Sstevel@tonic-gate 	if (pthread_create(&log_thread, &log_attr, logmsg, NULL) != 0) {
29287c478bd9Sstevel@tonic-gate 		logerror("pthread_create failed - fatal");
29297c478bd9Sstevel@tonic-gate 		exit(1);
29307c478bd9Sstevel@tonic-gate 	}
29317c478bd9Sstevel@tonic-gate 
29327c478bd9Sstevel@tonic-gate 	/*
29337c478bd9Sstevel@tonic-gate 	 * open the log device, and pull up all pending message
29347c478bd9Sstevel@tonic-gate 	 * from the log driver.
29357c478bd9Sstevel@tonic-gate 	 */
29367c478bd9Sstevel@tonic-gate 	prepare_sys_poll();
29377c478bd9Sstevel@tonic-gate 
29387c478bd9Sstevel@tonic-gate 	/*
29397c478bd9Sstevel@tonic-gate 	 * Now we can deliver the pending internal error messages.
29407c478bd9Sstevel@tonic-gate 	 */
29417c478bd9Sstevel@tonic-gate 	enable_errorlog();
29427c478bd9Sstevel@tonic-gate 
29437c478bd9Sstevel@tonic-gate 	/* 2: sys_poll thread */
29447c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setstacksize(&sys_attr, stacksize);
29457c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setstackaddr(&sys_attr, stack_ptr);
29467c478bd9Sstevel@tonic-gate 	stack_ptr += stacksize + redzonesize;
29477c478bd9Sstevel@tonic-gate 	if (pthread_create(&sys_thread, &sys_attr, sys_poll, NULL) != 0) {
29487c478bd9Sstevel@tonic-gate 		logerror("pthread_create failed - fatal");
29497c478bd9Sstevel@tonic-gate 		exit(1);
29507c478bd9Sstevel@tonic-gate 	}
29517c478bd9Sstevel@tonic-gate 
29527c478bd9Sstevel@tonic-gate 	/*
29537c478bd9Sstevel@tonic-gate 	 * We've started the sys_poll() and logmsg() threads.  Now we are ready
29547c478bd9Sstevel@tonic-gate 	 * to open the door.  This cannot happen before spawning sys_poll(),
29557c478bd9Sstevel@tonic-gate 	 * because after opening the door, syslog() will no longer take care of
29567c478bd9Sstevel@tonic-gate 	 * LOG_CONS.  Therefor, we should pull up all pending log messages and
29577c478bd9Sstevel@tonic-gate 	 * activate sys_poll() before opening the door, so that log driver
29587c478bd9Sstevel@tonic-gate 	 * won't drop messages.
29597c478bd9Sstevel@tonic-gate 	 */
29607c478bd9Sstevel@tonic-gate 	open_door();
29617c478bd9Sstevel@tonic-gate 
29627c478bd9Sstevel@tonic-gate 	DPRINT1(1, "init(%u): accepting messages from local system\n",
29637c478bd9Sstevel@tonic-gate 			mythreadno);
29647c478bd9Sstevel@tonic-gate 
29657c478bd9Sstevel@tonic-gate 	if (turnoff == 0) {
29667c478bd9Sstevel@tonic-gate 		/* init the hostname lookup queue */
29677c478bd9Sstevel@tonic-gate 		(void) dataq_init(&hnlq);
29687c478bd9Sstevel@tonic-gate 
29697c478bd9Sstevel@tonic-gate 		/* 3: hostname lookup thread */
29707c478bd9Sstevel@tonic-gate 		(void) pthread_attr_setstacksize(&hnl_attr, stacksize);
29717c478bd9Sstevel@tonic-gate 		(void) pthread_attr_setstackaddr(&hnl_attr, stack_ptr);
29727c478bd9Sstevel@tonic-gate 		stack_ptr += stacksize + redzonesize;
29737c478bd9Sstevel@tonic-gate 		if (pthread_create(&hnl_thread, &hnl_attr,
29747c478bd9Sstevel@tonic-gate 				hostname_lookup, NULL) != 0) {
29757c478bd9Sstevel@tonic-gate 			logerror("pthread_create failed - fatal");
29767c478bd9Sstevel@tonic-gate 			exit(1);
29777c478bd9Sstevel@tonic-gate 		}
29787c478bd9Sstevel@tonic-gate 
29797c478bd9Sstevel@tonic-gate 		/* 4: net_poll thread */
29807c478bd9Sstevel@tonic-gate 		(void) pthread_attr_setstacksize(&net_attr, stacksize);
29817c478bd9Sstevel@tonic-gate 		(void) pthread_attr_setstackaddr(&net_attr, stack_ptr);
29827c478bd9Sstevel@tonic-gate 		stack_ptr += stacksize + redzonesize;
29837c478bd9Sstevel@tonic-gate 
29847c478bd9Sstevel@tonic-gate 		/* grab UDP port */
29857c478bd9Sstevel@tonic-gate 		bindnet();
29867c478bd9Sstevel@tonic-gate 
29877c478bd9Sstevel@tonic-gate 		if (pthread_create(&net_thread, &net_attr, net_poll,
29887c478bd9Sstevel@tonic-gate 					NULL) != 0) {
29897c478bd9Sstevel@tonic-gate 			logerror("pthread_create failed - fatal");
29907c478bd9Sstevel@tonic-gate 			exit(1);
29917c478bd9Sstevel@tonic-gate 		}
29927c478bd9Sstevel@tonic-gate 		DPRINT1(1, "init(%u): accepting messages from remote\n",
29937c478bd9Sstevel@tonic-gate 				mythreadno);
29947c478bd9Sstevel@tonic-gate 	}
29957c478bd9Sstevel@tonic-gate 
29967c478bd9Sstevel@tonic-gate 	(void) pthread_attr_destroy(&sys_attr);
29977c478bd9Sstevel@tonic-gate 	(void) pthread_attr_destroy(&net_attr);
29987c478bd9Sstevel@tonic-gate 	(void) pthread_attr_destroy(&log_attr);
29997c478bd9Sstevel@tonic-gate 	(void) pthread_attr_destroy(&hnl_attr);
30007c478bd9Sstevel@tonic-gate 
30017c478bd9Sstevel@tonic-gate 	curalarm = MarkInterval * 60 / MARKCOUNT;
30027c478bd9Sstevel@tonic-gate 	(void) alarm((unsigned)curalarm);
30037c478bd9Sstevel@tonic-gate 	DPRINT2(2, "init(%u): Next alarm in %d seconds\n",
30047c478bd9Sstevel@tonic-gate 		mythreadno, curalarm);
30057c478bd9Sstevel@tonic-gate 	DPRINT1(1, "init(%u): syslogd: started\n", mythreadno);
30067c478bd9Sstevel@tonic-gate }
30077c478bd9Sstevel@tonic-gate 
30087c478bd9Sstevel@tonic-gate /*
30097c478bd9Sstevel@tonic-gate  * will print a bunch of debugging stats on 'fd'
30107c478bd9Sstevel@tonic-gate  */
30117c478bd9Sstevel@tonic-gate static void
30127c478bd9Sstevel@tonic-gate dumpstats(int fd)
30137c478bd9Sstevel@tonic-gate {
30147c478bd9Sstevel@tonic-gate 	FILE *out;
30157c478bd9Sstevel@tonic-gate 	struct filed *f;
30167c478bd9Sstevel@tonic-gate 	int i;
30177c478bd9Sstevel@tonic-gate 	char users[1024];
30187c478bd9Sstevel@tonic-gate 	char cbuf[30];
30197c478bd9Sstevel@tonic-gate 	char *dashes = "------------------------";
30207c478bd9Sstevel@tonic-gate 	static int conversion_printed;
30217c478bd9Sstevel@tonic-gate 
30227c478bd9Sstevel@tonic-gate 	if ((out = fdopen(fd, "w+")) == NULL)
30237c478bd9Sstevel@tonic-gate 		return;
30247c478bd9Sstevel@tonic-gate 
30257c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "\n  syslogd: version %s\n", Version);
30267c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "  Started: %s", ctime_r(&start_time, cbuf));
30277c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "Input message count: system %d, network %d\n",
30287c478bd9Sstevel@tonic-gate 		sys_msg_count, net_msg_count);
30297c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "# Outputs: %d\n\n", nlogs);
30307c478bd9Sstevel@tonic-gate 
30317c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "%s priority = [file, facility] %s\n\n",
30327c478bd9Sstevel@tonic-gate 		dashes, dashes);
30337c478bd9Sstevel@tonic-gate 
30347c478bd9Sstevel@tonic-gate 	for (i = 0; i < LOG_NFACILITIES + 1; i++) {
30357c478bd9Sstevel@tonic-gate 		(void) fprintf(out, "%d ", i / 10);
30367c478bd9Sstevel@tonic-gate 	}
30377c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "\n");
30387c478bd9Sstevel@tonic-gate 	for (i = 0; i < LOG_NFACILITIES + 1; i++) {
30397c478bd9Sstevel@tonic-gate 		(void) fprintf(out, "%d ", i % 10);
30407c478bd9Sstevel@tonic-gate 	}
30417c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "\n");
30427c478bd9Sstevel@tonic-gate 	for (i = 0; i < LOG_NFACILITIES + 1; i++) {
30437c478bd9Sstevel@tonic-gate 		(void) fprintf(out, "--");
30447c478bd9Sstevel@tonic-gate 	}
30457c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "\n");
30467c478bd9Sstevel@tonic-gate 
30477c478bd9Sstevel@tonic-gate 	for (f = Files; f < &Files[nlogs]; f++) {
30487c478bd9Sstevel@tonic-gate 		for (i = 0; i < LOG_NFACILITIES + 1; i++) {
30497c478bd9Sstevel@tonic-gate 			if (f->f_pmask[i] == NOPRI)
30507c478bd9Sstevel@tonic-gate 				(void) fprintf(out, "X ");
30517c478bd9Sstevel@tonic-gate 			else
30527c478bd9Sstevel@tonic-gate 				(void) fprintf(out, "%d ",
30537c478bd9Sstevel@tonic-gate 					f->f_pmask[i]);
30547c478bd9Sstevel@tonic-gate 		}
30557c478bd9Sstevel@tonic-gate 		(void) fprintf(out, "%s: ", TypeNames[f->f_type]);
30567c478bd9Sstevel@tonic-gate 		switch (f->f_type) {
30577c478bd9Sstevel@tonic-gate 		case F_FILE:
30587c478bd9Sstevel@tonic-gate 		case F_TTY:
30597c478bd9Sstevel@tonic-gate 		case F_CONSOLE:
30607c478bd9Sstevel@tonic-gate 			(void) fprintf(out, "%s", f->f_un.f_fname);
30617c478bd9Sstevel@tonic-gate 			break;
30627c478bd9Sstevel@tonic-gate 		case F_FORW:
30637c478bd9Sstevel@tonic-gate 			(void) fprintf(out, "%s", f->f_un.f_forw.f_hname);
30647c478bd9Sstevel@tonic-gate 			break;
30657c478bd9Sstevel@tonic-gate 		case F_USERS:
30667c478bd9Sstevel@tonic-gate 			for (i = 0; i < MAXUNAMES &&
30677c478bd9Sstevel@tonic-gate 				*f->f_un.f_uname[i]; i++) {
30687c478bd9Sstevel@tonic-gate 				if (!i)
30697c478bd9Sstevel@tonic-gate 					(void) fprintf(out, "%s",
30707c478bd9Sstevel@tonic-gate 						f->f_un.f_uname[i]);
30717c478bd9Sstevel@tonic-gate 				else
30727c478bd9Sstevel@tonic-gate 					(void) fprintf(out, ", %s",
30737c478bd9Sstevel@tonic-gate 						f->f_un.f_uname[i]);
30747c478bd9Sstevel@tonic-gate 			}
30757c478bd9Sstevel@tonic-gate 			break;
30767c478bd9Sstevel@tonic-gate 		}
30777c478bd9Sstevel@tonic-gate 		(void) fprintf(out, "\n");
30787c478bd9Sstevel@tonic-gate 	}
30797c478bd9Sstevel@tonic-gate 
30807c478bd9Sstevel@tonic-gate 	if (!conversion_printed) {
30817c478bd9Sstevel@tonic-gate 		fprintf(out, "\nFacilities:\n");
30827c478bd9Sstevel@tonic-gate 
30837c478bd9Sstevel@tonic-gate 		for (i = 0; FacNames[i].c_val != -1; i++) {
30847c478bd9Sstevel@tonic-gate 			fprintf(out, "  [%02d] %s: %3d\n", i,
30857c478bd9Sstevel@tonic-gate 				FacNames[i].c_name, FacNames[i].c_val);
30867c478bd9Sstevel@tonic-gate 		}
30877c478bd9Sstevel@tonic-gate 
30887c478bd9Sstevel@tonic-gate 		fprintf(out, "\nPriorities:\n");
30897c478bd9Sstevel@tonic-gate 
30907c478bd9Sstevel@tonic-gate 		for (i = 0; PriNames[i].c_val != -1; i++) {
30917c478bd9Sstevel@tonic-gate 			fprintf(out, "  [%02d] %s: %3d\n", i,
30927c478bd9Sstevel@tonic-gate 				PriNames[i].c_name, PriNames[i].c_val);
30937c478bd9Sstevel@tonic-gate 		}
30947c478bd9Sstevel@tonic-gate 
30957c478bd9Sstevel@tonic-gate 		conversion_printed = 1;
30967c478bd9Sstevel@tonic-gate 	}
30977c478bd9Sstevel@tonic-gate 
30987c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "\n\n\n\t\tPer File Statistics\n");
30997c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "%-24s\tTot\tDups\tNofwd\tErrs\n", "File");
31007c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "%-24s\t---\t----\t-----\t----\n", "----");
31017c478bd9Sstevel@tonic-gate 	for (f = Files; f < &Files[nlogs]; f++) {
31027c478bd9Sstevel@tonic-gate 		switch (f->f_type) {
31037c478bd9Sstevel@tonic-gate 		case F_FILE:
31047c478bd9Sstevel@tonic-gate 		case F_TTY:
31057c478bd9Sstevel@tonic-gate 		case F_CONSOLE:
31067c478bd9Sstevel@tonic-gate 			(void) fprintf(out, "%-24s", f->f_un.f_fname);
31077c478bd9Sstevel@tonic-gate 			break;
31087c478bd9Sstevel@tonic-gate 		case F_WALL:
31097c478bd9Sstevel@tonic-gate 			(void) fprintf(out, "%-24s", TypeNames[f->f_type]);
31107c478bd9Sstevel@tonic-gate 			break;
31117c478bd9Sstevel@tonic-gate 		case F_FORW:
31127c478bd9Sstevel@tonic-gate 			(void) fprintf(out, "%-24s", f->f_un.f_forw.f_hname);
31137c478bd9Sstevel@tonic-gate 			break;
31147c478bd9Sstevel@tonic-gate 		case F_USERS:
31157c478bd9Sstevel@tonic-gate 			for (i = 0; i < MAXUNAMES &&
31167c478bd9Sstevel@tonic-gate 				*f->f_un.f_uname[i]; i++) {
31177c478bd9Sstevel@tonic-gate 				if (!i)
31187c478bd9Sstevel@tonic-gate 					(void) strcpy(users,
31197c478bd9Sstevel@tonic-gate 						f->f_un.f_uname[i]);
31207c478bd9Sstevel@tonic-gate 				else {
31217c478bd9Sstevel@tonic-gate 					(void) strcat(users, ",");
31227c478bd9Sstevel@tonic-gate 					(void) strcat(users,
31237c478bd9Sstevel@tonic-gate 						f->f_un.f_uname[i]);
31247c478bd9Sstevel@tonic-gate 				}
31257c478bd9Sstevel@tonic-gate 			}
31267c478bd9Sstevel@tonic-gate 			(void) fprintf(out, "%-24s", users);
31277c478bd9Sstevel@tonic-gate 			break;
31287c478bd9Sstevel@tonic-gate 		}
31297c478bd9Sstevel@tonic-gate 		(void) fprintf(out, "\t%d\t%d\t%d\t%d\n",
31307c478bd9Sstevel@tonic-gate 			f->f_stat.total, f->f_stat.dups,
31317c478bd9Sstevel@tonic-gate 			f->f_stat.cantfwd, f->f_stat.errs);
31327c478bd9Sstevel@tonic-gate 	}
31337c478bd9Sstevel@tonic-gate 	(void) fprintf(out, "\n\n");
31347c478bd9Sstevel@tonic-gate 	if (Debug && fd == 1)
31357c478bd9Sstevel@tonic-gate 		return;
31367c478bd9Sstevel@tonic-gate 	(void) fclose(out);
31377c478bd9Sstevel@tonic-gate }
31387c478bd9Sstevel@tonic-gate 
31397c478bd9Sstevel@tonic-gate /*
31407c478bd9Sstevel@tonic-gate  * conf_init - This routine is code seperated from the
31417c478bd9Sstevel@tonic-gate  * init routine in order to be re-callable when we get
31427c478bd9Sstevel@tonic-gate  * a SIGHUP signal.
31437c478bd9Sstevel@tonic-gate  */
31447c478bd9Sstevel@tonic-gate static void
31457c478bd9Sstevel@tonic-gate conf_init(void)
31467c478bd9Sstevel@tonic-gate {
31477c478bd9Sstevel@tonic-gate 	char *p;
31487c478bd9Sstevel@tonic-gate 	int i;
31497c478bd9Sstevel@tonic-gate 	struct filed *f;
31507c478bd9Sstevel@tonic-gate 	char *m4argv[4];
31517c478bd9Sstevel@tonic-gate 	int m4argc = 0;
31527c478bd9Sstevel@tonic-gate 	conf_t cf;
31537c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
31547c478bd9Sstevel@tonic-gate 
31557c478bd9Sstevel@tonic-gate 	if (Debug) {
31567c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
31577c478bd9Sstevel@tonic-gate 	}
31587c478bd9Sstevel@tonic-gate 
31597c478bd9Sstevel@tonic-gate 	DPRINT1(2, "conf_init(%u): starting logger threads\n",
31607c478bd9Sstevel@tonic-gate 		mythreadno);
31617c478bd9Sstevel@tonic-gate 
31627c478bd9Sstevel@tonic-gate 	m4argv[m4argc++] = "m4";
31637c478bd9Sstevel@tonic-gate 
31647c478bd9Sstevel@tonic-gate 	if (amiloghost() == 1) {
31657c478bd9Sstevel@tonic-gate 		DPRINT1(1, "conf_init(%u): I am loghost\n", mythreadno);
31667c478bd9Sstevel@tonic-gate 		m4argv[m4argc++] = "-DLOGHOST=1";
31677c478bd9Sstevel@tonic-gate 	}
31687c478bd9Sstevel@tonic-gate 
31697c478bd9Sstevel@tonic-gate 	m4argv[m4argc++] = ConfFile;
31707c478bd9Sstevel@tonic-gate 	m4argv[m4argc] = NULL;
31717c478bd9Sstevel@tonic-gate 
31727c478bd9Sstevel@tonic-gate 	/*
31737c478bd9Sstevel@tonic-gate 	 * Make sure the configuration file and m4 exist, and then parse
31747c478bd9Sstevel@tonic-gate 	 * the configuration file with m4.  If any of these fail, resort
31757c478bd9Sstevel@tonic-gate 	 * to our hardcoded fallback configuration.
31767c478bd9Sstevel@tonic-gate 	 */
31777c478bd9Sstevel@tonic-gate 
31787c478bd9Sstevel@tonic-gate 	if (access(ConfFile, R_OK) == -1) {
31797c478bd9Sstevel@tonic-gate 		DPRINT2(1, "conf_init(%u): %s does not exist\n", mythreadno,
31807c478bd9Sstevel@tonic-gate 			ConfFile);
31817c478bd9Sstevel@tonic-gate 		logerror("can't open configuration file");
31827c478bd9Sstevel@tonic-gate 		/* CSTYLED */
31837c478bd9Sstevel@tonic-gate 		Files = (struct filed *) &fallback; /*lint !e545 */
31847c478bd9Sstevel@tonic-gate 		cfline("*.ERR\t/dev/sysmsg", 0, &Files[0]);
31857c478bd9Sstevel@tonic-gate 		cfline("*.PANIC\t*", 0, &Files[1]);
31867c478bd9Sstevel@tonic-gate 		nlogs = 2;
31877c478bd9Sstevel@tonic-gate 		goto nofile;
31887c478bd9Sstevel@tonic-gate 	}
31897c478bd9Sstevel@tonic-gate 
31907c478bd9Sstevel@tonic-gate 	if (checkm4() != 0 || conf_open(&cf, "/usr/ccs/bin/m4", m4argv) == -1) {
31917c478bd9Sstevel@tonic-gate 		DPRINT2(1, "conf_init(%u): cannot open %s\n", mythreadno,
31927c478bd9Sstevel@tonic-gate 			ConfFile);
31937c478bd9Sstevel@tonic-gate 		/* CSTYLED */
31947c478bd9Sstevel@tonic-gate 		Files = (struct filed *) &fallback; /*lint !e545 */
31957c478bd9Sstevel@tonic-gate 		cfline("*.ERR\t/dev/sysmsg", 0, &Files[0]);
31967c478bd9Sstevel@tonic-gate 		cfline("*.PANIC\t*", 0, &Files[1]);
31977c478bd9Sstevel@tonic-gate 		nlogs = 2;
31987c478bd9Sstevel@tonic-gate 		goto nofile;
31997c478bd9Sstevel@tonic-gate 	}
32007c478bd9Sstevel@tonic-gate 
32017c478bd9Sstevel@tonic-gate 	/* Count the number of lines which are not blanks or comments */
32027c478bd9Sstevel@tonic-gate 	nlogs = 0;
32037c478bd9Sstevel@tonic-gate 	while ((p = conf_read(&cf)) != NULL) {
32047c478bd9Sstevel@tonic-gate 		if (p[0] != '\0' && p[0] != '#')
32057c478bd9Sstevel@tonic-gate 			nlogs++;
32067c478bd9Sstevel@tonic-gate 	}
32077c478bd9Sstevel@tonic-gate 
32087c478bd9Sstevel@tonic-gate 	Files = (struct filed *)malloc(sizeof (struct filed) * nlogs);
32097c478bd9Sstevel@tonic-gate 
32107c478bd9Sstevel@tonic-gate 	if (!Files) {
32117c478bd9Sstevel@tonic-gate 		DPRINT1(1, "conf_init(%u): malloc failed - can't "
32127c478bd9Sstevel@tonic-gate 			"allocate 'Files' array\n", mythreadno);
32137c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("loading minimum configuration");
32147c478bd9Sstevel@tonic-gate 		/* CSTYLED */
32157c478bd9Sstevel@tonic-gate 		Files = (struct filed *) &fallback; /*lint !e545 */
32167c478bd9Sstevel@tonic-gate 		cfline("*.ERR\t/dev/sysmsg", 0, &Files[0]);
32177c478bd9Sstevel@tonic-gate 		cfline("*.PANIC\t*", 0, &Files[1]);
32187c478bd9Sstevel@tonic-gate 		nlogs = 2;
32197c478bd9Sstevel@tonic-gate 		conf_close(&cf);
32207c478bd9Sstevel@tonic-gate 		goto nofile;
32217c478bd9Sstevel@tonic-gate 	}
32227c478bd9Sstevel@tonic-gate 
32237c478bd9Sstevel@tonic-gate 	/*
32247c478bd9Sstevel@tonic-gate 	 *  Foreach line in the conf table, open that file.
32257c478bd9Sstevel@tonic-gate 	 */
32267c478bd9Sstevel@tonic-gate 	conf_rewind(&cf);
32277c478bd9Sstevel@tonic-gate 	f = Files;
32287c478bd9Sstevel@tonic-gate 	i = 0;
32297c478bd9Sstevel@tonic-gate 	while (((p = conf_read(&cf)) != NULL) && (f < &Files[nlogs])) {
32307c478bd9Sstevel@tonic-gate 		i++;
32317c478bd9Sstevel@tonic-gate 		/* check for end-of-section */
32327c478bd9Sstevel@tonic-gate 		if (p[0] == '\0' || p[0] == '#')
32337c478bd9Sstevel@tonic-gate 			continue;
32347c478bd9Sstevel@tonic-gate 
32357c478bd9Sstevel@tonic-gate 		cfline(p, i, f);
32367c478bd9Sstevel@tonic-gate 		if (f->f_type == F_UNUSED)
32377c478bd9Sstevel@tonic-gate 			nlogs--;
32387c478bd9Sstevel@tonic-gate 		else
32397c478bd9Sstevel@tonic-gate 			f++;
32407c478bd9Sstevel@tonic-gate 	}
32417c478bd9Sstevel@tonic-gate 
32427c478bd9Sstevel@tonic-gate 	conf_close(&cf);
32437c478bd9Sstevel@tonic-gate 
32447c478bd9Sstevel@tonic-gate 	/*
32457c478bd9Sstevel@tonic-gate 	 * See if marks are to be written to any files.  If so, set up a
32467c478bd9Sstevel@tonic-gate 	 * timeout for marks.
32477c478bd9Sstevel@tonic-gate 	 */
32487c478bd9Sstevel@tonic-gate nofile:
32497c478bd9Sstevel@tonic-gate 	Marking = 0;
32507c478bd9Sstevel@tonic-gate 
32517c478bd9Sstevel@tonic-gate 	/*
32527c478bd9Sstevel@tonic-gate 	 * allocate thread stacks - one for each logger thread.
32537c478bd9Sstevel@tonic-gate 	 */
32547c478bd9Sstevel@tonic-gate 	if ((cstack_ptr = alloc_stacks(nlogs)) == NULL) {
32557c478bd9Sstevel@tonic-gate 		logerror("alloc_stacks failed - fatal");
32567c478bd9Sstevel@tonic-gate 		exit(1);
32577c478bd9Sstevel@tonic-gate 	}
32587c478bd9Sstevel@tonic-gate 
32597c478bd9Sstevel@tonic-gate 	/* And now one thread for each configured file */
32607c478bd9Sstevel@tonic-gate 	for (f = Files; f < &Files[nlogs]; f++) {
32617c478bd9Sstevel@tonic-gate 		if (filed_init(f) != 0) {
32627c478bd9Sstevel@tonic-gate 			logerror("pthread_create failed - fatal");
32637c478bd9Sstevel@tonic-gate 			exit(1);
32647c478bd9Sstevel@tonic-gate 		}
32657c478bd9Sstevel@tonic-gate 
32667c478bd9Sstevel@tonic-gate 		pthread_mutex_lock(&cft);
32677c478bd9Sstevel@tonic-gate 		++conf_threads;
32687c478bd9Sstevel@tonic-gate 		pthread_mutex_unlock(&cft);
32697c478bd9Sstevel@tonic-gate 
32707c478bd9Sstevel@tonic-gate 		if (f->f_type != F_UNUSED &&
32717c478bd9Sstevel@tonic-gate 			f->f_pmask[LOG_NFACILITIES] != NOPRI)
32727c478bd9Sstevel@tonic-gate 			Marking = 1;
32737c478bd9Sstevel@tonic-gate 	}
32747c478bd9Sstevel@tonic-gate }
32757c478bd9Sstevel@tonic-gate 
32767c478bd9Sstevel@tonic-gate /*
32777c478bd9Sstevel@tonic-gate  * filed init - initialize fields in a file descriptor struct
32787c478bd9Sstevel@tonic-gate  * this is called before multiple threads are running, so no mutex
32797c478bd9Sstevel@tonic-gate  * needs to be held at this time.
32807c478bd9Sstevel@tonic-gate  */
328178eb75caSchin static int
32827c478bd9Sstevel@tonic-gate filed_init(struct filed *f)
32837c478bd9Sstevel@tonic-gate {
32847c478bd9Sstevel@tonic-gate 	pthread_attr_t stack_attr;
32857c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
32867c478bd9Sstevel@tonic-gate 
32877c478bd9Sstevel@tonic-gate 	if (Debug) {
32887c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
32897c478bd9Sstevel@tonic-gate 	}
32907c478bd9Sstevel@tonic-gate 
32917c478bd9Sstevel@tonic-gate 	if (pthread_mutex_init(&f->filed_mutex, NULL) != 0) {
32927c478bd9Sstevel@tonic-gate 		logerror("pthread_mutex_init failed");
32937c478bd9Sstevel@tonic-gate 		return (-1);
32947c478bd9Sstevel@tonic-gate 	}
32957c478bd9Sstevel@tonic-gate 
32967c478bd9Sstevel@tonic-gate 	DPRINT2(5, "filed_init(%u): dataq_init for queue %p\n",
32977c478bd9Sstevel@tonic-gate 		mythreadno, &f->f_queue);
32987c478bd9Sstevel@tonic-gate 	(void) dataq_init(&f->f_queue);
32997c478bd9Sstevel@tonic-gate 
33007c478bd9Sstevel@tonic-gate 	if (pthread_attr_init(&stack_attr) != 0) {
33017c478bd9Sstevel@tonic-gate 		logerror("pthread_attr_init failed");
33027c478bd9Sstevel@tonic-gate 		return (-1);
33037c478bd9Sstevel@tonic-gate 	}
33047c478bd9Sstevel@tonic-gate 
33057c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setstacksize(&stack_attr, stacksize);
33067c478bd9Sstevel@tonic-gate 	(void) pthread_attr_setstackaddr(&stack_attr, cstack_ptr);
33077c478bd9Sstevel@tonic-gate 	cstack_ptr += stacksize + redzonesize;
33087c478bd9Sstevel@tonic-gate 
33097c478bd9Sstevel@tonic-gate 	f->f_msgflag = 0;
33107c478bd9Sstevel@tonic-gate 	f->f_prevmsg.msg[0] = '\0';
33117c478bd9Sstevel@tonic-gate 	f->f_prevmsg.flags = 0;
33127c478bd9Sstevel@tonic-gate 	f->f_prevmsg.pri = 0;
33137c478bd9Sstevel@tonic-gate 	f->f_prevmsg.host[0] = '\0';
33147c478bd9Sstevel@tonic-gate 
33157c478bd9Sstevel@tonic-gate 	f->f_current.msg[0] = '\0';
33167c478bd9Sstevel@tonic-gate 	f->f_current.flags = 0;
33177c478bd9Sstevel@tonic-gate 	f->f_current.pri = 0;
33187c478bd9Sstevel@tonic-gate 	f->f_current.host[0] = '\0';
33197c478bd9Sstevel@tonic-gate 
33207c478bd9Sstevel@tonic-gate 	f->f_prevcount = 0;
33217c478bd9Sstevel@tonic-gate 
33227c478bd9Sstevel@tonic-gate 	f->f_stat.flag = 0;
33237c478bd9Sstevel@tonic-gate 	f->f_stat.total = 0;
33247c478bd9Sstevel@tonic-gate 	f->f_stat.dups = 0;
33257c478bd9Sstevel@tonic-gate 	f->f_stat.cantfwd = 0;
33267c478bd9Sstevel@tonic-gate 	f->f_stat.errs = 0;
33277c478bd9Sstevel@tonic-gate 
33287c478bd9Sstevel@tonic-gate 	if (pthread_create(&f->f_thread, NULL, logit, (void *)f) != 0) {
33297c478bd9Sstevel@tonic-gate 		logerror("pthread_create failed");
33307c478bd9Sstevel@tonic-gate 		pthread_attr_destroy(&stack_attr);
33317c478bd9Sstevel@tonic-gate 		return (-1);
33327c478bd9Sstevel@tonic-gate 	}
33337c478bd9Sstevel@tonic-gate 
33347c478bd9Sstevel@tonic-gate 	pthread_attr_destroy(&stack_attr);
33357c478bd9Sstevel@tonic-gate 	return (0);
33367c478bd9Sstevel@tonic-gate }
33377c478bd9Sstevel@tonic-gate 
33387c478bd9Sstevel@tonic-gate 
33397c478bd9Sstevel@tonic-gate /*
33407c478bd9Sstevel@tonic-gate  * Crack a configuration file line
33417c478bd9Sstevel@tonic-gate  */
33427c478bd9Sstevel@tonic-gate static void
33437c478bd9Sstevel@tonic-gate cfline(char *line, int lineno, struct filed *f)
33447c478bd9Sstevel@tonic-gate {
33457c478bd9Sstevel@tonic-gate 	char *p;
33467c478bd9Sstevel@tonic-gate 	char *q;
33477c478bd9Sstevel@tonic-gate 	int i;
33487c478bd9Sstevel@tonic-gate 	char *bp;
33497c478bd9Sstevel@tonic-gate 	int pri;
33507c478bd9Sstevel@tonic-gate 	char buf[MAXLINE];
33517c478bd9Sstevel@tonic-gate 	char ebuf[SYS_NMLN+1+40];
33527c478bd9Sstevel@tonic-gate 	mode_t fmode, omode = O_WRONLY|O_APPEND|O_NOCTTY;
33537c478bd9Sstevel@tonic-gate 	struct stat64 sbuf;
33547c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
33557c478bd9Sstevel@tonic-gate 
33567c478bd9Sstevel@tonic-gate 	if (Debug) {
33577c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
33587c478bd9Sstevel@tonic-gate 	}
33597c478bd9Sstevel@tonic-gate 
33607c478bd9Sstevel@tonic-gate 	DPRINT2(1, "cfline(%u): (%s)\n", mythreadno, line);
33617c478bd9Sstevel@tonic-gate 
3362ace1a5f1Sdp 	errno = 0;	/* keep errno related stuff out of logerror messages */
33637c478bd9Sstevel@tonic-gate 
33647c478bd9Sstevel@tonic-gate 	/* clear out file entry */
33657c478bd9Sstevel@tonic-gate 	bzero((char *)f, sizeof (*f));
33667c478bd9Sstevel@tonic-gate 	for (i = 0; i <= LOG_NFACILITIES; i++)
33677c478bd9Sstevel@tonic-gate 		f->f_pmask[i] = NOPRI;
33687c478bd9Sstevel@tonic-gate 
33697c478bd9Sstevel@tonic-gate 	/* scan through the list of selectors */
33707c478bd9Sstevel@tonic-gate 	for (p = line; *p && *p != '\t'; ) {
33717c478bd9Sstevel@tonic-gate 
33727c478bd9Sstevel@tonic-gate 		/* find the end of this facility name list */
33737c478bd9Sstevel@tonic-gate 		for (q = p; *q && *q != '\t' && *q++ != '.'; )
33747c478bd9Sstevel@tonic-gate 			continue;
33757c478bd9Sstevel@tonic-gate 
33767c478bd9Sstevel@tonic-gate 		/* collect priority name */
33777c478bd9Sstevel@tonic-gate 		for (bp = buf; *q && !strchr("\t,;", *q); )
33787c478bd9Sstevel@tonic-gate 			*bp++ = *q++;
33797c478bd9Sstevel@tonic-gate 		*bp = '\0';
33807c478bd9Sstevel@tonic-gate 
33817c478bd9Sstevel@tonic-gate 		/* skip cruft */
33827c478bd9Sstevel@tonic-gate 		while (strchr(", ;", *q))
33837c478bd9Sstevel@tonic-gate 			q++;
33847c478bd9Sstevel@tonic-gate 
33857c478bd9Sstevel@tonic-gate 		/* decode priority name */
33867c478bd9Sstevel@tonic-gate 		pri = decode(buf, PriNames);
33877c478bd9Sstevel@tonic-gate 		if (pri < 0) {
33887c478bd9Sstevel@tonic-gate 			logerror("line %d: unknown priority name \"%s\"",
33897c478bd9Sstevel@tonic-gate 					lineno, buf);
33907c478bd9Sstevel@tonic-gate 			return;
33917c478bd9Sstevel@tonic-gate 		}
33927c478bd9Sstevel@tonic-gate 
33937c478bd9Sstevel@tonic-gate 		/* scan facilities */
33947c478bd9Sstevel@tonic-gate 		while (*p && !strchr("\t.;", *p)) {
33957c478bd9Sstevel@tonic-gate 			for (bp = buf; *p && !strchr("\t,;.", *p); )
33967c478bd9Sstevel@tonic-gate 				*bp++ = *p++;
33977c478bd9Sstevel@tonic-gate 			*bp = '\0';
33987c478bd9Sstevel@tonic-gate 			if (*buf == '*')
33997c478bd9Sstevel@tonic-gate 				for (i = 0; i < LOG_NFACILITIES; i++)
34007c478bd9Sstevel@tonic-gate 					f->f_pmask[i] = (uchar_t)pri;
34017c478bd9Sstevel@tonic-gate 			else {
34027c478bd9Sstevel@tonic-gate 				i = decode(buf, FacNames);
34037c478bd9Sstevel@tonic-gate 				if (i < 0) {
34047c478bd9Sstevel@tonic-gate 					logerror("line %d: unknown facility"
34057c478bd9Sstevel@tonic-gate 						" name \"%s\"", lineno, buf);
34067c478bd9Sstevel@tonic-gate 					return;
34077c478bd9Sstevel@tonic-gate 				}
34087c478bd9Sstevel@tonic-gate 				f->f_pmask[i >> 3] = (uchar_t)pri;
34097c478bd9Sstevel@tonic-gate 			}
34107c478bd9Sstevel@tonic-gate 			while (*p == ',' || *p == ' ')
34117c478bd9Sstevel@tonic-gate 				p++;
34127c478bd9Sstevel@tonic-gate 		}
34137c478bd9Sstevel@tonic-gate 
34147c478bd9Sstevel@tonic-gate 		p = q;
34157c478bd9Sstevel@tonic-gate 	}
34167c478bd9Sstevel@tonic-gate 
34177c478bd9Sstevel@tonic-gate 	/* skip to action part */
34187c478bd9Sstevel@tonic-gate 	while (*p == '\t' || *p == ' ')
34197c478bd9Sstevel@tonic-gate 		p++;
34207c478bd9Sstevel@tonic-gate 
34217c478bd9Sstevel@tonic-gate 	switch (*p) {
34227c478bd9Sstevel@tonic-gate 	case '\0':
34237c478bd9Sstevel@tonic-gate 		errno = 0;
34247c478bd9Sstevel@tonic-gate 		logerror("line %d: no action part", lineno);
34257c478bd9Sstevel@tonic-gate 		break;
34267c478bd9Sstevel@tonic-gate 
34277c478bd9Sstevel@tonic-gate 	case '@':
34287c478bd9Sstevel@tonic-gate 		(void) strlcpy(f->f_un.f_forw.f_hname, ++p, SYS_NMLN);
34297c478bd9Sstevel@tonic-gate 		if (logforward(f, ebuf) != 0) {
34307c478bd9Sstevel@tonic-gate 			logerror("line %d: %s", lineno, ebuf);
34317c478bd9Sstevel@tonic-gate 			break;
34327c478bd9Sstevel@tonic-gate 		}
34337c478bd9Sstevel@tonic-gate 		f->f_type = F_FORW;
34347c478bd9Sstevel@tonic-gate 		break;
34357c478bd9Sstevel@tonic-gate 
34367c478bd9Sstevel@tonic-gate 	case '/':
34377c478bd9Sstevel@tonic-gate 		(void) strlcpy(f->f_un.f_fname, p, MAXPATHLEN);
34387c478bd9Sstevel@tonic-gate 		if (stat64(p, &sbuf) < 0) {
34397c478bd9Sstevel@tonic-gate 			logerror(p);
34407c478bd9Sstevel@tonic-gate 			break;
34417c478bd9Sstevel@tonic-gate 		}
34427c478bd9Sstevel@tonic-gate 		/*
34437c478bd9Sstevel@tonic-gate 		 * don't block trying to open a pipe
34447c478bd9Sstevel@tonic-gate 		 * with no reader on the other end
34457c478bd9Sstevel@tonic-gate 		 */
34467c478bd9Sstevel@tonic-gate 		fmode = 0; 	/* reset each pass */
34477c478bd9Sstevel@tonic-gate 		if (S_ISFIFO(sbuf.st_mode))
34487c478bd9Sstevel@tonic-gate 			fmode = O_NONBLOCK;
34497c478bd9Sstevel@tonic-gate 
34507c478bd9Sstevel@tonic-gate 		f->f_file = open64(p, omode|fmode);
34517c478bd9Sstevel@tonic-gate 		if (f->f_file < 0) {
34527c478bd9Sstevel@tonic-gate 			if (fmode && errno == ENXIO) {
34537c478bd9Sstevel@tonic-gate 				errno = 0;
34547c478bd9Sstevel@tonic-gate 				logerror("%s - no reader", p);
34557c478bd9Sstevel@tonic-gate 			} else
34567c478bd9Sstevel@tonic-gate 				logerror(p);
34577c478bd9Sstevel@tonic-gate 			break;
34587c478bd9Sstevel@tonic-gate 		}
34597c478bd9Sstevel@tonic-gate 
34607c478bd9Sstevel@tonic-gate 		/*
34617c478bd9Sstevel@tonic-gate 		 * Fifos are initially opened NONBLOCK
34627c478bd9Sstevel@tonic-gate 		 * to insure we don't hang, but once
34637c478bd9Sstevel@tonic-gate 		 * we are open, we need to change the
34647c478bd9Sstevel@tonic-gate 		 * behavior back to blocking, otherwise
34657c478bd9Sstevel@tonic-gate 		 * we may get write errors, and the log
34667c478bd9Sstevel@tonic-gate 		 * will get closed down the line.
34677c478bd9Sstevel@tonic-gate 		 */
34687c478bd9Sstevel@tonic-gate 		if (S_ISFIFO(sbuf.st_mode))
34697c478bd9Sstevel@tonic-gate 			(void) fcntl(f->f_file, F_SETFL, omode);
34707c478bd9Sstevel@tonic-gate 
34717c478bd9Sstevel@tonic-gate 		if (isatty(f->f_file)) {
34727c478bd9Sstevel@tonic-gate 			f->f_type = F_TTY;
34737c478bd9Sstevel@tonic-gate 			untty();
34747c478bd9Sstevel@tonic-gate 		} else
34757c478bd9Sstevel@tonic-gate 			f->f_type = F_FILE;
34767c478bd9Sstevel@tonic-gate 
34777c478bd9Sstevel@tonic-gate 		if ((strcmp(p, ctty) == 0) || (strcmp(p, sysmsg) == 0))
34787c478bd9Sstevel@tonic-gate 			f->f_type = F_CONSOLE;
34797c478bd9Sstevel@tonic-gate 		break;
34807c478bd9Sstevel@tonic-gate 
34817c478bd9Sstevel@tonic-gate 	case '*':
34827c478bd9Sstevel@tonic-gate 		f->f_type = F_WALL;
34837c478bd9Sstevel@tonic-gate 		break;
34847c478bd9Sstevel@tonic-gate 
34857c478bd9Sstevel@tonic-gate 	default:
34867c478bd9Sstevel@tonic-gate 		for (i = 0; i < MAXUNAMES && *p; i++) {
34877c478bd9Sstevel@tonic-gate 			for (q = p; *q && *q != ','; )
34887c478bd9Sstevel@tonic-gate 				q++;
34897c478bd9Sstevel@tonic-gate 			(void) strlcpy(f->f_un.f_uname[i], p, UNAMESZ);
34907c478bd9Sstevel@tonic-gate 			if ((q - p) > UNAMESZ)
34917c478bd9Sstevel@tonic-gate 				f->f_un.f_uname[i][UNAMESZ] = '\0';
34927c478bd9Sstevel@tonic-gate 			else
34937c478bd9Sstevel@tonic-gate 				f->f_un.f_uname[i][q - p] = '\0';
34947c478bd9Sstevel@tonic-gate 			while (*q == ',' || *q == ' ')
34957c478bd9Sstevel@tonic-gate 				q++;
34967c478bd9Sstevel@tonic-gate 			p = q;
34977c478bd9Sstevel@tonic-gate 		}
34987c478bd9Sstevel@tonic-gate 		f->f_type = F_USERS;
34997c478bd9Sstevel@tonic-gate 		break;
35007c478bd9Sstevel@tonic-gate 	}
35017c478bd9Sstevel@tonic-gate 	f->f_orig_type = f->f_type;
35027c478bd9Sstevel@tonic-gate }
35037c478bd9Sstevel@tonic-gate 
35047c478bd9Sstevel@tonic-gate 
35057c478bd9Sstevel@tonic-gate /*
35067c478bd9Sstevel@tonic-gate  *  Decode a symbolic name to a numeric value
35077c478bd9Sstevel@tonic-gate  */
35087c478bd9Sstevel@tonic-gate static int
35097c478bd9Sstevel@tonic-gate decode(char *name, struct code *codetab)
35107c478bd9Sstevel@tonic-gate {
35117c478bd9Sstevel@tonic-gate 	struct code *c;
35127c478bd9Sstevel@tonic-gate 	char *p;
35137c478bd9Sstevel@tonic-gate 	char buf[40];
35147c478bd9Sstevel@tonic-gate 
35157c478bd9Sstevel@tonic-gate 	if (isdigit(*name))
35167c478bd9Sstevel@tonic-gate 		return (atoi(name));
35177c478bd9Sstevel@tonic-gate 
35187c478bd9Sstevel@tonic-gate 	(void) strncpy(buf, name, sizeof (buf) - 1);
35197c478bd9Sstevel@tonic-gate 	for (p = buf; *p; p++)
35207c478bd9Sstevel@tonic-gate 		if (isupper(*p))
35217c478bd9Sstevel@tonic-gate 			*p = tolower(*p);
35227c478bd9Sstevel@tonic-gate 	for (c = codetab; c->c_name; c++)
35237c478bd9Sstevel@tonic-gate 		if (!(strcmp(buf, c->c_name)))
35247c478bd9Sstevel@tonic-gate 			return (c->c_val);
35257c478bd9Sstevel@tonic-gate 
35267c478bd9Sstevel@tonic-gate 	return (-1);
35277c478bd9Sstevel@tonic-gate }
35287c478bd9Sstevel@tonic-gate 
35297c478bd9Sstevel@tonic-gate static int
35307c478bd9Sstevel@tonic-gate ismyaddr(struct netbuf *nbp)
35317c478bd9Sstevel@tonic-gate {
35327c478bd9Sstevel@tonic-gate 	int i;
35337c478bd9Sstevel@tonic-gate 
35347c478bd9Sstevel@tonic-gate 	if (nbp == NULL)
35357c478bd9Sstevel@tonic-gate 		return (0);
35367c478bd9Sstevel@tonic-gate 
35377c478bd9Sstevel@tonic-gate 	for (i = 1; i < Ninputs; i++) {
35387c478bd9Sstevel@tonic-gate 		if (same_addr(nbp, Myaddrs[i]))
35397c478bd9Sstevel@tonic-gate 			return (1);
35407c478bd9Sstevel@tonic-gate 	}
35417c478bd9Sstevel@tonic-gate 	return (0);
35427c478bd9Sstevel@tonic-gate }
35437c478bd9Sstevel@tonic-gate 
35447c478bd9Sstevel@tonic-gate static void
35457c478bd9Sstevel@tonic-gate getnets(void)
35467c478bd9Sstevel@tonic-gate {
35477c478bd9Sstevel@tonic-gate 	struct nd_hostserv hs;
35487c478bd9Sstevel@tonic-gate 	struct netconfig *ncp;
35497c478bd9Sstevel@tonic-gate 	struct nd_addrlist *nap;
35507c478bd9Sstevel@tonic-gate 	struct netbuf *nbp;
35517c478bd9Sstevel@tonic-gate 	int i, inputs;
35527c478bd9Sstevel@tonic-gate 	void *handle;
35537c478bd9Sstevel@tonic-gate 	char *uap;
35547c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
35557c478bd9Sstevel@tonic-gate 
35567c478bd9Sstevel@tonic-gate 	if (Debug) {
35577c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
35587c478bd9Sstevel@tonic-gate 	}
35597c478bd9Sstevel@tonic-gate 
35607c478bd9Sstevel@tonic-gate 	if (turnoff) {
35617c478bd9Sstevel@tonic-gate 		DPRINT1(1, "getnets(%u): network is being turned off\n",
35627c478bd9Sstevel@tonic-gate 				mythreadno);
35637c478bd9Sstevel@tonic-gate 		return;
35647c478bd9Sstevel@tonic-gate 	}
35657c478bd9Sstevel@tonic-gate 
35667c478bd9Sstevel@tonic-gate 	hs.h_host = HOST_SELF;
35677c478bd9Sstevel@tonic-gate 	hs.h_serv = "syslog";
35687c478bd9Sstevel@tonic-gate 
35697c478bd9Sstevel@tonic-gate 	if ((handle = setnetconfig()) == NULL) {
35707c478bd9Sstevel@tonic-gate 		return;
35717c478bd9Sstevel@tonic-gate 	}
35727c478bd9Sstevel@tonic-gate 
35737c478bd9Sstevel@tonic-gate 	while ((ncp = getnetconfig(handle)) != NULL) {
35747c478bd9Sstevel@tonic-gate 		if (ncp->nc_semantics != NC_TPI_CLTS) {
35757c478bd9Sstevel@tonic-gate 			continue;
35767c478bd9Sstevel@tonic-gate 		}
35777c478bd9Sstevel@tonic-gate 
35787c478bd9Sstevel@tonic-gate 		if (netdir_getbyname(ncp, &hs, &nap) != 0) {
35797c478bd9Sstevel@tonic-gate 			continue;
35807c478bd9Sstevel@tonic-gate 		}
35817c478bd9Sstevel@tonic-gate 
35827c478bd9Sstevel@tonic-gate 		if (nap == NULL || nap->n_cnt <= 0) {
35837c478bd9Sstevel@tonic-gate 			DPRINT1(1, "getnets(%u): found no address\n",
35847c478bd9Sstevel@tonic-gate 					mythreadno);
35857c478bd9Sstevel@tonic-gate 			netdir_free((void *)nap, ND_ADDRLIST);
35867c478bd9Sstevel@tonic-gate 			continue;
35877c478bd9Sstevel@tonic-gate 		}
35887c478bd9Sstevel@tonic-gate 
35897c478bd9Sstevel@tonic-gate 		if (Debug) {
35907c478bd9Sstevel@tonic-gate 			DPRINT2(1, "getnets(%u): found %d addresses",
35917c478bd9Sstevel@tonic-gate 				mythreadno, nap->n_cnt);
35927c478bd9Sstevel@tonic-gate 			DPRINT0(1, ", they are: ");
35937c478bd9Sstevel@tonic-gate 			nbp = nap->n_addrs;
35947c478bd9Sstevel@tonic-gate 
35957c478bd9Sstevel@tonic-gate 			for (i = 0; i < nap->n_cnt; i++) {
35967c478bd9Sstevel@tonic-gate 				if ((uap = taddr2uaddr(ncp, nbp)) != NULL) {
35977c478bd9Sstevel@tonic-gate 					DPRINT1(1, "%s ", uap);
35987c478bd9Sstevel@tonic-gate 					free(uap);
35997c478bd9Sstevel@tonic-gate 				}
36007c478bd9Sstevel@tonic-gate 				nbp++;
36017c478bd9Sstevel@tonic-gate 			}
36027c478bd9Sstevel@tonic-gate 
36037c478bd9Sstevel@tonic-gate 			DPRINT0(1, "\n");
36047c478bd9Sstevel@tonic-gate 		}
36057c478bd9Sstevel@tonic-gate 
36067c478bd9Sstevel@tonic-gate 		inputs = Ninputs + nap->n_cnt;
36077c478bd9Sstevel@tonic-gate 
36087c478bd9Sstevel@tonic-gate 		Nfd = realloc(Nfd, inputs * sizeof (struct pollfd));
36097c478bd9Sstevel@tonic-gate 		Ncf = realloc(Ncf, inputs * sizeof (struct netconfig));
36107c478bd9Sstevel@tonic-gate 		Myaddrs = realloc(Myaddrs, inputs * sizeof (struct netbuf *));
36117c478bd9Sstevel@tonic-gate 		Udp = realloc(Udp, inputs * sizeof (struct t_unitdata *));
36127c478bd9Sstevel@tonic-gate 		Errp = realloc(Errp, inputs * sizeof (struct t_uderr *));
36137c478bd9Sstevel@tonic-gate 
36147c478bd9Sstevel@tonic-gate 		/*
36157c478bd9Sstevel@tonic-gate 		 * all malloc failures here are fatal
36167c478bd9Sstevel@tonic-gate 		 */
36177c478bd9Sstevel@tonic-gate 		if (Nfd == NULL || Ncf == NULL || Myaddrs == NULL ||
36187c478bd9Sstevel@tonic-gate 			Udp == NULL || Errp == NULL) {
36197c478bd9Sstevel@tonic-gate 			MALLOC_FAIL_EXIT;
36207c478bd9Sstevel@tonic-gate 		}
36217c478bd9Sstevel@tonic-gate 
36227c478bd9Sstevel@tonic-gate 		nbp = nap->n_addrs;
36237c478bd9Sstevel@tonic-gate 
36247c478bd9Sstevel@tonic-gate 		for (i = 0; i < nap->n_cnt; i++, nbp++) {
36257c478bd9Sstevel@tonic-gate 			char ebuf[128];
36267c478bd9Sstevel@tonic-gate 
36277c478bd9Sstevel@tonic-gate 			if (addnet(ncp, nbp) == 0) {
36287c478bd9Sstevel@tonic-gate 				/* no error */
36297c478bd9Sstevel@tonic-gate 				continue;
36307c478bd9Sstevel@tonic-gate 			}
36317c478bd9Sstevel@tonic-gate 
36327c478bd9Sstevel@tonic-gate 			(void) strcpy(ebuf, "Unable to configure syslog port");
36337c478bd9Sstevel@tonic-gate 
36347c478bd9Sstevel@tonic-gate 			if ((uap = taddr2uaddr(ncp, nbp)) != NULL) {
36357c478bd9Sstevel@tonic-gate 				size_t l = strlen(ebuf);
36367c478bd9Sstevel@tonic-gate 				(void) snprintf(ebuf + l, sizeof (ebuf) - l,
36377c478bd9Sstevel@tonic-gate 					" for %s", uap);
36387c478bd9Sstevel@tonic-gate 			}
36397c478bd9Sstevel@tonic-gate 
36407c478bd9Sstevel@tonic-gate 			DPRINT2(1, "getnets(%u): %s",
36417c478bd9Sstevel@tonic-gate 				mythreadno, ebuf);
36427c478bd9Sstevel@tonic-gate 
36437c478bd9Sstevel@tonic-gate 			if (uap) {
36447c478bd9Sstevel@tonic-gate 				free(uap);
36457c478bd9Sstevel@tonic-gate 			}
36467c478bd9Sstevel@tonic-gate 
36477c478bd9Sstevel@tonic-gate 			logerror(ebuf);
36487c478bd9Sstevel@tonic-gate 			/*
36497c478bd9Sstevel@tonic-gate 			 * Here maybe syslogd can quit. However, syslogd
36507c478bd9Sstevel@tonic-gate 			 * has been ignoring this error and keep running.
36517c478bd9Sstevel@tonic-gate 			 * So we won't break it.
36527c478bd9Sstevel@tonic-gate 			 */
36537c478bd9Sstevel@tonic-gate 		}
36547c478bd9Sstevel@tonic-gate 
36557c478bd9Sstevel@tonic-gate 		netdir_free((void *)nap, ND_ADDRLIST);
36567c478bd9Sstevel@tonic-gate 	}
36577c478bd9Sstevel@tonic-gate 
36587c478bd9Sstevel@tonic-gate 	(void) endnetconfig(handle);
36597c478bd9Sstevel@tonic-gate }
36607c478bd9Sstevel@tonic-gate 
36617c478bd9Sstevel@tonic-gate /*
36627c478bd9Sstevel@tonic-gate  * Open the network device, and allocate necessary resources.
36637c478bd9Sstevel@tonic-gate  * Myaddrs will also be filled, so that we can call ismyaddr() before
36647c478bd9Sstevel@tonic-gate  * being bound to the network.
36657c478bd9Sstevel@tonic-gate  */
36667c478bd9Sstevel@tonic-gate static int
36677c478bd9Sstevel@tonic-gate addnet(struct netconfig *ncp, struct netbuf *nbp)
36687c478bd9Sstevel@tonic-gate {
36697c478bd9Sstevel@tonic-gate 	int fd;
36707c478bd9Sstevel@tonic-gate 	struct netbuf *bp;
36717c478bd9Sstevel@tonic-gate 
36727c478bd9Sstevel@tonic-gate 	fd = t_open(ncp->nc_device, O_RDWR, NULL);
36737c478bd9Sstevel@tonic-gate 
36747c478bd9Sstevel@tonic-gate 	if (fd < 0) {
36757c478bd9Sstevel@tonic-gate 		return (1);
36767c478bd9Sstevel@tonic-gate 	}
36777c478bd9Sstevel@tonic-gate 
36787c478bd9Sstevel@tonic-gate 	(void) memcpy(&Ncf[Ninputs], ncp, sizeof (struct netconfig));
36797c478bd9Sstevel@tonic-gate 
36807c478bd9Sstevel@tonic-gate 	/*LINTED*/
36817c478bd9Sstevel@tonic-gate 	Udp[Ninputs] = (struct t_unitdata *)t_alloc(fd, T_UNITDATA, T_ADDR);
36827c478bd9Sstevel@tonic-gate 
36837c478bd9Sstevel@tonic-gate 	if (Udp[Ninputs] == NULL) {
36847c478bd9Sstevel@tonic-gate 		t_close(fd);
36857c478bd9Sstevel@tonic-gate 		return (1);
36867c478bd9Sstevel@tonic-gate 	}
36877c478bd9Sstevel@tonic-gate 
36887c478bd9Sstevel@tonic-gate 	/*LINTED*/
36897c478bd9Sstevel@tonic-gate 	Errp[Ninputs] = (struct t_uderr *)t_alloc(fd, T_UDERROR, T_ADDR);
36907c478bd9Sstevel@tonic-gate 
36917c478bd9Sstevel@tonic-gate 	if (Errp[Ninputs] == NULL) {
36927c478bd9Sstevel@tonic-gate 		t_close(fd);
36937c478bd9Sstevel@tonic-gate 		t_free((char *)Udp[Ninputs], T_UNITDATA);
36947c478bd9Sstevel@tonic-gate 		return (1);
36957c478bd9Sstevel@tonic-gate 	}
36967c478bd9Sstevel@tonic-gate 
36977c478bd9Sstevel@tonic-gate 	if ((bp = malloc(sizeof (struct netbuf))) == NULL ||
36987c478bd9Sstevel@tonic-gate 		(bp->buf = malloc(nbp->len)) == NULL) {
36997c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("allocating address buffer");
37007c478bd9Sstevel@tonic-gate 		t_close(fd);
37017c478bd9Sstevel@tonic-gate 		t_free((char *)Udp[Ninputs], T_UNITDATA);
37027c478bd9Sstevel@tonic-gate 		t_free((char *)Errp[Ninputs], T_UDERROR);
37037c478bd9Sstevel@tonic-gate 
37047c478bd9Sstevel@tonic-gate 		if (bp) {
37057c478bd9Sstevel@tonic-gate 			free(bp);
37067c478bd9Sstevel@tonic-gate 		}
37077c478bd9Sstevel@tonic-gate 
37087c478bd9Sstevel@tonic-gate 		return (1);
37097c478bd9Sstevel@tonic-gate 	}
37107c478bd9Sstevel@tonic-gate 
37117c478bd9Sstevel@tonic-gate 	bp->len = nbp->len;
37127c478bd9Sstevel@tonic-gate 	(void) memcpy(bp->buf, nbp->buf, nbp->len);
37137c478bd9Sstevel@tonic-gate 	Myaddrs[Ninputs] = bp;
37147c478bd9Sstevel@tonic-gate 
37157c478bd9Sstevel@tonic-gate 	Nfd[Ninputs].fd = fd;
37167c478bd9Sstevel@tonic-gate 	Nfd[Ninputs].events = POLLIN;
37177c478bd9Sstevel@tonic-gate 	Ninputs++;
37187c478bd9Sstevel@tonic-gate 	return (0);
37197c478bd9Sstevel@tonic-gate }
37207c478bd9Sstevel@tonic-gate 
37217c478bd9Sstevel@tonic-gate /*
37227c478bd9Sstevel@tonic-gate  * Allocate UDP buffer to minimize packet loss.
37237c478bd9Sstevel@tonic-gate  */
37247c478bd9Sstevel@tonic-gate static void
37257c478bd9Sstevel@tonic-gate set_udp_buffer(int fd)
37267c478bd9Sstevel@tonic-gate {
37277c478bd9Sstevel@tonic-gate 	struct t_optmgmt req, resp;
37287c478bd9Sstevel@tonic-gate 	struct opthdr *opt;
37297c478bd9Sstevel@tonic-gate 	size_t optsize, bsize = 256 * 1024;
37307c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
37317c478bd9Sstevel@tonic-gate 
37327c478bd9Sstevel@tonic-gate 	if (Debug) {
37337c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
37347c478bd9Sstevel@tonic-gate 	}
37357c478bd9Sstevel@tonic-gate 
37367c478bd9Sstevel@tonic-gate 	optsize = sizeof (struct opthdr) + sizeof (int);
37377c478bd9Sstevel@tonic-gate 	if ((opt = malloc(optsize)) == NULL) {
37387c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("will have no udp buffer");
37397c478bd9Sstevel@tonic-gate 		return;
37407c478bd9Sstevel@tonic-gate 	}
37417c478bd9Sstevel@tonic-gate 	opt->level = SOL_SOCKET;
37427c478bd9Sstevel@tonic-gate 	opt->name = SO_RCVBUF;
37437c478bd9Sstevel@tonic-gate 	opt->len = sizeof (int);
37447c478bd9Sstevel@tonic-gate 	*(int *)(opt + 1) = bsize;
37457c478bd9Sstevel@tonic-gate 
37467c478bd9Sstevel@tonic-gate 	req.flags = T_NEGOTIATE;
37477c478bd9Sstevel@tonic-gate 	req.opt.len = optsize;
37487c478bd9Sstevel@tonic-gate 	req.opt.buf = (char *)opt;
37497c478bd9Sstevel@tonic-gate 
37507c478bd9Sstevel@tonic-gate 	resp.flags = 0;
37517c478bd9Sstevel@tonic-gate 	resp.opt.maxlen = optsize;
37527c478bd9Sstevel@tonic-gate 	resp.opt.buf = (char *)opt;
37537c478bd9Sstevel@tonic-gate 
37547c478bd9Sstevel@tonic-gate 	while (t_optmgmt(fd, &req, &resp) == -1 || resp.flags != T_SUCCESS) {
37557c478bd9Sstevel@tonic-gate 		if (t_errno != TSYSERR || errno != ENOBUFS) {
37567c478bd9Sstevel@tonic-gate 			bsize = 0;
37577c478bd9Sstevel@tonic-gate 			break;
37587c478bd9Sstevel@tonic-gate 		}
37597c478bd9Sstevel@tonic-gate 		bsize >>= 1;
37607c478bd9Sstevel@tonic-gate 		if (bsize < 8192) {
37617c478bd9Sstevel@tonic-gate 			break;
37627c478bd9Sstevel@tonic-gate 		}
37637c478bd9Sstevel@tonic-gate 		*(int *)(opt + 1) = bsize;
37647c478bd9Sstevel@tonic-gate 	}
37657c478bd9Sstevel@tonic-gate 	if (bsize == 0) {
37667c478bd9Sstevel@tonic-gate 		logerror("failed to allocate UDP buffer");
37677c478bd9Sstevel@tonic-gate 	}
37687c478bd9Sstevel@tonic-gate 	DPRINT3(1, "set_udp_buffer(%u): allocate %d for fd %d\n",
37697c478bd9Sstevel@tonic-gate 		mythreadno, bsize, fd);
37707c478bd9Sstevel@tonic-gate 	free(opt);
37717c478bd9Sstevel@tonic-gate }
37727c478bd9Sstevel@tonic-gate 
37737c478bd9Sstevel@tonic-gate /*
37747c478bd9Sstevel@tonic-gate  * Attach the network, and allocate UDP buffer for the interface.
37757c478bd9Sstevel@tonic-gate  */
37767c478bd9Sstevel@tonic-gate static void
37777c478bd9Sstevel@tonic-gate bindnet(void)
37787c478bd9Sstevel@tonic-gate {
37797c478bd9Sstevel@tonic-gate 	struct t_bind bind, *bound;
37807c478bd9Sstevel@tonic-gate 	int cnt, i;
37817c478bd9Sstevel@tonic-gate 	char *uap;
37827c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
37837c478bd9Sstevel@tonic-gate 
37847c478bd9Sstevel@tonic-gate 	if (Debug) {
37857c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
37867c478bd9Sstevel@tonic-gate 	}
37877c478bd9Sstevel@tonic-gate 
37887c478bd9Sstevel@tonic-gate 	cnt = 0;
37897c478bd9Sstevel@tonic-gate 
37907c478bd9Sstevel@tonic-gate 	while (cnt < Ninputs) {
37917c478bd9Sstevel@tonic-gate 		char ebuf[128];
37927c478bd9Sstevel@tonic-gate 
37937c478bd9Sstevel@tonic-gate 		/*LINTED*/
37947c478bd9Sstevel@tonic-gate 		bound  = (struct t_bind *)t_alloc(Nfd[cnt].fd, T_BIND, T_ADDR);
37957c478bd9Sstevel@tonic-gate 		bind.addr = *Myaddrs[cnt];
37967c478bd9Sstevel@tonic-gate 		bind.qlen = 0;
37977c478bd9Sstevel@tonic-gate 
37987c478bd9Sstevel@tonic-gate 		if (t_bind(Nfd[cnt].fd, &bind, bound) == 0) {
37997c478bd9Sstevel@tonic-gate 			if (same_addr(&bind.addr, &bound->addr)) {
38007c478bd9Sstevel@tonic-gate 				t_free((char *)bound, T_BIND);
38017c478bd9Sstevel@tonic-gate 				set_udp_buffer(Nfd[cnt].fd);
38027c478bd9Sstevel@tonic-gate 				cnt++;
38037c478bd9Sstevel@tonic-gate 				continue;
38047c478bd9Sstevel@tonic-gate 			}
38057c478bd9Sstevel@tonic-gate 		}
38067c478bd9Sstevel@tonic-gate 
38077c478bd9Sstevel@tonic-gate 		/* failed to bind port */
38087c478bd9Sstevel@tonic-gate 		t_free((char *)bound, T_BIND);
38097c478bd9Sstevel@tonic-gate 
38107c478bd9Sstevel@tonic-gate 		(void) strcpy(ebuf, "Unable to bind syslog port");
38117c478bd9Sstevel@tonic-gate 
38127c478bd9Sstevel@tonic-gate 		uap = taddr2uaddr(&Ncf[cnt], Myaddrs[cnt]);
38137c478bd9Sstevel@tonic-gate 		if (uap) {
38147c478bd9Sstevel@tonic-gate 			i = strlen(ebuf);
38157c478bd9Sstevel@tonic-gate 			(void) snprintf(ebuf + i, sizeof (ebuf) - i,
38167c478bd9Sstevel@tonic-gate 				" for %s", uap);
38177c478bd9Sstevel@tonic-gate 		}
38187c478bd9Sstevel@tonic-gate 
38197c478bd9Sstevel@tonic-gate 		DPRINT2(1, "bindnet(%u): failed to bind port (%s)\n",
38207c478bd9Sstevel@tonic-gate 			mythreadno, uap ? uap : "<unknown>");
38217c478bd9Sstevel@tonic-gate 
38227c478bd9Sstevel@tonic-gate 		if (uap) {
38237c478bd9Sstevel@tonic-gate 			free(uap);
38247c478bd9Sstevel@tonic-gate 		}
38257c478bd9Sstevel@tonic-gate 
38267c478bd9Sstevel@tonic-gate 		errno = 0;
38277c478bd9Sstevel@tonic-gate 		logerror(ebuf);
38287c478bd9Sstevel@tonic-gate 
38297c478bd9Sstevel@tonic-gate 		t_close(Nfd[cnt].fd);
38307c478bd9Sstevel@tonic-gate 		free(Myaddrs[cnt]->buf);
38317c478bd9Sstevel@tonic-gate 		free(Myaddrs[cnt]);
38327c478bd9Sstevel@tonic-gate 		t_free((char *)Udp[cnt], T_UNITDATA);
38337c478bd9Sstevel@tonic-gate 		t_free((char *)Errp[cnt], T_UDERROR);
38347c478bd9Sstevel@tonic-gate 
38357c478bd9Sstevel@tonic-gate 		for (i = cnt; i < (Ninputs-1); i++) {
38367c478bd9Sstevel@tonic-gate 			Nfd[i] = Nfd[i + 1];
38377c478bd9Sstevel@tonic-gate 			Ncf[i] = Ncf[i + 1];
38387c478bd9Sstevel@tonic-gate 			Myaddrs[i] = Myaddrs[i + 1];
38397c478bd9Sstevel@tonic-gate 			Udp[i] = Udp[i + 1];
38407c478bd9Sstevel@tonic-gate 			Errp[i] = Errp[i + 1];
38417c478bd9Sstevel@tonic-gate 		}
38427c478bd9Sstevel@tonic-gate 
38437c478bd9Sstevel@tonic-gate 		Ninputs--;
38447c478bd9Sstevel@tonic-gate 	}
38457c478bd9Sstevel@tonic-gate }
38467c478bd9Sstevel@tonic-gate 
38477c478bd9Sstevel@tonic-gate static int
38487c478bd9Sstevel@tonic-gate logforward(struct filed *f, char *ebuf)
38497c478bd9Sstevel@tonic-gate {
38507c478bd9Sstevel@tonic-gate 	struct nd_hostserv hs;
38517c478bd9Sstevel@tonic-gate 	struct netbuf *nbp;
38527c478bd9Sstevel@tonic-gate 	struct netconfig *ncp;
38537c478bd9Sstevel@tonic-gate 	struct nd_addrlist *nap;
38547c478bd9Sstevel@tonic-gate 	void *handle;
38557c478bd9Sstevel@tonic-gate 	char *hp;
38567c478bd9Sstevel@tonic-gate 
38577c478bd9Sstevel@tonic-gate 	hp = f->f_un.f_forw.f_hname;
38587c478bd9Sstevel@tonic-gate 	hs.h_host = hp;
38597c478bd9Sstevel@tonic-gate 	hs.h_serv = "syslog";
38607c478bd9Sstevel@tonic-gate 
38617c478bd9Sstevel@tonic-gate 	if ((handle = setnetconfig()) == NULL) {
38627c478bd9Sstevel@tonic-gate 		(void) strcpy(ebuf,
38637c478bd9Sstevel@tonic-gate 			"unable to rewind the netconfig database");
38647c478bd9Sstevel@tonic-gate 		errno = 0;
38657c478bd9Sstevel@tonic-gate 		return (-1);
38667c478bd9Sstevel@tonic-gate 	}
38677c478bd9Sstevel@tonic-gate 	nap = (struct nd_addrlist *)NULL;
38687c478bd9Sstevel@tonic-gate 	while ((ncp = getnetconfig(handle)) != NULL) {
38697c478bd9Sstevel@tonic-gate 		if (ncp->nc_semantics == NC_TPI_CLTS) {
38707c478bd9Sstevel@tonic-gate 			if (netdir_getbyname(ncp, &hs, &nap) == 0) {
38717c478bd9Sstevel@tonic-gate 				if (!nap)
38727c478bd9Sstevel@tonic-gate 					continue;
38737c478bd9Sstevel@tonic-gate 				nbp = nap->n_addrs;
38747c478bd9Sstevel@tonic-gate 				break;
38757c478bd9Sstevel@tonic-gate 			}
38767c478bd9Sstevel@tonic-gate 		}
38777c478bd9Sstevel@tonic-gate 	}
38787c478bd9Sstevel@tonic-gate 	if (ncp == NULL) {
38797c478bd9Sstevel@tonic-gate 		endnetconfig(handle);
38807c478bd9Sstevel@tonic-gate 		(void) sprintf(ebuf, "WARNING: %s could not be resolved", hp);
38817c478bd9Sstevel@tonic-gate 		errno = 0;
38827c478bd9Sstevel@tonic-gate 		return (-1);
38837c478bd9Sstevel@tonic-gate 	}
38847c478bd9Sstevel@tonic-gate 	if (nap == (struct nd_addrlist *)NULL) {
38857c478bd9Sstevel@tonic-gate 		endnetconfig(handle);
38867c478bd9Sstevel@tonic-gate 		(void) sprintf(ebuf, "unknown host %s", hp);
38877c478bd9Sstevel@tonic-gate 		errno = 0;
38887c478bd9Sstevel@tonic-gate 		return (-1);
38897c478bd9Sstevel@tonic-gate 	}
38907c478bd9Sstevel@tonic-gate 	/* CSTYLED */
38917c478bd9Sstevel@tonic-gate 	if (ismyaddr(nbp)) { /*lint !e644 */
38927c478bd9Sstevel@tonic-gate 		netdir_free((void *)nap, ND_ADDRLIST);
38937c478bd9Sstevel@tonic-gate 		endnetconfig(handle);
38947c478bd9Sstevel@tonic-gate 		(void) sprintf(ebuf, "host %s is this host - logging loop",
38957c478bd9Sstevel@tonic-gate 			hp);
38967c478bd9Sstevel@tonic-gate 		errno = 0;
38977c478bd9Sstevel@tonic-gate 		return (-1);
38987c478bd9Sstevel@tonic-gate 	}
38997c478bd9Sstevel@tonic-gate 	f->f_un.f_forw.f_addr.buf = malloc(nbp->len);
39007c478bd9Sstevel@tonic-gate 	if (f->f_un.f_forw.f_addr.buf == NULL) {
39017c478bd9Sstevel@tonic-gate 		netdir_free((void *)nap, ND_ADDRLIST);
39027c478bd9Sstevel@tonic-gate 		endnetconfig(handle);
39037c478bd9Sstevel@tonic-gate 		(void) strcpy(ebuf, "malloc failed");
39047c478bd9Sstevel@tonic-gate 		return (-1);
39057c478bd9Sstevel@tonic-gate 	}
39067c478bd9Sstevel@tonic-gate 	bcopy(nbp->buf, f->f_un.f_forw.f_addr.buf, nbp->len);
39077c478bd9Sstevel@tonic-gate 	f->f_un.f_forw.f_addr.len = nbp->len;
39087c478bd9Sstevel@tonic-gate 	f->f_file = t_open(ncp->nc_device, O_RDWR, NULL);
39097c478bd9Sstevel@tonic-gate 	if (f->f_file < 0) {
39107c478bd9Sstevel@tonic-gate 		netdir_free((void *)nap, ND_ADDRLIST);
39117c478bd9Sstevel@tonic-gate 		endnetconfig(handle);
39127c478bd9Sstevel@tonic-gate 		free(f->f_un.f_forw.f_addr.buf);
39137c478bd9Sstevel@tonic-gate 		(void) strcpy(ebuf, "t_open");
39147c478bd9Sstevel@tonic-gate 		return (-1);
39157c478bd9Sstevel@tonic-gate 	}
39167c478bd9Sstevel@tonic-gate 	netdir_free((void *)nap, ND_ADDRLIST);
39177c478bd9Sstevel@tonic-gate 	endnetconfig(handle);
39187c478bd9Sstevel@tonic-gate 	if (t_bind(f->f_file, NULL, NULL) < 0) {
39197c478bd9Sstevel@tonic-gate 		(void) strcpy(ebuf, "t_bind");
39207c478bd9Sstevel@tonic-gate 		free(f->f_un.f_forw.f_addr.buf);
39217c478bd9Sstevel@tonic-gate 		t_close(f->f_file);
39227c478bd9Sstevel@tonic-gate 		return (-1);
39237c478bd9Sstevel@tonic-gate 	}
39247c478bd9Sstevel@tonic-gate 	return (0);
39257c478bd9Sstevel@tonic-gate }
39267c478bd9Sstevel@tonic-gate 
39277c478bd9Sstevel@tonic-gate static int
39287c478bd9Sstevel@tonic-gate amiloghost(void)
39297c478bd9Sstevel@tonic-gate {
39307c478bd9Sstevel@tonic-gate 	struct nd_hostserv hs;
39317c478bd9Sstevel@tonic-gate 	struct netconfig *ncp;
39327c478bd9Sstevel@tonic-gate 	struct nd_addrlist *nap;
39337c478bd9Sstevel@tonic-gate 	struct netbuf *nbp;
39347c478bd9Sstevel@tonic-gate 	int i, fd;
39357c478bd9Sstevel@tonic-gate 	void *handle;
39367c478bd9Sstevel@tonic-gate 	char *uap;
39377c478bd9Sstevel@tonic-gate 	struct t_bind bind, *bound;
39387c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
39397c478bd9Sstevel@tonic-gate 
39407c478bd9Sstevel@tonic-gate 	if (Debug) {
39417c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
39427c478bd9Sstevel@tonic-gate 	}
39437c478bd9Sstevel@tonic-gate 
39447c478bd9Sstevel@tonic-gate 	/*
39457c478bd9Sstevel@tonic-gate 	 * we need to know if we are running on the loghost. This is
39467c478bd9Sstevel@tonic-gate 	 * checked by binding to the address associated with "loghost"
39477c478bd9Sstevel@tonic-gate 	 * and "syslogd" service over the connectionless transport
39487c478bd9Sstevel@tonic-gate 	 */
39497c478bd9Sstevel@tonic-gate 	hs.h_host = "loghost";
39507c478bd9Sstevel@tonic-gate 	hs.h_serv = "syslog";
39517c478bd9Sstevel@tonic-gate 
39527c478bd9Sstevel@tonic-gate 	if ((handle = setnetconfig()) == NULL) {
39537c478bd9Sstevel@tonic-gate 		return (0);
39547c478bd9Sstevel@tonic-gate 	}
39557c478bd9Sstevel@tonic-gate 
39567c478bd9Sstevel@tonic-gate 	while ((ncp = getnetconfig(handle)) != NULL) {
39577c478bd9Sstevel@tonic-gate 		if (ncp->nc_semantics != NC_TPI_CLTS) {
39587c478bd9Sstevel@tonic-gate 			continue;
39597c478bd9Sstevel@tonic-gate 		}
39607c478bd9Sstevel@tonic-gate 
39617c478bd9Sstevel@tonic-gate 		if (netdir_getbyname(ncp, &hs, &nap) != 0) {
39627c478bd9Sstevel@tonic-gate 			continue;
39637c478bd9Sstevel@tonic-gate 		}
39647c478bd9Sstevel@tonic-gate 
39657c478bd9Sstevel@tonic-gate 		if (nap == NULL) {
39667c478bd9Sstevel@tonic-gate 			continue;
39677c478bd9Sstevel@tonic-gate 		}
39687c478bd9Sstevel@tonic-gate 
39697c478bd9Sstevel@tonic-gate 		nbp = nap->n_addrs;
39707c478bd9Sstevel@tonic-gate 
39717c478bd9Sstevel@tonic-gate 		for (i = 0; i < nap->n_cnt; i++) {
39727c478bd9Sstevel@tonic-gate 			if ((uap = taddr2uaddr(ncp, nbp)) != (char *)NULL) {
39737c478bd9Sstevel@tonic-gate 				DPRINT2(1, "amiloghost(%u): testing %s\n",
39747c478bd9Sstevel@tonic-gate 					mythreadno, uap);
39757c478bd9Sstevel@tonic-gate 			}
39767c478bd9Sstevel@tonic-gate 
39777c478bd9Sstevel@tonic-gate 			free(uap);
39787c478bd9Sstevel@tonic-gate 
39797c478bd9Sstevel@tonic-gate 			fd = t_open(ncp->nc_device, O_RDWR, NULL);
39807c478bd9Sstevel@tonic-gate 
39817c478bd9Sstevel@tonic-gate 			if (fd < 0) {
39827c478bd9Sstevel@tonic-gate 				netdir_free((void *)nap, ND_ADDRLIST);
39837c478bd9Sstevel@tonic-gate 				endnetconfig(handle);
39847c478bd9Sstevel@tonic-gate 				return (0);
39857c478bd9Sstevel@tonic-gate 			}
39867c478bd9Sstevel@tonic-gate 
39877c478bd9Sstevel@tonic-gate 			/*LINTED*/
39887c478bd9Sstevel@tonic-gate 			bound = (struct t_bind *)t_alloc(fd, T_BIND, T_ADDR);
39897c478bd9Sstevel@tonic-gate 			bind.addr = *nbp;
39907c478bd9Sstevel@tonic-gate 			bind.qlen = 0;
39917c478bd9Sstevel@tonic-gate 
39927c478bd9Sstevel@tonic-gate 			if (t_bind(fd, &bind, bound) == 0) {
39937c478bd9Sstevel@tonic-gate 				t_close(fd);
39947c478bd9Sstevel@tonic-gate 				t_free((char *)bound, T_BIND);
39957c478bd9Sstevel@tonic-gate 				netdir_free((void *)nap, ND_ADDRLIST);
39967c478bd9Sstevel@tonic-gate 				endnetconfig(handle);
39977c478bd9Sstevel@tonic-gate 				return (1);
39987c478bd9Sstevel@tonic-gate 			} else {
39997c478bd9Sstevel@tonic-gate 				t_close(fd);
40007c478bd9Sstevel@tonic-gate 				t_free((char *)bound, T_BIND);
40017c478bd9Sstevel@tonic-gate 			}
40027c478bd9Sstevel@tonic-gate 
40037c478bd9Sstevel@tonic-gate 			nbp++;
40047c478bd9Sstevel@tonic-gate 		}
40057c478bd9Sstevel@tonic-gate 
40067c478bd9Sstevel@tonic-gate 		netdir_free((void *)nap, ND_ADDRLIST);
40077c478bd9Sstevel@tonic-gate 	}
40087c478bd9Sstevel@tonic-gate 
40097c478bd9Sstevel@tonic-gate 	endnetconfig(handle);
40107c478bd9Sstevel@tonic-gate 	return (0);
40117c478bd9Sstevel@tonic-gate }
40127c478bd9Sstevel@tonic-gate 
40137c478bd9Sstevel@tonic-gate int
40147c478bd9Sstevel@tonic-gate same_addr(struct netbuf *na, struct netbuf *nb)
40157c478bd9Sstevel@tonic-gate {
40167c478bd9Sstevel@tonic-gate 	char *a, *b;
40177c478bd9Sstevel@tonic-gate 	size_t n;
40187c478bd9Sstevel@tonic-gate 
40197c478bd9Sstevel@tonic-gate 	assert(a != NULL && b != NULL);
40207c478bd9Sstevel@tonic-gate 
40217c478bd9Sstevel@tonic-gate 	if (na->len != nb->len) {
40227c478bd9Sstevel@tonic-gate 		return (0);
40237c478bd9Sstevel@tonic-gate 	}
40247c478bd9Sstevel@tonic-gate 
40257c478bd9Sstevel@tonic-gate 	a = na->buf;
40267c478bd9Sstevel@tonic-gate 	b = nb->buf;
40277c478bd9Sstevel@tonic-gate 	n = nb->len;
40287c478bd9Sstevel@tonic-gate 
40297c478bd9Sstevel@tonic-gate 	while (n-- > 0) {
40307c478bd9Sstevel@tonic-gate 		if (*a++ != *b++) {
40317c478bd9Sstevel@tonic-gate 			return (0);
40327c478bd9Sstevel@tonic-gate 		}
40337c478bd9Sstevel@tonic-gate 	}
40347c478bd9Sstevel@tonic-gate 
40357c478bd9Sstevel@tonic-gate 	return (1);
40367c478bd9Sstevel@tonic-gate }
40377c478bd9Sstevel@tonic-gate 
40387c478bd9Sstevel@tonic-gate /*
40397c478bd9Sstevel@tonic-gate  * allocates a new message structure, initializes it
40407c478bd9Sstevel@tonic-gate  * and returns a pointer to it
40417c478bd9Sstevel@tonic-gate  */
40427c478bd9Sstevel@tonic-gate static log_message_t *
40437c478bd9Sstevel@tonic-gate new_msg(void)
40447c478bd9Sstevel@tonic-gate {
40457c478bd9Sstevel@tonic-gate 	log_message_t *lm;
40467c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
40477c478bd9Sstevel@tonic-gate 
40487c478bd9Sstevel@tonic-gate 	if (Debug) {
40497c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
40507c478bd9Sstevel@tonic-gate 	}
40517c478bd9Sstevel@tonic-gate 
40527c478bd9Sstevel@tonic-gate 	if ((lm = malloc(sizeof (log_message_t))) == NULL)
40537c478bd9Sstevel@tonic-gate 		return ((log_message_t *)NULL);
40547c478bd9Sstevel@tonic-gate 
40557c478bd9Sstevel@tonic-gate 	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*lm))
40567c478bd9Sstevel@tonic-gate 
40577c478bd9Sstevel@tonic-gate 	if (pthread_mutex_init(&lm->msg_mutex, NULL) != 0)
40587c478bd9Sstevel@tonic-gate 		return ((log_message_t *)NULL);
40597c478bd9Sstevel@tonic-gate 	lm->refcnt = 0;
40607c478bd9Sstevel@tonic-gate 	lm->pri = 0;
40617c478bd9Sstevel@tonic-gate 	lm->flags = 0;
40627c478bd9Sstevel@tonic-gate 	lm->hlp = NULL;
40637c478bd9Sstevel@tonic-gate 	lm->msg[0] = '\0';
40647c478bd9Sstevel@tonic-gate 	lm->ptr = NULL;
40657c478bd9Sstevel@tonic-gate 
40667c478bd9Sstevel@tonic-gate 	DPRINT2(3, "new_msg(%u): creating msg %p\n", mythreadno, lm);
40677c478bd9Sstevel@tonic-gate 	return (lm);
40687c478bd9Sstevel@tonic-gate }
40697c478bd9Sstevel@tonic-gate 
40707c478bd9Sstevel@tonic-gate /*
40717c478bd9Sstevel@tonic-gate  * frees a message structure - should only be called if
40727c478bd9Sstevel@tonic-gate  * the refcount is 0
40737c478bd9Sstevel@tonic-gate  */
40747c478bd9Sstevel@tonic-gate static void
40757c478bd9Sstevel@tonic-gate free_msg(log_message_t *lm)
40767c478bd9Sstevel@tonic-gate {
40777c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
40787c478bd9Sstevel@tonic-gate 
40797c478bd9Sstevel@tonic-gate 	if (Debug) {
40807c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
40817c478bd9Sstevel@tonic-gate 	}
40827c478bd9Sstevel@tonic-gate 
40837c478bd9Sstevel@tonic-gate 	assert(lm != NULL && lm->refcnt == 0);
40847c478bd9Sstevel@tonic-gate 	if (lm->hlp != NULL)
40857c478bd9Sstevel@tonic-gate 		freehl(lm->hlp);
40867c478bd9Sstevel@tonic-gate 	DPRINT2(3, "free_msg(%u): freeing msg %p\n", mythreadno, lm);
40877c478bd9Sstevel@tonic-gate 	free(lm);
40887c478bd9Sstevel@tonic-gate }
40897c478bd9Sstevel@tonic-gate 
40907c478bd9Sstevel@tonic-gate /*
40917c478bd9Sstevel@tonic-gate  *  Make sure that the message makes sense in the current locale, and
40927c478bd9Sstevel@tonic-gate  *  does not contain stray control characters.
40937c478bd9Sstevel@tonic-gate  */
40947c478bd9Sstevel@tonic-gate static void
40957c478bd9Sstevel@tonic-gate filter_string(char *mbstr, char *filtered, size_t max)
40967c478bd9Sstevel@tonic-gate {
40977c478bd9Sstevel@tonic-gate 	size_t	cs = 0;
40987c478bd9Sstevel@tonic-gate 	size_t	mb_cur_max;
40997c478bd9Sstevel@tonic-gate 	unsigned char	*p = (unsigned char *)mbstr;
41007c478bd9Sstevel@tonic-gate 	pthread_t mythreadno = 0;
41017c478bd9Sstevel@tonic-gate 
41027c478bd9Sstevel@tonic-gate 	if (Debug) {
41037c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
41047c478bd9Sstevel@tonic-gate 	}
41057c478bd9Sstevel@tonic-gate 
41067c478bd9Sstevel@tonic-gate 	assert(mbstr != NULL && filtered != NULL);
41077c478bd9Sstevel@tonic-gate 
41087c478bd9Sstevel@tonic-gate 	/*
41097c478bd9Sstevel@tonic-gate 	 * Since the access to MB_CUR_MAX is expensive (because
41107c478bd9Sstevel@tonic-gate 	 * MB_CUR_MAX lives in a global area), it should be
41117c478bd9Sstevel@tonic-gate 	 * restrained for the better performance.
41127c478bd9Sstevel@tonic-gate 	 */
41137c478bd9Sstevel@tonic-gate 	mb_cur_max = (size_t)MB_CUR_MAX;
41147c478bd9Sstevel@tonic-gate 	if (mb_cur_max > 1) {
41157c478bd9Sstevel@tonic-gate 		/* multibyte locale */
41167c478bd9Sstevel@tonic-gate 		int	mlen;
41177c478bd9Sstevel@tonic-gate 		wchar_t	wc;
41187c478bd9Sstevel@tonic-gate 
41197c478bd9Sstevel@tonic-gate 		while (*p != '\0') {
41207c478bd9Sstevel@tonic-gate 			if ((mlen = mbtowc(&wc, (char *)p,
41217c478bd9Sstevel@tonic-gate 				mb_cur_max)) == -1) {
41227c478bd9Sstevel@tonic-gate 				/*
41237c478bd9Sstevel@tonic-gate 				 * Invalid byte sequence found.
41247c478bd9Sstevel@tonic-gate 				 *
41257c478bd9Sstevel@tonic-gate 				 * try to print one byte
41267c478bd9Sstevel@tonic-gate 				 * in ASCII format.
41277c478bd9Sstevel@tonic-gate 				 */
41287c478bd9Sstevel@tonic-gate 				DPRINT2(9, "filter_string(%u): Invalid "
41297c478bd9Sstevel@tonic-gate 					"MB sequence: %d\n", mythreadno,
41307c478bd9Sstevel@tonic-gate 					wc);
41317c478bd9Sstevel@tonic-gate 
41327c478bd9Sstevel@tonic-gate 				if (!putctrlc(*p++, &filtered, &cs, max)) {
41337c478bd9Sstevel@tonic-gate 					/* not enough buffer */
41347c478bd9Sstevel@tonic-gate 					goto end;
41357c478bd9Sstevel@tonic-gate 				} else {
41367c478bd9Sstevel@tonic-gate 					continue;
41377c478bd9Sstevel@tonic-gate 				}
41387c478bd9Sstevel@tonic-gate 			} else {
41397c478bd9Sstevel@tonic-gate 				/*
41407c478bd9Sstevel@tonic-gate 				 * Since *p is not a null byte here,
41417c478bd9Sstevel@tonic-gate 				 * mbtowc should have never returned 0.
41427c478bd9Sstevel@tonic-gate 				 *
41437c478bd9Sstevel@tonic-gate 				 * A valid wide character found.
41447c478bd9Sstevel@tonic-gate 				 */
41457c478bd9Sstevel@tonic-gate 
41467c478bd9Sstevel@tonic-gate 				if (wc != L'\t' && iswcntrl(wc)) {
41477c478bd9Sstevel@tonic-gate 					/*
41487c478bd9Sstevel@tonic-gate 					 * non-tab, non-newline, and
41497c478bd9Sstevel@tonic-gate 					 * control character found.
41507c478bd9Sstevel@tonic-gate 					 *
41517c478bd9Sstevel@tonic-gate 					 * try to print this wide character
41527c478bd9Sstevel@tonic-gate 					 * in ASCII-format.
41537c478bd9Sstevel@tonic-gate 					 */
41547c478bd9Sstevel@tonic-gate 					char	*q = filtered;
41557c478bd9Sstevel@tonic-gate 
41567c478bd9Sstevel@tonic-gate 					DPRINT2(9, "filter_string(%u): MB"
41577c478bd9Sstevel@tonic-gate 						" control character: %d\n",
41587c478bd9Sstevel@tonic-gate 						mythreadno, wc);
41597c478bd9Sstevel@tonic-gate 
41607c478bd9Sstevel@tonic-gate 					while (mlen--) {
41617c478bd9Sstevel@tonic-gate 						if (!putctrlc(*p++, &filtered,
41627c478bd9Sstevel@tonic-gate 							&cs, max)) {
41637c478bd9Sstevel@tonic-gate 							/*
41647c478bd9Sstevel@tonic-gate 							 * not enough buffer in
41657c478bd9Sstevel@tonic-gate 							 * filtered
41667c478bd9Sstevel@tonic-gate 							 *
41677c478bd9Sstevel@tonic-gate 							 * cancel already
41687c478bd9Sstevel@tonic-gate 							 * stored bytes in
41697c478bd9Sstevel@tonic-gate 							 * filtered for this
41707c478bd9Sstevel@tonic-gate 							 * wide character.
41717c478bd9Sstevel@tonic-gate 							 */
41727c478bd9Sstevel@tonic-gate 							filtered = q;
41737c478bd9Sstevel@tonic-gate 							goto end;
41747c478bd9Sstevel@tonic-gate 						}
41757c478bd9Sstevel@tonic-gate 					}
41767c478bd9Sstevel@tonic-gate 					continue;
41777c478bd9Sstevel@tonic-gate 				} else {
41787c478bd9Sstevel@tonic-gate 					/*
41797c478bd9Sstevel@tonic-gate 					 * tab, newline, or non-control
41807c478bd9Sstevel@tonic-gate 					 * character found.
41817c478bd9Sstevel@tonic-gate 					 */
41827c478bd9Sstevel@tonic-gate 					if (cs + mlen < max) {
41837c478bd9Sstevel@tonic-gate 						/* enough buffer */
41847c478bd9Sstevel@tonic-gate 						cs += mlen;
41857c478bd9Sstevel@tonic-gate 						while (mlen--) {
41867c478bd9Sstevel@tonic-gate 							*filtered++ = *p++;
41877c478bd9Sstevel@tonic-gate 						}
41887c478bd9Sstevel@tonic-gate 						continue;
41897c478bd9Sstevel@tonic-gate 					} else {
41907c478bd9Sstevel@tonic-gate 						/* not enough buffer */
41917c478bd9Sstevel@tonic-gate 						goto end;
41927c478bd9Sstevel@tonic-gate 					}
41937c478bd9Sstevel@tonic-gate 				}
41947c478bd9Sstevel@tonic-gate 			}
41957c478bd9Sstevel@tonic-gate 		}
41967c478bd9Sstevel@tonic-gate 	} else {
41977c478bd9Sstevel@tonic-gate 		/* singlebyte locale */
41987c478bd9Sstevel@tonic-gate 
41997c478bd9Sstevel@tonic-gate 		while (*p != '\0') {
42007c478bd9Sstevel@tonic-gate 			if (*p != '\t' && iscntrl(*p)) {
42017c478bd9Sstevel@tonic-gate 				/*
42027c478bd9Sstevel@tonic-gate 				 * non-tab, non-newline,
42037c478bd9Sstevel@tonic-gate 				 * and control character found.
42047c478bd9Sstevel@tonic-gate 				 *
42057c478bd9Sstevel@tonic-gate 				 * try to print this singlebyte character
42067c478bd9Sstevel@tonic-gate 				 * in ASCII format.
42077c478bd9Sstevel@tonic-gate 				 */
42087c478bd9Sstevel@tonic-gate 				DPRINT2(9, "filter_string(%u): control "
42097c478bd9Sstevel@tonic-gate 					"character: %d\n", mythreadno, *p);
42107c478bd9Sstevel@tonic-gate 
42117c478bd9Sstevel@tonic-gate 				if (!putctrlc(*p++, &filtered, &cs, max)) {
42127c478bd9Sstevel@tonic-gate 					/* not enough buffer */
42137c478bd9Sstevel@tonic-gate 					goto end;
42147c478bd9Sstevel@tonic-gate 				} else {
42157c478bd9Sstevel@tonic-gate 					continue;
42167c478bd9Sstevel@tonic-gate 				}
42177c478bd9Sstevel@tonic-gate 			} else if (*p != '\t' && !isprint(*p)) {
42187c478bd9Sstevel@tonic-gate 				/*
42197c478bd9Sstevel@tonic-gate 				 * non-tab and non printable character found
42207c478bd9Sstevel@tonic-gate 				 * this check is required for the C locale
42217c478bd9Sstevel@tonic-gate 				 */
42227c478bd9Sstevel@tonic-gate 				DPRINT2(9, "filter_string(%u): non-printable "
42237c478bd9Sstevel@tonic-gate 					"character: %d\n", mythreadno, *p);
42247c478bd9Sstevel@tonic-gate 				if (!putctrlc(*p++, &filtered, &cs, max)) {
42257c478bd9Sstevel@tonic-gate 					/* not enough buffer */
42267c478bd9Sstevel@tonic-gate 					goto end;
42277c478bd9Sstevel@tonic-gate 				} else {
42287c478bd9Sstevel@tonic-gate 					continue;
42297c478bd9Sstevel@tonic-gate 				}
42307c478bd9Sstevel@tonic-gate 			} else {
42317c478bd9Sstevel@tonic-gate 				/*
42327c478bd9Sstevel@tonic-gate 				 * tab, newline, non-control character, or
42337c478bd9Sstevel@tonic-gate 				 * printable found.
42347c478bd9Sstevel@tonic-gate 				 */
42357c478bd9Sstevel@tonic-gate 				if (cs + 1 < max) {
42367c478bd9Sstevel@tonic-gate 					*filtered++ = *p++;
42377c478bd9Sstevel@tonic-gate 					cs++;
42387c478bd9Sstevel@tonic-gate 					continue;
42397c478bd9Sstevel@tonic-gate 				} else {
42407c478bd9Sstevel@tonic-gate 					/* not enough buffer */
42417c478bd9Sstevel@tonic-gate 					goto end;
42427c478bd9Sstevel@tonic-gate 				}
42437c478bd9Sstevel@tonic-gate 			}
42447c478bd9Sstevel@tonic-gate 		}
42457c478bd9Sstevel@tonic-gate 	}
42467c478bd9Sstevel@tonic-gate 
42477c478bd9Sstevel@tonic-gate end:
42487c478bd9Sstevel@tonic-gate 	*filtered = '\0';
42497c478bd9Sstevel@tonic-gate 
42507c478bd9Sstevel@tonic-gate 	if (cs >= 2 &&
42517c478bd9Sstevel@tonic-gate 		filtered[-2] == '\\' && filtered[-1] == 'n') {
42527c478bd9Sstevel@tonic-gate 		filtered[-2] = '\0';
42537c478bd9Sstevel@tonic-gate 	}
42547c478bd9Sstevel@tonic-gate }
42557c478bd9Sstevel@tonic-gate 
42567c478bd9Sstevel@tonic-gate static char *
42577c478bd9Sstevel@tonic-gate alloc_stacks(int numstacks)
42587c478bd9Sstevel@tonic-gate {
42597c478bd9Sstevel@tonic-gate 	size_t pagesize, mapsize;
42607c478bd9Sstevel@tonic-gate 	char *stack_top;
42617c478bd9Sstevel@tonic-gate 	char *addr;
42627c478bd9Sstevel@tonic-gate 	int i;
42637c478bd9Sstevel@tonic-gate 
42647c478bd9Sstevel@tonic-gate 	pagesize = (size_t)sysconf(_SC_PAGESIZE);
42657c478bd9Sstevel@tonic-gate 	/*
42667c478bd9Sstevel@tonic-gate 	 * stacksize and redzonesize are global so threads
42677c478bd9Sstevel@tonic-gate 	 * can be created elsewhere and refer to the sizes
42687c478bd9Sstevel@tonic-gate 	 */
42697c478bd9Sstevel@tonic-gate 	stacksize = (size_t)roundup(sysconf(_SC_THREAD_STACK_MIN) +
42707c478bd9Sstevel@tonic-gate 		DEFAULT_STACKSIZE, pagesize);
42717c478bd9Sstevel@tonic-gate 	redzonesize = (size_t)roundup(DEFAULT_REDZONESIZE, pagesize);
42727c478bd9Sstevel@tonic-gate 
42737c478bd9Sstevel@tonic-gate 	/*
42747c478bd9Sstevel@tonic-gate 	 * allocate an additional "redzonesize" chunk in addition
42757c478bd9Sstevel@tonic-gate 	 * to what we require, so we can create a redzone at the
42767c478bd9Sstevel@tonic-gate 	 * bottom of the last stack as well.
42777c478bd9Sstevel@tonic-gate 	 */
42787c478bd9Sstevel@tonic-gate 	mapsize = redzonesize + numstacks * (stacksize + redzonesize);
42797c478bd9Sstevel@tonic-gate 	stack_top = mmap(NULL, mapsize, PROT_READ|PROT_WRITE,
42807c478bd9Sstevel@tonic-gate 		MAP_PRIVATE|MAP_ANON, -1, 0);
42817c478bd9Sstevel@tonic-gate 	if (stack_top == MAP_FAILED)
42827c478bd9Sstevel@tonic-gate 		return (NULL);
42837c478bd9Sstevel@tonic-gate 
42847c478bd9Sstevel@tonic-gate 	addr = stack_top;
42857c478bd9Sstevel@tonic-gate 	/*
42867c478bd9Sstevel@tonic-gate 	 * this loop is intentionally <= instead of <, so we can
42877c478bd9Sstevel@tonic-gate 	 * protect the redzone at the bottom of the last stack
42887c478bd9Sstevel@tonic-gate 	 */
42897c478bd9Sstevel@tonic-gate 	for (i = 0; i <= numstacks; i++) {
42907c478bd9Sstevel@tonic-gate 		(void) mprotect(addr, redzonesize, PROT_NONE);
42917c478bd9Sstevel@tonic-gate 		addr += stacksize + redzonesize;
42927c478bd9Sstevel@tonic-gate 	}
42937c478bd9Sstevel@tonic-gate 	return ((char *)(stack_top + redzonesize));
42947c478bd9Sstevel@tonic-gate }
42957c478bd9Sstevel@tonic-gate 
42967c478bd9Sstevel@tonic-gate static void
42977c478bd9Sstevel@tonic-gate dealloc_stacks(int numstacks)
42987c478bd9Sstevel@tonic-gate {
42997c478bd9Sstevel@tonic-gate 	size_t pagesize, mapsize;
43007c478bd9Sstevel@tonic-gate 
43017c478bd9Sstevel@tonic-gate 	pagesize = (size_t)sysconf(_SC_PAGESIZE);
43027c478bd9Sstevel@tonic-gate 
43037c478bd9Sstevel@tonic-gate 	stacksize = (size_t)roundup(sysconf(_SC_THREAD_STACK_MIN) +
43047c478bd9Sstevel@tonic-gate 	    DEFAULT_STACKSIZE, pagesize);
43057c478bd9Sstevel@tonic-gate 
43067c478bd9Sstevel@tonic-gate 	redzonesize = (size_t)roundup(DEFAULT_REDZONESIZE, pagesize);
43077c478bd9Sstevel@tonic-gate 
43087c478bd9Sstevel@tonic-gate 	mapsize = redzonesize + numstacks * (stacksize + redzonesize);
43097c478bd9Sstevel@tonic-gate 	(void) munmap(cstack_ptr - mapsize, mapsize);
43107c478bd9Sstevel@tonic-gate }
43117c478bd9Sstevel@tonic-gate 
43127c478bd9Sstevel@tonic-gate static void
43137c478bd9Sstevel@tonic-gate filed_destroy(struct filed *f)
43147c478bd9Sstevel@tonic-gate {
43157c478bd9Sstevel@tonic-gate 	(void) dataq_destroy(&f->f_queue);
43167c478bd9Sstevel@tonic-gate 	pthread_mutex_destroy(&f->filed_mutex);
43177c478bd9Sstevel@tonic-gate }
43187c478bd9Sstevel@tonic-gate 
43197c478bd9Sstevel@tonic-gate static void
43207c478bd9Sstevel@tonic-gate close_door(void)
43217c478bd9Sstevel@tonic-gate {
43227c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
43237c478bd9Sstevel@tonic-gate 
43247c478bd9Sstevel@tonic-gate 	if (Debug) {
43257c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
43267c478bd9Sstevel@tonic-gate 	}
43277c478bd9Sstevel@tonic-gate 
43287c478bd9Sstevel@tonic-gate 	(void) fdetach(DoorFileName);
43297c478bd9Sstevel@tonic-gate 
43307c478bd9Sstevel@tonic-gate 	DPRINT2(5, "close_door(%u): detached server() from %s\n",
43317c478bd9Sstevel@tonic-gate 		mythreadno, DoorFileName);
43327c478bd9Sstevel@tonic-gate }
43337c478bd9Sstevel@tonic-gate 
43347c478bd9Sstevel@tonic-gate static void
43357c478bd9Sstevel@tonic-gate delete_doorfiles(void)
43367c478bd9Sstevel@tonic-gate {
43377c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
43387c478bd9Sstevel@tonic-gate 	struct stat sb;
43397c478bd9Sstevel@tonic-gate 	int err;
43407c478bd9Sstevel@tonic-gate 	char line[MAXLINE+1];
43417c478bd9Sstevel@tonic-gate 
43427c478bd9Sstevel@tonic-gate 	if (Debug) {
43437c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
43447c478bd9Sstevel@tonic-gate 	}
43457c478bd9Sstevel@tonic-gate 
43467c478bd9Sstevel@tonic-gate 
43477c478bd9Sstevel@tonic-gate 	if (lstat(DoorFileName, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
43487c478bd9Sstevel@tonic-gate 		if (unlink(DoorFileName) < 0) {
43497c478bd9Sstevel@tonic-gate 			err = errno;
43507c478bd9Sstevel@tonic-gate 			(void) sprintf(line, "unlink() of %s failed - fatal",
43517c478bd9Sstevel@tonic-gate 				DoorFileName);
43527c478bd9Sstevel@tonic-gate 			errno = err;
43537c478bd9Sstevel@tonic-gate 			logerror(line);
43547c478bd9Sstevel@tonic-gate 			DPRINT3(1, "delete_doorfiles(%u): error: %s, "
43557c478bd9Sstevel@tonic-gate 				"errno=%d\n", mythreadno, line, err);
43567c478bd9Sstevel@tonic-gate 			exit(1);
43577c478bd9Sstevel@tonic-gate 		}
43587c478bd9Sstevel@tonic-gate 
43597c478bd9Sstevel@tonic-gate 		DPRINT2(5, "delete_doorfiles(%u): deleted %s\n",
43607c478bd9Sstevel@tonic-gate 			mythreadno, DoorFileName);
43617c478bd9Sstevel@tonic-gate 	}
43627c478bd9Sstevel@tonic-gate 
43637c478bd9Sstevel@tonic-gate 	if (strcmp(DoorFileName, DOORFILE) == 0) {
43647c478bd9Sstevel@tonic-gate 		if (lstat(OLD_DOORFILE, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
43657c478bd9Sstevel@tonic-gate 			if (unlink(OLD_DOORFILE) < 0) {
43667c478bd9Sstevel@tonic-gate 				err = errno;
43677c478bd9Sstevel@tonic-gate 				(void) sprintf(line, "unlink() of %s "
43687c478bd9Sstevel@tonic-gate 					"failed", OLD_DOORFILE);
43697c478bd9Sstevel@tonic-gate 				DPRINT2(5, "delete_doorfiles(%u): %s\n",
43707c478bd9Sstevel@tonic-gate 					mythreadno, line);
43717c478bd9Sstevel@tonic-gate 
43727c478bd9Sstevel@tonic-gate 				if (err != EROFS) {
43737c478bd9Sstevel@tonic-gate 					errno = err;
43747c478bd9Sstevel@tonic-gate 					(void) strcat(line, " - fatal");
43757c478bd9Sstevel@tonic-gate 					logerror(line);
43767c478bd9Sstevel@tonic-gate 					DPRINT3(1, "delete_doorfiles(%u): "
43777c478bd9Sstevel@tonic-gate 						"error: %s, errno=%d\n",
43787c478bd9Sstevel@tonic-gate 						mythreadno, line, err);
43797c478bd9Sstevel@tonic-gate 					exit(1);
43807c478bd9Sstevel@tonic-gate 				}
43817c478bd9Sstevel@tonic-gate 
43827c478bd9Sstevel@tonic-gate 				DPRINT1(5, "delete_doorfiles(%u): unlink() "
43837c478bd9Sstevel@tonic-gate 					"failure OK on RO file system\n",
43847c478bd9Sstevel@tonic-gate 					mythreadno);
43857c478bd9Sstevel@tonic-gate 			}
43867c478bd9Sstevel@tonic-gate 
43877c478bd9Sstevel@tonic-gate 			DPRINT2(5, "delete_doorfiles(%u): deleted %s\n",
43887c478bd9Sstevel@tonic-gate 				mythreadno, OLD_DOORFILE);
43897c478bd9Sstevel@tonic-gate 		}
43907c478bd9Sstevel@tonic-gate 	}
43917c478bd9Sstevel@tonic-gate 
43927c478bd9Sstevel@tonic-gate 	if (lstat(PidFileName, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
43937c478bd9Sstevel@tonic-gate 		if (unlink(PidFileName) < 0) {
43947c478bd9Sstevel@tonic-gate 			err = errno;
43957c478bd9Sstevel@tonic-gate 			(void) sprintf(line, "unlink() of %s failed"
43967c478bd9Sstevel@tonic-gate 				" - fatal", PidFileName);
43977c478bd9Sstevel@tonic-gate 			errno = err;
43987c478bd9Sstevel@tonic-gate 			logerror(line);
43997c478bd9Sstevel@tonic-gate 			DPRINT3(1, "delete_doorfiles(%u): error: %s, "
44007c478bd9Sstevel@tonic-gate 				"errno=%d\n", mythreadno, line, err);
44017c478bd9Sstevel@tonic-gate 			exit(1);
44027c478bd9Sstevel@tonic-gate 		}
44037c478bd9Sstevel@tonic-gate 
44047c478bd9Sstevel@tonic-gate 		DPRINT2(5, "delete_doorfiles(%u): deleted %s\n", mythreadno,
44057c478bd9Sstevel@tonic-gate 			PidFileName);
44067c478bd9Sstevel@tonic-gate 	}
44077c478bd9Sstevel@tonic-gate 
44087c478bd9Sstevel@tonic-gate 	if (strcmp(PidFileName, PIDFILE) == 0) {
44097c478bd9Sstevel@tonic-gate 		if (lstat(OLD_PIDFILE, &sb) == 0 && !S_ISDIR(sb.st_mode)) {
44107c478bd9Sstevel@tonic-gate 			if (unlink(OLD_PIDFILE) < 0) {
44117c478bd9Sstevel@tonic-gate 				err = errno;
44127c478bd9Sstevel@tonic-gate 				(void) sprintf(line, "unlink() of %s failed",
44137c478bd9Sstevel@tonic-gate 					OLD_PIDFILE);
44147c478bd9Sstevel@tonic-gate 				DPRINT2(5, "delete_doorfiles(%u): %s, \n",
44157c478bd9Sstevel@tonic-gate 					mythreadno, line);
44167c478bd9Sstevel@tonic-gate 
44177c478bd9Sstevel@tonic-gate 				if (err != EROFS) {
44187c478bd9Sstevel@tonic-gate 					errno = err;
44197c478bd9Sstevel@tonic-gate 					(void) strcat(line, " - fatal");
44207c478bd9Sstevel@tonic-gate 					logerror(line);
44217c478bd9Sstevel@tonic-gate 					DPRINT3(1, "delete_doorfiles(%u): "
44227c478bd9Sstevel@tonic-gate 						"error: %s, errno=%d\n",
44237c478bd9Sstevel@tonic-gate 						mythreadno, line, err);
44247c478bd9Sstevel@tonic-gate 					exit(1);
44257c478bd9Sstevel@tonic-gate 				}
44267c478bd9Sstevel@tonic-gate 
44277c478bd9Sstevel@tonic-gate 				DPRINT1(5, "delete_doorfiles(%u): unlink "
44287c478bd9Sstevel@tonic-gate 					"failure OK on RO file system\n",
44297c478bd9Sstevel@tonic-gate 					mythreadno);
44307c478bd9Sstevel@tonic-gate 			}
44317c478bd9Sstevel@tonic-gate 
44327c478bd9Sstevel@tonic-gate 			DPRINT2(5, "delete_doorfiles(%u): deleted %s\n",
44337c478bd9Sstevel@tonic-gate 				mythreadno, OLD_PIDFILE);
44347c478bd9Sstevel@tonic-gate 		}
44357c478bd9Sstevel@tonic-gate 	}
44367c478bd9Sstevel@tonic-gate 
44377c478bd9Sstevel@tonic-gate 	if (DoorFd != -1) {
44387c478bd9Sstevel@tonic-gate 		(void) door_revoke(DoorFd);
44397c478bd9Sstevel@tonic-gate 	}
44407c478bd9Sstevel@tonic-gate 
44417c478bd9Sstevel@tonic-gate 	DPRINT2(1, "delete_doorfiles(%u): revoked door: DoorFd=%d\n",
44427c478bd9Sstevel@tonic-gate 		mythreadno, DoorFd);
44437c478bd9Sstevel@tonic-gate }
44447c478bd9Sstevel@tonic-gate 
44457c478bd9Sstevel@tonic-gate 
44467c478bd9Sstevel@tonic-gate /*ARGSUSED*/
44477c478bd9Sstevel@tonic-gate static void
44487c478bd9Sstevel@tonic-gate signull(int sig, siginfo_t *sip, void *utp)
44497c478bd9Sstevel@tonic-gate {
44507c478bd9Sstevel@tonic-gate 	DPRINT1(1, "signull(%u): THIS CALL SHOULD NEVER HAPPEN\n",
44517c478bd9Sstevel@tonic-gate 		pthread_self());
44527c478bd9Sstevel@tonic-gate 	/*
44537c478bd9Sstevel@tonic-gate 	 * Do nothing, as this is a place-holder used in conjunction with
44547c478bd9Sstevel@tonic-gate 	 * sigaction()/sigwait() to ensure that the proper disposition is
44557c478bd9Sstevel@tonic-gate 	 * given to the signals we handle in main().
44567c478bd9Sstevel@tonic-gate 	 */
44577c478bd9Sstevel@tonic-gate }
44587c478bd9Sstevel@tonic-gate 
44597c478bd9Sstevel@tonic-gate /*
44607c478bd9Sstevel@tonic-gate  * putctrlc returns zero, if failed due to not enough buffer.
44617c478bd9Sstevel@tonic-gate  * Otherwise, putctrlc returns non-zero.
44627c478bd9Sstevel@tonic-gate  *
44637c478bd9Sstevel@tonic-gate  * c:     a byte to print in ASCII format
44647c478bd9Sstevel@tonic-gate  * **buf: a pointer to the pointer to the output buffer.
44657c478bd9Sstevel@tonic-gate  * *cl:   current length of characters in the output buffer
44667c478bd9Sstevel@tonic-gate  * max:   maximum length of the buffer
44677c478bd9Sstevel@tonic-gate  */
44687c478bd9Sstevel@tonic-gate 
44697c478bd9Sstevel@tonic-gate static int
44707c478bd9Sstevel@tonic-gate putctrlc(int c, char **buf, size_t *cl, size_t max)
44717c478bd9Sstevel@tonic-gate {
44727c478bd9Sstevel@tonic-gate 	char	*p = *buf;
44737c478bd9Sstevel@tonic-gate 
44747c478bd9Sstevel@tonic-gate 	if (c == '\n') {
44757c478bd9Sstevel@tonic-gate 		if (*cl + 2 < max) {
44767c478bd9Sstevel@tonic-gate 			*p++ = '\\';
44777c478bd9Sstevel@tonic-gate 			*p++ = 'n';
44787c478bd9Sstevel@tonic-gate 			*cl += 2;
44797c478bd9Sstevel@tonic-gate 			*buf = p;
44807c478bd9Sstevel@tonic-gate 			return (2);
44817c478bd9Sstevel@tonic-gate 		} else {
44827c478bd9Sstevel@tonic-gate 			return (0);
44837c478bd9Sstevel@tonic-gate 		}
44847c478bd9Sstevel@tonic-gate 	} else if (c < 0200) {
44857c478bd9Sstevel@tonic-gate 		/* ascii control character */
44867c478bd9Sstevel@tonic-gate 		if (*cl + 2 < max) {
44877c478bd9Sstevel@tonic-gate 			*p++ = '^';
44887c478bd9Sstevel@tonic-gate 			*p++ = c ^ 0100;
44897c478bd9Sstevel@tonic-gate 			*cl += 2;
44907c478bd9Sstevel@tonic-gate 			*buf = p;
44917c478bd9Sstevel@tonic-gate 			return (2);
44927c478bd9Sstevel@tonic-gate 		} else {
44937c478bd9Sstevel@tonic-gate 			return (0);
44947c478bd9Sstevel@tonic-gate 		}
44957c478bd9Sstevel@tonic-gate 	} else {
44967c478bd9Sstevel@tonic-gate 		if (*cl + 4 < max) {
44977c478bd9Sstevel@tonic-gate 			*p++ = '\\';
44987c478bd9Sstevel@tonic-gate 			*p++ = ((c >> 6) & 07) + '0';
44997c478bd9Sstevel@tonic-gate 			*p++ = ((c >> 3) & 07) + '0';
45007c478bd9Sstevel@tonic-gate 			*p++ = (c & 07) + '0';
45017c478bd9Sstevel@tonic-gate 			*cl += 4;
45027c478bd9Sstevel@tonic-gate 			*buf = p;
45037c478bd9Sstevel@tonic-gate 			return (4);
45047c478bd9Sstevel@tonic-gate 		} else {
45057c478bd9Sstevel@tonic-gate 			return (0);
45067c478bd9Sstevel@tonic-gate 		}
45077c478bd9Sstevel@tonic-gate 	}
45087c478bd9Sstevel@tonic-gate }
45097c478bd9Sstevel@tonic-gate 
45107c478bd9Sstevel@tonic-gate /*
45117c478bd9Sstevel@tonic-gate  * findnl_bkwd:
45127c478bd9Sstevel@tonic-gate  *	Scans each character in buf until it finds the last newline in buf,
45137c478bd9Sstevel@tonic-gate  *	or the scanned character becomes the last COMPLETE character in buf.
45147c478bd9Sstevel@tonic-gate  *	Returns the number of scanned bytes.
45157c478bd9Sstevel@tonic-gate  *
45167c478bd9Sstevel@tonic-gate  *	buf - pointer to a buffer containing the message string
45177c478bd9Sstevel@tonic-gate  *	len - the length of the buffer
45187c478bd9Sstevel@tonic-gate  */
45197c478bd9Sstevel@tonic-gate size_t
45207c478bd9Sstevel@tonic-gate findnl_bkwd(const char *buf, const size_t len)
45217c478bd9Sstevel@tonic-gate {
45227c478bd9Sstevel@tonic-gate 	const char *p;
45237c478bd9Sstevel@tonic-gate 	size_t	mb_cur_max;
45247c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
45257c478bd9Sstevel@tonic-gate 
45267c478bd9Sstevel@tonic-gate 	if (Debug) {
45277c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
45287c478bd9Sstevel@tonic-gate 	}
45297c478bd9Sstevel@tonic-gate 
45307c478bd9Sstevel@tonic-gate 	if (len == 0) {
45317c478bd9Sstevel@tonic-gate 		return (0);
45327c478bd9Sstevel@tonic-gate 	}
45337c478bd9Sstevel@tonic-gate 
45347c478bd9Sstevel@tonic-gate 	mb_cur_max = MB_CUR_MAX;
45357c478bd9Sstevel@tonic-gate 
45367c478bd9Sstevel@tonic-gate 	if (mb_cur_max == 1) {
45377c478bd9Sstevel@tonic-gate 		/* single-byte locale */
45387c478bd9Sstevel@tonic-gate 		for (p = buf + len - 1; p != buf; p--) {
45397c478bd9Sstevel@tonic-gate 			if (*p == '\n') {
45407c478bd9Sstevel@tonic-gate 				return ((size_t)(p - buf));
45417c478bd9Sstevel@tonic-gate 			}
45427c478bd9Sstevel@tonic-gate 		}
45437c478bd9Sstevel@tonic-gate 		return ((size_t)len);
45447c478bd9Sstevel@tonic-gate 	} else {
45457c478bd9Sstevel@tonic-gate 		/* multi-byte locale */
45467c478bd9Sstevel@tonic-gate 		int mlen;
45477c478bd9Sstevel@tonic-gate 		const char *nl;
45487c478bd9Sstevel@tonic-gate 		size_t	rem;
45497c478bd9Sstevel@tonic-gate 
45507c478bd9Sstevel@tonic-gate 		p = buf;
45517c478bd9Sstevel@tonic-gate 		nl = NULL;
45527c478bd9Sstevel@tonic-gate 		for (rem = len; rem >= mb_cur_max; ) {
45537c478bd9Sstevel@tonic-gate 			mlen = mblen(p, mb_cur_max);
45547c478bd9Sstevel@tonic-gate 			if (mlen == -1) {
45557c478bd9Sstevel@tonic-gate 				/*
45567c478bd9Sstevel@tonic-gate 				 * Invalid character found.
45577c478bd9Sstevel@tonic-gate 				 */
45587c478bd9Sstevel@tonic-gate 				DPRINT1(9, "findnl_bkwd(%u): Invalid MB "
45597c478bd9Sstevel@tonic-gate 					"sequence\n", mythreadno);
45607c478bd9Sstevel@tonic-gate 				/*
45617c478bd9Sstevel@tonic-gate 				 * handle as a single byte character.
45627c478bd9Sstevel@tonic-gate 				 */
45637c478bd9Sstevel@tonic-gate 				p++;
45647c478bd9Sstevel@tonic-gate 				rem--;
45657c478bd9Sstevel@tonic-gate 			} else {
45667c478bd9Sstevel@tonic-gate 				/*
45677c478bd9Sstevel@tonic-gate 				 * It's guaranteed that *p points to
45687c478bd9Sstevel@tonic-gate 				 * the 1st byte of a multibyte character.
45697c478bd9Sstevel@tonic-gate 				 */
45707c478bd9Sstevel@tonic-gate 				if (*p == '\n') {
45717c478bd9Sstevel@tonic-gate 					nl = p;
45727c478bd9Sstevel@tonic-gate 				}
45737c478bd9Sstevel@tonic-gate 				p += mlen;
45747c478bd9Sstevel@tonic-gate 				rem -= mlen;
45757c478bd9Sstevel@tonic-gate 			}
45767c478bd9Sstevel@tonic-gate 		}
45777c478bd9Sstevel@tonic-gate 		if (nl) {
45787c478bd9Sstevel@tonic-gate 			return ((size_t)(nl - buf));
45797c478bd9Sstevel@tonic-gate 		}
45807c478bd9Sstevel@tonic-gate 		/*
45817c478bd9Sstevel@tonic-gate 		 * no newline nor null byte found.
45827c478bd9Sstevel@tonic-gate 		 * Also it's guaranteed that *p points to
45837c478bd9Sstevel@tonic-gate 		 * the 1st byte of a (multibyte) character
45847c478bd9Sstevel@tonic-gate 		 * at this point.
45857c478bd9Sstevel@tonic-gate 		 */
45867c478bd9Sstevel@tonic-gate 		return (len - rem);
45877c478bd9Sstevel@tonic-gate 	}
45887c478bd9Sstevel@tonic-gate }
45897c478bd9Sstevel@tonic-gate 
45907c478bd9Sstevel@tonic-gate /*
45917c478bd9Sstevel@tonic-gate  * copynl_frwd:
45927c478bd9Sstevel@tonic-gate  *	Scans each character in buf and copies the scanned character to obuf
45937c478bd9Sstevel@tonic-gate  *	until it finds a null byte or a newline, or
45947c478bd9Sstevel@tonic-gate  *	the number of the remaining bytes in obuf gets to exceed obuflen
45957c478bd9Sstevel@tonic-gate  *	if copying the scanned character to obuf.
45967c478bd9Sstevel@tonic-gate  *	Returns the number of scanned bytes.
45977c478bd9Sstevel@tonic-gate  *
45987c478bd9Sstevel@tonic-gate  *	obuf - buffer to be copied the scanned character
45997c478bd9Sstevel@tonic-gate  *	obuflen - the size of obuf
46007c478bd9Sstevel@tonic-gate  *	buf - pointer to a buffer containing the message string
46017c478bd9Sstevel@tonic-gate  *	len - the length of the buffer
46027c478bd9Sstevel@tonic-gate  */
46037c478bd9Sstevel@tonic-gate size_t
46047c478bd9Sstevel@tonic-gate copynl_frwd(char *obuf, const size_t obuflen,
46057c478bd9Sstevel@tonic-gate 	    const char *buf, const size_t len)
46067c478bd9Sstevel@tonic-gate {
46077c478bd9Sstevel@tonic-gate 	const char *p;
46087c478bd9Sstevel@tonic-gate 	char	*q = obuf;
46097c478bd9Sstevel@tonic-gate 	size_t	olen = 0;
46107c478bd9Sstevel@tonic-gate 	size_t	mb_cur_max;
46117c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
46127c478bd9Sstevel@tonic-gate 
46137c478bd9Sstevel@tonic-gate 	if (Debug) {
46147c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
46157c478bd9Sstevel@tonic-gate 	}
46167c478bd9Sstevel@tonic-gate 
46177c478bd9Sstevel@tonic-gate 	if (len == 0) {
46187c478bd9Sstevel@tonic-gate 		return (0);
46197c478bd9Sstevel@tonic-gate 	}
46207c478bd9Sstevel@tonic-gate 
46217c478bd9Sstevel@tonic-gate 	mb_cur_max = MB_CUR_MAX;
46227c478bd9Sstevel@tonic-gate 
46237c478bd9Sstevel@tonic-gate 	if (mb_cur_max == 1) {
46247c478bd9Sstevel@tonic-gate 		/* single-byte locale */
46257c478bd9Sstevel@tonic-gate 		for (p = buf; *p; ) {
46267c478bd9Sstevel@tonic-gate 			if (obuflen > olen + 1) {
46277c478bd9Sstevel@tonic-gate 				if (*p != '\n') {
46287c478bd9Sstevel@tonic-gate 					*q++ = *p++;
46297c478bd9Sstevel@tonic-gate 					olen++;
46307c478bd9Sstevel@tonic-gate 				} else {
46317c478bd9Sstevel@tonic-gate 					*q = '\0';
46327c478bd9Sstevel@tonic-gate 					return ((size_t)(p - buf));
46337c478bd9Sstevel@tonic-gate 				}
46347c478bd9Sstevel@tonic-gate 			} else {
46357c478bd9Sstevel@tonic-gate 				*q = '\0';
46367c478bd9Sstevel@tonic-gate 				return ((size_t)(p - buf));
46377c478bd9Sstevel@tonic-gate 			}
46387c478bd9Sstevel@tonic-gate 		}
46397c478bd9Sstevel@tonic-gate 		*q = '\0';
46407c478bd9Sstevel@tonic-gate 		return ((size_t)(p - buf));
46417c478bd9Sstevel@tonic-gate 	} else {
46427c478bd9Sstevel@tonic-gate 		/* multi-byte locale */
46437c478bd9Sstevel@tonic-gate 		int mlen;
46447c478bd9Sstevel@tonic-gate 
46457c478bd9Sstevel@tonic-gate 		for (p = buf; *p; ) {
46467c478bd9Sstevel@tonic-gate 			mlen = mblen(p, mb_cur_max);
46477c478bd9Sstevel@tonic-gate 			if (mlen == -1) {
46487c478bd9Sstevel@tonic-gate 				/*
46497c478bd9Sstevel@tonic-gate 				 * Invalid character found.
46507c478bd9Sstevel@tonic-gate 				 */
46517c478bd9Sstevel@tonic-gate 				DPRINT1(9, "copynl_frwd(%u): Invalid MB "
46527c478bd9Sstevel@tonic-gate 					"sequence\n", mythreadno);
46537c478bd9Sstevel@tonic-gate 				/*
46547c478bd9Sstevel@tonic-gate 				 * handle as a single byte character.
46557c478bd9Sstevel@tonic-gate 				 */
46567c478bd9Sstevel@tonic-gate 				if (obuflen > olen + 1) {
46577c478bd9Sstevel@tonic-gate 					*q++ = *p++;
46587c478bd9Sstevel@tonic-gate 					olen++;
46597c478bd9Sstevel@tonic-gate 				} else {
46607c478bd9Sstevel@tonic-gate 					*q = '\0';
46617c478bd9Sstevel@tonic-gate 					return ((size_t)(p - buf));
46627c478bd9Sstevel@tonic-gate 				}
46637c478bd9Sstevel@tonic-gate 			} else {
46647c478bd9Sstevel@tonic-gate 				/*
46657c478bd9Sstevel@tonic-gate 				 * It's guaranteed that *p points to
46667c478bd9Sstevel@tonic-gate 				 * the 1st byte of a multibyte character.
46677c478bd9Sstevel@tonic-gate 				 */
46687c478bd9Sstevel@tonic-gate 				if (*p == '\n') {
46697c478bd9Sstevel@tonic-gate 					*q = '\0';
46707c478bd9Sstevel@tonic-gate 					return ((size_t)(p - buf));
46717c478bd9Sstevel@tonic-gate 				}
46727c478bd9Sstevel@tonic-gate 				if (obuflen > olen + mlen) {
46737c478bd9Sstevel@tonic-gate 					int	n;
46747c478bd9Sstevel@tonic-gate 					for (n = 0; n < mlen; n++) {
46757c478bd9Sstevel@tonic-gate 						*q++ = *p++;
46767c478bd9Sstevel@tonic-gate 					}
46777c478bd9Sstevel@tonic-gate 					olen += mlen;
46787c478bd9Sstevel@tonic-gate 				} else {
46797c478bd9Sstevel@tonic-gate 					*q = '\0';
46807c478bd9Sstevel@tonic-gate 					return ((size_t)(p - buf));
46817c478bd9Sstevel@tonic-gate 				}
46827c478bd9Sstevel@tonic-gate 			}
46837c478bd9Sstevel@tonic-gate 		}
46847c478bd9Sstevel@tonic-gate 		/*
46857c478bd9Sstevel@tonic-gate 		 * no newline nor null byte found.
46867c478bd9Sstevel@tonic-gate 		 * Also it's guaranteed that *p points to
46877c478bd9Sstevel@tonic-gate 		 * the 1st byte of a (multibyte) character
46887c478bd9Sstevel@tonic-gate 		 * at this point.
46897c478bd9Sstevel@tonic-gate 		 */
46907c478bd9Sstevel@tonic-gate 		*q = '\0';
46917c478bd9Sstevel@tonic-gate 		return ((size_t)(p - buf));
46927c478bd9Sstevel@tonic-gate 	}
46937c478bd9Sstevel@tonic-gate }
46947c478bd9Sstevel@tonic-gate 
46957c478bd9Sstevel@tonic-gate /*
46967c478bd9Sstevel@tonic-gate  * copy_frwd:
46977c478bd9Sstevel@tonic-gate  *	Scans each character in buf and copies the scanned character to obuf
46987c478bd9Sstevel@tonic-gate  *	until the number of the remaining bytes in obuf gets to exceed obuflen
46997c478bd9Sstevel@tonic-gate  *	if copying the scanned character to obuf.
47007c478bd9Sstevel@tonic-gate  *	Returns the number of scanned (copied) bytes.
47017c478bd9Sstevel@tonic-gate  *
47027c478bd9Sstevel@tonic-gate  *	obuf - buffer to be copied the scanned character
47037c478bd9Sstevel@tonic-gate  *	obuflen - the size of obuf
47047c478bd9Sstevel@tonic-gate  *	buf - pointer to a buffer containing the message string
47057c478bd9Sstevel@tonic-gate  *	len - the length of the buffer
47067c478bd9Sstevel@tonic-gate  */
47077c478bd9Sstevel@tonic-gate size_t
47087c478bd9Sstevel@tonic-gate copy_frwd(char *obuf, const size_t obuflen,
47097c478bd9Sstevel@tonic-gate 	const char *buf, const size_t len)
47107c478bd9Sstevel@tonic-gate {
47117c478bd9Sstevel@tonic-gate 	const char *p;
47127c478bd9Sstevel@tonic-gate 	char	*q = obuf;
47137c478bd9Sstevel@tonic-gate 	size_t	olen = 0;
47147c478bd9Sstevel@tonic-gate 	size_t	mb_cur_max;
47157c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
47167c478bd9Sstevel@tonic-gate 
47177c478bd9Sstevel@tonic-gate 	if (Debug) {
47187c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
47197c478bd9Sstevel@tonic-gate 	}
47207c478bd9Sstevel@tonic-gate 
47217c478bd9Sstevel@tonic-gate 	if (len == 0) {
47227c478bd9Sstevel@tonic-gate 		return (0);
47237c478bd9Sstevel@tonic-gate 	}
47247c478bd9Sstevel@tonic-gate 
47257c478bd9Sstevel@tonic-gate 	mb_cur_max = MB_CUR_MAX;
47267c478bd9Sstevel@tonic-gate 
47277c478bd9Sstevel@tonic-gate 	if (mb_cur_max == 1) {
47287c478bd9Sstevel@tonic-gate 		/* single-byte locale */
47297c478bd9Sstevel@tonic-gate 		if (obuflen > len) {
47307c478bd9Sstevel@tonic-gate 			(void) memcpy(obuf, buf, len);
47317c478bd9Sstevel@tonic-gate 			obuf[len] = '\0';
47327c478bd9Sstevel@tonic-gate 			return ((size_t)len);
47337c478bd9Sstevel@tonic-gate 		} else {
47347c478bd9Sstevel@tonic-gate 			(void) memcpy(obuf, buf, obuflen - 1);
47357c478bd9Sstevel@tonic-gate 			obuf[obuflen - 1] = '\0';
47367c478bd9Sstevel@tonic-gate 			return (obuflen - 1);
47377c478bd9Sstevel@tonic-gate 		}
47387c478bd9Sstevel@tonic-gate 	} else {
47397c478bd9Sstevel@tonic-gate 		/* multi-byte locale */
47407c478bd9Sstevel@tonic-gate 		int mlen;
47417c478bd9Sstevel@tonic-gate 
47427c478bd9Sstevel@tonic-gate 		for (p = buf; *p; ) {
47437c478bd9Sstevel@tonic-gate 			mlen = mblen(p, mb_cur_max);
47447c478bd9Sstevel@tonic-gate 			if (mlen == -1) {
47457c478bd9Sstevel@tonic-gate 				/*
47467c478bd9Sstevel@tonic-gate 				 * Invalid character found.
47477c478bd9Sstevel@tonic-gate 				 */
47487c478bd9Sstevel@tonic-gate 				DPRINT1(9, "copy_frwd(%u): Invalid MB "
47497c478bd9Sstevel@tonic-gate 					"sequence\n", mythreadno);
47507c478bd9Sstevel@tonic-gate 				/*
47517c478bd9Sstevel@tonic-gate 				 * handle as a single byte character.
47527c478bd9Sstevel@tonic-gate 				 */
47537c478bd9Sstevel@tonic-gate 				if (obuflen > olen + 1) {
47547c478bd9Sstevel@tonic-gate 					*q++ = *p++;
47557c478bd9Sstevel@tonic-gate 					olen++;
47567c478bd9Sstevel@tonic-gate 				} else {
47577c478bd9Sstevel@tonic-gate 					*q = '\0';
47587c478bd9Sstevel@tonic-gate 					return ((size_t)(p - buf));
47597c478bd9Sstevel@tonic-gate 				}
47607c478bd9Sstevel@tonic-gate 			} else {
47617c478bd9Sstevel@tonic-gate 				if (obuflen > olen + mlen) {
47627c478bd9Sstevel@tonic-gate 					int	n;
47637c478bd9Sstevel@tonic-gate 					for (n = 0; n < mlen; n++) {
47647c478bd9Sstevel@tonic-gate 						*q++ = *p++;
47657c478bd9Sstevel@tonic-gate 					}
47667c478bd9Sstevel@tonic-gate 					olen += mlen;
47677c478bd9Sstevel@tonic-gate 				} else {
47687c478bd9Sstevel@tonic-gate 					*q = '\0';
47697c478bd9Sstevel@tonic-gate 					return ((size_t)(p - buf));
47707c478bd9Sstevel@tonic-gate 				}
47717c478bd9Sstevel@tonic-gate 			}
47727c478bd9Sstevel@tonic-gate 		}
47737c478bd9Sstevel@tonic-gate 		*q = '\0';
47747c478bd9Sstevel@tonic-gate 		return ((size_t)(p - buf));
47757c478bd9Sstevel@tonic-gate 	}
47767c478bd9Sstevel@tonic-gate }
47777c478bd9Sstevel@tonic-gate 
47787c478bd9Sstevel@tonic-gate /*
47797c478bd9Sstevel@tonic-gate  * defaults:
47807c478bd9Sstevel@tonic-gate  *	Read defaults from file.
47817c478bd9Sstevel@tonic-gate  */
47827c478bd9Sstevel@tonic-gate static void
47837c478bd9Sstevel@tonic-gate defaults(void)
47847c478bd9Sstevel@tonic-gate {
47857c478bd9Sstevel@tonic-gate 	int  flags;
47867c478bd9Sstevel@tonic-gate 	char *ptr;
47877c478bd9Sstevel@tonic-gate 
47887c478bd9Sstevel@tonic-gate 	if (defopen(DflFile) == 0) {
47897c478bd9Sstevel@tonic-gate 		/*
47907c478bd9Sstevel@tonic-gate 		 * ignore case
47917c478bd9Sstevel@tonic-gate 		 */
47927c478bd9Sstevel@tonic-gate 		flags = defcntl(DC_GETFLAGS, 0);
47937c478bd9Sstevel@tonic-gate 		TURNOFF(flags, DC_CASE);
47947c478bd9Sstevel@tonic-gate 		defcntl(DC_SETFLAGS, flags);
47957c478bd9Sstevel@tonic-gate 
47967c478bd9Sstevel@tonic-gate 		if ((ptr = defread("LOG_FROM_REMOTE=")) != NULL) {
47977c478bd9Sstevel@tonic-gate 			turnoff = strcasecmp(ptr, "NO") == 0;
47987c478bd9Sstevel@tonic-gate 		}
47997c478bd9Sstevel@tonic-gate 
48007c478bd9Sstevel@tonic-gate 		(void) defopen((char *)NULL);
48017c478bd9Sstevel@tonic-gate 	}
48027c478bd9Sstevel@tonic-gate }
48037c478bd9Sstevel@tonic-gate 
48047c478bd9Sstevel@tonic-gate /*
48057c478bd9Sstevel@tonic-gate  * close all the input devices.
48067c478bd9Sstevel@tonic-gate  */
48077c478bd9Sstevel@tonic-gate static void
48087c478bd9Sstevel@tonic-gate shutdown_input(void)
48097c478bd9Sstevel@tonic-gate {
48107c478bd9Sstevel@tonic-gate 	int cnt;
48117c478bd9Sstevel@tonic-gate 
48127c478bd9Sstevel@tonic-gate 	shutting_down = 1;
48137c478bd9Sstevel@tonic-gate 
48147c478bd9Sstevel@tonic-gate 	for (cnt = 0; cnt < Ninputs; cnt++) {
48157c478bd9Sstevel@tonic-gate 		(void) t_close(Nfd[cnt].fd);
48167c478bd9Sstevel@tonic-gate 	}
48177c478bd9Sstevel@tonic-gate 
48187c478bd9Sstevel@tonic-gate 	(void) close(Pfd.fd);
48197c478bd9Sstevel@tonic-gate }
48207c478bd9Sstevel@tonic-gate 
48217c478bd9Sstevel@tonic-gate /*
48227c478bd9Sstevel@tonic-gate  * This is for the one thread that dedicates to resolve the
48237c478bd9Sstevel@tonic-gate  * hostname. This will get the messages from net_poll() through
48247c478bd9Sstevel@tonic-gate  * hnlq, and resolve the hostname, and push the messages back
48257c478bd9Sstevel@tonic-gate  * into the inputq.
48267c478bd9Sstevel@tonic-gate  */
48277c478bd9Sstevel@tonic-gate /*ARGSUSED*/
48287c478bd9Sstevel@tonic-gate static void *
48297c478bd9Sstevel@tonic-gate hostname_lookup(void *ap)
48307c478bd9Sstevel@tonic-gate {
48317c478bd9Sstevel@tonic-gate 	char *uap;
48327c478bd9Sstevel@tonic-gate 	log_message_t *mp;
48337c478bd9Sstevel@tonic-gate 	host_info_t *hip;
48347c478bd9Sstevel@tonic-gate 	char failsafe_addr[SYS_NMLN + 1];
48357c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
48367c478bd9Sstevel@tonic-gate 
48377c478bd9Sstevel@tonic-gate 	if (Debug) {
48387c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
48397c478bd9Sstevel@tonic-gate 	}
48407c478bd9Sstevel@tonic-gate 
48417c478bd9Sstevel@tonic-gate 	DPRINT1(1, "hostname_lookup(%u): hostname_lookup started\n",
48427c478bd9Sstevel@tonic-gate 		mythreadno);
48437c478bd9Sstevel@tonic-gate 
48447c478bd9Sstevel@tonic-gate 	for (;;) {
48457c478bd9Sstevel@tonic-gate 		(void) dataq_dequeue(&hnlq, (void **)&mp, 0);
48467c478bd9Sstevel@tonic-gate 
48477c478bd9Sstevel@tonic-gate 		DPRINT3(5, "hostname_lookup(%u): dequeued msg %p"
48487c478bd9Sstevel@tonic-gate 				" from queue %p\n", mythreadno, mp, &hnlq);
48497c478bd9Sstevel@tonic-gate 
48507c478bd9Sstevel@tonic-gate 		hip = (host_info_t *)mp->ptr;
48517c478bd9Sstevel@tonic-gate 		if ((uap = taddr2uaddr(hip->ncp, &hip->addr)) != NULL) {
48527c478bd9Sstevel@tonic-gate 			(void) strlcpy(failsafe_addr, uap, SYS_NMLN);
48537c478bd9Sstevel@tonic-gate 			free(uap);
48547c478bd9Sstevel@tonic-gate 		} else {
48557c478bd9Sstevel@tonic-gate 			(void) strlcpy(failsafe_addr, "<unknown>", SYS_NMLN);
48567c478bd9Sstevel@tonic-gate 		}
48577c478bd9Sstevel@tonic-gate 
48587c478bd9Sstevel@tonic-gate 		mp->hlp = cvthname(&hip->addr, hip->ncp, failsafe_addr);
48597c478bd9Sstevel@tonic-gate 
48607c478bd9Sstevel@tonic-gate 		if (mp->hlp == NULL) {
48617c478bd9Sstevel@tonic-gate 			mp->hlp = &NullHostName;
48627c478bd9Sstevel@tonic-gate 		}
48637c478bd9Sstevel@tonic-gate 
48647c478bd9Sstevel@tonic-gate 		free(hip->addr.buf);
48657c478bd9Sstevel@tonic-gate 		free(hip);
48667c478bd9Sstevel@tonic-gate 		mp->ptr = NULL;
48677c478bd9Sstevel@tonic-gate 
48687c478bd9Sstevel@tonic-gate 		if (dataq_enqueue(&inputq, (void *)mp) == -1) {
48697c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("dropping message from remote");
48707c478bd9Sstevel@tonic-gate 			free_msg(mp);
48717c478bd9Sstevel@tonic-gate 			continue;
48727c478bd9Sstevel@tonic-gate 		}
48737c478bd9Sstevel@tonic-gate 
48747c478bd9Sstevel@tonic-gate 		DPRINT3(5, "hostname_lookup(%u): enqueued msg %p on queue %p\n",
48757c478bd9Sstevel@tonic-gate 			mythreadno, mp, &inputq);
48767c478bd9Sstevel@tonic-gate 	}
48777c478bd9Sstevel@tonic-gate 
48787c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
48797c478bd9Sstevel@tonic-gate 	return (NULL);
48807c478bd9Sstevel@tonic-gate }
48817c478bd9Sstevel@tonic-gate 
48827c478bd9Sstevel@tonic-gate /*
48837c478bd9Sstevel@tonic-gate  * Does all HUP(re-configuration) process.
48847c478bd9Sstevel@tonic-gate  */
48857c478bd9Sstevel@tonic-gate static void
48867c478bd9Sstevel@tonic-gate reconfigure()
48877c478bd9Sstevel@tonic-gate {
48887c478bd9Sstevel@tonic-gate 	int cnt, loop, drops;
48897c478bd9Sstevel@tonic-gate 	int really_stuck;
48907c478bd9Sstevel@tonic-gate 	int console_stuck = 0;
48917c478bd9Sstevel@tonic-gate 	struct filed *f;
48927c478bd9Sstevel@tonic-gate 	char buf[LINE_MAX];
48937c478bd9Sstevel@tonic-gate 	struct utsname up;
48947c478bd9Sstevel@tonic-gate 	char cbuf[30];
48957c478bd9Sstevel@tonic-gate 	time_t tim;
48967c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
48977c478bd9Sstevel@tonic-gate 
48987c478bd9Sstevel@tonic-gate 	if (Debug) {
48997c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
49007c478bd9Sstevel@tonic-gate 	}
49017c478bd9Sstevel@tonic-gate 
49027c478bd9Sstevel@tonic-gate 	/* If we get here then we must need to regen */
49037c478bd9Sstevel@tonic-gate 	flushmsg(0);
49047c478bd9Sstevel@tonic-gate 
49057c478bd9Sstevel@tonic-gate 	if (logmymsg(LOG_SYSLOG|LOG_INFO, "syslogd: configuration restart",
49067c478bd9Sstevel@tonic-gate 		ADDDATE, 0) == -1) {
49077c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("dropping message");
49087c478bd9Sstevel@tonic-gate 	}
49097c478bd9Sstevel@tonic-gate 
49107c478bd9Sstevel@tonic-gate 	/*
49117c478bd9Sstevel@tonic-gate 	 * make sure the logmsg thread is not in the waiting state.
49127c478bd9Sstevel@tonic-gate 	 * Otherwise, changing hup_state will prevent the logmsg thread
49137c478bd9Sstevel@tonic-gate 	 * getting out from the waiting loop.
49147c478bd9Sstevel@tonic-gate 	 */
49157c478bd9Sstevel@tonic-gate 
49167c478bd9Sstevel@tonic-gate 	if (Debug) {
49177c478bd9Sstevel@tonic-gate 		tim = time(NULL);
49187c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s: awaiting logmsg()"
49197c478bd9Sstevel@tonic-gate 			" moving to the safe place\n",
49207c478bd9Sstevel@tonic-gate 			mythreadno, ctime_r(&tim, cbuf)+4);
49217c478bd9Sstevel@tonic-gate 	}
49227c478bd9Sstevel@tonic-gate 
49237c478bd9Sstevel@tonic-gate 	for (loop = 0; loop < LOOP_MAX; loop++) {
49247c478bd9Sstevel@tonic-gate 		/* we don't need the mutex to read */
49257c478bd9Sstevel@tonic-gate 		if (hup_state == HUP_ACCEPTABLE)
49267c478bd9Sstevel@tonic-gate 			break;
49277c478bd9Sstevel@tonic-gate 		(void) sleep(1);
49287c478bd9Sstevel@tonic-gate 	}
49297c478bd9Sstevel@tonic-gate 	if (hup_state != HUP_ACCEPTABLE) {
49307c478bd9Sstevel@tonic-gate 		goto thread_stuck;
49317c478bd9Sstevel@tonic-gate 	}
49327c478bd9Sstevel@tonic-gate 
49337c478bd9Sstevel@tonic-gate 	if (Debug) {
49347c478bd9Sstevel@tonic-gate 		tim = time(NULL);
49357c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s: logmsg() will accept HUP\n",
49367c478bd9Sstevel@tonic-gate 			mythreadno, ctime_r(&tim, cbuf)+4);
49377c478bd9Sstevel@tonic-gate 	}
49387c478bd9Sstevel@tonic-gate 
49397c478bd9Sstevel@tonic-gate 	/*
49407c478bd9Sstevel@tonic-gate 	 * Prevent logging until we are truly done processing the HUP
49417c478bd9Sstevel@tonic-gate 	 */
49427c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&hup_lock);
49437c478bd9Sstevel@tonic-gate 	hup_state = HUP_INPROGRESS;
49447c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&hup_lock);
49457c478bd9Sstevel@tonic-gate 
49467c478bd9Sstevel@tonic-gate 	/*
49477c478bd9Sstevel@tonic-gate 	 * We will be going into a critical state. Any error message
49487c478bd9Sstevel@tonic-gate 	 * from syslogd needs to be dumped to the console by default
49497c478bd9Sstevel@tonic-gate 	 * immediately. Also, those error messages are quened in a temporary
49507c478bd9Sstevel@tonic-gate 	 * queue to be able to post into the regular stream later.
49517c478bd9Sstevel@tonic-gate 	 */
49527c478bd9Sstevel@tonic-gate 	disable_errorlog();
49537c478bd9Sstevel@tonic-gate 
49547c478bd9Sstevel@tonic-gate 	if (Debug) {
49557c478bd9Sstevel@tonic-gate 		tim = time(NULL);
49567c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s: sending SHUTDOWN\n",
49577c478bd9Sstevel@tonic-gate 			mythreadno, ctime_r(&tim, cbuf)+4);
49587c478bd9Sstevel@tonic-gate 	}
49597c478bd9Sstevel@tonic-gate 
49607c478bd9Sstevel@tonic-gate 	/* stop configured threads */
49617c478bd9Sstevel@tonic-gate 	if (shutdown_msg() == -1) {
49627c478bd9Sstevel@tonic-gate 		/*
49637c478bd9Sstevel@tonic-gate 		 * No memory, message will be dumped to the console.
49647c478bd9Sstevel@tonic-gate 		 */
49657c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("unable to restart syslogd");
49667c478bd9Sstevel@tonic-gate 		goto out;
49677c478bd9Sstevel@tonic-gate 	}
49687c478bd9Sstevel@tonic-gate 
49697c478bd9Sstevel@tonic-gate 	/* make sure logmsg() is in suspended state */
49707c478bd9Sstevel@tonic-gate 	for (loop = 0; loop < LOOP_INTERVAL; loop++) {
49717c478bd9Sstevel@tonic-gate 		if (hup_state & HUP_LOGMSG_SUSPENDED)
49727c478bd9Sstevel@tonic-gate 			break;
49737c478bd9Sstevel@tonic-gate 		(void) sleep(1);
49747c478bd9Sstevel@tonic-gate 	}
49757c478bd9Sstevel@tonic-gate 
49767c478bd9Sstevel@tonic-gate 	if ((hup_state & HUP_LOGMSG_SUSPENDED) == 0) {
49777c478bd9Sstevel@tonic-gate 		if (Debug) {
49787c478bd9Sstevel@tonic-gate 			tim = time(NULL);
49797c478bd9Sstevel@tonic-gate 			DPRINT2(3, "reconfigure(%u): %.15s: logmsg() does not "
49807c478bd9Sstevel@tonic-gate 				"stop. enforcing\n",
49817c478bd9Sstevel@tonic-gate 				mythreadno, ctime_r(&tim, cbuf)+4);
49827c478bd9Sstevel@tonic-gate 		}
49837c478bd9Sstevel@tonic-gate 
49847c478bd9Sstevel@tonic-gate 		/* probably we have too long input queue, or really stuck */
49857c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_lock(&hup_lock);
49867c478bd9Sstevel@tonic-gate 		hup_state |= HUP_SUSP_LOGMSG_REQD;
49877c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&hup_lock);
49887c478bd9Sstevel@tonic-gate 
49897c478bd9Sstevel@tonic-gate 		for (loop = 0; loop < LOOP_MAX; loop++) {
49907c478bd9Sstevel@tonic-gate 			if (hup_state & HUP_LOGMSG_SUSPENDED)
49917c478bd9Sstevel@tonic-gate 				break;
49927c478bd9Sstevel@tonic-gate 			(void) sleep(1);
49937c478bd9Sstevel@tonic-gate 		}
49947c478bd9Sstevel@tonic-gate 		if ((hup_state & HUP_LOGMSG_SUSPENDED) == 0) {
49957c478bd9Sstevel@tonic-gate 			if (Debug) {
49967c478bd9Sstevel@tonic-gate 				tim = time(NULL);
49977c478bd9Sstevel@tonic-gate 				DPRINT2(3, "reconfigure(%u): %.15s: logmsg()"
49987c478bd9Sstevel@tonic-gate 					" does not stop. give up\n",
49997c478bd9Sstevel@tonic-gate 					mythreadno, ctime_r(&tim, cbuf)+4);
50007c478bd9Sstevel@tonic-gate 			}
50017c478bd9Sstevel@tonic-gate 			logerror("could not suspend logmsg - fatal");
50027c478bd9Sstevel@tonic-gate 			goto thread_stuck;
50037c478bd9Sstevel@tonic-gate 		}
50047c478bd9Sstevel@tonic-gate 	}
50057c478bd9Sstevel@tonic-gate 
50067c478bd9Sstevel@tonic-gate 	if (Debug) {
50077c478bd9Sstevel@tonic-gate 		tim = time(NULL);
50087c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s: logmsg() suspended\n",
50097c478bd9Sstevel@tonic-gate 			mythreadno, ctime_r(&tim, cbuf)+4);
50107c478bd9Sstevel@tonic-gate 	}
50117c478bd9Sstevel@tonic-gate 
50127c478bd9Sstevel@tonic-gate 	/*
50137c478bd9Sstevel@tonic-gate 	 * Will wait for LOOP_MAX secs with watching queue lengths for the
50147c478bd9Sstevel@tonic-gate 	 * each logger threads. If they have backlogs, and no change in the
50157c478bd9Sstevel@tonic-gate 	 * length of queue found in 30 seconds, those will be counted as
50167c478bd9Sstevel@tonic-gate 	 * "really stuck".
50177c478bd9Sstevel@tonic-gate 	 * If all running logger threads become "really stuck" state, there
50187c478bd9Sstevel@tonic-gate 	 * should be no worth waiting for them to quit.
50197c478bd9Sstevel@tonic-gate 	 * In that case, we will go ahead and close out file descriptors to
50207c478bd9Sstevel@tonic-gate 	 * have them pull out from hanging system call, and give them a last
50217c478bd9Sstevel@tonic-gate 	 * chance(LOOP_INTERVAL sec) to quit.
50227c478bd9Sstevel@tonic-gate 	 */
50237c478bd9Sstevel@tonic-gate 
50247c478bd9Sstevel@tonic-gate 	if (Debug) {
50257c478bd9Sstevel@tonic-gate 		tim = time(NULL);
50267c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s: awaiting logit() to be"
50277c478bd9Sstevel@tonic-gate 			" shutdown\n", mythreadno, ctime_r(&tim, cbuf)+4);
50287c478bd9Sstevel@tonic-gate 	}
50297c478bd9Sstevel@tonic-gate 
50307c478bd9Sstevel@tonic-gate 	cnt = 0;
50317c478bd9Sstevel@tonic-gate 	really_stuck = 0;
50327c478bd9Sstevel@tonic-gate 	while (cnt < (LOOP_MAX/LOOP_INTERVAL) &&
50337c478bd9Sstevel@tonic-gate 		conf_threads > really_stuck) {
50347c478bd9Sstevel@tonic-gate 
50357c478bd9Sstevel@tonic-gate 		/* save initial queue count */
50367c478bd9Sstevel@tonic-gate 		for (f = Files; f < &Files[nlogs]; f++) {
50377c478bd9Sstevel@tonic-gate 			f->f_prev_queue_count = (f->f_type == F_UNUSED) ?
50387c478bd9Sstevel@tonic-gate 				-1 : f->f_queue_count;
50397c478bd9Sstevel@tonic-gate 		}
50407c478bd9Sstevel@tonic-gate 
50417c478bd9Sstevel@tonic-gate 		for (loop = 0; loop < LOOP_INTERVAL; loop++) {
50427c478bd9Sstevel@tonic-gate 			if (conf_threads == 0)
50437c478bd9Sstevel@tonic-gate 				break;
50447c478bd9Sstevel@tonic-gate 			(void) sleep(1);
50457c478bd9Sstevel@tonic-gate 		}
50467c478bd9Sstevel@tonic-gate 
50477c478bd9Sstevel@tonic-gate 		if (conf_threads == 0)
50487c478bd9Sstevel@tonic-gate 			break;
50497c478bd9Sstevel@tonic-gate 
50507c478bd9Sstevel@tonic-gate 		if (Debug) {
50517c478bd9Sstevel@tonic-gate 			tim = time(NULL);
50527c478bd9Sstevel@tonic-gate 			DPRINT3(3, "reconfigure(%u): %.15s: "
50537c478bd9Sstevel@tonic-gate 				"%d threads are still alive.\n",
50547c478bd9Sstevel@tonic-gate 				mythreadno, ctime_r(&tim, cbuf)+4,
50557c478bd9Sstevel@tonic-gate 				conf_threads);
50567c478bd9Sstevel@tonic-gate 		}
50577c478bd9Sstevel@tonic-gate 
50587c478bd9Sstevel@tonic-gate 		really_stuck = 0;
50597c478bd9Sstevel@tonic-gate 		for (f = Files; f < &Files[nlogs]; f++) {
50607c478bd9Sstevel@tonic-gate 			if (f->f_type == F_UNUSED) {
50617c478bd9Sstevel@tonic-gate 				f->f_prev_queue_count = -1;
50627c478bd9Sstevel@tonic-gate 				continue;
50637c478bd9Sstevel@tonic-gate 			}
50647c478bd9Sstevel@tonic-gate 			if (f->f_prev_queue_count == f->f_queue_count) {
50657c478bd9Sstevel@tonic-gate 				really_stuck++;
50667c478bd9Sstevel@tonic-gate 				f->f_prev_queue_count = 1;
50677c478bd9Sstevel@tonic-gate 				DPRINT2(3, "reconfigure(%u): "
50687c478bd9Sstevel@tonic-gate 					"tid=%d is really stuck.\n",
50697c478bd9Sstevel@tonic-gate 					mythreadno, f->f_thread);
50707c478bd9Sstevel@tonic-gate 			} else {
50717c478bd9Sstevel@tonic-gate 				f->f_prev_queue_count = 0;
50727c478bd9Sstevel@tonic-gate 				DPRINT2(3, "reconfigure(%u): "
50737c478bd9Sstevel@tonic-gate 					"tid=%d is still active.\n",
50747c478bd9Sstevel@tonic-gate 					mythreadno, f->f_thread);
50757c478bd9Sstevel@tonic-gate 			}
50767c478bd9Sstevel@tonic-gate 		}
50777c478bd9Sstevel@tonic-gate 		/*
50787c478bd9Sstevel@tonic-gate 		 * Here we have one of following values in the
50797c478bd9Sstevel@tonic-gate 		 * f_prev_queue_count:
50807c478bd9Sstevel@tonic-gate 		 *  0: logger thread is still actively working.
50817c478bd9Sstevel@tonic-gate 		 *  1: logger thread is really stuck.
50827c478bd9Sstevel@tonic-gate 		 * -1: logger thread has already died.
50837c478bd9Sstevel@tonic-gate 		 */
50847c478bd9Sstevel@tonic-gate 
50857c478bd9Sstevel@tonic-gate 		cnt++;
50867c478bd9Sstevel@tonic-gate 	}
50877c478bd9Sstevel@tonic-gate 
50887c478bd9Sstevel@tonic-gate 	if (Debug) {
50897c478bd9Sstevel@tonic-gate 		tim = time(NULL);
50907c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s:"
50917c478bd9Sstevel@tonic-gate 			" complete awaiting logit()\n",
50927c478bd9Sstevel@tonic-gate 			mythreadno, ctime_r(&tim, cbuf)+4);
50937c478bd9Sstevel@tonic-gate 		DPRINT3(3, "reconfigure(%u): %d threads alive."
50947c478bd9Sstevel@tonic-gate 			" %d threads stuck\n",
50957c478bd9Sstevel@tonic-gate 			mythreadno, conf_threads, really_stuck);
50967c478bd9Sstevel@tonic-gate 	}
50977c478bd9Sstevel@tonic-gate 
50987c478bd9Sstevel@tonic-gate 	/*
50997c478bd9Sstevel@tonic-gate 	 * Still running? If so, mark it as UNUSED, and close
51007c478bd9Sstevel@tonic-gate 	 * the fd so that logger threads can bail out from the loop.
51017c478bd9Sstevel@tonic-gate 	 */
51027c478bd9Sstevel@tonic-gate 	drops = 0;
51037c478bd9Sstevel@tonic-gate 	if (conf_threads) {
51047c478bd9Sstevel@tonic-gate 		for (f = Files; f < &Files[nlogs]; f++) {
51057c478bd9Sstevel@tonic-gate 			if (f->f_type == F_CONSOLE &&
51067c478bd9Sstevel@tonic-gate 				f->f_prev_queue_count == 1) {
51077c478bd9Sstevel@tonic-gate 				/* console is really stuck */
51087c478bd9Sstevel@tonic-gate 				console_stuck = 1;
51097c478bd9Sstevel@tonic-gate 			}
51107c478bd9Sstevel@tonic-gate 			if (f->f_type == F_USERS || f->f_type == F_WALL ||
51117c478bd9Sstevel@tonic-gate 				f->f_type == F_UNUSED)
51127c478bd9Sstevel@tonic-gate 				continue;
51137c478bd9Sstevel@tonic-gate 			cnt = f->f_queue_count;
51147c478bd9Sstevel@tonic-gate 			drops += (cnt > 0) ? cnt - 1: 0;
51157c478bd9Sstevel@tonic-gate 			f->f_type = F_UNUSED;
51167c478bd9Sstevel@tonic-gate 
51177c478bd9Sstevel@tonic-gate 			if (f->f_orig_type == F_FORW)
51187c478bd9Sstevel@tonic-gate 				t_close(f->f_file);
51197c478bd9Sstevel@tonic-gate 			else
51207c478bd9Sstevel@tonic-gate 				close(f->f_file);
51217c478bd9Sstevel@tonic-gate 		}
51227c478bd9Sstevel@tonic-gate 
51237c478bd9Sstevel@tonic-gate 		if (Debug) {
51247c478bd9Sstevel@tonic-gate 			tim = time(NULL);
51257c478bd9Sstevel@tonic-gate 			DPRINT1(3, "reconfigure(%u): terminating logit()\n",
51267c478bd9Sstevel@tonic-gate 				mythreadno);
51277c478bd9Sstevel@tonic-gate 		}
51287c478bd9Sstevel@tonic-gate 
51297c478bd9Sstevel@tonic-gate 		/* last chance to exit */
51307c478bd9Sstevel@tonic-gate 		for (loop = 0; loop < LOOP_MAX; loop++) {
51317c478bd9Sstevel@tonic-gate 			if (conf_threads == 0)
51327c478bd9Sstevel@tonic-gate 				break;
51337c478bd9Sstevel@tonic-gate 			(void) sleep(1);
51347c478bd9Sstevel@tonic-gate 		}
51357c478bd9Sstevel@tonic-gate 
51367c478bd9Sstevel@tonic-gate 		if (Debug) {
51377c478bd9Sstevel@tonic-gate 			tim = time(NULL);
51387c478bd9Sstevel@tonic-gate 			DPRINT3(3, "reconfigure(%u): %.15s: %d alive\n",
51397c478bd9Sstevel@tonic-gate 				mythreadno, ctime_r(&tim, cbuf)+4,
51407c478bd9Sstevel@tonic-gate 				conf_threads);
51417c478bd9Sstevel@tonic-gate 		}
51427c478bd9Sstevel@tonic-gate 	}
51437c478bd9Sstevel@tonic-gate 
51447c478bd9Sstevel@tonic-gate 	if (conf_threads == 0 && drops) {
51457c478bd9Sstevel@tonic-gate 		errno = 0;
51467c478bd9Sstevel@tonic-gate 		logerror("Could not completely output pending messages"
51477c478bd9Sstevel@tonic-gate 			" while preparing re-configuration");
51487c478bd9Sstevel@tonic-gate 		logerror("discarded %d messages and restart configuration.",
51497c478bd9Sstevel@tonic-gate 			drops);
51507c478bd9Sstevel@tonic-gate 		if (Debug) {
51517c478bd9Sstevel@tonic-gate 			tim = time(NULL);
51527c478bd9Sstevel@tonic-gate 			DPRINT3(3, "reconfigure(%u): %.15s: "
51537c478bd9Sstevel@tonic-gate 				"discarded %d messages\n",
51547c478bd9Sstevel@tonic-gate 				mythreadno, ctime_r(&tim, cbuf)+4, drops);
51557c478bd9Sstevel@tonic-gate 		}
51567c478bd9Sstevel@tonic-gate 	}
51577c478bd9Sstevel@tonic-gate 
51587c478bd9Sstevel@tonic-gate 	/*
51597c478bd9Sstevel@tonic-gate 	 * If all threads still haven't exited
51607c478bd9Sstevel@tonic-gate 	 * something is stuck or hosed. We just
51617c478bd9Sstevel@tonic-gate 	 * have no option but to exit.
51627c478bd9Sstevel@tonic-gate 	 */
51637c478bd9Sstevel@tonic-gate 	if (conf_threads) {
51647c478bd9Sstevel@tonic-gate thread_stuck:
51657c478bd9Sstevel@tonic-gate 		if (Debug) {
51667c478bd9Sstevel@tonic-gate 			tim = time(NULL);
51677c478bd9Sstevel@tonic-gate 			DPRINT2(3, "reconfigure(%u): %.15s: really stuck\n",
51687c478bd9Sstevel@tonic-gate 				mythreadno, ctime_r(&tim, cbuf)+4);
51697c478bd9Sstevel@tonic-gate 		}
51707c478bd9Sstevel@tonic-gate 
51717c478bd9Sstevel@tonic-gate 		shutdown_input();
51727c478bd9Sstevel@tonic-gate 		delete_doorfiles();
51737c478bd9Sstevel@tonic-gate 		uname(&up);
51747c478bd9Sstevel@tonic-gate 
51757c478bd9Sstevel@tonic-gate 		(void) sprintf(buf,
51767c478bd9Sstevel@tonic-gate 			"syslogd(%s): some logger thread(s) "
51777c478bd9Sstevel@tonic-gate 			"are stuck%s; syslogd is shutting down.",
51787c478bd9Sstevel@tonic-gate 			up.nodename,
51797c478bd9Sstevel@tonic-gate 			console_stuck ? " (including the console)" : "");
51807c478bd9Sstevel@tonic-gate 
51817c478bd9Sstevel@tonic-gate 		if (console_stuck) {
51827c478bd9Sstevel@tonic-gate 			FILE *m = popen(MAILCMD, "w");
51837c478bd9Sstevel@tonic-gate 
51847c478bd9Sstevel@tonic-gate 			if (m != NULL) {
51857c478bd9Sstevel@tonic-gate 				fprintf(m, "%s\n", buf);
51867c478bd9Sstevel@tonic-gate 				pclose(m);
51877c478bd9Sstevel@tonic-gate 			}
51887c478bd9Sstevel@tonic-gate 		}
51897c478bd9Sstevel@tonic-gate 
51907c478bd9Sstevel@tonic-gate 		disable_errorlog();
51917c478bd9Sstevel@tonic-gate 		logerror(buf);
51927c478bd9Sstevel@tonic-gate 		exit(1);
51937c478bd9Sstevel@tonic-gate 	}
51947c478bd9Sstevel@tonic-gate 
51957c478bd9Sstevel@tonic-gate 	/* Free up some resources */
51967c478bd9Sstevel@tonic-gate 	if (Files != (struct filed *)&fallback) {
51977c478bd9Sstevel@tonic-gate 		for (f = Files; f < &Files[nlogs]; f++) {
51987c478bd9Sstevel@tonic-gate 			(void) pthread_join(f->f_thread, NULL);
51997c478bd9Sstevel@tonic-gate 			filed_destroy(f);
52007c478bd9Sstevel@tonic-gate 		}
52017c478bd9Sstevel@tonic-gate 		free(Files);
52027c478bd9Sstevel@tonic-gate 	}
52037c478bd9Sstevel@tonic-gate 
52047c478bd9Sstevel@tonic-gate 	dealloc_stacks(nlogs);
52057c478bd9Sstevel@tonic-gate 
52067c478bd9Sstevel@tonic-gate 	if (Debug) {
52077c478bd9Sstevel@tonic-gate 		tim = time(NULL);
52087c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s: cleanup complete\n",
52097c478bd9Sstevel@tonic-gate 			mythreadno, ctime_r(&tim, cbuf)+4);
52107c478bd9Sstevel@tonic-gate 	}
52117c478bd9Sstevel@tonic-gate 
52127c478bd9Sstevel@tonic-gate 	hnc_init(1);	/* purge hostname cache */
52137c478bd9Sstevel@tonic-gate 	conf_init();	/* start reconfigure */
52147c478bd9Sstevel@tonic-gate 
52157c478bd9Sstevel@tonic-gate out:;
52167c478bd9Sstevel@tonic-gate 	/* Now should be ready to dispatch error messages from syslogd. */
52177c478bd9Sstevel@tonic-gate 	enable_errorlog();
52187c478bd9Sstevel@tonic-gate 
52197c478bd9Sstevel@tonic-gate 	/* Wake up the log thread */
52207c478bd9Sstevel@tonic-gate 
52217c478bd9Sstevel@tonic-gate 	if (Debug) {
52227c478bd9Sstevel@tonic-gate 		tim = time(NULL);
52237c478bd9Sstevel@tonic-gate 		DPRINT2(3, "reconfigure(%u): %.15s: resuming logmsg()\n",
52247c478bd9Sstevel@tonic-gate 			mythreadno, ctime_r(&tim, cbuf)+4);
52257c478bd9Sstevel@tonic-gate 	}
52267c478bd9Sstevel@tonic-gate 
52277c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&hup_lock);
52287c478bd9Sstevel@tonic-gate 	hup_state = HUP_COMPLETED;
52297c478bd9Sstevel@tonic-gate 	(void) pthread_cond_signal(&hup_done);
52307c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&hup_lock);
52317c478bd9Sstevel@tonic-gate }
52327c478bd9Sstevel@tonic-gate 
52337c478bd9Sstevel@tonic-gate /*
52347c478bd9Sstevel@tonic-gate  * The following function implements simple hostname cache mechanism.
5235293d1fc4Spd155743  * Host name cache is implemented through hash table bucket chaining method.
5236293d1fc4Spd155743  * Collisions are handled by bucket chaining.
52377c478bd9Sstevel@tonic-gate  *
52387c478bd9Sstevel@tonic-gate  * hnc_init():
52397c478bd9Sstevel@tonic-gate  * 	allocate and initialize the cache. If reinit is set,
52407c478bd9Sstevel@tonic-gate  *	invalidate all cache entries.
52417c478bd9Sstevel@tonic-gate  * hnc_look():
5242293d1fc4Spd155743  *	It hashes the ipaddress gets the index and walks thru the
5243293d1fc4Spd155743  *	single linked list. if cached entry was found, it will
52447c478bd9Sstevel@tonic-gate  *	put in the head of the list, and return.While going through
52457c478bd9Sstevel@tonic-gate  *	the entries, an entry which has already expired will be invalidated.
52467c478bd9Sstevel@tonic-gate  * hnc_register():
5247293d1fc4Spd155743  *	Hashes the ipaddress finds the index and puts current entry to the list.
52487c478bd9Sstevel@tonic-gate  * hnc_unreg():
5249293d1fc4Spd155743  *	invalidate the cachep.
52507c478bd9Sstevel@tonic-gate  */
52517c478bd9Sstevel@tonic-gate 
52527c478bd9Sstevel@tonic-gate static void
52537c478bd9Sstevel@tonic-gate hnc_init(int reinit)
52547c478bd9Sstevel@tonic-gate {
52557c478bd9Sstevel@tonic-gate 	struct hostname_cache **hpp;
52567c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
5257293d1fc4Spd155743 	int i;
52587c478bd9Sstevel@tonic-gate 
52597c478bd9Sstevel@tonic-gate 	if (Debug) {
52607c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
52617c478bd9Sstevel@tonic-gate 	}
52627c478bd9Sstevel@tonic-gate 
52637c478bd9Sstevel@tonic-gate 	if (reinit) {
52647c478bd9Sstevel@tonic-gate 		pthread_mutex_lock(&hnc_mutex);
52657c478bd9Sstevel@tonic-gate 
5266293d1fc4Spd155743 		for (i = 0; i < hnc_size; i++) {
5267293d1fc4Spd155743 			for (hpp = &hnc_cache[i]; *hpp != NULL; ) {
52687c478bd9Sstevel@tonic-gate 				hnc_unreg(hpp);
52697c478bd9Sstevel@tonic-gate 			}
5270293d1fc4Spd155743 		}
52717c478bd9Sstevel@tonic-gate 
52727c478bd9Sstevel@tonic-gate 		pthread_mutex_unlock(&hnc_mutex);
52737c478bd9Sstevel@tonic-gate 		DPRINT1(2, "hnc_init(%u): hostname cache re-configured\n",
52747c478bd9Sstevel@tonic-gate 			mythreadno);
52757c478bd9Sstevel@tonic-gate 	} else {
52767c478bd9Sstevel@tonic-gate 
5277293d1fc4Spd155743 		hnc_cache = calloc(hnc_size, sizeof (struct hostname_cache *));
52787c478bd9Sstevel@tonic-gate 
52797c478bd9Sstevel@tonic-gate 		if (hnc_cache == NULL) {
52807c478bd9Sstevel@tonic-gate 			MALLOC_FAIL("hostname cache");
52817c478bd9Sstevel@tonic-gate 			logerror("hostname cache disabled");
52827c478bd9Sstevel@tonic-gate 			return;
52837c478bd9Sstevel@tonic-gate 		}
52847c478bd9Sstevel@tonic-gate 
52857c478bd9Sstevel@tonic-gate 		DPRINT3(1, "hnc_init(%u): hostname cache configured %d entry"
52867c478bd9Sstevel@tonic-gate 			" ttl:%d\n", mythreadno, hnc_size, hnc_ttl);
52877c478bd9Sstevel@tonic-gate 	}
52887c478bd9Sstevel@tonic-gate }
52897c478bd9Sstevel@tonic-gate 
52907c478bd9Sstevel@tonic-gate static host_list_t *
5291293d1fc4Spd155743 hnc_lookup(struct netbuf *nbp, struct netconfig *ncp, int *hindex)
52927c478bd9Sstevel@tonic-gate {
52937c478bd9Sstevel@tonic-gate 	struct hostname_cache **hpp, *hp;
52947c478bd9Sstevel@tonic-gate 	time_t now;
52957c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
5296293d1fc4Spd155743 	int index;
52977c478bd9Sstevel@tonic-gate 
52987c478bd9Sstevel@tonic-gate 	if (Debug) {
52997c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
53007c478bd9Sstevel@tonic-gate 	}
53017c478bd9Sstevel@tonic-gate 
53027c478bd9Sstevel@tonic-gate 	if (hnc_cache == NULL) {
53037c478bd9Sstevel@tonic-gate 		return (NULL);
53047c478bd9Sstevel@tonic-gate 	}
53057c478bd9Sstevel@tonic-gate 
53067c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&hnc_mutex);
53077c478bd9Sstevel@tonic-gate 	now = time(0);
53087c478bd9Sstevel@tonic-gate 
5309293d1fc4Spd155743 	*hindex = index = addr_hash(nbp);
5310293d1fc4Spd155743 
5311293d1fc4Spd155743 	for (hpp = &hnc_cache[index]; (hp = *hpp) != NULL; ) {
53127c478bd9Sstevel@tonic-gate 		DPRINT4(10, "hnc_lookup(%u): check %p on %p for %s\n",
53137c478bd9Sstevel@tonic-gate 			mythreadno, hp->h, hp, hp->h->hl_hosts[0]);
53147c478bd9Sstevel@tonic-gate 
53157c478bd9Sstevel@tonic-gate 		if (hp->expire < now) {
53167c478bd9Sstevel@tonic-gate 			DPRINT2(9, "hnc_lookup(%u): purge %p\n",
53177c478bd9Sstevel@tonic-gate 				mythreadno, hp);
53187c478bd9Sstevel@tonic-gate 			hnc_unreg(hpp);
53197c478bd9Sstevel@tonic-gate 			continue;
53207c478bd9Sstevel@tonic-gate 		}
53217c478bd9Sstevel@tonic-gate 
53227c478bd9Sstevel@tonic-gate 		if (ncp == hp->ncp && same_addr(&hp->addr, nbp)) {
53237c478bd9Sstevel@tonic-gate 			/*
53247c478bd9Sstevel@tonic-gate 			 * found!
53257c478bd9Sstevel@tonic-gate 			 * Put the entry at the top.
53267c478bd9Sstevel@tonic-gate 			 */
53277c478bd9Sstevel@tonic-gate 
5328293d1fc4Spd155743 			if (hp != hnc_cache[index]) {
53297c478bd9Sstevel@tonic-gate 				/* unlink from active list */
53307c478bd9Sstevel@tonic-gate 				*hpp = (*hpp)->next;
53317c478bd9Sstevel@tonic-gate 				/* push it onto the top */
5332293d1fc4Spd155743 				hp->next = hnc_cache[index];
5333293d1fc4Spd155743 				hnc_cache[index] = hp;
53347c478bd9Sstevel@tonic-gate 			}
53357c478bd9Sstevel@tonic-gate 
53367c478bd9Sstevel@tonic-gate 			pthread_mutex_lock(&hp->h->hl_mutex);
53377c478bd9Sstevel@tonic-gate 			hp->h->hl_refcnt++;
53387c478bd9Sstevel@tonic-gate 			pthread_mutex_unlock(&hp->h->hl_mutex);
53397c478bd9Sstevel@tonic-gate 
53407c478bd9Sstevel@tonic-gate 			DPRINT4(9, "hnc_lookup(%u): found %p on %p for %s\n",
53417c478bd9Sstevel@tonic-gate 				mythreadno, hp->h, hp, hp->h->hl_hosts[0]);
53427c478bd9Sstevel@tonic-gate 
53437c478bd9Sstevel@tonic-gate 			pthread_mutex_unlock(&hnc_mutex);
53447c478bd9Sstevel@tonic-gate 			return (hp->h);
53457c478bd9Sstevel@tonic-gate 		}
53467c478bd9Sstevel@tonic-gate 
53477c478bd9Sstevel@tonic-gate 		hpp = &hp->next;
53487c478bd9Sstevel@tonic-gate 	}
53497c478bd9Sstevel@tonic-gate 
53507c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&hnc_mutex);
53517c478bd9Sstevel@tonic-gate 	return (NULL);
53527c478bd9Sstevel@tonic-gate }
53537c478bd9Sstevel@tonic-gate 
53547c478bd9Sstevel@tonic-gate static void
5355293d1fc4Spd155743 hnc_register(struct netbuf *nbp, struct netconfig *ncp,
5356293d1fc4Spd155743 		    host_list_t *h, int hindex)
53577c478bd9Sstevel@tonic-gate {
5358293d1fc4Spd155743 	struct hostname_cache **hpp, **tailp, *hp, *entry;
53597c478bd9Sstevel@tonic-gate 	void *addrbuf;
53607c478bd9Sstevel@tonic-gate 	time_t now;
53617c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
5362293d1fc4Spd155743 	int i;
53637c478bd9Sstevel@tonic-gate 
53647c478bd9Sstevel@tonic-gate 	if (Debug) {
53657c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
53667c478bd9Sstevel@tonic-gate 	}
53677c478bd9Sstevel@tonic-gate 
53687c478bd9Sstevel@tonic-gate 	if (hnc_cache == NULL) {
53697c478bd9Sstevel@tonic-gate 		return;
53707c478bd9Sstevel@tonic-gate 	}
53717c478bd9Sstevel@tonic-gate 
53727c478bd9Sstevel@tonic-gate 	if ((addrbuf = malloc(nbp->len)) == NULL) {
53737c478bd9Sstevel@tonic-gate 		MALLOC_FAIL("pushing hostname cache");
53747c478bd9Sstevel@tonic-gate 		return;
53757c478bd9Sstevel@tonic-gate 	}
53767c478bd9Sstevel@tonic-gate 
5377293d1fc4Spd155743 	if ((entry = malloc(sizeof (struct hostname_cache))) == NULL) {
5378293d1fc4Spd155743 		MALLOC_FAIL("pushing hostname entry");
5379293d1fc4Spd155743 		free(addrbuf);
5380293d1fc4Spd155743 		return;
5381293d1fc4Spd155743 	}
5382293d1fc4Spd155743 
53837c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&hnc_mutex);
53847c478bd9Sstevel@tonic-gate 
5385293d1fc4Spd155743 	i = 0;
5386293d1fc4Spd155743 
5387293d1fc4Spd155743 	now = time(0);
53887c478bd9Sstevel@tonic-gate 	/*
53897c478bd9Sstevel@tonic-gate 	 * first go through active list, and discard the
5390293d1fc4Spd155743 	 * caches which has been invalid. Count number of
5391293d1fc4Spd155743 	 * non-expired buckets.
53927c478bd9Sstevel@tonic-gate 	 */
5393293d1fc4Spd155743 
5394293d1fc4Spd155743 	for (hpp = &hnc_cache[hindex]; (hp = *hpp) != NULL; ) {
53957c478bd9Sstevel@tonic-gate 		tailp = hpp;
53967c478bd9Sstevel@tonic-gate 
53977c478bd9Sstevel@tonic-gate 		if (hp->expire < now) {
53987c478bd9Sstevel@tonic-gate 			DPRINT2(9, "hnc_register(%u): discard %p\n",
53997c478bd9Sstevel@tonic-gate 				mythreadno, hp);
54007c478bd9Sstevel@tonic-gate 			hnc_unreg(hpp);
54017c478bd9Sstevel@tonic-gate 		} else {
5402293d1fc4Spd155743 			i++;
54037c478bd9Sstevel@tonic-gate 			hpp = &hp->next;
54047c478bd9Sstevel@tonic-gate 		}
54057c478bd9Sstevel@tonic-gate 	}
54067c478bd9Sstevel@tonic-gate 
54077c478bd9Sstevel@tonic-gate 	/*
5408293d1fc4Spd155743 	 * If max limit of chained hash buckets has been used up
5409293d1fc4Spd155743 	 * delete the least active element in the chain.
54107c478bd9Sstevel@tonic-gate 	 */
5411293d1fc4Spd155743 	if (i == MAX_BUCKETS) {
54127c478bd9Sstevel@tonic-gate 		hnc_unreg(tailp);
54137c478bd9Sstevel@tonic-gate 	}
54147c478bd9Sstevel@tonic-gate 
54157c478bd9Sstevel@tonic-gate 	(void) memcpy(addrbuf, nbp->buf, nbp->len);
5416293d1fc4Spd155743 	entry->addr.len = nbp->len;
5417293d1fc4Spd155743 	entry->addr.buf = addrbuf;
5418293d1fc4Spd155743 	entry->ncp = ncp;
5419293d1fc4Spd155743 	entry->h = h;
5420293d1fc4Spd155743 	entry->expire = time(NULL) + hnc_ttl;
5421293d1fc4Spd155743 
5422293d1fc4Spd155743 	/* insert it at the top */
5423293d1fc4Spd155743 	entry->next = hnc_cache[hindex];
5424293d1fc4Spd155743 	hnc_cache[hindex] = entry;
54257c478bd9Sstevel@tonic-gate 
54267c478bd9Sstevel@tonic-gate 	/*
54277c478bd9Sstevel@tonic-gate 	 * As far as cache is valid, corresponding host_list must
54287c478bd9Sstevel@tonic-gate 	 * also be valid. Increments the refcnt to avoid freeing
54297c478bd9Sstevel@tonic-gate 	 * host_list.
54307c478bd9Sstevel@tonic-gate 	 */
54317c478bd9Sstevel@tonic-gate 	h->hl_refcnt++;
54327c478bd9Sstevel@tonic-gate 	DPRINT4(9, "hnc_register(%u): reg %p onto %p for %s\n",
54337c478bd9Sstevel@tonic-gate 			mythreadno, h, hp, hp->h->hl_hosts[0]);
54347c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&hnc_mutex);
54357c478bd9Sstevel@tonic-gate }
54367c478bd9Sstevel@tonic-gate 
54377c478bd9Sstevel@tonic-gate static void
54387c478bd9Sstevel@tonic-gate hnc_unreg(struct hostname_cache **hpp)
54397c478bd9Sstevel@tonic-gate {
54407c478bd9Sstevel@tonic-gate 	struct hostname_cache *hp = *hpp;
54417c478bd9Sstevel@tonic-gate 	pthread_t mythreadno;
54427c478bd9Sstevel@tonic-gate 
54437c478bd9Sstevel@tonic-gate 	if (Debug) {
54447c478bd9Sstevel@tonic-gate 		mythreadno = pthread_self();
54457c478bd9Sstevel@tonic-gate 	}
54467c478bd9Sstevel@tonic-gate 
54477c478bd9Sstevel@tonic-gate 	DPRINT4(9, "hnc_unreg(%u): unreg %p on %p for %s\n",
54487c478bd9Sstevel@tonic-gate 			mythreadno, hp->h, hp, hp->h->hl_hosts[0]);
54497c478bd9Sstevel@tonic-gate 	free(hp->addr.buf);
54507c478bd9Sstevel@tonic-gate 	freehl(hp->h);
54517c478bd9Sstevel@tonic-gate 
54527c478bd9Sstevel@tonic-gate 	/* unlink from active list */
54537c478bd9Sstevel@tonic-gate 	*hpp = (*hpp)->next;
54547c478bd9Sstevel@tonic-gate 
5455293d1fc4Spd155743 	free(hp);
54567c478bd9Sstevel@tonic-gate }
54577c478bd9Sstevel@tonic-gate 
54587c478bd9Sstevel@tonic-gate /*
54597c478bd9Sstevel@tonic-gate  * Once this is called, error messages through logerror() will go to
54607c478bd9Sstevel@tonic-gate  * the console immediately. Also, messages are queued into the tmpq
54617c478bd9Sstevel@tonic-gate  * to be able to later put them into inputq.
54627c478bd9Sstevel@tonic-gate  */
54637c478bd9Sstevel@tonic-gate static void
54647c478bd9Sstevel@tonic-gate disable_errorlog()
54657c478bd9Sstevel@tonic-gate {
54667c478bd9Sstevel@tonic-gate 	dataq_init(&tmpq);
54677c478bd9Sstevel@tonic-gate 
54687c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&logerror_lock);
54697c478bd9Sstevel@tonic-gate 	interrorlog = 0;
54707c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&logerror_lock);
54717c478bd9Sstevel@tonic-gate }
54727c478bd9Sstevel@tonic-gate 
54737c478bd9Sstevel@tonic-gate /*
54747c478bd9Sstevel@tonic-gate  * Turn internal error messages to regular input stream.
54757c478bd9Sstevel@tonic-gate  * All pending messages are pulled and pushed into the regular
54767c478bd9Sstevel@tonic-gate  * input queue.
54777c478bd9Sstevel@tonic-gate  */
54787c478bd9Sstevel@tonic-gate static void
54797c478bd9Sstevel@tonic-gate enable_errorlog()
54807c478bd9Sstevel@tonic-gate {
54817c478bd9Sstevel@tonic-gate 	log_message_t *mp;
54827c478bd9Sstevel@tonic-gate 
54837c478bd9Sstevel@tonic-gate 	pthread_mutex_lock(&logerror_lock);
54847c478bd9Sstevel@tonic-gate 	interrorlog = 1;
54857c478bd9Sstevel@tonic-gate 	pthread_mutex_unlock(&logerror_lock);
54867c478bd9Sstevel@tonic-gate 
54877c478bd9Sstevel@tonic-gate 	/*
54887c478bd9Sstevel@tonic-gate 	 * push all the pending messages into inputq.
54897c478bd9Sstevel@tonic-gate 	 */
54907c478bd9Sstevel@tonic-gate 	while (dataq_dequeue(&tmpq, (void **)&mp, 1) == 0) {
54917c478bd9Sstevel@tonic-gate 		(void) dataq_enqueue(&inputq, mp);
54927c478bd9Sstevel@tonic-gate 	}
54937c478bd9Sstevel@tonic-gate 	dataq_destroy(&tmpq);
54947c478bd9Sstevel@tonic-gate }
5495293d1fc4Spd155743 
5496293d1fc4Spd155743 /*
5497293d1fc4Spd155743  * Generate a hash value of the given address and derive
5498293d1fc4Spd155743  * an index into the hnc_cache hashtable.
5499293d1fc4Spd155743  * The hashing method is similar to what Java does for strings.
5500293d1fc4Spd155743  */
5501293d1fc4Spd155743 static int
5502293d1fc4Spd155743 addr_hash(struct netbuf *nbp)
5503293d1fc4Spd155743 {
5504293d1fc4Spd155743 	char *uap;
5505293d1fc4Spd155743 	int i;
5506293d1fc4Spd155743 	unsigned long hcode = 0;
5507293d1fc4Spd155743 
5508293d1fc4Spd155743 	uap = nbp->buf;
5509293d1fc4Spd155743 
5510293d1fc4Spd155743 	if (uap == NULL) {
5511293d1fc4Spd155743 		return (0);
5512293d1fc4Spd155743 	}
5513293d1fc4Spd155743 
5514293d1fc4Spd155743 	/*
5515293d1fc4Spd155743 	 * Compute a hashcode of the address string
5516293d1fc4Spd155743 	 */
5517293d1fc4Spd155743 	for (i = 0; i < nbp->len; i++)
5518293d1fc4Spd155743 		hcode = (31 * hcode) + uap[i];
5519293d1fc4Spd155743 
5520293d1fc4Spd155743 	/*
5521293d1fc4Spd155743 	 * Scramble the hashcode for better distribution
5522293d1fc4Spd155743 	 */
5523293d1fc4Spd155743 	hcode += ~(hcode << 9);
5524293d1fc4Spd155743 	hcode ^=  (hcode >> 14);
5525293d1fc4Spd155743 	hcode +=  (hcode << 4);
5526293d1fc4Spd155743 	hcode ^=  (hcode >> 10);
5527293d1fc4Spd155743 
5528293d1fc4Spd155743 	return ((int)(hcode % hnc_size));
5529293d1fc4Spd155743 }
5530