/*	$NetBSD: syslogd.c,v 1.123.8.1 2017/09/23 17:20:13 snj Exp $	*/

/*
 * Copyright (c) 1983, 1988, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 1983, 1988, 1993, 1994\
	The Regents of the University of California.  All rights reserved.");
#endif /* not lint */

#ifndef lint
#if 0
static char sccsid[] = "@(#)syslogd.c	8.3 (Berkeley) 4/4/94";
#else
__RCSID("$NetBSD: syslogd.c,v 1.123.8.1 2017/09/23 17:20:13 snj Exp $");
#endif
#endif /* not lint */

/*
 *  syslogd -- log system messages
 *
 * This program implements a system log. It takes a series of lines.
 * Each line may have a priority, signified as "<n>" as
 * the first characters of the line.  If this is
 * not present, a default priority is used.
 *
 * To kill syslogd, send a signal 15 (terminate).  A signal 1 (hup) will
 * cause it to reread its configuration file.
 *
 * Defined Constants:
 *
 * MAXLINE -- the maximimum line length that can be handled.
 * DEFUPRI -- the default priority for user messages
 * DEFSPRI -- the default priority for kernel messages
 *
 * Author: Eric Allman
 * extensive changes by Ralph Campbell
 * more extensive changes by Eric Allman (again)
 * Extension to log by program name as well as facility and priority
 *   by Peter da Silva.
 * -U and -v by Harlan Stenn.
 * Priority comparison code by Harlan Stenn.
 * TLS, syslog-protocol, and syslog-sign code by Martin Schuette.
 */
#define SYSLOG_NAMES
#include <sys/stat.h>
#include <poll.h>
#include "syslogd.h"
#include "extern.h"

#ifndef DISABLE_SIGN
#include "sign.h"
struct sign_global_t GlobalSign = {
	.rsid = 0,
	.sig2_delims = STAILQ_HEAD_INITIALIZER(GlobalSign.sig2_delims)
};
#endif /* !DISABLE_SIGN */

#ifndef DISABLE_TLS
#include "tls.h"
#endif /* !DISABLE_TLS */

#ifdef LIBWRAP
int allow_severity = LOG_AUTH|LOG_INFO;
int deny_severity = LOG_AUTH|LOG_WARNING;
#endif

const char	*ConfFile = _PATH_LOGCONF;
char	ctty[] = _PATH_CONSOLE;

/*
 * Queue of about-to-be-dead processes we should watch out for.
 */
TAILQ_HEAD(, deadq_entry) deadq_head = TAILQ_HEAD_INITIALIZER(deadq_head);

typedef struct deadq_entry {
	pid_t				dq_pid;
	int				dq_timeout;
	TAILQ_ENTRY(deadq_entry)	dq_entries;
} *dq_t;

/*
 * The timeout to apply to processes waiting on the dead queue.	 Unit
 * of measure is "mark intervals", i.e. 20 minutes by default.
 * Processes on the dead queue will be terminated after that time.
 */
#define DQ_TIMO_INIT	2

/*
 * Intervals at which we flush out "message repeated" messages,
 * in seconds after previous message is logged.	 After each flush,
 * we move to the next interval until we reach the largest.
 */
int	repeatinterval[] = { 30, 120, 600 };	/* # of secs before flush */
#define MAXREPEAT ((sizeof(repeatinterval) / sizeof(repeatinterval[0])) - 1)
#define REPEATTIME(f)	((f)->f_time + repeatinterval[(f)->f_repeatcount])
#define BACKOFF(f)	{ if ((size_t)(++(f)->f_repeatcount) > MAXREPEAT) \
				 (f)->f_repeatcount = MAXREPEAT; \
			}

/* values for f_type */
#define F_UNUSED	0		/* unused entry */
#define F_FILE		1		/* regular file */
#define F_TTY		2		/* terminal */
#define F_CONSOLE	3		/* console terminal */
#define F_FORW		4		/* remote machine */
#define F_USERS		5		/* list of users */
#define F_WALL		6		/* everyone logged on */
#define F_PIPE		7		/* pipe to program */
#define F_FIFO		8		/* mkfifo(2) file */
#define F_TLS		9

struct TypeInfo {
	const char *name;
	char	   *queue_length_string;
	const char *default_length_string;
	char	   *queue_size_string;
	const char *default_size_string;
	int64_t	    queue_length;
	int64_t	    queue_size;
	int   max_msg_length;
} TypeInfo[] = {
	/* numeric values are set in init()
	 * -1 in length/size or max_msg_length means infinite */
	{"UNUSED",  NULL,    "0", NULL,	  "0", 0, 0,	 0},
	{"FILE",    NULL, "1024", NULL,	 "1M", 0, 0, 16384},
	{"TTY",	    NULL,    "0", NULL,	  "0", 0, 0,  1024},
	{"CONSOLE", NULL,    "0", NULL,	  "0", 0, 0,  1024},
	{"FORW",    NULL,    "0", NULL,	 "1M", 0, 0, 16384},
	{"USERS",   NULL,    "0", NULL,	  "0", 0, 0,  1024},
	{"WALL",    NULL,    "0", NULL,	  "0", 0, 0,  1024},
	{"PIPE",    NULL, "1024", NULL,	 "1M", 0, 0, 16384},
	{"FIFO",    NULL, "1024", NULL,	 "1M", 0, 0, 16384},
#ifndef DISABLE_TLS
	{"TLS",	    NULL,   "-1", NULL, "16M", 0, 0, 16384}
#endif /* !DISABLE_TLS */
};

struct	filed *Files = NULL;
struct	filed consfile;

time_t	now;
int	Debug = D_NONE;		/* debug flag */
int	daemonized = 0;		/* we are not daemonized yet */
char	*LocalFQDN = NULL;	       /* our FQDN */
char	*oldLocalFQDN = NULL;	       /* our previous FQDN */
char	LocalHostName[MAXHOSTNAMELEN]; /* our hostname */
struct socketEvent *finet;	/* Internet datagram sockets and events */
int   *funix;			/* Unix domain datagram sockets */
#ifndef DISABLE_TLS
struct socketEvent *TLS_Listen_Set; /* TLS/TCP sockets and events */
#endif /* !DISABLE_TLS */
int	Initialized = 0;	/* set when we have initialized ourselves */
int	ShuttingDown;		/* set when we die() */
int	MarkInterval = 20 * 60; /* interval between marks in seconds */
int	MarkSeq = 0;		/* mark sequence number */
int	SecureMode = 0;		/* listen only on unix domain socks */
int	UseNameService = 1;	/* make domain name queries */
int	NumForwards = 0;	/* number of forwarding actions in conf file */
char	**LogPaths;		/* array of pathnames to read messages from */
int	NoRepeat = 0;		/* disable "repeated"; log always */
int	RemoteAddDate = 0;	/* always add date to messages from network */
int	SyncKernel = 0;		/* write kernel messages synchronously */
int	UniquePriority = 0;	/* only log specified priority */
int	LogFacPri = 0;		/* put facility and priority in log messages: */
				/* 0=no, 1=numeric, 2=names */
bool	BSDOutputFormat = true;	/* if true emit traditional BSD Syslog lines,
				 * otherwise new syslog-protocol lines
				 *
				 * Open Issue: having a global flag is the
				 * easiest solution. If we get a more detailed
				 * config file this could/should be changed
				 * into a destination-specific flag.
				 * Most output code should be ready to handle
				 * this, it will only break some syslog-sign
				 * configurations (e.g. with SG="0").
				 */
char	appname[]   = "syslogd";/* the APPNAME for own messages */
char   *include_pid = NULL;	/* include PID in own messages */


/* init and setup */
void		usage(void) __attribute__((__noreturn__));
void		logpath_add(char ***, int *, int *, const char *);
void		logpath_fileadd(char ***, int *, int *, const char *);
void		init(int fd, short event, void *ev);  /* SIGHUP kevent dispatch routine */
struct socketEvent*
		socksetup(int, const char *);
int		getmsgbufsize(void);
char	       *getLocalFQDN(void);
void		trim_anydomain(char *);
/* pipe & subprocess handling */
int		p_open(char *, pid_t *);
void		deadq_enter(pid_t, const char *);
int		deadq_remove(pid_t);
void		log_deadchild(pid_t, int, const char *);
void		reapchild(int fd, short event, void *ev); /* SIGCHLD kevent dispatch routine */
/* input message parsing & formatting */
const char     *cvthname(struct sockaddr_storage *);
void		printsys(char *);
struct buf_msg *printline_syslogprotocol(const char*, char*, int, int);
struct buf_msg *printline_bsdsyslog(const char*, char*, int, int);
struct buf_msg *printline_kernelprintf(const char*, char*, int, int);
size_t		check_timestamp(unsigned char *, char **, bool, bool);
char	       *copy_utf8_ascii(char*, size_t);
uint_fast32_t	get_utf8_value(const char*);
unsigned	valid_utf8(const char *);
static unsigned check_sd(char*);
static unsigned check_msgid(char *);
/* event handling */
static void	dispatch_read_klog(int fd, short event, void *ev);
static void	dispatch_read_finet(int fd, short event, void *ev);
static void	dispatch_read_funix(int fd, short event, void *ev);
static void	domark(int fd, short event, void *ev); /* timer kevent dispatch routine */
/* log messages */
void		logmsg_async(int, const char *, const char *, int);
void		logmsg(struct buf_msg *);
int		matches_spec(const char *, const char *,
		char *(*)(const char *, const char *));
void		udp_send(struct filed *, char *, size_t);
void		wallmsg(struct filed *, struct iovec *, size_t);
/* buffer & queue functions */
size_t		message_queue_purge(struct filed *f, size_t, int);
size_t		message_allqueues_check(void);
static struct buf_queue *
		find_qentry_to_delete(const struct buf_queue_head *, int, bool);
struct buf_queue *
		message_queue_add(struct filed *, struct buf_msg *);
size_t		buf_queue_obj_size(struct buf_queue*);
/* configuration & parsing */
void		cfline(size_t, const char *, struct filed *, const char *,
    const char *);
void		read_config_file(FILE*, struct filed**);
void		store_sign_delim_sg2(char*);
int		decode(const char *, CODE *);
bool		copy_config_value(const char *, char **, const char **,
    const char *, int);
bool		copy_config_value_word(char **, const char **);

/* config parsing */
#ifndef DISABLE_TLS
void		free_cred_SLIST(struct peer_cred_head *);
static inline void
		free_incoming_tls_sockets(void);
#endif /* !DISABLE_TLS */
static int writev1(int, struct iovec *, size_t);

/* for make_timestamp() */
char	timestamp[MAX_TIMESTAMPLEN + 1];
/*
 * Global line buffer.	Since we only process one event at a time,
 * a global one will do.  But for klog, we use own buffer so that
 * partial line at the end of buffer can be deferred.
 */
char *linebuf, *klog_linebuf;
size_t linebufsize, klog_linebufoff;

static const char *bindhostname = NULL;

#ifndef DISABLE_TLS
struct TLS_Incoming TLS_Incoming_Head = \
	SLIST_HEAD_INITIALIZER(TLS_Incoming_Head);
extern char *SSL_ERRCODE[];
struct tls_global_options_t tls_opt;
#endif /* !DISABLE_TLS */

int
main(int argc, char *argv[])
{
	int ch, j, fklog;
	int funixsize = 0, funixmaxsize = 0;
	struct sockaddr_un sunx;
	char **pp;
	struct event *ev;
	uid_t uid = 0;
	gid_t gid = 0;
	char *user = NULL;
	char *group = NULL;
	const char *root = "/";
	char *endp;
	struct group   *gr;
	struct passwd  *pw;
	unsigned long l;

	/* should we set LC_TIME="C" to ensure correct timestamps&parsing? */
	(void)setlocale(LC_ALL, "");

	while ((ch = getopt(argc, argv, "b:dnsSf:m:o:p:P:ru:g:t:TUv")) != -1)
		switch(ch) {
		case 'b':
			bindhostname = optarg;
			break;
		case 'd':		/* debug */
			Debug = D_DEFAULT;
			/* is there a way to read the integer value
			 * for Debug as an optional argument? */
			break;
		case 'f':		/* configuration file */
			ConfFile = optarg;
			break;
		case 'g':
			group = optarg;
			if (*group == '\0')
				usage();
			break;
		case 'm':		/* mark interval */
			MarkInterval = atoi(optarg) * 60;
			break;
		case 'n':		/* turn off DNS queries */
			UseNameService = 0;
			break;
		case 'o':		/* message format */
#define EQ(a)		(strncmp(optarg, # a, sizeof(# a) - 1) == 0)
			if (EQ(bsd) || EQ(rfc3264))
				BSDOutputFormat = true;
			else if (EQ(syslog) || EQ(rfc5424))
				BSDOutputFormat = false;
			else
				usage();
			/* TODO: implement additional output option "osyslog"
			 *	 for old syslogd behaviour as introduced after
			 *	 FreeBSD PR#bin/7055.
			 */
			break;
		case 'p':		/* path */
			logpath_add(&LogPaths, &funixsize,
			    &funixmaxsize, optarg);
			break;
		case 'P':		/* file of paths */
			logpath_fileadd(&LogPaths, &funixsize,
			    &funixmaxsize, optarg);
			break;
		case 'r':		/* disable "repeated" compression */
			NoRepeat++;
			break;
		case 's':		/* no network listen mode */
			SecureMode++;
			break;
		case 'S':
			SyncKernel = 1;
			break;
		case 't':
			root = optarg;
			if (*root == '\0')
				usage();
			break;
		case 'T':
			RemoteAddDate = 1;
			break;
		case 'u':
			user = optarg;
			if (*user == '\0')
				usage();
			break;
		case 'U':		/* only log specified priority */
			UniquePriority = 1;
			break;
		case 'v':		/* log facility and priority */
			if (LogFacPri < 2)
				LogFacPri++;
			break;
		default:
			usage();
		}
	if ((argc -= optind) != 0)
		usage();

	setlinebuf(stdout);
	tzset(); /* init TZ information for localtime. */

	if (user != NULL) {
		if (isdigit((unsigned char)*user)) {
			errno = 0;
			endp = NULL;
			l = strtoul(user, &endp, 0);
			if (errno || *endp != '\0')
				goto getuser;
			uid = (uid_t)l;
			if (uid != l) {/* TODO: never executed */
				errno = 0;
				logerror("UID out of range");
				die(0, 0, NULL);
			}
		} else {
getuser:
			if ((pw = getpwnam(user)) != NULL) {
				uid = pw->pw_uid;
			} else {
				errno = 0;
				logerror("Cannot find user `%s'", user);
				die(0, 0, NULL);
			}
		}
	}

	if (group != NULL) {
		if (isdigit((unsigned char)*group)) {
			errno = 0;
			endp = NULL;
			l = strtoul(group, &endp, 0);
			if (errno || *endp != '\0')
				goto getgroup;
			gid = (gid_t)l;
			if (gid != l) {/* TODO: never executed */
				errno = 0;
				logerror("GID out of range");
				die(0, 0, NULL);
			}
		} else {
getgroup:
			if ((gr = getgrnam(group)) != NULL) {
				gid = gr->gr_gid;
			} else {
				errno = 0;
				logerror("Cannot find group `%s'", group);
				die(0, 0, NULL);
			}
		}
	}

	if (access(root, F_OK | R_OK)) {
		logerror("Cannot access `%s'", root);
		die(0, 0, NULL);
	}

	consfile.f_type = F_CONSOLE;
	(void)strlcpy(consfile.f_un.f_fname, ctty,
	    sizeof(consfile.f_un.f_fname));
	linebufsize = getmsgbufsize();
	if (linebufsize < MAXLINE)
		linebufsize = MAXLINE;
	linebufsize++;

	if (!(linebuf = malloc(linebufsize))) {
		logerror("Couldn't allocate buffer");
		die(0, 0, NULL);
	}
	if (!(klog_linebuf = malloc(linebufsize))) {
		logerror("Couldn't allocate buffer for klog");
		die(0, 0, NULL);
	}


#ifndef SUN_LEN
#define SUN_LEN(unp) (strlen((unp)->sun_path) + 2)
#endif
	if (funixsize == 0)
		logpath_add(&LogPaths, &funixsize,
		    &funixmaxsize, _PATH_LOG);
	funix = malloc(sizeof(*funix) * funixsize);
	if (funix == NULL) {
		logerror("Couldn't allocate funix descriptors");
		die(0, 0, NULL);
	}
	for (j = 0, pp = LogPaths; *pp; pp++, j++) {
		DPRINTF(D_NET, "Making unix dgram socket `%s'\n", *pp);
		unlink(*pp);
		memset(&sunx, 0, sizeof(sunx));
		sunx.sun_family = AF_LOCAL;
		(void)strncpy(sunx.sun_path, *pp, sizeof(sunx.sun_path));
		funix[j] = socket(AF_LOCAL, SOCK_DGRAM, 0);
		if (funix[j] < 0 || bind(funix[j],
		    (struct sockaddr *)&sunx, SUN_LEN(&sunx)) < 0 ||
		    chmod(*pp, 0666) < 0) {
			logerror("Cannot create `%s'", *pp);
			die(0, 0, NULL);
		}
		DPRINTF(D_NET, "Listening on unix dgram socket `%s'\n", *pp);
	}

	if ((fklog = open(_PATH_KLOG, O_RDONLY, 0)) < 0) {
		DPRINTF(D_FILE, "Can't open `%s' (%d)\n", _PATH_KLOG, errno);
	} else {
		DPRINTF(D_FILE, "Listening on kernel log `%s' with fd %d\n",
		    _PATH_KLOG, fklog);
	}

#if (!defined(DISABLE_TLS) && !defined(DISABLE_SIGN))
	/* basic OpenSSL init */
	SSL_load_error_strings();
	(void) SSL_library_init();
	OpenSSL_add_all_digests();
	/* OpenSSL PRNG needs /dev/urandom, thus initialize before chroot() */
	if (!RAND_status()) {
		errno = 0;
		logerror("Unable to initialize OpenSSL PRNG");
	} else {
		DPRINTF(D_TLS, "Initializing PRNG\n");
	}
#endif /* (!defined(DISABLE_TLS) && !defined(DISABLE_SIGN)) */
#ifndef DISABLE_SIGN
	/* initialize rsid -- we will use that later to determine
	 * whether sign_global_init() was already called */
	GlobalSign.rsid = 0;
#endif /* !DISABLE_SIGN */
#if (IETF_NUM_PRIVALUES != (LOG_NFACILITIES<<3))
	logerror("Warning: system defines %d priority values, but "
	    "syslog-protocol/syslog-sign specify %d values",
	    LOG_NFACILITIES, SIGN_NUM_PRIVALS);
#endif

	/*
	 * All files are open, we can drop privileges and chroot
	 */
	DPRINTF(D_MISC, "Attempt to chroot to `%s'\n", root);
	if (chroot(root) == -1) {
		logerror("Failed to chroot to `%s'", root);
		die(0, 0, NULL);
	}
	DPRINTF(D_MISC, "Attempt to set GID/EGID to `%d'\n", gid);
	if (setgid(gid) || setegid(gid)) {
		logerror("Failed to set gid to `%d'", gid);
		die(0, 0, NULL);
	}
	DPRINTF(D_MISC, "Attempt to set UID/EUID to `%d'\n", uid);
	if (setuid(uid) || seteuid(uid)) {
		logerror("Failed to set uid to `%d'", uid);
		die(0, 0, NULL);
	}
	/*
	 * We cannot detach from the terminal before we are sure we won't
	 * have a fatal error, because error message would not go to the
	 * terminal and would not be logged because syslogd dies.
	 * All die() calls are behind us, we can call daemon()
	 */
	if (!Debug) {
		(void)daemon(0, 0);
		daemonized = 1;
		/* tuck my process id away, if i'm not in debug mode */
#ifdef __NetBSD_Version__
		pidfile(NULL);
#endif /* __NetBSD_Version__ */
	}

#define MAX_PID_LEN 5
	include_pid = malloc(MAX_PID_LEN+1);
	snprintf(include_pid, MAX_PID_LEN+1, "%d", getpid());

	/*
	 * Create the global kernel event descriptor.
	 *
	 * NOTE: We MUST do this after daemon(), bacause the kqueue()
	 * API dictates that kqueue descriptors are not inherited
	 * across forks (lame!).
	 */
	(void)event_init();

	/*
	 * We must read the configuration file for the first time
	 * after the kqueue descriptor is created, because we install
	 * events during this process.
	 */
	init(0, 0, NULL);

	/*
	 * Always exit on SIGTERM.  Also exit on SIGINT and SIGQUIT
	 * if we're debugging.
	 */
	(void)signal(SIGTERM, SIG_IGN);
	(void)signal(SIGINT, SIG_IGN);
	(void)signal(SIGQUIT, SIG_IGN);

	ev = allocev();
	signal_set(ev, SIGTERM, die, ev);
	EVENT_ADD(ev);

	if (Debug) {
		ev = allocev();
		signal_set(ev, SIGINT, die, ev);
		EVENT_ADD(ev);
		ev = allocev();
		signal_set(ev, SIGQUIT, die, ev);
		EVENT_ADD(ev);
	}

	ev = allocev();
	signal_set(ev, SIGCHLD, reapchild, ev);
	EVENT_ADD(ev);

	ev = allocev();
	schedule_event(&ev,
		&((struct timeval){TIMERINTVL, 0}),
		domark, ev);

	(void)signal(SIGPIPE, SIG_IGN); /* We'll catch EPIPE instead. */

	/* Re-read configuration on SIGHUP. */
	(void) signal(SIGHUP, SIG_IGN);
	ev = allocev();
	signal_set(ev, SIGHUP, init, ev);
	EVENT_ADD(ev);

#ifndef DISABLE_TLS
	ev = allocev();
	signal_set(ev, SIGUSR1, dispatch_force_tls_reconnect, ev);
	EVENT_ADD(ev);
#endif /* !DISABLE_TLS */

	if (fklog >= 0) {
		ev = allocev();
		DPRINTF(D_EVENT,
			"register klog for fd %d with ev@%p\n", fklog, ev);
		event_set(ev, fklog, EV_READ | EV_PERSIST,
			dispatch_read_klog, ev);
		EVENT_ADD(ev);
	}
	for (j = 0, pp = LogPaths; *pp; pp++, j++) {
		ev = allocev();
		event_set(ev, funix[j], EV_READ | EV_PERSIST,
			dispatch_read_funix, ev);
		EVENT_ADD(ev);
	}

	DPRINTF(D_MISC, "Off & running....\n");

	j = event_dispatch();
	/* normal termination via die(), reaching this is an error */
	DPRINTF(D_MISC, "event_dispatch() returned %d\n", j);
	die(0, 0, NULL);
	/*NOTREACHED*/
	return 0;
}

