![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to syslog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / aux|
Return to syslog.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / aux |
1.1 root 1: /*
2: ** SYSLOG -- log system messages
3: **
4: ** This program implements a system log, implemented as the
5: ** "/dev/log" mpx file on a pre-4.2bsd system or a port on
6: ** a post-4.2bsd system. This takes a series of lines.
7: ** Each line may have a priority, signified as "<n>" as
8: ** the first three characters of the line. If this is
9: ** not present, a default priority (DefPri) is used, which
10: ** starts out as LOG_ERROR. The default priority can get
11: ** changed using "<*>n".
12: **
13: ** Timestamps are added if they are not already present.
14: **
15: ** To kill syslog, send a signal 15 (terminate). In 30
16: ** seconds, syslog will go down. A signal 1 (hup) will
17: ** cause it to reread its configuration file.
18: **
19: ** Defined Constants:
20: ** MAXLINE -- the maximimum line length that can be
21: ** handled.
22: ** NLOGS -- the maximum number of simultaneous log
23: ** files.
24: ** NUSERS -- the maximum number of people that can
25: ** be designated as "superusers" on your system.
26: **
27: ** Author:
28: ** Eric Allman, UCB/INGRES and Britton-Lee.
29: */
30:
31: # define NLOGS 10 /* max number of log files */
32: # define NSUSERS 10 /* max number of special users */
33: # define MAXLINE 256 /* maximum line length */
34:
35: # define LOGHOSTNAME 1 /* log hostid on each line */
36:
37: # include <syslog.h>
38: # include <errno.h>
39: # include <stdio.h>
40: # include <utmp.h>
41: # include <ctype.h>
42: # include <sys/param.h>
43: # include <sys/stat.h>
44: # include <signal.h>
45: # include <sysexits.h>
46: # ifdef LOG_IPC
47: # include <sys/socket.h>
48: #ifndef LOG_OLDIPC
49: # include <netinet/in.h>
50: # include <netdb.h>
51: #else LOG_OLDIPC
52: # include <net/in.h>
53: #endif LOG_OLDIPC
54: # else LOG_IPC
55: # include <sys/mx.h>
56: # endif LOG_IPC
57:
58: typedef char bool;
59: # define TRUE 1
60: # define FALSE 0
61:
62: # ifdef EBUG
63: # define dprintf if (Debug) printf
64: # else
65: # define dprintf if (0) printf
66: # endif
67:
68: static char SccsId[] = "@(#)syslog.c 4.1 7/25/83";
69:
70: # define UNAMESZ 8 /* length of a login name */
71:
72: /*
73: ** This structure represents the files that will have log
74: ** copies printed.
75: */
76:
77: struct filed
78: {
79: char f_pmask; /* priority mask */
80: bool f_mark; /* if set, output timing marks */
81: bool f_tty; /* if set, this is a tty */
82: FILE *f_file; /* file descriptor; NULL means unallocated */
83: long f_time; /* the last time anything was output to it */
84: char f_name[30]; /* filename */
85: };
86:
87: struct filed Files[NLOGS];
88:
89: /* list of superusers */
90: char Susers[NSUSERS][UNAMESZ+1];
91:
92: int ShutDown; /* set if going down */
93: int DefPri = LOG_ERROR; /* the default priority for untagged msgs */
94: int Debug; /* debug flag */
95: int LogFile; /* log mx file descriptor */
96: int MarkIntvl = 15; /* mark interval in minutes */
97: char *ConfFile; /* configuration file */
98:
99: # ifdef LOG_IPC
100: #ifndef LOG_OLDIPC
101: struct sockaddr_in SyslogAddr;
102: #else LOG_OLDIPC
103: struct sockaddr_in SyslogAddr = { AF_INET, LOG_PORT };
104: struct sockproto SyslogProto = { PF_INET, IPPROTO_UDP };
105: #endif LOG_OLDIPC
106: # endif LOG_IPC
107:
108: main(argc, argv)
109: int argc;
110: char **argv;
111: {
112: register int i;
113: register char *p;
114: extern shutdown();
115: extern int domark();
116: extern int errno;
117: int errct = 0;
118: FILE *fp;
119: char *logname = "/dev/log";
120: #ifndef LOG_OLDIPC
121: #ifdef LOG_IPC
122: auto int lenSyslogAddr;
123: struct servent *sp;
124: struct hostent *hp;
125: #endif LOG_IPC
126: #endif LOG_OLDIPC
127: static char *defconf = "/etc/syslog.conf";
128: static char *defpid = "/etc/syslog.pid";
129: char line[300];
130:
131: #ifndef LOG_OLDIPC
132: #ifdef LOG_IPC
133: /* set up initial port assignment */
134: sp = getservbyname("syslog", "udp");
135: if (sp == NULL)
136: {
137: perror("Cannot get server");
138: exit(EX_OSFILE);
139: }
140: SyslogAddr.sin_family = AF_INET;
141: SyslogAddr.sin_port = sp->s_port;
142: SyslogAddr.sin_addr.s_addr = INADDR_ANY;
143: #endif LOG_IPC
144:
145: #endif LOG_OLDIPC
146: while (--argc > 0)
147: {
148: p = *++argv;
149: if (p[0] == '-')
150: {
151: switch (p[1])
152: {
153: case 'm': /* set mark interval */
154: MarkIntvl = atoi(&p[2]);
155: if (MarkIntvl <= 0)
156: MarkIntvl = 1;
157: break;
158:
159: case 'f': /* configuration file */
160: if (p[2] != '\0')
161: ConfFile = &p[2];
162: else
163: ConfFile = defconf;
164: break;
165:
166: case 'd': /* debug */
167: Debug++;
168: if (ConfFile == NULL)
169: ConfFile = "./syslog.conf";
170: break;
171:
172: # ifdef LOG_IPC
173: case 'p': /* port */
174: SyslogAddr.sin_port = htons(atoi(&p[2]));
175: break;
176: # endif LOG_IPC
177: }
178: }
179: }
180:
181: if (ConfFile == NULL)
182: ConfFile = defconf;
183:
184: /* try to ignore all signals */
185: if (!Debug)
186: {
187: for (i = 1; i < NSIG; i++)
188: signal(i, SIG_IGN);
189: }
190: else
191: signal(SIGINT, shutdown);
192: signal(SIGTERM, shutdown);
193: signal(SIGALRM, domark);
194: alarm(MarkIntvl*60);
195:
196: /* close all files */
197: if (!Debug)
198: for (i = 0; i < NOFILE; i++)
199: close(i);
200:
201: # ifdef LOG_IPC
202: logname = "IPC socket";
203: #ifndef LOG_OLDIPC
204: LogFile = socket(AF_INET, SOCK_DGRAM, 0, 0);
205: if (LogFile >= 0 && bind(LogFile, &SyslogAddr, sizeof SyslogAddr, 0) < 0)
206: {
207: close(LogFile);
208: LogFile = -1;
209: }
210: #else LOG_OLDIPC
211: LogFile = socket(SOCK_DGRAM, &SyslogProto, &SyslogAddr, 0);
212: #endif LOG_OLDIPC
213: # else LOG_IPC
214: /* create the "/dev/log" device */
215: if (Debug)
216: logname = "log";
217: unlink(logname);
218: LogFile = mpx(logname, 0222);
219: chmod(logname, 0222);
220: # endif LOG_IPC
221: if (LogFile < 0)
222: {
223: fp = fopen("/dev/console", "w");
224: fprintf(fp, "\r\nsyslog: cannot create %s (%d)\r\n", logname, errno);
225: dprintf("cannot create %s (%d)\n", logname, errno);
226: exit(EX_OSFILE);
227: }
228:
229: /* now we can run as daemon safely */
230: setuid(1);
231: dprintf("off & running....\n");
232: if (!Debug)
233: {
234: if (fork() == 0)
235: {
236: /* tuck my process id away */
237: fp = fopen(defpid, "w");
238: if (fp != NULL)
239: {
240: fprintf(fp, "%d\n", getpid());
241: fclose(fp);
242: }
243: }
244: else
245: exit(0);
246: }
247:
248: init();
249:
250: for (;;)
251: {
252: # ifdef LOG_IPC
253: #ifndef LOG_OLDIPC
254: lenSyslogAddr = sizeof SyslogAddr;
255: i = recvfrom(LogFile, line, sizeof line, 0, &SyslogAddr, &lenSyslogAddr);
256: #else LOG_OLDIPC
257: i = receive(LogFile, &SyslogAddr, line, sizeof line);
258: #endif LOG_OLDIPC
259: # else LOG_IPC
260: i = read(LogFile, line, sizeof line);
261: # endif LOG_IPC
262: if (i < 0)
263: {
264: if (errno == EINTR)
265: continue;
266: logerror("read");
267: errct++;
268: if (errct > 1000)
269: {
270: logmsg(LOG_SALERT, "syslog: too many errors");
271: die();
272: }
273: sleep(15);
274: continue;
275: }
276: # ifdef LOG_IPC
277: line[i] = '\0';
278: hp = gethostbyaddr(&SyslogAddr.sin_addr,
279: sizeof (SyslogAddr.sin_addr), AF_INET);
280: if (hp == 0)
281: printline(line, inet_ntoa(SyslogAddr.sin_addr));
282: else
283: printline(line, hp->h_name);
284: # else LOG_IPC
285: crack(line, i);
286: # endif LOG_IPC
287: }
288: }
289: /*
290: ** LOGERROR -- log an error on the log.
291: **
292: ** Parameters:
293: ** type -- string to print as error type.
294: **
295: ** Returns:
296: ** none.
297: **
298: ** Side Effects:
299: ** outputs the error code in errno to someplace.
300: */
301:
302: logerror(type)
303: char *type;
304: {
305: char buf[50];
306: extern int errno;
307:
308: sprintf(buf, "log %s error %d\n", type, errno);
309: errno = 0;
310: logmsg(LOG_SALERT, buf);
311: }
312:
313: # ifndef LOG_IPC
314:
315: /*
316: ** CRACK -- parse & handle a log line
317: **
318: ** Parameters:
319: ** rec -- the input record.
320: ** bc -- the byte count for rec.
321: **
322: ** Returns:
323: ** nothing
324: **
325: ** Side Effects:
326: ** rec is output.
327: */
328:
329: # define skip(rec, n) ((struct rh *) (((char *) rec) + n))
330:
331: crack(rec, bc)
332: register struct rh *rec;
333: int bc;
334: {
335: struct rh *endrec;
336:
337: endrec = skip(rec, bc);
338:
339: while (rec < endrec)
340: {
341: if (rec->count == 0)
342: {
343: /* control record from mpx file */
344: dprintf("%d byte control message\n", rec->ccount);
345: control(rec);
346: }
347: else
348: {
349: /* data record -- process message */
350: messg(rec);
351: }
352: rec->count += rec->ccount;
353: if (rec->count & 01)
354: rec->count++;
355: rec = skip(rec, rec->count + sizeof *rec);
356: }
357: }
358: /*
359: ** CONTROL -- handle mpx control messages.
360: **
361: ** Parameters:
362: ** rec -- control message.
363: **
364: ** Returns:
365: ** none.
366: **
367: ** Side Effects:
368: ** as necessary for that control message.
369: */
370:
371: short NoIoctl[] = { M_IOANS };
372:
373: control(rec)
374: register struct rh *rec;
375: {
376: register int cmd;
377: register short val;
378: register short *ap;
379: # ifdef MPXDEBUG
380: char dbbuf[100];
381: # endif MPXDEBUG
382:
383: ap = (short *) (((char *) rec) + sizeof *rec);
384: cmd = *ap++ & 0377;
385: val = *ap++;
386: # ifdef MPXDEBUG
387: sprintf(dbbuf, "syslog: ctl ch=%x cmd=%d val=%d", rec->index, cmd, val);
388: logmsg(LOG_DEBUG, dbbuf);
389: # endif MPXDEBUG
390:
391: switch (cmd)
392: {
393: case M_WATCH: /* attempted connect; value is uid */
394: dprintf("WATCH, uid=%d\n", val);
395: attach(rec->index, LogFile);
396: break;
397:
398: case M_CLOSE: /* close channel; value is unused */
399: dprintf("CLOSE, val=%d\n", val);
400: detach(rec->index, LogFile);
401: break;
402:
403: case M_IOCTL:
404: dprintf("IOCTL, val=%d\n", val);
405: wmpxctl(rec->index, NoIoctl, sizeof NoIoctl);
406: break;
407:
408: default:
409: dprintf("unknown cmd %d, val=%d\n", cmd, val);
410: break;
411: }
412: }
413: /*
414: ** WMPXCTL -- write mpx control message
415: **
416: ** Parameters:
417: ** index -- index to write to.
418: ** buf -- place to write.
419: ** len -- length to write.
420: **
421: ** Returns:
422: ** none.
423: **
424: ** Side Effects:
425: ** writes to LogFile.
426: */
427:
428: wmpxctl(index, buf, cnt)
429: int index;
430: char *buf;
431: int cnt;
432: {
433: struct wh wbuf;
434:
435: wbuf.index = index;
436: wbuf.count = 0;
437: wbuf.ccount = cnt;
438: wbuf.data = buf;
439: write(LogFile, &wbuf, sizeof wbuf);
440: }
441: /*
442: ** MESSG -- log message
443: **
444: ** Parameters:
445: ** rec -- record of data.
446: **
447: ** Returns:
448: ** nothing.
449: **
450: ** Side Effects:
451: ** sends the record to the system log.
452: */
453:
454: messg(rec)
455: register struct rh *rec;
456: {
457: char endchar;
458: char *endptr;
459: register char *q;
460:
461: q = (char *) rec + sizeof *rec;
462: endptr = &q[rec->count];
463: endchar = *endptr;
464: *endptr = '\0';
465: printline(q, NULL);
466: *endptr = endchar;
467: }
468:
469: # endif LOG_IPC
470: /*
471: ** PRINTLINE -- print one line
472: **
473: ** This is really it -- we have one line -- we crack it and
474: ** and print it appropriately.
475: **
476: ** Parameters:
477: ** q -- pointer to the line.
478: ** tag -- the name of the host this is from.
479: **
480: ** Returns:
481: ** none.
482: **
483: ** Side Effects:
484: ** q is broken up and printed.
485: */
486:
487: printline(q, tag)
488: register char *q;
489: {
490: register int i;
491: static int pri;
492: register char *p;
493: static char buf[1000];
494: static char *bp = buf;
495:
496: dprintf("message = ``%s''\n", q);
497: while (*q != '\0')
498: {
499: if (bp == buf)
500: {
501: # if LOGHOSTNAME > 0
502: if (tag != NULL)
503: {
504: strcpy(bp, tag);
505: strcat(bp, ": ");
506: bp += strlen(bp);
507: }
508: # endif LOGHOSTNAME
509:
510: /* test for special codes */
511: pri = DefPri;
512: if (q[0] == '<' && q[2] == '>')
513: {
514: switch (q[1])
515: {
516: case '*': /* reset default message priority */
517: dprintf("default priority = %c\n", q[3]);
518: i = q[3] - '0';
519: if (i > 0 && i <= 9)
520: DefPri = i;
521: continue;
522:
523: case '$': /* reconfigure */
524: dprintf("reconfigure\n");
525: init();
526: continue;
527: }
528: q++;
529: pri = *q++ - '0';
530: q++;
531: if (pri < 0 || pri > 9)
532: pri = DefPri;
533: }
534: else
535: pri = DefPri;
536: }
537: while (*q != '\0' && *q != '\n')
538: {
539: if (*q != '\r')
540: *bp++ = *q;
541: q++;
542: }
543: if (*q == '\0')
544: continue;
545: *bp++ = '\0';
546: q++;
547: bp = buf;
548:
549: /* output the line to all files */
550: logmsg(pri, bp);
551: bp = buf;
552: }
553: }
554: /*
555: ** SHUTDOWN -- shutdown the logger
556: **
557: ** This should only be done when the system is going down.
558: **
559: ** Parameters:
560: ** none
561: **
562: ** Returns:
563: ** none
564: **
565: ** Side Effects:
566: ** Starts up an alarm clock, to let other things
567: ** happen. Alarm clock will call "die".
568: **
569: ** Called By:
570: ** main
571: ** signal 15 (terminate)
572: */
573:
574: shutdown()
575: {
576: extern die();
577:
578: logmsg(LOG_CRIT, "syslog: shutdown within 30 seconds\n");
579: ShutDown++;
580: signal(SIGALRM, die);
581: alarm(30);
582: signal(SIGTERM, die);
583: if (Debug)
584: signal(SIGINT, die);
585: }
586: /*
587: ** DIE -- really die.
588: **
589: ** Parameters:
590: ** none
591: **
592: ** Returns:
593: ** never
594: **
595: ** Side Effects:
596: ** Syslog dies.
597: **
598: ** Requires:
599: ** exit (sys)
600: **
601: ** Called By:
602: ** alarm clock (signal 14)
603: */
604:
605: die()
606: {
607: alarm(0);
608: logmsg(LOG_CRIT, "syslog: down\n");
609: sleep(2); /* wait for output to drain */
610: # ifndef LOG_IPC
611: if (!Debug)
612: unlink("/dev/log");
613: # endif LOG_IPC
614: sync();
615: exit(0);
616: }
617: /*
618: ** STAMPED -- tell if line is already time stamped.
619: **
620: ** Accepts time stamps of the form "Sep 13 00:15:17".
621: ** Currently just looks for blanks and colons.
622: **
623: ** Parameters:
624: ** l -- the line to check.
625: **
626: ** Returns:
627: ** nonzero -- if the line is time stamped.
628: ** zero -- otherwise.
629: **
630: ** Side Effects:
631: ** none.
632: */
633:
634: stamped(l)
635: register char *l;
636: {
637: register int i;
638:
639: /* timestamps are at least 15 bytes long */
640: for (i = 0; i < 15; i++)
641: if (l[i] == '\0')
642: return (0);
643:
644: /* and they have blanks & colons in well-known places */
645: if (l[3] != ' ' || l[6] != ' ' || l[9] != ':' || l[12] != ':')
646: return (0);
647: return (1);
648: }
649: /*
650: ** LOGMSG -- log a message to the outputs
651: **
652: ** Arranges to get the message to the correct places
653: ** based on the priority of the message. A timestamp
654: ** is prepended to the message if one does not already
655: ** exist.
656: **
657: ** Parameters:
658: ** pri -- the message priority.
659: ** msg -- the message to be logged.
660: **
661: ** Returns:
662: ** none
663: **
664: ** Side Effects:
665: ** possibly messages to all users, or just specific
666: ** users.
667: */
668:
669: logmsg(pri, msg)
670: int pri;
671: char *msg;
672: {
673: register char *m;
674: register char *p;
675: register struct filed *f;
676: register int l;
677: register int i;
678: char buf[MAXLINE+2];
679: auto int st;
680: auto long now;
681: extern char *ctime();
682: extern int errno;
683:
684: p = buf;
685: l = MAXLINE;
686:
687: /* output a time stamp if one is not already there */
688: time(&now);
689: if (!stamped(msg))
690: {
691: m = &ctime(&now)[4];
692: for (i = 16; i > 0; i--)
693: *p++ = *m++;
694: l -= 16;
695: }
696:
697: /* find the end of the message */
698: for (m = msg; *m != '\0' &&l -- >= 0; )
699: *p++ = *m++;
700: if (*--m != '\n')
701: *p++ = '\n';
702:
703: /* log the message to the particular outputs */
704: for (i = 0; i < NLOGS; i++)
705: {
706: f = &Files[i];
707: if (f->f_file == NULL)
708: continue;
709: if (pri < 0)
710: {
711: if (!f->f_mark || f->f_time + MarkIntvl*60 > now)
712: continue;
713: }
714: else if (f->f_pmask < pri)
715: continue;
716: fseek(f->f_file, 0L, 2);
717: errno = 0;
718: fwrite(buf, p - buf, 1, f->f_file);
719: if (f->f_tty)
720: fwrite("\r", 1, 1, f->f_file);
721: f->f_time = now;
722: fflush(f->f_file);
723: if (ferror(f->f_file))
724: {
725: char namebuf[40];
726:
727: fclose(f->f_file);
728: f->f_file = NULL;
729: sprintf(namebuf, "write %s", f->f_name);
730: logerror(namebuf);
731: }
732: }
733:
734: /* let's be paranoid.... */
735: sync();
736:
737: /*
738: ** Output alert and subalert priority messages to terminals.
739: **
740: ** We double fork here so that we can continue. Our
741: ** child will fork again and die; we wait for him.
742: ** Then process one inherits our grandchildren, we
743: ** can run off and have a good time. Our grandchild
744: ** actually tries to do the writing (by calling
745: ** wallmsg).
746: **
747: ** Anything go wrong? -- just give up.
748: */
749:
750: if (pri <= LOG_SALERT && pri > 0)
751: {
752: if (fork() == 0)
753: {
754: if (fork() == 0)
755: {
756: wallmsg(pri == LOG_ALERT, buf, p - buf);
757: exit(0);
758: }
759: else
760: exit(0);
761: }
762: else
763: while (wait(&st) >= 0)
764: continue;
765: }
766: }
767: /*
768: ** INIT -- Initialize syslog from configuration table
769: **
770: ** The configuration table consists of a series of lines
771: ** broken into two sections by a blank line. The first
772: ** section gives a list of files to log on. The first
773: ** character is a digit which is the priority mask for
774: ** that file. If the second digit is an asterisk, then
775: ** syslog arranges for something to be printed every fifteen
776: ** minutes (even if only a null line), so that crashes and
777: ** other events can be localized. The rest of the line is
778: ** the pathname of the log file. The second section is
779: ** a list of user names; these people are all notified
780: ** when subalert messages occur (if they are logged on).
781: **
782: ** The configuration table will be reread by this routine
783: ** if a signal 1 occurs; for that reason, it is tricky
784: ** about not re-opening files and closing files it will
785: ** not be using.
786: **
787: ** Parameters:
788: ** none
789: **
790: ** Returns:
791: ** none
792: **
793: ** Side Effects:
794: ** 'Files' and 'Susers' are (re)initialized.
795: */
796:
797: init()
798: {
799: register int i;
800: register FILE *cf;
801: char cline[40];
802: register struct filed *f;
803: register char *p;
804: int mark;
805: int pmask;
806:
807: dprintf("init\n");
808:
809: /* ignore interrupts during this routine */
810: signal(SIGHUP, SIG_IGN);
811: logmsg(LOG_INFO, "reinitializing\n");
812:
813: /* open the configuration file */
814: if ((cf = fopen(ConfFile, "r")) == NULL)
815: {
816: dprintf("cannot open %s\n", ConfFile);
817: return;
818: }
819:
820: /*
821: ** Close all open files.
822: */
823:
824: for (f = Files; f < &Files[NLOGS]; f++)
825: {
826: if (f->f_file != NULL)
827: fclose(f->f_file);
828: f->f_file = NULL;
829: }
830:
831: /*
832: ** Foreach line in the conf table, open that file.
833: */
834:
835: f = Files;
836: while (fgets(cline, sizeof cline, cf) != NULL)
837: {
838: dprintf("F: got line >%s<\n", cline, 0);
839: /* check for end-of-section */
840: if (cline[0] == '\n')
841: break;
842:
843: /* strip off possible newline character */
844: for (p = cline; *p != '\0' && *p != '\n'; p++)
845: continue;
846: *p = '\0';
847:
848: /* extract priority mask and mark flag */
849: p = cline;
850: mark = FALSE;
851: pmask = *p++ - '0';
852: if (*p == '*')
853: {
854: p++;
855: mark = TRUE;
856: }
857:
858: /* insure that it is null-terminated */
859: p[sizeof Files[0].f_name - 1] = '\0';
860:
861: if (f >= &Files[NLOGS])
862: continue;
863:
864: /* mark entry as used and update flags */
865: strcpy(f->f_name, p);
866: f->f_file = fopen(p, "a");
867: f->f_time = 0;
868: f->f_pmask = pmask;
869: f->f_mark = mark;
870: f->f_tty = isatty(fileno(f->f_file));
871: dprintf("File %s pmask %d mark %d tty %d\n", p, pmask, mark, f->f_tty);
872: f++;
873: }
874:
875: /*
876: ** Read the list of users.
877: **
878: ** Anyone in this list is informed directly if s/he
879: ** is logged in when a "subalert" or higher priority
880: ** message comes through.
881: **
882: ** Out with the old order, in with the new.
883: */
884:
885: for (i = 0; i < NSUSERS && fgets(cline, sizeof cline, cf) != NULL; i++)
886: {
887: /* strip off newline */
888: for (p = cline; *p != '\0' && *p != '\n'; p++)
889: continue;
890: *p = '\0';
891: cline[8] = '\0';
892: strcpy(Susers[i], cline, 8);
893: }
894:
895: /* zero the rest of the old superusers */
896: for (; i < NSUSERS; i++)
897: Susers[i][0] = '\0';
898:
899: /* close the configuration file */
900: fclose(cf);
901:
902: logmsg(LOG_INFO, "syslog restart\n");
903:
904: /* arrange for signal 1 to reconfigure */
905: signal(SIGHUP, init);
906: }
907: /*
908: ** WALLMSG -- Write a message to the world at large
909: **
910: ** This writes the specified message to either the entire
911: ** world, or at least a list of approved users.
912: **
913: ** It scans the utmp file. For each user logged in, it
914: ** checks to see if the user is on the approved list, or if
915: ** this is an "alert" priority message. In either case,
916: ** it opens a line to that typewriter (unless mesg permission
917: ** is denied) and outputs the message to that terminal.
918: **
919: ** Parameters:
920: ** toall -- if non-zero, writes the message to everyone.
921: ** msg -- the message to write.
922: ** len -- the length of the message.
923: **
924: ** Returns:
925: ** none
926: **
927: ** Side Effects:
928: ** none
929: **
930: ** Requires:
931: ** open(sys)
932: ** read(sys)
933: ** write(sys)
934: ** fstat(sys)
935: ** strcmp(sys)
936: ** fork(sys)
937: ** sleep(sys)
938: ** exit(sys)
939: ** close(sys)
940: **
941: ** Called By:
942: ** logmsg
943: */
944:
945: wallmsg(toall, msg, len)
946: int toall;
947: char *msg;
948: int len;
949: {
950: struct utmp ut;
951: register int i;
952: register char *p;
953: int uf;
954: struct stat statbuf;
955: auto long t;
956: extern char *ctime();
957: char sbuf[1024];
958: #ifdef LOG_IPC
959: extern char *gethostname();
960: char hbuf[32];
961: auto int hlen;
962: #endif LOG_IPC
963:
964: /* open the user login file */
965: uf = open("/etc/utmp", 0);
966: if (uf < 0)
967: return;
968:
969: /* scan the user login file */
970: while (read(uf, &ut, sizeof ut) == sizeof ut)
971: {
972: /* is this slot used? */
973: if (ut.ut_name[0] == '\0')
974: continue;
975:
976: /* if not "alert", check if this user is super */
977: if (!toall)
978: {
979: for (i = 0; i < NSUSERS; i++)
980: {
981: if (namecheck(Susers[i], ut.ut_name))
982: break;
983: }
984: if (i >= NSUSERS)
985: {
986: /* nope, just a serf */
987: continue;
988: }
989: }
990:
991: /* fork so that the open can't hang us */
992: if (fork() != 0)
993: continue;
994: sleep(1);
995:
996: /* compute the device name */
997: # ifdef V6
998: p = "/dev/ttyx";
999: p[8] = ut.ut_tty;
1000: # else
1001: p = "/dev/12345678";
1002: strcpyn(&p[5], ut.ut_line, 8);
1003: # endif
1004:
1005: /* open the terminal */
1006: i = open(p, 1);
1007: if (i < 0)
1008: exit(1);
1009:
1010: /* does he have write permission? */
1011: if (fstat(i, &statbuf) < 0 || (statbuf.st_mode & 02) == 0)
1012: {
1013: /* no, just pass him by */
1014: dprintf("Drop user, mode=%o\n", statbuf.st_mode, 0);
1015: close(i);
1016: exit(0);
1017: }
1018:
1019: /* yes, output the message */
1020: time(&t);
1021: strcpy(sbuf, "\r\n\007Broadcast message from ");
1022: #ifdef LOG_IPC
1023: strcat(sbuf, "syslog@");
1024: hlen = sizeof hbuf;
1025: gethostname(hbuf, &hlen);
1026: strcat(sbuf, hbuf);
1027: #else LOG_IPC
1028: strcat(sbuf, sysname);
1029: strcat(sbuf, "!syslog");
1030: #endif LOG_IPC
1031: strcat(sbuf, " at ");
1032: strncat(sbuf, ctime(&t), 24);
1033: strcat(sbuf, "...\r\n");
1034: write(i, sbuf, strlen(sbuf));
1035: p = sbuf;
1036: while (len-- > 0)
1037: {
1038: *msg &= 0177;
1039: if (iscntrl(*msg))
1040: {
1041: *p++ = '^';
1042: *p++ = *msg++ ^ 0100;
1043: }
1044: else
1045: *p++ = *msg++;
1046: }
1047: strcpy(p, "\r\n");
1048: write(i, sbuf, strlen(sbuf));
1049:
1050: /* all finished! go away */
1051: exit(0);
1052: }
1053:
1054: /* close the user login file */
1055: close(uf);
1056: }
1057: /*
1058: ** CHECKNAME -- Do an equality comparison on names.
1059: **
1060: ** Does right blank padding.
1061: **
1062: ** Parameters:
1063: ** a, b -- pointers to the names to check.
1064: **
1065: ** Returns:
1066: ** 1 if equal
1067: ** 0 otherwise.
1068: **
1069: ** Side Effects:
1070: ** none
1071: **
1072: ** Requires:
1073: ** none
1074: **
1075: ** Called By:
1076: ** wallmsg
1077: */
1078:
1079: namecheck(a, b)
1080: register char *a, *b;
1081: {
1082: register int i;
1083:
1084: for (i = 0; i < 8; i++)
1085: {
1086: if (*a != *b)
1087: {
1088: if (!((*a == ' ' && *b == '\0') || (*a == '\0' && *b == ' ')))
1089: return (0);
1090: }
1091: if (*a != ' ' && *a != '\0')
1092: a++;
1093: if (*b != ' ' && *b != '\0')
1094: b++;
1095: }
1096: return (1);
1097: }
1098: /*
1099: ** DOMARK -- Make sure every marked file gets output every 15 minutes
1100: **
1101: ** Just calls "logmsg" with a negative priority every time it
1102: ** gets called.
1103: **
1104: ** Algorithm:
1105: ** create timestamp.
1106: ** call logmsg.
1107: **
1108: ** Parameters:
1109: ** none
1110: **
1111: ** Returns:
1112: ** none
1113: **
1114: ** Side Effects:
1115: ** sets the alarm clock to call itself after MarkIntvl
1116: ** minutes.
1117: **
1118: ** Requires:
1119: ** logmsg
1120: **
1121: ** Called By:
1122: ** system alarm clock.
1123: ** init
1124: */
1125:
1126: domark()
1127: {
1128: auto long t;
1129: extern char *ctime();
1130: register char *p;
1131: register char *q;
1132: char buf[40];
1133:
1134: alarm(0);
1135: dprintf("domark\n");
1136: time(&t);
1137: q = buf;
1138: for (p = " --- MARK --- "; (*q++ = *p++) != '\0'; )
1139: continue;
1140: q--;
1141: for (p = ctime(&t); (*q++ = *p++) != '\0'; )
1142: continue;
1143: logmsg(-1, buf);
1144: signal(SIGALRM, domark);
1145: alarm(MarkIntvl*60);
1146: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.