1 /* $NetBSD: syslogd.c,v 1.122 2015/09/05 20:19:43 dholland Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1988, 1993, 1994 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __COPYRIGHT("@(#) Copyright (c) 1983, 1988, 1993, 1994\ 35 The Regents of the University of California. All rights reserved."); 36 #endif /* not lint */ 37 38 #ifndef lint 39 #if 0 40 static char sccsid[] = "@(#)syslogd.c 8.3 (Berkeley) 4/4/94"; 41 #else 42 __RCSID("$NetBSD: syslogd.c,v 1.122 2015/09/05 20:19:43 dholland Exp $"); 43 #endif 44 #endif /* not lint */ 45 46 /* 47 * syslogd -- log system messages 48 * 49 * This program implements a system log. It takes a series of lines. 50 * Each line may have a priority, signified as "<n>" as 51 * the first characters of the line. If this is 52 * not present, a default priority is used. 53 * 54 * To kill syslogd, send a signal 15 (terminate). A signal 1 (hup) will 55 * cause it to reread its configuration file. 56 * 57 * Defined Constants: 58 * 59 * MAXLINE -- the maximimum line length that can be handled. 60 * DEFUPRI -- the default priority for user messages 61 * DEFSPRI -- the default priority for kernel messages 62 * 63 * Author: Eric Allman 64 * extensive changes by Ralph Campbell 65 * more extensive changes by Eric Allman (again) 66 * Extension to log by program name as well as facility and priority 67 * by Peter da Silva. 68 * -U and -v by Harlan Stenn. 69 * Priority comparison code by Harlan Stenn. 70 * TLS, syslog-protocol, and syslog-sign code by Martin Schuette. 71 */ 72 #define SYSLOG_NAMES 73 #include <sys/stat.h> 74 #include <poll.h> 75 #include "syslogd.h" 76 #include "extern.h" 77 78 #ifndef DISABLE_SIGN 79 #include "sign.h" 80 struct sign_global_t GlobalSign = { 81 .rsid = 0, 82 .sig2_delims = STAILQ_HEAD_INITIALIZER(GlobalSign.sig2_delims) 83 }; 84 #endif /* !DISABLE_SIGN */ 85 86 #ifndef DISABLE_TLS 87 #include "tls.h" 88 #endif /* !DISABLE_TLS */ 89 90 #ifdef LIBWRAP 91 int allow_severity = LOG_AUTH|LOG_INFO; 92 int deny_severity = LOG_AUTH|LOG_WARNING; 93 #endif 94 95 const char *ConfFile = _PATH_LOGCONF; 96 char ctty[] = _PATH_CONSOLE; 97 98 /* 99 * Queue of about-to-be-dead processes we should watch out for. 100 */ 101 TAILQ_HEAD(, deadq_entry) deadq_head = TAILQ_HEAD_INITIALIZER(deadq_head); 102 103 typedef struct deadq_entry { 104 pid_t dq_pid; 105 int dq_timeout; 106 TAILQ_ENTRY(deadq_entry) dq_entries; 107 } *dq_t; 108 109 /* 110 * The timeout to apply to processes waiting on the dead queue. Unit 111 * of measure is "mark intervals", i.e. 20 minutes by default. 112 * Processes on the dead queue will be terminated after that time. 113 */ 114 #define DQ_TIMO_INIT 2 115 116 /* 117 * Intervals at which we flush out "message repeated" messages, 118 * in seconds after previous message is logged. After each flush, 119 * we move to the next interval until we reach the largest. 120 */ 121 int repeatinterval[] = { 30, 120, 600 }; /* # of secs before flush */ 122 #define MAXREPEAT ((sizeof(repeatinterval) / sizeof(repeatinterval[0])) - 1) 123 #define REPEATTIME(f) ((f)->f_time + repeatinterval[(f)->f_repeatcount]) 124 #define BACKOFF(f) { if ((size_t)(++(f)->f_repeatcount) > MAXREPEAT) \ 125 (f)->f_repeatcount = MAXREPEAT; \ 126 } 127 128 /* values for f_type */ 129 #define F_UNUSED 0 /* unused entry */ 130 #define F_FILE 1 /* regular file */ 131 #define F_TTY 2 /* terminal */ 132 #define F_CONSOLE 3 /* console terminal */ 133 #define F_FORW 4 /* remote machine */ 134 #define F_USERS 5 /* list of users */ 135 #define F_WALL 6 /* everyone logged on */ 136 #define F_PIPE 7 /* pipe to program */ 137 #define F_FIFO 8 /* mkfifo(2) file */ 138 #define F_TLS 9 139 140 struct TypeInfo { 141 const char *name; 142 char *queue_length_string; 143 const char *default_length_string; 144 char *queue_size_string; 145 const char *default_size_string; 146 int64_t queue_length; 147 int64_t queue_size; 148 int max_msg_length; 149 } TypeInfo[] = { 150 /* numeric values are set in init() 151 * -1 in length/size or max_msg_length means infinite */ 152 {"UNUSED", NULL, "0", NULL, "0", 0, 0, 0}, 153 {"FILE", NULL, "1024", NULL, "1M", 0, 0, 16384}, 154 {"TTY", NULL, "0", NULL, "0", 0, 0, 1024}, 155 {"CONSOLE", NULL, "0", NULL, "0", 0, 0, 1024}, 156 {"FORW", NULL, "0", NULL, "1M", 0, 0, 16384}, 157 {"USERS", NULL, "0", NULL, "0", 0, 0, 1024}, 158 {"WALL", NULL, "0", NULL, "0", 0, 0, 1024}, 159 {"PIPE", NULL, "1024", NULL, "1M", 0, 0, 16384}, 160 {"FIFO", NULL, "1024", NULL, "1M", 0, 0, 16384}, 161 #ifndef DISABLE_TLS 162 {"TLS", NULL, "-1", NULL, "16M", 0, 0, 16384} 163 #endif /* !DISABLE_TLS */ 164 }; 165 166 struct filed *Files = NULL; 167 struct filed consfile; 168 169 time_t now; 170 int Debug = D_NONE; /* debug flag */ 171 int daemonized = 0; /* we are not daemonized yet */ 172 char *LocalFQDN = NULL; /* our FQDN */ 173 char *oldLocalFQDN = NULL; /* our previous FQDN */ 174 char LocalHostName[MAXHOSTNAMELEN]; /* our hostname */ 175 struct socketEvent *finet; /* Internet datagram sockets and events */ 176 int *funix; /* Unix domain datagram sockets */ 177 #ifndef DISABLE_TLS 178 struct socketEvent *TLS_Listen_Set; /* TLS/TCP sockets and events */ 179 #endif /* !DISABLE_TLS */ 180 int Initialized = 0; /* set when we have initialized ourselves */ 181 int ShuttingDown; /* set when we die() */ 182 int MarkInterval = 20 * 60; /* interval between marks in seconds */ 183 int MarkSeq = 0; /* mark sequence number */ 184 int SecureMode = 0; /* listen only on unix domain socks */ 185 int UseNameService = 1; /* make domain name queries */ 186 int NumForwards = 0; /* number of forwarding actions in conf file */ 187 char **LogPaths; /* array of pathnames to read messages from */ 188 int NoRepeat = 0; /* disable "repeated"; log always */ 189 int RemoteAddDate = 0; /* always add date to messages from network */ 190 int SyncKernel = 0; /* write kernel messages synchronously */ 191 int UniquePriority = 0; /* only log specified priority */ 192 int LogFacPri = 0; /* put facility and priority in log messages: */ 193 /* 0=no, 1=numeric, 2=names */ 194 bool BSDOutputFormat = true; /* if true emit traditional BSD Syslog lines, 195 * otherwise new syslog-protocol lines 196 * 197 * Open Issue: having a global flag is the 198 * easiest solution. If we get a more detailed 199 * config file this could/should be changed 200 * into a destination-specific flag. 201 * Most output code should be ready to handle 202 * this, it will only break some syslog-sign 203 * configurations (e.g. with SG="0"). 204 */ 205 char appname[] = "syslogd";/* the APPNAME for own messages */ 206 char *include_pid = NULL; /* include PID in own messages */ 207 208 209 /* init and setup */ 210 void usage(void) __attribute__((__noreturn__)); 211 void logpath_add(char ***, int *, int *, const char *); 212 void logpath_fileadd(char ***, int *, int *, const char *); 213 void init(int fd, short event, void *ev); /* SIGHUP kevent dispatch routine */ 214 struct socketEvent* 215 socksetup(int, const char *); 216 int getmsgbufsize(void); 217 char *getLocalFQDN(void); 218 void trim_anydomain(char *); 219 /* pipe & subprocess handling */ 220 int p_open(char *, pid_t *); 221 void deadq_enter(pid_t, const char *); 222 int deadq_remove(pid_t); 223 void log_deadchild(pid_t, int, const char *); 224 void reapchild(int fd, short event, void *ev); /* SIGCHLD kevent dispatch routine */ 225 /* input message parsing & formatting */ 226 const char *cvthname(struct sockaddr_storage *); 227 void printsys(char *); 228 struct buf_msg *printline_syslogprotocol(const char*, char*, int, int); 229 struct buf_msg *printline_bsdsyslog(const char*, char*, int, int); 230 struct buf_msg *printline_kernelprintf(const char*, char*, int, int); 231 size_t check_timestamp(unsigned char *, char **, bool, bool); 232 char *copy_utf8_ascii(char*, size_t); 233 uint_fast32_t get_utf8_value(const char*); 234 unsigned valid_utf8(const char *); 235 static unsigned check_sd(char*); 236 static unsigned check_msgid(char *); 237 /* event handling */ 238 static void dispatch_read_klog(int fd, short event, void *ev); 239 static void dispatch_read_finet(int fd, short event, void *ev); 240 static void dispatch_read_funix(int fd, short event, void *ev); 241 static void domark(int fd, short event, void *ev); /* timer kevent dispatch routine */ 242 /* log messages */ 243 void logmsg_async(int, const char *, const char *, int); 244 void logmsg(struct buf_msg *); 245 int matches_spec(const char *, const char *, 246 char *(*)(const char *, const char *)); 247 void udp_send(struct filed *, char *, size_t); 248 void wallmsg(struct filed *, struct iovec *, size_t); 249 /* buffer & queue functions */ 250 size_t message_queue_purge(struct filed *f, size_t, int); 251 size_t message_allqueues_check(void); 252 static struct buf_queue * 253 find_qentry_to_delete(const struct buf_queue_head *, int, bool); 254 struct buf_queue * 255 message_queue_add(struct filed *, struct buf_msg *); 256 size_t buf_queue_obj_size(struct buf_queue*); 257 /* configuration & parsing */ 258 void cfline(size_t, const char *, struct filed *, const char *, 259 const char *); 260 void read_config_file(FILE*, struct filed**); 261 void store_sign_delim_sg2(char*); 262 int decode(const char *, CODE *); 263 bool copy_config_value(const char *, char **, const char **, 264 const char *, int); 265 bool copy_config_value_word(char **, const char **); 266 267 /* config parsing */ 268 #ifndef DISABLE_TLS 269 void free_cred_SLIST(struct peer_cred_head *); 270 static inline void 271 free_incoming_tls_sockets(void); 272 #endif /* !DISABLE_TLS */ 273 static int writev1(int, struct iovec *, size_t); 274 275 /* for make_timestamp() */ 276 char timestamp[MAX_TIMESTAMPLEN + 1]; 277 /* 278 * Global line buffer. Since we only process one event at a time, 279 * a global one will do. But for klog, we use own buffer so that 280 * partial line at the end of buffer can be deferred. 281 */ 282 char *linebuf, *klog_linebuf; 283 size_t linebufsize, klog_linebufoff; 284 285 static const char *bindhostname = NULL; 286 287 #ifndef DISABLE_TLS 288 struct TLS_Incoming TLS_Incoming_Head = \ 289 SLIST_HEAD_INITIALIZER(TLS_Incoming_Head); 290 extern char *SSL_ERRCODE[]; 291 struct tls_global_options_t tls_opt; 292 #endif /* !DISABLE_TLS */ 293 294 int 295 main(int argc, char *argv[]) 296 { 297 int ch, j, fklog; 298 int funixsize = 0, funixmaxsize = 0; 299 struct sockaddr_un sunx; 300 char **pp; 301 struct event *ev; 302 uid_t uid = 0; 303 gid_t gid = 0; 304 char *user = NULL; 305 char *group = NULL; 306 const char *root = "/"; 307 char *endp; 308 struct group *gr; 309 struct passwd *pw; 310 unsigned long l; 311 312 /* should we set LC_TIME="C" to ensure correct timestamps&parsing? */ 313 (void)setlocale(LC_ALL, ""); 314 315 while ((ch = getopt(argc, argv, "b:dnsSf:m:o:p:P:ru:g:t:TUv")) != -1) 316 switch(ch) { 317 case 'b': 318 bindhostname = optarg; 319 break; 320 case 'd': /* debug */ 321 Debug = D_DEFAULT; 322 /* is there a way to read the integer value 323 * for Debug as an optional argument? */ 324 break; 325 case 'f': /* configuration file */ 326 ConfFile = optarg; 327 break; 328 case 'g': 329 group = optarg; 330 if (*group == '\0') 331 usage(); 332 break; 333 case 'm': /* mark interval */ 334 MarkInterval = atoi(optarg) * 60; 335 break; 336 case 'n': /* turn off DNS queries */ 337 UseNameService = 0; 338 break; 339 case 'o': /* message format */ 340 #define EQ(a) (strncmp(optarg, # a, sizeof(# a) - 1) == 0) 341 if (EQ(bsd) || EQ(rfc3264)) 342 BSDOutputFormat = true; 343 else if (EQ(syslog) || EQ(rfc5424)) 344 BSDOutputFormat = false; 345 else 346 usage(); 347 /* TODO: implement additional output option "osyslog" 348 * for old syslogd behaviour as introduced after 349 * FreeBSD PR#bin/7055. 350 */ 351 break; 352 case 'p': /* path */ 353 logpath_add(&LogPaths, &funixsize, 354 &funixmaxsize, optarg); 355 break; 356 case 'P': /* file of paths */ 357 logpath_fileadd(&LogPaths, &funixsize, 358 &funixmaxsize, optarg); 359 break; 360 case 'r': /* disable "repeated" compression */ 361 NoRepeat++; 362 break; 363 case 's': /* no network listen mode */ 364 SecureMode++; 365 break; 366 case 'S': 367 SyncKernel = 1; 368 break; 369 case 't': 370 root = optarg; 371 if (*root == '\0') 372 usage(); 373 break; 374 case 'T': 375 RemoteAddDate = 1; 376 break; 377 case 'u': 378 user = optarg; 379 if (*user == '\0') 380 usage(); 381 break; 382 case 'U': /* only log specified priority */ 383 UniquePriority = 1; 384 break; 385 case 'v': /* log facility and priority */ 386 if (LogFacPri < 2) 387 LogFacPri++; 388 break; 389 default: 390 usage(); 391 } 392 if ((argc -= optind) != 0) 393 usage(); 394 395 setlinebuf(stdout); 396 tzset(); /* init TZ information for localtime. */ 397 398 if (user != NULL) { 399 if (isdigit((unsigned char)*user)) { 400 errno = 0; 401 endp = NULL; 402 l = strtoul(user, &endp, 0); 403 if (errno || *endp != '\0') 404 goto getuser; 405 uid = (uid_t)l; 406 if (uid != l) {/* TODO: never executed */ 407 errno = 0; 408 logerror("UID out of range"); 409 die(0, 0, NULL); 410 } 411 } else { 412 getuser: 413 if ((pw = getpwnam(user)) != NULL) { 414 uid = pw->pw_uid; 415 } else { 416 errno = 0; 417 logerror("Cannot find user `%s'", user); 418 die(0, 0, NULL); 419 } 420 } 421 } 422 423 if (group != NULL) { 424 if (isdigit((unsigned char)*group)) { 425 errno = 0; 426 endp = NULL; 427 l = strtoul(group, &endp, 0); 428 if (errno || *endp != '\0') 429 goto getgroup; 430 gid = (gid_t)l; 431 if (gid != l) {/* TODO: never executed */ 432 errno = 0; 433 logerror("GID out of range"); 434 die(0, 0, NULL); 435 } 436 } else { 437 getgroup: 438 if ((gr = getgrnam(group)) != NULL) { 439 gid = gr->gr_gid; 440 } else { 441 errno = 0; 442 logerror("Cannot find group `%s'", group); 443 die(0, 0, NULL); 444 } 445 } 446 } 447 448 if (access(root, F_OK | R_OK)) { 449 logerror("Cannot access `%s'", root); 450 die(0, 0, NULL); 451 } 452 453 consfile.f_type = F_CONSOLE; 454 (void)strlcpy(consfile.f_un.f_fname, ctty, 455 sizeof(consfile.f_un.f_fname)); 456 linebufsize = getmsgbufsize(); 457 if (linebufsize < MAXLINE) 458 linebufsize = MAXLINE; 459 linebufsize++; 460 461 if (!(linebuf = malloc(linebufsize))) { 462 logerror("Couldn't allocate buffer"); 463 die(0, 0, NULL); 464 } 465 if (!(klog_linebuf = malloc(linebufsize))) { 466 logerror("Couldn't allocate buffer for klog"); 467 die(0, 0, NULL); 468 } 469 470 471 #ifndef SUN_LEN 472 #define SUN_LEN(unp) (strlen((unp)->sun_path) + 2) 473 #endif 474 if (funixsize == 0) 475 logpath_add(&LogPaths, &funixsize, 476 &funixmaxsize, _PATH_LOG); 477 funix = malloc(sizeof(*funix) * funixsize); 478 if (funix == NULL) { 479 logerror("Couldn't allocate funix descriptors"); 480 die(0, 0, NULL); 481 } 482 for (j = 0, pp = LogPaths; *pp; pp++, j++) { 483 DPRINTF(D_NET, "Making unix dgram socket `%s'\n", *pp); 484 unlink(*pp); 485 memset(&sunx, 0, sizeof(sunx)); 486 sunx.sun_family = AF_LOCAL; 487 (void)strncpy(sunx.sun_path, *pp, sizeof(sunx.sun_path)); 488 funix[j] = socket(AF_LOCAL, SOCK_DGRAM, 0); 489 if (funix[j] < 0 || bind(funix[j], 490 (struct sockaddr *)&sunx, SUN_LEN(&sunx)) < 0 || 491 chmod(*pp, 0666) < 0) { 492 logerror("Cannot create `%s'", *pp); 493 die(0, 0, NULL); 494 } 495 DPRINTF(D_NET, "Listening on unix dgram socket `%s'\n", *pp); 496 } 497 498 if ((fklog = open(_PATH_KLOG, O_RDONLY, 0)) < 0) { 499 DPRINTF(D_FILE, "Can't open `%s' (%d)\n", _PATH_KLOG, errno); 500 } else { 501 DPRINTF(D_FILE, "Listening on kernel log `%s' with fd %d\n", 502 _PATH_KLOG, fklog); 503 } 504 505 #if (!defined(DISABLE_TLS) && !defined(DISABLE_SIGN)) 506 /* basic OpenSSL init */ 507 SSL_load_error_strings(); 508 (void) SSL_library_init(); 509 OpenSSL_add_all_digests(); 510 /* OpenSSL PRNG needs /dev/urandom, thus initialize before chroot() */ 511 if (!RAND_status()) { 512 errno = 0; 513 logerror("Unable to initialize OpenSSL PRNG"); 514 } else { 515 DPRINTF(D_TLS, "Initializing PRNG\n"); 516 } 517 #endif /* (!defined(DISABLE_TLS) && !defined(DISABLE_SIGN)) */ 518 #ifndef DISABLE_SIGN 519 /* initialize rsid -- we will use that later to determine 520 * whether sign_global_init() was already called */ 521 GlobalSign.rsid = 0; 522 #endif /* !DISABLE_SIGN */ 523 #if (IETF_NUM_PRIVALUES != (LOG_NFACILITIES<<3)) 524 logerror("Warning: system defines %d priority values, but " 525 "syslog-protocol/syslog-sign specify %d values", 526 LOG_NFACILITIES, SIGN_NUM_PRIVALS); 527 #endif 528 529 /* 530 * All files are open, we can drop privileges and chroot 531 */ 532 DPRINTF(D_MISC, "Attempt to chroot to `%s'\n", root); 533 if (chroot(root) == -1) { 534 logerror("Failed to chroot to `%s'", root); 535 die(0, 0, NULL); 536 } 537 DPRINTF(D_MISC, "Attempt to set GID/EGID to `%d'\n", gid); 538 if (setgid(gid) || setegid(gid)) { 539 logerror("Failed to set gid to `%d'", gid); 540 die(0, 0, NULL); 541 } 542 DPRINTF(D_MISC, "Attempt to set UID/EUID to `%d'\n", uid); 543 if (setuid(uid) || seteuid(uid)) { 544 logerror("Failed to set uid to `%d'", uid); 545 die(0, 0, NULL); 546 } 547 /* 548 * We cannot detach from the terminal before we are sure we won't 549 * have a fatal error, because error message would not go to the 550 * terminal and would not be logged because syslogd dies. 551 * All die() calls are behind us, we can call daemon() 552 */ 553 if (!Debug) { 554 (void)daemon(0, 0); 555 daemonized = 1; 556 /* tuck my process id away, if i'm not in debug mode */ 557 #ifdef __NetBSD_Version__ 558 pidfile(NULL); 559 #endif /* __NetBSD_Version__ */ 560 } 561 562 #define MAX_PID_LEN 5 563 include_pid = malloc(MAX_PID_LEN+1); 564 snprintf(include_pid, MAX_PID_LEN+1, "%d", getpid()); 565 566 /* 567 * Create the global kernel event descriptor. 568 * 569 * NOTE: We MUST do this after daemon(), bacause the kqueue() 570 * API dictates that kqueue descriptors are not inherited 571 * across forks (lame!). 572 */ 573 (void)event_init(); 574 575 /* 576 * We must read the configuration file for the first time 577 * after the kqueue descriptor is created, because we install 578 * events during this process. 579 */ 580 init(0, 0, NULL); 581 582 /* 583 * Always exit on SIGTERM. Also exit on SIGINT and SIGQUIT 584 * if we're debugging. 585 */ 586 (void)signal(SIGTERM, SIG_IGN); 587 (void)signal(SIGINT, SIG_IGN); 588 (void)signal(SIGQUIT, SIG_IGN); 589 590 ev = allocev(); 591 signal_set(ev, SIGTERM, die, ev); 592 EVENT_ADD(ev); 593 594 if (Debug) { 595 ev = allocev(); 596 signal_set(ev, SIGINT, die, ev); 597 EVENT_ADD(ev); 598 ev = allocev(); 599 signal_set(ev, SIGQUIT, die, ev); 600 EVENT_ADD(ev); 601 } 602 603 ev = allocev(); 604 signal_set(ev, SIGCHLD, reapchild, ev); 605 EVENT_ADD(ev); 606 607 ev = allocev(); 608 schedule_event(&ev, 609 &((struct timeval){TIMERINTVL, 0}), 610 domark, ev); 611 612 (void)signal(SIGPIPE, SIG_IGN); /* We'll catch EPIPE instead. */ 613 614 /* Re-read configuration on SIGHUP. */ 615 (void) signal(SIGHUP, SIG_IGN); 616 ev = allocev(); 617 signal_set(ev, SIGHUP, init, ev); 618 EVENT_ADD(ev); 619 620 #ifndef DISABLE_TLS 621 ev = allocev(); 622 signal_set(ev, SIGUSR1, dispatch_force_tls_reconnect, ev); 623 EVENT_ADD(ev); 624 #endif /* !DISABLE_TLS */ 625 626 if (fklog >= 0) { 627 ev = allocev(); 628 DPRINTF(D_EVENT, 629 "register klog for fd %d with ev@%p\n", fklog, ev); 630 event_set(ev, fklog, EV_READ | EV_PERSIST, 631 dispatch_read_klog, ev); 632 EVENT_ADD(ev); 633 } 634 for (j = 0, pp = LogPaths; *pp; pp++, j++) { 635 ev = allocev(); 636 event_set(ev, funix[j], EV_READ | EV_PERSIST, 637 dispatch_read_funix, ev); 638 EVENT_ADD(ev); 639 } 640 641 DPRINTF(D_MISC, "Off & running....\n"); 642 643 j = event_dispatch(); 644 /* normal termination via die(), reaching this is an error */ 645 DPRINTF(D_MISC, "event_dispatch() returned %d\n", j); 646 die(0, 0, NULL); 647 /*NOTREACHED*/ 648 return 0; 649 } 650 651 void 652 usage(void) 653 { 654 655 (void)fprintf(stderr, 656 "usage: %s [-dnrSsTUv] [-b bind_address] [-f config_file] [-g group]\n" 657 "\t[-m mark_interval] [-P file_list] [-p log_socket\n" 658 "\t[-p log_socket2 ...]] [-t chroot_dir] [-u user]\n", 659 getprogname()); 660 exit(1); 661 } 662 663 /* 664 * Dispatch routine for reading /dev/klog 665 * 666 * Note: slightly different semantic in dispatch_read functions: 667 * - read_klog() might give multiple messages in linebuf and 668 * leaves the task of splitting them to printsys() 669 * - all other read functions receive one message and 670 * then call printline() with one buffer. 671 */ 672 static void 673 dispatch_read_klog(int fd, short event, void *ev) 674 { 675 ssize_t rv; 676 size_t resid = linebufsize - klog_linebufoff; 677 678 DPRINTF((D_CALL|D_EVENT), "Kernel log active (%d, %d, %p)" 679 " with linebuf@%p, length %zu)\n", fd, event, ev, 680 klog_linebuf, linebufsize); 681 682 rv = read(fd, &klog_linebuf[klog_linebufoff], resid - 1); 683 if (rv > 0) { 684 klog_linebuf[klog_linebufoff + rv] = '\0'; 685 printsys(klog_linebuf); 686 } else if (rv < 0 && errno != EINTR) { 687 /* 688 * /dev/klog has croaked. Disable the event 689 * so it won't bother us again. 690 */ 691 logerror("klog failed"); 692 event_del(ev); 693 } 694 } 695 696 /* 697 * Dispatch routine for reading Unix domain sockets. 698 */ 699 static void 700 dispatch_read_funix(int fd, short event, void *ev) 701 { 702 struct sockaddr_un myname, fromunix; 703 ssize_t rv; 704 socklen_t sunlen; 705 706 sunlen = sizeof(myname); 707 if (getsockname(fd, (struct sockaddr *)&myname, &sunlen) != 0) { 708 /* 709 * This should never happen, so ensure that it doesn't 710 * happen again. 711 */ 712 logerror("getsockname() unix failed"); 713 event_del(ev); 714 return; 715 } 716 717 #define SUN_PATHLEN(su) \ 718 ((su)->sun_len - (sizeof(*(su)) - sizeof((su)->sun_path))) 719 720 DPRINTF((D_CALL|D_EVENT|D_NET), "Unix socket (%.*s) active (%d, %d %p)" 721 " with linebuf@%p, size %zu)\n", (int)SUN_PATHLEN(&myname), 722 myname.sun_path, fd, event, ev, linebuf, linebufsize-1); 723 724 sunlen = sizeof(fromunix); 725 rv = recvfrom(fd, linebuf, linebufsize-1, 0, 726 (struct sockaddr *)&fromunix, &sunlen); 727 if (rv > 0) { 728 linebuf[rv] = '\0'; 729 printline(LocalFQDN, linebuf, 0); 730 } else if (rv < 0 && errno != EINTR) { 731 logerror("recvfrom() unix `%.*s'", 732 (int)SUN_PATHLEN(&myname), myname.sun_path); 733 } 734 } 735 736 /* 737 * Dispatch routine for reading Internet sockets. 738 */ 739 static void 740 dispatch_read_finet(int fd, short event, void *ev) 741 { 742 #ifdef LIBWRAP 743 struct request_info req; 744 #endif 745 struct sockaddr_storage frominet; 746 ssize_t rv; 747 socklen_t len; 748 int reject = 0; 749 750 DPRINTF((D_CALL|D_EVENT|D_NET), "inet socket active (%d, %d %p) " 751 " with linebuf@%p, size %zu)\n", 752 fd, event, ev, linebuf, linebufsize-1); 753 754 #ifdef LIBWRAP 755 request_init(&req, RQ_DAEMON, appname, RQ_FILE, fd, NULL); 756 fromhost(&req); 757 reject = !hosts_access(&req); 758 if (reject) 759 DPRINTF(D_NET, "access denied\n"); 760 #endif 761 762 len = sizeof(frominet); 763 rv = recvfrom(fd, linebuf, linebufsize-1, 0, 764 (struct sockaddr *)&frominet, &len); 765 if (rv == 0 || (rv < 0 && errno == EINTR)) 766 return; 767 else if (rv < 0) { 768 logerror("recvfrom inet"); 769 return; 770 } 771 772 linebuf[rv] = '\0'; 773 if (!reject) 774 printline(cvthname(&frominet), linebuf, 775 RemoteAddDate ? ADDDATE : 0); 776 } 777 778 /* 779 * given a pointer to an array of char *'s, a pointer to its current 780 * size and current allocated max size, and a new char * to add, add 781 * it, update everything as necessary, possibly allocating a new array 782 */ 783 void 784 logpath_add(char ***lp, int *szp, int *maxszp, const char *new) 785 { 786 char **nlp; 787 int newmaxsz; 788 789 DPRINTF(D_FILE, "Adding `%s' to the %p logpath list\n", new, *lp); 790 if (*szp == *maxszp) { 791 if (*maxszp == 0) { 792 newmaxsz = 4; /* start of with enough for now */ 793 *lp = NULL; 794 } else 795 newmaxsz = *maxszp * 2; 796 nlp = realloc(*lp, sizeof(char *) * (newmaxsz + 1)); 797 if (nlp == NULL) { 798 logerror("Couldn't allocate line buffer"); 799 die(0, 0, NULL); 800 } 801 *lp = nlp; 802 *maxszp = newmaxsz; 803 } 804 if (((*lp)[(*szp)++] = strdup(new)) == NULL) { 805 logerror("Couldn't allocate logpath"); 806 die(0, 0, NULL); 807 } 808 (*lp)[(*szp)] = NULL; /* always keep it NULL terminated */ 809 } 810 811 /* do a file of log sockets */ 812 void 813 logpath_fileadd(char ***lp, int *szp, int *maxszp, const char *file) 814 { 815 FILE *fp; 816 char *line; 817 size_t len; 818 819 fp = fopen(file, "r"); 820 if (fp == NULL) { 821 logerror("Could not open socket file list `%s'", file); 822 die(0, 0, NULL); 823 } 824 825 while ((line = fgetln(fp, &len)) != NULL) { 826 line[len - 1] = 0; 827 logpath_add(lp, szp, maxszp, line); 828 } 829 fclose(fp); 830 } 831 832 /* 833 * checks UTF-8 codepoint 834 * returns either its length in bytes or 0 if *input is invalid 835 */ 836 unsigned 837 valid_utf8(const char *c) { 838 unsigned rc, nb; 839 840 /* first byte gives sequence length */ 841 if ((*c & 0x80) == 0x00) return 1; /* 0bbbbbbb -- ASCII */ 842 else if ((*c & 0xc0) == 0x80) return 0; /* 10bbbbbb -- trailing byte */ 843 else if ((*c & 0xe0) == 0xc0) nb = 2; /* 110bbbbb */ 844 else if ((*c & 0xf0) == 0xe0) nb = 3; /* 1110bbbb */ 845 else if ((*c & 0xf8) == 0xf0) nb = 4; /* 11110bbb */ 846 else return 0; /* UTF-8 allows only up to 4 bytes */ 847 848 /* catch overlong encodings */ 849 if ((*c & 0xfe) == 0xc0) 850 return 0; /* 1100000b ... */ 851 else if (((*c & 0xff) == 0xe0) && ((*(c+1) & 0xe0) == 0x80)) 852 return 0; /* 11100000 100bbbbb ... */ 853 else if (((*c & 0xff) == 0xf0) && ((*(c+1) & 0xf0) == 0x80)) 854 return 0; /* 11110000 1000bbbb ... ... */ 855 856 /* and also filter UTF-16 surrogates (=invalid in UTF-8) */ 857 if (((*c & 0xff) == 0xed) && ((*(c+1) & 0xe0) == 0xa0)) 858 return 0; /* 11101101 101bbbbb ... */ 859 860 rc = nb; 861 /* check trailing bytes */ 862 switch (nb) { 863 default: return 0; 864 case 4: if ((*(c+3) & 0xc0) != 0x80) return 0; /*FALLTHROUGH*/ 865 case 3: if ((*(c+2) & 0xc0) != 0x80) return 0; /*FALLTHROUGH*/ 866 case 2: if ((*(c+1) & 0xc0) != 0x80) return 0; /*FALLTHROUGH*/ 867 } 868 return rc; 869 } 870 #define UTF8CHARMAX 4 871 872 /* 873 * read UTF-8 value 874 * returns a the codepoint number 875 */ 876 uint_fast32_t 877 get_utf8_value(const char *c) { 878 uint_fast32_t sum; 879 unsigned nb, i; 880 881 /* first byte gives sequence length */ 882 if ((*c & 0x80) == 0x00) return *c;/* 0bbbbbbb -- ASCII */ 883 else if ((*c & 0xc0) == 0x80) return 0; /* 10bbbbbb -- trailing byte */ 884 else if ((*c & 0xe0) == 0xc0) { /* 110bbbbb */ 885 nb = 2; 886 sum = (*c & ~0xe0) & 0xff; 887 } else if ((*c & 0xf0) == 0xe0) { /* 1110bbbb */ 888 nb = 3; 889 sum = (*c & ~0xf0) & 0xff; 890 } else if ((*c & 0xf8) == 0xf0) { /* 11110bbb */ 891 nb = 4; 892 sum = (*c & ~0xf8) & 0xff; 893 } else return 0; /* UTF-8 allows only up to 4 bytes */ 894 895 /* check trailing bytes -- 10bbbbbb */ 896 i = 1; 897 while (i < nb) { 898 sum <<= 6; 899 sum |= ((*(c+i) & ~0xc0) & 0xff); 900 i++; 901 } 902 return sum; 903 } 904 905 /* note previous versions transscribe 906 * control characters, e.g. \007 --> "^G" 907 * did anyone rely on that? 908 * 909 * this new version works on only one buffer and 910 * replaces control characters with a space 911 */ 912 #define NEXTFIELD(ptr) if (*(p) == ' ') (p)++; /* SP */ \ 913 else { \ 914 DPRINTF(D_DATA, "format error\n"); \ 915 if (*(p) == '\0') start = (p); \ 916 goto all_syslog_msg; \ 917 } 918 #define FORCE2ASCII(c) ((iscntrl((unsigned char)(c)) && (c) != '\t') \ 919 ? ((c) == '\n' ? ' ' : '?') \ 920 : (c) & 0177) 921 922 /* following syslog-protocol */ 923 #define printusascii(ch) (ch >= 33 && ch <= 126) 924 #define sdname(ch) (ch != '=' && ch != ' ' \ 925 && ch != ']' && ch != '"' \ 926 && printusascii(ch)) 927 928 /* checks whether the first word of string p can be interpreted as 929 * a syslog-protocol MSGID and if so returns its length. 930 * 931 * otherwise returns 0 932 */ 933 static unsigned 934 check_msgid(char *p) 935 { 936 char *q = p; 937 938 /* consider the NILVALUE to be valid */ 939 if (*q == '-' && *(q+1) == ' ') 940 return 1; 941 942 for (;;) { 943 if (*q == ' ') 944 return q - p; 945 else if (*q == '\0' || !printusascii(*q) || q - p >= MSGID_MAX) 946 return 0; 947 else 948 q++; 949 } 950 } 951 952 /* 953 * returns number of chars found in SD at beginning of string p 954 * thus returns 0 if no valid SD is found 955 * 956 * if ascii == true then substitute all non-ASCII chars 957 * otherwise use syslog-protocol rules to allow UTF-8 in values 958 * note: one pass for filtering and scanning, so a found SD 959 * is always filtered, but an invalid one could be partially 960 * filtered up to the format error. 961 */ 962 static unsigned 963 check_sd(char* p) 964 { 965 char *q = p; 966 bool esc = false; 967 968 /* consider the NILVALUE to be valid */ 969 if (*q == '-' && (*(q+1) == ' ' || *(q+1) == '\0')) 970 return 1; 971 972 for(;;) { /* SD-ELEMENT */ 973 if (*q++ != '[') return 0; 974 /* SD-ID */ 975 if (!sdname(*q)) return 0; 976 while (sdname(*q)) { 977 *q = FORCE2ASCII(*q); 978 q++; 979 } 980 for(;;) { /* SD-PARAM */ 981 if (*q == ']') { 982 q++; 983 if (*q == ' ' || *q == '\0') return q - p; 984 else if (*q == '[') break; 985 } else if (*q++ != ' ') return 0; 986 987 /* PARAM-NAME */ 988 if (!sdname(*q)) return 0; 989 while (sdname(*q)) { 990 *q = FORCE2ASCII(*q); 991 q++; 992 } 993 994 if (*q++ != '=') return 0; 995 if (*q++ != '"') return 0; 996 997 for(;;) { /* PARAM-VALUE */ 998 if (esc) { 999 esc = false; 1000 if (*q == '\\' || *q == '"' || 1001 *q == ']') { 1002 q++; 1003 continue; 1004 } 1005 /* no else because invalid 1006 * escape sequences are accepted */ 1007 } 1008 else if (*q == '"') break; 1009 else if (*q == '\0' || *q == ']') return 0; 1010 else if (*q == '\\') esc = true; 1011 else { 1012 int i; 1013 i = valid_utf8(q); 1014 if (i == 0) 1015 *q = '?'; 1016 else if (i == 1) 1017 *q = FORCE2ASCII(*q); 1018 else /* multi byte char */ 1019 q += (i-1); 1020 } 1021 q++; 1022 } 1023 q++; 1024 } 1025 } 1026 } 1027 1028 struct buf_msg * 1029 printline_syslogprotocol(const char *hname, char *msg, 1030 int flags, int pri) 1031 { 1032 struct buf_msg *buffer; 1033 char *p, *start; 1034 unsigned sdlen = 0, i = 0; 1035 bool utf8allowed = false; /* for some fields */ 1036 1037 DPRINTF((D_CALL|D_BUFFER|D_DATA), "printline_syslogprotocol(" 1038 "\"%s\", \"%s\", %d, %d)\n", hname, msg, flags, pri); 1039 1040 buffer = buf_msg_new(0); 1041 p = msg; 1042 p += check_timestamp((unsigned char*) p, 1043 &buffer->timestamp, true, !BSDOutputFormat); 1044 DPRINTF(D_DATA, "Got timestamp \"%s\"\n", buffer->timestamp); 1045 1046 if (flags & ADDDATE) { 1047 FREEPTR(buffer->timestamp); 1048 buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0); 1049 } 1050 1051 start = p; 1052 NEXTFIELD(p); 1053 /* extract host */ 1054 for (start = p;; p++) { 1055 if ((*p == ' ' || *p == '\0') 1056 && start == p-1 && *(p-1) == '-') { 1057 /* NILVALUE */ 1058 break; 1059 } else if ((*p == ' ' || *p == '\0') 1060 && (start != p-1 || *(p-1) != '-')) { 1061 buffer->host = strndup(start, p - start); 1062 break; 1063 } else { 1064 *p = FORCE2ASCII(*p); 1065 } 1066 } 1067 /* p @ SP after host */ 1068 DPRINTF(D_DATA, "Got host \"%s\"\n", buffer->host); 1069 1070 /* extract app-name */ 1071 NEXTFIELD(p); 1072 for (start = p;; p++) { 1073 if ((*p == ' ' || *p == '\0') 1074 && start == p-1 && *(p-1) == '-') { 1075 /* NILVALUE */ 1076 break; 1077 } else if ((*p == ' ' || *p == '\0') 1078 && (start != p-1 || *(p-1) != '-')) { 1079 buffer->prog = strndup(start, p - start); 1080 break; 1081 } else { 1082 *p = FORCE2ASCII(*p); 1083 } 1084 } 1085 DPRINTF(D_DATA, "Got prog \"%s\"\n", buffer->prog); 1086 1087 /* extract procid */ 1088 NEXTFIELD(p); 1089 for (start = p;; p++) { 1090 if ((*p == ' ' || *p == '\0') 1091 && start == p-1 && *(p-1) == '-') { 1092 /* NILVALUE */ 1093 break; 1094 } else if ((*p == ' ' || *p == '\0') 1095 && (start != p-1 || *(p-1) != '-')) { 1096 buffer->pid = strndup(start, p - start); 1097 start = p; 1098 break; 1099 } else { 1100 *p = FORCE2ASCII(*p); 1101 } 1102 } 1103 DPRINTF(D_DATA, "Got pid \"%s\"\n", buffer->pid); 1104 1105 /* extract msgid */ 1106 NEXTFIELD(p); 1107 for (start = p;; p++) { 1108 if ((*p == ' ' || *p == '\0') 1109 && start == p-1 && *(p-1) == '-') { 1110 /* NILVALUE */ 1111 start = p+1; 1112 break; 1113 } else if ((*p == ' ' || *p == '\0') 1114 && (start != p-1 || *(p-1) != '-')) { 1115 buffer->msgid = strndup(start, p - start); 1116 start = p+1; 1117 break; 1118 } else { 1119 *p = FORCE2ASCII(*p); 1120 } 1121 } 1122 DPRINTF(D_DATA, "Got msgid \"%s\"\n", buffer->msgid); 1123 1124 /* extract SD */ 1125 NEXTFIELD(p); 1126 start = p; 1127 sdlen = check_sd(p); 1128 DPRINTF(D_DATA, "check_sd(\"%s\") returned %d\n", p, sdlen); 1129 1130 if (sdlen == 1 && *p == '-') { 1131 /* NILVALUE */ 1132 p++; 1133 } else if (sdlen > 1) { 1134 buffer->sd = strndup(p, sdlen); 1135 p += sdlen; 1136 } else { 1137 DPRINTF(D_DATA, "format error\n"); 1138 } 1139 if (*p == '\0') start = p; 1140 else if (*p == ' ') start = ++p; /* SP */ 1141 DPRINTF(D_DATA, "Got SD \"%s\"\n", buffer->sd); 1142 1143 /* and now the message itself 1144 * note: move back to last start to check for BOM 1145 */ 1146 all_syslog_msg: 1147 p = start; 1148 1149 /* check for UTF-8-BOM */ 1150 if (IS_BOM(p)) { 1151 DPRINTF(D_DATA, "UTF-8 BOM\n"); 1152 utf8allowed = true; 1153 p += 3; 1154 } 1155 1156 if (*p != '\0' && !utf8allowed) { 1157 size_t msglen; 1158 1159 msglen = strlen(p); 1160 assert(!buffer->msg); 1161 buffer->msg = copy_utf8_ascii(p, msglen); 1162 buffer->msgorig = buffer->msg; 1163 buffer->msglen = buffer->msgsize = strlen(buffer->msg)+1; 1164 } else if (*p != '\0' && utf8allowed) { 1165 while (*p != '\0') { 1166 i = valid_utf8(p); 1167 if (i == 0) 1168 *p++ = '?'; 1169 else if (i == 1) 1170 *p = FORCE2ASCII(*p); 1171 p += i; 1172 } 1173 assert(p != start); 1174 assert(!buffer->msg); 1175 buffer->msg = strndup(start, p - start); 1176 buffer->msgorig = buffer->msg; 1177 buffer->msglen = buffer->msgsize = 1 + p - start; 1178 } 1179 DPRINTF(D_DATA, "Got msg \"%s\"\n", buffer->msg); 1180 1181 buffer->recvhost = strdup(hname); 1182 buffer->pri = pri; 1183 buffer->flags = flags; 1184 1185 return buffer; 1186 } 1187 1188 /* copies an input into a new ASCII buffer 1189 * ASCII controls are converted to format "^X" 1190 * multi-byte UTF-8 chars are converted to format "<ab><cd>" 1191 */ 1192 #define INIT_BUFSIZE 512 1193 char * 1194 copy_utf8_ascii(char *p, size_t p_len) 1195 { 1196 size_t idst = 0, isrc = 0, dstsize = INIT_BUFSIZE, i; 1197 char *dst, *tmp_dst; 1198 1199 MALLOC(dst, dstsize); 1200 while (isrc < p_len) { 1201 if (dstsize < idst + 10) { 1202 /* check for enough space for \0 and a UTF-8 1203 * conversion; longest possible is <U+123456> */ 1204 tmp_dst = realloc(dst, dstsize + INIT_BUFSIZE); 1205 if (!tmp_dst) 1206 break; 1207 dst = tmp_dst; 1208 dstsize += INIT_BUFSIZE; 1209 } 1210 1211 i = valid_utf8(&p[isrc]); 1212 if (i == 0) { /* invalid encoding */ 1213 dst[idst++] = '?'; 1214 isrc++; 1215 } else if (i == 1) { /* check printable */ 1216 if (iscntrl((unsigned char)p[isrc]) 1217 && p[isrc] != '\t') { 1218 if (p[isrc] == '\n') { 1219 dst[idst++] = ' '; 1220 isrc++; 1221 } else { 1222 dst[idst++] = '^'; 1223 dst[idst++] = p[isrc++] ^ 0100; 1224 } 1225 } else 1226 dst[idst++] = p[isrc++]; 1227 } else { /* convert UTF-8 to ASCII */ 1228 dst[idst++] = '<'; 1229 idst += snprintf(&dst[idst], dstsize - idst, "U+%x", 1230 get_utf8_value(&p[isrc])); 1231 isrc += i; 1232 dst[idst++] = '>'; 1233 } 1234 } 1235 dst[idst] = '\0'; 1236 1237 /* shrink buffer to right size */ 1238 tmp_dst = realloc(dst, idst+1); 1239 if (tmp_dst) 1240 return tmp_dst; 1241 else 1242 return dst; 1243 } 1244 1245 struct buf_msg * 1246 printline_bsdsyslog(const char *hname, char *msg, 1247 int flags, int pri) 1248 { 1249 struct buf_msg *buffer; 1250 char *p, *start; 1251 unsigned msgidlen = 0, sdlen = 0; 1252 1253 DPRINTF((D_CALL|D_BUFFER|D_DATA), "printline_bsdsyslog(" 1254 "\"%s\", \"%s\", %d, %d)\n", hname, msg, flags, pri); 1255 1256 buffer = buf_msg_new(0); 1257 p = msg; 1258 p += check_timestamp((unsigned char*) p, 1259 &buffer->timestamp, false, !BSDOutputFormat); 1260 DPRINTF(D_DATA, "Got timestamp \"%s\"\n", buffer->timestamp); 1261 1262 if (flags & ADDDATE || !buffer->timestamp) { 1263 FREEPTR(buffer->timestamp); 1264 buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0); 1265 } 1266 1267 if (*p == ' ') p++; /* SP */ 1268 else goto all_bsd_msg; 1269 /* in any error case we skip header parsing and 1270 * treat all following data as message content */ 1271 1272 /* extract host */ 1273 for (start = p;; p++) { 1274 if (*p == ' ' || *p == '\0') { 1275 buffer->host = strndup(start, p - start); 1276 break; 1277 } else if (*p == '[' || (*p == ':' 1278 && (*(p+1) == ' ' || *(p+1) == '\0'))) { 1279 /* no host in message */ 1280 buffer->host = LocalFQDN; 1281 buffer->prog = strndup(start, p - start); 1282 break; 1283 } else { 1284 *p = FORCE2ASCII(*p); 1285 } 1286 } 1287 DPRINTF(D_DATA, "Got host \"%s\"\n", buffer->host); 1288 /* p @ SP after host, or @ :/[ after prog */ 1289 1290 /* extract program */ 1291 if (!buffer->prog) { 1292 if (*p == ' ') p++; /* SP */ 1293 else goto all_bsd_msg; 1294 1295 for (start = p;; p++) { 1296 if (*p == ' ' || *p == '\0') { /* error */ 1297 goto all_bsd_msg; 1298 } else if (*p == '[' || (*p == ':' 1299 && (*(p+1) == ' ' || *(p+1) == '\0'))) { 1300 buffer->prog = strndup(start, p - start); 1301 break; 1302 } else { 1303 *p = FORCE2ASCII(*p); 1304 } 1305 } 1306 } 1307 DPRINTF(D_DATA, "Got prog \"%s\"\n", buffer->prog); 1308 start = p; 1309 1310 /* p @ :/[ after prog */ 1311 if (*p == '[') { 1312 p++; 1313 if (*p == ' ') p++; /* SP */ 1314 for (start = p;; p++) { 1315 if (*p == ' ' || *p == '\0') { /* error */ 1316 goto all_bsd_msg; 1317 } else if (*p == ']') { 1318 buffer->pid = strndup(start, p - start); 1319 break; 1320 } else { 1321 *p = FORCE2ASCII(*p); 1322 } 1323 } 1324 } 1325 DPRINTF(D_DATA, "Got pid \"%s\"\n", buffer->pid); 1326 1327 if (*p == ']') p++; 1328 if (*p == ':') p++; 1329 if (*p == ' ') p++; 1330 1331 /* p @ msgid, @ opening [ of SD or @ first byte of message 1332 * accept either case and try to detect MSGID and SD fields 1333 * 1334 * only limitation: we do not accept UTF-8 data in 1335 * BSD Syslog messages -- so all SD values are ASCII-filtered 1336 * 1337 * I have found one scenario with 'unexpected' behaviour: 1338 * if there is only a SD intended, but a) it is short enough 1339 * to be a MSGID and b) the first word of the message can also 1340 * be parsed as an SD. 1341 * example: 1342 * "<35>Jul 6 12:39:08 tag[123]: [exampleSDID@0] - hello" 1343 * --> parsed as 1344 * MSGID = "[exampleSDID@0]" 1345 * SD = "-" 1346 * MSG = "hello" 1347 */ 1348 start = p; 1349 msgidlen = check_msgid(p); 1350 if (msgidlen) /* check for SD in 2nd field */ 1351 sdlen = check_sd(p+msgidlen+1); 1352 1353 if (msgidlen && sdlen) { 1354 /* MSGID in 1st and SD in 2nd field 1355 * now check for NILVALUEs and copy */ 1356 if (msgidlen == 1 && *p == '-') { 1357 p++; /* - */ 1358 p++; /* SP */ 1359 DPRINTF(D_DATA, "Got MSGID \"-\"\n"); 1360 } else { 1361 /* only has ASCII chars after check_msgid() */ 1362 buffer->msgid = strndup(p, msgidlen); 1363 p += msgidlen; 1364 p++; /* SP */ 1365 DPRINTF(D_DATA, "Got MSGID \"%s\"\n", 1366 buffer->msgid); 1367 } 1368 } else { 1369 /* either no msgid or no SD in 2nd field 1370 * --> check 1st field for SD */ 1371 DPRINTF(D_DATA, "No MSGID\n"); 1372 sdlen = check_sd(p); 1373 } 1374 1375 if (sdlen == 0) { 1376 DPRINTF(D_DATA, "No SD\n"); 1377 } else if (sdlen > 1) { 1378 buffer->sd = copy_utf8_ascii(p, sdlen); 1379 DPRINTF(D_DATA, "Got SD \"%s\"\n", buffer->sd); 1380 } else if (sdlen == 1 && *p == '-') { 1381 p++; 1382 DPRINTF(D_DATA, "Got SD \"-\"\n"); 1383 } else { 1384 DPRINTF(D_DATA, "Error\n"); 1385 } 1386 1387 if (*p == ' ') p++; 1388 start = p; 1389 /* and now the message itself 1390 * note: do not reset start, because we might come here 1391 * by goto and want to have the incomplete field as part 1392 * of the msg 1393 */ 1394 all_bsd_msg: 1395 if (*p != '\0') { 1396 size_t msglen = strlen(p); 1397 buffer->msg = copy_utf8_ascii(p, msglen); 1398 buffer->msgorig = buffer->msg; 1399 buffer->msglen = buffer->msgsize = strlen(buffer->msg)+1; 1400 } 1401 DPRINTF(D_DATA, "Got msg \"%s\"\n", buffer->msg); 1402 1403 buffer->recvhost = strdup(hname); 1404 buffer->pri = pri; 1405 buffer->flags = flags | BSDSYSLOG; 1406 1407 return buffer; 1408 } 1409 1410 struct buf_msg * 1411 printline_kernelprintf(const char *hname, char *msg, 1412 int flags, int pri) 1413 { 1414 struct buf_msg *buffer; 1415 char *p; 1416 unsigned sdlen = 0; 1417 1418 DPRINTF((D_CALL|D_BUFFER|D_DATA), "printline_kernelprintf(" 1419 "\"%s\", \"%s\", %d, %d)\n", hname, msg, flags, pri); 1420 1421 buffer = buf_msg_new(0); 1422 buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0); 1423 buffer->pri = pri; 1424 buffer->flags = flags; 1425 1426 /* assume there is no MSGID but there might be SD */ 1427 p = msg; 1428 sdlen = check_sd(p); 1429 1430 if (sdlen == 0) { 1431 DPRINTF(D_DATA, "No SD\n"); 1432 } else if (sdlen > 1) { 1433 buffer->sd = copy_utf8_ascii(p, sdlen); 1434 DPRINTF(D_DATA, "Got SD \"%s\"\n", buffer->sd); 1435 } else if (sdlen == 1 && *p == '-') { 1436 p++; 1437 DPRINTF(D_DATA, "Got SD \"-\"\n"); 1438 } else { 1439 DPRINTF(D_DATA, "Error\n"); 1440 } 1441 1442 if (*p == ' ') p++; 1443 if (*p != '\0') { 1444 size_t msglen = strlen(p); 1445 buffer->msg = copy_utf8_ascii(p, msglen); 1446 buffer->msgorig = buffer->msg; 1447 buffer->msglen = buffer->msgsize = strlen(buffer->msg)+1; 1448 } 1449 DPRINTF(D_DATA, "Got msg \"%s\"\n", buffer->msg); 1450 1451 return buffer; 1452 } 1453 1454 /* 1455 * Take a raw input line, read priority and version, call the 1456 * right message parsing function, then call logmsg(). 1457 */ 1458 void 1459 printline(const char *hname, char *msg, int flags) 1460 { 1461 struct buf_msg *buffer; 1462 int pri; 1463 char *p, *q; 1464 long n; 1465 bool bsdsyslog = true; 1466 1467 DPRINTF((D_CALL|D_BUFFER|D_DATA), 1468 "printline(\"%s\", \"%s\", %d)\n", hname, msg, flags); 1469 1470 /* test for special codes */ 1471 pri = DEFUPRI; 1472 p = msg; 1473 if (*p == '<') { 1474 errno = 0; 1475 n = strtol(p + 1, &q, 10); 1476 if (*q == '>' && n >= 0 && n < INT_MAX && errno == 0) { 1477 p = q + 1; 1478 pri = (int)n; 1479 /* check for syslog-protocol version */ 1480 if (*p == '1' && p[1] == ' ') { 1481 p += 2; /* skip version and space */ 1482 bsdsyslog = false; 1483 } else { 1484 bsdsyslog = true; 1485 } 1486 } 1487 } 1488 if (pri & ~(LOG_FACMASK|LOG_PRIMASK)) 1489 pri = DEFUPRI; 1490 1491 /* 1492 * Don't allow users to log kernel messages. 1493 * NOTE: Since LOG_KERN == 0, this will also match 1494 * messages with no facility specified. 1495 */ 1496 if ((pri & LOG_FACMASK) == LOG_KERN) 1497 pri = LOG_MAKEPRI(LOG_USER, LOG_PRI(pri)); 1498 1499 if (bsdsyslog) { 1500 buffer = printline_bsdsyslog(hname, p, flags, pri); 1501 } else { 1502 buffer = printline_syslogprotocol(hname, p, flags, pri); 1503 } 1504 logmsg(buffer); 1505 DELREF(buffer); 1506 } 1507 1508 /* 1509 * Take a raw input line from /dev/klog, split and format similar to syslog(). 1510 */ 1511 void 1512 printsys(char *msg) 1513 { 1514 int n, is_printf, pri, flags; 1515 char *p, *q; 1516 struct buf_msg *buffer; 1517 1518 klog_linebufoff = 0; 1519 for (p = msg; *p != '\0'; ) { 1520 bool bsdsyslog = true; 1521 1522 is_printf = 1; 1523 flags = ISKERNEL | ADDDATE | BSDSYSLOG; 1524 if (SyncKernel) 1525 flags |= SYNC_FILE; 1526 if (is_printf) /* kernel printf's come out on console */ 1527 flags |= IGN_CONS; 1528 pri = DEFSPRI; 1529 1530 if (*p == '<') { 1531 errno = 0; 1532 n = (int)strtol(p + 1, &q, 10); 1533 if (*q == '>' && n >= 0 && n < INT_MAX && errno == 0) { 1534 p = q + 1; 1535 is_printf = 0; 1536 pri = n; 1537 if (*p == '1') { /* syslog-protocol version */ 1538 p += 2; /* skip version and space */ 1539 bsdsyslog = false; 1540 } else { 1541 bsdsyslog = true; 1542 } 1543 } 1544 } 1545 for (q = p; *q != '\0' && *q != '\n'; q++) 1546 /* look for end of line; no further checks. 1547 * trust the kernel to send ASCII only */; 1548 if (*q != '\0') 1549 *q++ = '\0'; 1550 else { 1551 memcpy(linebuf, p, klog_linebufoff = q - p); 1552 break; 1553 } 1554 1555 if (pri &~ (LOG_FACMASK|LOG_PRIMASK)) 1556 pri = DEFSPRI; 1557 1558 /* allow all kinds of input from kernel */ 1559 if (is_printf) 1560 buffer = printline_kernelprintf( 1561 LocalFQDN, p, flags, pri); 1562 else { 1563 if (bsdsyslog) 1564 buffer = printline_bsdsyslog( 1565 LocalFQDN, p, flags, pri); 1566 else 1567 buffer = printline_syslogprotocol( 1568 LocalFQDN, p, flags, pri); 1569 } 1570 1571 /* set fields left open */ 1572 if (!buffer->prog) 1573 buffer->prog = strdup(_PATH_UNIX); 1574 if (!buffer->host) 1575 buffer->host = LocalFQDN; 1576 if (!buffer->recvhost) 1577 buffer->recvhost = LocalFQDN; 1578 1579 logmsg(buffer); 1580 DELREF(buffer); 1581 p = q; 1582 } 1583 } 1584 1585 /* 1586 * Check to see if `name' matches the provided specification, using the 1587 * specified strstr function. 1588 */ 1589 int 1590 matches_spec(const char *name, const char *spec, 1591 char *(*check)(const char *, const char *)) 1592 { 1593 const char *s; 1594 const char *cursor; 1595 char prev, next; 1596 size_t len; 1597 1598 if (name[0] == '\0') 1599 return 0; 1600 1601 if (strchr(name, ',')) /* sanity */ 1602 return 0; 1603 1604 len = strlen(name); 1605 cursor = spec; 1606 while ((s = (*check)(cursor, name)) != NULL) { 1607 prev = s == spec ? ',' : *(s - 1); 1608 cursor = s + len; 1609 next = *cursor; 1610 1611 if (prev == ',' && (next == '\0' || next == ',')) 1612 return 1; 1613 } 1614 1615 return 0; 1616 } 1617 1618 /* 1619 * wrapper with old function signature, 1620 * keeps calling code shorter and hides buffer allocation 1621 */ 1622 void 1623 logmsg_async(int pri, const char *sd, const char *msg, int flags) 1624 { 1625 struct buf_msg *buffer; 1626 size_t msglen; 1627 1628 DPRINTF((D_CALL|D_DATA), "logmsg_async(%d, \"%s\", \"%s\", %d)\n", 1629 pri, sd, msg, flags); 1630 1631 if (msg) { 1632 msglen = strlen(msg); 1633 msglen++; /* adds \0 */ 1634 buffer = buf_msg_new(msglen); 1635 buffer->msglen = strlcpy(buffer->msg, msg, msglen) + 1; 1636 } else { 1637 buffer = buf_msg_new(0); 1638 } 1639 if (sd) buffer->sd = strdup(sd); 1640 buffer->timestamp = make_timestamp(NULL, !BSDOutputFormat, 0); 1641 buffer->prog = appname; 1642 buffer->pid = include_pid; 1643 buffer->recvhost = buffer->host = LocalFQDN; 1644 buffer->pri = pri; 1645 buffer->flags = flags; 1646 1647 logmsg(buffer); 1648 DELREF(buffer); 1649 } 1650 1651 /* read timestamp in from_buf, convert into a timestamp in to_buf 1652 * 1653 * returns length of timestamp found in from_buf (= number of bytes consumed) 1654 */ 1655 size_t 1656 check_timestamp(unsigned char *from_buf, char **to_buf, 1657 bool from_iso, bool to_iso) 1658 { 1659 unsigned char *q; 1660 int p; 1661 bool found_ts = false; 1662 1663 DPRINTF((D_CALL|D_DATA), "check_timestamp(%p = \"%s\", from_iso=%d, " 1664 "to_iso=%d)\n", from_buf, from_buf, from_iso, to_iso); 1665 1666 if (!from_buf) return 0; 1667 /* 1668 * Check to see if msg looks non-standard. 1669 * looks at every char because we do not have a msg length yet 1670 */ 1671 /* detailed checking adapted from Albert Mietus' sl_timestamp.c */ 1672 if (from_iso) { 1673 if (from_buf[4] == '-' && from_buf[7] == '-' 1674 && from_buf[10] == 'T' && from_buf[13] == ':' 1675 && from_buf[16] == ':' 1676 && isdigit(from_buf[0]) && isdigit(from_buf[1]) 1677 && isdigit(from_buf[2]) && isdigit(from_buf[3]) /* YYYY */ 1678 && isdigit(from_buf[5]) && isdigit(from_buf[6]) 1679 && isdigit(from_buf[8]) && isdigit(from_buf[9]) /* mm dd */ 1680 && isdigit(from_buf[11]) && isdigit(from_buf[12]) /* HH */ 1681 && isdigit(from_buf[14]) && isdigit(from_buf[15]) /* MM */ 1682 && isdigit(from_buf[17]) && isdigit(from_buf[18]) /* SS */ 1683 ) { 1684 /* time-secfrac */ 1685 if (from_buf[19] == '.') 1686 for (p=20; isdigit(from_buf[p]); p++) /* NOP*/; 1687 else 1688 p = 19; 1689 /* time-offset */ 1690 if (from_buf[p] == 'Z' 1691 || ((from_buf[p] == '+' || from_buf[p] == '-') 1692 && from_buf[p+3] == ':' 1693 && isdigit(from_buf[p+1]) && isdigit(from_buf[p+2]) 1694 && isdigit(from_buf[p+4]) && isdigit(from_buf[p+5]) 1695 )) 1696 found_ts = true; 1697 } 1698 } else { 1699 if (from_buf[3] == ' ' && from_buf[6] == ' ' 1700 && from_buf[9] == ':' && from_buf[12] == ':' 1701 && (from_buf[4] == ' ' || isdigit(from_buf[4])) 1702 && isdigit(from_buf[5]) /* dd */ 1703 && isdigit(from_buf[7]) && isdigit(from_buf[8]) /* HH */ 1704 && isdigit(from_buf[10]) && isdigit(from_buf[11]) /* MM */ 1705 && isdigit(from_buf[13]) && isdigit(from_buf[14]) /* SS */ 1706 && isupper(from_buf[0]) && islower(from_buf[1]) /* month */ 1707 && islower(from_buf[2])) 1708 found_ts = true; 1709 } 1710 if (!found_ts) { 1711 if (from_buf[0] == '-' && from_buf[1] == ' ') { 1712 /* NILVALUE */ 1713 if (to_iso) { 1714 /* with ISO = syslog-protocol output leave 1715 * it as is, because it is better to have 1716 * no timestamp than a wrong one. 1717 */ 1718 *to_buf = strdup("-"); 1719 } else { 1720 /* with BSD Syslog the field is reqired 1721 * so replace it with current time 1722 */ 1723 *to_buf = make_timestamp(NULL, false, 0); 1724 } 1725 return 2; 1726 } 1727 *to_buf = make_timestamp(NULL, false, 0); 1728 return 0; 1729 } 1730 1731 if (!from_iso && !to_iso) { 1732 /* copy BSD timestamp */ 1733 DPRINTF(D_CALL, "check_timestamp(): copy BSD timestamp\n"); 1734 *to_buf = strndup((char *)from_buf, BSD_TIMESTAMPLEN); 1735 return BSD_TIMESTAMPLEN; 1736 } else if (from_iso && to_iso) { 1737 /* copy ISO timestamp */ 1738 DPRINTF(D_CALL, "check_timestamp(): copy ISO timestamp\n"); 1739 if (!(q = (unsigned char *) strchr((char *)from_buf, ' '))) 1740 q = from_buf + strlen((char *)from_buf); 1741 *to_buf = strndup((char *)from_buf, q - from_buf); 1742 return q - from_buf; 1743 } else if (from_iso && !to_iso) { 1744 /* convert ISO->BSD */ 1745 struct tm parsed; 1746 time_t timeval; 1747 char tsbuf[MAX_TIMESTAMPLEN]; 1748 int i = 0; 1749 1750 DPRINTF(D_CALL, "check_timestamp(): convert ISO->BSD\n"); 1751 for(i = 0; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0' 1752 && from_buf[i] != '.' && from_buf[i] != ' '; i++) 1753 tsbuf[i] = from_buf[i]; /* copy date & time */ 1754 for(; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0' 1755 && from_buf[i] != '+' && from_buf[i] != '-' 1756 && from_buf[i] != 'Z' && from_buf[i] != ' '; i++) 1757 ; /* skip fraction digits */ 1758 for(; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0' 1759 && from_buf[i] != ':' && from_buf[i] != ' ' ; i++) 1760 tsbuf[i] = from_buf[i]; /* copy TZ */ 1761 if (from_buf[i] == ':') i++; /* skip colon */ 1762 for(; i < MAX_TIMESTAMPLEN && from_buf[i] != '\0' 1763 && from_buf[i] != ' ' ; i++) 1764 tsbuf[i] = from_buf[i]; /* copy TZ */ 1765 1766 (void)memset(&parsed, 0, sizeof(parsed)); 1767 parsed.tm_isdst = -1; 1768 (void)strptime(tsbuf, "%FT%T%z", &parsed); 1769 timeval = mktime(&parsed); 1770 1771 *to_buf = make_timestamp(&timeval, false, BSD_TIMESTAMPLEN); 1772 return i; 1773 } else if (!from_iso && to_iso) { 1774 /* convert BSD->ISO */ 1775 struct tm parsed; 1776 struct tm *current; 1777 time_t timeval; 1778 1779 (void)memset(&parsed, 0, sizeof(parsed)); 1780 parsed.tm_isdst = -1; 1781 DPRINTF(D_CALL, "check_timestamp(): convert BSD->ISO\n"); 1782 strptime((char *)from_buf, "%b %d %T", &parsed); 1783 current = gmtime(&now); 1784 1785 /* use current year and timezone */ 1786 parsed.tm_isdst = current->tm_isdst; 1787 parsed.tm_gmtoff = current->tm_gmtoff; 1788 parsed.tm_year = current->tm_year; 1789 if (current->tm_mon == 0 && parsed.tm_mon == 11) 1790 parsed.tm_year--; 1791 1792 timeval = mktime(&parsed); 1793 *to_buf = make_timestamp(&timeval, true, MAX_TIMESTAMPLEN - 1); 1794 1795 return BSD_TIMESTAMPLEN; 1796 } else { 1797 DPRINTF(D_MISC, 1798 "Executing unreachable code in check_timestamp()\n"); 1799 return 0; 1800 } 1801 } 1802 1803 /* 1804 * Log a message to the appropriate log files, users, etc. based on 1805 * the priority. 1806 */ 1807 void 1808 logmsg(struct buf_msg *buffer) 1809 { 1810 struct filed *f; 1811 #ifndef __minix 1812 int fac, omask, prilev; 1813 #else /* __minix */ 1814 int fac, prilev; 1815 sigset_t omask; 1816 #endif /* __minix */ 1817 1818 DPRINTF((D_CALL|D_BUFFER), "logmsg: buffer@%p, pri 0%o/%d, flags 0x%x," 1819 " timestamp \"%s\", from \"%s\", sd \"%s\", msg \"%s\"\n", 1820 buffer, buffer->pri, buffer->pri, buffer->flags, 1821 buffer->timestamp, buffer->recvhost, buffer->sd, buffer->msg); 1822 1823 #ifndef __minix 1824 omask = sigblock(sigmask(SIGHUP)|sigmask(SIGALRM)); 1825 #else /* __minix */ 1826 sigemptyset(&omask); 1827 sigaddset(&omask, SIGHUP); 1828 sigaddset(&omask, SIGALRM); 1829 #define sigsetmask(s) (sigprocmask(SIG_SETMASK, &s, NULL)) 1830 #endif /* __minix */ 1831 1832 /* sanity check */ 1833 assert(buffer->refcount == 1); 1834 assert(buffer->msglen <= buffer->msgsize); 1835 assert(buffer->msgorig <= buffer->msg); 1836 assert((buffer->msg && buffer->msglen == strlen(buffer->msg)+1) 1837 || (!buffer->msg && !buffer->msglen)); 1838 if (!buffer->msg && !buffer->sd && !buffer->msgid) 1839 DPRINTF(D_BUFFER, "Empty message?\n"); 1840 1841 /* extract facility and priority level */ 1842 if (buffer->flags & MARK) 1843 fac = LOG_NFACILITIES; 1844 else 1845 fac = LOG_FAC(buffer->pri); 1846 prilev = LOG_PRI(buffer->pri); 1847 1848 /* log the message to the particular outputs */ 1849 if (!Initialized) { 1850 f = &consfile; 1851 f->f_file = open(ctty, O_WRONLY | O_NDELAY, 0); 1852 1853 if (f->f_file >= 0) { 1854 DELREF(f->f_prevmsg); 1855 f->f_prevmsg = NEWREF(buffer); 1856 fprintlog(f, NEWREF(buffer), NULL); 1857 DELREF(buffer); 1858 (void)close(f->f_file); 1859 } 1860 (void)sigsetmask(omask); 1861 return; 1862 } 1863 1864 for (f = Files; f; f = f->f_next) { 1865 char *h; /* host to use for comparing */ 1866 1867 /* skip messages that are incorrect priority */ 1868 if (!MATCH_PRI(f, fac, prilev) 1869 || f->f_pmask[fac] == INTERNAL_NOPRI) 1870 continue; 1871 1872 /* skip messages with the incorrect host name */ 1873 /* compare with host (which is supposedly more correct), */ 1874 /* but fallback to recvhost if host is NULL */ 1875 h = (buffer->host != NULL) ? buffer->host : buffer->recvhost; 1876 if (f->f_host != NULL && h != NULL) { 1877 char shost[MAXHOSTNAMELEN + 1]; 1878 1879 if (BSDOutputFormat) { 1880 (void)strlcpy(shost, h, sizeof(shost)); 1881 trim_anydomain(shost); 1882 h = shost; 1883 } 1884 switch (f->f_host[0]) { 1885 case '+': 1886 if (! matches_spec(h, f->f_host + 1, 1887 strcasestr)) 1888 continue; 1889 break; 1890 case '-': 1891 if (matches_spec(h, f->f_host + 1, 1892 strcasestr)) 1893 continue; 1894 break; 1895 } 1896 } 1897 1898 /* skip messages with the incorrect program name */ 1899 if (f->f_program != NULL && buffer->prog != NULL) { 1900 switch (f->f_program[0]) { 1901 case '+': 1902 if (!matches_spec(buffer->prog, 1903 f->f_program + 1, strstr)) 1904 continue; 1905 break; 1906 case '-': 1907 if (matches_spec(buffer->prog, 1908 f->f_program + 1, strstr)) 1909 continue; 1910 break; 1911 default: 1912 if (!matches_spec(buffer->prog, 1913 f->f_program, strstr)) 1914 continue; 1915 break; 1916 } 1917 } 1918 1919 if (f->f_type == F_CONSOLE && (buffer->flags & IGN_CONS)) 1920 continue; 1921 1922 /* don't output marks to recently written files */ 1923 if ((buffer->flags & MARK) 1924 && (now - f->f_time) < MarkInterval / 2) 1925 continue; 1926 1927 /* 1928 * suppress duplicate lines to this file unless NoRepeat 1929 */ 1930 #define MSG_FIELD_EQ(x) ((!buffer->x && !f->f_prevmsg->x) || \ 1931 (buffer->x && f->f_prevmsg->x && !strcmp(buffer->x, f->f_prevmsg->x))) 1932 1933 if ((buffer->flags & MARK) == 0 && 1934 f->f_prevmsg && 1935 buffer->msglen == f->f_prevmsg->msglen && 1936 !NoRepeat && 1937 MSG_FIELD_EQ(host) && 1938 MSG_FIELD_EQ(sd) && 1939 MSG_FIELD_EQ(msg) 1940 ) { 1941 f->f_prevcount++; 1942 DPRINTF(D_DATA, "Msg repeated %d times, %ld sec of %d\n", 1943 f->f_prevcount, (long)(now - f->f_time), 1944 repeatinterval[f->f_repeatcount]); 1945 /* 1946 * If domark would have logged this by now, 1947 * flush it now (so we don't hold isolated messages), 1948 * but back off so we'll flush less often 1949 * in the future. 1950 */ 1951 if (now > REPEATTIME(f)) { 1952 fprintlog(f, NEWREF(buffer), NULL); 1953 DELREF(buffer); 1954 BACKOFF(f); 1955 } 1956 } else { 1957 /* new line, save it */ 1958 if (f->f_prevcount) 1959 fprintlog(f, NULL, NULL); 1960 f->f_repeatcount = 0; 1961 DELREF(f->f_prevmsg); 1962 f->f_prevmsg = NEWREF(buffer); 1963 fprintlog(f, NEWREF(buffer), NULL); 1964 DELREF(buffer); 1965 } 1966 } 1967 (void)sigsetmask(omask); 1968 } 1969 1970 /* 1971 * format one buffer into output format given by flag BSDOutputFormat 1972 * line is allocated and has to be free()d by caller 1973 * size_t pointers are optional, if not NULL then they will return 1974 * different lenghts used for formatting and output 1975 */ 1976 #define OUT(x) ((x)?(x):"-") 1977 bool 1978 format_buffer(struct buf_msg *buffer, char **line, size_t *ptr_linelen, 1979 size_t *ptr_msglen, size_t *ptr_tlsprefixlen, size_t *ptr_prilen) 1980 { 1981 #define FPBUFSIZE 30 1982 static char ascii_empty[] = ""; 1983 char fp_buf[FPBUFSIZE] = "\0"; 1984 char *hostname, *shorthostname = NULL; 1985 char *ascii_sd = ascii_empty; 1986 char *ascii_msg = ascii_empty; 1987 size_t linelen, msglen, tlsprefixlen, prilen, j; 1988 1989 DPRINTF(D_CALL, "format_buffer(%p)\n", buffer); 1990 if (!buffer) return false; 1991 1992 /* All buffer fields are set with strdup(). To avoid problems 1993 * on memory exhaustion we allow them to be empty and replace 1994 * the essential fields with already allocated generic values. 1995 */ 1996 if (!buffer->timestamp) 1997 buffer->timestamp = timestamp; 1998 if (!buffer->host && !buffer->recvhost) 1999 buffer->host = LocalFQDN; 2000 2001 if (LogFacPri) { 2002 const char *f_s = NULL, *p_s = NULL; 2003 int fac = buffer->pri & LOG_FACMASK; 2004 int pri = LOG_PRI(buffer->pri); 2005 char f_n[5], p_n[5]; 2006 2007 if (LogFacPri > 1) { 2008 CODE *c; 2009 2010 for (c = facilitynames; c->c_name != NULL; c++) { 2011 if (c->c_val == fac) { 2012 f_s = c->c_name; 2013 break; 2014 } 2015 } 2016 for (c = prioritynames; c->c_name != NULL; c++) { 2017 if (c->c_val == pri) { 2018 p_s = c->c_name; 2019 break; 2020 } 2021 } 2022 } 2023 if (f_s == NULL) { 2024 snprintf(f_n, sizeof(f_n), "%d", LOG_FAC(fac)); 2025 f_s = f_n; 2026 } 2027 if (p_s == NULL) { 2028 snprintf(p_n, sizeof(p_n), "%d", pri); 2029 p_s = p_n; 2030 } 2031 snprintf(fp_buf, sizeof(fp_buf), "<%s.%s>", f_s, p_s); 2032 } 2033 2034 /* hostname or FQDN */ 2035 hostname = (buffer->host ? buffer->host : buffer->recvhost); 2036 if (BSDOutputFormat 2037 && (shorthostname = strdup(hostname))) { 2038 /* if the previous BSD output format with "host [recvhost]:" 2039 * gets implemented, this is the right place to distinguish 2040 * between buffer->host and buffer->recvhost 2041 */ 2042 trim_anydomain(shorthostname); 2043 hostname = shorthostname; 2044 } 2045 2046 /* new message formatting: 2047 * instead of using iov always assemble one complete TLS-ready line 2048 * with length and priority (depending on BSDOutputFormat either in 2049 * BSD Syslog or syslog-protocol format) 2050 * 2051 * additionally save the length of the prefixes, 2052 * so UDP destinations can skip the length prefix and 2053 * file/pipe/wall destinations can omit length and priority 2054 */ 2055 /* first determine required space */ 2056 if (BSDOutputFormat) { 2057 /* only output ASCII chars */ 2058 if (buffer->sd) 2059 ascii_sd = copy_utf8_ascii(buffer->sd, 2060 strlen(buffer->sd)); 2061 if (buffer->msg) { 2062 if (IS_BOM(buffer->msg)) 2063 ascii_msg = copy_utf8_ascii(buffer->msg, 2064 buffer->msglen - 1); 2065 else /* assume already converted at input */ 2066 ascii_msg = buffer->msg; 2067 } 2068 msglen = snprintf(NULL, 0, "<%d>%s%.15s %s %s%s%s%s: %s%s%s", 2069 buffer->pri, fp_buf, buffer->timestamp, 2070 hostname, OUT(buffer->prog), 2071 buffer->pid ? "[" : "", 2072 buffer->pid ? buffer->pid : "", 2073 buffer->pid ? "]" : "", ascii_sd, 2074 (buffer->sd && buffer->msg ? " ": ""), ascii_msg); 2075 } else 2076 msglen = snprintf(NULL, 0, "<%d>1 %s%s %s %s %s %s %s%s%s", 2077 buffer->pri, fp_buf, buffer->timestamp, 2078 hostname, OUT(buffer->prog), OUT(buffer->pid), 2079 OUT(buffer->msgid), OUT(buffer->sd), 2080 (buffer->msg ? " ": ""), 2081 (buffer->msg ? buffer->msg: "")); 2082 /* add space for length prefix */ 2083 tlsprefixlen = 0; 2084 for (j = msglen; j; j /= 10) 2085 tlsprefixlen++; 2086 /* one more for the space */ 2087 tlsprefixlen++; 2088 2089 prilen = snprintf(NULL, 0, "<%d>", buffer->pri); 2090 if (!BSDOutputFormat) 2091 prilen += 2; /* version char and space */ 2092 MALLOC(*line, msglen + tlsprefixlen + 1); 2093 if (BSDOutputFormat) 2094 linelen = snprintf(*line, 2095 msglen + tlsprefixlen + 1, 2096 "%zu <%d>%s%.15s %s %s%s%s%s: %s%s%s", 2097 msglen, buffer->pri, fp_buf, buffer->timestamp, 2098 hostname, OUT(buffer->prog), 2099 (buffer->pid ? "[" : ""), 2100 (buffer->pid ? buffer->pid : ""), 2101 (buffer->pid ? "]" : ""), ascii_sd, 2102 (buffer->sd && buffer->msg ? " ": ""), ascii_msg); 2103 else 2104 linelen = snprintf(*line, 2105 msglen + tlsprefixlen + 1, 2106 "%zu <%d>1 %s%s %s %s %s %s %s%s%s", 2107 msglen, buffer->pri, fp_buf, buffer->timestamp, 2108 hostname, OUT(buffer->prog), OUT(buffer->pid), 2109 OUT(buffer->msgid), OUT(buffer->sd), 2110 (buffer->msg ? " ": ""), 2111 (buffer->msg ? buffer->msg: "")); 2112 DPRINTF(D_DATA, "formatted %zu octets to: '%.*s' (linelen %zu, " 2113 "msglen %zu, tlsprefixlen %zu, prilen %zu)\n", linelen, 2114 (int)linelen, *line, linelen, msglen, tlsprefixlen, prilen); 2115 2116 FREEPTR(shorthostname); 2117 if (ascii_sd != ascii_empty) 2118 FREEPTR(ascii_sd); 2119 if (ascii_msg != ascii_empty && ascii_msg != buffer->msg) 2120 FREEPTR(ascii_msg); 2121 2122 if (ptr_linelen) *ptr_linelen = linelen; 2123 if (ptr_msglen) *ptr_msglen = msglen; 2124 if (ptr_tlsprefixlen) *ptr_tlsprefixlen = tlsprefixlen; 2125 if (ptr_prilen) *ptr_prilen = prilen; 2126 return true; 2127 } 2128 2129 /* 2130 * if qentry == NULL: new message, if temporarily undeliverable it will be enqueued 2131 * if qentry != NULL: a temporarily undeliverable message will not be enqueued, 2132 * but after delivery be removed from the queue 2133 */ 2134 void 2135 fprintlog(struct filed *f, struct buf_msg *passedbuffer, struct buf_queue *qentry) 2136 { 2137 static char crnl[] = "\r\n"; 2138 struct buf_msg *buffer = passedbuffer; 2139 struct iovec iov[4]; 2140 struct iovec *v = iov; 2141 bool error = false; 2142 int e = 0, len = 0; 2143 size_t msglen, linelen, tlsprefixlen, prilen; 2144 char *p, *line = NULL, *lineptr = NULL; 2145 #ifndef DISABLE_SIGN 2146 bool newhash = false; 2147 #endif 2148 #define REPBUFSIZE 80 2149 char greetings[200]; 2150 #define ADDEV() do { v++; assert((size_t)(v - iov) < A_CNT(iov)); } while(/*CONSTCOND*/0) 2151 2152 DPRINTF(D_CALL, "fprintlog(%p, %p, %p)\n", f, buffer, qentry); 2153 2154 f->f_time = now; 2155 2156 /* increase refcount here and lower again at return. 2157 * this enables the buffer in the else branch to be freed 2158 * --> every branch needs one NEWREF() or buf_msg_new()! */ 2159 if (buffer) { 2160 (void)NEWREF(buffer); 2161 } else { 2162 if (f->f_prevcount > 1) { 2163 /* possible syslog-sign incompatibility: 2164 * assume destinations f1 and f2 share one SG and 2165 * get the same message sequence. 2166 * 2167 * now both f1 and f2 generate "repeated" messages 2168 * "repeated" messages are different due to different 2169 * timestamps 2170 * the SG will get hashes for the two "repeated" messages 2171 * 2172 * now both f1 and f2 are just fine, but a verification 2173 * will report that each 'lost' a message, i.e. the 2174 * other's "repeated" message 2175 * 2176 * conditions for 'safe configurations': 2177 * - use NoRepeat option, 2178 * - use SG 3, or 2179 * - have exactly one destination for every PRI 2180 */ 2181 buffer = buf_msg_new(REPBUFSIZE); 2182 buffer->msglen = snprintf(buffer->msg, REPBUFSIZE, 2183 "last message repeated %d times", f->f_prevcount); 2184 buffer->timestamp = make_timestamp(NULL, 2185 !BSDOutputFormat, 0); 2186 buffer->pri = f->f_prevmsg->pri; 2187 buffer->host = LocalFQDN; 2188 buffer->prog = appname; 2189 buffer->pid = include_pid; 2190 2191 } else { 2192 buffer = NEWREF(f->f_prevmsg); 2193 } 2194 } 2195 2196 /* no syslog-sign messages to tty/console/... */ 2197 if ((buffer->flags & SIGN_MSG) 2198 && ((f->f_type == F_UNUSED) 2199 || (f->f_type == F_TTY) 2200 || (f->f_type == F_CONSOLE) 2201 || (f->f_type == F_USERS) 2202 || (f->f_type == F_WALL) 2203 || (f->f_type == F_FIFO))) { 2204 DELREF(buffer); 2205 return; 2206 } 2207 2208 /* buffering works only for few types */ 2209 if (qentry 2210 && (f->f_type != F_TLS) 2211 && (f->f_type != F_PIPE) 2212 && (f->f_type != F_FILE) 2213 && (f->f_type != F_FIFO)) { 2214 errno = 0; 2215 logerror("Warning: unexpected message type %d in buffer", 2216 f->f_type); 2217 DELREF(buffer); 2218 return; 2219 } 2220 2221 if (!format_buffer(buffer, &line, 2222 &linelen, &msglen, &tlsprefixlen, &prilen)) { 2223 DPRINTF(D_CALL, "format_buffer() failed, skip message\n"); 2224 DELREF(buffer); 2225 return; 2226 } 2227 /* assert maximum message length */ 2228 if (TypeInfo[f->f_type].max_msg_length != -1 2229 && (size_t)TypeInfo[f->f_type].max_msg_length 2230 < linelen - tlsprefixlen - prilen) { 2231 linelen = TypeInfo[f->f_type].max_msg_length 2232 + tlsprefixlen + prilen; 2233 DPRINTF(D_DATA, "truncating oversized message to %zu octets\n", 2234 linelen); 2235 } 2236 2237 #ifndef DISABLE_SIGN 2238 /* keep state between appending the hash (before buffer is sent) 2239 * and possibly sending a SB (after buffer is sent): */ 2240 /* get hash */ 2241 if (!(buffer->flags & SIGN_MSG) && !qentry) { 2242 char *hash = NULL; 2243 struct signature_group_t *sg; 2244 2245 if ((sg = sign_get_sg(buffer->pri, f)) != NULL) { 2246 if (sign_msg_hash(line + tlsprefixlen, &hash)) 2247 newhash = sign_append_hash(hash, sg); 2248 else 2249 DPRINTF(D_SIGN, 2250 "Unable to hash line \"%s\"\n", line); 2251 } 2252 } 2253 #endif /* !DISABLE_SIGN */ 2254 2255 /* set start and length of buffer and/or fill iovec */ 2256 switch (f->f_type) { 2257 case F_UNUSED: 2258 /* nothing */ 2259 break; 2260 case F_TLS: 2261 /* nothing, as TLS uses whole buffer to send */ 2262 lineptr = line; 2263 len = linelen; 2264 break; 2265 case F_FORW: 2266 lineptr = line + tlsprefixlen; 2267 len = linelen - tlsprefixlen; 2268 break; 2269 case F_PIPE: 2270 case F_FIFO: 2271 case F_FILE: /* fallthrough */ 2272 if (f->f_flags & FFLAG_FULL) { 2273 v->iov_base = line + tlsprefixlen; 2274 v->iov_len = linelen - tlsprefixlen; 2275 } else { 2276 v->iov_base = line + tlsprefixlen + prilen; 2277 v->iov_len = linelen - tlsprefixlen - prilen; 2278 } 2279 ADDEV(); 2280 v->iov_base = &crnl[1]; 2281 v->iov_len = 1; 2282 ADDEV(); 2283 break; 2284 case F_CONSOLE: 2285 case F_TTY: 2286 /* filter non-ASCII */ 2287 p = line; 2288 while (*p) { 2289 *p = FORCE2ASCII(*p); 2290 p++; 2291 } 2292 v->iov_base = line + tlsprefixlen + prilen; 2293 v->iov_len = linelen - tlsprefixlen - prilen; 2294 ADDEV(); 2295 v->iov_base = crnl; 2296 v->iov_len = 2; 2297 ADDEV(); 2298 break; 2299 case F_WALL: 2300 v->iov_base = greetings; 2301 v->iov_len = snprintf(greetings, sizeof(greetings), 2302 "\r\n\7Message from syslogd@%s at %s ...\r\n", 2303 (buffer->host ? buffer->host : buffer->recvhost), 2304 buffer->timestamp); 2305 ADDEV(); 2306 case F_USERS: /* fallthrough */ 2307 /* filter non-ASCII */ 2308 p = line; 2309 while (*p) { 2310 *p = FORCE2ASCII(*p); 2311 p++; 2312 } 2313 v->iov_base = line + tlsprefixlen + prilen; 2314 v->iov_len = linelen - tlsprefixlen - prilen; 2315 ADDEV(); 2316 v->iov_base = &crnl[1]; 2317 v->iov_len = 1; 2318 ADDEV(); 2319 break; 2320 } 2321 2322 /* send */ 2323 switch (f->f_type) { 2324 case F_UNUSED: 2325 DPRINTF(D_MISC, "Logging to %s\n", TypeInfo[f->f_type].name); 2326 break; 2327 2328 case F_FORW: 2329 DPRINTF(D_MISC, "Logging to %s %s\n", 2330 TypeInfo[f->f_type].name, f->f_un.f_forw.f_hname); 2331 udp_send(f, lineptr, len); 2332 break; 2333 2334 #ifndef DISABLE_TLS 2335 case F_TLS: 2336 DPRINTF(D_MISC, "Logging to %s %s\n", 2337 TypeInfo[f->f_type].name, 2338 f->f_un.f_tls.tls_conn->hostname); 2339 /* make sure every message gets queued once 2340 * it will be removed when sendmsg is sent and free()d */ 2341 if (!qentry) 2342 qentry = message_queue_add(f, NEWREF(buffer)); 2343 (void)tls_send(f, lineptr, len, qentry); 2344 break; 2345 #endif /* !DISABLE_TLS */ 2346 2347 case F_PIPE: 2348 DPRINTF(D_MISC, "Logging to %s %s\n", 2349 TypeInfo[f->f_type].name, f->f_un.f_pipe.f_pname); 2350 if (f->f_un.f_pipe.f_pid == 0) { 2351 /* (re-)open */ 2352 if ((f->f_file = p_open(f->f_un.f_pipe.f_pname, 2353 &f->f_un.f_pipe.f_pid)) < 0) { 2354 f->f_type = F_UNUSED; 2355 logerror("%s", f->f_un.f_pipe.f_pname); 2356 message_queue_freeall(f); 2357 break; 2358 } else if (!qentry) /* prevent recursion */ 2359 SEND_QUEUE(f); 2360 } 2361 if (writev(f->f_file, iov, v - iov) < 0) { 2362 e = errno; 2363 if (f->f_un.f_pipe.f_pid > 0) { 2364 (void) close(f->f_file); 2365 deadq_enter(f->f_un.f_pipe.f_pid, 2366 f->f_un.f_pipe.f_pname); 2367 } 2368 f->f_un.f_pipe.f_pid = 0; 2369 /* 2370 * If the error was EPIPE, then what is likely 2371 * has happened is we have a command that is 2372 * designed to take a single message line and 2373 * then exit, but we tried to feed it another 2374 * one before we reaped the child and thus 2375 * reset our state. 2376 * 2377 * Well, now we've reset our state, so try opening 2378 * the pipe and sending the message again if EPIPE 2379 * was the error. 2380 */ 2381 if (e == EPIPE) { 2382 if ((f->f_file = p_open(f->f_un.f_pipe.f_pname, 2383 &f->f_un.f_pipe.f_pid)) < 0) { 2384 f->f_type = F_UNUSED; 2385 logerror("%s", f->f_un.f_pipe.f_pname); 2386 message_queue_freeall(f); 2387 break; 2388 } 2389 if (writev(f->f_file, iov, v - iov) < 0) { 2390 e = errno; 2391 if (f->f_un.f_pipe.f_pid > 0) { 2392 (void) close(f->f_file); 2393 deadq_enter(f->f_un.f_pipe.f_pid, 2394 f->f_un.f_pipe.f_pname); 2395 } 2396 f->f_un.f_pipe.f_pid = 0; 2397 error = true; /* enqueue on return */ 2398 } else 2399 e = 0; 2400 } 2401 if (e != 0 && !error) { 2402 errno = e; 2403 logerror("%s", f->f_un.f_pipe.f_pname); 2404 } 2405 } 2406 if (e == 0 && qentry) { /* sent buffered msg */ 2407 message_queue_remove(f, qentry); 2408 } 2409 break; 2410 2411 case F_CONSOLE: 2412 if (buffer->flags & IGN_CONS) { 2413 DPRINTF(D_MISC, "Logging to %s (ignored)\n", 2414 TypeInfo[f->f_type].name); 2415 break; 2416 } 2417 /* FALLTHROUGH */ 2418 2419 case F_TTY: 2420 case F_FILE: 2421 DPRINTF(D_MISC, "Logging to %s %s\n", 2422 TypeInfo[f->f_type].name, f->f_un.f_fname); 2423 again: 2424 if ((f->f_type == F_FILE ? writev(f->f_file, iov, v - iov) : 2425 writev1(f->f_file, iov, v - iov)) < 0) { 2426 e = errno; 2427 if (f->f_type == F_FILE && e == ENOSPC) { 2428 int lasterror = f->f_lasterror; 2429 f->f_lasterror = e; 2430 if (lasterror != e) 2431 logerror("%s", f->f_un.f_fname); 2432 error = true; /* enqueue on return */ 2433 } 2434 (void)close(f->f_file); 2435 /* 2436 * Check for errors on TTY's due to loss of tty 2437 */ 2438 if ((e == EIO || e == EBADF) && f->f_type != F_FILE) { 2439 f->f_file = open(f->f_un.f_fname, 2440 O_WRONLY|O_APPEND|O_NONBLOCK, 0); 2441 if (f->f_file < 0) { 2442 f->f_type = F_UNUSED; 2443 logerror("%s", f->f_un.f_fname); 2444 message_queue_freeall(f); 2445 } else 2446 goto again; 2447 } else { 2448 f->f_type = F_UNUSED; 2449 errno = e; 2450 f->f_lasterror = e; 2451 logerror("%s", f->f_un.f_fname); 2452 message_queue_freeall(f); 2453 } 2454 } else { 2455 f->f_lasterror = 0; 2456 if ((buffer->flags & SYNC_FILE) 2457 && (f->f_flags & FFLAG_SYNC)) 2458 (void)fsync(f->f_file); 2459 /* Problem with files: We cannot check beforehand if 2460 * they would be writeable and call send_queue() first. 2461 * So we call send_queue() after a successful write, 2462 * which means the first message will be out of order. 2463 */ 2464 if (!qentry) /* prevent recursion */ 2465 SEND_QUEUE(f); 2466 else if (qentry) /* sent buffered msg */ 2467 message_queue_remove(f, qentry); 2468 } 2469 break; 2470 2471 case F_FIFO: 2472 DPRINTF(D_MISC, "Logging to %s %s\n", 2473 TypeInfo[f->f_type].name, f->f_un.f_fname); 2474 if (f->f_file < 0) { 2475 f->f_file = 2476 open(f->f_un.f_fname, O_WRONLY|O_NONBLOCK, 0); 2477 e = errno; 2478 if (f->f_file < 0 && e == ENXIO) { 2479 /* Drop messages with no reader */ 2480 if (qentry) 2481 message_queue_remove(f, qentry); 2482 break; 2483 } 2484 } 2485 2486 if (f->f_file >= 0 && writev(f->f_file, iov, v - iov) < 0) { 2487 e = errno; 2488 2489 /* Enqueue if the fifo buffer is full */ 2490 if (e == EAGAIN) { 2491 if (f->f_lasterror != e) 2492 logerror("%s", f->f_un.f_fname); 2493 f->f_lasterror = e; 2494 error = true; /* enqueue on return */ 2495 break; 2496 } 2497 2498 close(f->f_file); 2499 f->f_file = -1; 2500 2501 /* Drop messages with no reader */ 2502 if (e == EPIPE) { 2503 if (qentry) 2504 message_queue_remove(f, qentry); 2505 break; 2506 } 2507 } 2508 2509 if (f->f_file < 0) { 2510 f->f_type = F_UNUSED; 2511 errno = e; 2512 f->f_lasterror = e; 2513 logerror("%s", f->f_un.f_fname); 2514 message_queue_freeall(f); 2515 break; 2516 } 2517 2518 f->f_lasterror = 0; 2519 if (!qentry) /* prevent recursion (see comment for F_FILE) */ 2520 SEND_QUEUE(f); 2521 if (qentry) /* sent buffered msg */ 2522 message_queue_remove(f, qentry); 2523 break; 2524 2525 case F_USERS: 2526 case F_WALL: 2527 DPRINTF(D_MISC, "Logging to %s\n", TypeInfo[f->f_type].name); 2528 wallmsg(f, iov, v - iov); 2529 break; 2530 } 2531 f->f_prevcount = 0; 2532 2533 if (error && !qentry) 2534 message_queue_add(f, NEWREF(buffer)); 2535 #ifndef DISABLE_SIGN 2536 if (newhash) { 2537 struct signature_group_t *sg; 2538 sg = sign_get_sg(buffer->pri, f); 2539 (void)sign_send_signature_block(sg, false); 2540 } 2541 #endif /* !DISABLE_SIGN */ 2542 /* this belongs to the ad-hoc buffer at the first if(buffer) */ 2543 DELREF(buffer); 2544 /* TLS frees on its own */ 2545 if (f->f_type != F_TLS) 2546 FREEPTR(line); 2547 } 2548 2549 /* send one line by UDP */ 2550 void 2551 udp_send(struct filed *f, char *line, size_t len) 2552 { 2553 int lsent, fail, retry, j; 2554 struct addrinfo *r; 2555 2556 DPRINTF((D_NET|D_CALL), "udp_send(f=%p, line=\"%s\", " 2557 "len=%zu) to dest.\n", f, line, len); 2558 2559 if (!finet) 2560 return; 2561 2562 lsent = -1; 2563 fail = 0; 2564 assert(f->f_type == F_FORW); 2565 for (r = f->f_un.f_forw.f_addr; r; r = r->ai_next) { 2566 retry = 0; 2567 for (j = 0; j < finet->fd; j++) { 2568 if (finet[j+1].af != r->ai_family) 2569 continue; 2570 sendagain: 2571 lsent = sendto(finet[j+1].fd, line, len, 0, 2572 r->ai_addr, r->ai_addrlen); 2573 if (lsent == -1) { 2574 switch (errno) { 2575 case ENOBUFS: 2576 /* wait/retry/drop */ 2577 if (++retry < 5) { 2578 usleep(1000); 2579 goto sendagain; 2580 } 2581 break; 2582 case EHOSTDOWN: 2583 case EHOSTUNREACH: 2584 case ENETDOWN: 2585 /* drop */ 2586 break; 2587 default: 2588 /* busted */ 2589 fail++; 2590 break; 2591 } 2592 } else if ((size_t)lsent == len) 2593 break; 2594 } 2595 if ((size_t)lsent != len && fail) { 2596 f->f_type = F_UNUSED; 2597 logerror("sendto() failed"); 2598 } 2599 } 2600 } 2601 2602 /* 2603 * WALLMSG -- Write a message to the world at large 2604 * 2605 * Write the specified message to either the entire 2606 * world, or a list of approved users. 2607 */ 2608 void 2609 wallmsg(struct filed *f, struct iovec *iov, size_t iovcnt) 2610 { 2611 #ifdef __NetBSD_Version__ 2612 static int reenter; /* avoid calling ourselves */ 2613 int i; 2614 char *p; 2615 struct utmpentry *ep; 2616 2617 if (reenter++) 2618 return; 2619 2620 (void)getutentries(NULL, &ep); 2621 /* NOSTRICT */ 2622 for (; ep; ep = ep->next) { 2623 if (f->f_type == F_WALL) { 2624 if ((p = ttymsg(iov, iovcnt, ep->line, TTYMSGTIME)) 2625 != NULL) { 2626 errno = 0; /* already in msg */ 2627 logerror("%s", p); 2628 } 2629 continue; 2630 } 2631 /* should we send the message to this user? */ 2632 for (i = 0; i < MAXUNAMES; i++) { 2633 if (!f->f_un.f_uname[i][0]) 2634 break; 2635 if (strcmp(f->f_un.f_uname[i], ep->name) == 0) { 2636 struct stat st; 2637 char tty[MAXPATHLEN]; 2638 snprintf(tty, sizeof(tty), "%s/%s", _PATH_DEV, 2639 ep->line); 2640 if (stat(tty, &st) != -1 && 2641 (st.st_mode & S_IWGRP) == 0) 2642 break; 2643 2644 if ((p = ttymsg(iov, iovcnt, ep->line, 2645 TTYMSGTIME)) != NULL) { 2646 errno = 0; /* already in msg */ 2647 logerror("%s", p); 2648 } 2649 break; 2650 } 2651 } 2652 } 2653 reenter = 0; 2654 #endif /* __NetBSD_Version__ */ 2655 } 2656 2657 void 2658 /*ARGSUSED*/ 2659 reapchild(int fd, short event, void *ev) 2660 { 2661 int status; 2662 pid_t pid; 2663 struct filed *f; 2664 2665 while ((pid = wait3(&status, WNOHANG, NULL)) > 0) { 2666 if (!Initialized || ShuttingDown) { 2667 /* 2668 * Be silent while we are initializing or 2669 * shutting down. 2670 */ 2671 continue; 2672 } 2673 2674 if (deadq_remove(pid)) 2675 continue; 2676 2677 /* Now, look in the list of active processes. */ 2678 for (f = Files; f != NULL; f = f->f_next) { 2679 if (f->f_type == F_PIPE && 2680 f->f_un.f_pipe.f_pid == pid) { 2681 (void) close(f->f_file); 2682 f->f_un.f_pipe.f_pid = 0; 2683 log_deadchild(pid, status, 2684 f->f_un.f_pipe.f_pname); 2685 break; 2686 } 2687 } 2688 } 2689 } 2690 2691 /* 2692 * Return a printable representation of a host address (FQDN if available) 2693 */ 2694 const char * 2695 cvthname(struct sockaddr_storage *f) 2696 { 2697 int error; 2698 int niflag = NI_DGRAM; 2699 static char host[NI_MAXHOST], ip[NI_MAXHOST]; 2700 2701 error = getnameinfo((struct sockaddr*)f, ((struct sockaddr*)f)->sa_len, 2702 ip, sizeof ip, NULL, 0, NI_NUMERICHOST|niflag); 2703 2704 DPRINTF(D_CALL, "cvthname(%s)\n", ip); 2705 2706 if (error) { 2707 DPRINTF(D_NET, "Malformed from address %s\n", 2708 gai_strerror(error)); 2709 return "???"; 2710 } 2711 2712 if (!UseNameService) 2713 return ip; 2714 2715 error = getnameinfo((struct sockaddr*)f, ((struct sockaddr*)f)->sa_len, 2716 host, sizeof host, NULL, 0, niflag); 2717 if (error) { 2718 DPRINTF(D_NET, "Host name for your address (%s) unknown\n", ip); 2719 return ip; 2720 } 2721 2722 return host; 2723 } 2724 2725 void 2726 trim_anydomain(char *host) 2727 { 2728 bool onlydigits = true; 2729 int i; 2730 2731 if (!BSDOutputFormat) 2732 return; 2733 2734 /* if non-digits found, then assume hostname and cut at first dot (this 2735 * case also covers IPv6 addresses which should not contain dots), 2736 * if only digits then assume IPv4 address and do not cut at all */ 2737 for (i = 0; host[i]; i++) { 2738 if (host[i] == '.' && !onlydigits) 2739 host[i] = '\0'; 2740 else if (!isdigit((unsigned char)host[i]) && host[i] != '.') 2741 onlydigits = false; 2742 } 2743 } 2744 2745 static void 2746 /*ARGSUSED*/ 2747 domark(int fd, short event, void *ev) 2748 { 2749 struct event *ev_pass = (struct event *)ev; 2750 struct filed *f; 2751 dq_t q, nextq; 2752 sigset_t newmask, omask; 2753 2754 schedule_event(&ev_pass, 2755 &((struct timeval){TIMERINTVL, 0}), 2756 domark, ev_pass); 2757 DPRINTF((D_CALL|D_EVENT), "domark()\n"); 2758 2759 BLOCK_SIGNALS(omask, newmask); 2760 now = time(NULL); 2761 MarkSeq += TIMERINTVL; 2762 if (MarkSeq >= MarkInterval) { 2763 logmsg_async(LOG_INFO, NULL, "-- MARK --", ADDDATE|MARK); 2764 MarkSeq = 0; 2765 } 2766 2767 for (f = Files; f; f = f->f_next) { 2768 if (f->f_prevcount && now >= REPEATTIME(f)) { 2769 DPRINTF(D_DATA, "Flush %s: repeated %d times, %d sec.\n", 2770 TypeInfo[f->f_type].name, f->f_prevcount, 2771 repeatinterval[f->f_repeatcount]); 2772 fprintlog(f, NULL, NULL); 2773 BACKOFF(f); 2774 } 2775 } 2776 message_allqueues_check(); 2777 RESTORE_SIGNALS(omask); 2778 2779 /* Walk the dead queue, and see if we should signal somebody. */ 2780 for (q = TAILQ_FIRST(&deadq_head); q != NULL; q = nextq) { 2781 nextq = TAILQ_NEXT(q, dq_entries); 2782 switch (q->dq_timeout) { 2783 case 0: 2784 /* Already signalled once, try harder now. */ 2785 if (kill(q->dq_pid, SIGKILL) != 0) 2786 (void) deadq_remove(q->dq_pid); 2787 break; 2788 2789 case 1: 2790 /* 2791 * Timed out on the dead queue, send terminate 2792 * signal. Note that we leave the removal from 2793 * the dead queue to reapchild(), which will 2794 * also log the event (unless the process 2795 * didn't even really exist, in case we simply 2796 * drop it from the dead queue). 2797 */ 2798 if (kill(q->dq_pid, SIGTERM) != 0) { 2799 (void) deadq_remove(q->dq_pid); 2800 break; 2801 } 2802 /* FALLTHROUGH */ 2803 2804 default: 2805 q->dq_timeout--; 2806 } 2807 } 2808 #ifndef DISABLE_SIGN 2809 if (GlobalSign.rsid) { /* check if initialized */ 2810 struct signature_group_t *sg; 2811 STAILQ_FOREACH(sg, &GlobalSign.SigGroups, entries) { 2812 sign_send_certificate_block(sg); 2813 } 2814 } 2815 #endif /* !DISABLE_SIGN */ 2816 } 2817 2818 /* 2819 * Print syslogd errors some place. 2820 */ 2821 void 2822 logerror(const char *fmt, ...) 2823 { 2824 static int logerror_running; 2825 va_list ap; 2826 char tmpbuf[BUFSIZ]; 2827 char buf[BUFSIZ]; 2828 char *outbuf; 2829 2830 /* If there's an error while trying to log an error, give up. */ 2831 if (logerror_running) 2832 return; 2833 logerror_running = 1; 2834 2835 va_start(ap, fmt); 2836 (void)vsnprintf(tmpbuf, sizeof(tmpbuf), fmt, ap); 2837 va_end(ap); 2838 2839 if (errno) { 2840 (void)snprintf(buf, sizeof(buf), "%s: %s", 2841 tmpbuf, strerror(errno)); 2842 outbuf = buf; 2843 } else { 2844 (void)snprintf(buf, sizeof(buf), "%s", tmpbuf); 2845 outbuf = tmpbuf; 2846 } 2847 2848 if (daemonized) 2849 logmsg_async(LOG_SYSLOG|LOG_ERR, NULL, outbuf, ADDDATE); 2850 if (!daemonized && Debug) 2851 DPRINTF(D_MISC, "%s\n", outbuf); 2852 if (!daemonized && !Debug) 2853 printf("%s\n", outbuf); 2854 2855 logerror_running = 0; 2856 } 2857 2858 /* 2859 * Print syslogd info some place. 2860 */ 2861 void 2862 loginfo(const char *fmt, ...) 2863 { 2864 va_list ap; 2865 char buf[BUFSIZ]; 2866 2867 va_start(ap, fmt); 2868 (void)vsnprintf(buf, sizeof(buf), fmt, ap); 2869 va_end(ap); 2870 2871 DPRINTF(D_MISC, "%s\n", buf); 2872 logmsg_async(LOG_SYSLOG|LOG_INFO, NULL, buf, ADDDATE); 2873 } 2874 2875 #ifndef DISABLE_TLS 2876 static inline void 2877 free_incoming_tls_sockets(void) 2878 { 2879 struct TLS_Incoming_Conn *tls_in; 2880 int i; 2881 2882 /* 2883 * close all listening and connected TLS sockets 2884 */ 2885 if (TLS_Listen_Set) 2886 for (i = 0; i < TLS_Listen_Set->fd; i++) { 2887 if (close(TLS_Listen_Set[i+1].fd) == -1) 2888 logerror("close() failed"); 2889 DEL_EVENT(TLS_Listen_Set[i+1].ev); 2890 FREEPTR(TLS_Listen_Set[i+1].ev); 2891 } 2892 FREEPTR(TLS_Listen_Set); 2893 /* close/free incoming TLS connections */ 2894 while (!SLIST_EMPTY(&TLS_Incoming_Head)) { 2895 tls_in = SLIST_FIRST(&TLS_Incoming_Head); 2896 SLIST_REMOVE_HEAD(&TLS_Incoming_Head, entries); 2897 FREEPTR(tls_in->inbuf); 2898 free_tls_conn(tls_in->tls_conn); 2899 free(tls_in); 2900 } 2901 } 2902 #endif /* !DISABLE_TLS */ 2903 2904 void 2905 /*ARGSUSED*/ 2906 die(int fd, short event, void *ev) 2907 { 2908 struct filed *f, *next; 2909 char **p; 2910 sigset_t newmask, omask; 2911 int i; 2912 size_t j; 2913 2914 ShuttingDown = 1; /* Don't log SIGCHLDs. */ 2915 /* prevent recursive signals */ 2916 BLOCK_SIGNALS(omask, newmask); 2917 2918 errno = 0; 2919 if (ev != NULL) 2920 logerror("Exiting on signal %d", fd); 2921 else 2922 logerror("Fatal error, exiting"); 2923 2924 /* 2925 * flush any pending output 2926 */ 2927 for (f = Files; f != NULL; f = f->f_next) { 2928 /* flush any pending output */ 2929 if (f->f_prevcount) 2930 fprintlog(f, NULL, NULL); 2931 SEND_QUEUE(f); 2932 } 2933 2934 #ifndef DISABLE_TLS 2935 free_incoming_tls_sockets(); 2936 #endif /* !DISABLE_TLS */ 2937 #ifndef DISABLE_SIGN 2938 sign_global_free(); 2939 #endif /* !DISABLE_SIGN */ 2940 2941 /* 2942 * Close all open log files. 2943 */ 2944 for (f = Files; f != NULL; f = next) { 2945 message_queue_freeall(f); 2946 2947 switch (f->f_type) { 2948 case F_FILE: 2949 case F_TTY: 2950 case F_CONSOLE: 2951 case F_FIFO: 2952 if (f->f_file >= 0) 2953 (void)close(f->f_file); 2954 break; 2955 case F_PIPE: 2956 if (f->f_un.f_pipe.f_pid > 0) { 2957 (void)close(f->f_file); 2958 } 2959 f->f_un.f_pipe.f_pid = 0; 2960 break; 2961 case F_FORW: 2962 if (f->f_un.f_forw.f_addr) 2963 freeaddrinfo(f->f_un.f_forw.f_addr); 2964 break; 2965 #ifndef DISABLE_TLS 2966 case F_TLS: 2967 free_tls_conn(f->f_un.f_tls.tls_conn); 2968 break; 2969 #endif /* !DISABLE_TLS */ 2970 } 2971 next = f->f_next; 2972 DELREF(f->f_prevmsg); 2973 FREEPTR(f->f_program); 2974 FREEPTR(f->f_host); 2975 DEL_EVENT(f->f_sq_event); 2976 free((char *)f); 2977 } 2978 2979 /* 2980 * Close all open UDP sockets 2981 */ 2982 if (finet) { 2983 for (i = 0; i < finet->fd; i++) { 2984 if (close(finet[i+1].fd) < 0) { 2985 logerror("close() failed"); 2986 die(0, 0, NULL); 2987 } 2988 DEL_EVENT(finet[i+1].ev); 2989 FREEPTR(finet[i+1].ev); 2990 } 2991 FREEPTR(finet); 2992 } 2993 2994 /* free config options */ 2995 for (j = 0; j < A_CNT(TypeInfo); j++) { 2996 FREEPTR(TypeInfo[j].queue_length_string); 2997 FREEPTR(TypeInfo[j].queue_size_string); 2998 } 2999 3000 #ifndef DISABLE_TLS 3001 FREEPTR(tls_opt.CAdir); 3002 FREEPTR(tls_opt.CAfile); 3003 FREEPTR(tls_opt.keyfile); 3004 FREEPTR(tls_opt.certfile); 3005 FREEPTR(tls_opt.x509verify); 3006 FREEPTR(tls_opt.bindhost); 3007 FREEPTR(tls_opt.bindport); 3008 FREEPTR(tls_opt.server); 3009 FREEPTR(tls_opt.gen_cert); 3010 free_cred_SLIST(&tls_opt.cert_head); 3011 free_cred_SLIST(&tls_opt.fprint_head); 3012 FREE_SSL_CTX(tls_opt.global_TLS_CTX); 3013 #endif /* !DISABLE_TLS */ 3014 3015 FREEPTR(funix); 3016 for (p = LogPaths; p && *p; p++) 3017 unlink(*p); 3018 exit(0); 3019 } 3020 3021 #ifndef DISABLE_SIGN 3022 /* 3023 * get one "sign_delim_sg2" item, convert and store in ordered queue 3024 */ 3025 void 3026 store_sign_delim_sg2(char *tmp_buf) 3027 { 3028 struct string_queue *sqentry, *sqe1, *sqe2; 3029 3030 if(!(sqentry = malloc(sizeof(*sqentry)))) { 3031 logerror("Unable to allocate memory"); 3032 return; 3033 } 3034 /*LINTED constcond/null effect */ 3035 assert(sizeof(int64_t) == sizeof(uint_fast64_t)); 3036 if (dehumanize_number(tmp_buf, (int64_t*) &(sqentry->key)) == -1 3037 || sqentry->key > (LOG_NFACILITIES<<3)) { 3038 DPRINTF(D_PARSE, "invalid sign_delim_sg2: %s\n", tmp_buf); 3039 free(sqentry); 3040 FREEPTR(tmp_buf); 3041 return; 3042 } 3043 sqentry->data = tmp_buf; 3044 3045 if (STAILQ_EMPTY(&GlobalSign.sig2_delims)) { 3046 STAILQ_INSERT_HEAD(&GlobalSign.sig2_delims, 3047 sqentry, entries); 3048 return; 3049 } 3050 3051 /* keep delimiters sorted */ 3052 sqe1 = sqe2 = STAILQ_FIRST(&GlobalSign.sig2_delims); 3053 if (sqe1->key > sqentry->key) { 3054 STAILQ_INSERT_HEAD(&GlobalSign.sig2_delims, 3055 sqentry, entries); 3056 return; 3057 } 3058 3059 while ((sqe1 = sqe2) 3060 && (sqe2 = STAILQ_NEXT(sqe1, entries))) { 3061 if (sqe2->key > sqentry->key) { 3062 break; 3063 } else if (sqe2->key == sqentry->key) { 3064 DPRINTF(D_PARSE, "duplicate sign_delim_sg2: %s\n", 3065 tmp_buf); 3066 FREEPTR(sqentry); 3067 FREEPTR(tmp_buf); 3068 return; 3069 } 3070 } 3071 STAILQ_INSERT_AFTER(&GlobalSign.sig2_delims, sqe1, sqentry, entries); 3072 } 3073 #endif /* !DISABLE_SIGN */ 3074 3075 /* 3076 * read syslog.conf 3077 */ 3078 void 3079 read_config_file(FILE *cf, struct filed **f_ptr) 3080 { 3081 size_t linenum = 0; 3082 size_t i; 3083 struct filed *f, **nextp; 3084 char cline[LINE_MAX]; 3085 char prog[NAME_MAX + 1]; 3086 char host[MAXHOSTNAMELEN]; 3087 const char *p; 3088 char *q; 3089 bool found_keyword; 3090 #ifndef DISABLE_TLS 3091 struct peer_cred *cred = NULL; 3092 struct peer_cred_head *credhead = NULL; 3093 #endif /* !DISABLE_TLS */ 3094 #ifndef DISABLE_SIGN 3095 char *sign_sg_str = NULL; 3096 #endif /* !DISABLE_SIGN */ 3097 #if (!defined(DISABLE_TLS) || !defined(DISABLE_SIGN)) 3098 char *tmp_buf = NULL; 3099 #endif /* (!defined(DISABLE_TLS) || !defined(DISABLE_SIGN)) */ 3100 /* central list of recognized configuration keywords 3101 * and an address for their values as strings */ 3102 const struct config_keywords { 3103 const char *keyword; 3104 char **variable; 3105 } config_keywords[] = { 3106 #ifndef DISABLE_TLS 3107 /* TLS settings */ 3108 {"tls_ca", &tls_opt.CAfile}, 3109 {"tls_cadir", &tls_opt.CAdir}, 3110 {"tls_cert", &tls_opt.certfile}, 3111 {"tls_key", &tls_opt.keyfile}, 3112 {"tls_verify", &tls_opt.x509verify}, 3113 {"tls_bindport", &tls_opt.bindport}, 3114 {"tls_bindhost", &tls_opt.bindhost}, 3115 {"tls_server", &tls_opt.server}, 3116 {"tls_gen_cert", &tls_opt.gen_cert}, 3117 /* special cases in parsing */ 3118 {"tls_allow_fingerprints",&tmp_buf}, 3119 {"tls_allow_clientcerts", &tmp_buf}, 3120 /* buffer settings */ 3121 {"tls_queue_length", &TypeInfo[F_TLS].queue_length_string}, 3122 {"tls_queue_size", &TypeInfo[F_TLS].queue_size_string}, 3123 #endif /* !DISABLE_TLS */ 3124 {"file_queue_length", &TypeInfo[F_FILE].queue_length_string}, 3125 {"pipe_queue_length", &TypeInfo[F_PIPE].queue_length_string}, 3126 {"fifo_queue_length", &TypeInfo[F_FIFO].queue_length_string}, 3127 {"file_queue_size", &TypeInfo[F_FILE].queue_size_string}, 3128 {"pipe_queue_size", &TypeInfo[F_PIPE].queue_size_string}, 3129 {"fifo_queue_size", &TypeInfo[F_FIFO].queue_size_string}, 3130 #ifndef DISABLE_SIGN 3131 /* syslog-sign setting */ 3132 {"sign_sg", &sign_sg_str}, 3133 /* also special case in parsing */ 3134 {"sign_delim_sg2", &tmp_buf}, 3135 #endif /* !DISABLE_SIGN */ 3136 }; 3137 3138 DPRINTF(D_CALL, "read_config_file()\n"); 3139 3140 /* free all previous config options */ 3141 for (i = 0; i < A_CNT(TypeInfo); i++) { 3142 if (TypeInfo[i].queue_length_string 3143 && TypeInfo[i].queue_length_string 3144 != TypeInfo[i].default_length_string) { 3145 FREEPTR(TypeInfo[i].queue_length_string); 3146 TypeInfo[i].queue_length_string = 3147 strdup(TypeInfo[i].default_length_string); 3148 } 3149 if (TypeInfo[i].queue_size_string 3150 && TypeInfo[i].queue_size_string 3151 != TypeInfo[i].default_size_string) { 3152 FREEPTR(TypeInfo[i].queue_size_string); 3153 TypeInfo[i].queue_size_string = 3154 strdup(TypeInfo[i].default_size_string); 3155 } 3156 } 3157 for (i = 0; i < A_CNT(config_keywords); i++) 3158 FREEPTR(*config_keywords[i].variable); 3159 /* 3160 * global settings 3161 */ 3162 while (fgets(cline, sizeof(cline), cf) != NULL) { 3163 linenum++; 3164 for (p = cline; isspace((unsigned char)*p); ++p) 3165 continue; 3166 if ((*p == '\0') || (*p == '#')) 3167 continue; 3168 3169 for (i = 0; i < A_CNT(config_keywords); i++) { 3170 if (copy_config_value(config_keywords[i].keyword, 3171 config_keywords[i].variable, &p, ConfFile, 3172 linenum)) { 3173 DPRINTF((D_PARSE|D_MEM), 3174 "found option %s, saved @%p\n", 3175 config_keywords[i].keyword, 3176 *config_keywords[i].variable); 3177 #ifndef DISABLE_SIGN 3178 if (!strcmp("sign_delim_sg2", 3179 config_keywords[i].keyword)) 3180 do { 3181 store_sign_delim_sg2(tmp_buf); 3182 } while (copy_config_value_word( 3183 &tmp_buf, &p)); 3184 3185 #endif /* !DISABLE_SIGN */ 3186 3187 #ifndef DISABLE_TLS 3188 /* special cases with multiple parameters */ 3189 if (!strcmp("tls_allow_fingerprints", 3190 config_keywords[i].keyword)) 3191 credhead = &tls_opt.fprint_head; 3192 else if (!strcmp("tls_allow_clientcerts", 3193 config_keywords[i].keyword)) 3194 credhead = &tls_opt.cert_head; 3195 3196 if (credhead) do { 3197 if(!(cred = malloc(sizeof(*cred)))) { 3198 logerror("Unable to " 3199 "allocate memory"); 3200 break; 3201 } 3202 cred->data = tmp_buf; 3203 tmp_buf = NULL; 3204 SLIST_INSERT_HEAD(credhead, 3205 cred, entries); 3206 } while /* additional values? */ 3207 (copy_config_value_word(&tmp_buf, &p)); 3208 credhead = NULL; 3209 break; 3210 #endif /* !DISABLE_TLS */ 3211 } 3212 } 3213 } 3214 /* convert strings to integer values */ 3215 for (i = 0; i < A_CNT(TypeInfo); i++) { 3216 if (!TypeInfo[i].queue_length_string 3217 || dehumanize_number(TypeInfo[i].queue_length_string, 3218 &TypeInfo[i].queue_length) == -1) 3219 if (dehumanize_number(TypeInfo[i].default_length_string, 3220 &TypeInfo[i].queue_length) == -1) 3221 abort(); 3222 if (!TypeInfo[i].queue_size_string 3223 || dehumanize_number(TypeInfo[i].queue_size_string, 3224 &TypeInfo[i].queue_size) == -1) 3225 if (dehumanize_number(TypeInfo[i].default_size_string, 3226 &TypeInfo[i].queue_size) == -1) 3227 abort(); 3228 } 3229 3230 #ifndef DISABLE_SIGN 3231 if (sign_sg_str) { 3232 if (sign_sg_str[1] == '\0' 3233 && (sign_sg_str[0] == '0' || sign_sg_str[0] == '1' 3234 || sign_sg_str[0] == '2' || sign_sg_str[0] == '3')) 3235 GlobalSign.sg = sign_sg_str[0] - '0'; 3236 else { 3237 GlobalSign.sg = SIGN_SG; 3238 DPRINTF(D_MISC, "Invalid sign_sg value `%s', " 3239 "use default value `%d'\n", 3240 sign_sg_str, GlobalSign.sg); 3241 } 3242 } else /* disable syslog-sign */ 3243 GlobalSign.sg = -1; 3244 #endif /* !DISABLE_SIGN */ 3245 3246 rewind(cf); 3247 linenum = 0; 3248 /* 3249 * Foreach line in the conf table, open that file. 3250 */ 3251 f = NULL; 3252 nextp = &f; 3253 3254 strcpy(prog, "*"); 3255 strcpy(host, "*"); 3256 while (fgets(cline, sizeof(cline), cf) != NULL) { 3257 linenum++; 3258 found_keyword = false; 3259 /* 3260 * check for end-of-section, comments, strip off trailing 3261 * spaces and newline character. #!prog is treated specially: 3262 * following lines apply only to that program. 3263 */ 3264 for (p = cline; isspace((unsigned char)*p); ++p) 3265 continue; 3266 if (*p == '\0') 3267 continue; 3268 if (*p == '#') { 3269 p++; 3270 if (*p != '!' && *p != '+' && *p != '-') 3271 continue; 3272 } 3273 3274 for (i = 0; i < A_CNT(config_keywords); i++) { 3275 if (!strncasecmp(p, config_keywords[i].keyword, 3276 strlen(config_keywords[i].keyword))) { 3277 DPRINTF(D_PARSE, 3278 "skip cline %zu with keyword %s\n", 3279 linenum, config_keywords[i].keyword); 3280 found_keyword = true; 3281 } 3282 } 3283 if (found_keyword) 3284 continue; 3285 3286 if (*p == '+' || *p == '-') { 3287 host[0] = *p++; 3288 while (isspace((unsigned char)*p)) 3289 p++; 3290 if (*p == '\0' || *p == '*') { 3291 strcpy(host, "*"); 3292 continue; 3293 } 3294 /* the +hostname expression will continue 3295 * to use the LocalHostName, not the FQDN */ 3296 for (i = 1; i < MAXHOSTNAMELEN - 1; i++) { 3297 if (*p == '@') { 3298 (void)strncpy(&host[i], LocalHostName, 3299 sizeof(host) - 1 - i); 3300 host[sizeof(host) - 1] = '\0'; 3301 i = strlen(host) - 1; 3302 p++; 3303 continue; 3304 } 3305 if (!isalnum((unsigned char)*p) && 3306 *p != '.' && *p != '-' && *p != ',') 3307 break; 3308 host[i] = *p++; 3309 } 3310 host[i] = '\0'; 3311 continue; 3312 } 3313 if (*p == '!') { 3314 p++; 3315 while (isspace((unsigned char)*p)) 3316 p++; 3317 if (*p == '\0' || *p == '*') { 3318 strcpy(prog, "*"); 3319 continue; 3320 } 3321 for (i = 0; i < NAME_MAX; i++) { 3322 if (!isprint((unsigned char)p[i])) 3323 break; 3324 prog[i] = p[i]; 3325 } 3326 prog[i] = '\0'; 3327 continue; 3328 } 3329 for (q = strchr(cline, '\0'); isspace((unsigned char)*--q);) 3330 continue; 3331 *++q = '\0'; 3332 if ((f = calloc(1, sizeof(*f))) == NULL) { 3333 logerror("alloc failed"); 3334 die(0, 0, NULL); 3335 } 3336 if (!*f_ptr) *f_ptr = f; /* return first node */ 3337 *nextp = f; 3338 nextp = &f->f_next; 3339 cfline(linenum, cline, f, prog, host); 3340 } 3341 } 3342 3343 /* 3344 * INIT -- Initialize syslogd from configuration table 3345 */ 3346 void 3347 /*ARGSUSED*/ 3348 init(int fd, short event, void *ev) 3349 { 3350 FILE *cf; 3351 int i; 3352 struct filed *f, *newf, **nextp, *f2; 3353 char *p; 3354 sigset_t newmask, omask; 3355 #ifndef DISABLE_TLS 3356 char *tls_status_msg = NULL; 3357 struct peer_cred *cred = NULL; 3358 #endif /* !DISABLE_TLS */ 3359 3360 /* prevent recursive signals */ 3361 BLOCK_SIGNALS(omask, newmask); 3362 3363 DPRINTF((D_EVENT|D_CALL), "init\n"); 3364 3365 /* 3366 * be careful about dependencies and order of actions: 3367 * 1. flush buffer queues 3368 * 2. flush -sign SBs 3369 * 3. flush/delete buffer queue again, in case an SB got there 3370 * 4. close files/connections 3371 */ 3372 3373 /* 3374 * flush any pending output 3375 */ 3376 for (f = Files; f != NULL; f = f->f_next) { 3377 /* flush any pending output */ 3378 if (f->f_prevcount) 3379 fprintlog(f, NULL, NULL); 3380 SEND_QUEUE(f); 3381 } 3382 /* some actions only on SIGHUP and not on first start */ 3383 if (Initialized) { 3384 #ifndef DISABLE_SIGN 3385 sign_global_free(); 3386 #endif /* !DISABLE_SIGN */ 3387 #ifndef DISABLE_TLS 3388 free_incoming_tls_sockets(); 3389 #endif /* !DISABLE_TLS */ 3390 Initialized = 0; 3391 } 3392 /* 3393 * Close all open log files. 3394 */ 3395 for (f = Files; f != NULL; f = f->f_next) { 3396 switch (f->f_type) { 3397 case F_FILE: 3398 case F_TTY: 3399 case F_CONSOLE: 3400 (void)close(f->f_file); 3401 break; 3402 case F_PIPE: 3403 if (f->f_un.f_pipe.f_pid > 0) { 3404 (void)close(f->f_file); 3405 deadq_enter(f->f_un.f_pipe.f_pid, 3406 f->f_un.f_pipe.f_pname); 3407 } 3408 f->f_un.f_pipe.f_pid = 0; 3409 break; 3410 case F_FORW: 3411 if (f->f_un.f_forw.f_addr) 3412 freeaddrinfo(f->f_un.f_forw.f_addr); 3413 break; 3414 #ifndef DISABLE_TLS 3415 case F_TLS: 3416 free_tls_sslptr(f->f_un.f_tls.tls_conn); 3417 break; 3418 #endif /* !DISABLE_TLS */ 3419 } 3420 } 3421 3422 /* 3423 * Close all open UDP sockets 3424 */ 3425 if (finet) { 3426 for (i = 0; i < finet->fd; i++) { 3427 if (close(finet[i+1].fd) < 0) { 3428 logerror("close() failed"); 3429 die(0, 0, NULL); 3430 } 3431 DEL_EVENT(finet[i+1].ev); 3432 FREEPTR(finet[i+1].ev); 3433 } 3434 FREEPTR(finet); 3435 } 3436 3437 /* get FQDN and hostname/domain */ 3438 FREEPTR(oldLocalFQDN); 3439 oldLocalFQDN = LocalFQDN; 3440 LocalFQDN = getLocalFQDN(); 3441 if ((p = strchr(LocalFQDN, '.')) != NULL) 3442 (void)strlcpy(LocalHostName, LocalFQDN, 1+p-LocalFQDN); 3443 else 3444 (void)strlcpy(LocalHostName, LocalFQDN, sizeof(LocalHostName)); 3445 3446 /* 3447 * Reset counter of forwarding actions 3448 */ 3449 3450 NumForwards=0; 3451 3452 /* new destination list to replace Files */ 3453 newf = NULL; 3454 nextp = &newf; 3455 3456 /* open the configuration file */ 3457 if ((cf = fopen(ConfFile, "r")) == NULL) { 3458 DPRINTF(D_FILE, "Cannot open `%s'\n", ConfFile); 3459 *nextp = (struct filed *)calloc(1, sizeof(*f)); 3460 cfline(0, "*.ERR\t/dev/console", *nextp, "*", "*"); 3461 (*nextp)->f_next = (struct filed *)calloc(1, sizeof(*f)); 3462 cfline(0, "*.PANIC\t*", (*nextp)->f_next, "*", "*"); 3463 Initialized = 1; 3464 RESTORE_SIGNALS(omask); 3465 return; 3466 } 3467 3468 #ifndef DISABLE_TLS 3469 /* init with new TLS_CTX 3470 * as far as I see one cannot change the cert/key of an existing CTX 3471 */ 3472 FREE_SSL_CTX(tls_opt.global_TLS_CTX); 3473 3474 free_cred_SLIST(&tls_opt.cert_head); 3475 free_cred_SLIST(&tls_opt.fprint_head); 3476 #endif /* !DISABLE_TLS */ 3477 3478 /* read and close configuration file */ 3479 read_config_file(cf, &newf); 3480 newf = *nextp; 3481 (void)fclose(cf); 3482 DPRINTF(D_MISC, "read_config_file() returned newf=%p\n", newf); 3483 3484 #define MOVE_QUEUE(dst, src) do { \ 3485 struct buf_queue *buf; \ 3486 STAILQ_CONCAT(&dst->f_qhead, &src->f_qhead); \ 3487 STAILQ_FOREACH(buf, &dst->f_qhead, entries) { \ 3488 dst->f_qelements++; \ 3489 dst->f_qsize += buf_queue_obj_size(buf); \ 3490 } \ 3491 src->f_qsize = 0; \ 3492 src->f_qelements = 0; \ 3493 } while (/*CONSTCOND*/0) 3494 3495 /* 3496 * Free old log files. 3497 */ 3498 for (f = Files; f != NULL;) { 3499 struct filed *ftmp; 3500 3501 /* check if a new logfile is equal, if so pass the queue */ 3502 for (f2 = newf; f2 != NULL; f2 = f2->f_next) { 3503 if (f->f_type == f2->f_type 3504 && ((f->f_type == F_PIPE 3505 && !strcmp(f->f_un.f_pipe.f_pname, 3506 f2->f_un.f_pipe.f_pname)) 3507 #ifndef DISABLE_TLS 3508 || (f->f_type == F_TLS 3509 && !strcmp(f->f_un.f_tls.tls_conn->hostname, 3510 f2->f_un.f_tls.tls_conn->hostname) 3511 && !strcmp(f->f_un.f_tls.tls_conn->port, 3512 f2->f_un.f_tls.tls_conn->port)) 3513 #endif /* !DISABLE_TLS */ 3514 || (f->f_type == F_FORW 3515 && !strcmp(f->f_un.f_forw.f_hname, 3516 f2->f_un.f_forw.f_hname)))) { 3517 DPRINTF(D_BUFFER, "move queue from f@%p " 3518 "to f2@%p\n", f, f2); 3519 MOVE_QUEUE(f2, f); 3520 } 3521 } 3522 message_queue_freeall(f); 3523 DELREF(f->f_prevmsg); 3524 #ifndef DISABLE_TLS 3525 if (f->f_type == F_TLS) 3526 free_tls_conn(f->f_un.f_tls.tls_conn); 3527 #endif /* !DISABLE_TLS */ 3528 FREEPTR(f->f_program); 3529 FREEPTR(f->f_host); 3530 DEL_EVENT(f->f_sq_event); 3531 3532 ftmp = f->f_next; 3533 free((char *)f); 3534 f = ftmp; 3535 } 3536 Files = newf; 3537 Initialized = 1; 3538 3539 if (Debug) { 3540 for (f = Files; f; f = f->f_next) { 3541 for (i = 0; i <= LOG_NFACILITIES; i++) 3542 if (f->f_pmask[i] == INTERNAL_NOPRI) 3543 printf("X "); 3544 else 3545 printf("%d ", f->f_pmask[i]); 3546 printf("%s: ", TypeInfo[f->f_type].name); 3547 switch (f->f_type) { 3548 case F_FILE: 3549 case F_TTY: 3550 case F_CONSOLE: 3551 case F_FIFO: 3552 printf("%s", f->f_un.f_fname); 3553 break; 3554 3555 case F_FORW: 3556 printf("%s", f->f_un.f_forw.f_hname); 3557 break; 3558 #ifndef DISABLE_TLS 3559 case F_TLS: 3560 printf("[%s]", f->f_un.f_tls.tls_conn->hostname); 3561 break; 3562 #endif /* !DISABLE_TLS */ 3563 case F_PIPE: 3564 printf("%s", f->f_un.f_pipe.f_pname); 3565 break; 3566 3567 case F_USERS: 3568 for (i = 0; 3569 i < MAXUNAMES && *f->f_un.f_uname[i]; i++) 3570 printf("%s, ", f->f_un.f_uname[i]); 3571 break; 3572 } 3573 if (f->f_program != NULL) 3574 printf(" (%s)", f->f_program); 3575 printf("\n"); 3576 } 3577 } 3578 3579 finet = socksetup(PF_UNSPEC, bindhostname); 3580 if (finet) { 3581 if (SecureMode) { 3582 for (i = 0; i < finet->fd; i++) { 3583 if (shutdown(finet[i+1].fd, SHUT_RD) < 0) { 3584 logerror("shutdown() failed"); 3585 die(0, 0, NULL); 3586 } 3587 } 3588 } else 3589 DPRINTF(D_NET, "Listening on inet and/or inet6 socket\n"); 3590 DPRINTF(D_NET, "Sending on inet and/or inet6 socket\n"); 3591 } 3592 3593 #ifndef DISABLE_TLS 3594 /* TLS setup -- after all local destinations opened */ 3595 DPRINTF(D_PARSE, "Parsed options: tls_ca: %s, tls_cadir: %s, " 3596 "tls_cert: %s, tls_key: %s, tls_verify: %s, " 3597 "bind: %s:%s, max. queue_lengths: %" 3598 PRId64 ", %" PRId64 ", %" PRId64 ", " 3599 "max. queue_sizes: %" 3600 PRId64 ", %" PRId64 ", %" PRId64 "\n", 3601 tls_opt.CAfile, tls_opt.CAdir, 3602 tls_opt.certfile, tls_opt.keyfile, tls_opt.x509verify, 3603 tls_opt.bindhost, tls_opt.bindport, 3604 TypeInfo[F_TLS].queue_length, TypeInfo[F_FILE].queue_length, 3605 TypeInfo[F_PIPE].queue_length, 3606 TypeInfo[F_TLS].queue_size, TypeInfo[F_FILE].queue_size, 3607 TypeInfo[F_PIPE].queue_size); 3608 SLIST_FOREACH(cred, &tls_opt.cert_head, entries) { 3609 DPRINTF(D_PARSE, "Accepting peer certificate " 3610 "from file: \"%s\"\n", cred->data); 3611 } 3612 SLIST_FOREACH(cred, &tls_opt.fprint_head, entries) { 3613 DPRINTF(D_PARSE, "Accepting peer certificate with " 3614 "fingerprint: \"%s\"\n", cred->data); 3615 } 3616 3617 /* Note: The order of initialization is important because syslog-sign 3618 * should use the TLS cert for signing. -- So we check first if TLS 3619 * will be used and initialize it before starting -sign. 3620 * 3621 * This means that if we are a client without TLS destinations TLS 3622 * will not be initialized and syslog-sign will generate a new key. 3623 * -- Even if the user has set a usable tls_cert. 3624 * Is this the expected behaviour? The alternative would be to always 3625 * initialize the TLS structures, even if they will not be needed 3626 * (or only needed to read the DSA key for -sign). 3627 */ 3628 3629 /* Initialize TLS only if used */ 3630 if (tls_opt.server) 3631 tls_status_msg = init_global_TLS_CTX(); 3632 else 3633 for (f = Files; f; f = f->f_next) { 3634 if (f->f_type != F_TLS) 3635 continue; 3636 tls_status_msg = init_global_TLS_CTX(); 3637 break; 3638 } 3639 3640 #endif /* !DISABLE_TLS */ 3641 3642 #ifndef DISABLE_SIGN 3643 /* only initialize -sign if actually used */ 3644 if (GlobalSign.sg == 0 || GlobalSign.sg == 1 || GlobalSign.sg == 2) 3645 (void)sign_global_init(Files); 3646 else if (GlobalSign.sg == 3) 3647 for (f = Files; f; f = f->f_next) 3648 if (f->f_flags & FFLAG_SIGN) { 3649 (void)sign_global_init(Files); 3650 break; 3651 } 3652 #endif /* !DISABLE_SIGN */ 3653 3654 #ifndef DISABLE_TLS 3655 if (tls_status_msg) { 3656 loginfo("%s", tls_status_msg); 3657 free(tls_status_msg); 3658 } 3659 DPRINTF((D_NET|D_TLS), "Preparing sockets for TLS\n"); 3660 TLS_Listen_Set = 3661 socksetup_tls(PF_UNSPEC, tls_opt.bindhost, tls_opt.bindport); 3662 3663 for (f = Files; f; f = f->f_next) { 3664 if (f->f_type != F_TLS) 3665 continue; 3666 if (!tls_connect(f->f_un.f_tls.tls_conn)) { 3667 logerror("Unable to connect to TLS server %s", 3668 f->f_un.f_tls.tls_conn->hostname); 3669 /* Reconnect after x seconds */ 3670 schedule_event(&f->f_un.f_tls.tls_conn->event, 3671 &((struct timeval){TLS_RECONNECT_SEC, 0}), 3672 tls_reconnect, f->f_un.f_tls.tls_conn); 3673 } 3674 } 3675 #endif /* !DISABLE_TLS */ 3676 3677 loginfo("restart"); 3678 /* 3679 * Log a change in hostname, but only on a restart (we detect this 3680 * by checking to see if we're passed a kevent). 3681 */ 3682 if (oldLocalFQDN && strcmp(oldLocalFQDN, LocalFQDN) != 0) 3683 loginfo("host name changed, \"%s\" to \"%s\"", 3684 oldLocalFQDN, LocalFQDN); 3685 3686 RESTORE_SIGNALS(omask); 3687 } 3688 3689 /* 3690 * Crack a configuration file line 3691 */ 3692 void 3693 cfline(size_t linenum, const char *line, struct filed *f, const char *prog, 3694 const char *host) 3695 { 3696 struct addrinfo hints, *res; 3697 int error, i, pri, syncfile; 3698 const char *p, *q; 3699 char *bp; 3700 char buf[MAXLINE]; 3701 struct stat sb; 3702 3703 DPRINTF((D_CALL|D_PARSE), 3704 "cfline(%zu, \"%s\", f, \"%s\", \"%s\")\n", 3705 linenum, line, prog, host); 3706 3707 errno = 0; /* keep strerror() stuff out of logerror messages */ 3708 3709 /* clear out file entry */ 3710 memset(f, 0, sizeof(*f)); 3711 for (i = 0; i <= LOG_NFACILITIES; i++) 3712 f->f_pmask[i] = INTERNAL_NOPRI; 3713 STAILQ_INIT(&f->f_qhead); 3714 3715 /* 3716 * There should not be any space before the log facility. 3717 * Check this is okay, complain and fix if it is not. 3718 */ 3719 q = line; 3720 if (isblank((unsigned char)*line)) { 3721 errno = 0; 3722 logerror("Warning: `%s' space or tab before the log facility", 3723 line); 3724 /* Fix: strip all spaces/tabs before the log facility */ 3725 while (*q++ && isblank((unsigned char)*q)) 3726 /* skip blanks */; 3727 line = q; 3728 } 3729 3730 /* 3731 * q is now at the first char of the log facility 3732 * There should be at least one tab after the log facility 3733 * Check this is okay, and complain and fix if it is not. 3734 */ 3735 q = line + strlen(line); 3736 while (!isblank((unsigned char)*q) && (q != line)) 3737 q--; 3738 if ((q == line) && strlen(line)) { 3739 /* No tabs or space in a non empty line: complain */ 3740 errno = 0; 3741 logerror( 3742 "Error: `%s' log facility or log target missing", 3743 line); 3744 return; 3745 } 3746 3747 /* save host name, if any */ 3748 if (*host == '*') 3749 f->f_host = NULL; 3750 else { 3751 f->f_host = strdup(host); 3752 trim_anydomain(&f->f_host[1]); /* skip +/- at beginning */ 3753 } 3754 3755 /* save program name, if any */ 3756 if (*prog == '*') 3757 f->f_program = NULL; 3758 else 3759 f->f_program = strdup(prog); 3760 3761 /* scan through the list of selectors */ 3762 for (p = line; *p && !isblank((unsigned char)*p);) { 3763 int pri_done, pri_cmp, pri_invert; 3764 3765 /* find the end of this facility name list */ 3766 for (q = p; *q && !isblank((unsigned char)*q) && *q++ != '.'; ) 3767 continue; 3768 3769 /* get the priority comparison */ 3770 pri_cmp = 0; 3771 pri_done = 0; 3772 pri_invert = 0; 3773 if (*q == '!') { 3774 pri_invert = 1; 3775 q++; 3776 } 3777 while (! pri_done) { 3778 switch (*q) { 3779 case '<': 3780 pri_cmp = PRI_LT; 3781 q++; 3782 break; 3783 case '=': 3784 pri_cmp = PRI_EQ; 3785 q++; 3786 break; 3787 case '>': 3788 pri_cmp = PRI_GT; 3789 q++; 3790 break; 3791 default: 3792 pri_done = 1; 3793 break; 3794 } 3795 } 3796 3797 /* collect priority name */ 3798 for (bp = buf; *q && !strchr("\t ,;", *q); ) 3799 *bp++ = *q++; 3800 *bp = '\0'; 3801 3802 /* skip cruft */ 3803 while (strchr(",;", *q)) 3804 q++; 3805 3806 /* decode priority name */ 3807 if (*buf == '*') { 3808 pri = LOG_PRIMASK + 1; 3809 pri_cmp = PRI_LT | PRI_EQ | PRI_GT; 3810 } else { 3811 pri = decode(buf, prioritynames); 3812 if (pri < 0) { 3813 errno = 0; 3814 logerror("Unknown priority name `%s'", buf); 3815 return; 3816 } 3817 } 3818 if (pri_cmp == 0) 3819 pri_cmp = UniquePriority ? PRI_EQ 3820 : PRI_EQ | PRI_GT; 3821 if (pri_invert) 3822 pri_cmp ^= PRI_LT | PRI_EQ | PRI_GT; 3823 3824 /* scan facilities */ 3825 while (*p && !strchr("\t .;", *p)) { 3826 for (bp = buf; *p && !strchr("\t ,;.", *p); ) 3827 *bp++ = *p++; 3828 *bp = '\0'; 3829 if (*buf == '*') 3830 for (i = 0; i < LOG_NFACILITIES; i++) { 3831 f->f_pmask[i] = pri; 3832 f->f_pcmp[i] = pri_cmp; 3833 } 3834 else { 3835 i = decode(buf, facilitynames); 3836 if (i < 0) { 3837 errno = 0; 3838 logerror("Unknown facility name `%s'", 3839 buf); 3840 return; 3841 } 3842 f->f_pmask[i >> 3] = pri; 3843 f->f_pcmp[i >> 3] = pri_cmp; 3844 } 3845 while (*p == ',' || *p == ' ') 3846 p++; 3847 } 3848 3849 p = q; 3850 } 3851 3852 /* skip to action part */ 3853 while (isblank((unsigned char)*p)) 3854 p++; 3855 3856 /* 3857 * should this be "#ifndef DISABLE_SIGN" or is it a general option? 3858 * '+' before file destination: write with PRI field for later 3859 * verification 3860 */ 3861 if (*p == '+') { 3862 f->f_flags |= FFLAG_FULL; 3863 p++; 3864 } 3865 if (*p == '-') { 3866 syncfile = 0; 3867 p++; 3868 } else 3869 syncfile = 1; 3870 3871 switch (*p) { 3872 case '@': 3873 #ifndef DISABLE_SIGN 3874 if (GlobalSign.sg == 3) 3875 f->f_flags |= FFLAG_SIGN; 3876 #endif /* !DISABLE_SIGN */ 3877 #ifndef DISABLE_TLS 3878 if (*(p+1) == '[') { 3879 /* TLS destination */ 3880 if (!parse_tls_destination(p, f, linenum)) { 3881 logerror("Unable to parse action %s", p); 3882 break; 3883 } 3884 f->f_type = F_TLS; 3885 break; 3886 } 3887 #endif /* !DISABLE_TLS */ 3888 (void)strlcpy(f->f_un.f_forw.f_hname, ++p, 3889 sizeof(f->f_un.f_forw.f_hname)); 3890 memset(&hints, 0, sizeof(hints)); 3891 hints.ai_family = AF_UNSPEC; 3892 hints.ai_socktype = SOCK_DGRAM; 3893 hints.ai_protocol = 0; 3894 error = getaddrinfo(f->f_un.f_forw.f_hname, "syslog", &hints, 3895 &res); 3896 if (error) { 3897 errno = 0; 3898 logerror("%s", gai_strerror(error)); 3899 break; 3900 } 3901 f->f_un.f_forw.f_addr = res; 3902 f->f_type = F_FORW; 3903 NumForwards++; 3904 break; 3905 3906 case '/': 3907 #ifndef DISABLE_SIGN 3908 if (GlobalSign.sg == 3) 3909 f->f_flags |= FFLAG_SIGN; 3910 #endif /* !DISABLE_SIGN */ 3911 (void)strlcpy(f->f_un.f_fname, p, sizeof(f->f_un.f_fname)); 3912 if ((f->f_file = open(p, O_WRONLY|O_APPEND|O_NONBLOCK, 0)) < 0) 3913 { 3914 f->f_type = F_UNUSED; 3915 logerror("%s", p); 3916 break; 3917 } 3918 if (!fstat(f->f_file, &sb) && S_ISFIFO(sb.st_mode)) { 3919 f->f_file = -1; 3920 f->f_type = F_FIFO; 3921 break; 3922 } 3923 3924 if (isatty(f->f_file)) { 3925 f->f_type = F_TTY; 3926 if (strcmp(p, ctty) == 0) 3927 f->f_type = F_CONSOLE; 3928 } else 3929 f->f_type = F_FILE; 3930 3931 if (syncfile) 3932 f->f_flags |= FFLAG_SYNC; 3933 break; 3934 3935 case '|': 3936 #ifndef DISABLE_SIGN 3937 if (GlobalSign.sg == 3) 3938 f->f_flags |= FFLAG_SIGN; 3939 #endif 3940 f->f_un.f_pipe.f_pid = 0; 3941 (void) strlcpy(f->f_un.f_pipe.f_pname, p + 1, 3942 sizeof(f->f_un.f_pipe.f_pname)); 3943 f->f_type = F_PIPE; 3944 break; 3945 3946 case '*': 3947 f->f_type = F_WALL; 3948 break; 3949 3950 default: 3951 for (i = 0; i < MAXUNAMES && *p; i++) { 3952 for (q = p; *q && *q != ','; ) 3953 q++; 3954 (void)strncpy(f->f_un.f_uname[i], p, UT_NAMESIZE); 3955 if ((q - p) > UT_NAMESIZE) 3956 f->f_un.f_uname[i][UT_NAMESIZE] = '\0'; 3957 else 3958 f->f_un.f_uname[i][q - p] = '\0'; 3959 while (*q == ',' || *q == ' ') 3960 q++; 3961 p = q; 3962 } 3963 f->f_type = F_USERS; 3964 break; 3965 } 3966 } 3967 3968 3969 /* 3970 * Decode a symbolic name to a numeric value 3971 */ 3972 int 3973 decode(const char *name, CODE *codetab) 3974 { 3975 CODE *c; 3976 char *p, buf[40]; 3977 3978 if (isdigit((unsigned char)*name)) 3979 return atoi(name); 3980 3981 for (p = buf; *name && p < &buf[sizeof(buf) - 1]; p++, name++) { 3982 if (isupper((unsigned char)*name)) 3983 *p = tolower((unsigned char)*name); 3984 else 3985 *p = *name; 3986 } 3987 *p = '\0'; 3988 for (c = codetab; c->c_name; c++) 3989 if (!strcmp(buf, c->c_name)) 3990 return c->c_val; 3991 3992 return -1; 3993 } 3994 3995 /* 3996 * Retrieve the size of the kernel message buffer, via sysctl. 3997 */ 3998 int 3999 getmsgbufsize(void) 4000 { 4001 #ifdef __NetBSD_Version__ 4002 int msgbufsize, mib[2]; 4003 size_t size; 4004 4005 mib[0] = CTL_KERN; 4006 mib[1] = KERN_MSGBUFSIZE; 4007 size = sizeof msgbufsize; 4008 if (sysctl(mib, 2, &msgbufsize, &size, NULL, 0) == -1) { 4009 DPRINTF(D_MISC, "Couldn't get kern.msgbufsize\n"); 4010 return 0; 4011 } 4012 return msgbufsize; 4013 #else 4014 return MAXLINE; 4015 #endif /* __NetBSD_Version__ */ 4016 } 4017 4018 /* 4019 * Retrieve the hostname, via sysctl. 4020 */ 4021 char * 4022 getLocalFQDN(void) 4023 { 4024 int mib[2]; 4025 char *hostname; 4026 size_t len; 4027 4028 #ifdef __minix 4029 len = MAXHOSTNAMELEN + 1; 4030 #endif /* __minix */ 4031 4032 mib[0] = CTL_KERN; 4033 mib[1] = KERN_HOSTNAME; 4034 sysctl(mib, 2, NULL, &len, NULL, 0); 4035 4036 if (!(hostname = malloc(len))) { 4037 logerror("Unable to allocate memory"); 4038 die(0,0,NULL); 4039 } else if (sysctl(mib, 2, hostname, &len, NULL, 0) == -1) { 4040 DPRINTF(D_MISC, "Couldn't get kern.hostname\n"); 4041 (void)gethostname(hostname, sizeof(len)); 4042 } 4043 return hostname; 4044 } 4045 4046 struct socketEvent * 4047 socksetup(int af, const char *hostname) 4048 { 4049 struct addrinfo hints, *res, *r; 4050 int error, maxs; 4051 #ifdef IPV6_V6ONLY 4052 int on = 1; 4053 #endif /* IPV6_V6ONLY */ 4054 struct socketEvent *s, *socks; 4055 4056 if(SecureMode && !NumForwards) 4057 return NULL; 4058 4059 memset(&hints, 0, sizeof(hints)); 4060 hints.ai_flags = AI_PASSIVE; 4061 hints.ai_family = af; 4062 hints.ai_socktype = SOCK_DGRAM; 4063 error = getaddrinfo(hostname, "syslog", &hints, &res); 4064 if (error) { 4065 errno = 0; 4066 logerror("%s", gai_strerror(error)); 4067 die(0, 0, NULL); 4068 } 4069 4070 /* Count max number of sockets we may open */ 4071 for (maxs = 0, r = res; r; r = r->ai_next, maxs++) 4072 continue; 4073 socks = calloc(maxs+1, sizeof(*socks)); 4074 if (!socks) { 4075 logerror("Couldn't allocate memory for sockets"); 4076 die(0, 0, NULL); 4077 } 4078 4079 socks->fd = 0; /* num of sockets counter at start of array */ 4080 s = socks + 1; 4081 for (r = res; r; r = r->ai_next) { 4082 s->fd = socket(r->ai_family, r->ai_socktype, r->ai_protocol); 4083 if (s->fd < 0) { 4084 logerror("socket() failed"); 4085 continue; 4086 } 4087 s->af = r->ai_family; 4088 #ifdef IPV6_V6ONLY 4089 if (r->ai_family == AF_INET6 && setsockopt(s->fd, IPPROTO_IPV6, 4090 IPV6_V6ONLY, &on, sizeof(on)) < 0) { 4091 logerror("setsockopt(IPV6_V6ONLY) failed"); 4092 close(s->fd); 4093 continue; 4094 } 4095 #endif /* IPV6_V6ONLY */ 4096 4097 if (!SecureMode) { 4098 if (bind(s->fd, r->ai_addr, r->ai_addrlen) < 0) { 4099 logerror("bind() failed"); 4100 close(s->fd); 4101 continue; 4102 } 4103 s->ev = allocev(); 4104 event_set(s->ev, s->fd, EV_READ | EV_PERSIST, 4105 dispatch_read_finet, s->ev); 4106 if (event_add(s->ev, NULL) == -1) { 4107 DPRINTF((D_EVENT|D_NET), 4108 "Failure in event_add()\n"); 4109 } else { 4110 DPRINTF((D_EVENT|D_NET), 4111 "Listen on UDP port " 4112 "(event@%p)\n", s->ev); 4113 } 4114 } 4115 4116 socks->fd++; /* num counter */ 4117 s++; 4118 } 4119 4120 if (res) 4121 freeaddrinfo(res); 4122 if (socks->fd == 0) { 4123 free (socks); 4124 if(Debug) 4125 return NULL; 4126 else 4127 die(0, 0, NULL); 4128 } 4129 return socks; 4130 } 4131 4132 /* 4133 * Fairly similar to popen(3), but returns an open descriptor, as opposed 4134 * to a FILE *. 4135 */ 4136 int 4137 p_open(char *prog, pid_t *rpid) 4138 { 4139 static char sh[] = "sh", mc[] = "-c"; 4140 int pfd[2], nulldesc, i; 4141 pid_t pid; 4142 char *argv[4]; /* sh -c cmd NULL */ 4143 4144 if (pipe(pfd) == -1) 4145 return -1; 4146 if ((nulldesc = open(_PATH_DEVNULL, O_RDWR)) == -1) { 4147 /* We are royally screwed anyway. */ 4148 return -1; 4149 } 4150 4151 switch ((pid = fork())) { 4152 case -1: 4153 (void) close(nulldesc); 4154 return -1; 4155 4156 case 0: 4157 argv[0] = sh; 4158 argv[1] = mc; 4159 argv[2] = prog; 4160 argv[3] = NULL; 4161 4162 (void) setsid(); /* avoid catching SIGHUPs. */ 4163 4164 /* 4165 * Reset ignored signals to their default behavior. 4166 */ 4167 (void)signal(SIGTERM, SIG_DFL); 4168 (void)signal(SIGINT, SIG_DFL); 4169 (void)signal(SIGQUIT, SIG_DFL); 4170 (void)signal(SIGPIPE, SIG_DFL); 4171 (void)signal(SIGHUP, SIG_DFL); 4172 4173 dup2(pfd[0], STDIN_FILENO); 4174 dup2(nulldesc, STDOUT_FILENO); 4175 dup2(nulldesc, STDERR_FILENO); 4176 for (i = getdtablesize(); i > 2; i--) 4177 (void) close(i); 4178 4179 (void) execvp(_PATH_BSHELL, argv); 4180 _exit(255); 4181 } 4182 4183 (void) close(nulldesc); 4184 (void) close(pfd[0]); 4185 4186 /* 4187 * Avoid blocking on a hung pipe. With O_NONBLOCK, we are 4188 * supposed to get an EWOULDBLOCK on writev(2), which is 4189 * caught by the logic above anyway, which will in turn 4190 * close the pipe, and fork a new logging subprocess if 4191 * necessary. The stale subprocess will be killed some 4192 * time later unless it terminated itself due to closing 4193 * its input pipe. 4194 */ 4195 if (fcntl(pfd[1], F_SETFL, O_NONBLOCK) == -1) { 4196 /* This is bad. */ 4197 logerror("Warning: cannot change pipe to pid %d to " 4198 "non-blocking.", (int) pid); 4199 } 4200 *rpid = pid; 4201 return pfd[1]; 4202 } 4203 4204 void 4205 deadq_enter(pid_t pid, const char *name) 4206 { 4207 dq_t p; 4208 int status; 4209 4210 /* 4211 * Be paranoid: if we can't signal the process, don't enter it 4212 * into the dead queue (perhaps it's already dead). If possible, 4213 * we try to fetch and log the child's status. 4214 */ 4215 if (kill(pid, 0) != 0) { 4216 if (waitpid(pid, &status, WNOHANG) > 0) 4217 log_deadchild(pid, status, name); 4218 return; 4219 } 4220 4221 p = malloc(sizeof(*p)); 4222 if (p == NULL) { 4223 logerror("panic: out of memory!"); 4224 exit(1); 4225 } 4226 4227 p->dq_pid = pid; 4228 p->dq_timeout = DQ_TIMO_INIT; 4229 TAILQ_INSERT_TAIL(&deadq_head, p, dq_entries); 4230 } 4231 4232 int 4233 deadq_remove(pid_t pid) 4234 { 4235 dq_t q; 4236 4237 for (q = TAILQ_FIRST(&deadq_head); q != NULL; 4238 q = TAILQ_NEXT(q, dq_entries)) { 4239 if (q->dq_pid == pid) { 4240 TAILQ_REMOVE(&deadq_head, q, dq_entries); 4241 free(q); 4242 return 1; 4243 } 4244 } 4245 return 0; 4246 } 4247 4248 void 4249 log_deadchild(pid_t pid, int status, const char *name) 4250 { 4251 int code; 4252 char buf[256]; 4253 const char *reason; 4254 4255 /* Keep strerror() struff out of logerror messages. */ 4256 errno = 0; 4257 if (WIFSIGNALED(status)) { 4258 reason = "due to signal"; 4259 code = WTERMSIG(status); 4260 } else { 4261 reason = "with status"; 4262 code = WEXITSTATUS(status); 4263 if (code == 0) 4264 return; 4265 } 4266 (void) snprintf(buf, sizeof(buf), 4267 "Logging subprocess %d (%s) exited %s %d.", 4268 pid, name, reason, code); 4269 logerror("%s", buf); 4270 } 4271 4272 struct event * 4273 allocev(void) 4274 { 4275 struct event *ev; 4276 4277 if (!(ev = calloc(1, sizeof(*ev)))) 4278 logerror("Unable to allocate memory"); 4279 return ev; 4280 } 4281 4282 /* *ev is allocated if necessary */ 4283 void 4284 schedule_event(struct event **ev, struct timeval *tv, 4285 void (*cb)(int, short, void *), void *arg) 4286 { 4287 if (!*ev && !(*ev = allocev())) { 4288 return; 4289 } 4290 event_set(*ev, 0, 0, cb, arg); 4291 DPRINTF(D_EVENT, "event_add(%s@%p)\n", "schedule_ev", *ev); \ 4292 if (event_add(*ev, tv) == -1) { 4293 DPRINTF(D_EVENT, "Failure in event_add()\n"); 4294 } 4295 } 4296 4297 #ifndef DISABLE_TLS 4298 /* abbreviation for freeing credential lists */ 4299 void 4300 free_cred_SLIST(struct peer_cred_head *head) 4301 { 4302 struct peer_cred *cred; 4303 4304 while (!SLIST_EMPTY(head)) { 4305 cred = SLIST_FIRST(head); 4306 SLIST_REMOVE_HEAD(head, entries); 4307 FREEPTR(cred->data); 4308 free(cred); 4309 } 4310 } 4311 #endif /* !DISABLE_TLS */ 4312 4313 /* 4314 * send message queue after reconnect 4315 */ 4316 /*ARGSUSED*/ 4317 void 4318 send_queue(int fd, short event, void *arg) 4319 { 4320 struct filed *f = (struct filed *) arg; 4321 struct buf_queue *qentry; 4322 #define SQ_CHUNK_SIZE 250 4323 size_t cnt = 0; 4324 4325 #ifndef DISABLE_TLS 4326 if (f->f_type == F_TLS) { 4327 /* use a flag to prevent recursive calls to send_queue() */ 4328 if (f->f_un.f_tls.tls_conn->send_queue) 4329 return; 4330 else 4331 f->f_un.f_tls.tls_conn->send_queue = true; 4332 } 4333 DPRINTF((D_DATA|D_CALL), "send_queue(f@%p with %zu msgs, " 4334 "cnt@%p = %zu)\n", f, f->f_qelements, &cnt, cnt); 4335 #endif /* !DISABLE_TLS */ 4336 4337 while ((qentry = STAILQ_FIRST(&f->f_qhead))) { 4338 #ifndef DISABLE_TLS 4339 /* send_queue() might be called with an unconnected destination 4340 * from init() or die() or one message might take longer, 4341 * leaving the connection in state ST_WAITING and thus not 4342 * ready for the next message. 4343 * this check is a shortcut to skip these unnecessary calls */ 4344 if (f->f_type == F_TLS 4345 && f->f_un.f_tls.tls_conn->state != ST_TLS_EST) { 4346 DPRINTF(D_TLS, "abort send_queue(cnt@%p = %zu) " 4347 "on TLS connection in state %d\n", 4348 &cnt, cnt, f->f_un.f_tls.tls_conn->state); 4349 return; 4350 } 4351 #endif /* !DISABLE_TLS */ 4352 fprintlog(f, qentry->msg, qentry); 4353 4354 /* Sending a long queue can take some time during which 4355 * SIGHUP and SIGALRM are blocked and no events are handled. 4356 * To avoid that we only send SQ_CHUNK_SIZE messages at once 4357 * and then reschedule ourselves to continue. Thus the control 4358 * will return first from all signal-protected functions so a 4359 * possible SIGHUP/SIGALRM is handled and then back to the 4360 * main loop which can handle possible input. 4361 */ 4362 if (++cnt >= SQ_CHUNK_SIZE) { 4363 if (!f->f_sq_event) { /* alloc on demand */ 4364 f->f_sq_event = allocev(); 4365 event_set(f->f_sq_event, 0, 0, send_queue, f); 4366 } 4367 if (event_add(f->f_sq_event, &((struct timeval){0, 1})) == -1) { 4368 DPRINTF(D_EVENT, "Failure in event_add()\n"); 4369 } 4370 break; 4371 } 4372 } 4373 #ifndef DISABLE_TLS 4374 if (f->f_type == F_TLS) 4375 f->f_un.f_tls.tls_conn->send_queue = false; 4376 #endif 4377 4378 } 4379 4380 /* 4381 * finds the next queue element to delete 4382 * 4383 * has stateful behaviour, before using it call once with reset = true 4384 * after that every call will return one next queue elemen to delete, 4385 * depending on strategy either the oldest or the one with the lowest priority 4386 */ 4387 static struct buf_queue * 4388 find_qentry_to_delete(const struct buf_queue_head *head, int strategy, 4389 bool reset) 4390 { 4391 static int pri; 4392 static struct buf_queue *qentry_static; 4393 4394 struct buf_queue *qentry_tmp; 4395 4396 if (reset || STAILQ_EMPTY(head)) { 4397 pri = LOG_DEBUG; 4398 qentry_static = STAILQ_FIRST(head); 4399 return NULL; 4400 } 4401 4402 /* find elements to delete */ 4403 if (strategy == PURGE_BY_PRIORITY) { 4404 qentry_tmp = qentry_static; 4405 if (!qentry_tmp) return NULL; 4406 while ((qentry_tmp = STAILQ_NEXT(qentry_tmp, entries)) != NULL) 4407 { 4408 if (LOG_PRI(qentry_tmp->msg->pri) == pri) { 4409 /* save the successor, because qentry_tmp 4410 * is probably deleted by the caller */ 4411 qentry_static = STAILQ_NEXT(qentry_tmp, entries); 4412 return qentry_tmp; 4413 } 4414 } 4415 /* nothing found in while loop --> next pri */ 4416 if (--pri) 4417 return find_qentry_to_delete(head, strategy, false); 4418 else 4419 return NULL; 4420 } else /* strategy == PURGE_OLDEST or other value */ { 4421 qentry_tmp = qentry_static; 4422 qentry_static = STAILQ_NEXT(qentry_tmp, entries); 4423 return qentry_tmp; /* is NULL on empty queue */ 4424 } 4425 } 4426 4427 /* note on TAILQ: newest message added at TAIL, 4428 * oldest to be removed is FIRST 4429 */ 4430 /* 4431 * checks length of a destination's message queue 4432 * if del_entries == 0 then assert queue length is 4433 * less or equal to configured number of queue elements 4434 * otherwise del_entries tells how many entries to delete 4435 * 4436 * returns the number of removed queue elements 4437 * (which not necessarily means free'd messages) 4438 * 4439 * strategy PURGE_OLDEST to delete oldest entry, e.g. after it was resent 4440 * strategy PURGE_BY_PRIORITY to delete messages with lowest priority first, 4441 * this is much slower but might be desirable when unsent messages have 4442 * to be deleted, e.g. in call from domark() 4443 */ 4444 size_t 4445 message_queue_purge(struct filed *f, size_t del_entries, int strategy) 4446 { 4447 size_t removed = 0; 4448 struct buf_queue *qentry = NULL; 4449 4450 DPRINTF((D_CALL|D_BUFFER), "purge_message_queue(%p, %zu, %d) with " 4451 "f_qelements=%zu and f_qsize=%zu\n", 4452 f, del_entries, strategy, 4453 f->f_qelements, f->f_qsize); 4454 4455 /* reset state */ 4456 (void)find_qentry_to_delete(&f->f_qhead, strategy, true); 4457 4458 while (removed < del_entries 4459 || (TypeInfo[f->f_type].queue_length != -1 4460 && (size_t)TypeInfo[f->f_type].queue_length <= f->f_qelements) 4461 || (TypeInfo[f->f_type].queue_size != -1 4462 && (size_t)TypeInfo[f->f_type].queue_size <= f->f_qsize)) { 4463 qentry = find_qentry_to_delete(&f->f_qhead, strategy, 0); 4464 if (message_queue_remove(f, qentry)) 4465 removed++; 4466 else 4467 break; 4468 } 4469 return removed; 4470 } 4471 4472 /* run message_queue_purge() for all destinations to free memory */ 4473 size_t 4474 message_allqueues_purge(void) 4475 { 4476 size_t sum = 0; 4477 struct filed *f; 4478 4479 for (f = Files; f; f = f->f_next) 4480 sum += message_queue_purge(f, 4481 f->f_qelements/10, PURGE_BY_PRIORITY); 4482 4483 DPRINTF(D_BUFFER, 4484 "message_allqueues_purge(): removed %zu buffer entries\n", sum); 4485 return sum; 4486 } 4487 4488 /* run message_queue_purge() for all destinations to check limits */ 4489 size_t 4490 message_allqueues_check(void) 4491 { 4492 size_t sum = 0; 4493 struct filed *f; 4494 4495 for (f = Files; f; f = f->f_next) 4496 sum += message_queue_purge(f, 0, PURGE_BY_PRIORITY); 4497 DPRINTF(D_BUFFER, 4498 "message_allqueues_check(): removed %zu buffer entries\n", sum); 4499 return sum; 4500 } 4501 4502 struct buf_msg * 4503 buf_msg_new(const size_t len) 4504 { 4505 struct buf_msg *newbuf; 4506 4507 CALLOC(newbuf, sizeof(*newbuf)); 4508 4509 if (len) { /* len = 0 is valid */ 4510 MALLOC(newbuf->msg, len); 4511 newbuf->msgorig = newbuf->msg; 4512 newbuf->msgsize = len; 4513 } 4514 return NEWREF(newbuf); 4515 } 4516 4517 void 4518 buf_msg_free(struct buf_msg *buf) 4519 { 4520 if (!buf) 4521 return; 4522 4523 buf->refcount--; 4524 if (buf->refcount == 0) { 4525 FREEPTR(buf->timestamp); 4526 /* small optimizations: the host/recvhost may point to the 4527 * global HostName/FQDN. of course this must not be free()d 4528 * same goes for appname and include_pid 4529 */ 4530 if (buf->recvhost != buf->host 4531 && buf->recvhost != LocalHostName 4532 && buf->recvhost != LocalFQDN 4533 && buf->recvhost != oldLocalFQDN) 4534 FREEPTR(buf->recvhost); 4535 if (buf->host != LocalHostName 4536 && buf->host != LocalFQDN 4537 && buf->host != oldLocalFQDN) 4538 FREEPTR(buf->host); 4539 if (buf->prog != appname) 4540 FREEPTR(buf->prog); 4541 if (buf->pid != include_pid) 4542 FREEPTR(buf->pid); 4543 FREEPTR(buf->msgid); 4544 FREEPTR(buf->sd); 4545 FREEPTR(buf->msgorig); /* instead of msg */ 4546 FREEPTR(buf); 4547 } 4548 } 4549 4550 size_t 4551 buf_queue_obj_size(struct buf_queue *qentry) 4552 { 4553 size_t sum = 0; 4554 4555 if (!qentry) 4556 return 0; 4557 sum += sizeof(*qentry) 4558 + sizeof(*qentry->msg) 4559 + qentry->msg->msgsize 4560 + SAFEstrlen(qentry->msg->timestamp)+1 4561 + SAFEstrlen(qentry->msg->msgid)+1; 4562 if (qentry->msg->prog 4563 && qentry->msg->prog != include_pid) 4564 sum += strlen(qentry->msg->prog)+1; 4565 if (qentry->msg->pid 4566 && qentry->msg->pid != appname) 4567 sum += strlen(qentry->msg->pid)+1; 4568 if (qentry->msg->recvhost 4569 && qentry->msg->recvhost != LocalHostName 4570 && qentry->msg->recvhost != LocalFQDN 4571 && qentry->msg->recvhost != oldLocalFQDN) 4572 sum += strlen(qentry->msg->recvhost)+1; 4573 if (qentry->msg->host 4574 && qentry->msg->host != LocalHostName 4575 && qentry->msg->host != LocalFQDN 4576 && qentry->msg->host != oldLocalFQDN) 4577 sum += strlen(qentry->msg->host)+1; 4578 4579 return sum; 4580 } 4581 4582 bool 4583 message_queue_remove(struct filed *f, struct buf_queue *qentry) 4584 { 4585 if (!f || !qentry || !qentry->msg) 4586 return false; 4587 4588 assert(!STAILQ_EMPTY(&f->f_qhead)); 4589 STAILQ_REMOVE(&f->f_qhead, qentry, buf_queue, entries); 4590 f->f_qelements--; 4591 f->f_qsize -= buf_queue_obj_size(qentry); 4592 4593 DPRINTF(D_BUFFER, "msg @%p removed from queue @%p, new qlen = %zu\n", 4594 qentry->msg, f, f->f_qelements); 4595 DELREF(qentry->msg); 4596 FREEPTR(qentry); 4597 return true; 4598 } 4599 4600 /* 4601 * returns *qentry on success and NULL on error 4602 */ 4603 struct buf_queue * 4604 message_queue_add(struct filed *f, struct buf_msg *buffer) 4605 { 4606 struct buf_queue *qentry; 4607 4608 /* check on every call or only every n-th time? */ 4609 message_queue_purge(f, 0, PURGE_BY_PRIORITY); 4610 4611 while (!(qentry = malloc(sizeof(*qentry))) 4612 && message_queue_purge(f, 1, PURGE_OLDEST)) 4613 continue; 4614 if (!qentry) { 4615 logerror("Unable to allocate memory"); 4616 DPRINTF(D_BUFFER, "queue empty, no memory, msg dropped\n"); 4617 return NULL; 4618 } else { 4619 qentry->msg = buffer; 4620 f->f_qelements++; 4621 f->f_qsize += buf_queue_obj_size(qentry); 4622 STAILQ_INSERT_TAIL(&f->f_qhead, qentry, entries); 4623 4624 DPRINTF(D_BUFFER, "msg @%p queued @%p, qlen = %zu\n", 4625 buffer, f, f->f_qelements); 4626 return qentry; 4627 } 4628 } 4629 4630 void 4631 message_queue_freeall(struct filed *f) 4632 { 4633 struct buf_queue *qentry; 4634 4635 if (!f) return; 4636 DPRINTF(D_MEM, "message_queue_freeall(f@%p) with f_qhead@%p\n", f, 4637 &f->f_qhead); 4638 4639 while (!STAILQ_EMPTY(&f->f_qhead)) { 4640 qentry = STAILQ_FIRST(&f->f_qhead); 4641 STAILQ_REMOVE(&f->f_qhead, qentry, buf_queue, entries); 4642 DELREF(qentry->msg); 4643 FREEPTR(qentry); 4644 } 4645 4646 f->f_qelements = 0; 4647 f->f_qsize = 0; 4648 } 4649 4650 #ifndef DISABLE_TLS 4651 /* utility function for tls_reconnect() */ 4652 struct filed * 4653 get_f_by_conninfo(struct tls_conn_settings *conn_info) 4654 { 4655 struct filed *f; 4656 4657 for (f = Files; f; f = f->f_next) { 4658 if ((f->f_type == F_TLS) && f->f_un.f_tls.tls_conn == conn_info) 4659 return f; 4660 } 4661 DPRINTF(D_TLS, "get_f_by_conninfo() called on invalid conn_info\n"); 4662 return NULL; 4663 } 4664 4665 /* 4666 * Called on signal. 4667 * Lets the admin reconnect without waiting for the reconnect timer expires. 4668 */ 4669 /*ARGSUSED*/ 4670 void 4671 dispatch_force_tls_reconnect(int fd, short event, void *ev) 4672 { 4673 struct filed *f; 4674 DPRINTF((D_TLS|D_CALL|D_EVENT), "dispatch_force_tls_reconnect()\n"); 4675 for (f = Files; f; f = f->f_next) { 4676 if (f->f_type == F_TLS && 4677 f->f_un.f_tls.tls_conn->state == ST_NONE) 4678 tls_reconnect(fd, event, f->f_un.f_tls.tls_conn); 4679 } 4680 } 4681 #endif /* !DISABLE_TLS */ 4682 4683 /* 4684 * return a timestamp in a static buffer, 4685 * either format the timestamp given by parameter in_now 4686 * or use the current time if in_now is NULL. 4687 */ 4688 char * 4689 make_timestamp(time_t *in_now, bool iso, size_t tlen) 4690 { 4691 int frac_digits = 6; 4692 struct timeval tv; 4693 time_t mytime; 4694 struct tm ltime; 4695 int len = 0; 4696 int tzlen = 0; 4697 /* uses global var: time_t now; */ 4698 4699 if (in_now) { 4700 mytime = *in_now; 4701 } else { 4702 gettimeofday(&tv, NULL); 4703 mytime = now = tv.tv_sec; 4704 } 4705 4706 if (!iso) { 4707 strlcpy(timestamp, ctime(&mytime) + 4, sizeof(timestamp)); 4708 timestamp[BSD_TIMESTAMPLEN] = '\0'; 4709 } else { 4710 localtime_r(&mytime, <ime); 4711 len += strftime(timestamp, sizeof(timestamp), "%FT%T", <ime); 4712 snprintf(×tamp[len], frac_digits + 2, ".%.*jd", 4713 frac_digits, (intmax_t)tv.tv_usec); 4714 len += frac_digits + 1; 4715 tzlen = strftime(×tamp[len], sizeof(timestamp) - len, "%z", 4716 <ime); 4717 len += tzlen; 4718 4719 if (tzlen == 5) { 4720 /* strftime gives "+0200", but we need "+02:00" */ 4721 timestamp[len + 2] = '\0'; 4722 timestamp[len + 1] = timestamp[len]; 4723 timestamp[len] = timestamp[len - 1]; 4724 timestamp[len - 1] = timestamp[len - 2]; 4725 timestamp[len - 2] = ':'; 4726 } 4727 } 4728 4729 switch (tlen) { 4730 case (size_t)-1: 4731 return timestamp; 4732 case 0: 4733 return strdup(timestamp); 4734 default: 4735 return strndup(timestamp, tlen); 4736 } 4737 } 4738 4739 /* auxillary code to allocate memory and copy a string */ 4740 bool 4741 copy_string(char **mem, const char *p, const char *q) 4742 { 4743 const size_t len = 1 + q - p; 4744 if (!(*mem = malloc(len))) { 4745 logerror("Unable to allocate memory for config"); 4746 return false; 4747 } 4748 strlcpy(*mem, p, len); 4749 return true; 4750 } 4751 4752 /* keyword has to end with ", everything until next " is copied */ 4753 bool 4754 copy_config_value_quoted(const char *keyword, char **mem, const char **p) 4755 { 4756 const char *q; 4757 if (strncasecmp(*p, keyword, strlen(keyword))) 4758 return false; 4759 q = *p += strlen(keyword); 4760 if (!(q = strchr(*p, '"'))) { 4761 errno = 0; 4762 logerror("unterminated \"\n"); 4763 return false; 4764 } 4765 if (!(copy_string(mem, *p, q))) 4766 return false; 4767 *p = ++q; 4768 return true; 4769 } 4770 4771 /* for config file: 4772 * following = required but whitespace allowed, quotes optional 4773 * if numeric, then conversion to integer and no memory allocation 4774 */ 4775 bool 4776 copy_config_value(const char *keyword, char **mem, 4777 const char **p, const char *file, int line) 4778 { 4779 if (strncasecmp(*p, keyword, strlen(keyword))) 4780 return false; 4781 *p += strlen(keyword); 4782 4783 while (isspace((unsigned char)**p)) 4784 *p += 1; 4785 if (**p != '=') { 4786 errno = 0; 4787 logerror("expected \"=\" in file %s, line %d", file, line); 4788 return false; 4789 } 4790 *p += 1; 4791 4792 return copy_config_value_word(mem, p); 4793 } 4794 4795 /* copy next parameter from a config line */ 4796 bool 4797 copy_config_value_word(char **mem, const char **p) 4798 { 4799 const char *q; 4800 while (isspace((unsigned char)**p)) 4801 *p += 1; 4802 if (**p == '"') 4803 return copy_config_value_quoted("\"", mem, p); 4804 4805 /* without quotes: find next whitespace or end of line */ 4806 (void)((q = strchr(*p, ' ')) || (q = strchr(*p, '\t')) 4807 || (q = strchr(*p, '\n')) || (q = strchr(*p, '\0'))); 4808 4809 if (q-*p == 0 || !(copy_string(mem, *p, q))) 4810 return false; 4811 4812 *p = ++q; 4813 return true; 4814 } 4815 4816 static int 4817 writev1(int fd, struct iovec *iov, size_t count) 4818 { 4819 ssize_t nw = 0, tot = 0; 4820 size_t ntries = 5; 4821 4822 if (count == 0) 4823 return 0; 4824 while (ntries--) { 4825 switch ((nw = writev(fd, iov, count))) { 4826 case -1: 4827 if (errno == EAGAIN || errno == EWOULDBLOCK) { 4828 struct pollfd pfd; 4829 pfd.fd = fd; 4830 pfd.events = POLLOUT; 4831 pfd.revents = 0; 4832 (void)poll(&pfd, 1, 500); 4833 continue; 4834 } 4835 return -1; 4836 case 0: 4837 return 0; 4838 default: 4839 tot += nw; 4840 while (nw > 0) { 4841 if (iov->iov_len > (size_t)nw) { 4842 iov->iov_len -= nw; 4843 iov->iov_base = 4844 (char *)iov->iov_base + nw; 4845 break; 4846 } else { 4847 if (--count == 0) 4848 return tot; 4849 nw -= iov->iov_len; 4850 iov++; 4851 } 4852 } 4853 } 4854 } 4855 return tot == 0 ? nw : tot; 4856 } 4857 4858 #ifndef NDEBUG 4859 void 4860 dbprintf(const char *fname, const char *funname, 4861 size_t lnum, const char *fmt, ...) 4862 { 4863 va_list ap; 4864 char *ts; 4865 4866 ts = make_timestamp(NULL, true, (size_t)-1); 4867 printf("%s:%s:%s:%.4zu\t", ts, fname, funname, lnum); 4868 4869 va_start(ap, fmt); 4870 vprintf(fmt, ap); 4871 va_end(ap); 4872 } 4873 #endif 4874