void
usage(void)
{

	(void)fprintf(stderr,
	    "usage: %s [-dnrSsTUv] [-b bind_address] [-f config_file] [-g group]\n"
	    "\t[-m mark_interval] [-P file_list] [-p log_socket\n"
	    "\t[-p log_socket2 ...]] [-t chroot_dir] [-u user]\n",
	    getprogname());
	exit(1);
}

/*
 * Dispatch routine for reading /dev/klog
 *
 * Note: slightly different semantic in dispatch_read functions:
 *	 - read_klog() might give multiple messages in linebuf and
 *	   leaves the task of splitting them to printsys()
 *	 - all other read functions receive one message and
 *	   then call printline() with one buffer.
 */
static void
dispatch_read_klog(int fd, short event, void *ev)
{
	ssize_t rv;
	size_t resid = linebufsize - klog_linebufoff;

	DPRINTF((D_CALL|D_EVENT), "Kernel log active (%d, %d, %p)"
		" with linebuf@%p, length %zu)\n", fd, event, ev,
		klog_linebuf, linebufsize);

	rv = read(fd, &klog_linebuf[klog_linebufoff], resid - 1);
	if (rv > 0) {
		klog_linebuf[klog_linebufoff + rv] = '\0';
		printsys(klog_linebuf);
	} else if (rv < 0 && errno != EINTR) {
		/*
		 * /dev/klog has croaked.  Disable the event
		 * so it won't bother us again.
		 */
		logerror("klog failed");
		event_del(ev);
	}
}

/*
 * Dispatch routine for reading Unix domain sockets.
 */
static void
dispatch_read_funix(int fd, short event, void *ev)
{
	struct sockaddr_un myname, fromunix;
	ssize_t rv;
	socklen_t sunlen;

	sunlen = sizeof(myname);
	if (getsockname(fd, (struct sockaddr *)&myname, &sunlen) != 0) {
		/*
		 * This should never happen, so ensure that it doesn't
		 * happen again.
		 */
		logerror("getsockname() unix failed");
		event_del(ev);
		return;
	}

#define SUN_PATHLEN(su) \
	((su)->sun_len - (sizeof(*(su)) - sizeof((su)->sun_path)))

	DPRINTF((D_CALL|D_EVENT|D_NET), "Unix socket (%.*s) active (%d, %d %p)"
		" with linebuf@%p, size %zu)\n", (int)SUN_PATHLEN(&myname),
		myname.sun_path, fd, event, ev, linebuf, linebufsize-1);

	sunlen = sizeof(fromunix);
	rv = recvfrom(fd, linebuf, linebufsize-1, 0,
	    (struct sockaddr *)&fromunix, &sunlen);
	if (rv > 0) {
		linebuf[rv] = '\0';
		printline(LocalFQDN, linebuf, 0);
	} else if (rv < 0 && errno != EINTR) {
		logerror("recvfrom() unix `%.*s'",
			(int)SUN_PATHLEN(&myname), myname.sun_path);
	}
}

/*
 * Dispatch routine for reading Internet sockets.
 */
static void
dispatch_read_finet(int fd, short event, void *ev)
{
#ifdef LIBWRAP
	struct request_info req;
#endif
	struct sockaddr_storage frominet;
	ssize_t rv;
	socklen_t len;
	int reject = 0;

	DPRINTF((D_CALL|D_EVENT|D_NET), "inet socket active (%d, %d %p) "
		" with linebuf@%p, size %zu)\n",
		fd, event, ev, linebuf, linebufsize-1);

#ifdef LIBWRAP
	request_init(&req, RQ_DAEMON, appname, RQ_FILE, fd, NULL);
	fromhost(&req);
	reject = !hosts_access(&req);
	if (reject)
		DPRINTF(D_NET, "access denied\n");
#endif

	len = sizeof(frominet);
	rv = recvfrom(fd, linebuf, linebufsize-1, 0,
	    (struct sockaddr *)&frominet, &len);
	if (rv == 0 || (rv < 0 && errno == EINTR))
		return;
	else if (rv < 0) {
		logerror("recvfrom inet");
		return;
	}

	linebuf[rv] = '\0';
	if (!reject)
		printline(cvthname(&frominet), linebuf,
		    RemoteAddDate ? ADDDATE : 0);
}

/*
 * given a pointer to an array of char *'s, a pointer to its current
 * size and current allocated max size, and a new char * to add, add
 * it, update everything as necessary, possibly allocating a new array
 */
void
logpath_add(char ***lp, int *szp, int *maxszp, const char *new)
{
	char **nlp;
	int newmaxsz;

	DPRINTF(D_FILE, "Adding `%s' to the %p logpath list\n", new, *lp);
	if (*szp == *maxszp) {
		if (*maxszp == 0) {
			newmaxsz = 4;	/* start of with enough for now */
			*lp = NULL;
		} else
			newmaxsz = *maxszp * 2;
		nlp = realloc(*lp, sizeof(char *) * (newmaxsz + 1));
		if (nlp == NULL) {
			logerror("Couldn't allocate line buffer");
			die(0, 0, NULL);
		}
		*lp = nlp;
		*maxszp = newmaxsz;
	}
	if (((*lp)[(*szp)++] = strdup(new)) == NULL) {
		logerror("Couldn't allocate logpath");
		die(0, 0, NULL);
	}
	(*lp)[(*szp)] = NULL;		/* always keep it NULL terminated */
}

/* do a file of log sockets */
void
logpath_fileadd(char ***lp, int *szp, int *maxszp, const char *file)
{
	FILE *fp;
	char *line;
	size_t len;

	fp = fopen(file, "r");
	if (fp == NULL) {
		logerror("Could not open socket file list `%s'", file);
		die(0, 0, NULL);
	}

	while ((line = fgetln(fp, &len)) != NULL) {
		line[len - 1] = 0;
		logpath_add(lp, szp, maxszp, line);
	}
	fclose(fp);
}

/*
 * checks UTF-8 codepoint
 * returns either its length in bytes or 0 if *input is invalid
*/
unsigned
valid_utf8(const char *c) {
	unsigned rc, nb;

	/* first byte gives sequence length */
	     if ((*c & 0x80) == 0x00) return 1; /* 0bbbbbbb -- ASCII */
	else if ((*c & 0xc0) == 0x80) return 0; /* 10bbbbbb -- trailing byte */
	else if ((*c & 0xe0) == 0xc0) nb = 2;	/* 110bbbbb */
	else if ((*c & 0xf0) == 0xe0) nb = 3;	/* 1110bbbb */
	else if ((*c & 0xf8) == 0xf0) nb = 4;	/* 11110bbb */
	else return 0; /* UTF-8 allows only up to 4 bytes */

	/* catch overlong encodings */
	if ((*c & 0xfe) == 0xc0)
		return 0; /* 1100000b ... */
	else if (((*c & 0xff) == 0xe0) && ((*(c+1) & 0xe0) == 0x80))
		return 0; /* 11100000 100bbbbb ... */
	else if (((*c & 0xff) == 0xf0) && ((*(c+1) & 0xf0) == 0x80))
		return 0; /* 11110000 1000bbbb ... ... */

	/* and also filter UTF-16 surrogates (=invalid in UTF-8) */
	if (((*c & 0xff) == 0xed) && ((*(c+1) & 0xe0) == 0xa0))
		return 0; /* 11101101 101bbbbb ... */

	rc = nb;
	/* check trailing bytes */
	switch (nb) {
	default: return 0;
	case 4: if ((*(c+3) & 0xc0) != 0x80) return 0; /*FALLTHROUGH*/
	case 3: if ((*(c+2) & 0xc0) != 0x80) return 0; /*FALLTHROUGH*/
	case 2: if ((*(c+1) & 0xc0) != 0x80) return 0; /*FALLTHROUGH*/
	}
	return rc;
}
#define UTF8CHARMAX 4

/*
 * read UTF-8 value
 * returns a the codepoint number
 */
uint_fast32_t
get_utf8_value(const char *c) {
	uint_fast32_t sum;
	unsigned nb, i;

	/* first byte gives sequence length */
	     if ((*c & 0x80) == 0x00) return *c;/* 0bbbbbbb -- ASCII */
	else if ((*c & 0xc0) == 0x80) return 0; /* 10bbbbbb -- trailing byte */
	else if ((*c & 0xe0) == 0xc0) {		/* 110bbbbb */
		nb = 2;
		sum = (*c & ~0xe0) & 0xff;
	} else if ((*c & 0xf0) == 0xe0) {	/* 1110bbbb */
		nb = 3;
		sum = (*c & ~0xf0) & 0xff;
	} else if ((*c & 0xf8) == 0xf0) {	/* 11110bbb */
		nb = 4;
		sum = (*c & ~0xf8) & 0xff;
	} else return 0; /* UTF-8 allows only up to 4 bytes */

	/* check trailing bytes -- 10bbbbbb */
	i = 1;
	while (i < nb) {
		sum <<= 6;
		sum |= ((*(c+i) & ~0xc0) & 0xff);
		i++;
	}
	return sum;
}

/* note previous versions transscribe
 * control characters, e.g. \007 --> "^G"
 * did anyone rely on that?
 *
 * this new version works on only one buffer and
 * replaces control characters with a space
 */
#define NEXTFIELD(ptr) if (*(p) == ' ') (p)++; /* SP */			\
		       else {						\
				DPRINTF(D_DATA, "format error\n");	\
				if (*(p) == '\0') start = (p);		\
				goto all_syslog_msg;			\
		       }
#define FORCE2ASCII(c) ((iscntrl((unsigned char)(c)) && (c) != '\t')	\
			? ((c) == '\n' ? ' ' : '?')			\
			: (c) & 0177)

/* following syslog-protocol */
#define printusascii(ch) (ch >= 33 && ch <= 126)
#define sdname(ch) (ch != '=' && ch != ' ' \
		 && ch != ']' && ch != '"' \
		 && printusascii(ch))

/* checks whether the first word of string p can be interpreted as
 * a syslog-protocol MSGID and if so returns its length.
 *
 * otherwise returns 0
 */
static unsigned
check_msgid(char *p)
{
	char *q = p;

	/* consider the NILVALUE to be valid */
	if (*q == '-' && *(q+1) == ' ')
		return 1;

	for (;;) {
		if (*q == ' ')
			return q - p;
		else if (*q == '\0' || !printusascii(*q) || q - p >= MSGID_MAX)
			return 0;
		else
			q++;
	}
}

/*
 * returns number of chars found in SD at beginning of string p
 * thus returns 0 if no valid SD is found
 *
 * if ascii == true then substitute all non-ASCII chars
 * otherwise use syslog-protocol rules to allow UTF-8 in values
 * note: one pass for filtering and scanning, so a found SD
 * is always filtered, but an invalid one could be partially
 * filtered up to the format error.
 */
static unsigned
check_sd(char* p)
{
	char *q = p;
	bool esc = false;

	/* consider the NILVALUE to be valid */
	if (*q == '-' && (*(q+1) == ' ' || *(q+1) == '\0'))
		return 1;

	for(;;) { /* SD-ELEMENT */
		if (*q++ != '[') return 0;
		/* SD-ID */
		if (!sdname(*q)) return 0;
		while (sdname(*q)) {
			*q = FORCE2ASCII(*q);
			q++;
		}
		for(;;) { /* SD-PARAM */
			if (*q == ']') {
				q++;
				if (*q == ' ' || *q == '\0') return q - p;
				else if (*q == '[') break;
			} else if (*q++ != ' ') return 0;

			/* PARAM-NAME */
			if (!sdname(*q)) return 0;
			while (sdname(*q)) {
				*q = FORCE2ASCII(*q);
				q++;
			}

			if (*q++ != '=') return 0;
			if (*q++ != '"') return 0;

			for(;;) { /* PARAM-VALUE */
				if (esc) {
					esc = false;
					if (*q == '\\' || *q == '"' ||
					    *q == ']') {
						q++;
						continue;
					}
					/* no else because invalid
					 * escape sequences are accepted */
				}
				else if (*q == '"') break;
				else if (*q == '\0' || *q == ']') return 0;
				else if (*q == '\\') esc = true;
				else {
					int i;
					i = valid_utf8(q);
					if (i == 0)
						*q = '?';
					else if (i == 1)
						*q = FORCE2ASCII(*q);
					else /* multi byte char */
						q += (i-1);
				}
				q++;
			}
			q++;
		}
	}
}

struct buf_msg *
printline_syslogprotocol(const char *hname, char *msg,
	int flags, int pri)
{
	struct buf_msg *buffer;
	char *p, *start;
	unsigned sdlen = 0, i = 0;
	bool utf8allowed = false; /* for some fields */

	DPRINTF((D_CALL|D_BUFFER|D_DATA), "printline_syslogprotocol("
	    "\"%s\", \"%s\", %d, %d)\n", hname, msg, flags, pri);

	buffer = buf_msg_new(0);
	p = msg;
	p += check_timestamp((unsigned char*) p,
		&buffer->timestamp, true, !BSDOutputFormat);
	DPRINTF(D_DATA, "Got timestamp \"%s\"\n", buffer->timestamp);

	if (flags & ADDDATE) {
		FREEPTR(buffer->timestamp);
		buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0);
	}

	start = p;
	NEXTFIELD(p);
	/* extract host */
	for (start = p;; p++) {
		if ((*p == ' ' || *p == '\0')
		    && start == p-1 && *(p-1) == '-') {
			/* NILVALUE */
			break;
		} else if ((*p == ' ' || *p == '\0')
		    && (start != p-1 || *(p-1) != '-')) {
			buffer->host = strndup(start, p - start);
			break;
		} else {
			*p = FORCE2ASCII(*p);
		}
	}
	/* p @ SP after host */
	DPRINTF(D_DATA, "Got host \"%s\"\n", buffer->host);

	/* extract app-name */
	NEXTFIELD(p);
	for (start = p;; p++) {
		if ((*p == ' ' || *p == '\0')
		    && start == p-1 && *(p-1) == '-') {
			/* NILVALUE */
			break;
		} else if ((*p == ' ' || *p == '\0')
		    && (start != p-1 || *(p-1) != '-')) {
			buffer->prog = strndup(start, p - start);
			break;
		} else {
			*p = FORCE2ASCII(*p);
		}
	}
	DPRINTF(D_DATA, "Got prog \"%s\"\n", buffer->prog);

	/* extract procid */
	NEXTFIELD(p);
	for (start = p;; p++) {
		if ((*p == ' ' || *p == '\0')
		    && start == p-1 && *(p-1) == '-') {
			/* NILVALUE */
			break;
		} else if ((*p == ' ' || *p == '\0')
		    && (start != p-1 || *(p-1) != '-')) {
			buffer->pid = strndup(start, p - start);
			start = p;
			break;
		} else {
			*p = FORCE2ASCII(*p);
		}
	}
	DPRINTF(D_DATA, "Got pid \"%s\"\n", buffer->pid);

	/* extract msgid */
	NEXTFIELD(p);
	for (start = p;; p++) {
		if ((*p == ' ' || *p == '\0')
		    && start == p-1 && *(p-1) == '-') {
			/* NILVALUE */
			start = p+1;
			break;
		} else if ((*p == ' ' || *p == '\0')
		    && (start != p-1 || *(p-1) != '-')) {
			buffer->msgid = strndup(start, p - start);
			start = p+1;
			break;
		} else {
			*p = FORCE2ASCII(*p);
		}
	}
	DPRINTF(D_DATA, "Got msgid \"%s\"\n", buffer->msgid);

	/* extract SD */
	NEXTFIELD(p);
	start = p;
	sdlen = check_sd(p);
	DPRINTF(D_DATA, "check_sd(\"%s\") returned %d\n", p, sdlen);

	if (sdlen == 1 && *p == '-') {
		/* NILVALUE */
		p++;
	} else if (sdlen > 1) {
		buffer->sd = strndup(p, sdlen);
		p += sdlen;
	} else {
		DPRINTF(D_DATA, "format error\n");
	}
	if	(*p == '\0') start = p;
	else if (*p == ' ')  start = ++p; /* SP */
	DPRINTF(D_DATA, "Got SD \"%s\"\n", buffer->sd);

	/* and now the message itself
	 * note: move back to last start to check for BOM
	 */
all_syslog_msg:
	p = start;

	/* check for UTF-8-BOM */
	if (IS_BOM(p)) {
		DPRINTF(D_DATA, "UTF-8 BOM\n");
		utf8allowed = true;
		p += 3;
	}

	if (*p != '\0' && !utf8allowed) {
		size_t msglen;

		msglen = strlen(p);
		assert(!buffer->msg);
		buffer->msg = copy_utf8_ascii(p, msglen);
		buffer->msgorig = buffer->msg;
		buffer->msglen = buffer->msgsize = strlen(buffer->msg)+1;
	} else if (*p != '\0' && utf8allowed) {
		while (*p != '\0') {
			i = valid_utf8(p);
			if (i == 0)
				*p++ = '?';
			else if (i == 1)
				*p = FORCE2ASCII(*p);
			p += i;
		}
		assert(p != start);
		assert(!buffer->msg);
		buffer->msg = strndup(start, p - start);
		buffer->msgorig = buffer->msg;
		buffer->msglen = buffer->msgsize = 1 + p - start;
	}
	DPRINTF(D_DATA, "Got msg \"%s\"\n", buffer->msg);

	buffer->recvhost = strdup(hname);
	buffer->pri = pri;
	buffer->flags = flags;

	return buffer;
}

