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

syslogd: Refactor internals to use new socket API

Browse Source 
This patch is inspired, in part, by FreeBSD syslogd but now diverges
onto its own path.  Special handling for AF_UNIX sockets are required
on Linux, which unlike BSD cannot use getaddrinfo() on UNIX sockets.

- Rip out old funix[] and finet support
- Add new concept of peers
- Linked list of peers can be > 20
- Temporarily open up to accept all remote conns
- Remove old logerror(), replaced with new log macros

Signed-off-by: Joachim Nilsson <troglobit@gmail.com>
This commit is contained in:
Joachim Nilsson
2019-11-12 09:24:26 +01:00
parent 07677c78a5
commit 4ee6211277
4 changed files with 177 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
man/syslogd.8
View File

@@ -155,7 +155,7 @@ options are specified, the remaining pathnames are treated as additional
log sockets. This might be needed when running applications in
containers or a
.Xr chroot 8
environment. In total 20 UNIX domain sockets are supported.
environment.
.It Fl R Ar size[:count]
Enable built-in support for log rotation of files listed in
.Pa /etc/syslog.conf .

540
src/syslogd.c
View File

@@ -74,11 +74,9 @@ static char sccsid[] __attribute__((unused)) =
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <arpa/inet.h>
@@ -98,17 +96,9 @@ char *ConfFile = _PATH_LOGCONF;
char *PidFile = _PATH_LOGPID;
char ctty[] = _PATH_CONSOLE;
char **parts;
static int debugging_on = 0;
static int restart = 0;
#define MAXFUNIX 20
static int nfunix;
static char *funixn[MAXFUNIX];
static int funix[MAXFUNIX];
/*
* Intervals at which we flush out "message repeated" messages,
* in seconds after previous message is logged. After each flush,
@@ -116,6 +106,13 @@ static int funix[MAXFUNIX];
*/
static int repeatinterval[] = { 30, 120, 600 }; /* # of secs before flush */
/* values for f_type */
static char *TypeNames[] = {
"UNUSED", "FILE", "TTY", "CONSOLE",
"FORW", "USERS", "WALL", "FORW(SUSPENDED)",
"FORW(UNKNOWN)", "PIPE"
};
static SIMPLEQ_HEAD(files, filed) fhead = SIMPLEQ_HEAD_INITIALIZER(fhead);
struct filed consfile;
@@ -124,12 +121,9 @@ static int Foreground = 0; /* don't fork - don't run in daemon mode */
static char LocalHostName[MAXHOSTNAMELEN + 1]; /* our hostname */
static char *LocalDomain; /* our local domain name */
static char *emptystring = "";
static int InetInuse = 0; /* non-zero if INET sockets are being used */
static int *finet = NULL; /* Internet datagram sockets */
static int Initialized = 0; /* set when we have initialized ourselves */
static int MarkInterval = 20 * 60; /* interval between marks in seconds */
static int family = PF_UNSPEC; /* protocol family (IPv4, IPv6 or both) */
static char *service = "syslog"; /* Port to bind to, default 514/udp */
static int mask_C1 = 1; /* mask characters from 0x80 - 0x9F */
static int send_to_all; /* send message to all IPv4/IPv6 addresses */
static int MarkSeq = 0; /* mark sequence number */
@@ -141,13 +135,24 @@ static int KeepKernFac; /* Keep remotely logged kernel facility */
static int LastAlarm = 0; /* last value passed to alarm() (seconds) */
static int DupesPending = 0; /* Number of unflushed duplicate messages */
static int AcceptRemote = 1; /* receive messages that come via UDP */
static char **StripDomains = NULL; /* these domains may be stripped before writing logs */
static char **LocalHosts = NULL; /* these hosts are logged with their hostname */
static int NoHops = 1; /* Can we bounce syslog messages through an intermediate host. */
static off_t RotateSz = 0; /* Max file size (bytes) before rotating, disabled by default */
static int RotateCnt = 5; /* Max number (count) of log files to keep, set with -c <NUM> */
/*
* List of peers and sockets for binding.
*/
struct peer {
const char *pe_name;
const char *pe_serv;
mode_t pe_mode;
SIMPLEQ_ENTRY(peer) next;
};
static SIMPLEQ_HEAD(, peer) pqueue = SIMPLEQ_HEAD_INITIALIZER(pqueue);
/* Function prototypes. */
char **crunch_list(char *list);
void untty(void);
@@ -162,7 +167,6 @@ const char *cvtaddr(struct sockaddr_storage *f, int len);
const char *cvthname(struct sockaddr_storage *f, int len);
void domark();
void debug_switch();
void logerror(const char *type);
void die(int sig);
void doexit(int sig);
void init();
@@ -171,9 +175,21 @@ static int cfparse(FILE *fp, struct files *newf);
int decode(char *name, struct _code *codetab);
static void logit(char *, ...);
void sighup_handler(int);
static int create_unix_socket(const char *path);
static int *create_inet_sockets();
static void create_unix_socket(struct peer *pe);
static void create_inet_socket(struct peer *pe);
static int addpeer(struct peer *pe0)
{
struct peer *pe;
pe = calloc(1, sizeof(*pe));
if (pe == NULL)
err(1, "malloc failed");
*pe = *pe0;
SIMPLEQ_INSERT_TAIL(&pqueue, pe, next);
return (0);
}
int usage(int code)
{
@@ -216,22 +232,11 @@ int usage(int code)
int main(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
struct sockaddr_storage frominet;
socklen_t len;
ssize_t msglen;
fd_set readfds;
struct peer *pe;
pid_t ppid = getpid();
char *ptr;
char line[MAXLINE + 1];
int num_fds, maxfds;
int i, fd, ch;
for (i = 0; i < MAXFUNIX; i++) {
funixn[i] = NULL;
funix[i] = -1;
}
int pflag = 0, bflag = 0;
int ch;
#ifndef WITHOUT_KLOGD
/*
@@ -257,9 +262,14 @@ int main(int argc, char *argv[])
break;
case 'b':
bflag = 1;
ptr = strchr(optarg, ':');
if (ptr)
service = ++ptr;
*ptr++ = 0;
addpeer(&(struct peer) {
.pe_name = optarg,
.pe_serv = ptr,
});
break;
case 'd': /* debug */
@@ -299,10 +309,16 @@ int main(int argc, char *argv[])
break;
case 'p': /* path to regular log socket */
if (nfunix < (int)NELEMS(funixn))
funixn[nfunix++] = optarg;
else
fprintf(stderr, "Max log sockets reached, ignoring %s\n", optarg);
if (optarg[0] != '/') {
warnx("Socket paths must be absolute (start with '/').");
break;
}
pflag = 1;
addpeer(&(struct peer) {
.pe_name = optarg,
.pe_mode = 0666,
});
break;
case 'R':
@@ -333,9 +349,19 @@ int main(int argc, char *argv[])
if ((argc -= optind))
return usage(1);
/* Default to listen to :514 (syslog/udp) */
if (!bflag)
addpeer(&(struct peer) {
.pe_name = NULL,
.pe_serv = "syslog",
});
/* Default to _PATH_LOG for the UNIX domain socket */
if (!nfunix)
funixn[nfunix++] = _PATH_LOG;
if (!pflag)
addpeer(&(struct peer) {
.pe_name = _PATH_LOG,
.pe_mode = 0666,
});
if ((!Foreground) && (!Debug)) {
signal(SIGTERM, doexit);
@@ -358,8 +384,7 @@ int main(int argc, char *argv[])
}
signal(SIGTERM, SIG_DFL);
num_fds = getdtablesize();
for (i = 0; i < num_fds; i++)
for (int i = 0; i < getdtablesize(); i++)
(void)close(i);
untty();
} else {
@@ -367,16 +392,6 @@ int main(int argc, char *argv[])
setlinebuf(stdout);
}
if (!Debug) {
if (pidfile(PidFile)) {
logit("Failed creating PID file %s: %s",
PidFile, strerror(errno));
if (getpid() != ppid)
kill(ppid, SIGTERM);
exit(1);
}
}
consfile.f_type = F_CONSOLE;
strlcpy(consfile.f_un.f_fname, ctty, sizeof(consfile.f_un.f_fname));
@@ -396,19 +411,14 @@ int main(int argc, char *argv[])
LastAlarm = MarkInterval;
alarm(LastAlarm);
/* Create a partial message table for all file descriptors. */
num_fds = getdtablesize();
logit("Allocated parts table for %d file descriptors.\n", num_fds);
if ((parts = malloc(num_fds * sizeof(char *))) == NULL) {
logerror("Cannot allocate memory for message parts table.");
if (getpid() != ppid)
kill(ppid, SIGTERM);
die(0);
}
for (i = 0; i < num_fds; ++i)
parts[i] = NULL;
logit("Starting.\n");
SIMPLEQ_FOREACH(pe, &pqueue, next) {
if (pe->pe_name && pe->pe_name[0] == '/')
create_unix_socket(pe);
else // XXX if (cffwd() && SecureMode <= 1)
create_inet_socket(pe);
}
init();
if (Debug) {
@@ -422,50 +432,21 @@ int main(int argc, char *argv[])
if (getpid() != ppid)
kill(ppid, SIGTERM);
/*
* Tell system we're up and running by creating /run/syslogd.pid
*/
if (!Debug && pidfile(PidFile)) {
logit("Failed creating %s: %s", PidFile, strerror(errno));
if (getpid() != ppid)
kill(ppid, SIGTERM);
exit(1);
}
/* Main loop begins here. */
for (;;) {
int nfds;
int rc;
errno = 0;
FD_ZERO(&readfds);
maxfds = 0;
/*
* Add the Unix Domain Sockets to the list of read
* descriptors.
*/
for (i = 0; i < nfunix; i++) {
if (funix[i] == -1)
continue;
FD_SET(funix[i], &readfds);
if (funix[i] > maxfds)
maxfds = funix[i];
}
/*
* Add the Internet Domain Socket to the list of read
* descriptors.
*/
if (InetInuse && AcceptRemote) {
for (i = 0; i < *finet; i++) {
if (finet[i + 1] != -1)
FD_SET(finet[i + 1], &readfds);
if (finet[i + 1] > maxfds)
maxfds = finet[i + 1];
}
logit("Listening on syslog UDP port.\n");
}
if (debugging_on) {
logit("Calling select, active file descriptors (max %d): ", maxfds);
for (nfds = 0; nfds <= maxfds; ++nfds)
if (FD_ISSET(nfds, &readfds))
logit("%d ", nfds);
logit("\n");
}
nfds = select(maxfds + 1, &readfds, NULL, NULL, NULL);
rc = socket_poll(NULL);
if (restart) {
restart = 0;
logit("\nReceived SIGHUP, reloading syslogd.\n");
@@ -476,225 +457,119 @@ int main(int argc, char *argv[])
continue;
}
if (nfds == 0) {
if (rc == 0) {
logit("No select activity.\n");
continue;
}
if (nfds < 0) {
if (rc < 0) {
if (errno != EINTR)
ERR("select()");
continue;
}
if (debugging_on) {
logit("\nSuccessful select, descriptor count = %d, "
"Activity on: ",
nfds);
for (nfds = 0; nfds <= maxfds; ++nfds)
if (FD_ISSET(nfds, &readfds))
logit("%d ", nfds);
logit("\n");
}
}
static void unix_cb(int sd, void *arg)
{
ssize_t msglen;
char msg[MAXLINE + 1] = { 0 };
msglen = recv(sd, msg, sizeof(msg) - 1, 0);
logit("Message from UNIX socket #%d: %s\n", sd, msg);
if (msglen <= 0) {
if (msglen < 0 && errno != EINTR)
ERR("recv() UNIX");
return;
}
for (i = 0; i < nfunix; i++) {
if ((fd = funix[i]) != -1 && FD_ISSET(fd, &readfds)) {
memset(line, 0, sizeof(line));
msglen = recv(fd, line, MAXLINE - 2, 0);
logit("Message from UNIX socket #%d: %s\n", fd, line);
if (msglen > 0)
parsemsg(LocalHostName, line);
else if (msglen < 0 && errno != EINTR) {
logit("UNIX socket error: %d = %s.\n",
errno, strerror(errno));
logerror("recvfrom UNIX");
}
}
}
parsemsg(LocalHostName, msg);
}
if (InetInuse && AcceptRemote && finet) {
for (i = 0; i < *finet; i++) {
if (finet[i + 1] != -1 && FD_ISSET(finet[i + 1], &readfds)) {
len = sizeof(frominet);
memset(line, 0, sizeof(line));
msglen = recvfrom(finet[i + 1], line, MAXLINE - 2, 0,
(struct sockaddr *)&frominet, &len);
if (Debug) {
const char *addr = cvtaddr(&frominet, len);
logit("Message from inetd socket: #%d, host: %s\n",
i + 1, addr);
}
static void create_unix_socket(struct peer *pe)
{
struct sockaddr_un sun;
struct addrinfo ai;
int sd = -1;
ai.ai_addr = (struct sockaddr *)&sun;
ai.ai_addrlen = sizeof(sun);
ai.ai_family = sun.sun_family = AF_UNIX;
ai.ai_socktype = SOCK_DGRAM;
ai.ai_protocol = pe->pe_mode;
strlcpy(sun.sun_path, pe->pe_name, sizeof(sun.sun_path));
sd = socket_create(&ai, unix_cb, NULL);
if (sd < 0)
goto err;
return;
err:
ERR("cannot create %s", pe->pe_name);
}
static void inet_cb(int sd, void *arg)
{
struct sockaddr_storage ss;
socklen_t len;
ssize_t msglen;
char msg[MAXLINE + 1] = { 0 };
len = sizeof(ss);
msglen = recvfrom(sd, msg, sizeof(msg) - 1, 0, (struct sockaddr *)&ss, &len);
if (msglen > 0) {
const char *from;
/* Note that if cvthname() returns NULL then
we shouldn't attempt to log the line -- jch */
from = cvthname(&frominet, len);
if (from)
parsemsg(from, line);
from = cvthname(&ss, len);
if (from) {
logit("Message from inet host %s\n", cvtaddr(&ss, len));
parsemsg(from, msg);
}
} else if (msglen < 0 && errno != EINTR && errno != EAGAIN) {
logit("INET socket error: %d = %s.\n",
errno, strerror(errno));
logerror("recvfrom inet");
ERR("INET socket recvfrom()");
/* should be harmless now that we set
* BSDCOMPAT on the socket */
sleep(1);
}
}
}
}
}
}
/*
* From FreeBSD syslogd SVN r259368
* https://svnweb.freebsd.org/base/stable/10/usr.sbin/syslogd/syslogd.c?r1=256281&r2=259368
*/
static void increase_rcvbuf(int fd)
{
socklen_t len, slen;
slen = sizeof(len);
if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, &slen))
return;
if (len < RCVBUF_MINSIZE) {
len = RCVBUF_MINSIZE;
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len)))
logerror("Failed increasing size of socket receive buffer");
}
}
static int create_unix_socket(const char *path)
{
struct sockaddr_un sun;
char line[MAXLINE + 1];
int sd = -1;
if (path[0] == '\0')
return -1;
(void)unlink(path);
sd = socket(AF_UNIX, SOCK_DGRAM, 0);
if (sd < 0)
goto err;
memset(&sun, 0, sizeof(sun));
sun.sun_family = AF_UNIX;
strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
if (bind(sd, (struct sockaddr *)&sun, sizeof(sun.sun_family) + strlen(sun.sun_path)))
goto err;
if (chmod(path, 0666) < 0)
goto err;
increase_rcvbuf(sd);
return sd;
err:
snprintf(line, sizeof(line), "cannot create %s", path);
logerror(line);
logit("cannot create %s (%d).\n", path, errno);
if (sd != -1)
close(sd);
return -1;
}
static int nslookup(char *host, char *service, struct addrinfo **ai)
static int nslookup(const char *host, const char *service, struct addrinfo **ai)
{
struct addrinfo hints;
const char *node = host;
if (!node || !node[0])
node = NULL;
logit("nslookup '%s:%s'\n", node ?: "none", service);
memset(&hints, 0, sizeof(hints));
hints.ai_flags = !host ? AI_PASSIVE : 0;
hints.ai_flags = !node ? AI_PASSIVE : 0;
hints.ai_family = family;
hints.ai_socktype = SOCK_DGRAM;
return getaddrinfo(host, service, &hints, ai);
return getaddrinfo(node, service, &hints, ai);
}
static int *create_inet_sockets(void)
static void create_inet_socket(struct peer *pe)
{
struct addrinfo *res, *r;
int err, maxs, *s, *socks;
int on = 1, sockflags;
int sd, err;
err = nslookup(NULL, service, &res);
err = nslookup(pe->pe_name, pe->pe_serv, &res);
if (err) {
flog(LOG_SYSLOG | LOG_ERR, "network logging disabled (%s/udp "
" service unknown): %s", service, gai_strerror(err));
return NULL;
ERRX("%s/udp service unknown: %s", pe->pe_serv, gai_strerror(err));
return;
}
/* Count max number of sockets we may open */
for (maxs = 0, r = res; r; r = r->ai_next, maxs++)
;
socks = malloc((maxs + 1) * sizeof(int));
if (!socks) {
logerror("couldn't allocate memory for sockets");
freeaddrinfo(res);
die(0);
}
*socks = 0; /* num of sockets counter at start of array */
s = socks + 1;
for (r = res; r; r = r->ai_next) {
*s = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
if (*s < 0) {
logerror("socket");
continue;
}
if (r->ai_family == AF_INET6) {
if (setsockopt(*s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0) {
logerror("setsockopt (IPV6_ONLY), suspending IPv6");
close(*s);
continue;
}
}
if (setsockopt(*s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
logerror("setsockopt(REUSEADDR), suspending inet");
close(*s);
sd = socket_create(r, inet_cb, NULL);
if (sd < 0)
continue;
logit("Created inet socket %d ...\n", sd);
}
logit("Created inet socket %d ...\n", *s);
increase_rcvbuf(*s);
/* We must not block on the network socket, in case a packet
* gets lost between select and recv, otherise the process
* will stall until the timeout, and other processes trying to
* log will also stall.
*/
if ((sockflags = fcntl(*s, F_GETFL)) != -1) {
sockflags |= O_NONBLOCK;
/*
* SETFL could fail too, so get it caught by the subsequent
* error check.
*/
sockflags = fcntl(*s, F_SETFL, sockflags);
}
if (sockflags == -1) {
logerror("fcntl(O_NONBLOCK), suspending inet");
close(*s);
continue;
}
if (bind(*s, r->ai_addr, r->ai_addrlen) < 0) {
logerror("bind, suspending inet");
close(*s);
continue;
}
(*socks)++;
s++;
}
freeaddrinfo(res);
if (*socks == 0) {
logerror("no valid sockets, suspending inet");
free(socks);
return NULL;
}
return socks;
}
char **crunch_list(list) char *list;
@@ -1669,7 +1544,7 @@ void fprintlog(struct filed *f, struct buf_msg *buffer)
logit(" %s:%s\n", f->f_un.f_forw.f_hname, f->f_un.f_forw.f_serv);
if (strcmp(buffer->hostname, LocalHostName) && NoHops)
logit("Not sending message to remote.\n");
else if (finet) {
else {
struct msghdr msg;
ssize_t len = 0;
@@ -1686,21 +1561,30 @@ void fprintlog(struct filed *f, struct buf_msg *buffer)
err = -1;
for (ai = f->f_un.f_forw.f_addr; ai; ai = ai->ai_next) {
for (int i = 0; i < *finet; i++) {
struct sockaddr_in *sin;
int sd;
sd = socket_ffs(ai->ai_family);
if (sd != -1) {
char buf[64] = { 0 };
ssize_t lsent;
msg.msg_name = ai->ai_addr;
msg.msg_namelen = ai->ai_addrlen;
lsent = sendmsg(finet[i + 1], &msg, 0);
lsent = sendmsg(sd, &msg, 0);
if (AF_INET == ai->ai_family) {
struct sockaddr_in *sin;
sin = (struct sockaddr_in *)ai->ai_addr;
inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf));
} else {
struct sockaddr_in6 *sin6;
sin6 = (struct sockaddr_in6 *)ai->ai_addr;
inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf));
}
logit("Sent %zd bytes to remote %s on socket %d ...\n",
lsent, buf, finet[i + 1]);
logit("Sent %zd bytes to %s on socket %d ...\n", lsent, buf, sd);
if (lsent == len) {
err = -1;
break;
@@ -2061,24 +1945,10 @@ void debug_switch(int signo)
signal(SIGUSR1, debug_switch);
}
/*
* Print syslogd errors some place.
*/
void logerror(const char *type)
{
logit("Called logerr, msg: %s\n", type);
if (errno == 0)
flog(LOG_SYSLOG | LOG_ERR, "%s", type);
else
flog(LOG_SYSLOG | LOG_ERR, "%s: %m", type);
}
void die(int signo)
{
struct filed *f, *next;
int was_initialized = Initialized;
int i;
Initialized = 0; /* Don't log SIGCHLDs in case we
receive one during exiting */
@@ -2118,26 +1988,13 @@ void die(int signo)
}
/* Close the UNIX sockets. */
for (i = 0; i < nfunix; i++) {
if (funix[i] != -1)
close(funix[i]);
}
/* XXX */
/* Close the inet sockets. */
if (InetInuse && finet) {
for (i = 0; i < *finet; i++)
close(finet[i + 1]);
free(finet);
}
/* XXX */
/* Clean-up files. */
for (i = 0; i < nfunix; i++) {
if (funixn[i] && funix[i] != -1)
(void)unlink(funixn[i]);
}
if (parts)
free(parts);
/* Clean-up UNIX sockets. */
/* XXX */
exit(0);
}
@@ -2220,7 +2077,7 @@ void init(void)
if ((p = strchr(LocalHostName, '.'))) {
*p++ = '\0';
LocalDomain = p;
} else if (AcceptRemote) {
} else {
/*
* It's not clearly defined whether gethostname()
* should return the simple hostname or the fqdn. A
@@ -2293,45 +2150,6 @@ void init(void)
}
fhead = newf;
for (i = 0; i < nfunix; i++) {
/*
* UNIX domain sockets are given on the command line, so
* there's no need to close them if they're already
* open. Doing so would only cause loss of any already
* buffered messages
*/
logit("Checking if we should open UNIX socket %s ...", funixn[i]);
if (funix[i] != -1) {
logit(" nope, already open.\n");
continue;
}
funix[i] = create_unix_socket(funixn[i]);
if (funix[i] == -1)
logit(" failed opening, error %d: %s\n", errno, strerror(errno));
else
logit(" opened successfully\n");
}
if (cffwd() || AcceptRemote) {
if (!finet) {
finet = create_inet_sockets();
if (finet) {
InetInuse = 1;
logit("Opened syslog UDP port.\n");
}
}
} else {
if (finet) {
for (i = 0; i < *finet; i++)
if (finet[i + 1] != -1)
close(finet[i + 1]);
free(finet);
finet = NULL;
}
InetInuse = 0;
}
Initialized = 1;
if (Debug) {
@@ -2369,11 +2187,7 @@ void init(void)
}
}
if (AcceptRemote)
flog(LOG_SYSLOG | LOG_INFO, "syslogd v" VERSION ": restart (remote reception).");
else
flog(LOG_SYSLOG | LOG_INFO, "syslogd v" VERSION ": restart.");
logit("syslogd: restarted.\n");
}
@@ -2605,7 +2419,7 @@ static struct filed *cfline(char *line)
if (bp)
*bp++ = 0;
else
bp = service;
bp = "syslog"; /* default: 514/udp */
strlcpy(f->f_un.f_forw.f_hname, p, sizeof(f->f_un.f_forw.f_hname));
strlcpy(f->f_un.f_forw.f_serv, bp, sizeof(f->f_un.f_forw.f_serv));

