![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to syslogd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / syslogd|
Return to syslogd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / syslogd |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983, 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted provided ! 6: * that: (1) source distributions retain this entire copyright notice and ! 7: * comment, and (2) distributions including binaries display the following ! 8: * acknowledgement: ``This product includes software developed by the ! 9: * University of California, Berkeley and its contributors'' in the ! 10: * documentation or other materials provided with the distribution and in ! 11: * all advertising materials mentioning features or use of this software. ! 12: * Neither the name of the University nor the names of its contributors may ! 13: * be used to endorse or promote products derived from this software without ! 14: * specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: char copyright[] = ! 22: "@(#) Copyright (c) 1983, 1988 Regents of the University of California.\n\ ! 23: All rights reserved.\n"; ! 24: #endif /* not lint */ ! 25: ! 26: #ifndef lint ! 27: static char sccsid[] = "@(#)syslogd.c 5.42 (Berkeley) 6/29/90"; ! 28: #endif /* not lint */ ! 29: ! 30: /* ! 31: * syslogd -- log system messages ! 32: * ! 33: * This program implements a system log. It takes a series of lines. ! 34: * Each line may have a priority, signified as "<n>" as ! 35: * the first characters of the line. If this is ! 36: * not present, a default priority is used. ! 37: * ! 38: * To kill syslogd, send a signal 15 (terminate). A signal 1 (hup) will ! 39: * cause it to reread its configuration file. ! 40: * ! 41: * Defined Constants: ! 42: * ! 43: * MAXLINE -- the maximimum line length that can be handled. ! 44: * DEFUPRI -- the default priority for user messages ! 45: * DEFSPRI -- the default priority for kernel messages ! 46: * ! 47: * Author: Eric Allman ! 48: * extensive changes by Ralph Campbell ! 49: * more extensive changes by Eric Allman (again) ! 50: */ ! 51: ! 52: #define MAXLINE 1024 /* maximum line length */ ! 53: #define MAXSVLINE 120 /* maximum saved line length */ ! 54: #define DEFUPRI (LOG_USER|LOG_NOTICE) ! 55: #define DEFSPRI (LOG_KERN|LOG_CRIT) ! 56: #define TIMERINTVL 30 /* interval for checking flush, mark */ ! 57: ! 58: #include <sys/param.h> ! 59: #include <sys/errno.h> ! 60: #include <sys/ioctl.h> ! 61: #include <sys/stat.h> ! 62: #include <sys/wait.h> ! 63: #include <sys/socket.h> ! 64: #include <sys/file.h> ! 65: #include <sys/msgbuf.h> ! 66: #include <sys/uio.h> ! 67: #include <sys/un.h> ! 68: #include <sys/time.h> ! 69: #include <sys/resource.h> ! 70: #include <sys/signal.h> ! 71: ! 72: #include <netinet/in.h> ! 73: #include <netdb.h> ! 74: ! 75: #include <utmp.h> ! 76: #include <setjmp.h> ! 77: #include <stdio.h> ! 78: #include <ctype.h> ! 79: #include <string.h> ! 80: #include <unistd.h> ! 81: #include "pathnames.h" ! 82: ! 83: #define SYSLOG_NAMES ! 84: #include <sys/syslog.h> ! 85: ! 86: char *LogName = _PATH_LOG; ! 87: char *ConfFile = _PATH_LOGCONF; ! 88: char *PidFile = _PATH_LOGPID; ! 89: char ctty[] = _PATH_CONSOLE; ! 90: ! 91: #define FDMASK(fd) (1 << (fd)) ! 92: ! 93: #define dprintf if (Debug) printf ! 94: ! 95: #define MAXUNAMES 20 /* maximum number of user names */ ! 96: ! 97: /* ! 98: * Flags to logmsg(). ! 99: */ ! 100: ! 101: #define IGN_CONS 0x001 /* don't print on console */ ! 102: #define SYNC_FILE 0x002 /* do fsync on file after printing */ ! 103: #define ADDDATE 0x004 /* add a date to the message */ ! 104: #define MARK 0x008 /* this message is a mark */ ! 105: ! 106: /* ! 107: * This structure represents the files that will have log ! 108: * copies printed. ! 109: */ ! 110: ! 111: struct filed { ! 112: struct filed *f_next; /* next in linked list */ ! 113: short f_type; /* entry type, see below */ ! 114: short f_file; /* file descriptor */ ! 115: time_t f_time; /* time this was last written */ ! 116: u_char f_pmask[LOG_NFACILITIES+1]; /* priority mask */ ! 117: union { ! 118: char f_uname[MAXUNAMES][UT_NAMESIZE+1]; ! 119: struct { ! 120: char f_hname[MAXHOSTNAMELEN+1]; ! 121: struct sockaddr_in f_addr; ! 122: } f_forw; /* forwarding address */ ! 123: char f_fname[MAXPATHLEN]; ! 124: } f_un; ! 125: char f_prevline[MAXSVLINE]; /* last message logged */ ! 126: char f_lasttime[16]; /* time of last occurrence */ ! 127: char f_prevhost[MAXHOSTNAMELEN+1]; /* host from which recd. */ ! 128: int f_prevpri; /* pri of f_prevline */ ! 129: int f_prevlen; /* length of f_prevline */ ! 130: int f_prevcount; /* repetition cnt of prevline */ ! 131: int f_repeatcount; /* number of "repeated" msgs */ ! 132: }; ! 133: ! 134: /* ! 135: * Intervals at which we flush out "message repeated" messages, ! 136: * in seconds after previous message is logged. After each flush, ! 137: * we move to the next interval until we reach the largest. ! 138: */ ! 139: int repeatinterval[] = { 30, 120, 600 }; /* # of secs before flush */ ! 140: #define MAXREPEAT ((sizeof(repeatinterval) / sizeof(repeatinterval[0])) - 1) ! 141: #define REPEATTIME(f) ((f)->f_time + repeatinterval[(f)->f_repeatcount]) ! 142: #define BACKOFF(f) { if (++(f)->f_repeatcount > MAXREPEAT) \ ! 143: (f)->f_repeatcount = MAXREPEAT; \ ! 144: } ! 145: ! 146: /* values for f_type */ ! 147: #define F_UNUSED 0 /* unused entry */ ! 148: #define F_FILE 1 /* regular file */ ! 149: #define F_TTY 2 /* terminal */ ! 150: #define F_CONSOLE 3 /* console terminal */ ! 151: #define F_FORW 4 /* remote machine */ ! 152: #define F_USERS 5 /* list of users */ ! 153: #define F_WALL 6 /* everyone logged on */ ! 154: ! 155: char *TypeNames[7] = { ! 156: "UNUSED", "FILE", "TTY", "CONSOLE", ! 157: "FORW", "USERS", "WALL" ! 158: }; ! 159: ! 160: struct filed *Files; ! 161: struct filed consfile; ! 162: ! 163: int Debug; /* debug flag */ ! 164: char LocalHostName[MAXHOSTNAMELEN+1]; /* our hostname */ ! 165: char *LocalDomain; /* our local domain name */ ! 166: int InetInuse = 0; /* non-zero if INET sockets are being used */ ! 167: int finet; /* Internet datagram socket */ ! 168: int LogPort; /* port number for INET connections */ ! 169: int Initialized = 0; /* set when we have initialized ourselves */ ! 170: int MarkInterval = 20 * 60; /* interval between marks in seconds */ ! 171: int MarkSeq = 0; /* mark sequence number */ ! 172: ! 173: extern int errno; ! 174: extern char *ctime(), *index(), *calloc(); ! 175: ! 176: main(argc, argv) ! 177: int argc; ! 178: char **argv; ! 179: { ! 180: register int i; ! 181: register char *p; ! 182: int funix, inetm, fklog, klogm, len; ! 183: struct sockaddr_un sunx, fromunix; ! 184: struct sockaddr_in sin, frominet; ! 185: FILE *fp; ! 186: int ch; ! 187: char line[MSG_BSIZE + 1]; ! 188: extern int optind; ! 189: extern char *optarg; ! 190: void die(), domark(), init(), reapchild(); ! 191: ! 192: while ((ch = getopt(argc, argv, "df:m:p:")) != EOF) ! 193: switch((char)ch) { ! 194: case 'd': /* debug */ ! 195: Debug++; ! 196: break; ! 197: case 'f': /* configuration file */ ! 198: ConfFile = optarg; ! 199: break; ! 200: case 'm': /* mark interval */ ! 201: MarkInterval = atoi(optarg) * 60; ! 202: break; ! 203: case 'p': /* path */ ! 204: LogName = optarg; ! 205: break; ! 206: case '?': ! 207: default: ! 208: usage(); ! 209: } ! 210: if (argc -= optind) ! 211: usage(); ! 212: ! 213: if (!Debug) ! 214: daemon(0, 0); ! 215: else ! 216: setlinebuf(stdout); ! 217: ! 218: consfile.f_type = F_CONSOLE; ! 219: (void) strcpy(consfile.f_un.f_fname, ctty); ! 220: (void) gethostname(LocalHostName, sizeof LocalHostName); ! 221: if (p = index(LocalHostName, '.')) { ! 222: *p++ = '\0'; ! 223: LocalDomain = p; ! 224: } ! 225: else ! 226: LocalDomain = ""; ! 227: (void) signal(SIGTERM, die); ! 228: (void) signal(SIGINT, Debug ? die : SIG_IGN); ! 229: (void) signal(SIGQUIT, Debug ? die : SIG_IGN); ! 230: (void) signal(SIGCHLD, reapchild); ! 231: (void) signal(SIGALRM, domark); ! 232: (void) alarm(TIMERINTVL); ! 233: (void) unlink(LogName); ! 234: ! 235: bzero((char *)&sunx, sizeof(sunx)); ! 236: sunx.sun_family = AF_UNIX; ! 237: (void) strncpy(sunx.sun_path, LogName, sizeof sunx.sun_path); ! 238: funix = socket(AF_UNIX, SOCK_DGRAM, 0); ! 239: if (funix < 0 || bind(funix, (struct sockaddr *) &sunx, ! 240: sizeof(sunx.sun_family)+sizeof(sunx.sun_len)+ ! 241: strlen(sunx.sun_path)) < 0 || ! 242: chmod(LogName, 0666) < 0) { ! 243: (void) sprintf(line, "cannot create %s", LogName); ! 244: logerror(line); ! 245: dprintf("cannot create %s (%d)\n", LogName, errno); ! 246: die(0); ! 247: } ! 248: finet = socket(AF_INET, SOCK_DGRAM, 0); ! 249: if (finet >= 0) { ! 250: struct servent *sp; ! 251: ! 252: sp = getservbyname("syslog", "udp"); ! 253: if (sp == NULL) { ! 254: errno = 0; ! 255: logerror("syslog/udp: unknown service"); ! 256: die(0); ! 257: } ! 258: sin.sin_family = AF_INET; ! 259: sin.sin_port = LogPort = sp->s_port; ! 260: if (bind(finet, (struct sockaddr *)&sin, sizeof(sin)) < 0) { ! 261: logerror("bind"); ! 262: if (!Debug) ! 263: die(0); ! 264: } else { ! 265: inetm = FDMASK(finet); ! 266: InetInuse = 1; ! 267: } ! 268: } ! 269: if ((fklog = open(_PATH_KLOG, O_RDONLY, 0)) >= 0) ! 270: klogm = FDMASK(fklog); ! 271: else { ! 272: dprintf("can't open %s (%d)\n", _PATH_KLOG, errno); ! 273: klogm = 0; ! 274: } ! 275: ! 276: /* tuck my process id away */ ! 277: fp = fopen(PidFile, "w"); ! 278: if (fp != NULL) { ! 279: fprintf(fp, "%d\n", getpid()); ! 280: (void) fclose(fp); ! 281: } ! 282: ! 283: dprintf("off & running....\n"); ! 284: ! 285: init(); ! 286: (void) signal(SIGHUP, init); ! 287: ! 288: for (;;) { ! 289: int nfds, readfds = FDMASK(funix) | inetm | klogm; ! 290: ! 291: errno = 0; ! 292: dprintf("readfds = %#x\n", readfds); ! 293: nfds = select(20, (fd_set *) &readfds, (fd_set *) NULL, ! 294: (fd_set *) NULL, (struct timeval *) NULL); ! 295: if (nfds == 0) ! 296: continue; ! 297: if (nfds < 0) { ! 298: if (errno != EINTR) ! 299: logerror("select"); ! 300: continue; ! 301: } ! 302: dprintf("got a message (%d, %#x)\n", nfds, readfds); ! 303: if (readfds & klogm) { ! 304: i = read(fklog, line, sizeof(line) - 1); ! 305: if (i > 0) { ! 306: line[i] = '\0'; ! 307: printsys(line); ! 308: } else if (i < 0 && errno != EINTR) { ! 309: logerror("klog"); ! 310: fklog = -1; ! 311: klogm = 0; ! 312: } ! 313: } ! 314: if (readfds & FDMASK(funix)) { ! 315: len = sizeof fromunix; ! 316: i = recvfrom(funix, line, MAXLINE, 0, ! 317: (struct sockaddr *) &fromunix, &len); ! 318: if (i > 0) { ! 319: line[i] = '\0'; ! 320: printline(LocalHostName, line); ! 321: } else if (i < 0 && errno != EINTR) ! 322: logerror("recvfrom unix"); ! 323: } ! 324: if (readfds & inetm) { ! 325: len = sizeof frominet; ! 326: i = recvfrom(finet, line, MAXLINE, 0, ! 327: (struct sockaddr *) &frominet, &len); ! 328: if (i > 0) { ! 329: extern char *cvthname(); ! 330: ! 331: line[i] = '\0'; ! 332: printline(cvthname(&frominet), line); ! 333: } else if (i < 0 && errno != EINTR) ! 334: logerror("recvfrom inet"); ! 335: } ! 336: } ! 337: } ! 338: ! 339: usage() ! 340: { ! 341: (void) fprintf(stderr, ! 342: "usage: syslogd [-d] [-f conffile] [-m markinterval] [-p path]\n"); ! 343: exit(1); ! 344: } ! 345: ! 346: /* ! 347: * Take a raw input line, decode the message, and print the message ! 348: * on the appropriate log files. ! 349: */ ! 350: ! 351: printline(hname, msg) ! 352: char *hname; ! 353: char *msg; ! 354: { ! 355: register char *p, *q; ! 356: register int c; ! 357: char line[MAXLINE + 1]; ! 358: int pri; ! 359: ! 360: /* test for special codes */ ! 361: pri = DEFUPRI; ! 362: p = msg; ! 363: if (*p == '<') { ! 364: pri = 0; ! 365: while (isdigit(*++p)) ! 366: pri = 10 * pri + (*p - '0'); ! 367: if (*p == '>') ! 368: ++p; ! 369: } ! 370: if (pri &~ (LOG_FACMASK|LOG_PRIMASK)) ! 371: pri = DEFUPRI; ! 372: ! 373: /* don't allow users to log kernel messages */ ! 374: if (LOG_FAC(pri) == LOG_KERN) ! 375: pri = LOG_MAKEPRI(LOG_USER, LOG_PRI(pri)); ! 376: ! 377: q = line; ! 378: ! 379: while ((c = *p++ & 0177) != '\0' && ! 380: q < &line[sizeof(line) - 1]) ! 381: if (iscntrl(c)) ! 382: if (c == '\n') ! 383: *q++ = ' '; ! 384: else if (c == '\t') ! 385: *q++ = '\t'; ! 386: else { ! 387: *q++ = '^'; ! 388: *q++ = c ^ 0100; ! 389: } ! 390: else ! 391: *q++ = c; ! 392: *q = '\0'; ! 393: ! 394: logmsg(pri, line, hname, 0); ! 395: } ! 396: ! 397: /* ! 398: * Take a raw input line from /dev/klog, split and format similar to syslog(). ! 399: */ ! 400: ! 401: printsys(msg) ! 402: char *msg; ! 403: { ! 404: register char *p, *q; ! 405: register int c; ! 406: char line[MAXLINE + 1]; ! 407: int pri, flags; ! 408: char *lp; ! 409: ! 410: (void) strcpy(line, "vmunix: "); ! 411: lp = line + strlen(line); ! 412: for (p = msg; *p != '\0'; ) { ! 413: flags = SYNC_FILE | ADDDATE; /* fsync file after write */ ! 414: pri = DEFSPRI; ! 415: if (*p == '<') { ! 416: pri = 0; ! 417: while (isdigit(*++p)) ! 418: pri = 10 * pri + (*p - '0'); ! 419: if (*p == '>') ! 420: ++p; ! 421: } else { ! 422: /* kernel printf's come out on console */ ! 423: flags |= IGN_CONS; ! 424: } ! 425: if (pri &~ (LOG_FACMASK|LOG_PRIMASK)) ! 426: pri = DEFSPRI; ! 427: q = lp; ! 428: while (*p != '\0' && (c = *p++) != '\n' && ! 429: q < &line[MAXLINE]) ! 430: *q++ = c; ! 431: *q = '\0'; ! 432: logmsg(pri, line, LocalHostName, flags); ! 433: } ! 434: } ! 435: ! 436: time_t now; ! 437: ! 438: /* ! 439: * Log a message to the appropriate log files, users, etc. based on ! 440: * the priority. ! 441: */ ! 442: ! 443: logmsg(pri, msg, from, flags) ! 444: int pri; ! 445: char *msg, *from; ! 446: int flags; ! 447: { ! 448: register struct filed *f; ! 449: int fac, prilev; ! 450: int omask, msglen; ! 451: char *timestamp; ! 452: time_t time(); ! 453: ! 454: dprintf("logmsg: pri %o, flags %x, from %s, msg %s\n", ! 455: pri, flags, from, msg); ! 456: ! 457: omask = sigblock(sigmask(SIGHUP)|sigmask(SIGALRM)); ! 458: ! 459: /* ! 460: * Check to see if msg looks non-standard. ! 461: */ ! 462: msglen = strlen(msg); ! 463: if (msglen < 16 || msg[3] != ' ' || msg[6] != ' ' || ! 464: msg[9] != ':' || msg[12] != ':' || msg[15] != ' ') ! 465: flags |= ADDDATE; ! 466: ! 467: (void) time(&now); ! 468: if (flags & ADDDATE) ! 469: timestamp = ctime(&now) + 4; ! 470: else { ! 471: timestamp = msg; ! 472: msg += 16; ! 473: msglen -= 16; ! 474: } ! 475: ! 476: /* extract facility and priority level */ ! 477: if (flags & MARK) ! 478: fac = LOG_NFACILITIES; ! 479: else ! 480: fac = LOG_FAC(pri); ! 481: prilev = LOG_PRI(pri); ! 482: ! 483: /* log the message to the particular outputs */ ! 484: if (!Initialized) { ! 485: f = &consfile; ! 486: f->f_file = open(ctty, O_WRONLY, 0); ! 487: ! 488: if (f->f_file >= 0) { ! 489: fprintlog(f, flags, msg); ! 490: (void) close(f->f_file); ! 491: } ! 492: (void) sigsetmask(omask); ! 493: return; ! 494: } ! 495: for (f = Files; f; f = f->f_next) { ! 496: /* skip messages that are incorrect priority */ ! 497: if (f->f_pmask[fac] < prilev || ! 498: f->f_pmask[fac] == INTERNAL_NOPRI) ! 499: continue; ! 500: ! 501: if (f->f_type == F_CONSOLE && (flags & IGN_CONS)) ! 502: continue; ! 503: ! 504: /* don't output marks to recently written files */ ! 505: if ((flags & MARK) && (now - f->f_time) < MarkInterval / 2) ! 506: continue; ! 507: ! 508: /* ! 509: * suppress duplicate lines to this file ! 510: */ ! 511: if ((flags & MARK) == 0 && msglen == f->f_prevlen && ! 512: !strcmp(msg, f->f_prevline) && ! 513: !strcmp(from, f->f_prevhost)) { ! 514: (void) strncpy(f->f_lasttime, timestamp, 15); ! 515: f->f_prevcount++; ! 516: dprintf("msg repeated %d times, %ld sec of %d\n", ! 517: f->f_prevcount, now - f->f_time, ! 518: repeatinterval[f->f_repeatcount]); ! 519: /* ! 520: * If domark would have logged this by now, ! 521: * flush it now (so we don't hold isolated messages), ! 522: * but back off so we'll flush less often ! 523: * in the future. ! 524: */ ! 525: if (now > REPEATTIME(f)) { ! 526: fprintlog(f, flags, (char *)NULL); ! 527: BACKOFF(f); ! 528: } ! 529: } else { ! 530: /* new line, save it */ ! 531: if (f->f_prevcount) ! 532: fprintlog(f, 0, (char *)NULL); ! 533: f->f_repeatcount = 0; ! 534: (void) strncpy(f->f_lasttime, timestamp, 15); ! 535: (void) strncpy(f->f_prevhost, from, ! 536: sizeof(f->f_prevhost)); ! 537: if (msglen < MAXSVLINE) { ! 538: f->f_prevlen = msglen; ! 539: f->f_prevpri = pri; ! 540: (void) strcpy(f->f_prevline, msg); ! 541: fprintlog(f, flags, (char *)NULL); ! 542: } else { ! 543: f->f_prevline[0] = 0; ! 544: f->f_prevlen = 0; ! 545: fprintlog(f, flags, msg); ! 546: } ! 547: } ! 548: } ! 549: (void) sigsetmask(omask); ! 550: } ! 551: ! 552: fprintlog(f, flags, msg) ! 553: register struct filed *f; ! 554: int flags; ! 555: char *msg; ! 556: { ! 557: struct iovec iov[6]; ! 558: register struct iovec *v; ! 559: register int l; ! 560: char line[MAXLINE + 1], repbuf[80], greetings[200]; ! 561: ! 562: v = iov; ! 563: if (f->f_type == F_WALL) { ! 564: v->iov_base = greetings; ! 565: v->iov_len = sprintf(greetings, ! 566: "\r\n\7Message from syslogd@%s at %.24s ...\r\n", ! 567: f->f_prevhost, ctime(&now)); ! 568: v++; ! 569: v->iov_base = ""; ! 570: v->iov_len = 0; ! 571: v++; ! 572: } else { ! 573: v->iov_base = f->f_lasttime; ! 574: v->iov_len = 15; ! 575: v++; ! 576: v->iov_base = " "; ! 577: v->iov_len = 1; ! 578: v++; ! 579: } ! 580: v->iov_base = f->f_prevhost; ! 581: v->iov_len = strlen(v->iov_base); ! 582: v++; ! 583: v->iov_base = " "; ! 584: v->iov_len = 1; ! 585: v++; ! 586: ! 587: if (msg) { ! 588: v->iov_base = msg; ! 589: v->iov_len = strlen(msg); ! 590: } else if (f->f_prevcount > 1) { ! 591: v->iov_base = repbuf; ! 592: v->iov_len = sprintf(repbuf, "last message repeated %d times", ! 593: f->f_prevcount); ! 594: } else { ! 595: v->iov_base = f->f_prevline; ! 596: v->iov_len = f->f_prevlen; ! 597: } ! 598: v++; ! 599: ! 600: dprintf("Logging to %s", TypeNames[f->f_type]); ! 601: f->f_time = now; ! 602: ! 603: switch (f->f_type) { ! 604: case F_UNUSED: ! 605: dprintf("\n"); ! 606: break; ! 607: ! 608: case F_FORW: ! 609: dprintf(" %s\n", f->f_un.f_forw.f_hname); ! 610: l = sprintf(line, "<%d>%.15s %s", f->f_prevpri, ! 611: iov[0].iov_base, iov[4].iov_base); ! 612: if (l > MAXLINE) ! 613: l = MAXLINE; ! 614: if (sendto(finet, line, l, 0, &f->f_un.f_forw.f_addr, ! 615: sizeof f->f_un.f_forw.f_addr) != l) { ! 616: int e = errno; ! 617: (void) close(f->f_file); ! 618: f->f_type = F_UNUSED; ! 619: errno = e; ! 620: logerror("sendto"); ! 621: } ! 622: break; ! 623: ! 624: case F_CONSOLE: ! 625: if (flags & IGN_CONS) { ! 626: dprintf(" (ignored)\n"); ! 627: break; ! 628: } ! 629: /* FALLTHROUGH */ ! 630: ! 631: case F_TTY: ! 632: case F_FILE: ! 633: dprintf(" %s\n", f->f_un.f_fname); ! 634: if (f->f_type != F_FILE) { ! 635: v->iov_base = "\r\n"; ! 636: v->iov_len = 2; ! 637: } else { ! 638: v->iov_base = "\n"; ! 639: v->iov_len = 1; ! 640: } ! 641: again: ! 642: if (writev(f->f_file, iov, 6) < 0) { ! 643: int e = errno; ! 644: (void) close(f->f_file); ! 645: /* ! 646: * Check for errors on TTY's due to loss of tty ! 647: */ ! 648: if ((e == EIO || e == EBADF) && f->f_type != F_FILE) { ! 649: f->f_file = open(f->f_un.f_fname, ! 650: O_WRONLY|O_APPEND, 0); ! 651: if (f->f_file < 0) { ! 652: f->f_type = F_UNUSED; ! 653: logerror(f->f_un.f_fname); ! 654: } else ! 655: goto again; ! 656: } else { ! 657: f->f_type = F_UNUSED; ! 658: errno = e; ! 659: logerror(f->f_un.f_fname); ! 660: } ! 661: } else if (flags & SYNC_FILE) ! 662: (void) fsync(f->f_file); ! 663: break; ! 664: ! 665: case F_USERS: ! 666: case F_WALL: ! 667: dprintf("\n"); ! 668: v->iov_base = "\r\n"; ! 669: v->iov_len = 2; ! 670: wallmsg(f, iov); ! 671: break; ! 672: } ! 673: f->f_prevcount = 0; ! 674: } ! 675: ! 676: /* ! 677: * WALLMSG -- Write a message to the world at large ! 678: * ! 679: * Write the specified message to either the entire ! 680: * world, or a list of approved users. ! 681: */ ! 682: ! 683: wallmsg(f, iov) ! 684: register struct filed *f; ! 685: struct iovec *iov; ! 686: { ! 687: static int reenter; /* avoid calling ourselves */ ! 688: register FILE *uf; ! 689: register int i; ! 690: struct utmp ut; ! 691: char *p, *ttymsg(); ! 692: ! 693: if (reenter++) ! 694: return; ! 695: if ((uf = fopen(_PATH_UTMP, "r")) == NULL) { ! 696: logerror(_PATH_UTMP); ! 697: reenter = 0; ! 698: return; ! 699: } ! 700: /* NOSTRICT */ ! 701: while (fread((char *) &ut, sizeof ut, 1, uf) == 1) { ! 702: if (ut.ut_name[0] == '\0') ! 703: continue; ! 704: if (f->f_type == F_WALL) { ! 705: if (p = ttymsg(iov, 6, ut.ut_line, 1)) { ! 706: errno = 0; /* already in msg */ ! 707: logerror(p); ! 708: } ! 709: continue; ! 710: } ! 711: /* should we send the message to this user? */ ! 712: for (i = 0; i < MAXUNAMES; i++) { ! 713: if (!f->f_un.f_uname[i][0]) ! 714: break; ! 715: if (!strncmp(f->f_un.f_uname[i], ut.ut_name, ! 716: UT_NAMESIZE)) { ! 717: if (p = ttymsg(iov, 6, ut.ut_line, 1)) { ! 718: errno = 0; /* already in msg */ ! 719: logerror(p); ! 720: } ! 721: break; ! 722: } ! 723: } ! 724: } ! 725: (void) fclose(uf); ! 726: reenter = 0; ! 727: } ! 728: ! 729: void ! 730: reapchild() ! 731: { ! 732: union wait status; ! 733: ! 734: while (wait3(&status, WNOHANG, (struct rusage *) NULL) > 0) ! 735: ; ! 736: } ! 737: ! 738: /* ! 739: * Return a printable representation of a host address. ! 740: */ ! 741: char * ! 742: cvthname(f) ! 743: struct sockaddr_in *f; ! 744: { ! 745: struct hostent *hp; ! 746: register char *p; ! 747: extern char *inet_ntoa(); ! 748: ! 749: dprintf("cvthname(%s)\n", inet_ntoa(f->sin_addr)); ! 750: ! 751: if (f->sin_family != AF_INET) { ! 752: dprintf("Malformed from address\n"); ! 753: return ("???"); ! 754: } ! 755: hp = gethostbyaddr(&f->sin_addr, sizeof(struct in_addr), f->sin_family); ! 756: if (hp == 0) { ! 757: dprintf("Host name for your address (%s) unknown\n", ! 758: inet_ntoa(f->sin_addr)); ! 759: return (inet_ntoa(f->sin_addr)); ! 760: } ! 761: if ((p = index(hp->h_name, '.')) && strcmp(p + 1, LocalDomain) == 0) ! 762: *p = '\0'; ! 763: return (hp->h_name); ! 764: } ! 765: ! 766: void ! 767: domark() ! 768: { ! 769: register struct filed *f; ! 770: time_t time(); ! 771: ! 772: now = time((time_t *)NULL); ! 773: MarkSeq += TIMERINTVL; ! 774: if (MarkSeq >= MarkInterval) { ! 775: logmsg(LOG_INFO, "-- MARK --", LocalHostName, ADDDATE|MARK); ! 776: MarkSeq = 0; ! 777: } ! 778: ! 779: for (f = Files; f; f = f->f_next) { ! 780: if (f->f_prevcount && now >= REPEATTIME(f)) { ! 781: dprintf("flush %s: repeated %d times, %d sec.\n", ! 782: TypeNames[f->f_type], f->f_prevcount, ! 783: repeatinterval[f->f_repeatcount]); ! 784: fprintlog(f, 0, (char *)NULL); ! 785: BACKOFF(f); ! 786: } ! 787: } ! 788: (void) alarm(TIMERINTVL); ! 789: } ! 790: ! 791: /* ! 792: * Print syslogd errors some place. ! 793: */ ! 794: logerror(type) ! 795: char *type; ! 796: { ! 797: char buf[100], *strerror(); ! 798: ! 799: if (errno) ! 800: (void) sprintf(buf, "syslogd: %s: %s", type, strerror(errno)); ! 801: else ! 802: (void) sprintf(buf, "syslogd: %s", type); ! 803: errno = 0; ! 804: dprintf("%s\n", buf); ! 805: logmsg(LOG_SYSLOG|LOG_ERR, buf, LocalHostName, ADDDATE); ! 806: } ! 807: ! 808: void ! 809: die(sig) ! 810: { ! 811: register struct filed *f; ! 812: char buf[100]; ! 813: ! 814: for (f = Files; f != NULL; f = f->f_next) { ! 815: /* flush any pending output */ ! 816: if (f->f_prevcount) ! 817: fprintlog(f, 0, (char *)NULL); ! 818: } ! 819: if (sig) { ! 820: dprintf("syslogd: exiting on signal %d\n", sig); ! 821: (void) sprintf(buf, "exiting on signal %d", sig); ! 822: errno = 0; ! 823: logerror(buf); ! 824: } ! 825: (void) unlink(LogName); ! 826: exit(0); ! 827: } ! 828: ! 829: /* ! 830: * INIT -- Initialize syslogd from configuration table ! 831: */ ! 832: ! 833: void ! 834: init() ! 835: { ! 836: register int i; ! 837: register FILE *cf; ! 838: register struct filed *f, *next, **nextp; ! 839: register char *p; ! 840: char cline[BUFSIZ]; ! 841: ! 842: dprintf("init\n"); ! 843: ! 844: /* ! 845: * Close all open log files. ! 846: */ ! 847: Initialized = 0; ! 848: for (f = Files; f != NULL; f = next) { ! 849: /* flush any pending output */ ! 850: if (f->f_prevcount) ! 851: fprintlog(f, 0, (char *)NULL); ! 852: ! 853: switch (f->f_type) { ! 854: case F_FILE: ! 855: case F_TTY: ! 856: case F_CONSOLE: ! 857: case F_FORW: ! 858: (void) close(f->f_file); ! 859: break; ! 860: } ! 861: next = f->f_next; ! 862: free((char *) f); ! 863: } ! 864: Files = NULL; ! 865: nextp = &Files; ! 866: ! 867: /* open the configuration file */ ! 868: if ((cf = fopen(ConfFile, "r")) == NULL) { ! 869: dprintf("cannot open %s\n", ConfFile); ! 870: *nextp = (struct filed *)calloc(1, sizeof(*f)); ! 871: cfline("*.ERR\t/dev/console", *nextp); ! 872: (*nextp)->f_next = (struct filed *)calloc(1, sizeof(*f)); ! 873: cfline("*.PANIC\t*", (*nextp)->f_next); ! 874: Initialized = 1; ! 875: return; ! 876: } ! 877: ! 878: /* ! 879: * Foreach line in the conf table, open that file. ! 880: */ ! 881: f = NULL; ! 882: while (fgets(cline, sizeof cline, cf) != NULL) { ! 883: /* ! 884: * check for end-of-section, comments, strip off trailing ! 885: * spaces and newline character. ! 886: */ ! 887: for (p = cline; isspace(*p); ++p); ! 888: if (*p == NULL || *p == '#') ! 889: continue; ! 890: for (p = index(cline, '\0'); isspace(*--p);); ! 891: *++p = '\0'; ! 892: f = (struct filed *)calloc(1, sizeof(*f)); ! 893: *nextp = f; ! 894: nextp = &f->f_next; ! 895: cfline(cline, f); ! 896: } ! 897: ! 898: /* close the configuration file */ ! 899: (void) fclose(cf); ! 900: ! 901: Initialized = 1; ! 902: ! 903: if (Debug) { ! 904: for (f = Files; f; f = f->f_next) { ! 905: for (i = 0; i <= LOG_NFACILITIES; i++) ! 906: if (f->f_pmask[i] == INTERNAL_NOPRI) ! 907: printf("X "); ! 908: else ! 909: printf("%d ", f->f_pmask[i]); ! 910: printf("%s: ", TypeNames[f->f_type]); ! 911: switch (f->f_type) { ! 912: case F_FILE: ! 913: case F_TTY: ! 914: case F_CONSOLE: ! 915: printf("%s", f->f_un.f_fname); ! 916: break; ! 917: ! 918: case F_FORW: ! 919: printf("%s", f->f_un.f_forw.f_hname); ! 920: break; ! 921: ! 922: case F_USERS: ! 923: for (i = 0; i < MAXUNAMES && *f->f_un.f_uname[i]; i++) ! 924: printf("%s, ", f->f_un.f_uname[i]); ! 925: break; ! 926: } ! 927: printf("\n"); ! 928: } ! 929: } ! 930: ! 931: logmsg(LOG_SYSLOG|LOG_INFO, "syslogd: restart", LocalHostName, ADDDATE); ! 932: dprintf("syslogd: restarted\n"); ! 933: } ! 934: ! 935: /* ! 936: * Crack a configuration file line ! 937: */ ! 938: ! 939: cfline(line, f) ! 940: char *line; ! 941: register struct filed *f; ! 942: { ! 943: register char *p; ! 944: register char *q; ! 945: register int i; ! 946: char *bp; ! 947: int pri; ! 948: struct hostent *hp; ! 949: char buf[MAXLINE]; ! 950: ! 951: dprintf("cfline(%s)\n", line); ! 952: ! 953: errno = 0; /* keep strerror() stuff out of logerror messages */ ! 954: ! 955: /* clear out file entry */ ! 956: bzero((char *) f, sizeof *f); ! 957: for (i = 0; i <= LOG_NFACILITIES; i++) ! 958: f->f_pmask[i] = INTERNAL_NOPRI; ! 959: ! 960: /* scan through the list of selectors */ ! 961: for (p = line; *p && *p != '\t';) { ! 962: ! 963: /* find the end of this facility name list */ ! 964: for (q = p; *q && *q != '\t' && *q++ != '.'; ) ! 965: continue; ! 966: ! 967: /* collect priority name */ ! 968: for (bp = buf; *q && !index("\t,;", *q); ) ! 969: *bp++ = *q++; ! 970: *bp = '\0'; ! 971: ! 972: /* skip cruft */ ! 973: while (index(", ;", *q)) ! 974: q++; ! 975: ! 976: /* decode priority name */ ! 977: pri = decode(buf, prioritynames); ! 978: if (pri < 0) { ! 979: char xbuf[200]; ! 980: ! 981: (void) sprintf(xbuf, "unknown priority name \"%s\"", ! 982: buf); ! 983: logerror(xbuf); ! 984: return; ! 985: } ! 986: ! 987: /* scan facilities */ ! 988: while (*p && !index("\t.;", *p)) { ! 989: for (bp = buf; *p && !index("\t,;.", *p); ) ! 990: *bp++ = *p++; ! 991: *bp = '\0'; ! 992: if (*buf == '*') ! 993: for (i = 0; i < LOG_NFACILITIES; i++) ! 994: f->f_pmask[i] = pri; ! 995: else { ! 996: i = decode(buf, facilitynames); ! 997: if (i < 0) { ! 998: char xbuf[200]; ! 999: ! 1000: (void) sprintf(xbuf, ! 1001: "unknown facility name \"%s\"", ! 1002: buf); ! 1003: logerror(xbuf); ! 1004: return; ! 1005: } ! 1006: f->f_pmask[i >> 3] = pri; ! 1007: } ! 1008: while (*p == ',' || *p == ' ') ! 1009: p++; ! 1010: } ! 1011: ! 1012: p = q; ! 1013: } ! 1014: ! 1015: /* skip to action part */ ! 1016: while (*p == '\t') ! 1017: p++; ! 1018: ! 1019: switch (*p) ! 1020: { ! 1021: case '@': ! 1022: if (!InetInuse) ! 1023: break; ! 1024: (void) strcpy(f->f_un.f_forw.f_hname, ++p); ! 1025: hp = gethostbyname(p); ! 1026: if (hp == NULL) { ! 1027: extern int h_errno, h_nerr; ! 1028: extern char **h_errlist; ! 1029: ! 1030: logerror((u_int)h_errno < h_nerr ? ! 1031: h_errlist[h_errno] : "Unknown error"); ! 1032: break; ! 1033: } ! 1034: bzero((char *) &f->f_un.f_forw.f_addr, ! 1035: sizeof f->f_un.f_forw.f_addr); ! 1036: f->f_un.f_forw.f_addr.sin_family = AF_INET; ! 1037: f->f_un.f_forw.f_addr.sin_port = LogPort; ! 1038: bcopy(hp->h_addr, (char *) &f->f_un.f_forw.f_addr.sin_addr, hp->h_length); ! 1039: f->f_type = F_FORW; ! 1040: break; ! 1041: ! 1042: case '/': ! 1043: (void) strcpy(f->f_un.f_fname, p); ! 1044: if ((f->f_file = open(p, O_WRONLY|O_APPEND, 0)) < 0) { ! 1045: f->f_file = F_UNUSED; ! 1046: logerror(p); ! 1047: break; ! 1048: } ! 1049: if (isatty(f->f_file)) ! 1050: f->f_type = F_TTY; ! 1051: else ! 1052: f->f_type = F_FILE; ! 1053: if (strcmp(p, ctty) == 0) ! 1054: f->f_type = F_CONSOLE; ! 1055: break; ! 1056: ! 1057: case '*': ! 1058: f->f_type = F_WALL; ! 1059: break; ! 1060: ! 1061: default: ! 1062: for (i = 0; i < MAXUNAMES && *p; i++) { ! 1063: for (q = p; *q && *q != ','; ) ! 1064: q++; ! 1065: (void) strncpy(f->f_un.f_uname[i], p, UT_NAMESIZE); ! 1066: if ((q - p) > UT_NAMESIZE) ! 1067: f->f_un.f_uname[i][UT_NAMESIZE] = '\0'; ! 1068: else ! 1069: f->f_un.f_uname[i][q - p] = '\0'; ! 1070: while (*q == ',' || *q == ' ') ! 1071: q++; ! 1072: p = q; ! 1073: } ! 1074: f->f_type = F_USERS; ! 1075: break; ! 1076: } ! 1077: } ! 1078: ! 1079: ! 1080: /* ! 1081: * Decode a symbolic name to a numeric value ! 1082: */ ! 1083: ! 1084: decode(name, codetab) ! 1085: char *name; ! 1086: CODE *codetab; ! 1087: { ! 1088: register CODE *c; ! 1089: register char *p; ! 1090: char buf[40]; ! 1091: ! 1092: if (isdigit(*name)) ! 1093: return (atoi(name)); ! 1094: ! 1095: (void) strcpy(buf, name); ! 1096: for (p = buf; *p; p++) ! 1097: if (isupper(*p)) ! 1098: *p = tolower(*p); ! 1099: for (c = codetab; c->c_name; c++) ! 1100: if (!strcmp(buf, c->c_name)) ! 1101: return (c->c_val); ! 1102: ! 1103: return (-1); ! 1104: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.