/* copies an input into a new ASCII buffer
 * ASCII controls are converted to format "^X"
 * multi-byte UTF-8 chars are converted to format "<ab><cd>"
 */
#define INIT_BUFSIZE 512
char *
copy_utf8_ascii(char *p, size_t p_len)
{
	size_t idst = 0, isrc = 0, dstsize = INIT_BUFSIZE, i;
	char *dst, *tmp_dst;

	MALLOC(dst, dstsize);
	while (isrc < p_len) {
		if (dstsize < idst + 10) {
			/* check for enough space for \0 and a UTF-8
			 * conversion; longest possible is <U+123456> */
			tmp_dst = realloc(dst, dstsize + INIT_BUFSIZE);
			if (!tmp_dst)
				break;
			dst = tmp_dst;
			dstsize += INIT_BUFSIZE;
		}

		i = valid_utf8(&p[isrc]);
		if (i == 0) { /* invalid encoding */
			dst[idst++] = '?';
			isrc++;
		} else if (i == 1) { /* check printable */
			if (iscntrl((unsigned char)p[isrc])
			 && p[isrc] != '\t') {
				if (p[isrc] == '\n') {
					dst[idst++] = ' ';
					isrc++;
				} else {
					dst[idst++] = '^';
					dst[idst++] = p[isrc++] ^ 0100;
				}
			} else
				dst[idst++] = p[isrc++];
		} else {  /* convert UTF-8 to ASCII */
			dst[idst++] = '<';
			idst += snprintf(&dst[idst], dstsize - idst, "U+%x",
			    get_utf8_value(&p[isrc]));
			isrc += i;
			dst[idst++] = '>';
		}
	}
	dst[idst] = '\0';

	/* shrink buffer to right size */
	tmp_dst = realloc(dst, idst+1);
	if (tmp_dst)
		return tmp_dst;
	else
		return dst;
}

struct buf_msg *
printline_bsdsyslog(const char *hname, char *msg,
	int flags, int pri)
{
	struct buf_msg *buffer;
	char *p, *start;
	unsigned msgidlen = 0, sdlen = 0;

	DPRINTF((D_CALL|D_BUFFER|D_DATA), "printline_bsdsyslog("
		"\"%s\", \"%s\", %d, %d)\n", hname, msg, flags, pri);

	buffer = buf_msg_new(0);
	p = msg;
	p += check_timestamp((unsigned char*) p,
		&buffer->timestamp, false, !BSDOutputFormat);
	DPRINTF(D_DATA, "Got timestamp \"%s\"\n", buffer->timestamp);

	if (flags & ADDDATE || !buffer->timestamp) {
		FREEPTR(buffer->timestamp);
		buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0);
	}

	if (*p == ' ') p++; /* SP */
	else goto all_bsd_msg;
	/* in any error case we skip header parsing and
	 * treat all following data as message content */

	/* extract host */
	for (start = p;; p++) {
		if (*p == ' ' || *p == '\0') {
			buffer->host = strndup(start, p - start);
			break;
		} else if (*p == '[' || (*p == ':'
			&& (*(p+1) == ' ' || *(p+1) == '\0'))) {
			/* no host in message */
			buffer->host = strdup(hname);
			buffer->prog = strndup(start, p - start);
			break;
		} else {
			*p = FORCE2ASCII(*p);
		}
	}
	DPRINTF(D_DATA, "Got host \"%s\"\n", buffer->host);
	/* p @ SP after host, or @ :/[ after prog */

	/* extract program */
	if (!buffer->prog) {
		if (*p == ' ') p++; /* SP */
		else goto all_bsd_msg;

		for (start = p;; p++) {
			if (*p == ' ' || *p == '\0') { /* error */
				goto all_bsd_msg;
			} else if (*p == '[' || (*p == ':'
				&& (*(p+1) == ' ' || *(p+1) == '\0'))) {
				buffer->prog = strndup(start, p - start);
				break;
			} else {
				*p = FORCE2ASCII(*p);
			}
		}
	}
	DPRINTF(D_DATA, "Got prog \"%s\"\n", buffer->prog);
	start = p;

	/* p @ :/[ after prog */
	if (*p == '[') {
		p++;
		if (*p == ' ') p++; /* SP */
		for (start = p;; p++) {
			if (*p == ' ' || *p == '\0') { /* error */
				goto all_bsd_msg;
			} else if (*p == ']') {
				buffer->pid = strndup(start, p - start);
				break;
			} else {
				*p = FORCE2ASCII(*p);
			}
		}
	}
	DPRINTF(D_DATA, "Got pid \"%s\"\n", buffer->pid);

	if (*p == ']') p++;
	if (*p == ':') p++;
	if (*p == ' ') p++;

	/* p @ msgid, @ opening [ of SD or @ first byte of message
	 * accept either case and try to detect MSGID and SD fields
	 *
	 * only limitation: we do not accept UTF-8 data in
	 * BSD Syslog messages -- so all SD values are ASCII-filtered
	 *
	 * I have found one scenario with 'unexpected' behaviour:
	 * if there is only a SD intended, but a) it is short enough
	 * to be a MSGID and b) the first word of the message can also
	 * be parsed as an SD.
	 * example:
	 * "<35>Jul  6 12:39:08 tag[123]: [exampleSDID@0] - hello"
	 * --> parsed as
	 *     MSGID = "[exampleSDID@0]"
	 *     SD    = "-"
	 *     MSG   = "hello"
	 */
	start = p;
	msgidlen = check_msgid(p);
	if (msgidlen) /* check for SD in 2nd field */
		sdlen = check_sd(p+msgidlen+1);

	if (msgidlen && sdlen) {
		/* MSGID in 1st and SD in 2nd field
		 * now check for NILVALUEs and copy */
		if (msgidlen == 1 && *p == '-') {
			p++; /* - */
			p++; /* SP */
			DPRINTF(D_DATA, "Got MSGID \"-\"\n");
		} else {
			/* only has ASCII chars after check_msgid() */
			buffer->msgid = strndup(p, msgidlen);
			p += msgidlen;
			p++; /* SP */
			DPRINTF(D_DATA, "Got MSGID \"%s\"\n",
				buffer->msgid);
		}
	} else {
		/* either no msgid or no SD in 2nd field
		 * --> check 1st field for SD */
		DPRINTF(D_DATA, "No MSGID\n");
		sdlen = check_sd(p);
	}

	if (sdlen == 0) {
		DPRINTF(D_DATA, "No SD\n");
	} else if (sdlen > 1) {
		buffer->sd = copy_utf8_ascii(p, sdlen);
		DPRINTF(D_DATA, "Got SD \"%s\"\n", buffer->sd);
	} else if (sdlen == 1 && *p == '-') {
		p++;
		DPRINTF(D_DATA, "Got SD \"-\"\n");
	} else {
		DPRINTF(D_DATA, "Error\n");
	}

	if (*p == ' ') p++;
	start = p;
	/* and now the message itself
	 * note: do not reset start, because we might come here
	 * by goto and want to have the incomplete field as part
	 * of the msg
	 */
all_bsd_msg:
	if (*p != '\0') {
		size_t msglen = strlen(p);
		buffer->msg = copy_utf8_ascii(p, msglen);
		buffer->msgorig = buffer->msg;
		buffer->msglen = buffer->msgsize = strlen(buffer->msg)+1;
	}
	DPRINTF(D_DATA, "Got msg \"%s\"\n", buffer->msg);

	buffer->recvhost = strdup(hname);
	buffer->pri = pri;
	buffer->flags = flags | BSDSYSLOG;

	return buffer;
}

struct buf_msg *
printline_kernelprintf(const char *hname, char *msg,
	int flags, int pri)
{
	struct buf_msg *buffer;
	char *p;
	unsigned sdlen = 0;

	DPRINTF((D_CALL|D_BUFFER|D_DATA), "printline_kernelprintf("
		"\"%s\", \"%s\", %d, %d)\n", hname, msg, flags, pri);

	buffer = buf_msg_new(0);
	buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0);
	buffer->pri = pri;
	buffer->flags = flags;

	/* assume there is no MSGID but there might be SD */
	p = msg;
	sdlen = check_sd(p);

	if (sdlen == 0) {
		DPRINTF(D_DATA, "No SD\n");
	} else if (sdlen > 1) {
		buffer->sd = copy_utf8_ascii(p, sdlen);
		DPRINTF(D_DATA, "Got SD \"%s\"\n", buffer->sd);
	} else if (sdlen == 1 && *p == '-') {
		p++;
		DPRINTF(D_DATA, "Got SD \"-\"\n");
	} else {
		DPRINTF(D_DATA, "Error\n");
	}

	if (*p == ' ') p++;
	if (*p != '\0') {
		size_t msglen = strlen(p);
		buffer->msg = copy_utf8_ascii(p, msglen);
		buffer->msgorig = buffer->msg;
		buffer->msglen = buffer->msgsize = strlen(buffer->msg)+1;
	}
	DPRINTF(D_DATA, "Got msg \"%s\"\n", buffer->msg);

	return buffer;
}

/*
 * Take a raw input line, read priority and version, call the
 * right message parsing function, then call logmsg().
 */
void
printline(const char *hname, char *msg, int flags)
{
	struct buf_msg *buffer;
	int pri;
	char *p, *q;
	long n;
	bool bsdsyslog = true;

	DPRINTF((D_CALL|D_BUFFER|D_DATA),
		"printline(\"%s\", \"%s\", %d)\n", hname, msg, flags);

	/* test for special codes */
	pri = DEFUPRI;
	p = msg;
	if (*p == '<') {
		errno = 0;
		n = strtol(p + 1, &q, 10);
		if (*q == '>' && n >= 0 && n < INT_MAX && errno == 0) {
			p = q + 1;
			pri = (int)n;
			/* check for syslog-protocol version */
			if (*p == '1' && p[1] == ' ') {
				p += 2;	 /* skip version and space */
				bsdsyslog = false;
			} else {
				bsdsyslog = true;
			}
		}
	}
	if (pri & ~(LOG_FACMASK|LOG_PRIMASK))
		pri = DEFUPRI;

	/*
	 * Don't allow users to log kernel messages.
	 * NOTE: Since LOG_KERN == 0, this will also match
	 *	 messages with no facility specified.
	 */
	if ((pri & LOG_FACMASK) == LOG_KERN)
		pri = LOG_MAKEPRI(LOG_USER, LOG_PRI(pri));

	if (bsdsyslog) {
		buffer = printline_bsdsyslog(hname, p, flags, pri);
	} else {
		buffer = printline_syslogprotocol(hname, p, flags, pri);
	}
	logmsg(buffer);
	DELREF(buffer);
}

/*
 * Take a raw input line from /dev/klog, split and format similar to syslog().
 */
void
printsys(char *msg)
{
	int n, is_printf, pri, flags;
	char *p, *q;
	struct buf_msg *buffer;

	klog_linebufoff = 0;
	for (p = msg; *p != '\0'; ) {
		bool bsdsyslog = true;

		is_printf = 1;
		flags = ISKERNEL | ADDDATE | BSDSYSLOG;
		if (SyncKernel)
			flags |= SYNC_FILE;
		if (is_printf) /* kernel printf's come out on console */
			flags |= IGN_CONS;
		pri = DEFSPRI;

		if (*p == '<') {
			errno = 0;
			n = (int)strtol(p + 1, &q, 10);
			if (*q == '>' && n >= 0 && n < INT_MAX && errno == 0) {
				p = q + 1;
				is_printf = 0;
				pri = n;
				if (*p == '1') { /* syslog-protocol version */
					p += 2;	 /* skip version and space */
					bsdsyslog = false;
				} else {
					bsdsyslog = true;
				}
			}
		}
		for (q = p; *q != '\0' && *q != '\n'; q++)
			/* look for end of line; no further checks.
			 * trust the kernel to send ASCII only */;
		if (*q != '\0')
			*q++ = '\0';
		else {
			memcpy(linebuf, p, klog_linebufoff = q - p);
			break;
		}

		if (pri &~ (LOG_FACMASK|LOG_PRIMASK))
			pri = DEFSPRI;

		/* allow all kinds of input from kernel */
		if (is_printf)
			buffer = printline_kernelprintf(
			    LocalFQDN, p, flags, pri);
		else {
			if (bsdsyslog)
				buffer = printline_bsdsyslog(
				    LocalFQDN, p, flags, pri);
			else
				buffer = printline_syslogprotocol(
				    LocalFQDN, p, flags, pri);
		}

		/* set fields left open */
		if (!buffer->prog)
			buffer->prog = strdup(_PATH_UNIX);
		if (!buffer->host)
			buffer->host = LocalFQDN;
		if (!buffer->recvhost)
			buffer->recvhost = LocalFQDN;

		logmsg(buffer);
		DELREF(buffer);
		p = q;
	}
}

/*
 * Check to see if `name' matches the provided specification, using the
 * specified strstr function.
 */
int
matches_spec(const char *name, const char *spec,
    char *(*check)(const char *, const char *))
{
	const char *s;
	const char *cursor;
	char prev, next;
	size_t len;

	if (name[0] == '\0')
		return 0;

	if (strchr(name, ',')) /* sanity */
		return 0;

	len = strlen(name);
	cursor = spec;
	while ((s = (*check)(cursor, name)) != NULL) {
		prev = s == spec ? ',' : *(s - 1);
		cursor = s + len;
		next = *cursor;

		if (prev == ',' && (next == '\0' || next == ','))
			return 1;
	}

	return 0;
}

/*
 * wrapper with old function signature,
 * keeps calling code shorter and hides buffer allocation
 */
void
logmsg_async(int pri, const char *sd, const char *msg, int flags)
{
	struct buf_msg *buffer;
	size_t msglen;

	DPRINTF((D_CALL|D_DATA), "logmsg_async(%d, \"%s\", \"%s\", %d)\n",
	    pri, sd, msg, flags);

	if (msg) {
		msglen = strlen(msg);
		msglen++;		/* adds \0 */
		buffer = buf_msg_new(msglen);
		buffer->msglen = strlcpy(buffer->msg, msg, msglen) + 1;
	} else {
		buffer = buf_msg_new(0);
	}
	if (sd) buffer->sd = strdup(sd);
	buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0);
	buffer->prog = appname;
	buffer->pid = include_pid;
	buffer->recvhost = buffer->host = LocalFQDN;
	buffer->pri = pri;
	buffer->flags = flags;

	logmsg(buffer);
	DELREF(buffer);
}

/* read timestamp in from_buf, convert into a timestamp in to_buf
 *
 * returns length of timestamp found in from_buf (= number of bytes consumed)
 */
size_t
check_timestamp(unsigned char *from_buf, char **to_buf,
	bool from_iso, bool to_iso)
{
	unsigned char *q;
	int p;
	bool found_ts = false;

	DPRINTF((D_CALL|D_DATA), "check_timestamp(%p = \"%s\", from_iso=%d, "
	    "to_iso=%d)\n", from_buf, from_buf, from_iso, to_iso);

	if (!from_buf) return 0;
	/*
	 * Check to see if msg looks non-standard.
	 * looks at every char because we do not have a msg length yet
	 */
	/* detailed checking adapted from Albert Mietus' sl_timestamp.c */
	if (from_iso) {
		if (from_buf[4] == '-' && from_buf[7] == '-'
		    && from_buf[10] == 'T' && from_buf[13] == ':'
		    && from_buf[16] == ':'
		    && isdigit(from_buf[0]) && isdigit(from_buf[1])
		    && isdigit(from_buf[2]) && isdigit(from_buf[3])  /* YYYY */
		    && isdigit(from_buf[5]) && isdigit(from_buf[6])
		    && isdigit(from_buf[8]) && isdigit(from_buf[9])  /* mm dd */
		    && isdigit(from_buf[11]) && isdigit(from_buf[12]) /* HH */
		    && isdigit(from_buf[14]) && isdigit(from_buf[15]) /* MM */
		    && isdigit(from_buf[17]) && isdigit(from_buf[18]) /* SS */
		    )  {
			/* time-secfrac */
			if (from_buf[19] == '.')
				for (p=20; isdigit(from_buf[p]); p++) /* NOP*/;
			else
				p = 19;
			/* time-offset */
			if (from_buf[p] == 'Z'
			 || ((from_buf[p] == '+' || from_buf[p] == '-')
			    && from_buf[p+3] == ':'
			    && isdigit(from_buf[p+1]) && isdigit(from_buf[p+2])
			    && isdigit(from_buf[p+4]) && isdigit(from_buf[p+5])
			 ))
				found_ts = true;
		}
	} else {
		if (from_buf[3] == ' ' && from_buf[6] == ' '
		    && from_buf[9] == ':' && from_buf[12] == ':'
		    && (from_buf[4] == ' ' || isdigit(from_buf[4]))
		    && isdigit(from_buf[5]) /* dd */
		    && isdigit(from_buf[7])  && isdigit(from_buf[8])   /* HH */
		    && isdigit(from_buf[10]) && isdigit(from_buf[11])  /* MM */
		    && isdigit(from_buf[13]) && isdigit(from_buf[14])  /* SS */
		    && isupper(from_buf[0]) && islower(from_buf[1]) /* month */
		    && islower(from_buf[2]))
			found_ts = true;
	}
	if (!found_ts) {
		if (from_buf[0] == '-' && from_buf[1] == ' ') {
			/* NILVALUE */
			if (to_iso) {
				/* with ISO = syslog-protocol output leave
			 	 * it as is, because it is better to have
			 	 * no timestamp than a wrong one.
			 	 */
				*to_buf = strdup("-");
			} else {
				/* with BSD Syslog the field is reqired
				 * so replace it with current time
				 */
				*to_buf = make_timestamp(NULL, false, 0);
			}
			return 2;
		}
		*to_buf = make_timestamp(NULL, false, 0);
		return 0;
	}

	if (!from_iso && !to_iso) {
		/* copy BSD timestamp */
		DPRINTF(D_CALL, "check_timestamp(): copy BSD timestamp\n");
		*to_buf = strndup((char *)from_buf, BSD_TIMESTAMPLEN);
		return BSD_TIMESTAMPLEN;
	} else if (from_iso && to_iso) {
		/* copy ISO timestamp */
		DPRINTF(D_CALL, "check_timestamp(): copy ISO timestamp\n");
		if (!(q = (unsigned char *) strchr((char *)from_buf, ' ')))
			q = from_buf + strlen((char *)from_buf);
		*to_buf = strndup((char *)from_buf, q - from_buf);
		return q - from_buf;
	} else if (from_iso && !to_iso) {
		/* convert ISO->BSD */
		struct tm parsed;
		time_t timeval;
		char tsbuf[MAX_TIMESTAMPLEN];
		int i = 0, j;

		DPRINTF(D_CALL, "check_timestamp(): convert ISO->BSD\n");
		for(i = 0; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0'
		    && from_buf[i] != '.' && from_buf[i] != ' '; i++)
			tsbuf[i] = from_buf[i]; /* copy date & time */
		j = i;
		for(; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0'
		    && from_buf[i] != '+' && from_buf[i] != '-'
		    && from_buf[i] != 'Z' && from_buf[i] != ' '; i++)
			;			   /* skip fraction digits */
		for(; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0'
		    && from_buf[i] != ':' && from_buf[i] != ' ' ; i++, j++)
			tsbuf[j] = from_buf[i]; /* copy TZ */
		if (from_buf[i] == ':') i++;	/* skip colon */
		for(; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0'
		    && from_buf[i] != ' ' ; i++, j++)
			tsbuf[j] = from_buf[i]; /* copy TZ */

		(void)memset(&parsed, 0, sizeof(parsed));
		(void)strptime(tsbuf, "%FT%T%z", &parsed);
		parsed.tm_isdst = -1;
		timeval = mktime(&parsed);

		*to_buf = make_timestamp(&timeval, false, BSD_TIMESTAMPLEN);
		return i;
	} else if (!from_iso && to_iso) {
		/* convert BSD->ISO */
		struct tm parsed;
		struct tm *current;
		time_t timeval;

		(void)memset(&parsed, 0, sizeof(parsed));
		parsed.tm_isdst = -1;
		DPRINTF(D_CALL, "check_timestamp(): convert BSD->ISO\n");
		strptime((char *)from_buf, "%b %d %T", &parsed);
		current = gmtime(&now);

		/* use current year and timezone */
		parsed.tm_isdst = current->tm_isdst;
		parsed.tm_gmtoff = current->tm_gmtoff;
		parsed.tm_year = current->tm_year;
		if (current->tm_mon == 0 && parsed.tm_mon == 11)
			parsed.tm_year--;

		timeval = mktime(&parsed);
		*to_buf = make_timestamp(&timeval, true, MAX_TIMESTAMPLEN - 1);

		return BSD_TIMESTAMPLEN;
	} else {
		DPRINTF(D_MISC,
			"Executing unreachable code in check_timestamp()\n");
		return 0;
	}
}