9
src/syslogd.h
View File

@@ -32,6 +32,10 @@
#ifndef SYSKLOGD_SYSLOGD_H_
#define SYSKLOGD_SYSLOGD_H_
#include <netdb.h> /* struct addrinfo */
#include <sys/param.h> /* MAXHOSTNAMELEN */
#include <sys/socket.h>
#include <sys/un.h> /* struct sockaddr_un */
#include "queue.h"
#include "syslog.h"
@@ -159,11 +163,6 @@
#define F_FORW_SUSP 7 /* suspended host forwarding */
#define F_FORW_UNKN 8 /* unknown host forwarding */
#define F_PIPE 9 /* named pipe */
char *TypeNames[] = {
"UNUSED", "FILE", "TTY", "CONSOLE",
"FORW", "USERS", "WALL", "FORW(SUSPENDED)",
"FORW(UNKNOWN)", "PIPE"
};
/* Timestamps of log entries. */
struct logtime {

2
test/start.sh
View File

@@ -17,7 +17,7 @@ EOF
cat <<EOF > ${CONFD}/bar.conf
# For remote logging
*.* @127.0.0.2
*.* @127.0.0.2:${PORT}
EOF
../src/syslogd -b :${PORT} -d -n -f ${CONF} -p ${SOCK} -p ${ALTSOCK} &