Home | History | Annotate | Line # | Download | only in syslogd
      1 /*	$NetBSD: syslogd.h,v 1.9 2021/11/27 22:30:26 rillig Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Martin Schtte.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *        This product includes software developed by the NetBSD
     21  *        Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 #ifndef SYSLOGD_H_
     39 #define SYSLOGD_H_
     40 /*
     41  * hold common data structures and prototypes
     42  * for syslogd.c and tls.c
     43  *
     44  */
     45 
     46 #include <sys/cdefs.h>
     47 #define MAXLINE		1024		/* maximum line length */
     48 #define MAXSVLINE	120		/* maximum saved line length */
     49 #define DEFUPRI		(LOG_USER|LOG_NOTICE)
     50 #define DEFSPRI		(LOG_KERN|LOG_NOTICE)
     51 #define TIMERINTVL	30		/* interval for checking flush, mark */
     52 #define TTYMSGTIME	1		/* timeout passed to ttymsg */
     53 
     54 #include <sys/param.h>
     55 #include <sys/socket.h>
     56 #include <sys/sysctl.h>
     57 #include <sys/types.h>
     58 #include <sys/un.h>
     59 #include <sys/wait.h>
     60 #include <sys/queue.h>
     61 #include <netinet/in.h>
     62 #include <sys/event.h>
     63 #include <event.h>
     64 
     65 #include <assert.h>
     66 #include <ctype.h>
     67 #include <errno.h>
     68 #include <fcntl.h>
     69 #include <grp.h>
     70 #include <locale.h>
     71 #include <netdb.h>
     72 #include <pwd.h>
     73 #include <signal.h>
     74 #include <stdarg.h>
     75 #include <stdio.h>
     76 #include <stdlib.h>
     77 #include <string.h>
     78 #include <unistd.h>
     79 #include <stdbool.h>
     80 #include <utmp.h>
     81 #ifdef __NetBSD_Version__
     82 #include <util.h>
     83 #include "utmpentry.h"
     84 #endif /* __NetBSD_Version__ */
     85 #ifdef __FreeBSD_version
     86 #include <libutil.h>
     87 #include <sys/stat.h>
     88 #include <sys/uio.h>
     89 #include <limits.h>
     90 #endif /* __FreeBSD_version */
     91 
     92 #ifndef DISABLE_TLS
     93 #include <netinet/tcp.h>
     94 #include <openssl/ssl.h>
     95 #endif /* !DISABLE_TLS */
     96 
     97 #include <sys/stdint.h>
     98 #include <sys/resource.h>
     99 
    100 #include "pathnames.h"
    101 #include <sys/syslog.h>
    102 
    103 /* some differences between the BSDs  */
    104 #ifdef __FreeBSD_version
    105 #undef _PATH_UNIX
    106 #define _PATH_UNIX "kernel"
    107 #define HAVE_STRNDUP 0
    108 #endif /* __FreeBSD_version */
    109 
    110 #ifdef __NetBSD_Version__
    111 #define HAVE_STRNDUP 1
    112 #define HAVE_DEHUMANIZE_NUMBER 1
    113 #endif /* __NetBSD_Version__ */
    114 
    115 #ifndef HAVE_DEHUMANIZE_NUMBER	/* not in my 4.0-STABLE yet */
    116 extern int dehumanize_number(const char *str, int64_t *size);
    117 #endif /* !HAVE_DEHUMANIZE_NUMBER */
    118 
    119 #if !HAVE_STRNDUP
    120 char *strndup(const char *str, size_t n);
    121 #endif /* !HAVE_STRNDUP */
    122 
    123 #ifdef LIBWRAP
    124 #include <tcpd.h>
    125 #endif
    126 
    127 #define FDMASK(fd)	(1 << (fd))
    128 
    129 #define A_CNT(x)	(sizeof((x)) / sizeof((x)[0]))
    130 
    131 /* debug messages with categories */
    132 #define D_NONE	   0
    133 #define D_CALL	   1	/* function calls */
    134 #define D_DATA	   2	/* syslog message reading/formatting */
    135 #define D_NET	   4	/* sockets/network */
    136 #define D_FILE	   8	/* local files */
    137 #define D_TLS	  16	/* TLS */
    138 #define D_PARSE	  32	/* configuration/parsing */
    139 #define D_EVENT	  64	/* libevent */
    140 #define D_BUFFER 128	/* message queues */
    141 #define D_MEM	 256	/* malloc/free */
    142 #define D_MEM2	1024	/* every single malloc/free */
    143 #define D_SIGN	2048	/* -sign */
    144 #define D_MISC	4096	/* everything else */
    145 #define D_ALL	(D_CALL | D_DATA | D_NET | D_FILE | D_TLS | D_PARSE |  \
    146 		 D_EVENT | D_BUFFER | D_MEM | D_MEM2 | D_SIGN | D_MISC)
    147 #define D_DEFAULT (D_CALL | D_NET | D_FILE | D_TLS | D_MISC)
    148 
    149 
    150 /* build with -DNDEBUG to remove all assert()s and DPRINTF()s */
    151 #ifdef NDEBUG
    152 #define DPRINTF(x, ...) (void)0
    153 #else
    154 void dbprintf(const char *, const char *, size_t, const char *, ...)
    155     __printflike(4, 5);
    156 #define DPRINTF(x, ...) /*LINTED null effect */(void)(Debug & (x) \
    157     ? dbprintf(__FILE__, __func__, __LINE__, __VA_ARGS__) : ((void)0))
    158 #endif
    159 
    160 /* shortcuts for libevent */
    161 #define EVENT_ADD(x) do {						\
    162 	DPRINTF(D_EVENT, "event_add(%s@%p)\n", #x, x);			\
    163 	if (event_add(x, NULL) == -1) {					\
    164 		DPRINTF(D_EVENT, "Failure in event_add()\n");		\
    165 	}								\
    166 } while (0)
    167 #define RETRYEVENT_ADD(x) do {						\
    168 	struct timeval _tv;						\
    169 	_tv.tv_sec = 0;							\
    170 	_tv.tv_usec = TLS_RETRY_EVENT_USEC;				\
    171 	DPRINTF(D_EVENT, "retryevent_add(%s@%p)\n", #x, x);		\
    172 	if (event_add(x, &_tv) == -1) {					\
    173 		DPRINTF(D_EVENT, "Failure in event_add()\n");		\
    174 	}								\
    175 } while (0)
    176 #define DEL_EVENT(x) do {						\
    177 	DPRINTF(D_MEM2, "DEL_EVENT(%s@%p)\n", #x, x);			\
    178 	if ((x) && (event_del(x) == -1)) {				\
    179 		DPRINTF(D_EVENT, "Failure in event_del()\n");		\
    180 	}								\
    181 } while (0)
    182 
    183 /* safe calls to free() */
    184 #define FREEPTR(x)	if (x) {					\
    185 		DPRINTF(D_MEM2, "free(%s@%p)\n", #x, x);		\
    186 		free(x);	 x = NULL; }
    187 #define FREE_SSL(x)	if (x) {					\
    188 		DPRINTF(D_MEM2, "SSL_free(%s@%p)\n", #x, x);		\
    189 		SSL_free(x);	 x = NULL; }
    190 #define FREE_SSL_CTX(x) if (x) {					\
    191 		DPRINTF(D_MEM2, "SSL_CTX_free(%s@%p)\n", #x, x);	\
    192 		SSL_CTX_free(x); x = NULL; }
    193 
    194 /* reference counting macros for buffers */
    195 #define NEWREF(x) ((x) ? (DPRINTF(D_BUFFER, "inc refcount of " #x \
    196 			" @ %p: %zu --> %zu\n", (x), (x)->refcount, \
    197 			(x)->refcount + 1), (x)->refcount++, (x))\
    198 		       : (DPRINTF(D_BUFFER, "inc refcount of NULL!\n"), NULL))
    199 #define DELREF(x) /*LINTED null effect*/(void)((x) ? (DPRINTF(D_BUFFER, "dec refcount of " #x \
    200 			" @ %p: %zu --> %zu\n", (x), (x)->refcount, \
    201 			(x)->refcount - 1), buf_msg_free(x), NULL) \
    202 		       : (DPRINTF(D_BUFFER, "dec refcount of NULL!\n"), NULL))
    203 
    204 /* assumption:
    205  * - malloc()/calloc() only fails if not enough memory available
    206  * - once init() has set up all global variables etc.
    207  *   the bulk of available memory is used for buffers
    208  *   and can be freed if necessary
    209  */
    210 #define MALLOC(ptr, size) do {						\
    211 	while(!(ptr = malloc(size))) {					\
    212 		DPRINTF(D_MEM, "Unable to allocate memory");		\
    213 		message_allqueues_purge();				\
    214 	}								\
    215 	DPRINTF(D_MEM2, "MALLOC(%s@%p, %zu)\n", #ptr, ptr, size);	\
    216 } while (0)
    217 
    218 #define CALLOC(ptr, size) do {						\
    219 	while(!(ptr = calloc(1, size))) {				\
    220 		DPRINTF(D_MEM, "Unable to allocate memory");		\
    221 		message_allqueues_purge();				\
    222 	}								\
    223 	DPRINTF(D_MEM2, "CALLOC(%s@%p, %zu)\n", #ptr, ptr, size);	\
    224 } while (0)
    225 
    226 /* define strlen(NULL) to be 0 */
    227 #define SAFEstrlen(x) ((x) ? strlen(x) : 0)
    228 
    229 /* shorthand to block/restore signals for the duration of one function */
    230 #define BLOCK_SIGNALS(omask, newmask) do {				\
    231 	sigemptyset(&newmask);						\
    232 	sigaddset(&newmask, SIGHUP);					\
    233 	sigaddset(&newmask, SIGALRM);					\
    234 	sigprocmask(SIG_BLOCK, &newmask, &omask);			\
    235 } while (0)
    236 
    237 #define RESTORE_SIGNALS(omask) sigprocmask(SIG_SETMASK, &omask, NULL)
    238 
    239 /* small optimization to call send_queue() only if queue has elements */
    240 #define SEND_QUEUE(f) do {						\
    241 	if ((f)->f_qelements)						\
    242 		send_queue(0, 0, f);	      				\
    243 } while (0)
    244 
    245 #define MAXUNAMES		20	/* maximum number of user names */
    246 #define BSD_TIMESTAMPLEN	(14+1)
    247 #define MAX_TIMESTAMPLEN	(31+1)
    248 
    249 /* maximum field lengths in syslog-protocol */
    250 #define PRI_MAX	      5
    251 #define HOST_MAX    255
    252 #define APPNAME_MAX  48
    253 #define PROCID_MAX  128
    254 #define MSGID_MAX    32
    255 /* longest possible header length */
    256 #define HEADER_LEN_MAX (PRI_MAX + 1 + 1 + MAX_TIMESTAMPLEN + 1 + HOST_MAX \
    257 			+ 1 + APPNAME_MAX + 1 + PROCID_MAX + 1 + MSGID_MAX)
    258 
    259 /* allowed number of priorities by IETF standards */
    260 #define IETF_NUM_PRIVALUES  192
    261 
    262 /* check if message with fac/sev belogs to a destination f */
    263 #define MATCH_PRI(f, fac, sev) \
    264 	   (  (((f)->f_pcmp[fac] & PRI_EQ) && ((f)->f_pmask[fac] == (sev))) \
    265 	    ||(((f)->f_pcmp[fac] & PRI_LT) && ((f)->f_pmask[fac]  < (sev)))  \
    266 	    ||(((f)->f_pcmp[fac] & PRI_GT) && ((f)->f_pmask[fac]  > (sev)))  \
    267 	   )
    268 
    269 /* shorthand to test Byte Order Mark which indicates UTF-8 content */
    270 #define IS_BOM(p) ( \
    271     (p)[0] != '\0' && (unsigned char)(p)[0] == (unsigned char)0xEF && \
    272     (p)[1] != '\0' && (unsigned char)(p)[1] == (unsigned char)0xBB && \
    273     (p)[2] != '\0' && (unsigned char)(p)[2] == (unsigned char)0xBF)
    274 
    275 /* message buffer container used for processing, formatting, and queueing */
    276 struct buf_msg {
    277 	size_t	 refcount;
    278 	int	 pri;
    279 	int	 flags;
    280 	char	*timestamp;
    281 	char	*recvhost;
    282 	char	*host;
    283 	char	*prog;
    284 	char	*pid;
    285 	char	*msgid;
    286 	char	*sd;	    /* structured data */
    287 	char	*msg;	    /* message content */
    288 	char	*msgorig;   /* in case we advance *msg beyond header fields
    289 			       we still want to free() the original ptr  */
    290 	size_t	 msglen;    /* strlen(msg) */
    291 	size_t	 msgsize;   /* allocated memory size   */
    292 	size_t	 tlsprefixlen; /* bytes for the TLS length prefix */
    293 	size_t	 prilen;       /* bytes for priority and version  */
    294 };
    295 
    296 /* queue of messages */
    297 struct buf_queue {
    298 	struct buf_msg* msg;
    299 	STAILQ_ENTRY(buf_queue) entries;
    300 };
    301 STAILQ_HEAD(buf_queue_head, buf_queue);
    302 
    303 /* a pair of a socket and an associated event object */
    304 struct socketEvent {
    305 	int fd;
    306 	int af;
    307 	struct event *ev;
    308 };
    309 
    310 /*
    311  * Flags to logmsg().
    312  */
    313 #define IGN_CONS	0x001	/* don't print on console */
    314 #define SYNC_FILE	0x002	/* do fsync on file after printing */
    315 #define ADDDATE		0x004	/* add a date to the message */
    316 #define MARK		0x008	/* this message is a mark */
    317 #define ISKERNEL	0x010	/* kernel generated message */
    318 #define BSDSYSLOG	0x020	/* line in traditional BSD Syslog format */
    319 #define SIGN_MSG	0x040	/* syslog-sign data, not signed again */
    320 
    321 /* strategies for message_queue_purge() */
    322 #define PURGE_OLDEST		1
    323 #define PURGE_BY_PRIORITY	2
    324 
    325 /*
    326  * This structure represents the files that will have log
    327  * copies printed.
    328  * We require f_file to be valid if f_type is F_FILE, F_CONSOLE, F_TTY,
    329  * or if f_type is F_PIPE and f_pid > 0.
    330  */
    331 
    332 struct filed {
    333 	struct	filed *f_next;		/* next in linked list */
    334 	short	f_type;			/* entry type, see below */
    335 	short	f_file;			/* file descriptor */
    336 	time_t	f_time;			/* time this was last written */
    337 	char	*f_host;		/* host from which to record */
    338 	u_char	f_pmask[LOG_NFACILITIES+1];	/* priority mask */
    339 	u_char	f_pcmp[LOG_NFACILITIES+1];	/* compare priority */
    340 #define PRI_LT	0x1
    341 #define PRI_EQ	0x2
    342 #define PRI_GT	0x4
    343 	char	*f_program;		/* program this applies to */
    344 	union {
    345 		char	f_uname[MAXUNAMES][UT_NAMESIZE+1];
    346 		struct {
    347 			char	f_hname[MAXHOSTNAMELEN];
    348 			struct	addrinfo *f_addr;
    349 		} f_forw;		/* UDP forwarding address */
    350 #ifndef DISABLE_TLS
    351 		struct {
    352 			SSL	*ssl;			/* SSL object  */
    353 			struct tls_conn_settings *tls_conn;  /* certificate info */
    354 		} f_tls;		/* TLS forwarding address */
    355 #endif /* !DISABLE_TLS */
    356 		char	f_fname[MAXPATHLEN];
    357 		struct {
    358 			char	f_pname[MAXPATHLEN];
    359 			pid_t	f_pid;
    360 		} f_pipe;
    361 	} f_un;
    362 #ifndef DISABLE_SIGN
    363 	struct signature_group_t *f_sg;	     /* one signature group */
    364 #endif /* !DISABLE_SIGN */
    365 	struct buf_queue_head f_qhead;	     /* undelivered msgs queue */
    366 	size_t	      	      f_qelements;   /* elements in queue */
    367 	size_t		      f_qsize;	     /* size of queue in bytes */
    368 	struct buf_msg	     *f_prevmsg;     /* last message logged */
    369 	struct event	     *f_sq_event;    /* timer for send_queue() */
    370 	int		      f_prevcount;   /* repetition cnt of prevmsg */
    371 	int		      f_repeatcount; /* number of "repeated" msgs */
    372 	int		      f_lasterror;   /* last error on writev() */
    373 	int		      f_flags;	     /* file-specific flags */
    374 #define FFLAG_SYNC	0x01	/* for F_FILE: fsync after every msg */
    375 #define FFLAG_FULL	0x02	/* for F_FILE | F_PIPE: write PRI header */
    376 #define FFLAG_SIGN	0x04	/* for syslog-sign with SG="3":
    377 				 * sign the messages to this destination */
    378 };
    379 
    380 #ifndef DISABLE_TLS
    381 
    382 /* linked list for allowed TLS peer credentials
    383  * (one for fingerprint, one for cert-files)
    384  */
    385 SLIST_HEAD(peer_cred_head, peer_cred);
    386 struct peer_cred {
    387 	SLIST_ENTRY(peer_cred) entries;
    388 	char *data;
    389 };
    390 
    391 /* config options for TLS server-side */
    392 struct tls_global_options_t {
    393 	SSL_CTX *global_TLS_CTX;
    394 	struct peer_cred_head fprint_head;  /* trusted client fingerprints */
    395 	struct peer_cred_head cert_head;    /* trusted client cert files   */
    396 	char *keyfile;	    /* file with private key	 */
    397 	char *certfile;	    /* file with own certificate */
    398 	char *CAfile;	    /* file with CA certificate	 */
    399 	char *CAdir;	    /* alternative: path to directory with CA certs */
    400 	char *x509verify;   /* level of peer verification */
    401 	char *bindhost;	    /* hostname/IP to bind to	  */
    402 	char *bindport;	    /* port/service to bind to	  */
    403 	char *server;	    /* if !NULL: do not listen to incoming TLS	  */
    404 	char *gen_cert;	    /* if !NULL: generate self-signed certificate */
    405 };
    406 
    407 /* TLS needs three sets of sockets:
    408  * - listening sockets: a fixed size array TLS_Listen_Set, just like finet for UDP.
    409  * - outgoing connections: managed as part of struct filed.
    410  * - incoming connections: variable sized, thus a linked list TLS_Incoming.
    411  */
    412 /* every connection has its own input buffer with status
    413  * variables for message reading */
    414 SLIST_HEAD(TLS_Incoming, TLS_Incoming_Conn);
    415 
    416 struct TLS_Incoming_Conn {
    417 	SLIST_ENTRY(TLS_Incoming_Conn) entries;
    418 	struct tls_conn_settings *tls_conn;
    419 	int socket;
    420 	char *inbuf;		    /* input buffer */
    421 	size_t inbuflen;
    422 	size_t cur_msg_len;	    /* length of current msg */
    423 	size_t cur_msg_start;	    /* beginning of current msg */
    424 	size_t read_pos;	    /* ring buffer position to write to */
    425 	size_t errorcount;	    /* to close faulty connections */
    426 	bool closenow;		    /* close connection as soon as buffer processed */
    427 	bool dontsave;		    /* for receiving oversized messages w/o saving them */
    428 };
    429 
    430 #endif /* !DISABLE_TLS */
    431 
    432 #endif /*SYSLOGD_H_*/
    433