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