/*
 * Log a message to the appropriate log files, users, etc. based on
 * the priority.
 */
void
logmsg(struct buf_msg *buffer)
{
	struct filed *f;
	int fac, omask, prilev;

	DPRINTF((D_CALL|D_BUFFER), "logmsg: buffer@%p, pri 0%o/%d, flags 0x%x,"
	    " timestamp \"%s\", from \"%s\", sd \"%s\", msg \"%s\"\n",
	    buffer, buffer->pri, buffer->pri, buffer->flags,
	    buffer->timestamp, buffer->recvhost, buffer->sd, buffer->msg);

	omask = sigblock(sigmask(SIGHUP)|sigmask(SIGALRM));

	/* sanity check */
	assert(buffer->refcount == 1);
	assert(buffer->msglen <= buffer->msgsize);
	assert(buffer->msgorig <= buffer->msg);
	assert((buffer->msg && buffer->msglen == strlen(buffer->msg)+1)
	      || (!buffer->msg && !buffer->msglen));
	if (!buffer->msg && !buffer->sd && !buffer->msgid)
		DPRINTF(D_BUFFER, "Empty message?\n");

	/* extract facility and priority level */
	if (buffer->flags & MARK)
		fac = LOG_NFACILITIES;
	else
		fac = LOG_FAC(buffer->pri);
	prilev = LOG_PRI(buffer->pri);

	/* log the message to the particular outputs */
	if (!Initialized) {
		f = &consfile;
		f->f_file = open(ctty, O_WRONLY | O_NDELAY, 0);

		if (f->f_file >= 0) {
			DELREF(f->f_prevmsg);
			f->f_prevmsg = NEWREF(buffer);
			fprintlog(f, NEWREF(buffer), NULL);
			DELREF(buffer);
			(void)close(f->f_file);
		}
		(void)sigsetmask(omask);
		return;
	}

	for (f = Files; f; f = f->f_next) {
		char *h;	/* host to use for comparing */

		/* skip messages that are incorrect priority */
		if (!MATCH_PRI(f, fac, prilev)
		    || f->f_pmask[fac] == INTERNAL_NOPRI)
			continue;

		/* skip messages with the incorrect host name */
		/* compare with host (which is supposedly more correct), */
		/* but fallback to recvhost if host is NULL */
		h = (buffer->host != NULL) ? buffer->host : buffer->recvhost;
		if (f->f_host != NULL && h != NULL) {
			char shost[MAXHOSTNAMELEN + 1];

			if (BSDOutputFormat) {
				(void)strlcpy(shost, h, sizeof(shost));
				trim_anydomain(shost);
				h = shost;
			}
			switch (f->f_host[0]) {
			case '+':
				if (! matches_spec(h, f->f_host + 1,
				    strcasestr))
					continue;
				break;
			case '-':
				if (matches_spec(h, f->f_host + 1,
				    strcasestr))
					continue;
				break;
			}
		}

		/* skip messages with the incorrect program name */
		if (f->f_program != NULL && buffer->prog != NULL) {
			switch (f->f_program[0]) {
			case '+':
				if (!matches_spec(buffer->prog,
				    f->f_program + 1, strstr))
					continue;
				break;
			case '-':
				if (matches_spec(buffer->prog,
				    f->f_program + 1, strstr))
					continue;
				break;
			default:
				if (!matches_spec(buffer->prog,
				    f->f_program, strstr))
					continue;
				break;
			}
		}

		if (f->f_type == F_CONSOLE && (buffer->flags & IGN_CONS))
			continue;

		/* don't output marks to recently written files */
		if ((buffer->flags & MARK)
		 && (now - f->f_time) < MarkInterval / 2)
			continue;

		/*
		 * suppress duplicate lines to this file unless NoRepeat
		 */
#define MSG_FIELD_EQ(x) ((!buffer->x && !f->f_prevmsg->x) ||	\
    (buffer->x && f->f_prevmsg->x && !strcmp(buffer->x, f->f_prevmsg->x)))

		if ((buffer->flags & MARK) == 0 &&
		    f->f_prevmsg &&
		    buffer->msglen == f->f_prevmsg->msglen &&
		    !NoRepeat &&
		    MSG_FIELD_EQ(host) &&
		    MSG_FIELD_EQ(sd) &&
		    MSG_FIELD_EQ(msg)
		    ) {
			f->f_prevcount++;
			DPRINTF(D_DATA, "Msg repeated %d times, %ld sec of %d\n",
			    f->f_prevcount, (long)(now - f->f_time),
			    repeatinterval[f->f_repeatcount]);
			/*
			 * If domark would have logged this by now,
			 * flush it now (so we don't hold isolated messages),
			 * but back off so we'll flush less often
			 * in the future.
			 */
			if (now > REPEATTIME(f)) {
				fprintlog(f, NEWREF(buffer), NULL);
				DELREF(buffer);
				BACKOFF(f);
			}
		} else {
			/* new line, save it */
			if (f->f_prevcount)
				fprintlog(f, NULL, NULL);
			f->f_repeatcount = 0;
			DELREF(f->f_prevmsg);
			f->f_prevmsg = NEWREF(buffer);
			fprintlog(f, NEWREF(buffer), NULL);
			DELREF(buffer);
		}
	}
	(void)sigsetmask(omask);
}

/*
 * format one buffer into output format given by flag BSDOutputFormat
 * line is allocated and has to be free()d by caller
 * size_t pointers are optional, if not NULL then they will return
 *   different lenghts used for formatting and output
 */
#define OUT(x) ((x)?(x):"-")
bool
format_buffer(struct buf_msg *buffer, char **line, size_t *ptr_linelen,
	size_t *ptr_msglen, size_t *ptr_tlsprefixlen, size_t *ptr_prilen)
{
#define FPBUFSIZE 30
	static char ascii_empty[] = "";
	char fp_buf[FPBUFSIZE] = "\0";
	char *hostname, *shorthostname = NULL;
	char *ascii_sd = ascii_empty;
	char *ascii_msg = ascii_empty;
	size_t linelen, msglen, tlsprefixlen, prilen, j;

	DPRINTF(D_CALL, "format_buffer(%p)\n", buffer);
	if (!buffer) return false;

	/* All buffer fields are set with strdup(). To avoid problems
	 * on memory exhaustion we allow them to be empty and replace
	 * the essential fields with already allocated generic values.
	 */
	if (!buffer->timestamp)
		buffer->timestamp = timestamp;
	if (!buffer->host && !buffer->recvhost)
		buffer->host = LocalFQDN;

	if (LogFacPri) {
		const char *f_s = NULL, *p_s = NULL;
		int fac = buffer->pri & LOG_FACMASK;
		int pri = LOG_PRI(buffer->pri);
		char f_n[5], p_n[5];

		if (LogFacPri > 1) {
			CODE *c;

			for (c = facilitynames; c->c_name != NULL; c++) {
				if (c->c_val == fac) {
					f_s = c->c_name;
					break;
				}
			}
			for (c = prioritynames; c->c_name != NULL; c++) {
				if (c->c_val == pri) {
					p_s = c->c_name;
					break;
				}
			}
		}
		if (f_s == NULL) {
			snprintf(f_n, sizeof(f_n), "%d", LOG_FAC(fac));
			f_s = f_n;
		}
		if (p_s == NULL) {
			snprintf(p_n, sizeof(p_n), "%d", pri);
			p_s = p_n;
		}
		snprintf(fp_buf, sizeof(fp_buf), "<%s.%s>", f_s, p_s);
	}

	/* hostname or FQDN */
	hostname = (buffer->host ? buffer->host : buffer->recvhost);
	if (BSDOutputFormat
	 && (shorthostname = strdup(hostname))) {
		/* if the previous BSD output format with "host [recvhost]:"
		 * gets implemented, this is the right place to distinguish
		 * between buffer->host and buffer->recvhost
		 */
		trim_anydomain(shorthostname);
		hostname = shorthostname;
	}

	/* new message formatting:
	 * instead of using iov always assemble one complete TLS-ready line
	 * with length and priority (depending on BSDOutputFormat either in
	 * BSD Syslog or syslog-protocol format)
	 *
	 * additionally save the length of the prefixes,
	 * so UDP destinations can skip the length prefix and
	 * file/pipe/wall destinations can omit length and priority
	 */
	/* first determine required space */
	if (BSDOutputFormat) {
		/* only output ASCII chars */
		if (buffer->sd)
			ascii_sd = copy_utf8_ascii(buffer->sd,
				strlen(buffer->sd));
		if (buffer->msg) {
			if (IS_BOM(buffer->msg))
				ascii_msg = copy_utf8_ascii(buffer->msg,
					buffer->msglen - 1);
			else /* assume already converted at input */
				ascii_msg = buffer->msg;
		}
		msglen = snprintf(NULL, 0, "<%d>%s%.15s %s %s%s%s%s: %s%s%s",
			     buffer->pri, fp_buf, buffer->timestamp,
			     hostname, OUT(buffer->prog),
			     buffer->pid ? "[" : "",
			     buffer->pid ? buffer->pid : "",
			     buffer->pid ? "]" : "", ascii_sd,
			     (buffer->sd && buffer->msg ? " ": ""), ascii_msg);
	} else
		msglen = snprintf(NULL, 0, "<%d>1 %s%s %s %s %s %s %s%s%s",
			     buffer->pri, fp_buf, buffer->timestamp,
			     hostname, OUT(buffer->prog), OUT(buffer->pid),
			     OUT(buffer->msgid), OUT(buffer->sd),
			     (buffer->msg ? " ": ""),
			     (buffer->msg ? buffer->msg: ""));
	/* add space for length prefix */
	tlsprefixlen = 0;
	for (j = msglen; j; j /= 10)
		tlsprefixlen++;
	/* one more for the space */
	tlsprefixlen++;

	prilen = snprintf(NULL, 0, "<%d>", buffer->pri);
	if (!BSDOutputFormat)
		prilen += 2; /* version char and space */
	MALLOC(*line, msglen + tlsprefixlen + 1);
	if (BSDOutputFormat)
		linelen = snprintf(*line,
		     msglen + tlsprefixlen + 1,
		     "%zu <%d>%s%.15s %s %s%s%s%s: %s%s%s",
		     msglen, buffer->pri, fp_buf, buffer->timestamp,
		     hostname, OUT(buffer->prog),
		     (buffer->pid ? "[" : ""),
		     (buffer->pid ? buffer->pid : ""),
		     (buffer->pid ? "]" : ""), ascii_sd,
		     (buffer->sd && buffer->msg ? " ": ""), ascii_msg);
	else
		linelen = snprintf(*line,
		     msglen + tlsprefixlen + 1,
		     "%zu <%d>1 %s%s %s %s %s %s %s%s%s",
		     msglen, buffer->pri, fp_buf, buffer->timestamp,
		     hostname, OUT(buffer->prog), OUT(buffer->pid),
		     OUT(buffer->msgid), OUT(buffer->sd),
		     (buffer->msg ? " ": ""),
		     (buffer->msg ? buffer->msg: ""));
	DPRINTF(D_DATA, "formatted %zu octets to: '%.*s' (linelen %zu, "
	    "msglen %zu, tlsprefixlen %zu, prilen %zu)\n", linelen,
	    (int)linelen, *line, linelen, msglen, tlsprefixlen, prilen);

	FREEPTR(shorthostname);
	if (ascii_sd != ascii_empty)
		FREEPTR(ascii_sd);
	if (ascii_msg != ascii_empty && ascii_msg != buffer->msg)
		FREEPTR(ascii_msg);

	if (ptr_linelen)      *ptr_linelen	= linelen;
	if (ptr_msglen)	      *ptr_msglen	= msglen;
	if (ptr_tlsprefixlen) *ptr_tlsprefixlen = tlsprefixlen;
	if (ptr_prilen)	      *ptr_prilen	= prilen;
	return true;
}

/*
 * if qentry == NULL: new message, if temporarily undeliverable it will be enqueued
 * if qentry != NULL: a temporarily undeliverable message will not be enqueued,
 *		    but after delivery be removed from the queue
 */
