From f6e17bd6b30397912dcae33842b7aba8d32710a2 Mon Sep 17 00:00:00 2001 From: Joachim Nilsson Date: Fri, 25 Oct 2019 14:25:29 +0200 Subject: [PATCH] Update syslog.c, add syslog.h from NetBSD to get new syslogp() API This patch merges the upstream NetBSD syslog.[ch], which adds syslogp() family of APIs to support RFC5424. This API will first go into use in the logger tool, klogd, and syslog_tst, then it will also be exposed as libsyslog and syslog/syslog.h for end-users. Signed-off-by: Joachim Nilsson --- src/Makefile.am | 2 +- src/compat.h | 72 ++++++ src/syslog.c | 587 ++++++++++++++++++++++++++++++++++-------------- src/syslog.h | 230 +++++++++++++++++++ 4 files changed, 720 insertions(+), 171 deletions(-) create mode 100644 src/compat.h create mode 100644 src/syslog.h diff --git a/src/Makefile.am b/src/Makefile.am index d05003e..613a5a2 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -35,7 +35,7 @@ klogd_CPPFLAGS = -DALLOW_KERNEL_LOGGING -D_BSD_SOURCE -D_DEFAULT_SOURCE klogd_LDADD = $(LIBS) $(LIBOBJS) logger_SOURCES = logger.c syslog.c -logger_CPPFLAGS = -D_XOPEN_SOURCE=600 -D_BSD_SOURCE -D_GNU_SOURCE -D_DEFAULT_SOURCE +logger_CPPFLAGS = -D_XOPEN_SOURCE=600 -D_BSD_SOURCE -D_DEFAULT_SOURCE logger_LDADD = $(LIBS) $(LIBOBJS) tsyslogd_SOURCES = $(syslogd_SOURCES) diff --git a/src/compat.h b/src/compat.h new file mode 100644 index 0000000..fbd1073 --- /dev/null +++ b/src/compat.h @@ -0,0 +1,72 @@ +/* + * Copyright (c) 1983, 1988, 1993 + * 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. + */ + +#ifndef SYSKLOGD_COMPAT_H_ +#define SYSKLOGD_COMPAT_H_ + +#include + +/* + * The following macro is used to remove const cast-away warnings + * from gcc -Wcast-qual; it should be used with caution because it + * can hide valid errors; in particular most valid uses are in + * situations where the API requires it, not to cast away string + * constants. We don't use *intptr_t on purpose here and we are + * explicit about unsigned long so that we don't have additional + * dependencies. + */ +#define __UNCONST(a) ((void *)(unsigned long)(const void *)(a)) + +/* Pthread wrapper for BSD LWP mutexes */ +typedef pthread_mutex_t mutex_t; + +#define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER +#define mutex_lock(m) pthread_mutex_lock(m) +#define mutex_unlock(m) pthread_mutex_unlock(m) + +/* BSD have sa_len, Linux/GNU doesn't */ +#if defined(_AIX) || (defined(BSD) && (BSD >= 199006)) /* sa_len was added with 4.3-Reno */ +#define HAVE_SA_LEN +#endif + +#ifndef strlcpy +size_t strlcpy(char *dst, const char *src, size_t siz); +#endif + +#ifndef strlcat +size_t strlcat(char *dst, const char *src, size_t siz); +#endif + +static inline char *getprogname(void) +{ + extern char *__progname; + return __progname; +} + +#endif /* SYSKLOGD_COMPAT_H_ */ diff --git a/src/syslog.c b/src/syslog.c index f800bad..fcd7f65 100644 --- a/src/syslog.c +++ b/src/syslog.c @@ -30,68 +30,47 @@ */ #if defined(LIBC_SCCS) && !defined(lint) -static char sccsid[] = "@(#)syslog.c 5.28 (Berkeley) 6/27/90"; +#if 0 +static char sccsid[] = "@(#)syslog.c 8.5 (Berkeley) 4/29/95"; +#else +__RCSID("$NetBSD: syslog.c,v 1.55 2015/10/26 11:44:30 roy Exp $"); +#endif #endif /* LIBC_SCCS and not lint */ -/* - * SYSLOG -- print message on log file - * - * This routine looks a lot like printf, except that it outputs to the - * log file instead of the standard output. Also: - * adds a timestamp, - * prints the module name in front of the message, - * has some other formatting types (or will sometime), - * adds a newline on the end of the message. - * - * The output of this routine is intended to be read by syslogd(8). - * - * Author: Eric Allman - * Modified to use UNIX domain IPC by Ralph Campbell - * - * Sat Dec 11 11:58:31 CST 1993: Dr. Wettstein - * Changes to allow compilation with no complains under -Wall. - * - * Thu Jan 18 11:16:11 CST 1996: Dr. Wettstein - * Added patch to close potential security hole. This is the same - * patch which was announced in the linux-security mailing lists - * and incorporated into the libc version of syslog.c. - * - * Sun Mar 11 20:23:44 CET 2001: Martin Schulze - * Use SOCK_DGRAM for loggin, renables it to work. - * - * Wed Aug 27 17:48:16 CEST 2003: Martin Schulze - * Improved patch by Michael Pomraning to - * reconnect klogd to the logger after it went away. - */ +#include +#include +#include +#include +#include +#include +#include #include #include -#include #include #include #include +#include #include -#include -#include -#include -#include -#include -#include #include #include -#define _PATH_LOGNAME "/dev/log" +#include "syslog.h" +#include "compat.h" -#ifndef TESTING -static struct sockaddr SyslogAddr; /* AF_UNIX address of local logger */ -#endif -static int LogFile = -1; /* fd for log */ -static int connected; /* have done connect */ -static int LogStat = 0; /* status bits, set by openlog() */ -static const char *LogTag = "syslog"; /* string to tag the entry with */ -static int LogFacility = LOG_USER; /* default facility code */ +static struct syslog_data sdata = SYSLOG_DATA_INIT; -/* wrapper for GLIBC, which provides this for security measures */ +static void openlog_unlocked_r(const char *, int, int, + struct syslog_data *); +static void disconnectlog_r(struct syslog_data *); +static void connectlog_r(struct syslog_data *); + +static mutex_t syslog_mutex = MUTEX_INITIALIZER; + +/* + * wrapper to catch GLIBC syslog(), which provides this for security measures + * Note: we only enter here if user includes GLIBC syslog.h + */ void __syslog_chk(int pri, int flag __attribute__((unused)), const char *fmt, ...) { va_list ap; @@ -101,7 +80,12 @@ void __syslog_chk(int pri, int flag __attribute__((unused)), const char *fmt, .. va_end(ap); } -void syslog(int pri, const char *fmt, ...) +/* + * syslog, vsyslog -- + * print message on log file; output is intended for syslogd(8). + */ +void +syslog(int pri, const char *fmt, ...) { va_list ap; @@ -110,166 +94,429 @@ void syslog(int pri, const char *fmt, ...) va_end(ap); } -void vsyslog(int pri, const char *fmt, va_list ap) +void +vsyslog(int pri, const char *fmt, va_list ap) { - int cnt; - char * p; + vsyslog_r(pri, &sdata, fmt, ap); +} + +/* + * syslogp, vsyslogp -- + * like syslog but take additional arguments for MSGID and SD + */ +void +syslogp(int pri, const char *msgid, const char *sdfmt, const char *msgfmt, ...) +{ + va_list ap; + + va_start(ap, msgfmt); + vsyslogp(pri, msgid, sdfmt, msgfmt, ap); + va_end(ap); +} + +void +vsyslogp(int pri, const char *msgid, const char *sdfmt, const char *msgfmt, va_list ap) +{ + vsyslogp_r(pri, &sdata, msgid, sdfmt, msgfmt, ap); +} + +void +openlog(const char *ident, int logstat, int logfac) +{ + openlog_r(ident, logstat, logfac, &sdata); +} + +void +closelog(void) +{ + closelog_r(&sdata); +} + +/* setlogmask -- set the log mask level */ +int +setlogmask(int pmask) +{ + return setlogmask_r(pmask, &sdata); +} + +/* Reentrant version of syslog, i.e. syslog_r() */ + +void +syslog_r(int pri, struct syslog_data *data, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + vsyslog_r(pri, data, fmt, ap); + va_end(ap); +} + +void +syslogp_r(int pri, struct syslog_data *data, const char *msgid, + const char *sdfmt, const char *msgfmt, ...) +{ + va_list ap; + + va_start(ap, msgfmt); + vsyslogp_r(pri, data, msgid, sdfmt, msgfmt, ap); + va_end(ap); +} + +void +vsyslog_r(int pri, struct syslog_data *data, const char *fmt, va_list ap) +{ + vsyslogp_r(pri, data, NULL, NULL, fmt, ap); +} + +void +vsyslogp_r(int pri, struct syslog_data *data, const char *msgid, + const char *sdfmt, const char *msgfmt, va_list ap) +{ + static const char BRCOSP[] = "]: "; + static const char CRLF[] = "\r\n"; + size_t cnt, prlen, tries; + char ch, *p, *t; + struct timeval tv; + struct tm tmnow; time_t now; - int fd, saved_errno; - int result; - char tbuf[2048], fmt_cpy[1024], *stdp = NULL; + int fd, saved_errno; +#define TBUF_LEN 2048 +#define FMT_LEN 1024 +#define MAXTRIES 10 + char tbuf[TBUF_LEN], fmt_cpy[FMT_LEN], fmt_cat[FMT_LEN] = ""; + size_t tbuf_left, fmt_left, msgsdlen; + char *fmt = fmt_cat; + struct iovec iov[7]; /* prog + [ + pid + ]: + fmt + crlf */ + int opened, iovcnt; + +#define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID + /* Check for invalid bits. */ + if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { + syslog_r(INTERNALLOG, data, + "syslog_r: unknown facility/priority: %x", pri); + pri &= LOG_PRIMASK|LOG_FACMASK; + } + + /* Check priority against setlogmask values. */ + if (!(LOG_MASK(LOG_PRI(pri)) & data->log_mask)) + return; saved_errno = errno; - /* see if we should just throw out this message */ - if (!LOG_MASK(LOG_PRI(pri)) || (pri & ~(LOG_PRIMASK | LOG_FACMASK))) - return; - if (LogFile < 0 || !connected) - openlog(LogTag, LogStat | LOG_NDELAY, LogFacility); - - /* set default facility if none specified */ + /* Set default facility if none specified. */ if ((pri & LOG_FACMASK) == 0) - pri |= LogFacility; + pri |= data->log_fac; - /* build the message */ - (void)time(&now); - (void)sprintf(tbuf, "<%d>%.15s ", pri, ctime(&now) + 4); - for (p = tbuf; *p; ++p) - ; - if (LogStat & LOG_PERROR) - stdp = p; - if (LogTag) { - (void)strcpy(p, LogTag); - for (; *p; ++p) - ; - } - if (LogStat & LOG_PID) { - (void)sprintf(p, "[%d]", getpid()); - for (; *p; ++p) - ; - } - if (LogTag) { - *p++ = ':'; - *p++ = ' '; + /* Build the message. */ + p = tbuf; + tbuf_left = TBUF_LEN; + +#define DEC() \ + do { \ + if (prlen >= tbuf_left) \ + prlen = tbuf_left - 1; \ + p += prlen; \ + tbuf_left -= prlen; \ + } while (/*CONSTCOND*/0) + + prlen = snprintf(p, tbuf_left, "<%d>1 ", pri); + DEC(); + + if (gettimeofday(&tv, NULL) != -1) { + /* strftime() implies tzset(), localtime_r() doesn't. */ + tzset(); + now = (time_t) tv.tv_sec; + localtime_r(&now, &tmnow); + + prlen = strftime(p, tbuf_left, "%FT%T", &tmnow); + DEC(); + prlen = snprintf(p, tbuf_left, ".%06ld", (long)tv.tv_usec); + DEC(); + prlen = strftime(p, tbuf_left-1, "%z", &tmnow); + /* strftime gives eg. "+0200", but we need "+02:00" */ + if (prlen == 5) { + p[prlen+1] = p[prlen]; + p[prlen] = p[prlen-1]; + p[prlen-1] = p[prlen-2]; + p[prlen-2] = ':'; + prlen += 1; + } } - /* substitute error message for %m */ - { - char ch, *t1, *t2; - char *strerror(); + if (data == &sdata) + mutex_lock(&syslog_mutex); - for (t1 = fmt_cpy; - (ch = *fmt) != '\0' && t1 < fmt_cpy + sizeof(fmt_cpy); - ++fmt) - if (ch == '%' && fmt[1] == 'm') { - ++fmt; - for (t2 = strerror(saved_errno); - (*t1 = *t2++); ++t1) - ; - } else - *t1++ = ch; - *t1 = '\0'; + if (data->log_hostname[0] == '\0' && gethostname(data->log_hostname, + sizeof(data->log_hostname)) == -1) { + /* can this really happen? */ + data->log_hostname[0] = '-'; + data->log_hostname[1] = '\0'; } - (void)vsprintf(p, fmt_cpy, ap); + DEC(); + prlen = snprintf(p, tbuf_left, " %s ", data->log_hostname); - cnt = strlen(tbuf); + if (data->log_tag == NULL) + data->log_tag = getprogname(); - /* output to stderr if requested */ - if (LogStat & LOG_PERROR) { - struct iovec iov[2]; - struct iovec *v = iov; + DEC(); + prlen = snprintf(p, tbuf_left, "%s ", + data->log_tag ? data->log_tag : "-"); - v->iov_base = stdp; - v->iov_len = cnt - (stdp - tbuf); - ++v; - v->iov_base = "\n"; - v->iov_len = 1; - (void)writev(2, iov, 2); + if (data == &sdata) + mutex_unlock(&syslog_mutex); + + if (data->log_stat & (LOG_PERROR|LOG_CONS)) { + iovcnt = 0; + iov[iovcnt].iov_base = p; + iov[iovcnt].iov_len = prlen - 1; + iovcnt++; } + DEC(); - /* output the message to the local logger */ - result = write(LogFile, tbuf, cnt + 1); - - if (result == -1 && (errno == ECONNRESET || errno == ENOTCONN || errno == ECONNREFUSED)) { - closelog(); - openlog(LogTag, LogStat | LOG_NDELAY, LogFacility); - result = write(LogFile, tbuf, cnt + 1); + if (data->log_stat & LOG_PID) { + prlen = snprintf(p, tbuf_left, "%d ", getpid()); + if (data->log_stat & (LOG_PERROR|LOG_CONS)) { + iov[iovcnt].iov_base = __UNCONST("["); + iov[iovcnt].iov_len = 1; + iovcnt++; + iov[iovcnt].iov_base = p; + iov[iovcnt].iov_len = prlen - 1; + iovcnt++; + iov[iovcnt].iov_base = __UNCONST(BRCOSP); + iov[iovcnt].iov_len = 3; + iovcnt++; + } + } else { + prlen = snprintf(p, tbuf_left, "- "); + if (data->log_stat & (LOG_PERROR|LOG_CONS)) { + iov[iovcnt].iov_base = __UNCONST(BRCOSP + 1); + iov[iovcnt].iov_len = 2; + iovcnt++; + } } - - if (result >= 0 || !(LogStat & LOG_CONS)) - return; + DEC(); /* - * output the message to the console; don't worry about - * blocking, if console blocks everything will. + * concat the format strings, then use one vsnprintf() */ - if ((fd = open(_PATH_CONSOLE, O_WRONLY | O_NOCTTY, 0)) < 0) - return; - (void)strcat(tbuf, "\r\n"); - cnt += 2; - p = index(tbuf, '>') + 1; - (void)write(fd, p, cnt - (p - tbuf)); - (void)close(fd); + if (msgid != NULL && *msgid != '\0') { + strlcat(fmt_cat, msgid, FMT_LEN); + strlcat(fmt_cat, " ", FMT_LEN); + } else + strlcat(fmt_cat, "- ", FMT_LEN); + + if (sdfmt != NULL && *sdfmt != '\0') { + strlcat(fmt_cat, sdfmt, FMT_LEN); + } else + strlcat(fmt_cat, "-", FMT_LEN); + + if (data->log_stat & (LOG_PERROR|LOG_CONS)) + msgsdlen = strlen(fmt_cat) + 1; + else + msgsdlen = 0; /* XXX: GCC */ + + if (msgfmt != NULL && *msgfmt != '\0') { + strlcat(fmt_cat, " ", FMT_LEN); + strlcat(fmt_cat, msgfmt, FMT_LEN); + } + + /* + * We wouldn't need this mess if printf handled %m, or if + * strerror() had been invented before syslog(). + */ + for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt) != '\0'; ++fmt) { + if (ch == '%' && fmt[1] == 'm') { + const char *s; + + if ((s = strerror(saved_errno)) == NULL) + prlen = snprintf(t, fmt_left, "Error %d", + saved_errno); + else + prlen = strlcpy(t, s, fmt_left); + if (prlen >= fmt_left) + prlen = fmt_left - 1; + t += prlen; + fmt++; + fmt_left -= prlen; + } else if (ch == '%' && fmt[1] == '%' && fmt_left > 2) { + *t++ = '%'; + *t++ = '%'; + fmt++; + fmt_left -= 2; + } else { + if (fmt_left > 1) { + *t++ = ch; + fmt_left--; + } + } + } + *t = '\0'; + + prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap); + + if (data->log_stat & (LOG_PERROR|LOG_CONS)) { + iov[iovcnt].iov_base = p + msgsdlen; + iov[iovcnt].iov_len = prlen - msgsdlen; + iovcnt++; + } + + DEC(); + cnt = p - tbuf; + + /* Output to stderr if requested. */ + if (data->log_stat & LOG_PERROR) { + iov[iovcnt].iov_base = __UNCONST(CRLF + 1); + iov[iovcnt].iov_len = 1; + (void)writev(STDERR_FILENO, iov, iovcnt + 1); + } + + /* Get connected, output the message to the local logger. */ + if (data == &sdata) + mutex_lock(&syslog_mutex); + opened = !data->log_opened; + if (opened) + openlog_unlocked_r(data->log_tag, data->log_stat, 0, data); + connectlog_r(data); + + /* + * If the send() failed, there are two likely scenarios: + * 1) syslogd was restarted + * 2) /dev/log is out of socket buffer space + * We attempt to reconnect to /dev/log to take care of + * case #1 and keep send()ing data to cover case #2 + * to give syslogd a chance to empty its socket buffer. + */ + for (tries = 0; tries < MAXTRIES; tries++) { + if (send(data->log_file, tbuf, cnt, 0) != -1) + break; + if (errno != ENOBUFS) { + disconnectlog_r(data); + connectlog_r(data); + } else + (void)usleep(1); + } + + /* + * Output the message to the console; try not to block + * as a blocking console should not stop other processes. + * Make sure the error reported is the one from the syslogd failure. + */ + if (tries == MAXTRIES && (data->log_stat & LOG_CONS) && + (fd = open(_PATH_CONSOLE, + O_WRONLY | O_NONBLOCK | O_CLOEXEC, 0)) >= 0) { + iov[iovcnt].iov_base = __UNCONST(CRLF); + iov[iovcnt].iov_len = 2; + (void)writev(fd, iov, iovcnt + 1); + (void)close(fd); + } + + if (data == &sdata) + mutex_unlock(&syslog_mutex); + + if (data != &sdata && opened) { + /* preserve log tag */ + const char *ident = data->log_tag; + closelog_r(data); + data->log_tag = ident; + } } -/* - * OPENLOG -- open system log - */ -void openlog(const char *ident, int logstat, int logfac) +static void +disconnectlog_r(struct syslog_data *data) +{ + /* + * If the user closed the FD and opened another in the same slot, + * that's their problem. They should close it before calling on + * system services. + */ + if (data->log_file != -1) { + (void)close(data->log_file); + data->log_file = -1; + } + data->log_connected = 0; /* retry connect */ +} + +static void +connectlog_r(struct syslog_data *data) +{ + /* AF_UNIX address of local logger */ + static const struct sockaddr_un sun = { + .sun_family = AF_LOCAL, +#ifdef HAVE_SA_LEN + .sun_len = sizeof(sun), +#endif + .sun_path = _PATH_LOG, + }; + + if (data->log_file == -1 || fcntl(data->log_file, F_GETFL, 0) == -1) { + if ((data->log_file = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, + 0)) == -1) + return; + data->log_connected = 0; + } + if (!data->log_connected) { + if (connect(data->log_file, + (const struct sockaddr *)(const void *)&sun, + (socklen_t)sizeof(sun)) == -1) { + (void)close(data->log_file); + data->log_file = -1; + } else + data->log_connected = 1; + } +} + +static void +openlog_unlocked_r(const char *ident, int logstat, int logfac, + struct syslog_data *data) { if (ident != NULL) - LogTag = ident; - LogStat = logstat; - + data->log_tag = ident; + data->log_stat = logstat; #ifdef ALLOW_KERNEL_LOGGING if ((logfac & ~LOG_FACMASK) == 0) #else - if (logfac != 0 && (logfac & ~LOG_FACMASK) == 0) + if (logfac != 0 && (logfac &~ LOG_FACMASK) == 0) #endif - LogFacility = logfac; + data->log_fac = logfac; -#ifndef TESTING - if (LogFile == -1) { - SyslogAddr.sa_family = AF_UNIX; - strncpy(SyslogAddr.sa_data, _PATH_LOGNAME, sizeof(SyslogAddr.sa_data)); - if (LogStat & LOG_NDELAY) { - LogFile = socket(AF_UNIX, SOCK_DGRAM, 0); - fcntl(LogFile, F_SETFD, 1); /* FD_CLOEXEC */ - } - } - if (LogFile != -1 && !connected && - connect(LogFile, &SyslogAddr, sizeof(SyslogAddr.sa_family) + strlen(SyslogAddr.sa_data)) != -1) - connected = 1; -#else - LogFile = fileno(stdout); - connected = 1; -#endif + if (data->log_stat & LOG_NDELAY) /* open immediately */ + connectlog_r(data); + + data->log_opened = 1; } -/* - * CLOSELOG -- close the system log - */ -void closelog() +void +openlog_r(const char *ident, int logstat, int logfac, struct syslog_data *data) { -#ifndef TESTING - (void)close(LogFile); -#endif - LogFile = -1; - connected = 0; + if (data == &sdata) + mutex_lock(&syslog_mutex); + openlog_unlocked_r(ident, logstat, logfac, data); + if (data == &sdata) + mutex_unlock(&syslog_mutex); } -static int LogMask = 0xff; /* mask of priorities to be logged */ -/* - * SETLOGMASK -- set the log mask level - */ -int setlogmask(int pmask) +void +closelog_r(struct syslog_data *data) +{ + if (data == &sdata) + mutex_lock(&syslog_mutex); + (void)close(data->log_file); + data->log_file = -1; + data->log_connected = 0; + data->log_tag = NULL; + if (data == &sdata) + mutex_unlock(&syslog_mutex); +} + +int +setlogmask_r(int pmask, struct syslog_data *data) { int omask; - omask = LogMask; + omask = data->log_mask; if (pmask != 0) - LogMask = pmask; + data->log_mask = pmask; return omask; } diff --git a/src/syslog.h b/src/syslog.h new file mode 100644 index 0000000..9f1051d --- /dev/null +++ b/src/syslog.h @@ -0,0 +1,230 @@ +/* $NetBSD: syslog.h,v 1.34.8.3 2017/12/03 11:39:21 jdolecek Exp $ */ + +/* + * Copyright (c) 1982, 1986, 1988, 1993 + * 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. + * + * @(#)syslog.h 8.1 (Berkeley) 6/2/93 + */ + +#ifndef _SYS_SYSLOG_H_ /* From NetBSD, for co-existance with C-library header */ +#define _SYS_SYSLOG_H_ + +#include +#include + +#define _PATH_LOG "/var/run/log" + +/* + * priorities/facilities are encoded into a single 32-bit quantity, where the + * bottom 3 bits are the priority (0-7) and the top 28 bits are the facility + * (0-big number). Both the priorities and the facilities map roughly + * one-to-one to strings in the syslogd(8) source code. This mapping is + * included in this file. + * + * priorities (these are ordered) + */ +#define LOG_EMERG 0 /* system is unusable */ +#define LOG_ALERT 1 /* action must be taken immediately */ +#define LOG_CRIT 2 /* critical conditions */ +#define LOG_ERR 3 /* error conditions */ +#define LOG_WARNING 4 /* warning conditions */ +#define LOG_NOTICE 5 /* normal but significant condition */ +#define LOG_INFO 6 /* informational */ +#define LOG_DEBUG 7 /* debug-level messages */ + +#define LOG_PRIMASK 0x07 /* mask to extract priority part (internal) */ + /* extract priority */ +#define LOG_PRI(p) ((p) & LOG_PRIMASK) +#define LOG_MAKEPRI(fac, pri) (((fac) << 3) | (pri)) + +#ifdef SYSLOG_NAMES +#define INTERNAL_NOPRI 0x10 /* the "no priority" priority */ + /* mark "facility" */ +#define INTERNAL_MARK LOG_MAKEPRI(LOG_NFACILITIES, 0) +typedef struct _code { + const char *c_name; + int c_val; +} CODE; + +CODE prioritynames[] = { + { "alert", LOG_ALERT }, + { "crit", LOG_CRIT }, + { "debug", LOG_DEBUG }, + { "emerg", LOG_EMERG }, + { "err", LOG_ERR }, + { "error", LOG_ERR }, /* DEPRECATED */ + { "info", LOG_INFO }, + { "none", INTERNAL_NOPRI }, /* INTERNAL */ + { "notice", LOG_NOTICE }, + { "panic", LOG_EMERG }, /* DEPRECATED */ + { "warn", LOG_WARNING }, /* DEPRECATED */ + { "warning", LOG_WARNING }, + { NULL, -1 } +}; +#endif /* SYSLOG_NAMES */ + +/* facility codes */ +#define LOG_KERN (0<<3) /* kernel messages */ +#define LOG_USER (1<<3) /* random user-level messages */ +#define LOG_MAIL (2<<3) /* mail system */ +#define LOG_DAEMON (3<<3) /* system daemons */ +#define LOG_AUTH (4<<3) /* security/authorization messages */ +#define LOG_SYSLOG (5<<3) /* messages generated internally by syslogd */ +#define LOG_LPR (6<<3) /* line printer subsystem */ +#define LOG_NEWS (7<<3) /* network news subsystem */ +#define LOG_UUCP (8<<3) /* UUCP subsystem */ +#define LOG_CRON (9<<3) /* clock daemon */ +#define LOG_AUTHPRIV (10<<3) /* security/authorization messages (private) */ +#define LOG_FTP (11<<3) /* ftp daemon */ + + /* other codes through 15 reserved for system use */ +#define LOG_LOCAL0 (16<<3) /* reserved for local use */ +#define LOG_LOCAL1 (17<<3) /* reserved for local use */ +#define LOG_LOCAL2 (18<<3) /* reserved for local use */ +#define LOG_LOCAL3 (19<<3) /* reserved for local use */ +#define LOG_LOCAL4 (20<<3) /* reserved for local use */ +#define LOG_LOCAL5 (21<<3) /* reserved for local use */ +#define LOG_LOCAL6 (22<<3) /* reserved for local use */ +#define LOG_LOCAL7 (23<<3) /* reserved for local use */ + +#define LOG_NFACILITIES 24 /* current number of facilities */ +#define LOG_FACMASK 0x03f8 /* mask to extract facility part */ + /* facility of pri */ +#define LOG_FAC(p) (((p) & LOG_FACMASK) >> 3) + +#ifdef SYSLOG_NAMES +CODE facilitynames[] = { + { "auth", LOG_AUTH }, + { "authpriv", LOG_AUTHPRIV }, + { "cron", LOG_CRON }, + { "daemon", LOG_DAEMON }, + { "ftp", LOG_FTP }, + { "kern", LOG_KERN }, + { "lpr", LOG_LPR }, + { "mail", LOG_MAIL }, + { "mark", INTERNAL_MARK }, /* INTERNAL */ + { "news", LOG_NEWS }, + { "security", LOG_AUTH }, /* DEPRECATED */ + { "syslog", LOG_SYSLOG }, + { "user", LOG_USER }, + { "uucp", LOG_UUCP }, + { "local0", LOG_LOCAL0 }, + { "local1", LOG_LOCAL1 }, + { "local2", LOG_LOCAL2 }, + { "local3", LOG_LOCAL3 }, + { "local4", LOG_LOCAL4 }, + { "local5", LOG_LOCAL5 }, + { "local6", LOG_LOCAL6 }, + { "local7", LOG_LOCAL7 }, + { NULL, -1 } +}; +#endif /* SYSLOG_NAMES */ + +#ifdef __KERNEL__ +#define LOG_PRINTF -1 /* pseudo-priority to indicate use of printf */ +#endif + +/* + * arguments to setlogmask. + */ +#define LOG_MASK(pri) (1 << (pri)) /* mask for one priority */ +#define LOG_UPTO(pri) ((1 << ((pri)+1)) - 1) /* all priorities through pri */ + +/* + * Option flags for openlog. + * + * LOG_ODELAY no longer does anything. + * LOG_NDELAY is the inverse of what it used to be. + */ +#define LOG_PID 0x01 /* log the pid with each message */ +#define LOG_CONS 0x02 /* log on the console if errors in sending */ +#define LOG_ODELAY 0x04 /* delay open until first syslog() (default) */ +#define LOG_NDELAY 0x08 /* don't delay open */ +#define LOG_NOWAIT 0x10 /* don't wait for console forks: DEPRECATED */ +#define LOG_PERROR 0x20 /* log to stderr as well */ +#define LOG_PTRIM 0x40 /* trim tag and pid from messages to stderr */ +#define LOG_NLOG 0x80 /* don't write to the system log */ + +#ifndef __KERNEL__ + +/* Used by reentrant functions */ + +struct syslog_data { + int log_version; + int log_file; + int log_connected; + int log_opened; + int log_stat; + const char *log_tag; + char log_hostname[256]; /* MAXHOSTNAMELEN */ + int log_fac; + int log_mask; +}; + +#define SYSLOG_DATA_INIT { \ + .log_version = 1, \ + .log_file = -1, \ + .log_connected = 0, \ + .log_opened = 0, \ + .log_stat = 0, \ + .log_tag = 0, \ + .log_hostname = { '\0' }, \ + .log_fac = LOG_USER, \ + .log_mask = 0xff, \ +} + +__BEGIN_DECLS +void closelog(void); +void openlog(const char *, int, int); +int setlogmask(int); +void syslog(int, const char *, ...); +void vsyslog(int, const char *, va_list); +void closelog_r(struct syslog_data *); +void openlog_r(const char *, int, int, struct syslog_data *); +int setlogmask_r(int, struct syslog_data *); +void syslog_r(int, struct syslog_data *, const char *, ...); +void vsyslog_r(int, struct syslog_data *, const char *, va_list); +void syslogp_r(int, struct syslog_data *, const char *, const char *, + const char *, ...); +void vsyslogp_r(int, struct syslog_data *, const char *, const char *, + const char *, va_list); +void syslogp(int, const char *, const char *, const char *, ...); +void vsyslogp(int, const char *, const char *, const char *, va_list); +__END_DECLS + +#else /* !__KERNEL__ */ + +void logpri(int); +void log(int, const char *, ...); +void vlog(int, const char *, va_list); +void addlog(const char *, ...); +void logwakeup(void); + +#endif /* !__KERNEL__ */ + +#endif /* !_SYS_SYSLOG_H_ */