emo/sysklogd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update syslog.c, add syslog.h from NetBSD to get new syslogp() API

Browse Source 
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 <troglobit@gmail.com>
This commit is contained in:
Joachim Nilsson 2019-10-25 14:25:29 +02:00
parent d83f781dc0
commit f6e17bd6b3
4 changed files with 720 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile.am
View File

@ -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)

72
src/compat.h Normal file
View File

@ -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 <pthread.h>
/*
* 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_ */

587
src/syslog.c
View File

@ -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 <joey@infodrom.ffis.de>
* Use SOCK_DGRAM for loggin, renables it to work.
*
* Wed Aug 27 17:48:16 CEST 2003: Martin Schulze <joey@Infodrom.org>
* Improved patch by Michael Pomraning <mjp@securepipe.com> to
* reconnect klogd to the logger after it went away.
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <sys/un.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <paths.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#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;
}

230
src/syslog.h Normal file
View File

@ -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 <features.h>
#include <stdarg.h>
#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_ */