void
fprintlog(struct filed *f, struct buf_msg *passedbuffer, struct buf_queue *qentry)
{
	static char crnl[] = "\r\n";
	struct buf_msg *buffer = passedbuffer;
	struct iovec iov[4];
	struct iovec *v = iov;
	bool error = false;
	int e = 0, len = 0;
	size_t msglen, linelen, tlsprefixlen, prilen;
	char *p, *line = NULL, *lineptr = NULL;
#ifndef DISABLE_SIGN
	bool newhash = false;
#endif
#define REPBUFSIZE 80
	char greetings[200];
#define ADDEV() do { v++; assert((size_t)(v - iov) < A_CNT(iov)); } while(/*CONSTCOND*/0)

	DPRINTF(D_CALL, "fprintlog(%p, %p, %p)\n", f, buffer, qentry);

	f->f_time = now;

	/* increase refcount here and lower again at return.
	 * this enables the buffer in the else branch to be freed
	 * --> every branch needs one NEWREF() or buf_msg_new()! */
	if (buffer) {
		(void)NEWREF(buffer);
	} else {
		if (f->f_prevcount > 1) {
			/* possible syslog-sign incompatibility:
			 * assume destinations f1 and f2 share one SG and
			 * get the same message sequence.
			 *
			 * now both f1 and f2 generate "repeated" messages
			 * "repeated" messages are different due to different
			 * timestamps
			 * the SG will get hashes for the two "repeated" messages
			 *
			 * now both f1 and f2 are just fine, but a verification
			 * will report that each 'lost' a message, i.e. the
			 * other's "repeated" message
			 *
			 * conditions for 'safe configurations':
			 * - use NoRepeat option,
			 * - use SG 3, or
			 * - have exactly one destination for every PRI
			 */
			buffer = buf_msg_new(REPBUFSIZE);
			buffer->msglen = snprintf(buffer->msg, REPBUFSIZE,
			    "last message repeated %d times", f->f_prevcount);
			buffer->timestamp = make_timestamp(NULL,
			    !BSDOutputFormat, 0);
			buffer->pri = f->f_prevmsg->pri;
			buffer->host = LocalFQDN;
			buffer->prog = appname;
			buffer->pid = include_pid;

		} else {
			buffer = NEWREF(f->f_prevmsg);
		}
	}

	/* no syslog-sign messages to tty/console/... */
	if ((buffer->flags & SIGN_MSG)
	    && ((f->f_type == F_UNUSED)
	    || (f->f_type == F_TTY)
	    || (f->f_type == F_CONSOLE)
	    || (f->f_type == F_USERS)
	    || (f->f_type == F_WALL)
	    || (f->f_type == F_FIFO))) {
		DELREF(buffer);
		return;
	}

	/* buffering works only for few types */
	if (qentry
	    && (f->f_type != F_TLS)
	    && (f->f_type != F_PIPE)
	    && (f->f_type != F_FILE)
	    && (f->f_type != F_FIFO)) {
		errno = 0;
		logerror("Warning: unexpected message type %d in buffer",
		    f->f_type);
		DELREF(buffer);
		return;
	}

	if (!format_buffer(buffer, &line,
	    &linelen, &msglen, &tlsprefixlen, &prilen)) {
		DPRINTF(D_CALL, "format_buffer() failed, skip message\n");
		DELREF(buffer);
		return;
	}
	/* assert maximum message length */
	if (TypeInfo[f->f_type].max_msg_length != -1
	    && (size_t)TypeInfo[f->f_type].max_msg_length
	    < linelen - tlsprefixlen - prilen) {
		linelen = TypeInfo[f->f_type].max_msg_length
		    + tlsprefixlen + prilen;
		DPRINTF(D_DATA, "truncating oversized message to %zu octets\n",
		    linelen);
	}

#ifndef DISABLE_SIGN
	/* keep state between appending the hash (before buffer is sent)
	 * and possibly sending a SB (after buffer is sent): */
	/* get hash */
	if (!(buffer->flags & SIGN_MSG) && !qentry) {
		char *hash = NULL;
		struct signature_group_t *sg;

		if ((sg = sign_get_sg(buffer->pri, f)) != NULL) {
			if (sign_msg_hash(line + tlsprefixlen, &hash))
				newhash = sign_append_hash(hash, sg);
			else
				DPRINTF(D_SIGN,
					"Unable to hash line \"%s\"\n", line);
		}
	}
#endif /* !DISABLE_SIGN */

	/* set start and length of buffer and/or fill iovec */
	switch (f->f_type) {
	case F_UNUSED:
		/* nothing */
		break;
	case F_TLS:
		/* nothing, as TLS uses whole buffer to send */
		lineptr = line;
		len = linelen;
		break;
	case F_FORW:
		lineptr = line + tlsprefixlen;
		len = linelen - tlsprefixlen;
		break;
	case F_PIPE:
	case F_FIFO:
	case F_FILE:  /* fallthrough */
		if (f->f_flags & FFLAG_FULL) {
			v->iov_base = line + tlsprefixlen;
			v->iov_len = linelen - tlsprefixlen;
		} else {
			v->iov_base = line + tlsprefixlen + prilen;
			v->iov_len = linelen - tlsprefixlen - prilen;
		}
		ADDEV();
		v->iov_base = &crnl[1];
		v->iov_len = 1;
		ADDEV();
		break;
	case F_CONSOLE:
	case F_TTY:
		/* filter non-ASCII */
		p = line;
		while (*p) {
			*p = FORCE2ASCII(*p);
			p++;
		}
		v->iov_base = line + tlsprefixlen + prilen;
		v->iov_len = linelen - tlsprefixlen - prilen;
		ADDEV();
		v->iov_base = crnl;
		v->iov_len = 2;
		ADDEV();
		break;
	case F_WALL:
		v->iov_base = greetings;
		v->iov_len = snprintf(greetings, sizeof(greetings),
		    "\r\n\7Message from syslogd@%s at %s ...\r\n",
		    (buffer->host ? buffer->host : buffer->recvhost),
		    buffer->timestamp);
		ADDEV();
	case F_USERS: /* fallthrough */
		/* filter non-ASCII */
		p = line;
		while (*p) {
			*p = FORCE2ASCII(*p);
			p++;
		}
		v->iov_base = line + tlsprefixlen + prilen;
		v->iov_len = linelen - tlsprefixlen - prilen;
		ADDEV();
		v->iov_base = &crnl[1];
		v->iov_len = 1;
		ADDEV();
		break;
	}

	/* send */
	switch (f->f_type) {
	case F_UNUSED:
		DPRINTF(D_MISC, "Logging to %s\n", TypeInfo[f->f_type].name);
		break;

	case F_FORW:
		DPRINTF(D_MISC, "Logging to %s %s\n",
		    TypeInfo[f->f_type].name, f->f_un.f_forw.f_hname);
		udp_send(f, lineptr, len);
		break;

#ifndef DISABLE_TLS
	case F_TLS:
		DPRINTF(D_MISC, "Logging to %s %s\n",
		    TypeInfo[f->f_type].name,
		    f->f_un.f_tls.tls_conn->hostname);
		/* make sure every message gets queued once
		 * it will be removed when sendmsg is sent and free()d */
		if (!qentry)
			qentry = message_queue_add(f, NEWREF(buffer));
		(void)tls_send(f, lineptr, len, qentry);
		break;
#endif /* !DISABLE_TLS */

	case F_PIPE:
		DPRINTF(D_MISC, "Logging to %s %s\n",
		    TypeInfo[f->f_type].name, f->f_un.f_pipe.f_pname);
		if (f->f_un.f_pipe.f_pid == 0) {
			/* (re-)open */
			if ((f->f_file = p_open(f->f_un.f_pipe.f_pname,
			    &f->f_un.f_pipe.f_pid)) < 0) {
				f->f_type = F_UNUSED;
				logerror("%s", f->f_un.f_pipe.f_pname);
				message_queue_freeall(f);
				break;
			} else if (!qentry) /* prevent recursion */
				SEND_QUEUE(f);
		}
		if (writev(f->f_file, iov, v - iov) < 0) {
			e = errno;
			if (f->f_un.f_pipe.f_pid > 0) {
				(void) close(f->f_file);
				deadq_enter(f->f_un.f_pipe.f_pid,
				    f->f_un.f_pipe.f_pname);
			}
			f->f_un.f_pipe.f_pid = 0;
			/*
			 * If the error was EPIPE, then what is likely
			 * has happened is we have a command that is
			 * designed to take a single message line and
			 * then exit, but we tried to feed it another
			 * one before we reaped the child and thus
			 * reset our state.
			 *
			 * Well, now we've reset our state, so try opening
			 * the pipe and sending the message again if EPIPE
			 * was the error.
			 */
			if (e == EPIPE) {
				if ((f->f_file = p_open(f->f_un.f_pipe.f_pname,
				     &f->f_un.f_pipe.f_pid)) < 0) {
					f->f_type = F_UNUSED;
					logerror("%s", f->f_un.f_pipe.f_pname);
					message_queue_freeall(f);
					break;
				}
				if (writev(f->f_file, iov, v - iov) < 0) {
					e = errno;
					if (f->f_un.f_pipe.f_pid > 0) {
					    (void) close(f->f_file);
					    deadq_enter(f->f_un.f_pipe.f_pid,
						f->f_un.f_pipe.f_pname);
					}
					f->f_un.f_pipe.f_pid = 0;
					error = true;	/* enqueue on return */
				} else
					e = 0;
			}
			if (e != 0 && !error) {
				errno = e;
				logerror("%s", f->f_un.f_pipe.f_pname);
			}
		}
		if (e == 0 && qentry) { /* sent buffered msg */
			message_queue_remove(f, qentry);
		}
		break;

	case F_CONSOLE:
		if (buffer->flags & IGN_CONS) {
			DPRINTF(D_MISC, "Logging to %s (ignored)\n",
				TypeInfo[f->f_type].name);
			break;
		}
		/* FALLTHROUGH */

	case F_TTY:
	case F_FILE:
		DPRINTF(D_MISC, "Logging to %s %s\n",
			TypeInfo[f->f_type].name, f->f_un.f_fname);
	again:
		if ((f->f_type == F_FILE ? writev(f->f_file, iov, v - iov) :
		    writev1(f->f_file, iov, v - iov)) < 0) {
			e = errno;
			if (f->f_type == F_FILE && e == ENOSPC) {
				int lasterror = f->f_lasterror;
				f->f_lasterror = e;
				if (lasterror != e)
					logerror("%s", f->f_un.f_fname);
				error = true;	/* enqueue on return */
			}
			(void)close(f->f_file);
			/*
			 * Check for errors on TTY's due to loss of tty
			 */
			if ((e == EIO || e == EBADF) && f->f_type != F_FILE) {
				f->f_file = open(f->f_un.f_fname,
				    O_WRONLY|O_APPEND|O_NONBLOCK, 0);
				if (f->f_file < 0) {
					f->f_type = F_UNUSED;
					logerror("%s", f->f_un.f_fname);
					message_queue_freeall(f);
				} else
					goto again;
			} else {
				f->f_type = F_UNUSED;
				errno = e;
				f->f_lasterror = e;
				logerror("%s", f->f_un.f_fname);
				message_queue_freeall(f);
			}
		} else {
			f->f_lasterror = 0;
			if ((buffer->flags & SYNC_FILE)
			 && (f->f_flags & FFLAG_SYNC))
				(void)fsync(f->f_file);
			/* Problem with files: We cannot check beforehand if
			 * they would be writeable and call send_queue() first.
			 * So we call send_queue() after a successful write,
			 * which means the first message will be out of order.
			 */
			if (!qentry) /* prevent recursion */
				SEND_QUEUE(f);
			else if (qentry) /* sent buffered msg */
				message_queue_remove(f, qentry);
		}
		break;

	case F_FIFO:
		DPRINTF(D_MISC, "Logging to %s %s\n",
			TypeInfo[f->f_type].name, f->f_un.f_fname);
		if (f->f_file < 0) {
			f->f_file =
			  open(f->f_un.f_fname, O_WRONLY|O_NONBLOCK, 0);
			e = errno;
			if (f->f_file < 0 && e == ENXIO) {
				/* Drop messages with no reader */
				if (qentry)
					message_queue_remove(f, qentry);
				break;
			}
		}

		if (f->f_file >= 0 && writev(f->f_file, iov, v - iov) < 0) {
			e = errno;

			/* Enqueue if the fifo buffer is full */
			if (e == EAGAIN) {
				if (f->f_lasterror != e)
					logerror("%s", f->f_un.f_fname);
				f->f_lasterror = e;
				error = true;	/* enqueue on return */
				break;
			}

			close(f->f_file);
			f->f_file = -1;

			/* Drop messages with no reader */
			if (e == EPIPE) {
				if (qentry)
					message_queue_remove(f, qentry);
				break;
			}
		}

		if (f->f_file < 0) {
			f->f_type = F_UNUSED;
			errno = e;
			f->f_lasterror = e;
			logerror("%s", f->f_un.f_fname);
			message_queue_freeall(f);
			break;
		}

		f->f_lasterror = 0;
		if (!qentry) /* prevent recursion (see comment for F_FILE) */
			SEND_QUEUE(f);
		if (qentry) /* sent buffered msg */
			message_queue_remove(f, qentry);
		break;

	case F_USERS:
	case F_WALL:
		DPRINTF(D_MISC, "Logging to %s\n", TypeInfo[f->f_type].name);
		wallmsg(f, iov, v - iov);
		break;
	}
	f->f_prevcount = 0;

	if (error && !qentry)
		message_queue_add(f, NEWREF(buffer));
#ifndef DISABLE_SIGN
	if (newhash) {
		struct signature_group_t *sg;
		sg = sign_get_sg(buffer->pri, f);
		(void)sign_send_signature_block(sg, false);
	}
#endif /* !DISABLE_SIGN */
	/* this belongs to the ad-hoc buffer at the first if(buffer) */
	DELREF(buffer);
	/* TLS frees on its own */
	if (f->f_type != F_TLS)
		FREEPTR(line);
}

/* send one line by UDP */
void
udp_send(struct filed *f, char *line, size_t len)
{
	int lsent, fail, retry, j;
	struct addrinfo *r;

	DPRINTF((D_NET|D_CALL), "udp_send(f=%p, line=\"%s\", "
	    "len=%zu) to dest.\n", f, line, len);

	if (!finet)
		return;

	lsent = -1;
	fail = 0;
	assert(f->f_type == F_FORW);
	for (r = f->f_un.f_forw.f_addr; r; r = r->ai_next) {
		retry = 0;
		for (j = 0; j < finet->fd; j++) {
			if (finet[j+1].af != r->ai_family)
				continue;
sendagain:
			lsent = sendto(finet[j+1].fd, line, len, 0,
			    r->ai_addr, r->ai_addrlen);
			if (lsent == -1) {
				switch (errno) {
				case ENOBUFS:
					/* wait/retry/drop */
					if (++retry < 5) {
						usleep(1000);
						goto sendagain;
					}
					break;
				case EHOSTDOWN:
				case EHOSTUNREACH:
				case ENETDOWN:
					/* drop */
					break;
				default:
					/* busted */
					fail++;
					break;
				}
			} else if ((size_t)lsent == len)
				break;
		}
		if ((size_t)lsent != len && fail) {
			f->f_type = F_UNUSED;
			logerror("sendto() failed");
		}
	}
}

/*
 *  WALLMSG -- Write a message to the world at large
 *
 *	Write the specified message to either the entire
 *	world, or a list of approved users.
 */
void
wallmsg(struct filed *f, struct iovec *iov, size_t iovcnt)
{
#ifdef __NetBSD_Version__
	static int reenter;			/* avoid calling ourselves */
	int i;
	char *p;
	struct utmpentry *ep;

	if (reenter++)
		return;

	(void)getutentries(NULL, &ep);
	/* NOSTRICT */
	for (; ep; ep = ep->next) {
		if (f->f_type == F_WALL) {
			if ((p = ttymsg(iov, iovcnt, ep->line, TTYMSGTIME))
			    != NULL) {
				errno = 0;	/* already in msg */
				logerror("%s", p);
			}
			continue;
		}
		/* should we send the message to this user? */
		for (i = 0; i < MAXUNAMES; i++) {
			if (!f->f_un.f_uname[i][0])
				break;
			if (strcmp(f->f_un.f_uname[i], ep->name) == 0) {
				struct stat st;
				char tty[MAXPATHLEN];
				snprintf(tty, sizeof(tty), "%s/%s", _PATH_DEV,
				    ep->line);
				if (stat(tty, &st) != -1 &&
				    (st.st_mode & S_IWGRP) == 0)
					break;

				if ((p = ttymsg(iov, iovcnt, ep->line,
				    TTYMSGTIME)) != NULL) {
					errno = 0;	/* already in msg */
					logerror("%s", p);
				}
				break;
			}
		}
	}
	reenter = 0;
#endif /* __NetBSD_Version__ */
}

void
/*ARGSUSED*/
reapchild(int fd, short event, void *ev)
{
	int status;
	pid_t pid;
	struct filed *f;

	while ((pid = wait3(&status, WNOHANG, NULL)) > 0) {
		if (!Initialized || ShuttingDown) {
			/*
			 * Be silent while we are initializing or
			 * shutting down.
			 */
			continue;
		}

		if (deadq_remove(pid))
			continue;

		/* Now, look in the list of active processes. */
		for (f = Files; f != NULL; f = f->f_next) {
			if (f->f_type == F_PIPE &&
			    f->f_un.f_pipe.f_pid == pid) {
				(void) close(f->f_file);
				f->f_un.f_pipe.f_pid = 0;
				log_deadchild(pid, status,
				    f->f_un.f_pipe.f_pname);
				break;
			}
		}
	}
}

/*
 * Return a printable representation of a host address (FQDN if available)
 */
const char *
cvthname(struct sockaddr_storage *f)
{
	int error;
	int niflag = NI_DGRAM;
	static char host[NI_MAXHOST], ip[NI_MAXHOST];

	error = getnameinfo((struct sockaddr*)f, ((struct sockaddr*)f)->sa_len,
	    ip, sizeof ip, NULL, 0, NI_NUMERICHOST|niflag);

	DPRINTF(D_CALL, "cvthname(%s)\n", ip);

	if (error) {
		DPRINTF(D_NET, "Malformed from address %s\n",
		    gai_strerror(error));
		return "???";
	}

	if (!UseNameService)
		return ip;

	error = getnameinfo((struct sockaddr*)f, ((struct sockaddr*)f)->sa_len,
	    host, sizeof host, NULL, 0, niflag);
	if (error) {
		DPRINTF(D_NET, "Host name for your address (%s) unknown\n", ip);
		return ip;
	}

	return host;
}

void
trim_anydomain(char *host)
{
	bool onlydigits = true;
	int i;

	if (!BSDOutputFormat)
		return;

	/* if non-digits found, then assume hostname and cut at first dot (this
	 * case also covers IPv6 addresses which should not contain dots),
	 * if only digits then assume IPv4 address and do not cut at all */
	for (i = 0; host[i]; i++) {
		if (host[i] == '.' && !onlydigits)
			host[i] = '\0';
		else if (!isdigit((unsigned char)host[i]) && host[i] != '.')
			onlydigits = false;
	}
}

static void
/*ARGSUSED*/
domark(int fd, short event, void *ev)
{
	struct event *ev_pass = (struct event *)ev;
	struct filed *f;
	dq_t q, nextq;
	sigset_t newmask, omask;

	schedule_event(&ev_pass,
		&((struct timeval){TIMERINTVL, 0}),
		domark, ev_pass);
	DPRINTF((D_CALL|D_EVENT), "domark()\n");

	BLOCK_SIGNALS(omask, newmask);
	now = time(NULL);
	MarkSeq += TIMERINTVL;
	if (MarkSeq >= MarkInterval) {
		logmsg_async(LOG_INFO, NULL, "-- MARK --", ADDDATE|MARK);
		MarkSeq = 0;
	}

	for (f = Files; f; f = f->f_next) {
		if (f->f_prevcount && now >= REPEATTIME(f)) {
			DPRINTF(D_DATA, "Flush %s: repeated %d times, %d sec.\n",
			    TypeInfo[f->f_type].name, f->f_prevcount,
			    repeatinterval[f->f_repeatcount]);
			fprintlog(f, NULL, NULL);
			BACKOFF(f);
		}
	}
	message_allqueues_check();
	RESTORE_SIGNALS(omask);

	/* Walk the dead queue, and see if we should signal somebody. */
	for (q = TAILQ_FIRST(&deadq_head); q != NULL; q = nextq) {
		nextq = TAILQ_NEXT(q, dq_entries);
		switch (q->dq_timeout) {
		case 0:
			/* Already signalled once, try harder now. */
			if (kill(q->dq_pid, SIGKILL) != 0)
				(void) deadq_remove(q->dq_pid);
			break;

		case 1:
			/*
			 * Timed out on the dead queue, send terminate
			 * signal.  Note that we leave the removal from
			 * the dead queue to reapchild(), which will
			 * also log the event (unless the process
			 * didn't even really exist, in case we simply
			 * drop it from the dead queue).
			 */
			if (kill(q->dq_pid, SIGTERM) != 0) {
				(void) deadq_remove(q->dq_pid);
				break;
			}
			/* FALLTHROUGH */

		default:
			q->dq_timeout--;
		}
	}
#ifndef DISABLE_SIGN
	if (GlobalSign.rsid) {	/* check if initialized */
		struct signature_group_t *sg;
		STAILQ_FOREACH(sg, &GlobalSign.SigGroups, entries) {
			sign_send_certificate_block(sg);
		}
	}
#endif /* !DISABLE_SIGN */
}

/*
 * Print syslogd errors some place.
 */
void
logerror(const char *fmt, ...)
{
	static int logerror_running;
	va_list ap;
	char tmpbuf[BUFSIZ];
	char buf[BUFSIZ];
	char *outbuf;

	/* If there's an error while trying to log an error, give up. */
	if (logerror_running)
		return;
	logerror_running = 1;

	va_start(ap, fmt);
	(void)vsnprintf(tmpbuf, sizeof(tmpbuf), fmt, ap);
	va_end(ap);

	if (errno) {
		(void)snprintf(buf, sizeof(buf), "%s: %s",
		    tmpbuf, strerror(errno));
		outbuf = buf;
	} else {
		(void)snprintf(buf, sizeof(buf), "%s", tmpbuf);
		outbuf = tmpbuf;
	}

	if (daemonized)
		logmsg_async(LOG_SYSLOG|LOG_ERR, NULL, outbuf, ADDDATE);
	if (!daemonized && Debug)
		DPRINTF(D_MISC, "%s\n", outbuf);
	if (!daemonized && !Debug)
		printf("%s\n", outbuf);

	logerror_running = 0;
}

/*
 * Print syslogd info some place.
 */
void
loginfo(const char *fmt, ...)
{
	va_list ap;
	char buf[BUFSIZ];

	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof(buf), fmt, ap);
	va_end(ap);

	DPRINTF(D_MISC, "%s\n", buf);
	logmsg_async(LOG_SYSLOG|LOG_INFO, NULL, buf, ADDDATE);
}

#ifndef DISABLE_TLS
static inline void
free_incoming_tls_sockets(void)
{
	struct TLS_Incoming_Conn *tls_in;
	int i;

	/*
	 * close all listening and connected TLS sockets
	 */
	if (TLS_Listen_Set)
		for (i = 0; i < TLS_Listen_Set->fd; i++) {
			if (close(TLS_Listen_Set[i+1].fd) == -1)
				logerror("close() failed");
			DEL_EVENT(TLS_Listen_Set[i+1].ev);
			FREEPTR(TLS_Listen_Set[i+1].ev);
		}
	FREEPTR(TLS_Listen_Set);
	/* close/free incoming TLS connections */
	while (!SLIST_EMPTY(&TLS_Incoming_Head)) {
		tls_in = SLIST_FIRST(&TLS_Incoming_Head);
		SLIST_REMOVE_HEAD(&TLS_Incoming_Head, entries);
		FREEPTR(tls_in->inbuf);
		free_tls_conn(tls_in->tls_conn);
		free(tls_in);
	}
}
#endif /* !DISABLE_TLS */

void
/*ARGSUSED*/
die(int fd, short event, void *ev)
{
	struct filed *f, *next;
	char **p;
	sigset_t newmask, omask;
	int i;
	size_t j;

	ShuttingDown = 1;	/* Don't log SIGCHLDs. */
	/* prevent recursive signals */
	BLOCK_SIGNALS(omask, newmask);

	errno = 0;
	if (ev != NULL)
		logerror("Exiting on signal %d", fd);
	else
		logerror("Fatal error, exiting");

	/*
	 *  flush any pending output
	 */
	for (f = Files; f != NULL; f = f->f_next) {
		/* flush any pending output */
		if (f->f_prevcount)
			fprintlog(f, NULL, NULL);
		SEND_QUEUE(f);
	}

#ifndef DISABLE_TLS
	free_incoming_tls_sockets();
#endif /* !DISABLE_TLS */
#ifndef DISABLE_SIGN
	sign_global_free();
#endif /* !DISABLE_SIGN */

	/*
	 *  Close all open log files.
	 */
	for (f = Files; f != NULL; f = next) {
		message_queue_freeall(f);

		switch (f->f_type) {
		case F_FILE:
		case F_TTY:
		case F_CONSOLE:
		case F_FIFO:
			if (f->f_file >= 0)
				(void)close(f->f_file);
			break;
		case F_PIPE:
			if (f->f_un.f_pipe.f_pid > 0) {
				(void)close(f->f_file);
			}
			f->f_un.f_pipe.f_pid = 0;
			break;
		case F_FORW:
			if (f->f_un.f_forw.f_addr)
				freeaddrinfo(f->f_un.f_forw.f_addr);
			break;
#ifndef DISABLE_TLS
		case F_TLS:
			free_tls_conn(f->f_un.f_tls.tls_conn);
			break;
#endif /* !DISABLE_TLS */
		}
		next = f->f_next;
		DELREF(f->f_prevmsg);
		FREEPTR(f->f_program);
		FREEPTR(f->f_host);
		DEL_EVENT(f->f_sq_event);
		free((char *)f);
	}

	/*
	 *  Close all open UDP sockets
	 */
	if (finet) {
		for (i = 0; i < finet->fd; i++) {
			if (close(finet[i+1].fd) < 0) {
				logerror("close() failed");
				die(0, 0, NULL);
			}
			DEL_EVENT(finet[i+1].ev);
			FREEPTR(finet[i+1].ev);
		}
		FREEPTR(finet);
	}

	/* free config options */
	for (j = 0; j < A_CNT(TypeInfo); j++) {
		FREEPTR(TypeInfo[j].queue_length_string);
		FREEPTR(TypeInfo[j].queue_size_string);
	}

#ifndef DISABLE_TLS
	FREEPTR(tls_opt.CAdir);
	FREEPTR(tls_opt.CAfile);
	FREEPTR(tls_opt.keyfile);
	FREEPTR(tls_opt.certfile);
	FREEPTR(tls_opt.x509verify);
	FREEPTR(tls_opt.bindhost);
	FREEPTR(tls_opt.bindport);
	FREEPTR(tls_opt.server);
	FREEPTR(tls_opt.gen_cert);
	free_cred_SLIST(&tls_opt.cert_head);
	free_cred_SLIST(&tls_opt.fprint_head);
	FREE_SSL_CTX(tls_opt.global_TLS_CTX);
#endif /* !DISABLE_TLS */

	FREEPTR(funix);
	for (p = LogPaths; p && *p; p++)
		unlink(*p);
	exit(0);
}

