1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include <sys/types.h>
42: #include <sys/param.h>
43: #include <sys/socket.h>
44: #include <sys/uio.h>
45: #include <sys/queue.h>
46:
47: #include <netinet/in.h>
48:
49: #include <stdlib.h>
50: #include <stddef.h>
51: #include <stdio.h>
52: #include <syslog.h>
53: #include <assert.h>
54: #include <string.h>
55: #include <stdarg.h>
56: #include <unistd.h>
57: #include <fcntl.h>
58: #include <errno.h>
59: #include <regex.h>
60: #include <pthread.h>
61:
62: #include "structs/structs.h"
63: #include "structs/type/array.h"
64: #include "structs/type/int.h"
65: #include "structs/type/ip4.h"
66: #include "structs/type/pointer.h"
67: #include "structs/type/string.h"
68: #include "structs/type/struct.h"
69: #include "structs/type/time.h"
70: #include "sys/alog.h"
71: #include "sys/logfile.h"
72: #include "util/typed_mem.h"
73:
74: /* Memory allocation types */
75: #define MEM_TYPE "alog"
76: #define MEM_TYPE_ENTRY "alog_entry"
77: #define MEM_TYPE_HISTORY "alog_history"
78: #define MEM_TYPE_CURCHAN "alog_curchan"
79:
80: /* Last message timeout functions */
81: #define LASTMSG_TIMEOUT_INITIAL 5
82: #define LASTMSG_TIMEOUT_1(t, d) ((t) + (d) + 1 / 2)
83: #define LASTMSG_TIMEOUT_2(t, d) ((t) + (d) + 1 / 2)
84: #define LASTMSG_TIMEOUT_3(t) (t)
85:
86: #define LASTMSG_REPEATED_FMT "last message repeated %u times"
87:
88: /* Misc defs */
89: #define SYSLOG_PORT 514 /* syslogd udp port */
90: #define MAX_NAME 64 /* max identifier length */
91: #define EST_ENTRY_SIZE 100 /* estimated avg. size per entry */
92:
93: enum alog_type {
94: ALOG_NONE = 0, /* not initialized */
95: ALOG_NULL, /* log to nowhere */
96: ALOG_STDERR, /* log to stderr */
97: ALOG_SYSLOG_LOCAL, /* log to local machine syslog */
98: ALOG_SYSLOG_REMOTE /* log to remote machine syslog */
99: };
100:
101: /* Current alog channel (thread-specific variable) */
102: struct alog_curchan {
103: int channel;
104: };
105:
106: /* Stolen from syslog.h */
107: struct nameval {
108: const char *name;
109: int val;
110: };
111:
112: /* 'Last message' state for a channel */
113: struct alog_lastmsg {
114: char *msg; /* previously logged message */
115: int sev; /* severity for 'msg' */
116: time_t when; /* timestamp for 'msg' */
117: u_int repeat; /* number of unlogged repeats */
118: u_int timeout; /* timeout for logging repeat */
119: time_t timer_expiry; /* timer running & expiry */
120: };
121:
122: /* Structure describing one channel */
123: struct alog_channel {
124: char name[MAX_NAME]; /* local syslog(3) identifier */
125: struct logfile *logfile; /* history logfile, or NULL */
126: enum alog_type type; /* channel configuration type */
127: int sock; /* remote syslog(3) socket */
128: int facility; /* channel facility */
129: int min_severity; /* min channel severity */
130: u_char debug; /* debug enabled flag */
131: pthread_mutex_t mutex; /* mutex, if not ALOG_NONE */
132: struct alog_lastmsg last; /* 'last message' info */
133: };
134:
135: /*
136: * Internal variables
137: */
138: static struct alog_channel alog_channels[ALOG_MAX_CHANNELS];
139: static pthread_key_t alog_current_channel;
140:
141: /* Stolen from syslog.h */
142: static struct nameval prioritynames[] = {
143: { "alert", LOG_ALERT, },
144: { "crit", LOG_CRIT, },
145: { "debug", LOG_DEBUG, },
146: { "emerg", LOG_EMERG, },
147: { "err", LOG_ERR, },
148: { "error", LOG_ERR, }, /* DEPRECATED */
149: { "info", LOG_INFO, },
150: { "notice", LOG_NOTICE, },
151: { "panic", LOG_EMERG, }, /* DEPRECATED */
152: { "warn", LOG_WARNING, }, /* DEPRECATED */
153: { "warning", LOG_WARNING, },
154: { NULL, -1, }
155: };
156:
157: /* Stolen from syslog.h */
158: static struct nameval facilitynames[] = {
159: { "auth", LOG_AUTH, },
160: { "authpriv", LOG_AUTHPRIV, },
161: { "cron", LOG_CRON, },
162: { "daemon", LOG_DAEMON, },
163: { "ftp", LOG_FTP, },
164: { "kern", LOG_KERN, },
165: { "lpr", LOG_LPR, },
166: { "mail", LOG_MAIL, },
167: { "news", LOG_NEWS, },
168: #ifdef LOG_NTP
169: { "ntp", LOG_NTP, },
170: #endif
171: #ifdef LOG_SECURITY
172: { "security", LOG_SECURITY, },
173: #endif
174: { "syslog", LOG_SYSLOG, },
175: { "user", LOG_USER, },
176: { "uucp", LOG_UUCP, },
177: { "local0", LOG_LOCAL0, },
178: { "local1", LOG_LOCAL1, },
179: { "local2", LOG_LOCAL2, },
180: { "local3", LOG_LOCAL3, },
181: { "local4", LOG_LOCAL4, },
182: { "local5", LOG_LOCAL5, },
183: { "local6", LOG_LOCAL6, },
184: { "local7", LOG_LOCAL7, },
185: { NULL, -1, }
186: };
187:
188: /*
189: * Internal functions
190: */
191: static void alog_write(struct alog_channel *ch,
192: int sev, time_t when, const char *msg);
193: static void alog_flush_lastmsg(struct alog_channel *ch, u_int timeout);
194: static void alog_last_check(struct alog_channel *ch);
195: static int alog_get_channel(void);
196: static struct alog_curchan *alog_get_current_channel(int create);
197: static void alog_init_current_channel(void);
198: static void alog_curchan_destroy(void *arg);
199:
200: /*
201: * Initialize or reconfigure a logging channel.
202: */
203: int
204: alog_configure(int channel, const struct alog_config *conf)
205: {
206: struct alog_channel *const ch = &alog_channels[channel];
207: struct sockaddr_in sin;
208: int init_mutex = 0;
209: int esave;
210: int debug;
211:
212: /* Sanity check */
213: if (channel < 0 || channel >= ALOG_MAX_CHANNELS) {
214: errno = EINVAL;
215: return (-1);
216: }
217:
218: /* If already initialized, shut it down */
219: if (ch->type != ALOG_NONE)
220: alog_shutdown(channel);
221:
222: /* Initialize channel */
223: debug = ch->debug;
224: memset(ch, 0, sizeof(*ch));
225: ch->sock = -1;
226: ch->debug = debug;
227: if (conf->name != NULL)
228: strlcpy(ch->name, conf->name, sizeof(ch->name));
229: ch->facility = (ch->debug || conf->facility == NULL) ?
230: -1 : alog_facility(conf->facility);
231: ch->min_severity = conf->min_severity;
232:
233: /* Open logfile */
234: if (conf->histlen > 0) {
235: if ((ch->logfile = logfile_open(conf->path, 0,
236: conf->histlen, conf->histlen * EST_ENTRY_SIZE)) == NULL)
237: goto fail;
238: }
239:
240: /* Initialize mutex */
241: if ((errno = pthread_mutex_init(&ch->mutex, NULL)) != 0)
242: goto fail;
243: init_mutex = 1;
244:
245: /* Handle stderr case */
246: if (ch->facility == -1) {
247: ch->type = ALOG_STDERR;
248: return (0);
249: }
250:
251: /* Handle NULL case */
252: if (conf->name == NULL) {
253: ch->type = ALOG_NULL;
254: return (0);
255: }
256:
257: /* Handle local syslog case */
258: if (conf->remote_server.s_addr == 0) {
259: ch->type = ALOG_SYSLOG_LOCAL;
260: return (0);
261: }
262:
263: /* Handle remote syslog case */
264: if ((ch->sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
265: goto fail;
266: (void)fcntl(ch->sock, F_SETFD, 1);
267: if (shutdown(ch->sock, SHUT_RD) == -1)
268: goto fail;
269: memset(&sin, 0, sizeof(sin));
270: #ifndef __linux__
271: sin.sin_len = sizeof(sin);
272: #endif
273: sin.sin_family = AF_INET;
274: sin.sin_port = htons(SYSLOG_PORT);
275: sin.sin_addr = conf->remote_server;
276: if (connect(ch->sock, (struct sockaddr *)&sin, sizeof(sin)) == -1)
277: goto fail;
278: ch->type = ALOG_SYSLOG_REMOTE;
279: return (0);
280:
281: fail:
282: /* Clean up after failure */
283: esave = errno;
284: logfile_close(&ch->logfile); /* ok if null */
285: if (ch->sock != -1) {
286: (void)close(ch->sock);
287: ch->sock = -1;
288: }
289: if (init_mutex)
290: pthread_mutex_destroy(&ch->mutex);
291: errno = esave;
292: return (-1);
293: }
294:
295: /*
296: * Shutdown one logging channel.
297: */
298: int
299: alog_shutdown(int channel)
300: {
301: struct alog_channel *const ch = &alog_channels[channel];
302:
303: /* Sanity check */
304: if (channel < 0 || channel >= ALOG_MAX_CHANNELS) {
305: errno = EINVAL;
306: return (-1);
307: }
308:
309: /* Cancel timer */
310: ch->last.timer_expiry = 0;
311:
312: /* Flush any repeated message */
313: alog_flush_lastmsg(ch, 0);
314:
315: /* Shut down channel */
316: switch (ch->type) {
317: case ALOG_SYSLOG_REMOTE:
318: (void)close(ch->sock);
319: ch->sock = -1;
320: pthread_mutex_destroy(&ch->mutex);
321: break;
322: case ALOG_SYSLOG_LOCAL:
323: closelog();
324: pthread_mutex_destroy(&ch->mutex);
325: break;
326: case ALOG_NULL:
327: case ALOG_STDERR:
328: pthread_mutex_destroy(&ch->mutex);
329: break;
330: case ALOG_NONE:
331: break;
332: }
333: ch->type = ALOG_NONE;
334:
335: /* Free saved last message */
336: FREE(MEM_TYPE, ch->last.msg);
337: ch->last.msg = NULL;
338:
339: /* Close logfile */
340: logfile_close(&ch->logfile); /* ok if null */
341:
342: /* Done */
343: return (0);
344: }
345:
346: /*
347: * Get current channel.
348: */
349: static int
350: alog_get_channel(void)
351: {
352: struct alog_curchan *cc;
353:
354: if ((cc = alog_get_current_channel(0)) == NULL)
355: return (0);
356: return (cc->channel);
357: }
358:
359: /*
360: * Set active channel.
361: */
362: int
363: alog_set_channel(int channel)
364: {
365: struct alog_curchan *cc;
366:
367: /* Sanity check */
368: if (channel < 0 || channel >= ALOG_MAX_CHANNELS) {
369: errno = EINVAL;
370: return (-1);
371: }
372:
373: /* Compare with current channel */
374: if ((cc = alog_get_current_channel(channel != 0)) == NULL) {
375: if (channel != 0)
376: return (-1);
377: return (0);
378: }
379: if (channel == cc->channel)
380: return (0);
381:
382: /* Set to new channel, even if it's uninitialized */
383: cc->channel = channel;
384:
385: /* Done */
386: return (0);
387: }
388:
389: /*
390: * Get current channel per-thread variable.
391: */
392: static struct alog_curchan *
393: alog_get_current_channel(int create)
394: {
395: static pthread_once_t init_channel_once = PTHREAD_ONCE_INIT;
396: struct alog_curchan *cc;
397:
398: /* Initialize per-thread variable (once) */
399: if ((errno = pthread_once(&init_channel_once,
400: alog_init_current_channel)) != 0) {
401: fprintf(stderr, "%s: %s: %s\n",
402: "alog", "pthread_once", strerror(errno));
403: return (NULL);
404: }
405:
406: /* Get instance for this thread; create if necessary */
407: if ((cc = pthread_getspecific(alog_current_channel)) == NULL) {
408: if (!create)
409: return (NULL);
410: if ((cc = MALLOC(MEM_TYPE_CURCHAN, sizeof(*cc))) == NULL) {
411: fprintf(stderr, "%s: %s: %s\n",
412: "alog", "malloc", strerror(errno));
413: return (NULL);
414: }
415: cc->channel = 0;
416: if ((errno = pthread_setspecific(alog_current_channel,
417: cc)) != 0) {
418: fprintf(stderr, "%s: %s: %s\n",
419: "alog", "pthread_setspecific", strerror(errno));
420: FREE(MEM_TYPE_CURCHAN, cc);
421: return (NULL);
422: }
423: }
424:
425: /* Return current channel */
426: return (cc);
427: }
428:
429: /*
430: * Initialize "current channel" per-thread variable.
431: */
432: static void
433: alog_init_current_channel(void)
434: {
435: int err;
436:
437: if ((err = pthread_key_create(&alog_current_channel,
438: alog_curchan_destroy)) != 0) {
439: fprintf(stderr, "%s: %s: %s\n",
440: "alog", "pthread_key_create", strerror(err));
441: assert(0);
442: }
443: }
444:
445: /*
446: * Destroy an instance of the per-thread current channel variable.
447: */
448: static void
449: alog_curchan_destroy(void *arg)
450: {
451: struct alog_curchan *const cc = arg;
452:
453: FREE(MEM_TYPE_CURCHAN, cc);
454: }
455:
456: /*
457: * Enable debugging on a channel.
458: */
459: void
460: alog_set_debug(int channel, int enabled)
461: {
462: struct alog_channel *const ch = &alog_channels[channel];
463:
464: ch->debug = !!enabled;
465: }
466:
467: /*
468: * Log something to the currently selected channel. Preserves errno.
469: */
470: void
471: alog(int sev, const char *fmt, ...)
472: {
473: va_list args;
474:
475: va_start(args, fmt);
476: valog(sev, fmt, args);
477: va_end(args);
478: }
479:
480: /*
481: * Log something to the currently selected channel. Preserves errno.
482: */
483: void
484: valog(int sev, const char *fmt, va_list args)
485: {
486: const int errno_save = errno;
487: struct alog_channel *const ch = &alog_channels[alog_get_channel()];
488: char fmtbuf[1024];
489: time_t now;
490: char *msg;
491: int r;
492:
493: /* Lock channel */
494: if (ch->type != ALOG_NONE) {
495: r = pthread_mutex_lock(&ch->mutex);
496: assert(r == 0);
497: }
498:
499: /* Check last message timer */
500: alog_last_check(ch);
501:
502: /* Filter out unwanted verbosity */
503: if (ch->type != ALOG_NONE && sev > ch->min_severity)
504: goto done;
505:
506: /* Allow for things like ``alog(LOG_DEBUG + 1, ...)'' */
507: if (sev >= LOG_DEBUG)
508: sev = LOG_DEBUG;
509:
510: /* Build the message */
511: alog_expand(fmt, errno_save, fmtbuf, sizeof(fmtbuf));
512: VASPRINTF(MEM_TYPE, &msg, fmtbuf, args);
513: if (msg == NULL) {
514: fprintf(stderr, "%s: %s: %s\n",
515: __FUNCTION__, "vasprintf", strerror(errno));
516: goto done;
517: }
518:
519: /* Get current time */
520: now = time(NULL);
521:
522: /* If not configured, don't do the repeated messages thing */
523: if (ch->type == ALOG_NONE) {
524: alog_write(ch, sev, now, msg);
525: FREE(MEM_TYPE, msg);
526: goto done;
527: }
528:
529: /* Handle repeated messages */
530: if (ch->last.msg == NULL || strcmp(msg, ch->last.msg) != 0) {
531: alog_flush_lastmsg(ch, LASTMSG_TIMEOUT_INITIAL);
532: FREE(MEM_TYPE, ch->last.msg);
533: ch->last.msg = msg;
534: ch->last.sev = sev;
535: ch->last.when = now;
536: alog_write(ch, sev, now, msg);
537: } else {
538: time_t delay;
539:
540: delay = MAX(now - ch->last.when, 0);
541: if (++ch->last.repeat == 1) {
542: ch->last.timeout = LASTMSG_TIMEOUT_1(
543: ch->last.timeout, delay);
544: } else {
545: ch->last.timeout = LASTMSG_TIMEOUT_2(
546: ch->last.timeout, delay);
547: }
548: ch->last.when = now;
549: ch->last.timer_expiry = now + ch->last.timeout;
550: FREE(MEM_TYPE, msg);
551: }
552:
553: done:
554: /* Unlock channel and restore errno */
555: if (ch->type != ALOG_NONE) {
556: r = pthread_mutex_unlock(&ch->mutex);
557: assert(r == 0);
558: }
559: errno = errno_save;
560: }
561:
562: /*
563: * Check for expiration of 'last mesasge' timer.
564: *
565: * This assumes the channel is locked.
566: */
567: static void
568: alog_last_check(struct alog_channel *ch)
569: {
570: /* Is the timer "running"? */
571: if (ch->last.timer_expiry == 0)
572: return;
573:
574: /* Has the timer "expired"? */
575: if (ch->last.timer_expiry > time(NULL))
576: return;
577:
578: /* "Stop" timer */
579: ch->last.timer_expiry = 0;
580:
581: /* Flush last message */
582: alog_flush_lastmsg(ch, LASTMSG_TIMEOUT_3(ch->last.timeout));
583: }
584:
585: /*
586: * Log repeated message(s).
587: *
588: * This assumes the channel is locked.
589: */
590: static void
591: alog_flush_lastmsg(struct alog_channel *ch, u_int timeout)
592: {
593: switch (ch->last.repeat) {
594: case 0:
595: break;
596: case 1:
597: if (ch->last.msg != NULL) {
598: alog_write(ch, ch->last.sev,
599: ch->last.when, ch->last.msg);
600: }
601: break;
602: default:
603: {
604: char buf[sizeof(LASTMSG_REPEATED_FMT) + 32];
605:
606: snprintf(buf, sizeof(buf),
607: LASTMSG_REPEATED_FMT, ch->last.repeat);
608: alog_write(ch, ch->last.sev, ch->last.when, buf);
609: break;
610: }
611: }
612: ch->last.repeat = 0;
613: ch->last.timeout = timeout;
614: ch->last.timer_expiry = 0;
615: }
616:
617: /*
618: * Write a message to the log.
619: *
620: * This assumes the channel is locked.
621: */
622: static void
623: alog_write(struct alog_channel *ch, int sev, time_t when, const char *msg)
624: {
625: /* Log it to wherever */
626: switch (ch->type) {
627: case ALOG_NONE:
628: case ALOG_STDERR:
629: fprintf(stderr, "%s: %s\n",
630: alog_severity_name(LOG_PRI(sev)), msg);
631: break;
632: case ALOG_NULL:
633: break;
634: case ALOG_SYSLOG_LOCAL:
635: openlog(ch->name, 0, ch->facility); /* XXX race condition */
636: syslog(sev, "%s", msg); /* XXX race condition */
637: break;
638: case ALOG_SYSLOG_REMOTE:
639: {
640: char ascbuf[32];
641: struct tm tm;
642: char *netmsg;
643: int len;
644:
645: if (ch->sock == -1)
646: break;
647: gmtime_r(&when, &tm);
648: asctime_r(&tm, ascbuf);
649: len = ASPRINTF(TYPED_MEM_TEMP, &netmsg, "<%d>%.15s %s",
650: LOG_MAKEPRI(ch->facility, sev), ascbuf + 4, msg);
651: if (netmsg != NULL)
652: write(ch->sock, netmsg, len);
653: FREE(TYPED_MEM_TEMP, netmsg);
654: break;
655: }
656: }
657:
658: /* Save message in history buffer */
659: if (ch->logfile != NULL) {
660: struct alog_entry *ent;
661: int mlen;
662:
663: /* Setup entry */
664: mlen = strlen(msg) + 1;
665: if ((ent = MALLOC(MEM_TYPE, sizeof(*ent) + mlen)) == NULL) {
666: fprintf(stderr, "%s: %s: %s\n",
667: __FUNCTION__, "malloc", strerror(errno));
668: return;
669: }
670: ent->when = when;
671: ent->sev = LOG_PRI(sev);
672: memcpy(ent->msg, msg, mlen);
673:
674: /* Add to history file */
675: if (logfile_put(ch->logfile, ent, sizeof(*ent) + mlen) == -1) {
676: fprintf(stderr, "%s: %s: %s\n",
677: __FUNCTION__, "logfile_put", strerror(errno));
678: }
679: FREE(MEM_TYPE, ent);
680: }
681: }
682:
683: /*
684: * Get channel history
685: */
686: int
687: alog_get_history(int channel, int min_sev, int max_num, time_t max_age,
688: const regex_t *preg, struct alog_history *list)
689: {
690: struct alog_channel *const ch = &alog_channels[channel];
691: struct alog_entry *copy;
692: regmatch_t pmatch;
693: u_int num_ent;
694: int rtn = -1;
695: time_t now;
696: int i, j;
697: u_int num;
698: int r;
699:
700: /* Sanity check */
701: if (channel < 0 || channel >= ALOG_MAX_CHANNELS) {
702: errno = EINVAL;
703: return (-1);
704: }
705:
706: /* Lock channel */
707: if (ch->type != ALOG_NONE) {
708: r = pthread_mutex_lock(&ch->mutex);
709: assert(r == 0);
710: }
711:
712: /* Check last message timer */
713: alog_last_check(ch);
714:
715: /* Initialize array */
716: memset(list, 0, sizeof(*list));
717:
718: /* Nothing to return? */
719: if (ch->logfile == NULL
720: || max_num == 0
721: || (num_ent = logfile_num_entries(ch->logfile)) == 0) {
722: rtn = 0;
723: goto done;
724: }
725:
726: /* Get current time */
727: now = time(NULL);
728:
729: #define MATCH(sev, when, msg, msglen) \
730: (sev <= min_sev && (now - when) <= max_age && (preg == NULL \
731: || (pmatch.rm_so = 0, pmatch.rm_eo = msglen, \
732: regexec(preg, msg, 0, &pmatch, REG_STARTEND) == 0)))
733:
734: /* Count how many entries we'll be returning */
735: num = 0;
736: if (ch->last.repeat > 0
737: && ch->last.msg != NULL
738: && MATCH(ch->last.sev, ch->last.when,
739: ch->last.msg, strlen(ch->last.msg)))
740: num++;
741: for (i = -1; num < max_num && i >= -num_ent; i--) {
742: const struct alog_entry *ent;
743: int len;
744:
745: /* Get entry, check severity and age */
746: if ((ent = logfile_get(ch->logfile, i, &len)) != NULL
747: && len >= sizeof(*ent) + 1
748: && MATCH(ent->sev, ent->when,
749: ent->msg, len - sizeof(*ent) - 1))
750: num++;
751: }
752: if (num == 0) {
753: rtn = 0;
754: goto done;
755: }
756:
757: /* Allocate array of pointers */
758: if ((list->elems = MALLOC(MEM_TYPE_HISTORY,
759: num * sizeof(*list->elems))) == NULL)
760: goto done;
761:
762: /* Fill array, starting with the most recent first */
763: j = num;
764: if (ch->last.repeat > 0
765: && ch->last.msg != NULL
766: && MATCH(ch->last.sev, ch->last.when,
767: ch->last.msg, strlen(ch->last.msg))) {
768: char buf[sizeof(LASTMSG_REPEATED_FMT) + 32];
769: const char *s;
770:
771: if (ch->last.repeat > 1) {
772: snprintf(buf, sizeof(buf),
773: LASTMSG_REPEATED_FMT, ch->last.repeat);
774: s = buf;
775: } else
776: s = ch->last.msg;
777: if ((copy = MALLOC(MEM_TYPE_ENTRY,
778: sizeof(*copy) + strlen(s) + 1)) != NULL) {
779: copy->when = ch->last.when;
780: copy->sev = ch->last.sev;
781: strcpy(copy->msg, s);
782: list->elems[--j] = copy;
783: }
784: }
785: for (i = -1; j > 0 && i >= -num_ent; i--) {
786: const struct alog_entry *ent;
787: int len;
788:
789: /* Copy it if it matches */
790: if ((ent = logfile_get(ch->logfile, i, &len)) != NULL
791: && len >= sizeof(*ent) + 1
792: && MATCH(ent->sev, ent->when,
793: ent->msg, len - sizeof(*ent) - 1)) {
794: if ((copy = MALLOC(MEM_TYPE_ENTRY, len)) != NULL) {
795: memcpy(copy, ent, len - 1);
796: ((char *)copy)[len - 1] = '\0'; /* safety */
797: list->elems[--j] = copy;
798: }
799: }
800: }
801:
802: /* Collapse entries dropped because of memory problems or whatever */
803: if (j > 0) {
804: num -= j;
805: memcpy(list->elems, list->elems + j,
806: num * sizeof(*list->elems));
807: }
808: list->length = num;
809: rtn = 0;
810:
811: done:
812: /* Unlock channel and return */
813: if (ch->type != ALOG_NONE) {
814: r = pthread_mutex_unlock(&ch->mutex);
815: assert(r == 0);
816: }
817: return (rtn);
818: }
819:
820: /*
821: * Clear log history.
822: */
823: int
824: alog_clear_history(int channel)
825: {
826: struct alog_channel *const ch = &alog_channels[channel];
827: int r;
828:
829: /* Sanity check */
830: if (channel < 0 || channel >= ALOG_MAX_CHANNELS) {
831: errno = EINVAL;
832: return (-1);
833: }
834:
835: /* Lock channel */
836: if (ch->type != ALOG_NONE) {
837: r = pthread_mutex_lock(&ch->mutex);
838: assert(r == 0);
839: }
840:
841: /* Reset last message state */
842: ch->last.timer_expiry = 0;
843: FREE(MEM_TYPE, ch->last.msg);
844: memset(&ch->last, 0, sizeof(ch->last));
845:
846: /* Zero out logfile */
847: if (ch->logfile != NULL)
848: logfile_trim(ch->logfile, 0);
849:
850: /* Unlock channel */
851: if (ch->type != ALOG_NONE) {
852: r = pthread_mutex_unlock(&ch->mutex);
853: assert(r == 0);
854: }
855:
856: /* Done */
857: return (0);
858: }
859:
860: /*
861: * Decode syslog facility name
862: */
863: int
864: alog_facility(const char *name)
865: {
866: int i;
867:
868: for (i = 0; facilitynames[i].name != NULL; i++) {
869: if (strcmp(name, facilitynames[i].name) == 0)
870: return (facilitynames[i].val);
871: }
872: return (-1);
873: }
874:
875: /*
876: * Decode syslog facility name
877: */
878: const char *
879: alog_facility_name(int facility)
880: {
881: int i;
882:
883: for (i = 0; facilitynames[i].name != NULL; i++) {
884: if (facilitynames[i].val == facility)
885: return (facilitynames[i].name);
886: }
887: return (NULL);
888: }
889:
890: /*
891: * Decode syslog severity name
892: */
893: int
894: alog_severity(const char *name)
895: {
896: char *eptr;
897: int i;
898:
899: for (i = 0; prioritynames[i].name != NULL; i++) {
900: if (strcmp(name, prioritynames[i].name) == 0)
901: return (prioritynames[i].val);
902: }
903: i = (int)strtol(name, &eptr, 0);
904: if (*name != '\0' && *eptr == '\0')
905: return (i);
906: return (-1);
907: }
908:
909: /*
910: * Decode syslog severity name
911: */
912: const char *
913: alog_severity_name(int severity)
914: {
915: int i;
916:
917: for (i = 0; prioritynames[i].name != NULL; i++) {
918: if (prioritynames[i].val == severity)
919: return (prioritynames[i].name);
920: }
921: return (NULL);
922: }
923:
924: /*
925: * Kludge to deal with %m format when not using syslog
926: */
927: void
928: alog_expand(const char *fmt, int errnum, char *buf, size_t bufsize)
929: {
930: const char *errstr;
931: const char *s;
932: int errlen;
933: int i;
934:
935: /* Find "%m" which is usually at the end */
936: for (s = fmt + strlen(fmt) - 2;
937: s >= fmt && !(s[0] == '%' && s[1] == 'm');
938: s--);
939:
940: /* Check if we should bother doing anything */
941: if (s < fmt || (i = s - fmt) > bufsize - 2) {
942: strlcpy(buf, fmt, bufsize);
943: return;
944: }
945:
946: /* Convert "%m" to error string */
947: errstr = strerror(errnum);
948: errlen = strlen(errstr);
949: strlcpy(buf, fmt, i + 1);
950: strlcpy(buf + i, errstr, bufsize - i);
951: strlcpy(buf + i + errlen, fmt + i + 2, bufsize - i - errlen);
952: }
953:
954: /*********************************************************************
955: STRUCTS TYPE DEFINITIONS
956: *********************************************************************/
957:
958: /* Type for "path" and "name" strings in struct alog_config */
959: static const struct structs_type alog_path_type
960: = STRUCTS_STRING_TYPE("alog_config.path", 1);
961: static const struct structs_type alog_name_type
962: = STRUCTS_STRING_TYPE("alog_config.name", 1);
963:
964: /* Fields list for struct alog_config */
965: static const struct structs_field alog_config_fields[] = {
966: STRUCTS_STRUCT_FIELD(alog_config, path, &alog_path_type),
967: STRUCTS_STRUCT_FIELD(alog_config, name, &alog_name_type),
968: STRUCTS_STRUCT_FIELD(alog_config, facility, &alog_facility_type),
969: STRUCTS_STRUCT_FIELD(alog_config, remote_server, &structs_type_ip4),
970: STRUCTS_STRUCT_FIELD(alog_config, min_severity, &alog_severity_type),
971: STRUCTS_STRUCT_FIELD(alog_config, histlen, &structs_type_int),
972: STRUCTS_STRUCT_FIELD_END
973: };
974:
975: /* Type for struct alog_config */
976: const struct structs_type alog_config_type
977: = STRUCTS_STRUCT_TYPE(alog_config, &alog_config_fields);
978:
979: /* Override method for alog_facility_type */
980: static structs_init_t alog_facility_type_init;
981: static structs_binify_t alog_facility_type_binify;
982:
983: /* Type for syslog facility, which we store as a string. */
984: const struct structs_type alog_facility_type = {
985: sizeof(char *),
986: "alog",
987: STRUCTS_TYPE_PRIMITIVE,
988: alog_facility_type_init,
989: structs_ascii_copy,
990: structs_string_equal,
991: structs_string_ascify,
992: alog_facility_type_binify,
993: structs_string_encode,
994: structs_string_decode,
995: structs_string_free,
996: { { (void *)"alog_config.facility" }, { (void *)1 } }
997: };
998:
999: /*
1000: * Initializer for alog_facility_type
1001: */
1002: static int
1003: alog_facility_type_init(const struct structs_type *type, void *data)
1004: {
1005: return (structs_string_binify(type, "daemon", data, NULL, 0));
1006: }
1007:
1008: /*
1009: * Binifier for alog_facility_type
1010: */
1011: static int
1012: alog_facility_type_binify(const struct structs_type *type,
1013: const char *ascii, void *data, char *ebuf, size_t emax)
1014: {
1015: if (*ascii != '\0' && alog_facility(ascii) == -1) {
1016: strlcpy(ebuf, "invalid syslog facility", emax);
1017: errno = EINVAL;
1018: return (-1);
1019: }
1020: return (structs_string_binify(type, ascii, data, NULL, 0));
1021: }
1022:
1023: /* Override methods for alog_severity_type */
1024: static structs_init_t alog_severity_init;
1025: static structs_ascify_t alog_severity_ascify;
1026: static structs_binify_t alog_severity_binify;
1027:
1028: /* Type for severity, which defaults to LOG_INFO. The input can be either
1029: a symbolic name or a numeric value. */
1030: const struct structs_type alog_severity_type = {
1031: sizeof(int),
1032: "int",
1033: STRUCTS_TYPE_PRIMITIVE,
1034: alog_severity_init,
1035: structs_region_copy,
1036: structs_region_equal,
1037: alog_severity_ascify,
1038: alog_severity_binify,
1039: structs_region_encode_netorder,
1040: structs_region_decode_netorder,
1041: structs_nothing_free,
1042: { { (void *)2 }, { (void *)1 } }
1043: };
1044:
1045: /*
1046: * Initializer for severity
1047: */
1048: static int
1049: alog_severity_init(const struct structs_type *type, void *data)
1050: {
1051: *((int *)data) = LOG_INFO;
1052: return (0);
1053: }
1054:
1055: /*
1056: * Ascifier for severity
1057: */
1058: static char *
1059: alog_severity_ascify(const struct structs_type *type,
1060: const char *mtype, const void *data)
1061: {
1062: const int sev = *((int *)data);
1063: const char *s;
1064: char buf[32];
1065:
1066: if ((s = alog_severity_name(sev)) == NULL) {
1067: snprintf(buf, sizeof(buf), "%d", sev);
1068: s = buf;
1069: }
1070: return (STRDUP(mtype, s));
1071: }
1072:
1073: /*
1074: * Binifier for severity
1075: */
1076: static int
1077: alog_severity_binify(const struct structs_type *type,
1078: const char *ascii, void *data, char *ebuf, size_t emax)
1079: {
1080: int sev;
1081:
1082: if ((sev = alog_severity(ascii)) == -1
1083: && structs_int_binify(type, ascii, data, NULL, 0) == -1) {
1084: strlcpy(ebuf, "invalid syslog severity", emax);
1085: return (-1);
1086: }
1087: *((int *)data) = sev;
1088: return (0);
1089: }
1090:
1091: /*
1092: * Ascifier for log entry message.
1093: */
1094: static char *
1095: alog_entry_msg_ascify(const struct structs_type *type,
1096: const char *mtype, const void *data)
1097: {
1098: return (STRDUP(mtype, data));
1099: }
1100:
1101: /* Type for log entry message. This is a "read only" type. */
1102: static const struct structs_type alog_entry_msg_type = {
1103: 0,
1104: "alog_entry_msg_type",
1105: STRUCTS_TYPE_PRIMITIVE,
1106: structs_notsupp_init,
1107: structs_notsupp_copy,
1108: structs_notsupp_equal,
1109: alog_entry_msg_ascify,
1110: structs_notsupp_binify,
1111: structs_notsupp_encode,
1112: structs_notsupp_decode,
1113: structs_nothing_free,
1114: };
1115:
1116: /* Type for history list: an array of pointers to log entries */
1117: static const struct structs_field alog_entry_fields[] = {
1118: STRUCTS_STRUCT_FIELD(alog_entry, when, &structs_type_time_abs),
1119: STRUCTS_STRUCT_FIELD(alog_entry, sev, &alog_severity_type),
1120: STRUCTS_STRUCT_FIELD(alog_entry, msg, &alog_entry_msg_type),
1121: STRUCTS_STRUCT_FIELD_END
1122: };
1123: static const struct structs_type alog_entry_type
1124: = STRUCTS_STRUCT_TYPE(alog_entry, &alog_entry_fields);
1125: static const struct structs_type alog_history_ptr_type
1126: = STRUCTS_POINTER_TYPE(&alog_entry_type, MEM_TYPE_ENTRY);
1127: const struct structs_type alog_history_type
1128: = STRUCTS_ARRAY_TYPE(&alog_history_ptr_type, MEM_TYPE_HISTORY, "entry");
1129:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to alog.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / sys