2 * Copyright (c) 1983, 1988, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * @(#)syslogd.c 8.3 (Berkeley) 4/4/94
30 * $FreeBSD: head/usr.sbin/syslogd/syslogd.c 258077 2013-11-13 01:04:02Z ian $
34 * syslogd -- log system messages
36 * This program implements a system log. It takes a series of lines.
37 * Each line may have a priority, signified as "<n>" as
38 * the first characters of the line. If this is
39 * not present, a default priority is used.
41 * To kill syslogd, send a signal 15 (terminate). A signal 1 (hup) will
42 * cause it to reread its configuration file.
46 * MAXLINE -- the maximum line length that can be handled.
47 * DEFUPRI -- the default priority for user messages
48 * DEFSPRI -- the default priority for kernel messages
51 * extensive changes by Ralph Campbell
52 * more extensive changes by Eric Allman (again)
53 * Extension to log by program name as well as facility and priority
55 * -u and -v by Harlan Stenn.
56 * Priority comparison code by Harlan Stenn.
59 #define MAXLINE 1024 /* maximum line length */
60 #define MAXSVLINE 120 /* maximum saved line length */
61 #define DEFUPRI (LOG_USER|LOG_NOTICE)
62 #define DEFSPRI (LOG_KERN|LOG_CRIT)
63 #define TIMERINTVL 30 /* interval for checking flush, mark */
64 #define TTYMSGTIME 1 /* timeout passed to ttymsg */
65 #define RCVBUF_MINSIZE (80 * 1024) /* minimum size of dgram rcv buffer */
67 #include <sys/param.h>
68 #include <sys/ioctl.h>
72 #include <sys/socket.h>
73 #include <sys/queue.h>
77 #include <sys/resource.h>
78 #include <sys/syslimits.h>
79 #include <sys/types.h>
81 #include <netinet/in.h>
83 #include <arpa/inet.h>
100 #include "pathnames.h"
104 #include <sys/syslog.h>
106 const char *ConfFile
= _PATH_LOGCONF
;
107 const char *PidFile
= _PATH_LOGPID
;
108 const char ctty
[] = _PATH_CONSOLE
;
110 #define dprintf if (Debug) printf
112 #define MAXUNAMES 20 /* maximum number of user names */
116 * We have two default sockets, one with 666 permissions,
117 * and one for privileged programs.
123 STAILQ_ENTRY(funix
) next
;
125 struct funix funix_secure
= { -1, _PATH_LOG_PRIV
, S_IRUSR
| S_IWUSR
,
127 struct funix funix_default
= { -1, _PATH_LOG
, DEFFILEMODE
,
130 STAILQ_HEAD(, funix
) funixes
= { &funix_default
,
131 &(funix_secure
.next
.stqe_next
) };
137 #define IGN_CONS 0x001 /* don't print on console */
138 #define SYNC_FILE 0x002 /* do fsync on file after printing */
139 #define ADDDATE 0x004 /* add a date to the message */
140 #define MARK 0x008 /* this message is a mark */
141 #define ISKERNEL 0x010 /* kernel generated message */
144 * This structure represents the files that will have log
146 * We require f_file to be valid if f_type is F_FILE, F_CONSOLE, F_TTY
147 * or if f_type if F_PIPE and f_pid > 0.
151 struct filed
*f_next
; /* next in linked list */
152 short f_type
; /* entry type, see below */
153 short f_file
; /* file descriptor */
154 time_t f_time
; /* time this was last written */
155 char *f_host
; /* host from which to recd. */
156 u_char f_pmask
[LOG_NFACILITIES
+1]; /* priority mask */
157 u_char f_pcmp
[LOG_NFACILITIES
+1]; /* compare priority */
161 char *f_program
; /* program this applies to */
163 char f_uname
[MAXUNAMES
][MAXLOGNAME
];
165 char f_hname
[MAXHOSTNAMELEN
];
166 struct addrinfo
*f_addr
;
168 } f_forw
; /* forwarding address */
169 char f_fname
[MAXPATHLEN
];
171 char f_pname
[MAXPATHLEN
];
175 char f_prevline
[MAXSVLINE
]; /* last message logged */
176 char f_lasttime
[16]; /* time of last occurrence */
177 char f_prevhost
[MAXHOSTNAMELEN
]; /* host from which recd. */
178 int f_prevpri
; /* pri of f_prevline */
179 int f_prevlen
; /* length of f_prevline */
180 int f_prevcount
; /* repetition cnt of prevline */
181 u_int f_repeatcount
; /* number of "repeated" msgs */
182 int f_flags
; /* file-specific flags */
183 #define FFLAG_SYNC 0x01
184 #define FFLAG_NEEDSYNC 0x02
188 * Queue of about-to-be dead processes we should watch out for.
191 TAILQ_HEAD(stailhead
, deadq_entry
) deadq_head
;
192 struct stailhead
*deadq_headp
;
197 TAILQ_ENTRY(deadq_entry
) dq_entries
;
201 * The timeout to apply to processes waiting on the dead queue. Unit
202 * of measure is `mark intervals', i.e. 20 minutes by default.
203 * Processes on the dead queue will be terminated after that time.
206 #define DQ_TIMO_INIT 2
208 typedef struct deadq_entry
*dq_t
;
212 * Struct to hold records of network addresses that are allowed to log
220 struct sockaddr_storage addr
;
221 struct sockaddr_storage mask
;
225 #define a_addr u.numeric.addr
226 #define a_mask u.numeric.mask
227 #define a_name u.name
232 * Intervals at which we flush out "message repeated" messages,
233 * in seconds after previous message is logged. After each flush,
234 * we move to the next interval until we reach the largest.
236 int repeatinterval
[] = { 30, 120, 600 }; /* # of secs before flush */
237 #define MAXREPEAT (NELEM(repeatinterval) - 1)
238 #define REPEATTIME(f) ((f)->f_time + repeatinterval[(f)->f_repeatcount])
239 #define BACKOFF(f) { if (++(f)->f_repeatcount > MAXREPEAT) \
240 (f)->f_repeatcount = MAXREPEAT; \
243 /* values for f_type */
244 #define F_UNUSED 0 /* unused entry */
245 #define F_FILE 1 /* regular file */
246 #define F_TTY 2 /* terminal */
247 #define F_CONSOLE 3 /* console terminal */
248 #define F_FORW 4 /* remote machine */
249 #define F_USERS 5 /* list of users */
250 #define F_WALL 6 /* everyone logged on */
251 #define F_PIPE 7 /* pipe to program */
253 const char *TypeNames
[8] = {
254 "UNUSED", "FILE", "TTY", "CONSOLE",
255 "FORW", "USERS", "WALL", "PIPE"
258 static struct filed
*Files
; /* Log files that we write to */
259 static struct filed consfile
; /* Console */
261 static int Debug
; /* debug flag */
262 static int resolve
= 1; /* resolve hostname */
263 static char LocalHostName
[MAXHOSTNAMELEN
]; /* our hostname */
264 static const char *LocalDomain
; /* our local domain name */
265 static int *finet
; /* Internet datagram socket */
266 static int fklog
= -1; /* /dev/klog */
267 static int Initialized
; /* set when we have initialized ourselves */
268 static int MarkInterval
= 20 * 60; /* interval between marks in seconds */
269 static int MarkSeq
; /* mark sequence number */
270 static int NoBind
; /* don't bind() as suggested by RFC 3164 */
271 static int SecureMode
; /* when true, receive only unix domain socks */
273 static int family
= PF_UNSPEC
; /* protocol family (IPv4, IPv6 or both) */
275 static int family
= PF_INET
; /* protocol family (IPv4 only) */
277 static int mask_C1
= 1; /* mask characters from 0x80 - 0x9F */
278 static int send_to_all
; /* send message to all IPv4/IPv6 addresses */
279 static int use_bootfile
; /* log entire bootfile for every kern msg */
280 static int no_compress
; /* don't compress messages (1=pipes, 2=all) */
281 static int logflags
= O_WRONLY
|O_APPEND
; /* flags used to open log files */
283 static char bootfile
[MAXLINE
+1]; /* booted kernel file */
285 struct allowedpeer
*AllowedPeers
; /* List of allowed peers */
286 static int NumAllowed
; /* Number of entries in AllowedPeers */
287 static int RemoteAddDate
; /* Always set the date on remote messages */
289 static int UniquePriority
; /* Only log specified priority? */
290 static int LogFacPri
; /* Put facility and priority in log message: */
291 /* 0=no, 1=numeric, 2=names */
292 static int KeepKernFac
; /* Keep remotely logged kernel facility */
293 static int needdofsync
= 0; /* Are any file(s) waiting to be fsynced? */
294 static struct pidfh
*pfh
;
296 volatile sig_atomic_t MarkSet
, WantDie
;
298 static int allowaddr(char *);
299 static void cfline(const char *, struct filed
*,
300 const char *, const char *);
301 static const char *cvthname(struct sockaddr
*);
302 static void deadq_enter(pid_t
, const char *);
303 static int deadq_remove(pid_t
);
304 static int decode(const char *, const CODE
*);
305 static void die(int);
306 static void dodie(int);
307 static void dofsync(void);
308 static void domark(int);
309 static void fprintlog(struct filed
*, int, const char *);
310 static int *socksetup(int, char *);
311 static void init(int);
312 static void logerror(const char *);
313 static void logmsg(int, const char *, const char *, int);
314 static void log_deadchild(pid_t
, int, const char *);
315 static void markit(void);
316 static int skip_message(const char *, const char *, int);
317 static void printline(const char *, char *, int);
318 static void printsys(char *);
319 static int p_open(const char *, pid_t
*);
320 static void readklog(void);
321 static void reapchild(int);
322 static void usage(void);
323 static int validate(struct sockaddr
*, const char *);
324 static void unmapped(struct sockaddr
*);
325 static void wallmsg(struct filed
*, struct iovec
*, const int iovlen
);
326 static int waitdaemon(int, int, int);
327 static void timedout(int);
328 static void increase_rcvbuf(int);
331 main(int argc
, char *argv
[])
333 int ch
, i
, fdsrmax
= 0, l
;
334 struct sockaddr_un sunx
, fromunix
;
335 struct sockaddr_storage frominet
;
337 char line
[MAXLINE
+ 1];
340 struct timeval tv
, *tvp
;
341 struct sigaction sact
;
342 struct funix
*fx
, *fx1
;
344 pid_t ppid
= 1, spid
;
348 while ((ch
= getopt(argc
, argv
, "468Aa:b:cCdf:kl:m:nNop:P:sS:Tuv"))
365 case 'a': /* allow specific network addresses only */
366 if (allowaddr(optarg
) == -1)
370 bindhostname
= optarg
;
378 case 'd': /* debug */
381 case 'f': /* configuration file */
384 case 'k': /* keep remote kern fac */
393 if (optarg
[0] == '/') {
396 } else if ((name
= strchr(optarg
, ':')) != NULL
) {
399 errx(1, "socket name must be absolute "
401 if (isdigit(*optarg
)) {
402 perml
= strtol(optarg
, &ep
, 8);
403 if (*ep
|| perml
< 0 ||
404 perml
& ~(S_IRWXU
|S_IRWXG
|S_IRWXO
))
405 errx(1, "invalid mode %s, exiting",
407 mode
= (mode_t
)perml
;
409 errx(1, "invalid mode %s, exiting",
411 } else /* doesn't begin with '/', and no ':' */
412 errx(1, "can't parse path %s", optarg
);
414 if (strlen(name
) >= sizeof(sunx
.sun_path
))
415 errx(1, "%s path too long, exiting", name
);
416 if ((fx
= malloc(sizeof(struct funix
))) == NULL
)
417 errx(1, "malloc failed");
421 STAILQ_INSERT_TAIL(&funixes
, fx
, next
);
424 case 'm': /* mark interval */
425 MarkInterval
= atoi(optarg
) * 60;
438 if (strlen(optarg
) >= sizeof(sunx
.sun_path
))
439 errx(1, "%s path too long, exiting", optarg
);
440 funix_default
.name
= optarg
;
442 case 'P': /* path for alt. PID */
445 case 's': /* no network mode */
448 case 'S': /* path for privileged originator */
449 if (strlen(optarg
) >= sizeof(sunx
.sun_path
))
450 errx(1, "%s path too long, exiting", optarg
);
451 funix_secure
.name
= optarg
;
456 case 'u': /* only log specified priority */
459 case 'v': /* log facility and priority */
465 if ((argc
-= optind
) != 0)
468 pfh
= pidfile_open(PidFile
, 0600, &spid
);
471 errx(1, "syslogd already running, pid: %d", spid
);
472 warn("cannot open pid file");
476 ppid
= waitdaemon(0, 0, 30);
478 warn("could not become daemon");
489 consfile
.f_type
= F_CONSOLE
;
490 (void)strlcpy(consfile
.f_un
.f_fname
, ctty
+ sizeof _PATH_DEV
- 1,
491 sizeof(consfile
.f_un
.f_fname
));
492 (void)strlcpy(bootfile
, getbootfile(), sizeof(bootfile
));
493 (void)signal(SIGTERM
, dodie
);
494 (void)signal(SIGINT
, Debug
? dodie
: SIG_IGN
);
495 (void)signal(SIGQUIT
, Debug
? dodie
: SIG_IGN
);
497 * We don't want the SIGCHLD and SIGHUP handlers to interfere
498 * with each other; they are likely candidates for being called
499 * simultaneously (SIGHUP closes pipe descriptor, process dies,
503 sigaddset(&mask
, SIGHUP
);
504 sact
.sa_handler
= reapchild
;
506 sact
.sa_flags
= SA_RESTART
;
507 (void)sigaction(SIGCHLD
, &sact
, NULL
);
508 (void)signal(SIGALRM
, domark
);
509 (void)signal(SIGPIPE
, SIG_IGN
); /* We'll catch EPIPE instead. */
510 (void)alarm(TIMERINTVL
);
512 TAILQ_INIT(&deadq_head
);
515 #define SUN_LEN(unp) (strlen((unp)->sun_path) + 2)
517 STAILQ_FOREACH_MUTABLE(fx
, &funixes
, next
, fx1
) {
518 (void)unlink(fx
->name
);
519 memset(&sunx
, 0, sizeof(sunx
));
520 sunx
.sun_family
= AF_LOCAL
;
521 (void)strlcpy(sunx
.sun_path
, fx
->name
, sizeof(sunx
.sun_path
));
522 fx
->s
= socket(PF_LOCAL
, SOCK_DGRAM
, 0);
524 bind(fx
->s
, (struct sockaddr
*)&sunx
, SUN_LEN(&sunx
)) < 0 ||
525 chmod(fx
->name
, fx
->mode
) < 0) {
526 (void)snprintf(line
, sizeof line
,
527 "cannot create %s", fx
->name
);
529 dprintf("cannot create %s (%d)\n", fx
->name
, errno
);
530 if (fx
== &funix_default
|| fx
== &funix_secure
)
533 STAILQ_REMOVE(&funixes
, fx
, funix
, next
);
537 increase_rcvbuf(fx
->s
);
540 finet
= socksetup(family
, bindhostname
);
544 for (i
= 0; i
< *finet
; i
++) {
545 if (shutdown(finet
[i
+1], SHUT_RD
) < 0) {
546 logerror("shutdown");
552 dprintf("listening on inet and/or inet6 socket\n");
554 dprintf("sending on inet and/or inet6 socket\n");
557 if ((fklog
= open(_PATH_KLOG
, O_RDONLY
, 0)) >= 0)
558 if (fcntl(fklog
, F_SETFL
, O_NONBLOCK
) < 0)
561 dprintf("can't open %s (%d)\n", _PATH_KLOG
, errno
);
563 /* tuck my process id away */
566 dprintf("off & running....\n");
569 /* prevent SIGHUP and SIGCHLD handlers from running in parallel */
571 sigaddset(&mask
, SIGCHLD
);
572 sact
.sa_handler
= init
;
574 sact
.sa_flags
= SA_RESTART
;
575 (void)sigaction(SIGHUP
, &sact
, NULL
);
578 tv
.tv_sec
= tv
.tv_usec
= 0;
580 if (fklog
!= -1 && fklog
> fdsrmax
)
582 if (finet
&& !SecureMode
) {
583 for (i
= 0; i
< *finet
; i
++) {
584 if (finet
[i
+1] != -1 && finet
[i
+1] > fdsrmax
)
585 fdsrmax
= finet
[i
+1];
588 STAILQ_FOREACH(fx
, &funixes
, next
)
592 fdsr
= (fd_set
*)calloc(howmany(fdsrmax
+1, NFDBITS
),
595 errx(1, "calloc fd_set");
603 bzero(fdsr
, howmany(fdsrmax
+1, NFDBITS
) *
608 if (finet
&& !SecureMode
) {
609 for (i
= 0; i
< *finet
; i
++) {
610 if (finet
[i
+1] != -1)
611 FD_SET(finet
[i
+1], fdsr
);
614 STAILQ_FOREACH(fx
, &funixes
, next
)
617 i
= select(fdsrmax
+1, fdsr
, NULL
, NULL
,
618 needdofsync
? &tv
: tvp
);
634 if (fklog
!= -1 && FD_ISSET(fklog
, fdsr
))
636 if (finet
&& !SecureMode
) {
637 for (i
= 0; i
< *finet
; i
++) {
638 if (FD_ISSET(finet
[i
+1], fdsr
)) {
639 len
= sizeof(frominet
);
640 l
= recvfrom(finet
[i
+1], line
, MAXLINE
,
641 0, (struct sockaddr
*)&frominet
,
645 hname
= cvthname((struct sockaddr
*)&frominet
);
646 unmapped((struct sockaddr
*)&frominet
);
647 if (validate((struct sockaddr
*)&frominet
, hname
))
648 printline(hname
, line
, RemoteAddDate
? ADDDATE
: 0);
649 } else if (l
< 0 && errno
!= EINTR
)
650 logerror("recvfrom inet");
654 STAILQ_FOREACH(fx
, &funixes
, next
) {
655 if (FD_ISSET(fx
->s
, fdsr
)) {
656 len
= sizeof(fromunix
);
657 l
= recvfrom(fx
->s
, line
, MAXLINE
, 0,
658 (struct sockaddr
*)&fromunix
, &len
);
661 printline(LocalHostName
, line
, 0);
662 } else if (l
< 0 && errno
!= EINTR
)
663 logerror("recvfrom unix");
672 unmapped(struct sockaddr
*sa
)
674 struct sockaddr_in6
*sin6
;
675 struct sockaddr_in sin4
;
677 if (sa
->sa_family
!= AF_INET6
)
679 if (sa
->sa_len
!= sizeof(struct sockaddr_in6
) ||
680 sizeof(sin4
) > sa
->sa_len
)
682 sin6
= (struct sockaddr_in6
*)sa
;
683 if (!IN6_IS_ADDR_V4MAPPED(&sin6
->sin6_addr
))
686 memset(&sin4
, 0, sizeof(sin4
));
687 sin4
.sin_family
= AF_INET
;
688 sin4
.sin_len
= sizeof(struct sockaddr_in
);
689 memcpy(&sin4
.sin_addr
, &sin6
->sin6_addr
.s6_addr
[12],
690 sizeof(sin4
.sin_addr
));
691 sin4
.sin_port
= sin6
->sin6_port
;
693 memcpy(sa
, &sin4
, sin4
.sin_len
);
700 fprintf(stderr
, "%s\n%s\n%s\n%s\n",
701 "usage: syslogd [-468ACcdknosTuv] [-a allowed_peer]",
702 " [-b bind_address] [-f config_file]",
703 " [-l [mode:]path] [-m mark_interval]",
704 " [-P pid_file] [-p log_socket]");
709 * Take a raw input line, decode the message, and print the message
710 * on the appropriate log files.
713 printline(const char *hname
, char *msg
, int flags
)
718 char line
[MAXLINE
+ 1];
720 /* test for special codes */
725 n
= strtol(p
+ 1, &q
, 10);
726 if (*q
== '>' && n
>= 0 && n
< INT_MAX
&& errno
== 0) {
731 if (pri
&~ (LOG_FACMASK
|LOG_PRIMASK
))
735 * Don't allow users to log kernel messages.
736 * NOTE: since LOG_KERN == 0 this will also match
737 * messages with no facility specified.
739 if ((pri
& LOG_FACMASK
) == LOG_KERN
&& !KeepKernFac
)
740 pri
= LOG_MAKEPRI(LOG_USER
, LOG_PRI(pri
));
744 while ((c
= (unsigned char)*p
++) != '\0' &&
745 q
< &line
[sizeof(line
) - 4]) {
746 if (mask_C1
&& (c
& 0x80) && c
< 0xA0) {
751 if (isascii(c
) && iscntrl(c
)) {
754 } else if (c
== '\t') {
766 logmsg(pri
, line
, hname
, flags
);
770 * Read /dev/klog while data are available, split into lines.
772 * Only dump whole lines, fixing potential write/read races that can
773 * cause lines to be split up due to the speed.
778 static char line
[MAXLINE
+ 1];
784 i
= read(fklog
, line
+ len
, MAXLINE
- 1 - len
);
786 line
[i
+ len
] = '\0';
788 if (i
< 0 && errno
!= EINTR
&& errno
!= EAGAIN
) {
795 for (p
= line
; (q
= strchr(p
, '\n')) != NULL
; p
= q
+ 1) {
800 if (len
>= MAXLINE
- 1) {
805 memmove(line
, p
, len
+ 1);
810 * Take a raw input line from /dev/klog, format similar to syslog().
817 int flags
, isprintf
, pri
;
819 flags
= ISKERNEL
| SYNC_FILE
| ADDDATE
; /* fsync after write */
825 n
= strtol(p
+ 1, &q
, 10);
826 if (*q
== '>' && n
>= 0 && n
< INT_MAX
&& errno
== 0) {
833 * Kernel printf's and LOG_CONSOLE messages have been displayed
834 * on the console already.
836 if (isprintf
|| (pri
& LOG_FACMASK
) == LOG_CONSOLE
)
838 if (pri
&~ (LOG_FACMASK
|LOG_PRIMASK
))
840 logmsg(pri
, p
, LocalHostName
, flags
);
846 * Match a program or host name against a specification.
847 * Return a non-0 value if the message must be ignored
848 * based on the specification.
851 skip_message(const char *name
, const char *spec
, int checkcase
)
856 /* Behaviour on explicit match */
871 s
= strstr (spec
, name
);
873 s
= strcasestr (spec
, name
);
876 prev
= (s
== spec
? ',' : *(s
- 1));
877 next
= *(s
+ strlen (name
));
879 if (prev
== ',' && (next
== '\0' || next
== ','))
880 /* Explicit match: skip iff the spec is an
885 /* No explicit match for this name: skip the message iff
886 the spec is an inclusive one. */
891 * Log a message to the appropriate log files, users, etc. based on
895 logmsg(int pri
, const char *msg
, const char *from
, int flags
)
898 int i
, fac
, msglen
, omask
, prilev
;
899 const char *timestamp
;
900 char prog
[NAME_MAX
+1];
903 dprintf("logmsg: pri %o, flags %x, from %s, msg %s\n",
904 pri
, flags
, from
, msg
);
906 omask
= sigblock(sigmask(SIGHUP
)|sigmask(SIGALRM
));
909 * Check to see if msg looks non-standard.
911 msglen
= strlen(msg
);
912 if (msglen
< 16 || msg
[3] != ' ' || msg
[6] != ' ' ||
913 msg
[9] != ':' || msg
[12] != ':' || msg
[15] != ' ')
917 if (flags
& ADDDATE
) {
918 timestamp
= ctime(&now
) + 4;
925 /* skip leading blanks */
926 while (isspace(*msg
)) {
931 /* extract facility and priority level */
933 fac
= LOG_NFACILITIES
;
937 /* Check maximum facility number. */
938 if (fac
> LOG_NFACILITIES
) {
939 (void)sigsetmask(omask
);
943 prilev
= LOG_PRI(pri
);
945 /* extract program name */
946 for (i
= 0; i
< NAME_MAX
; i
++) {
947 if (!isprint(msg
[i
]) || msg
[i
] == ':' || msg
[i
] == '[' ||
948 msg
[i
] == '/' || isspace(msg
[i
]))
954 /* add kernel prefix for kernel messages */
955 if (flags
& ISKERNEL
) {
956 snprintf(buf
, sizeof(buf
), "%s: %s",
957 use_bootfile
? bootfile
: "kernel", msg
);
959 msglen
= strlen(buf
);
962 /* log the message to the particular outputs */
966 * Open in non-blocking mode to avoid hangs during open
967 * and close(waiting for the port to drain).
969 f
->f_file
= open(ctty
, O_WRONLY
| O_NONBLOCK
, 0);
971 if (f
->f_file
>= 0) {
972 (void)strlcpy(f
->f_lasttime
, timestamp
,
973 sizeof(f
->f_lasttime
));
974 fprintlog(f
, flags
, msg
);
975 (void)close(f
->f_file
);
977 (void)sigsetmask(omask
);
980 for (f
= Files
; f
; f
= f
->f_next
) {
981 /* skip messages that are incorrect priority */
982 if (!(((f
->f_pcmp
[fac
] & PRI_EQ
) && (f
->f_pmask
[fac
] == prilev
))
983 ||((f
->f_pcmp
[fac
] & PRI_LT
) && (f
->f_pmask
[fac
] < prilev
))
984 ||((f
->f_pcmp
[fac
] & PRI_GT
) && (f
->f_pmask
[fac
] > prilev
))
986 || f
->f_pmask
[fac
] == INTERNAL_NOPRI
)
989 /* skip messages with the incorrect hostname */
990 if (skip_message(from
, f
->f_host
, 0))
993 /* skip messages with the incorrect program name */
994 if (skip_message(prog
, f
->f_program
, 1))
997 /* skip message to console if it has already been printed */
998 if (f
->f_type
== F_CONSOLE
&& (flags
& IGN_CONS
))
1001 /* don't output marks to recently written files */
1002 if ((flags
& MARK
) && (now
- f
->f_time
) < MarkInterval
/ 2)
1006 * suppress duplicate lines to this file
1008 if (no_compress
- (f
->f_type
!= F_PIPE
) < 1 &&
1009 (flags
& MARK
) == 0 && msglen
== f
->f_prevlen
&&
1010 f
->f_prevline
&& !strcmp(msg
, f
->f_prevline
) &&
1011 !strcasecmp(from
, f
->f_prevhost
)) {
1012 (void)strlcpy(f
->f_lasttime
, timestamp
,
1013 sizeof(f
->f_lasttime
));
1015 dprintf("msg repeated %d times, %ld sec of %d\n",
1016 f
->f_prevcount
, (long)(now
- f
->f_time
),
1017 repeatinterval
[f
->f_repeatcount
]);
1019 * If domark would have logged this by now,
1020 * flush it now (so we don't hold isolated messages),
1021 * but back off so we'll flush less often
1024 if (now
> REPEATTIME(f
)) {
1025 fprintlog(f
, flags
, NULL
);
1029 /* new line, save it */
1031 fprintlog(f
, 0, NULL
);
1032 f
->f_repeatcount
= 0;
1034 (void)strlcpy(f
->f_lasttime
, timestamp
,
1035 sizeof(f
->f_lasttime
));
1036 (void)strlcpy(f
->f_prevhost
, from
,
1037 sizeof(f
->f_prevhost
));
1038 if (msglen
< MAXSVLINE
) {
1039 f
->f_prevlen
= msglen
;
1040 (void)strlcpy(f
->f_prevline
, msg
, sizeof(f
->f_prevline
));
1041 fprintlog(f
, flags
, NULL
);
1043 f
->f_prevline
[0] = 0;
1045 fprintlog(f
, flags
, msg
);
1049 (void)sigsetmask(omask
);
1057 for (f
= Files
; f
; f
= f
->f_next
) {
1058 if ((f
->f_type
== F_FILE
) &&
1059 (f
->f_flags
& FFLAG_NEEDSYNC
)) {
1060 f
->f_flags
&= ~FFLAG_NEEDSYNC
;
1061 (void)fsync(f
->f_file
);
1068 fprintlog(struct filed
*f
, int flags
, const char *msg
)
1070 struct iovec iov
[IOV_SIZE
];
1073 int i
, l
, lsent
= 0;
1074 char line
[MAXLINE
+ 1], repbuf
[80], greetings
[200], *wmsg
= NULL
;
1075 char nul
[] = "", space
[] = " ", lf
[] = "\n", crlf
[] = "\r\n";
1079 if (f
->f_type
== F_WALL
) {
1080 v
->iov_base
= greetings
;
1081 /* The time displayed is not synchornized with the other log
1082 * destinations (like messages). Following fragment was using
1083 * ctime(&now), which was updating the time every 30 sec.
1084 * With f_lasttime, time is synchronized correctly.
1086 v
->iov_len
= snprintf(greetings
, sizeof greetings
,
1087 "\r\n\7Message from syslogd@%s at %.24s ...\r\n",
1088 f
->f_prevhost
, f
->f_lasttime
);
1089 if (v
->iov_len
>= sizeof greetings
)
1090 v
->iov_len
= sizeof greetings
- 1;
1096 v
->iov_base
= f
->f_lasttime
;
1097 v
->iov_len
= strlen(f
->f_lasttime
);
1099 v
->iov_base
= space
;
1105 static char fp_buf
[30]; /* Hollow laugh */
1106 int fac
= f
->f_prevpri
& LOG_FACMASK
;
1107 int pri
= LOG_PRI(f
->f_prevpri
);
1108 const char *f_s
= NULL
;
1109 char f_n
[5]; /* Hollow laugh */
1110 const char *p_s
= NULL
;
1111 char p_n
[5]; /* Hollow laugh */
1113 if (LogFacPri
> 1) {
1116 for (c
= facilitynames
; c
->c_name
; c
++) {
1117 if (c
->c_val
== fac
) {
1122 for (c
= prioritynames
; c
->c_name
; c
++) {
1123 if (c
->c_val
== pri
) {
1130 snprintf(f_n
, sizeof f_n
, "%d", LOG_FAC(fac
));
1134 snprintf(p_n
, sizeof p_n
, "%d", pri
);
1137 snprintf(fp_buf
, sizeof fp_buf
, "<%s.%s> ", f_s
, p_s
);
1138 v
->iov_base
= fp_buf
;
1139 v
->iov_len
= strlen(fp_buf
);
1146 v
->iov_base
= f
->f_prevhost
;
1147 v
->iov_len
= strlen(v
->iov_base
);
1149 v
->iov_base
= space
;
1154 wmsg
= strdup(msg
); /* XXX iov_base needs a `const' sibling. */
1160 v
->iov_len
= strlen(msg
);
1161 } else if (f
->f_prevcount
> 1) {
1162 v
->iov_base
= repbuf
;
1163 v
->iov_len
= snprintf(repbuf
, sizeof repbuf
,
1164 "last message repeated %d times", f
->f_prevcount
);
1165 } else if (f
->f_prevline
) {
1166 v
->iov_base
= f
->f_prevline
;
1167 v
->iov_len
= f
->f_prevlen
;
1173 dprintf("Logging to %s", TypeNames
[f
->f_type
]);
1176 switch (f
->f_type
) {
1183 port
= (int)ntohs(((struct sockaddr_in
*)
1184 (f
->f_un
.f_forw
.f_addr
->ai_addr
))->sin_port
);
1186 dprintf(" %s:%d\n", f
->f_un
.f_forw
.f_hname
, port
);
1188 dprintf(" %s\n", f
->f_un
.f_forw
.f_hname
);
1190 /* check for local vs remote messages */
1191 if (strcasecmp(f
->f_prevhost
, LocalHostName
))
1192 l
= snprintf(line
, sizeof line
- 1,
1193 "<%d>%.15s Forwarded from %s: %s",
1194 f
->f_prevpri
, (char *)iov
[0].iov_base
,
1195 f
->f_prevhost
, (char *)iov
[5].iov_base
);
1197 l
= snprintf(line
, sizeof line
- 1, "<%d>%.15s %s",
1198 f
->f_prevpri
, (char *)iov
[0].iov_base
,
1199 (char *)iov
[5].iov_base
);
1202 else if (l
> MAXLINE
)
1206 for (r
= f
->f_un
.f_forw
.f_addr
; r
; r
= r
->ai_next
) {
1207 for (i
= 0; i
< *finet
; i
++) {
1210 * should we check AF first, or just
1211 * trial and error? FWD
1214 address_family_of(finet
[i
+1]))
1216 lsent
= sendto(finet
[i
+1], line
, l
, 0,
1217 r
->ai_addr
, r
->ai_addrlen
);
1221 if (lsent
== l
&& !send_to_all
)
1224 dprintf("lsent/l: %d/%d\n", lsent
, l
);
1239 /* case ENOTSOCK: */
1241 /* case EMSGSIZE: */
1244 /* case ECONNREFUSED: */
1246 dprintf("removing entry: errno=%d\n", e
);
1247 f
->f_type
= F_UNUSED
;
1255 dprintf(" %s\n", f
->f_un
.f_fname
);
1258 if (writev(f
->f_file
, iov
, IOV_SIZE
) < 0) {
1260 * If writev(2) fails for potentially transient errors
1261 * like the filesystem being full, ignore it.
1262 * Otherwise remove this logfile from the list.
1264 if (errno
!= ENOSPC
) {
1266 (void)close(f
->f_file
);
1267 f
->f_type
= F_UNUSED
;
1269 logerror(f
->f_un
.f_fname
);
1271 } else if ((flags
& SYNC_FILE
) && (f
->f_flags
& FFLAG_SYNC
)) {
1272 f
->f_flags
|= FFLAG_NEEDSYNC
;
1278 dprintf(" %s\n", f
->f_un
.f_pipe
.f_pname
);
1281 if (f
->f_un
.f_pipe
.f_pid
== 0) {
1282 if ((f
->f_file
= p_open(f
->f_un
.f_pipe
.f_pname
,
1283 &f
->f_un
.f_pipe
.f_pid
)) < 0) {
1284 f
->f_type
= F_UNUSED
;
1285 logerror(f
->f_un
.f_pipe
.f_pname
);
1289 if (writev(f
->f_file
, iov
, IOV_SIZE
) < 0) {
1291 (void)close(f
->f_file
);
1292 if (f
->f_un
.f_pipe
.f_pid
> 0)
1293 deadq_enter(f
->f_un
.f_pipe
.f_pid
,
1294 f
->f_un
.f_pipe
.f_pname
);
1295 f
->f_un
.f_pipe
.f_pid
= 0;
1297 logerror(f
->f_un
.f_pipe
.f_pname
);
1302 if (flags
& IGN_CONS
) {
1303 dprintf(" (ignored)\n");
1309 dprintf(" %s%s\n", _PATH_DEV
, f
->f_un
.f_fname
);
1313 errno
= 0; /* ttymsg() only sometimes returns an errno */
1314 if ((msgret
= ttymsg(iov
, IOV_SIZE
, f
->f_un
.f_fname
, 10))) {
1315 f
->f_type
= F_UNUSED
;
1325 wallmsg(f
, iov
, IOV_SIZE
);
1333 * WALLMSG -- Write a message to the world at large
1335 * Write the specified message to either the entire
1336 * world, or a list of approved users.
1339 wallmsg(struct filed
*f
, struct iovec
*iov
, const int iovlen
)
1341 static int reenter
; /* avoid calling ourselves */
1350 while ((ut
= getutxent()) != NULL
) {
1351 if (ut
->ut_type
!= USER_PROCESS
)
1353 if (f
->f_type
== F_WALL
) {
1354 if ((p
= ttymsg(iov
, iovlen
, ut
->ut_line
,
1355 TTYMSGTIME
)) != NULL
) {
1356 errno
= 0; /* already in msg */
1361 /* should we send the message to this user? */
1362 for (i
= 0; i
< MAXUNAMES
; i
++) {
1363 if (!f
->f_un
.f_uname
[i
][0])
1365 if (!strcmp(f
->f_un
.f_uname
[i
], ut
->ut_user
)) {
1366 if ((p
= ttymsg(iov
, iovlen
, ut
->ut_line
,
1367 TTYMSGTIME
)) != NULL
) {
1368 errno
= 0; /* already in msg */
1380 reapchild(int signo __unused
)
1386 while ((pid
= wait3(&status
, WNOHANG
, NULL
)) > 0) {
1388 /* Don't tell while we are initting. */
1391 /* First, look if it's a process from the dead queue. */
1392 if (deadq_remove(pid
))
1395 /* Now, look in list of active processes. */
1396 for (f
= Files
; f
; f
= f
->f_next
) {
1397 if (f
->f_type
== F_PIPE
&&
1398 f
->f_un
.f_pipe
.f_pid
== pid
) {
1399 (void)close(f
->f_file
);
1400 f
->f_un
.f_pipe
.f_pid
= 0;
1401 log_deadchild(pid
, status
,
1402 f
->f_un
.f_pipe
.f_pname
);
1410 * Return a printable representation of a host address.
1413 cvthname(struct sockaddr
*f
)
1416 sigset_t omask
, nmask
;
1417 static char hname
[NI_MAXHOST
], ip
[NI_MAXHOST
];
1419 error
= getnameinfo((struct sockaddr
*)f
,
1420 ((struct sockaddr
*)f
)->sa_len
,
1421 ip
, sizeof ip
, NULL
, 0, NI_NUMERICHOST
);
1422 dprintf("cvthname(%s)\n", ip
);
1425 dprintf("Malformed from address %s\n", gai_strerror(error
));
1431 sigemptyset(&nmask
);
1432 sigaddset(&nmask
, SIGHUP
);
1433 sigprocmask(SIG_BLOCK
, &nmask
, &omask
);
1434 error
= getnameinfo((struct sockaddr
*)f
,
1435 ((struct sockaddr
*)f
)->sa_len
,
1436 hname
, sizeof hname
, NULL
, 0, NI_NAMEREQD
);
1437 sigprocmask(SIG_SETMASK
, &omask
, NULL
);
1439 dprintf("Host name for your address (%s) unknown\n", ip
);
1443 if (hl
> 0 && hname
[hl
-1] == '.')
1445 trimdomain(hname
, hl
);
1457 domark(int signo __unused
)
1464 * Print syslogd errors some place.
1467 logerror(const char *type
)
1470 static int recursed
= 0;
1472 /* If there's an error while trying to log an error, give up. */
1478 sizeof buf
, "syslogd: %s: %s", type
, strerror(errno
));
1480 (void)snprintf(buf
, sizeof buf
, "syslogd: %s", type
);
1482 dprintf("%s\n", buf
);
1483 logmsg(LOG_SYSLOG
|LOG_ERR
, buf
, LocalHostName
, ADDDATE
);
1492 int was_initialized
;
1495 was_initialized
= Initialized
;
1496 Initialized
= 0; /* Don't log SIGCHLDs. */
1497 for (f
= Files
; f
!= NULL
; f
= f
->f_next
) {
1498 /* flush any pending output */
1500 fprintlog(f
, 0, NULL
);
1501 if (f
->f_type
== F_PIPE
&& f
->f_un
.f_pipe
.f_pid
> 0) {
1502 (void)close(f
->f_file
);
1503 f
->f_un
.f_pipe
.f_pid
= 0;
1506 Initialized
= was_initialized
;
1508 dprintf("syslogd: exiting on signal %d\n", signo
);
1509 (void)snprintf(buf
, sizeof(buf
), "exiting on signal %d", signo
);
1513 STAILQ_FOREACH(fx
, &funixes
, next
)
1514 (void)unlink(fx
->name
);
1515 pidfile_remove(pfh
);
1521 * INIT -- Initialize syslogd from configuration table
1528 struct filed
*f
, *next
, **nextp
;
1530 char cline
[LINE_MAX
];
1531 char prog
[NAME_MAX
+1];
1532 char host
[MAXHOSTNAMELEN
];
1533 char oldLocalHostName
[MAXHOSTNAMELEN
];
1534 char hostMsg
[2*MAXHOSTNAMELEN
+40];
1535 char bootfileMsg
[LINE_MAX
];
1540 * Load hostname (may have changed).
1543 (void)strlcpy(oldLocalHostName
, LocalHostName
,
1544 sizeof(oldLocalHostName
));
1545 if (gethostname(LocalHostName
, sizeof(LocalHostName
)))
1546 err(EX_OSERR
, "gethostname() failed");
1547 if ((p
= strchr(LocalHostName
, '.')) != NULL
) {
1555 * Close all open log files.
1558 for (f
= Files
; f
!= NULL
; f
= next
) {
1559 /* flush any pending output */
1561 fprintlog(f
, 0, NULL
);
1563 switch (f
->f_type
) {
1568 (void)close(f
->f_file
);
1571 if (f
->f_un
.f_pipe
.f_pid
> 0) {
1572 (void)close(f
->f_file
);
1573 deadq_enter(f
->f_un
.f_pipe
.f_pid
,
1574 f
->f_un
.f_pipe
.f_pname
);
1576 f
->f_un
.f_pipe
.f_pid
= 0;
1580 if (f
->f_program
) free(f
->f_program
);
1581 if (f
->f_host
) free(f
->f_host
);
1587 /* open the configuration file */
1588 if ((cf
= fopen(ConfFile
, "r")) == NULL
) {
1589 dprintf("cannot open %s\n", ConfFile
);
1590 *nextp
= (struct filed
*)calloc(1, sizeof(*f
));
1591 if (*nextp
== NULL
) {
1595 cfline("*.ERR\t/dev/console", *nextp
, "*", "*");
1596 (*nextp
)->f_next
= (struct filed
*)calloc(1, sizeof(*f
));
1597 if ((*nextp
)->f_next
== NULL
) {
1601 cfline("*.PANIC\t*", (*nextp
)->f_next
, "*", "*");
1607 * Foreach line in the conf table, open that file.
1610 (void)strlcpy(host
, "*", sizeof(host
));
1611 (void)strlcpy(prog
, "*", sizeof(prog
));
1612 while (fgets(cline
, sizeof(cline
), cf
) != NULL
) {
1614 * check for end-of-section, comments, strip off trailing
1615 * spaces and newline character. #!prog is treated specially:
1616 * following lines apply only to that program.
1618 for (p
= cline
; isspace(*p
); ++p
)
1624 if (*p
!= '!' && *p
!= '+' && *p
!= '-')
1627 if (*p
== '+' || *p
== '-') {
1631 if ((!*p
) || (*p
== '*')) {
1632 (void)strlcpy(host
, "*", sizeof(host
));
1637 for (i
= 1; i
< MAXHOSTNAMELEN
- 1; i
++) {
1638 if (!isalnum(*p
) && *p
!= '.' && *p
!= '-'
1639 && *p
!= ',' && *p
!= ':' && *p
!= '%')
1648 while (isspace(*p
)) p
++;
1649 if ((!*p
) || (*p
== '*')) {
1650 (void)strlcpy(prog
, "*", sizeof(prog
));
1653 for (i
= 0; i
< NAME_MAX
; i
++) {
1654 if (!isprint(p
[i
]) || isspace(p
[i
]))
1661 for (p
= cline
+ 1; *p
!= '\0'; p
++) {
1664 if (*(p
- 1) == '\\') {
1672 for (i
= strlen(cline
) - 1; i
>= 0 && isspace(cline
[i
]); i
--)
1674 f
= (struct filed
*)calloc(1, sizeof(*f
));
1681 cfline(cline
, f
, prog
, host
);
1684 /* close the configuration file */
1691 for (f
= Files
; f
; f
= f
->f_next
) {
1692 for (i
= 0; i
<= LOG_NFACILITIES
; i
++)
1693 if (f
->f_pmask
[i
] == INTERNAL_NOPRI
)
1696 printf("%d ", f
->f_pmask
[i
]);
1697 printf("%s: ", TypeNames
[f
->f_type
]);
1698 switch (f
->f_type
) {
1700 printf("%s", f
->f_un
.f_fname
);
1705 printf("%s%s", _PATH_DEV
, f
->f_un
.f_fname
);
1709 port
= (int)ntohs(((struct sockaddr_in
*)
1710 (f
->f_un
.f_forw
.f_addr
->ai_addr
))->sin_port
);
1713 f
->f_un
.f_forw
.f_hname
, port
);
1715 printf("%s", f
->f_un
.f_forw
.f_hname
);
1720 printf("%s", f
->f_un
.f_pipe
.f_pname
);
1724 for (i
= 0; i
< MAXUNAMES
&& *f
->f_un
.f_uname
[i
]; i
++)
1725 printf("%s, ", f
->f_un
.f_uname
[i
]);
1729 printf(" (%s)", f
->f_program
);
1734 logmsg(LOG_SYSLOG
|LOG_INFO
, "syslogd: restart", LocalHostName
, ADDDATE
);
1735 dprintf("syslogd: restarted\n");
1737 * Log a change in hostname, but only on a restart.
1739 if (signo
!= 0 && strcmp(oldLocalHostName
, LocalHostName
) != 0) {
1740 (void)snprintf(hostMsg
, sizeof(hostMsg
),
1741 "syslogd: hostname changed, \"%s\" to \"%s\"",
1742 oldLocalHostName
, LocalHostName
);
1743 logmsg(LOG_SYSLOG
|LOG_INFO
, hostMsg
, LocalHostName
, ADDDATE
);
1744 dprintf("%s\n", hostMsg
);
1747 * Log the kernel boot file if we aren't going to use it as
1748 * the prefix, and if this is *not* a restart.
1750 if (signo
== 0 && !use_bootfile
) {
1751 (void)snprintf(bootfileMsg
, sizeof(bootfileMsg
),
1752 "syslogd: kernel boot file is %s", bootfile
);
1753 logmsg(LOG_KERN
|LOG_INFO
, bootfileMsg
, LocalHostName
, ADDDATE
);
1754 dprintf("%s\n", bootfileMsg
);
1759 * Crack a configuration file line
1762 cfline(const char *line
, struct filed
*f
, const char *prog
, const char *host
)
1764 struct addrinfo hints
, *res
;
1765 int error
, i
, pri
, syncfile
;
1768 char buf
[MAXLINE
], ebuf
[100];
1770 dprintf("cfline(\"%s\", f, \"%s\", \"%s\")\n", line
, prog
, host
);
1772 errno
= 0; /* keep strerror() stuff out of logerror messages */
1774 /* clear out file entry */
1775 memset(f
, 0, sizeof(*f
));
1776 for (i
= 0; i
<= LOG_NFACILITIES
; i
++)
1777 f
->f_pmask
[i
] = INTERNAL_NOPRI
;
1779 /* save hostname if any */
1780 if (host
&& *host
== '*')
1785 f
->f_host
= strdup(host
);
1786 if (f
->f_host
== NULL
) {
1790 hl
= strlen(f
->f_host
);
1791 if (hl
> 0 && f
->f_host
[hl
-1] == '.')
1792 f
->f_host
[--hl
] = '\0';
1793 trimdomain(f
->f_host
, hl
);
1796 /* save program name if any */
1797 if (prog
&& *prog
== '*')
1800 f
->f_program
= strdup(prog
);
1801 if (f
->f_program
== NULL
) {
1807 /* scan through the list of selectors */
1808 for (p
= line
; *p
&& *p
!= '\t' && *p
!= ' ';) {
1813 /* find the end of this facility name list */
1814 for (q
= p
; *q
&& *q
!= '\t' && *q
!= ' ' && *q
++ != '.'; )
1817 /* get the priority comparison */
1845 /* collect priority name */
1846 for (bp
= buf
; *q
&& !strchr("\t,; ", *q
); )
1851 while (strchr(",;", *q
))
1854 /* decode priority name */
1857 pri_cmp
= PRI_LT
| PRI_EQ
| PRI_GT
;
1859 /* Ignore trailing spaces. */
1860 for (i
= strlen(buf
) - 1; i
>= 0 && buf
[i
] == ' '; i
--)
1863 pri
= decode(buf
, prioritynames
);
1866 (void)snprintf(ebuf
, sizeof ebuf
,
1867 "unknown priority name \"%s\"", buf
);
1873 pri_cmp
= (UniquePriority
)
1878 pri_cmp
^= PRI_LT
| PRI_EQ
| PRI_GT
;
1880 /* scan facilities */
1881 while (*p
&& !strchr("\t.; ", *p
)) {
1882 for (bp
= buf
; *p
&& !strchr("\t,;. ", *p
); )
1887 for (i
= 0; i
< LOG_NFACILITIES
; i
++) {
1888 f
->f_pmask
[i
] = pri
;
1889 f
->f_pcmp
[i
] = pri_cmp
;
1892 i
= decode(buf
, facilitynames
);
1895 (void)snprintf(ebuf
, sizeof ebuf
,
1896 "unknown facility name \"%s\"",
1901 f
->f_pmask
[i
>> 3] = pri
;
1902 f
->f_pcmp
[i
>> 3] = pri_cmp
;
1904 while (*p
== ',' || *p
== ' ')
1911 /* skip to action part */
1912 while (*p
== '\t' || *p
== ' ')
1927 * scan forward to see if there is a port defined.
1928 * so we can't use strlcpy..
1930 i
= sizeof(f
->f_un
.f_forw
.f_hname
);
1931 tp
= f
->f_un
.f_forw
.f_hname
;
1935 * an ipv6 address should start with a '[' in that case
1936 * we should scan for a ']'
1942 while (*p
&& (*p
!= endkey
) && (i
-- > 0)) {
1945 if (endkey
== ']' && *p
== endkey
)
1949 /* See if we copied a domain and have a port */
1955 memset(&hints
, 0, sizeof(hints
));
1956 hints
.ai_family
= family
;
1957 hints
.ai_socktype
= SOCK_DGRAM
;
1958 error
= getaddrinfo(f
->f_un
.f_forw
.f_hname
,
1959 p
? p
: "syslog", &hints
, &res
);
1961 logerror(gai_strerror(error
));
1964 f
->f_un
.f_forw
.f_addr
= res
;
1969 if ((f
->f_file
= open(p
, logflags
, 0600)) < 0) {
1970 f
->f_type
= F_UNUSED
;
1975 f
->f_flags
|= FFLAG_SYNC
;
1976 if (isatty(f
->f_file
)) {
1977 if (strcmp(p
, ctty
) == 0)
1978 f
->f_type
= F_CONSOLE
;
1981 (void)strlcpy(f
->f_un
.f_fname
, p
+ sizeof(_PATH_DEV
) - 1,
1982 sizeof(f
->f_un
.f_fname
));
1984 (void)strlcpy(f
->f_un
.f_fname
, p
, sizeof(f
->f_un
.f_fname
));
1990 f
->f_un
.f_pipe
.f_pid
= 0;
1991 (void)strlcpy(f
->f_un
.f_pipe
.f_pname
, p
+ 1,
1992 sizeof(f
->f_un
.f_pipe
.f_pname
));
2001 for (i
= 0; i
< MAXUNAMES
&& *p
; i
++) {
2002 for (q
= p
; *q
&& *q
!= ','; )
2004 (void)strncpy(f
->f_un
.f_uname
[i
], p
, MAXLOGNAME
- 1);
2005 if ((q
- p
) >= MAXLOGNAME
)
2006 f
->f_un
.f_uname
[i
][MAXLOGNAME
- 1] = '\0';
2008 f
->f_un
.f_uname
[i
][q
- p
] = '\0';
2009 while (*q
== ',' || *q
== ' ')
2013 f
->f_type
= F_USERS
;
2020 * Decode a symbolic name to a numeric value
2023 decode(const char *name
, const CODE
*codetab
)
2029 return (atoi(name
));
2031 for (p
= buf
; *name
&& p
< &buf
[sizeof(buf
) - 1]; p
++, name
++) {
2033 *p
= tolower(*name
);
2038 for (c
= codetab
; c
->c_name
; c
++)
2039 if (!strcmp(buf
, c
->c_name
))
2052 MarkSeq
+= TIMERINTVL
;
2053 if (MarkSeq
>= MarkInterval
) {
2054 logmsg(LOG_INFO
, "-- MARK --",
2055 LocalHostName
, ADDDATE
|MARK
);
2059 for (f
= Files
; f
; f
= f
->f_next
) {
2060 if (f
->f_prevcount
&& now
>= REPEATTIME(f
)) {
2061 dprintf("flush %s: repeated %d times, %d sec.\n",
2062 TypeNames
[f
->f_type
], f
->f_prevcount
,
2063 repeatinterval
[f
->f_repeatcount
]);
2064 fprintlog(f
, 0, NULL
);
2069 /* Walk the dead queue, and see if we should signal somebody. */
2070 for (q
= TAILQ_FIRST(&deadq_head
); q
!= NULL
; q
= next
) {
2071 next
= TAILQ_NEXT(q
, dq_entries
);
2073 switch (q
->dq_timeout
) {
2075 /* Already signalled once, try harder now. */
2076 if (kill(q
->dq_pid
, SIGKILL
) != 0)
2077 (void)deadq_remove(q
->dq_pid
);
2082 * Timed out on dead queue, send terminate
2083 * signal. Note that we leave the removal
2084 * from the dead queue to reapchild(), which
2085 * will also log the event (unless the process
2086 * didn't even really exist, in case we simply
2087 * drop it from the dead queue).
2089 if (kill(q
->dq_pid
, SIGTERM
) != 0)
2090 (void)deadq_remove(q
->dq_pid
);
2098 (void)alarm(TIMERINTVL
);
2102 * fork off and become a daemon, but wait for the child to come online
2103 * before returing to the parent, or we get disk thrashing at boot etc.
2104 * Set a timer so we don't hang forever if it wedges.
2107 waitdaemon(int nochdir
, int noclose
, int maxwait
)
2111 pid_t pid
, childpid
;
2113 switch (childpid
= fork()) {
2119 signal(SIGALRM
, timedout
);
2121 while ((pid
= wait3(&status
, 0, NULL
)) != -1) {
2122 if (WIFEXITED(status
))
2123 errx(1, "child pid %d exited with return code %d",
2124 pid
, WEXITSTATUS(status
));
2125 if (WIFSIGNALED(status
))
2126 errx(1, "child pid %d exited on signal %d%s",
2127 pid
, WTERMSIG(status
),
2128 WCOREDUMP(status
) ? " (core dumped)" :
2130 if (pid
== childpid
) /* it's gone... */
2142 if (!noclose
&& (fd
= open(_PATH_DEVNULL
, O_RDWR
, 0)) != -1) {
2143 (void)dup2(fd
, STDIN_FILENO
);
2144 (void)dup2(fd
, STDOUT_FILENO
);
2145 (void)dup2(fd
, STDERR_FILENO
);
2153 * We get a SIGALRM from the child when it's running and finished doing it's
2154 * fsync()'s or O_SYNC writes for all the boot messages.
2156 * We also get a signal from the kernel if the timer expires, so check to
2157 * see what happened.
2160 timedout(int sig __unused
)
2164 signal(SIGALRM
, SIG_DFL
);
2166 errx(1, "timed out waiting for child");
2172 * Add `s' to the list of allowable peer addresses to accept messages
2175 * `s' is a string in the form:
2177 * [*]domainname[:{servicename|portnumber|*}]
2181 * netaddr/maskbits[:{servicename|portnumber|*}]
2183 * Returns -1 on error, 0 if the argument was valid.
2189 struct allowedpeer ap
;
2192 struct addrinfo hints
, *res
;
2193 struct in_addr
*addrp
, *maskp
;
2196 u_int32_t
*addr6p
, *mask6p
;
2198 char ip
[NI_MAXHOST
];
2201 if (*s
!= '[' || (cp1
= strchr(s
+ 1, ']')) == NULL
)
2204 if ((cp1
= strrchr(cp1
, ':'))) {
2205 /* service/port provided */
2207 if (strlen(cp1
) == 1 && *cp1
== '*')
2208 /* any port allowed */
2210 else if ((se
= getservbyname(cp1
, "udp"))) {
2211 ap
.port
= ntohs(se
->s_port
);
2213 ap
.port
= strtol(cp1
, &cp2
, 0);
2215 return (-1); /* port not numeric */
2218 if ((se
= getservbyname("syslog", "udp")))
2219 ap
.port
= ntohs(se
->s_port
);
2221 /* sanity, should not happen */
2225 if ((cp1
= strchr(s
, '/')) != NULL
&&
2226 strspn(cp1
+ 1, "0123456789") == strlen(cp1
+ 1)) {
2228 if ((masklen
= atoi(cp1
+ 1)) < 0)
2233 cp2
= s
+ strlen(s
) - 1;
2244 memset(&hints
, 0, sizeof(hints
));
2245 hints
.ai_family
= PF_UNSPEC
;
2246 hints
.ai_socktype
= SOCK_DGRAM
;
2247 hints
.ai_flags
= AI_PASSIVE
| AI_NUMERICHOST
;
2248 if (getaddrinfo(s
, NULL
, &hints
, &res
) == 0) {
2250 memcpy(&ap
.a_addr
, res
->ai_addr
, res
->ai_addrlen
);
2251 memset(&ap
.a_mask
, 0, sizeof(ap
.a_mask
));
2252 ap
.a_mask
.ss_family
= res
->ai_family
;
2253 if (res
->ai_family
== AF_INET
) {
2254 ap
.a_mask
.ss_len
= sizeof(struct sockaddr_in
);
2255 maskp
= &((struct sockaddr_in
*)&ap
.a_mask
)->sin_addr
;
2256 addrp
= &((struct sockaddr_in
*)&ap
.a_addr
)->sin_addr
;
2258 /* use default netmask */
2259 if (IN_CLASSA(ntohl(addrp
->s_addr
)))
2260 maskp
->s_addr
= htonl(IN_CLASSA_NET
);
2261 else if (IN_CLASSB(ntohl(addrp
->s_addr
)))
2262 maskp
->s_addr
= htonl(IN_CLASSB_NET
);
2264 maskp
->s_addr
= htonl(IN_CLASSC_NET
);
2265 } else if (masklen
<= 32) {
2266 /* convert masklen to netmask */
2270 maskp
->s_addr
= htonl(~((1 << (32 - masklen
)) - 1));
2275 /* Lose any host bits in the network number. */
2276 addrp
->s_addr
&= maskp
->s_addr
;
2279 else if (res
->ai_family
== AF_INET6
&& masklen
<= 128) {
2280 ap
.a_mask
.ss_len
= sizeof(struct sockaddr_in6
);
2283 mask6p
= (u_int32_t
*)&((struct sockaddr_in6
*)&ap
.a_mask
)->sin6_addr
;
2284 /* convert masklen to netmask */
2285 while (masklen
> 0) {
2287 *mask6p
= htonl(~(0xffffffff >> masklen
));
2290 *mask6p
++ = 0xffffffff;
2293 /* Lose any host bits in the network number. */
2294 mask6p
= (u_int32_t
*)&((struct sockaddr_in6
*)&ap
.a_mask
)->sin6_addr
;
2295 addr6p
= (u_int32_t
*)&((struct sockaddr_in6
*)&ap
.a_addr
)->sin6_addr
;
2296 for (i
= 0; i
< 4; i
++)
2297 addr6p
[i
] &= mask6p
[i
];
2306 /* arg `s' is domain name */
2320 printf("allowaddr: rule %d: ", NumAllowed
);
2322 printf("numeric, ");
2323 getnameinfo((struct sockaddr
*)&ap
.a_addr
,
2324 ((struct sockaddr
*)&ap
.a_addr
)->sa_len
,
2325 ip
, sizeof ip
, NULL
, 0, NI_NUMERICHOST
);
2326 printf("addr = %s, ", ip
);
2327 getnameinfo((struct sockaddr
*)&ap
.a_mask
,
2328 ((struct sockaddr
*)&ap
.a_mask
)->sa_len
,
2329 ip
, sizeof ip
, NULL
, 0, NI_NUMERICHOST
);
2330 printf("mask = %s; ", ip
);
2332 printf("domainname = %s; ", ap
.a_name
);
2334 printf("port = %d\n", ap
.port
);
2337 if ((AllowedPeers
= realloc(AllowedPeers
,
2338 ++NumAllowed
* sizeof(struct allowedpeer
)))
2340 logerror("realloc");
2343 memcpy(&AllowedPeers
[NumAllowed
- 1], &ap
, sizeof(struct allowedpeer
));
2348 * Validate that the remote peer has permission to log to us.
2351 validate(struct sockaddr
*sa
, const char *hname
)
2355 char *cp
, name
[NI_MAXHOST
], ip
[NI_MAXHOST
], port
[NI_MAXSERV
];
2356 struct allowedpeer
*ap
;
2357 struct sockaddr_in
*sin4
, *a4p
= NULL
, *m4p
= NULL
;
2360 struct sockaddr_in6
*sin6
, *a6p
= NULL
, *m6p
= NULL
;
2362 struct addrinfo hints
, *res
;
2365 if (NumAllowed
== 0)
2366 /* traditional behaviour, allow everything */
2369 (void)strlcpy(name
, hname
, sizeof(name
));
2370 memset(&hints
, 0, sizeof(hints
));
2371 hints
.ai_family
= PF_UNSPEC
;
2372 hints
.ai_socktype
= SOCK_DGRAM
;
2373 hints
.ai_flags
= AI_PASSIVE
| AI_NUMERICHOST
;
2374 if (getaddrinfo(name
, NULL
, &hints
, &res
) == 0)
2376 else if (strchr(name
, '.') == NULL
) {
2377 strlcat(name
, ".", sizeof name
);
2378 strlcat(name
, LocalDomain
, sizeof name
);
2380 if (getnameinfo(sa
, sa
->sa_len
, ip
, sizeof ip
, port
, sizeof port
,
2381 NI_NUMERICHOST
| NI_NUMERICSERV
) != 0)
2382 return (0); /* for safety, should not occur */
2383 dprintf("validate: dgram from IP %s, port %s, name %s;\n",
2387 /* now, walk down the list */
2388 for (i
= 0, ap
= AllowedPeers
; i
< NumAllowed
; i
++, ap
++) {
2389 if (ap
->port
!= 0 && ap
->port
!= sport
) {
2390 dprintf("rejected in rule %d due to port mismatch.\n", i
);
2394 if (ap
->isnumeric
) {
2395 if (ap
->a_addr
.ss_family
!= sa
->sa_family
) {
2396 dprintf("rejected in rule %d due to address family mismatch.\n", i
);
2399 if (ap
->a_addr
.ss_family
== AF_INET
) {
2400 sin4
= (struct sockaddr_in
*)sa
;
2401 a4p
= (struct sockaddr_in
*)&ap
->a_addr
;
2402 m4p
= (struct sockaddr_in
*)&ap
->a_mask
;
2403 if ((sin4
->sin_addr
.s_addr
& m4p
->sin_addr
.s_addr
)
2404 != a4p
->sin_addr
.s_addr
) {
2405 dprintf("rejected in rule %d due to IP mismatch.\n", i
);
2410 else if (ap
->a_addr
.ss_family
== AF_INET6
) {
2411 sin6
= (struct sockaddr_in6
*)sa
;
2412 a6p
= (struct sockaddr_in6
*)&ap
->a_addr
;
2413 m6p
= (struct sockaddr_in6
*)&ap
->a_mask
;
2414 if (a6p
->sin6_scope_id
!= 0 &&
2415 sin6
->sin6_scope_id
!= a6p
->sin6_scope_id
) {
2416 dprintf("rejected in rule %d due to scope mismatch.\n", i
);
2420 for (j
= 0; j
< 16; j
+= 4) {
2421 if ((*(u_int32_t
*)&sin6
->sin6_addr
.s6_addr
[j
] & *(u_int32_t
*)&m6p
->sin6_addr
.s6_addr
[j
])
2422 != *(u_int32_t
*)&a6p
->sin6_addr
.s6_addr
[j
]) {
2428 dprintf("rejected in rule %d due to IP mismatch.\n", i
);
2439 /* allow wildmatch */
2442 if (l2
> l1
|| memcmp(cp
, &name
[l1
- l2
], l2
) != 0) {
2443 dprintf("rejected in rule %d due to name mismatch.\n", i
);
2449 if (l2
!= l1
|| memcmp(cp
, name
, l1
) != 0) {
2450 dprintf("rejected in rule %d due to name mismatch.\n", i
);
2455 dprintf("accepted in rule %d.\n", i
);
2456 return (1); /* hooray! */
2462 * Fairly similar to popen(3), but returns an open descriptor, as
2463 * opposed to a FILE *.
2466 p_open(const char *prog
, pid_t
*rpid
)
2468 int pfd
[2], nulldesc
;
2470 sigset_t omask
, mask
;
2471 char *argv
[4]; /* sh -c cmd NULL */
2474 if (pipe(pfd
) == -1)
2476 if ((nulldesc
= open(_PATH_DEVNULL
, O_RDWR
)) == -1)
2477 /* we are royally screwed anyway */
2481 sigaddset(&mask
, SIGALRM
);
2482 sigaddset(&mask
, SIGHUP
);
2483 sigprocmask(SIG_BLOCK
, &mask
, &omask
);
2484 switch ((pid
= fork())) {
2486 sigprocmask(SIG_SETMASK
, &omask
, 0);
2491 argv
[0] = strdup("sh");
2492 argv
[1] = strdup("-c");
2493 argv
[2] = strdup(prog
);
2495 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] == NULL
) {
2501 (void)setsid(); /* Avoid catching SIGHUPs. */
2504 * Throw away pending signals, and reset signal
2505 * behaviour to standard values.
2507 signal(SIGALRM
, SIG_IGN
);
2508 signal(SIGHUP
, SIG_IGN
);
2509 sigprocmask(SIG_SETMASK
, &omask
, 0);
2510 signal(SIGPIPE
, SIG_DFL
);
2511 signal(SIGQUIT
, SIG_DFL
);
2512 signal(SIGALRM
, SIG_DFL
);
2513 signal(SIGHUP
, SIG_DFL
);
2515 dup2(pfd
[0], STDIN_FILENO
);
2516 dup2(nulldesc
, STDOUT_FILENO
);
2517 dup2(nulldesc
, STDERR_FILENO
);
2520 (void)execvp(_PATH_BSHELL
, argv
);
2524 sigprocmask(SIG_SETMASK
, &omask
, 0);
2528 * Avoid blocking on a hung pipe. With O_NONBLOCK, we are
2529 * supposed to get an EWOULDBLOCK on writev(2), which is
2530 * caught by the logic above anyway, which will in turn close
2531 * the pipe, and fork a new logging subprocess if necessary.
2532 * The stale subprocess will be killed some time later unless
2533 * it terminated itself due to closing its input pipe (so we
2534 * get rid of really dead puppies).
2536 if (fcntl(pfd
[1], F_SETFL
, O_NONBLOCK
) == -1) {
2538 (void)snprintf(errmsg
, sizeof errmsg
,
2539 "Warning: cannot change pipe to PID %d to "
2540 "non-blocking behaviour.",
2549 deadq_enter(pid_t pid
, const char *name
)
2555 * Be paranoid, if we can't signal the process, don't enter it
2556 * into the dead queue (perhaps it's already dead). If possible,
2557 * we try to fetch and log the child's status.
2559 if (kill(pid
, 0) != 0) {
2560 if (waitpid(pid
, &status
, WNOHANG
) > 0)
2561 log_deadchild(pid
, status
, name
);
2565 p
= malloc(sizeof(struct deadq_entry
));
2572 p
->dq_timeout
= DQ_TIMO_INIT
;
2573 TAILQ_INSERT_TAIL(&deadq_head
, p
, dq_entries
);
2577 deadq_remove(pid_t pid
)
2581 TAILQ_FOREACH(q
, &deadq_head
, dq_entries
) {
2582 if (q
->dq_pid
== pid
) {
2583 TAILQ_REMOVE(&deadq_head
, q
, dq_entries
);
2593 log_deadchild(pid_t pid
, int status
, const char *name
)
2599 errno
= 0; /* Keep strerror() stuff out of logerror messages. */
2600 if (WIFSIGNALED(status
)) {
2601 reason
= "due to signal";
2602 code
= WTERMSIG(status
);
2604 reason
= "with status";
2605 code
= WEXITSTATUS(status
);
2609 (void)snprintf(buf
, sizeof buf
,
2610 "Logging subprocess %d (%s) exited %s %d.",
2611 pid
, name
, reason
, code
);
2616 socksetup(int af
, char *bindhostname
)
2618 struct addrinfo hints
, *res
, *r
;
2619 const char *bindservice
;
2621 int error
, maxs
, *s
, *socks
;
2624 * We have to handle this case for backwards compatibility:
2625 * If there are two (or more) colons but no '[' and ']',
2626 * assume this is an inet6 address without a service.
2628 bindservice
= "syslog";
2629 if (bindhostname
!= NULL
) {
2631 if (*bindhostname
== '[' &&
2632 (cp
= strchr(bindhostname
+ 1, ']')) != NULL
) {
2635 if (cp
[1] == ':' && cp
[2] != '\0')
2636 bindservice
= cp
+ 2;
2639 cp
= strchr(bindhostname
, ':');
2640 if (cp
!= NULL
&& strchr(cp
+ 1, ':') == NULL
) {
2643 bindservice
= cp
+ 1;
2644 if (cp
== bindhostname
)
2645 bindhostname
= NULL
;
2652 memset(&hints
, 0, sizeof(hints
));
2653 hints
.ai_flags
= AI_PASSIVE
;
2654 hints
.ai_family
= af
;
2655 hints
.ai_socktype
= SOCK_DGRAM
;
2656 error
= getaddrinfo(bindhostname
, bindservice
, &hints
, &res
);
2658 logerror(gai_strerror(error
));
2663 /* Count max number of sockets we may open */
2664 for (maxs
= 0, r
= res
; r
; r
= r
->ai_next
, maxs
++);
2665 socks
= malloc((maxs
+1) * sizeof(int));
2666 if (socks
== NULL
) {
2667 logerror("couldn't allocate memory for sockets");
2671 *socks
= 0; /* num of sockets counter at start of array */
2673 for (r
= res
; r
; r
= r
->ai_next
) {
2675 *s
= socket(r
->ai_family
, r
->ai_socktype
, r
->ai_protocol
);
2681 if (r
->ai_family
== AF_INET6
) {
2682 if (setsockopt(*s
, IPPROTO_IPV6
, IPV6_V6ONLY
,
2683 (char *)&on
, sizeof (on
)) < 0) {
2684 logerror("setsockopt");
2690 if (setsockopt(*s
, SOL_SOCKET
, SO_REUSEADDR
,
2691 (char *)&on
, sizeof (on
)) < 0) {
2692 logerror("setsockopt");
2697 * RFC 3164 recommends that client side message
2698 * should come from the privileged syslogd port.
2700 * If the system administrator choose not to obey
2701 * this, we can skip the bind() step so that the
2702 * system will choose a port for us.
2705 if (bind(*s
, r
->ai_addr
, r
->ai_addrlen
) < 0) {
2712 increase_rcvbuf(*s
);
2733 increase_rcvbuf(int fd
)
2735 socklen_t len
, slen
;
2739 if (getsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &len
, &slen
) == 0) {
2740 if (len
< RCVBUF_MINSIZE
) {
2741 len
= RCVBUF_MINSIZE
;
2742 setsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &len
, sizeof(len
));