#ifndef DISABLE_SIGN
/*
 * get one "sign_delim_sg2" item, convert and store in ordered queue
 */
void
store_sign_delim_sg2(char *tmp_buf)
{
	struct string_queue *sqentry, *sqe1, *sqe2;

	if(!(sqentry = malloc(sizeof(*sqentry)))) {
		logerror("Unable to allocate memory");
		return;
	}
	/*LINTED constcond/null effect */
	assert(sizeof(int64_t) == sizeof(uint_fast64_t));
	if (dehumanize_number(tmp_buf, (int64_t*) &(sqentry->key)) == -1
	    || sqentry->key > (LOG_NFACILITIES<<3)) {
		DPRINTF(D_PARSE, "invalid sign_delim_sg2: %s\n", tmp_buf);
		free(sqentry);
		FREEPTR(tmp_buf);
		return;
	}
	sqentry->data = tmp_buf;

	if (STAILQ_EMPTY(&GlobalSign.sig2_delims)) {
		STAILQ_INSERT_HEAD(&GlobalSign.sig2_delims,
		    sqentry, entries);
		return;
	}

	/* keep delimiters sorted */
	sqe1 = sqe2 = STAILQ_FIRST(&GlobalSign.sig2_delims);
	if (sqe1->key > sqentry->key) {
		STAILQ_INSERT_HEAD(&GlobalSign.sig2_delims,
		    sqentry, entries);
		return;
	}

	while ((sqe1 = sqe2)
	   && (sqe2 = STAILQ_NEXT(sqe1, entries))) {
		if (sqe2->key > sqentry->key) {
			break;
		} else if (sqe2->key == sqentry->key) {
			DPRINTF(D_PARSE, "duplicate sign_delim_sg2: %s\n",
			    tmp_buf);
			FREEPTR(sqentry);
			FREEPTR(tmp_buf);
			return;
		}
	}
	STAILQ_INSERT_AFTER(&GlobalSign.sig2_delims, sqe1, sqentry, entries);
}
#endif /* !DISABLE_SIGN */

/*
 * read syslog.conf
 */
void
read_config_file(FILE *cf, struct filed **f_ptr)
{
	size_t linenum = 0;
	size_t i;
	struct filed *f, **nextp;
	char cline[LINE_MAX];
	char prog[NAME_MAX + 1];
	char host[MAXHOSTNAMELEN];
	const char *p;
	char *q;
	bool found_keyword;
#ifndef DISABLE_TLS
	struct peer_cred *cred = NULL;
	struct peer_cred_head *credhead = NULL;
#endif /* !DISABLE_TLS */
#ifndef DISABLE_SIGN
	char *sign_sg_str = NULL;
#endif /* !DISABLE_SIGN */
#if (!defined(DISABLE_TLS) || !defined(DISABLE_SIGN))
	char *tmp_buf = NULL;
#endif /* (!defined(DISABLE_TLS) || !defined(DISABLE_SIGN)) */
	/* central list of recognized configuration keywords
	 * and an address for their values as strings */
	const struct config_keywords {
		const char *keyword;
		char **variable;
	} config_keywords[] = {
#ifndef DISABLE_TLS
		/* TLS settings */
		{"tls_ca",		  &tls_opt.CAfile},
		{"tls_cadir",		  &tls_opt.CAdir},
		{"tls_cert",		  &tls_opt.certfile},
		{"tls_key",		  &tls_opt.keyfile},
		{"tls_verify",		  &tls_opt.x509verify},
		{"tls_bindport",	  &tls_opt.bindport},
		{"tls_bindhost",	  &tls_opt.bindhost},
		{"tls_server",		  &tls_opt.server},
		{"tls_gen_cert",	  &tls_opt.gen_cert},
		/* special cases in parsing */
		{"tls_allow_fingerprints",&tmp_buf},
		{"tls_allow_clientcerts", &tmp_buf},
		/* buffer settings */
		{"tls_queue_length",	  &TypeInfo[F_TLS].queue_length_string},
		{"tls_queue_size",	  &TypeInfo[F_TLS].queue_size_string},
#endif /* !DISABLE_TLS */
		{"file_queue_length",	  &TypeInfo[F_FILE].queue_length_string},
		{"pipe_queue_length",	  &TypeInfo[F_PIPE].queue_length_string},
		{"fifo_queue_length",	  &TypeInfo[F_FIFO].queue_length_string},
		{"file_queue_size",	  &TypeInfo[F_FILE].queue_size_string},
		{"pipe_queue_size",	  &TypeInfo[F_PIPE].queue_size_string},
		{"fifo_queue_size",	  &TypeInfo[F_FIFO].queue_size_string},
#ifndef DISABLE_SIGN
		/* syslog-sign setting */
		{"sign_sg",		  &sign_sg_str},
		/* also special case in parsing */
		{"sign_delim_sg2",	  &tmp_buf},
#endif /* !DISABLE_SIGN */
	};

	DPRINTF(D_CALL, "read_config_file()\n");

	/* free all previous config options */
	for (i = 0; i < A_CNT(TypeInfo); i++) {
		if (TypeInfo[i].queue_length_string
		    && TypeInfo[i].queue_length_string
		    != TypeInfo[i].default_length_string) {
			FREEPTR(TypeInfo[i].queue_length_string);
			TypeInfo[i].queue_length_string =
				strdup(TypeInfo[i].default_length_string);
		 }
		if (TypeInfo[i].queue_size_string
		    && TypeInfo[i].queue_size_string
		    != TypeInfo[i].default_size_string) {
			FREEPTR(TypeInfo[i].queue_size_string);
			TypeInfo[i].queue_size_string =
				strdup(TypeInfo[i].default_size_string);
		 }
	}
	for (i = 0; i < A_CNT(config_keywords); i++)
		FREEPTR(*config_keywords[i].variable);
	/*
	 * global settings
	 */
	while (fgets(cline, sizeof(cline), cf) != NULL) {
		linenum++;
		for (p = cline; isspace((unsigned char)*p); ++p)
			continue;
		if ((*p == '\0') || (*p == '#'))
			continue;

		for (i = 0; i < A_CNT(config_keywords); i++) {
			if (copy_config_value(config_keywords[i].keyword,
			    config_keywords[i].variable, &p, ConfFile,
			    linenum)) {
				DPRINTF((D_PARSE|D_MEM),
				    "found option %s, saved @%p\n",
				    config_keywords[i].keyword,
				    *config_keywords[i].variable);
#ifndef DISABLE_SIGN
				if (!strcmp("sign_delim_sg2",
				    config_keywords[i].keyword))
					do {
						store_sign_delim_sg2(tmp_buf);
					} while (copy_config_value_word(
					    &tmp_buf, &p));

#endif /* !DISABLE_SIGN */

#ifndef DISABLE_TLS
				/* special cases with multiple parameters */
				if (!strcmp("tls_allow_fingerprints",
				    config_keywords[i].keyword))
					credhead = &tls_opt.fprint_head;
				else if (!strcmp("tls_allow_clientcerts",
				    config_keywords[i].keyword))
					credhead = &tls_opt.cert_head;

				if (credhead) do {
					if(!(cred = malloc(sizeof(*cred)))) {
						logerror("Unable to "
							"allocate memory");
						break;
					}
					cred->data = tmp_buf;
					tmp_buf = NULL;
					SLIST_INSERT_HEAD(credhead,
						cred, entries);
				} while /* additional values? */
					(copy_config_value_word(&tmp_buf, &p));
				credhead = NULL;
				break;
#endif /* !DISABLE_TLS */
			}
		}
	}
	/* convert strings to integer values */
	for (i = 0; i < A_CNT(TypeInfo); i++) {
		if (!TypeInfo[i].queue_length_string
		    || dehumanize_number(TypeInfo[i].queue_length_string,
		    &TypeInfo[i].queue_length) == -1)
			if (dehumanize_number(TypeInfo[i].default_length_string,
			    &TypeInfo[i].queue_length) == -1)
				abort();
		if (!TypeInfo[i].queue_size_string
		    || dehumanize_number(TypeInfo[i].queue_size_string,
		    &TypeInfo[i].queue_size) == -1)
			if (dehumanize_number(TypeInfo[i].default_size_string,
			    &TypeInfo[i].queue_size) == -1)
				abort();
	}

#ifndef DISABLE_SIGN
	if (sign_sg_str) {
		if (sign_sg_str[1] == '\0'
		    && (sign_sg_str[0] == '0' || sign_sg_str[0] == '1'
		    || sign_sg_str[0] == '2' || sign_sg_str[0] == '3'))
			GlobalSign.sg = sign_sg_str[0] - '0';
		else {
			GlobalSign.sg = SIGN_SG;
			DPRINTF(D_MISC, "Invalid sign_sg value `%s', "
			    "use default value `%d'\n",
			    sign_sg_str, GlobalSign.sg);
		}
	} else	/* disable syslog-sign */
		GlobalSign.sg = -1;
#endif /* !DISABLE_SIGN */

	rewind(cf);
	linenum = 0;
	/*
	 *  Foreach line in the conf table, open that file.
	 */
	f = NULL;
	nextp = &f;

	strcpy(prog, "*");
	strcpy(host, "*");
	while (fgets(cline, sizeof(cline), cf) != NULL) {
		linenum++;
		found_keyword = false;
		/*
		 * check for end-of-section, comments, strip off trailing
		 * spaces and newline character.  #!prog is treated specially:
		 * following lines apply only to that program.
		 */
		for (p = cline; isspace((unsigned char)*p); ++p)
			continue;
		if (*p == '\0')
			continue;
		if (*p == '#') {
			p++;
			if (*p != '!' && *p != '+' && *p != '-')
				continue;
		}

		for (i = 0; i < A_CNT(config_keywords); i++) {
			if (!strncasecmp(p, config_keywords[i].keyword,
				strlen(config_keywords[i].keyword))) {
				DPRINTF(D_PARSE,
				    "skip cline %zu with keyword %s\n",
				    linenum, config_keywords[i].keyword);
				found_keyword = true;
			}
		}
		if (found_keyword)
			continue;

		if (*p == '+' || *p == '-') {
			host[0] = *p++;
			while (isspace((unsigned char)*p))
				p++;
			if (*p == '\0' || *p == '*') {
				strcpy(host, "*");
				continue;
			}
			/* the +hostname expression will continue
			 * to use the LocalHostName, not the FQDN */
			for (i = 1; i < MAXHOSTNAMELEN - 1; i++) {
				if (*p == '@') {
					(void)strncpy(&host[i], LocalHostName,
					    sizeof(host) - 1 - i);
					host[sizeof(host) - 1] = '\0';
					i = strlen(host) - 1;
					p++;
					continue;
				}
				if (!isalnum((unsigned char)*p) &&
				    *p != '.' && *p != '-' && *p != ',')
					break;
				host[i] = *p++;
			}
			host[i] = '\0';
			continue;
		}
		if (*p == '!') {
			p++;
			while (isspace((unsigned char)*p))
				p++;
			if (*p == '\0' || *p == '*') {
				strcpy(prog, "*");
				continue;
			}
			for (i = 0; i < NAME_MAX; i++) {
				if (!isprint((unsigned char)p[i]))
					break;
				prog[i] = p[i];
			}
			prog[i] = '\0';
			continue;
		}
		for (q = strchr(cline, '\0'); isspace((unsigned char)*--q);)
			continue;
		*++q = '\0';
		if ((f = calloc(1, sizeof(*f))) == NULL) {
			logerror("alloc failed");
			die(0, 0, NULL);
		}
		if (!*f_ptr) *f_ptr = f; /* return first node */
		*nextp = f;
		nextp = &f->f_next;
		cfline(linenum, cline, f, prog, host);
	}
}

/*
 *  INIT -- Initialize syslogd from configuration table
 */
void
/*ARGSUSED*/
init(int fd, short event, void *ev)
{
	FILE *cf;
	int i;
	struct filed *f, *newf, **nextp, *f2;
	char *p;
	sigset_t newmask, omask;
#ifndef DISABLE_TLS
	char *tls_status_msg = NULL;
	struct peer_cred *cred = NULL;
#endif /* !DISABLE_TLS */

	/* prevent recursive signals */
	BLOCK_SIGNALS(omask, newmask);

	DPRINTF((D_EVENT|D_CALL), "init\n");

	/*
	 * be careful about dependencies and order of actions:
	 * 1. flush buffer queues
	 * 2. flush -sign SBs
	 * 3. flush/delete buffer queue again, in case an SB got there
	 * 4. close files/connections
	 */

	/*
	 *  flush any pending output
	 */
	for (f = Files; f != NULL; f = f->f_next) {
		/* flush any pending output */
		if (f->f_prevcount)
			fprintlog(f, NULL, NULL);
		SEND_QUEUE(f);
	}
	/* some actions only on SIGHUP and not on first start */
	if (Initialized) {
#ifndef DISABLE_SIGN
		sign_global_free();
#endif /* !DISABLE_SIGN */
#ifndef DISABLE_TLS
		free_incoming_tls_sockets();
#endif /* !DISABLE_TLS */
		Initialized = 0;
	}
	/*
	 *  Close all open log files.
	 */
	for (f = Files; f != NULL; f = f->f_next) {
		switch (f->f_type) {
		case F_FILE:
		case F_TTY:
		case F_CONSOLE:
			(void)close(f->f_file);
			break;
		case F_PIPE:
			if (f->f_un.f_pipe.f_pid > 0) {
				(void)close(f->f_file);
				deadq_enter(f->f_un.f_pipe.f_pid,
				    f->f_un.f_pipe.f_pname);
			}
			f->f_un.f_pipe.f_pid = 0;
			break;
		case F_FORW:
			if (f->f_un.f_forw.f_addr)
				freeaddrinfo(f->f_un.f_forw.f_addr);
			break;
#ifndef DISABLE_TLS
		case F_TLS:
			free_tls_sslptr(f->f_un.f_tls.tls_conn);
			break;
#endif /* !DISABLE_TLS */
		}
	}

	/*
	 *  Close all open UDP sockets
	 */
	if (finet) {
		for (i = 0; i < finet->fd; i++) {
			if (close(finet[i+1].fd) < 0) {
				logerror("close() failed");
				die(0, 0, NULL);
			}
			DEL_EVENT(finet[i+1].ev);
			FREEPTR(finet[i+1].ev);
		}
		FREEPTR(finet);
	}

	/* get FQDN and hostname/domain */
	FREEPTR(oldLocalFQDN);
	oldLocalFQDN = LocalFQDN;
	LocalFQDN = getLocalFQDN();
	if ((p = strchr(LocalFQDN, '.')) != NULL)
		(void)strlcpy(LocalHostName, LocalFQDN, 1+p-LocalFQDN);
	else
		(void)strlcpy(LocalHostName, LocalFQDN, sizeof(LocalHostName));

	/*
	 *  Reset counter of forwarding actions
	 */

	NumForwards=0;

	/* new destination list to replace Files */
	newf = NULL;
	nextp = &newf;

	/* open the configuration file */
	if ((cf = fopen(ConfFile, "r")) == NULL) {
		DPRINTF(D_FILE, "Cannot open `%s'\n", ConfFile);
		*nextp = (struct filed *)calloc(1, sizeof(*f));
		cfline(0, "*.ERR\t/dev/console", *nextp, "*", "*");
		(*nextp)->f_next = (struct filed *)calloc(1, sizeof(*f));
		cfline(0, "*.PANIC\t*", (*nextp)->f_next, "*", "*");
		Initialized = 1;
		RESTORE_SIGNALS(omask);
		return;
	}

#ifndef DISABLE_TLS
	/* init with new TLS_CTX
	 * as far as I see one cannot change the cert/key of an existing CTX
	 */
	FREE_SSL_CTX(tls_opt.global_TLS_CTX);

	free_cred_SLIST(&tls_opt.cert_head);
	free_cred_SLIST(&tls_opt.fprint_head);
#endif /* !DISABLE_TLS */

	/* read and close configuration file */
	read_config_file(cf, &newf);
	newf = *nextp;
	(void)fclose(cf);
	DPRINTF(D_MISC, "read_config_file() returned newf=%p\n", newf);

#define MOVE_QUEUE(dst, src) do {				\
	struct buf_queue *buf;					\
	STAILQ_CONCAT(&dst->f_qhead, &src->f_qhead);		\
	STAILQ_FOREACH(buf, &dst->f_qhead, entries) {		\
	      dst->f_qelements++;				\
	      dst->f_qsize += buf_queue_obj_size(buf);		\
	}							\
	src->f_qsize = 0;					\
	src->f_qelements = 0;					\
} while (/*CONSTCOND*/0)

	/*
	 *  Free old log files.
	 */
	for (f = Files; f != NULL;) {
		struct filed *ftmp;

		/* check if a new logfile is equal, if so pass the queue */
		for (f2 = newf; f2 != NULL; f2 = f2->f_next) {
			if (f->f_type == f2->f_type
			    && ((f->f_type == F_PIPE
			    && !strcmp(f->f_un.f_pipe.f_pname,
			    f2->f_un.f_pipe.f_pname))
#ifndef DISABLE_TLS
			    || (f->f_type == F_TLS
			    && !strcmp(f->f_un.f_tls.tls_conn->hostname,
			    f2->f_un.f_tls.tls_conn->hostname)
			    && !strcmp(f->f_un.f_tls.tls_conn->port,
			    f2->f_un.f_tls.tls_conn->port))
#endif /* !DISABLE_TLS */
			    || (f->f_type == F_FORW
			    && !strcmp(f->f_un.f_forw.f_hname,
			    f2->f_un.f_forw.f_hname)))) {
				DPRINTF(D_BUFFER, "move queue from f@%p "
				    "to f2@%p\n", f, f2);
				MOVE_QUEUE(f2, f);
			 }
		}
		message_queue_freeall(f);
		DELREF(f->f_prevmsg);
#ifndef DISABLE_TLS
		if (f->f_type == F_TLS)
			free_tls_conn(f->f_un.f_tls.tls_conn);
#endif /* !DISABLE_TLS */
		FREEPTR(f->f_program);
		FREEPTR(f->f_host);
		DEL_EVENT(f->f_sq_event);

		ftmp = f->f_next;
		free((char *)f);
		f = ftmp;
	}
	Files = newf;
	Initialized = 1;

	if (Debug) {
		for (f = Files; f; f = f->f_next) {
			for (i = 0; i <= LOG_NFACILITIES; i++)
				if (f->f_pmask[i] == INTERNAL_NOPRI)
					printf("X ");
				else
					printf("%d ", f->f_pmask[i]);
			printf("%s: ", TypeInfo[f->f_type].name);
			switch (f->f_type) {
			case F_FILE:
			case F_TTY:
			case F_CONSOLE:
			case F_FIFO:
				printf("%s", f->f_un.f_fname);
				break;

			case F_FORW:
				printf("%s", f->f_un.f_forw.f_hname);
				break;
#ifndef DISABLE_TLS
			case F_TLS:
				printf("[%s]", f->f_un.f_tls.tls_conn->hostname);
				break;
#endif /* !DISABLE_TLS */
			case F_PIPE:
				printf("%s", f->f_un.f_pipe.f_pname);
				break;

			case F_USERS:
				for (i = 0;
				    i < MAXUNAMES && *f->f_un.f_uname[i]; i++)
					printf("%s, ", f->f_un.f_uname[i]);
				break;
			}
			if (f->f_program != NULL)
				printf(" (%s)", f->f_program);
			printf("\n");
		}
	}

	finet = socksetup(PF_UNSPEC, bindhostname);
	if (finet) {
		if (SecureMode) {
			for (i = 0; i < finet->fd; i++) {
				if (shutdown(finet[i+1].fd, SHUT_RD) < 0) {
					logerror("shutdown() failed");
					die(0, 0, NULL);
				}
			}
		} else
			DPRINTF(D_NET, "Listening on inet and/or inet6 socket\n");
		DPRINTF(D_NET, "Sending on inet and/or inet6 socket\n");
	}

