Home | History | Annotate | Line # | Download | only in gen
xsyslog.c revision 1.2 
      1 /*	$NetBSD: xsyslog.c,v 1.2 2017/01/12 01:58:39 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1983, 1988, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 #if defined(LIBC_SCCS) && !defined(lint)
     34 #if 0
     35 static char sccsid[] = "@(#)syslog.c	8.5 (Berkeley) 4/29/95";
     36 #else
     37 __RCSID("$NetBSD: xsyslog.c,v 1.2 2017/01/12 01:58:39 christos Exp $");
     38 #endif
     39 #endif /* LIBC_SCCS and not lint */
     40 
     41 #include "namespace.h"
     42 #include <sys/types.h>
     43 #include <sys/param.h>
     44 #include <sys/socket.h>
     45 #include <sys/syslog.h>
     46 #include <sys/uio.h>
     47 #include <sys/un.h>
     48 
     49 #include <errno.h>
     50 #include <stdio.h>
     51 #include <stdarg.h>
     52 #include <string.h>
     53 #include <fcntl.h>
     54 #include <unistd.h>
     55 #include <stdlib.h>
     56 #include <paths.h>
     57 #include "syslog_private.h"
     58 #include "reentrant.h"
     59 #include "extern.h"
     60 
     61 static void
     62 disconnectlog_r(struct syslog_data *data)
     63 {
     64 	/*
     65 	 * If the user closed the FD and opened another in the same slot,
     66 	 * that's their problem.  They should close it before calling on
     67 	 * system services.
     68 	 */
     69 	if (data->log_file != -1) {
     70 		(void)close(data->log_file);
     71 		data->log_file = -1;
     72 	}
     73 	data->log_connected = 0;		/* retry connect */
     74 }
     75 
     76 static void
     77 connectlog_r(struct syslog_data *data)
     78 {
     79 	/* AF_UNIX address of local logger */
     80 	static const struct sockaddr_un sun = {
     81 		.sun_family = AF_LOCAL,
     82 		.sun_len = sizeof(sun),
     83 		.sun_path = _PATH_LOG,
     84 	};
     85 
     86 	if (data->log_file == -1 || fcntl(data->log_file, F_GETFL, 0) == -1) {
     87 		if ((data->log_file = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC,
     88 		    0)) == -1)
     89 			return;
     90 		data->log_connected = 0;
     91 	}
     92 	if (!data->log_connected) {
     93 		if (connect(data->log_file,
     94 		    (const struct sockaddr *)(const void *)&sun,
     95 		    (socklen_t)sizeof(sun)) == -1) {
     96 			(void)close(data->log_file);
     97 			data->log_file = -1;
     98 		} else
     99 			data->log_connected = 1;
    100 	}
    101 }
    102 
    103 void
    104 _openlog_unlocked_r(const char *ident, int logstat, int logfac,
    105     struct syslog_data *data)
    106 {
    107 	if (ident != NULL)
    108 		data->log_tag = ident;
    109 	data->log_stat = logstat;
    110 	if (logfac != 0 && (logfac &~ LOG_FACMASK) == 0)
    111 		data->log_fac = logfac;
    112 
    113 	if (data->log_stat & LOG_NDELAY)	/* open immediately */
    114 		connectlog_r(data);
    115 
    116 	data->log_opened = 1;
    117 }
    118 
    119 void
    120 _closelog_unlocked_r(struct syslog_data *data)
    121 {
    122 	(void)close(data->log_file);
    123 	data->log_file = -1;
    124 	data->log_connected = 0;
    125 }
    126 
    127 static void
    128 _xsyslogp_r(int pri, struct syslog_fun *fun,
    129     struct syslog_data *data, const char *msgid,
    130     const char *sdfmt, const char *msgfmt, ...)
    131 {
    132 	va_list ap;
    133 	va_start(ap, msgfmt);
    134 	_vxsyslogp_r(pri, fun, data, msgid, sdfmt, msgfmt, ap);
    135 	va_end(ap);
    136 }
    137 
    138 void
    139 _vxsyslogp_r(int pri, struct syslog_fun *fun,
    140     struct syslog_data *data, const char *msgid,
    141     const char *sdfmt, const char *msgfmt, va_list ap)
    142 {
    143 	static const char BRCOSP[] = "]: ";
    144 	static const char CRLF[] = "\r\n";
    145 	size_t cnt, prlen, tries;
    146 	char ch, *p, *t;
    147 	int fd, saved_errno;
    148 #define TBUF_LEN	2048
    149 #define FMT_LEN		1024
    150 #define MAXTRIES	10
    151 	char tbuf[TBUF_LEN], fmt_cpy[FMT_LEN], fmt_cat[FMT_LEN] = "";
    152 	size_t tbuf_left, fmt_left, msgsdlen;
    153 	char *fmt = fmt_cat;
    154 	struct iovec iov[7];	/* prog + [ + pid + ]: + fmt + crlf */
    155 	int opened, iovcnt;
    156 
    157 #define INTERNALLOG	LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
    158 	/* Check for invalid bits. */
    159 	if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) {
    160 		_xsyslogp_r(INTERNALLOG, &_syslog_ss_fun, data, NULL, NULL,
    161 		    "%s: unknown facility/priority: %x", pri);
    162 		pri &= LOG_PRIMASK|LOG_FACMASK;
    163 	}
    164 
    165 	/* Check priority against setlogmask values. */
    166 	if (!(LOG_MASK(LOG_PRI(pri)) & data->log_mask))
    167 		return;
    168 
    169 	saved_errno = errno;
    170 
    171 	/* Set default facility if none specified. */
    172 	if ((pri & LOG_FACMASK) == 0)
    173 		pri |= data->log_fac;
    174 
    175 	/* Build the message. */
    176 	p = tbuf;
    177 	tbuf_left = TBUF_LEN;
    178 
    179 	prlen = snprintf_ss(p, tbuf_left, "<%d>1 ", pri);
    180 	DEC();
    181 
    182 	prlen = (*fun->timefun)(p, tbuf_left);
    183 
    184 	(*fun->lock)(data);
    185 
    186 	if (data->log_hostname[0] == '\0' && gethostname(data->log_hostname,
    187 	    sizeof(data->log_hostname)) == -1) {
    188 		/* can this really happen? */
    189 		data->log_hostname[0] = '-';
    190 		data->log_hostname[1] = '\0';
    191 	}
    192 
    193 	DEC();
    194 	prlen = snprintf_ss(p, tbuf_left, " %s ", data->log_hostname);
    195 
    196 	if (data->log_tag == NULL)
    197 		data->log_tag = getprogname();
    198 
    199 	DEC();
    200 	prlen = snprintf_ss(p, tbuf_left, "%s ",
    201 	    data->log_tag ? data->log_tag : "-");
    202 
    203 	(*fun->unlock)(data);
    204 
    205 	if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
    206 		iovcnt = 0;
    207 		iov[iovcnt].iov_base = p;
    208 		iov[iovcnt].iov_len = prlen - 1;
    209 		iovcnt++;
    210 	}
    211 	DEC();
    212 
    213 	if (data->log_stat & LOG_PID) {
    214 		prlen = snprintf_ss(p, tbuf_left, "%d ", getpid());
    215 		if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
    216 			iov[iovcnt].iov_base = __UNCONST("[");
    217 			iov[iovcnt].iov_len = 1;
    218 			iovcnt++;
    219 			iov[iovcnt].iov_base = p;
    220 			iov[iovcnt].iov_len = prlen - 1;
    221 			iovcnt++;
    222 			iov[iovcnt].iov_base = __UNCONST(BRCOSP);
    223 			iov[iovcnt].iov_len = 3;
    224 			iovcnt++;
    225 		}
    226 	} else {
    227 		prlen = snprintf_ss(p, tbuf_left, "- ");
    228 		if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
    229 			iov[iovcnt].iov_base = __UNCONST(BRCOSP + 1);
    230 			iov[iovcnt].iov_len = 2;
    231 			iovcnt++;
    232 		}
    233 	}
    234 	DEC();
    235 
    236 	/*
    237 	 * concat the format strings, then use one vsnprintf()
    238 	 */
    239 	if (msgid != NULL && *msgid != '\0') {
    240 		strlcat(fmt_cat, msgid, FMT_LEN);
    241 		strlcat(fmt_cat, " ", FMT_LEN);
    242 	} else
    243 		strlcat(fmt_cat, "- ", FMT_LEN);
    244 
    245 	if (sdfmt != NULL && *sdfmt != '\0') {
    246 		strlcat(fmt_cat, sdfmt, FMT_LEN);
    247 	} else
    248 		strlcat(fmt_cat, "-", FMT_LEN);
    249 
    250 	if (data->log_stat & (LOG_PERROR|LOG_CONS))
    251 		msgsdlen = strlen(fmt_cat) + 1;
    252 	else
    253 		msgsdlen = 0;	/* XXX: GCC */
    254 
    255 	if (msgfmt != NULL && *msgfmt != '\0') {
    256 		strlcat(fmt_cat, " ", FMT_LEN);
    257 		strlcat(fmt_cat, msgfmt, FMT_LEN);
    258 	}
    259 
    260 	/*
    261 	 * We wouldn't need this mess if printf handled %m, or if
    262 	 * strerror() had been invented before syslog().
    263 	 */
    264 	for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt) != '\0'; ++fmt) {
    265 		if (ch == '%' && fmt[1] == 'm') {
    266 			char buf[256];
    267 
    268 			if ((*fun->errfun)(saved_errno, buf, sizeof(buf)) != 0)
    269 				prlen = snprintf_ss(t, fmt_left, "Error %d",
    270 				    saved_errno);
    271 			else
    272 				prlen = strlcpy(t, buf, fmt_left);
    273 			if (prlen >= fmt_left)
    274 				prlen = fmt_left - 1;
    275 			t += prlen;
    276 			fmt++;
    277 			fmt_left -= prlen;
    278 		} else if (ch == '%' && fmt[1] == '%' && fmt_left > 2) {
    279 			*t++ = '%';
    280 			*t++ = '%';
    281 			fmt++;
    282 			fmt_left -= 2;
    283 		} else {
    284 			if (fmt_left > 1) {
    285 				*t++ = ch;
    286 				fmt_left--;
    287 			}
    288 		}
    289 	}
    290 	*t = '\0';
    291 
    292 	prlen = (*fun->prfun)(p, tbuf_left, fmt_cpy, ap);
    293 	if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
    294 		iov[iovcnt].iov_base = p + msgsdlen;
    295 		iov[iovcnt].iov_len = prlen - msgsdlen;
    296 		iovcnt++;
    297 	}
    298 
    299 	DEC();
    300 	cnt = p - tbuf;
    301 
    302 	/* Output to stderr if requested. */
    303 	if (data->log_stat & LOG_PERROR) {
    304 		iov[iovcnt].iov_base = __UNCONST(CRLF + 1);
    305 		iov[iovcnt].iov_len = 1;
    306 		(void)writev(STDERR_FILENO, iov, iovcnt + 1);
    307 	}
    308 
    309 	/* Get connected, output the message to the local logger. */
    310 	(*fun->lock)(data);
    311 	opened = !data->log_opened;
    312 	if (opened)
    313 		_openlog_unlocked_r(data->log_tag, data->log_stat, 0, data);
    314 	connectlog_r(data);
    315 
    316 	/*
    317 	 * If the send() failed, there are two likely scenarios:
    318 	 *  1) syslogd was restarted
    319 	 *  2) /dev/log is out of socket buffer space
    320 	 * We attempt to reconnect to /dev/log to take care of
    321 	 * case #1 and keep send()ing data to cover case #2
    322 	 * to give syslogd a chance to empty its socket buffer.
    323 	 */
    324 	for (tries = 0; tries < MAXTRIES; tries++) {
    325 		if (send(data->log_file, tbuf, cnt, 0) != -1)
    326 			break;
    327 		if (errno != ENOBUFS) {
    328 			disconnectlog_r(data);
    329 			connectlog_r(data);
    330 		} else
    331 			(void)usleep(1);
    332 	}
    333 
    334 	/*
    335 	 * Output the message to the console; try not to block
    336 	 * as a blocking console should not stop other processes.
    337 	 * Make sure the error reported is the one from the syslogd failure.
    338 	 */
    339 	if (tries == MAXTRIES && (data->log_stat & LOG_CONS) &&
    340 	    (fd = open(_PATH_CONSOLE,
    341 		O_WRONLY | O_NONBLOCK | O_CLOEXEC, 0)) >= 0) {
    342 		iov[iovcnt].iov_base = __UNCONST(CRLF);
    343 		iov[iovcnt].iov_len = 2;
    344 		(void)writev(fd, iov, iovcnt + 1);
    345 		(void)close(fd);
    346 	}
    347 
    348 	if (!(*fun->unlock)(data) && opened)
    349 		_closelog_unlocked_r(data);
    350 }
    351 
    352 int
    353 setlogmask_r(int pmask, struct syslog_data *data)
    354 {
    355 	int omask;
    356 
    357 	omask = data->log_mask;
    358 	if (pmask != 0)
    359 		data->log_mask = pmask;
    360 	return omask;
    361 }
    362