#ifndef DISABLE_TLS
	/* TLS setup -- after all local destinations opened  */
	DPRINTF(D_PARSE, "Parsed options: tls_ca: %s, tls_cadir: %s, "
	    "tls_cert: %s, tls_key: %s, tls_verify: %s, "
	    "bind: %s:%s, max. queue_lengths: %"
	    PRId64 ", %" PRId64 ", %" PRId64 ", "
	    "max. queue_sizes: %"
	    PRId64 ", %" PRId64 ", %" PRId64 "\n",
	    tls_opt.CAfile, tls_opt.CAdir,
	    tls_opt.certfile, tls_opt.keyfile, tls_opt.x509verify,
	    tls_opt.bindhost, tls_opt.bindport,
	    TypeInfo[F_TLS].queue_length, TypeInfo[F_FILE].queue_length,
	    TypeInfo[F_PIPE].queue_length,
	    TypeInfo[F_TLS].queue_size, TypeInfo[F_FILE].queue_size,
	    TypeInfo[F_PIPE].queue_size);
	SLIST_FOREACH(cred, &tls_opt.cert_head, entries) {
		DPRINTF(D_PARSE, "Accepting peer certificate "
		    "from file: \"%s\"\n", cred->data);
	}
	SLIST_FOREACH(cred, &tls_opt.fprint_head, entries) {
		DPRINTF(D_PARSE, "Accepting peer certificate with "
		    "fingerprint: \"%s\"\n", cred->data);
	}

	/* Note: The order of initialization is important because syslog-sign
	 * should use the TLS cert for signing. -- So we check first if TLS
	 * will be used and initialize it before starting -sign.
	 *
	 * This means that if we are a client without TLS destinations TLS
	 * will not be initialized and syslog-sign will generate a new key.
	 * -- Even if the user has set a usable tls_cert.
	 * Is this the expected behaviour? The alternative would be to always
	 * initialize the TLS structures, even if they will not be needed
	 * (or only needed to read the DSA key for -sign).
	 */

	/* Initialize TLS only if used */
	if (tls_opt.server)
		tls_status_msg = init_global_TLS_CTX();
	else
		for (f = Files; f; f = f->f_next) {
			if (f->f_type != F_TLS)
				continue;
			tls_status_msg = init_global_TLS_CTX();
			break;
		}

#endif /* !DISABLE_TLS */

#ifndef DISABLE_SIGN
	/* only initialize -sign if actually used */
	if (GlobalSign.sg == 0 || GlobalSign.sg == 1 || GlobalSign.sg == 2)
		(void)sign_global_init(Files);
	else if (GlobalSign.sg == 3)
		for (f = Files; f; f = f->f_next)
			if (f->f_flags & FFLAG_SIGN) {
				(void)sign_global_init(Files);
				break;
			}
#endif /* !DISABLE_SIGN */

#ifndef DISABLE_TLS
	if (tls_status_msg) {
		loginfo("%s", tls_status_msg);
		free(tls_status_msg);
	}
	DPRINTF((D_NET|D_TLS), "Preparing sockets for TLS\n");
	TLS_Listen_Set =
		socksetup_tls(PF_UNSPEC, tls_opt.bindhost, tls_opt.bindport);

	for (f = Files; f; f = f->f_next) {
		if (f->f_type != F_TLS)
			continue;
		if (!tls_connect(f->f_un.f_tls.tls_conn)) {
			logerror("Unable to connect to TLS server %s",
			    f->f_un.f_tls.tls_conn->hostname);
			/* Reconnect after x seconds  */
			schedule_event(&f->f_un.f_tls.tls_conn->event,
			    &((struct timeval){TLS_RECONNECT_SEC, 0}),
			    tls_reconnect, f->f_un.f_tls.tls_conn);
		}
	}
#endif /* !DISABLE_TLS */

	loginfo("restart");
	/*
	 * Log a change in hostname, but only on a restart (we detect this
	 * by checking to see if we're passed a kevent).
	 */
	if (oldLocalFQDN && strcmp(oldLocalFQDN, LocalFQDN) != 0)
		loginfo("host name changed, \"%s\" to \"%s\"",
		    oldLocalFQDN, LocalFQDN);

	RESTORE_SIGNALS(omask);
}

/*
 * Crack a configuration file line
 */
void
cfline(size_t linenum, const char *line, struct filed *f, const char *prog,
    const char *host)
{
	struct addrinfo hints, *res;
	int    error, i, pri, syncfile;
	const char   *p, *q;
	char *bp;
	char   buf[MAXLINE];
	struct stat sb;

	DPRINTF((D_CALL|D_PARSE),
		"cfline(%zu, \"%s\", f, \"%s\", \"%s\")\n",
		linenum, line, prog, host);

	errno = 0;	/* keep strerror() stuff out of logerror messages */

	/* clear out file entry */
	memset(f, 0, sizeof(*f));
	for (i = 0; i <= LOG_NFACILITIES; i++)
		f->f_pmask[i] = INTERNAL_NOPRI;
	STAILQ_INIT(&f->f_qhead);

	/*
	 * There should not be any space before the log facility.
	 * Check this is okay, complain and fix if it is not.
	 */
	q = line;
	if (isblank((unsigned char)*line)) {
		errno = 0;
		logerror("Warning: `%s' space or tab before the log facility",
		    line);
		/* Fix: strip all spaces/tabs before the log facility */
		while (*q++ && isblank((unsigned char)*q))
			/* skip blanks */;
		line = q;
	}

	/*
	 * q is now at the first char of the log facility
	 * There should be at least one tab after the log facility
	 * Check this is okay, and complain and fix if it is not.
	 */
	q = line + strlen(line);
	while (!isblank((unsigned char)*q) && (q != line))
		q--;
	if ((q == line) && strlen(line)) {
		/* No tabs or space in a non empty line: complain */
		errno = 0;
		logerror(
		    "Error: `%s' log facility or log target missing",
		    line);
		return;
	}

	/* save host name, if any */
	if (*host == '*')
		f->f_host = NULL;
	else {
		f->f_host = strdup(host);
		trim_anydomain(&f->f_host[1]);	/* skip +/- at beginning */
	}

	/* save program name, if any */
	if (*prog == '*')
		f->f_program = NULL;
	else
		f->f_program = strdup(prog);

	/* scan through the list of selectors */
	for (p = line; *p && !isblank((unsigned char)*p);) {
		int pri_done, pri_cmp, pri_invert;

		/* find the end of this facility name list */
		for (q = p; *q && !isblank((unsigned char)*q) && *q++ != '.'; )
			continue;

		/* get the priority comparison */
		pri_cmp = 0;
		pri_done = 0;
		pri_invert = 0;
		if (*q == '!') {
			pri_invert = 1;
			q++;
		}
		while (! pri_done) {
			switch (*q) {
			case '<':
				pri_cmp = PRI_LT;
				q++;
				break;
			case '=':
				pri_cmp = PRI_EQ;
				q++;
				break;
			case '>':
				pri_cmp = PRI_GT;
				q++;
				break;
			default:
				pri_done = 1;
				break;
			}
		}

		/* collect priority name */
		for (bp = buf; *q && !strchr("\t ,;", *q); )
			*bp++ = *q++;
		*bp = '\0';

		/* skip cruft */
		while (strchr(",;", *q))
			q++;

		/* decode priority name */
		if (*buf == '*') {
			pri = LOG_PRIMASK + 1;
			pri_cmp = PRI_LT | PRI_EQ | PRI_GT;
		} else {
			pri = decode(buf, prioritynames);
			if (pri < 0) {
				errno = 0;
				logerror("Unknown priority name `%s'", buf);
				return;
			}
		}
		if (pri_cmp == 0)
			pri_cmp = UniquePriority ? PRI_EQ
						 : PRI_EQ | PRI_GT;
		if (pri_invert)
			pri_cmp ^= PRI_LT | PRI_EQ | PRI_GT;

		/* scan facilities */
		while (*p && !strchr("\t .;", *p)) {
			for (bp = buf; *p && !strchr("\t ,;.", *p); )
				*bp++ = *p++;
			*bp = '\0';
			if (*buf == '*')
				for (i = 0; i < LOG_NFACILITIES; i++) {
					f->f_pmask[i] = pri;
					f->f_pcmp[i] = pri_cmp;
				}
			else {
				i = decode(buf, facilitynames);
				if (i < 0) {
					errno = 0;
					logerror("Unknown facility name `%s'",
					    buf);
					return;
				}
				f->f_pmask[i >> 3] = pri;
				f->f_pcmp[i >> 3] = pri_cmp;
			}
			while (*p == ',' || *p == ' ')
				p++;
		}

		p = q;
	}

	/* skip to action part */
	while (isblank((unsigned char)*p))
		p++;

	/*
	 * should this be "#ifndef DISABLE_SIGN" or is it a general option?
	 * '+' before file destination: write with PRI field for later
	 * verification
	 */
	if (*p == '+') {
		f->f_flags |= FFLAG_FULL;
		p++;
	}
	if (*p == '-') {
		syncfile = 0;
		p++;
	} else
		syncfile = 1;

	switch (*p) {
	case '@':
#ifndef DISABLE_SIGN
		if (GlobalSign.sg == 3)
			f->f_flags |= FFLAG_SIGN;
#endif /* !DISABLE_SIGN */
#ifndef DISABLE_TLS
		if (*(p+1) == '[') {
			/* TLS destination */
			if (!parse_tls_destination(p, f, linenum)) {
				logerror("Unable to parse action %s", p);
				break;
			}
			f->f_type = F_TLS;
			break;
		}
#endif /* !DISABLE_TLS */
		(void)strlcpy(f->f_un.f_forw.f_hname, ++p,
		    sizeof(f->f_un.f_forw.f_hname));
		memset(&hints, 0, sizeof(hints));
		hints.ai_family = AF_UNSPEC;
		hints.ai_socktype = SOCK_DGRAM;
		hints.ai_protocol = 0;
		error = getaddrinfo(f->f_un.f_forw.f_hname, "syslog", &hints,
		    &res);
		if (error) {
			errno = 0;
			logerror("%s", gai_strerror(error));
			break;
		}
		f->f_un.f_forw.f_addr = res;
		f->f_type = F_FORW;
		NumForwards++;
		break;

	case '/':
#ifndef DISABLE_SIGN
		if (GlobalSign.sg == 3)
			f->f_flags |= FFLAG_SIGN;
#endif /* !DISABLE_SIGN */
		(void)strlcpy(f->f_un.f_fname, p, sizeof(f->f_un.f_fname));
		if ((f->f_file = open(p, O_WRONLY|O_APPEND|O_NONBLOCK, 0)) < 0)
		{
			f->f_type = F_UNUSED;
			logerror("%s", p);
			break;
		}
		if (!fstat(f->f_file, &sb) && S_ISFIFO(sb.st_mode)) {
			f->f_file = -1;
			f->f_type = F_FIFO;
			break;
		}

		if (isatty(f->f_file)) {
			f->f_type = F_TTY;
			if (strcmp(p, ctty) == 0)
				f->f_type = F_CONSOLE;
		} else
			f->f_type = F_FILE;

		if (syncfile)
			f->f_flags |= FFLAG_SYNC;
		break;

	case '|':
#ifndef DISABLE_SIGN
		if (GlobalSign.sg == 3)
			f->f_flags |= FFLAG_SIGN;
#endif
		f->f_un.f_pipe.f_pid = 0;
		(void) strlcpy(f->f_un.f_pipe.f_pname, p + 1,
		    sizeof(f->f_un.f_pipe.f_pname));
		f->f_type = F_PIPE;
		break;

	case '*':
		f->f_type = F_WALL;
		break;

	default:
		for (i = 0; i < MAXUNAMES && *p; i++) {
			for (q = p; *q && *q != ','; )
				q++;
			(void)strncpy(f->f_un.f_uname[i], p, UT_NAMESIZE);
			if ((q - p) > UT_NAMESIZE)
				f->f_un.f_uname[i][UT_NAMESIZE] = '\0';
			else
				f->f_un.f_uname[i][q - p] = '\0';
			while (*q == ',' || *q == ' ')
				q++;
			p = q;
		}
		f->f_type = F_USERS;
		break;
	}
}


/*
 *  Decode a symbolic name to a numeric value
 */
int
decode(const char *name, CODE *codetab)
{
	CODE *c;
	char *p, buf[40];

	if (isdigit((unsigned char)*name))
		return atoi(name);

	for (p = buf; *name && p < &buf[sizeof(buf) - 1]; p++, name++) {
		if (isupper((unsigned char)*name))
			*p = tolower((unsigned char)*name);
		else
			*p = *name;
	}
	*p = '\0';
	for (c = codetab; c->c_name; c++)
		if (!strcmp(buf, c->c_name))
			return c->c_val;

	return -1;
}

/*
 * Retrieve the size of the kernel message buffer, via sysctl.
 */
int
getmsgbufsize(void)
{
#ifdef __NetBSD_Version__
	int msgbufsize, mib[2];
	size_t size;

	mib[0] = CTL_KERN;
	mib[1] = KERN_MSGBUFSIZE;
	size = sizeof msgbufsize;
	if (sysctl(mib, 2, &msgbufsize, &size, NULL, 0) == -1) {
		DPRINTF(D_MISC, "Couldn't get kern.msgbufsize\n");
		return 0;
	}
	return msgbufsize;
#else
	return MAXLINE;
#endif /* __NetBSD_Version__ */
}

/*
 * Retrieve the hostname, via sysctl.
 */
char *
getLocalFQDN(void)
{
	int mib[2];
	char *hostname;
	size_t len;

	mib[0] = CTL_KERN;
	mib[1] = KERN_HOSTNAME;
	sysctl(mib, 2, NULL, &len, NULL, 0);

	if (!(hostname = malloc(len))) {
		logerror("Unable to allocate memory");
		die(0,0,NULL);
	} else if (sysctl(mib, 2, hostname, &len, NULL, 0) == -1) {
		DPRINTF(D_MISC, "Couldn't get kern.hostname\n");
		(void)gethostname(hostname, sizeof(len));
	}
	return hostname;
}

struct socketEvent *
socksetup(int af, const char *hostname)
{
	struct addrinfo hints, *res, *r;
	int error, maxs;
	int on = 1;
	struct socketEvent *s, *socks;

	if(SecureMode && !NumForwards)
		return NULL;

	memset(&hints, 0, sizeof(hints));
	hints.ai_flags = AI_PASSIVE;
	hints.ai_family = af;
	hints.ai_socktype = SOCK_DGRAM;
	error = getaddrinfo(hostname, "syslog", &hints, &res);
	if (error) {
		errno = 0;
		logerror("%s", gai_strerror(error));
		die(0, 0, NULL);
	}

	/* Count max number of sockets we may open */
	for (maxs = 0, r = res; r; r = r->ai_next, maxs++)
		continue;
	socks = calloc(maxs+1, sizeof(*socks));
	if (!socks) {
		logerror("Couldn't allocate memory for sockets");
		die(0, 0, NULL);
	}

	socks->fd = 0;	 /* num of sockets counter at start of array */
	s = socks + 1;
	for (r = res; r; r = r->ai_next) {
		s->fd = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
		if (s->fd < 0) {
			logerror("socket() failed");
			continue;
		}
		s->af = r->ai_family;
		if (r->ai_family == AF_INET6 && setsockopt(s->fd, IPPROTO_IPV6,
		    IPV6_V6ONLY, &on, sizeof(on)) < 0) {
			logerror("setsockopt(IPV6_V6ONLY) failed");
			close(s->fd);
			continue;
		}

		if (!SecureMode) {
			if (bind(s->fd, r->ai_addr, r->ai_addrlen) < 0) {
				logerror("bind() failed");
				close(s->fd);
				continue;
			}
			s->ev = allocev();
			event_set(s->ev, s->fd, EV_READ | EV_PERSIST,
				dispatch_read_finet, s->ev);
			if (event_add(s->ev, NULL) == -1) {
				DPRINTF((D_EVENT|D_NET),
				    "Failure in event_add()\n");
			} else {
				DPRINTF((D_EVENT|D_NET),
				    "Listen on UDP port "
				    "(event@%p)\n", s->ev);
			}
		}

		socks->fd++;  /* num counter */
		s++;
	}

	if (res)
		freeaddrinfo(res);
	if (socks->fd == 0) {
		free (socks);
		if(Debug)
			return NULL;
		else
			die(0, 0, NULL);
	}
	return socks;
}

/*
 * Fairly similar to popen(3), but returns an open descriptor, as opposed
 * to a FILE *.
 */
int
p_open(char *prog, pid_t *rpid)
{
	static char sh[] = "sh", mc[] = "-c";
	int pfd[2], nulldesc, i;
	pid_t pid;
	char *argv[4];	/* sh -c cmd NULL */

	if (pipe(pfd) == -1)
		return -1;
	if ((nulldesc = open(_PATH_DEVNULL, O_RDWR)) == -1) {
		/* We are royally screwed anyway. */
		return -1;
	}

	switch ((pid = fork())) {
	case -1:
		(void) close(nulldesc);
		return -1;

	case 0:
		argv[0] = sh;
		argv[1] = mc;
		argv[2] = prog;
		argv[3] = NULL;

		(void) setsid();	/* avoid catching SIGHUPs. */

		/*
		 * Reset ignored signals to their default behavior.
		 */
		(void)signal(SIGTERM, SIG_DFL);
		(void)signal(SIGINT, SIG_DFL);
		(void)signal(SIGQUIT, SIG_DFL);
		(void)signal(SIGPIPE, SIG_DFL);
		(void)signal(SIGHUP, SIG_DFL);

		dup2(pfd[0], STDIN_FILENO);
		dup2(nulldesc, STDOUT_FILENO);
		dup2(nulldesc, STDERR_FILENO);
		for (i = getdtablesize(); i > 2; i--)
			(void) close(i);

		(void) execvp(_PATH_BSHELL, argv);
		_exit(255);
	}

	(void) close(nulldesc);
	(void) close(pfd[0]);

	/*
	 * Avoid blocking on a hung pipe.  With O_NONBLOCK, we are
	 * supposed to get an EWOULDBLOCK on writev(2), which is
	 * caught by the logic above anyway, which will in turn
	 * close the pipe, and fork a new logging subprocess if
	 * necessary.  The stale subprocess will be killed some
	 * time later unless it terminated itself due to closing
	 * its input pipe.
	 */
	if (fcntl(pfd[1], F_SETFL, O_NONBLOCK) == -1) {
		/* This is bad. */
		logerror("Warning: cannot change pipe to pid %d to "
		    "non-blocking.", (int) pid);
	}
	*rpid = pid;
	return pfd[1];
}

void
deadq_enter(pid_t pid, const char *name)
{
	dq_t p;
	int status;

	/*
	 * Be paranoid: if we can't signal the process, don't enter it
	 * into the dead queue (perhaps it's already dead).  If possible,
	 * we try to fetch and log the child's status.
	 */
	if (kill(pid, 0) != 0) {
		if (waitpid(pid, &status, WNOHANG) > 0)
			log_deadchild(pid, status, name);
		return;
	}

	p = malloc(sizeof(*p));
	if (p == NULL) {
		logerror("panic: out of memory!");
		exit(1);
	}

	p->dq_pid = pid;
	p->dq_timeout = DQ_TIMO_INIT;
	TAILQ_INSERT_TAIL(&deadq_head, p, dq_entries);
}

int
deadq_remove(pid_t pid)
{
	dq_t q;

	for (q = TAILQ_FIRST(&deadq_head); q != NULL;
	     q = TAILQ_NEXT(q, dq_entries)) {
		if (q->dq_pid == pid) {
			TAILQ_REMOVE(&deadq_head, q, dq_entries);
			free(q);
			return 1;
		}
	}
	return 0;
}

void
log_deadchild(pid_t pid, int status, const char *name)
{
	int code;
	char buf[256];
	const char *reason;

	/* Keep strerror() struff out of logerror messages. */
	errno = 0;
	if (WIFSIGNALED(status)) {
		reason = "due to signal";
		code = WTERMSIG(status);
	} else {
		reason = "with status";
		code = WEXITSTATUS(status);
		if (code == 0)
			return;
	}
	(void) snprintf(buf, sizeof(buf),
	    "Logging subprocess %d (%s) exited %s %d.",
	    pid, name, reason, code);
	logerror("%s", buf);
}

struct event *
allocev(void)
{
	struct event *ev;

	if (!(ev = calloc(1, sizeof(*ev))))
		logerror("Unable to allocate memory");
	return ev;
}

/* *ev is allocated if necessary */
void
schedule_event(struct event **ev, struct timeval *tv,
	void (*cb)(int, short, void *), void *arg)
{
	if (!*ev && !(*ev = allocev())) {
		return;
	}
	event_set(*ev, 0, 0, cb, arg);
	DPRINTF(D_EVENT, "event_add(%s@%p)\n", "schedule_ev", *ev); \
	if (event_add(*ev, tv) == -1) {
		DPRINTF(D_EVENT, "Failure in event_add()\n");
	}
}

#ifndef DISABLE_TLS
/* abbreviation for freeing credential lists */
void
free_cred_SLIST(struct peer_cred_head *head)
{
	struct peer_cred *cred;

	while (!SLIST_EMPTY(head)) {
		cred = SLIST_FIRST(head);
		SLIST_REMOVE_HEAD(head, entries);
		FREEPTR(cred->data);
		free(cred);
	}
}
#endif /* !DISABLE_TLS */

/*
 * send message queue after reconnect
 */
/*ARGSUSED*/
void
send_queue(int fd, short event, void *arg)
{
	struct filed *f = (struct filed *) arg;
	struct buf_queue *qentry;
#define SQ_CHUNK_SIZE 250
	size_t cnt = 0;

#ifndef DISABLE_TLS
	if (f->f_type == F_TLS) {
		/* use a flag to prevent recursive calls to send_queue() */
		if (f->f_un.f_tls.tls_conn->send_queue)
			return;
		else
			f->f_un.f_tls.tls_conn->send_queue = true;
	}
	DPRINTF((D_DATA|D_CALL), "send_queue(f@%p with %zu msgs, "
		"cnt@%p = %zu)\n", f, f->f_qelements, &cnt, cnt);
#endif /* !DISABLE_TLS */

	while ((qentry = STAILQ_FIRST(&f->f_qhead))) {
#ifndef DISABLE_TLS
		/* send_queue() might be called with an unconnected destination
		 * from init() or die() or one message might take longer,
		 * leaving the connection in state ST_WAITING and thus not
		 * ready for the next message.
		 * this check is a shortcut to skip these unnecessary calls */
		if (f->f_type == F_TLS
		    && f->f_un.f_tls.tls_conn->state != ST_TLS_EST) {
			DPRINTF(D_TLS, "abort send_queue(cnt@%p = %zu) "
			    "on TLS connection in state %d\n",
			    &cnt, cnt, f->f_un.f_tls.tls_conn->state);
			return;
		 }
#endif /* !DISABLE_TLS */
		fprintlog(f, qentry->msg, qentry);

		/* Sending a long queue can take some time during which
		 * SIGHUP and SIGALRM are blocked and no events are handled.
		 * To avoid that we only send SQ_CHUNK_SIZE messages at once
		 * and then reschedule ourselves to continue. Thus the control
		 * will return first from all signal-protected functions so a
		 * possible SIGHUP/SIGALRM is handled and then back to the
		 * main loop which can handle possible input.
		 */
		if (++cnt >= SQ_CHUNK_SIZE) {
			if (!f->f_sq_event) { /* alloc on demand */
				f->f_sq_event = allocev();
				event_set(f->f_sq_event, 0, 0, send_queue, f);
			}
			if (event_add(f->f_sq_event, &((struct timeval){0, 1})) == -1) {
				DPRINTF(D_EVENT, "Failure in event_add()\n");
			}
			break;
		}
	}
#ifndef DISABLE_TLS
	if (f->f_type == F_TLS)
		f->f_un.f_tls.tls_conn->send_queue = false;
#endif

}

/*
 * finds the next queue element to delete
 *
 * has stateful behaviour, before using it call once with reset = true
 * after that every call will return one next queue elemen to delete,
 * depending on strategy either the oldest or the one with the lowest priority
 */
static struct buf_queue *
find_qentry_to_delete(const struct buf_queue_head *head, int strategy,
    bool reset)
{
	static int pri;
	static struct buf_queue *qentry_static;

	struct buf_queue *qentry_tmp;

	if (reset || STAILQ_EMPTY(head)) {
		pri = LOG_DEBUG;
		qentry_static = STAILQ_FIRST(head);
		return NULL;
	}

	/* find elements to delete */
	if (strategy == PURGE_BY_PRIORITY) {
		qentry_tmp = qentry_static;
		if (!qentry_tmp) return NULL;
		while ((qentry_tmp = STAILQ_NEXT(qentry_tmp, entries)) != NULL)
		{
			if (LOG_PRI(qentry_tmp->msg->pri) == pri) {
				/* save the successor, because qentry_tmp
				 * is probably deleted by the caller */
				qentry_static = STAILQ_NEXT(qentry_tmp, entries);
				return qentry_tmp;
			}
		}
		/* nothing found in while loop --> next pri */
		if (--pri)
			return find_qentry_to_delete(head, strategy, false);
		else
			return NULL;
	} else /* strategy == PURGE_OLDEST or other value */ {
		qentry_tmp = qentry_static;
		qentry_static = STAILQ_NEXT(qentry_tmp, entries);
		return qentry_tmp;  /* is NULL on empty queue */
	}
}

/* note on TAILQ: newest message added at TAIL,
 *		  oldest to be removed is FIRST
 */
/*
 * checks length of a destination's message queue
 * if del_entries == 0 then assert queue length is
 *   less or equal to configured number of queue elements
 * otherwise del_entries tells how many entries to delete
 *
 * returns the number of removed queue elements
 * (which not necessarily means free'd messages)
 *
 * strategy PURGE_OLDEST to delete oldest entry, e.g. after it was resent
 * strategy PURGE_BY_PRIORITY to delete messages with lowest priority first,
 *	this is much slower but might be desirable when unsent messages have
 *	to be deleted, e.g. in call from domark()
 */
size_t
message_queue_purge(struct filed *f, size_t del_entries, int strategy)
{
	size_t removed = 0;
	struct buf_queue *qentry = NULL;

	DPRINTF((D_CALL|D_BUFFER), "purge_message_queue(%p, %zu, %d) with "
	    "f_qelements=%zu and f_qsize=%zu\n",
	    f, del_entries, strategy,
	    f->f_qelements, f->f_qsize);

	/* reset state */
	(void)find_qentry_to_delete(&f->f_qhead, strategy, true);

	while (removed < del_entries
	    || (TypeInfo[f->f_type].queue_length != -1
	    && (size_t)TypeInfo[f->f_type].queue_length <= f->f_qelements)
	    || (TypeInfo[f->f_type].queue_size != -1
	    && (size_t)TypeInfo[f->f_type].queue_size <= f->f_qsize)) {
		qentry = find_qentry_to_delete(&f->f_qhead, strategy, 0);
		if (message_queue_remove(f, qentry))
			removed++;
		else
			break;
	}
	return removed;
}

/* run message_queue_purge() for all destinations to free memory */
size_t
message_allqueues_purge(void)
{
	size_t sum = 0;
	struct filed *f;

	for (f = Files; f; f = f->f_next)
		sum += message_queue_purge(f,
		    f->f_qelements/10, PURGE_BY_PRIORITY);

	DPRINTF(D_BUFFER,
	    "message_allqueues_purge(): removed %zu buffer entries\n", sum);
	return sum;
}

/* run message_queue_purge() for all destinations to check limits */
size_t
message_allqueues_check(void)
{
	size_t sum = 0;
	struct filed *f;

	for (f = Files; f; f = f->f_next)
		sum += message_queue_purge(f, 0, PURGE_BY_PRIORITY);
	DPRINTF(D_BUFFER,
	    "message_allqueues_check(): removed %zu buffer entries\n", sum);
	return sum;
}

struct buf_msg *
buf_msg_new(const size_t len)
{
	struct buf_msg *newbuf;

	CALLOC(newbuf, sizeof(*newbuf));

	if (len) { /* len = 0 is valid */
		MALLOC(newbuf->msg, len);
		newbuf->msgorig = newbuf->msg;
		newbuf->msgsize = len;
	}
	return NEWREF(newbuf);
}

void
buf_msg_free(struct buf_msg *buf)
{
	if (!buf)
		return;

	buf->refcount--;
	if (buf->refcount == 0) {
		FREEPTR(buf->timestamp);
		/* small optimizations: the host/recvhost may point to the
		 * global HostName/FQDN. of course this must not be free()d
		 * same goes for appname and include_pid
		 */
		if (buf->recvhost != buf->host
		    && buf->recvhost != LocalHostName
		    && buf->recvhost != LocalFQDN
		    && buf->recvhost != oldLocalFQDN)
			FREEPTR(buf->recvhost);
		if (buf->host != LocalHostName
		    && buf->host != LocalFQDN
		    && buf->host != oldLocalFQDN)
			FREEPTR(buf->host);
		if (buf->prog != appname)
			FREEPTR(buf->prog);
		if (buf->pid != include_pid)
			FREEPTR(buf->pid);
		FREEPTR(buf->msgid);
		FREEPTR(buf->sd);
		FREEPTR(buf->msgorig);	/* instead of msg */
		FREEPTR(buf);
	}
}

size_t
buf_queue_obj_size(struct buf_queue *qentry)
{
	size_t sum = 0;

	if (!qentry)
		return 0;
	sum += sizeof(*qentry)
	    + sizeof(*qentry->msg)
	    + qentry->msg->msgsize
	    + SAFEstrlen(qentry->msg->timestamp)+1
	    + SAFEstrlen(qentry->msg->msgid)+1;
	if (qentry->msg->prog
	    && qentry->msg->prog != include_pid)
		sum += strlen(qentry->msg->prog)+1;
	if (qentry->msg->pid
	    && qentry->msg->pid != appname)
		sum += strlen(qentry->msg->pid)+1;
	if (qentry->msg->recvhost
	    && qentry->msg->recvhost != LocalHostName
	    && qentry->msg->recvhost != LocalFQDN
	    && qentry->msg->recvhost != oldLocalFQDN)
		sum += strlen(qentry->msg->recvhost)+1;
	if (qentry->msg->host
	    && qentry->msg->host != LocalHostName
	    && qentry->msg->host != LocalFQDN
	    && qentry->msg->host != oldLocalFQDN)
		sum += strlen(qentry->msg->host)+1;

	return sum;
}

bool
message_queue_remove(struct filed *f, struct buf_queue *qentry)
{
	if (!f || !qentry || !qentry->msg)
		return false;

	assert(!STAILQ_EMPTY(&f->f_qhead));
	STAILQ_REMOVE(&f->f_qhead, qentry, buf_queue, entries);
	f->f_qelements--;
	f->f_qsize -= buf_queue_obj_size(qentry);

	DPRINTF(D_BUFFER, "msg @%p removed from queue @%p, new qlen = %zu\n",
	    qentry->msg, f, f->f_qelements);
	DELREF(qentry->msg);
	FREEPTR(qentry);
	return true;
}

/*
 * returns *qentry on success and NULL on error
 */
struct buf_queue *
message_queue_add(struct filed *f, struct buf_msg *buffer)
{
	struct buf_queue *qentry;

	/* check on every call or only every n-th time? */
	message_queue_purge(f, 0, PURGE_BY_PRIORITY);

	while (!(qentry = malloc(sizeof(*qentry)))
	    && message_queue_purge(f, 1, PURGE_OLDEST))
		continue;
	if (!qentry) {
		logerror("Unable to allocate memory");
		DPRINTF(D_BUFFER, "queue empty, no memory, msg dropped\n");
		return NULL;
	} else {
		qentry->msg = buffer;
		f->f_qelements++;
		f->f_qsize += buf_queue_obj_size(qentry);
		STAILQ_INSERT_TAIL(&f->f_qhead, qentry, entries);

		DPRINTF(D_BUFFER, "msg @%p queued @%p, qlen = %zu\n",
		    buffer, f, f->f_qelements);
		return qentry;
	}
}

void
message_queue_freeall(struct filed *f)
{
	struct buf_queue *qentry;

	if (!f) return;
	DPRINTF(D_MEM, "message_queue_freeall(f@%p) with f_qhead@%p\n", f,
	    &f->f_qhead);

	while (!STAILQ_EMPTY(&f->f_qhead)) {
		qentry = STAILQ_FIRST(&f->f_qhead);
		STAILQ_REMOVE(&f->f_qhead, qentry, buf_queue, entries);
		DELREF(qentry->msg);
		FREEPTR(qentry);
	}

	f->f_qelements = 0;
	f->f_qsize = 0;
}

#ifndef DISABLE_TLS
/* utility function for tls_reconnect() */
struct filed *
get_f_by_conninfo(struct tls_conn_settings *conn_info)
{
	struct filed *f;

	for (f = Files; f; f = f->f_next) {
		if ((f->f_type == F_TLS) && f->f_un.f_tls.tls_conn == conn_info)
			return f;
	}
	DPRINTF(D_TLS, "get_f_by_conninfo() called on invalid conn_info\n");
	return NULL;
}

/*
 * Called on signal.
 * Lets the admin reconnect without waiting for the reconnect timer expires.
 */
/*ARGSUSED*/
void
dispatch_force_tls_reconnect(int fd, short event, void *ev)
{
	struct filed *f;
	DPRINTF((D_TLS|D_CALL|D_EVENT), "dispatch_force_tls_reconnect()\n");
	for (f = Files; f; f = f->f_next) {
		if (f->f_type == F_TLS &&
		    f->f_un.f_tls.tls_conn->state == ST_NONE)
			tls_reconnect(fd, event, f->f_un.f_tls.tls_conn);
	}
}
#endif /* !DISABLE_TLS */

/*
 * return a timestamp in a static buffer,
 * either format the timestamp given by parameter in_now
 * or use the current time if in_now is NULL.
 */
char *
make_timestamp(time_t *in_now, bool iso, size_t tlen)
{
	int frac_digits = 6;
	struct timeval tv;
	time_t mytime;
	struct tm ltime;
	int len = 0;
	int tzlen = 0;
	/* uses global var: time_t now; */

	if (in_now) {
		mytime = *in_now;
	} else {
		gettimeofday(&tv, NULL);
		mytime = now = tv.tv_sec;
	}

	if (!iso) {
		strlcpy(timestamp, ctime(&mytime) + 4, sizeof(timestamp));
		timestamp[BSD_TIMESTAMPLEN] = '\0';
	} else {
		localtime_r(&mytime, &ltime);
		len += strftime(timestamp, sizeof(timestamp), "%FT%T", &ltime);
		snprintf(&timestamp[len], frac_digits + 2, ".%.*jd",
		    frac_digits, (intmax_t)tv.tv_usec);
		len += frac_digits + 1;
		tzlen = strftime(&timestamp[len], sizeof(timestamp) - len, "%z",
		    &ltime);
		len += tzlen;

		if (tzlen == 5) {
			/* strftime gives "+0200", but we need "+02:00" */
			timestamp[len + 2] = '\0';
			timestamp[len + 1] = timestamp[len];
			timestamp[len] = timestamp[len - 1];
			timestamp[len - 1] = timestamp[len - 2];
			timestamp[len - 2] = ':';
		}
	}

	switch (tlen) {
	case (size_t)-1:
		return timestamp;
	case 0:
		return strdup(timestamp);
	default:
		return strndup(timestamp, tlen);
	}
}

/* auxillary code to allocate memory and copy a string */
bool
copy_string(char **mem, const char *p, const char *q)
{
	const size_t len = 1 + q - p;
	if (!(*mem = malloc(len))) {
		logerror("Unable to allocate memory for config");
		return false;
	}
	strlcpy(*mem, p, len);
	return true;
}

/* keyword has to end with ",  everything until next " is copied */
bool
copy_config_value_quoted(const char *keyword, char **mem, const char **p)
{
	const char *q;
	if (strncasecmp(*p, keyword, strlen(keyword)))
		return false;
	q = *p += strlen(keyword);
	if (!(q = strchr(*p, '"'))) {
		errno = 0;
		logerror("unterminated \"\n");
		return false;
	}
	if (!(copy_string(mem, *p, q)))
		return false;
	*p = ++q;
	return true;
}

/* for config file:
 * following = required but whitespace allowed, quotes optional
 * if numeric, then conversion to integer and no memory allocation
 */
bool
copy_config_value(const char *keyword, char **mem,
	const char **p, const char *file, int line)
{
	if (strncasecmp(*p, keyword, strlen(keyword)))
		return false;
	*p += strlen(keyword);

	while (isspace((unsigned char)**p))
		*p += 1;
	if (**p != '=') {
		errno = 0;
		logerror("expected \"=\" in file %s, line %d", file, line);
		return false;
	}
	*p += 1;

	return copy_config_value_word(mem, p);
}

/* copy next parameter from a config line */
bool
copy_config_value_word(char **mem, const char **p)
{
	const char *q;
	while (isspace((unsigned char)**p))
		*p += 1;
	if (**p == '"')
		return copy_config_value_quoted("\"", mem, p);

	/* without quotes: find next whitespace or end of line */
	(void)((q = strchr(*p, ' ')) || (q = strchr(*p, '\t'))
	     || (q = strchr(*p, '\n')) || (q = strchr(*p, '\0')));

	if (q-*p == 0 || !(copy_string(mem, *p, q)))
		return false;

	*p = ++q;
	return true;
}

static int
writev1(int fd, struct iovec *iov, size_t count)
{
	ssize_t nw = 0, tot = 0;
	size_t ntries = 5;

	if (count == 0)
		return 0;
	while (ntries--) {
		switch ((nw = writev(fd, iov, count))) {
		case -1:
			if (errno == EAGAIN || errno == EWOULDBLOCK) {
				struct pollfd pfd;
				pfd.fd = fd;
				pfd.events = POLLOUT;
				pfd.revents = 0;
				(void)poll(&pfd, 1, 500);
				continue;
			}
			return -1;
		case 0:
			return 0;
		default:
			tot += nw;
			while (nw > 0) {
				if (iov->iov_len > (size_t)nw) {
					iov->iov_len -= nw;
					iov->iov_base =
					    (char *)iov->iov_base + nw;
					break;
				} else {
					if (--count == 0)
						return tot;
					nw -= iov->iov_len;
					iov++;
				}
			}
		}
	}
	return tot == 0 ? nw : tot;
}

#ifndef NDEBUG
void
dbprintf(const char *fname, const char *funname,
    size_t lnum, const char *fmt, ...)
{
	va_list ap;
	char *ts;

	ts = make_timestamp(NULL, true, (size_t)-1);
	printf("%s:%s:%s:%.4zu\t", ts, fname, funname, lnum);

	va_start(ap, fmt);
	vprintf(fmt, ap);
	va_end(ap);
}
#endif