1 /* log.c - Diagnostic and error logging
2 * Copyright 2000-2004 srvx Development Team
4 * This file is part of srvx.
6 * srvx is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with srvx; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 #include "helpfile.h" /* send_message, message_register, etc */
28 #define MAXLOGSEARCHLENGTH 10000
30 struct userNode
*chanserv
;
32 struct logDestination
;
34 struct logDest_vtable
{
35 const char *type_name
;
36 struct logDestination
* (*open
)(const char *args
);
37 void (*reopen
)(struct logDestination
*self
);
38 void (*close
)(struct logDestination
*self
);
39 void (*log_audit
)(struct logDestination
*self
, struct log_type
*type
, struct logEntry
*entry
);
40 void (*log_replay
)(struct logDestination
*self
, struct log_type
*type
, int is_write
, const char *line
);
41 void (*log_module
)(struct logDestination
*self
, struct log_type
*type
, enum log_severity sev
, const char *message
);
44 struct logDestination
{
45 struct logDest_vtable
*vtbl
;
50 DECLARE_LIST(logList
, struct logDestination
*);
54 struct logList logs
[LOG_NUM_SEVERITIES
];
55 struct logEntry
*log_oldest
;
56 struct logEntry
*log_newest
;
57 unsigned int log_count
;
59 unsigned int max_count
;
61 unsigned int default_set
: 1;
64 static const char *log_severity_names
[] = {
77 static struct dict
*log_dest_types
;
78 static struct dict
*log_dests
;
79 static struct dict
*log_types
;
80 static struct log_type
*log_default
;
81 static int log_inited
, log_debugged
;
83 DEFINE_LIST(logList
, struct logDestination
*)
84 static void log_format_audit(struct logEntry
*entry
);
85 static const struct message_entry msgtab
[] = {
86 { "MSG_INVALID_FACILITY", "$b%s$b is an invalid log facility." },
87 { "MSG_INVALID_SEVERITY", "$b%s$b is an invalid severity level." },
89 { "LAST_RESULTS", "$b%s$b] %s %s $b%s$b %s" },
90 { "LAST_ERROR", "%s:%s" },
91 { "LAST_COMMAND_LOG", "Channel Events for %s" },
92 { "LAST_LINE", "----------------------------------------" },
93 { "LAST_STOPPING_AT", "--------- Stopping at %d lines ---------" },
94 { "LAST_MAX_AGE", "-------- Data age limit reached --------" },
95 { "LAST_END_OF_LOG", "---------- Found %d Matches ------------" },
100 static struct logDestination
*
101 log_open(const char *name
)
103 struct logDest_vtable
*vtbl
;
104 struct logDestination
*ld
;
108 if ((ld
= dict_find(log_dests
, name
, NULL
))) {
112 if ((sep
= strchr(name
, ':'))) {
113 memcpy(type_name
, name
, sep
-name
);
114 type_name
[sep
-name
] = 0;
116 strcpy(type_name
, name
);
118 if (!(vtbl
= dict_find(log_dest_types
, type_name
, NULL
))) {
119 log_module(MAIN_LOG
, LOG_ERROR
, "Invalid log type for log '%s'.", name
);
122 if (!(ld
= vtbl
->open(sep
? sep
+1 : 0)))
124 ld
->name
= strdup(name
);
125 dict_insert(log_dests
, ld
->name
, ld
);
131 logList_open(struct logList
*ll
, struct record_data
*rd
)
133 struct logDestination
*ld
;
140 if ((ld
= log_open(rd
->d
.qstring
)))
141 logList_append(ll
, ld
);
143 case RECDB_STRING_LIST
:
144 for (ii
=0; ii
<rd
->d
.slist
->used
; ++ii
) {
145 if ((ld
= log_open(rd
->d
.slist
->list
[ii
])))
146 logList_append(ll
, ld
);
155 logList_join(struct logList
*target
, const struct logList
*source
)
157 unsigned int ii
, jj
, kk
;
162 target
->used
+= source
->used
;
163 target
->size
+= source
->used
;
164 target
->list
= realloc(target
->list
, target
->size
* sizeof(target
->list
[0]));
165 for (ii
= 0; ii
< source
->used
; ++ii
, ++jj
) {
167 for (is_duplicate
= 0, kk
= 0; kk
< jj
; kk
++) {
168 if (target
->list
[kk
] == source
->list
[ii
]) {
178 target
->list
[jj
] = source
->list
[ii
];
179 target
->list
[jj
]->refcnt
++;
184 logList_close(struct logList
*ll
)
187 for (ii
=0; ii
<ll
->used
; ++ii
) {
188 if (!--ll
->list
[ii
]->refcnt
) {
189 struct logDestination
*ld
= ll
->list
[ii
];
201 enum log_severity ls
;
203 for (it
= dict_first(log_types
); it
; it
= iter_next(it
)) {
205 for (ls
= 0; ls
< LOG_NUM_SEVERITIES
; ls
++) {
206 logList_close(<
->logs
[ls
]);
208 lt
->logs
[ls
].size
= 0;
209 lt
->logs
[ls
].used
= 0;
210 lt
->logs
[ls
].list
= 0;
216 log_type_free_oldest(struct log_type
*lt
)
218 struct logEntry
*next
;
222 next
= lt
->log_oldest
->next
;
223 free(lt
->log_oldest
->default_desc
);
224 free(lt
->log_oldest
);
225 lt
->log_oldest
= next
;
230 log_type_free(void *ptr
)
232 struct log_type
*lt
= ptr
;
234 while (lt
->log_oldest
)
235 log_type_free_oldest(lt
);
244 dict_delete(log_types
);
245 dict_delete(log_dests
);
246 dict_delete(log_dest_types
);
249 static enum log_severity
250 find_severity(const char *text
)
252 enum log_severity ls
;
253 for (ls
= 0; ls
< LOG_NUM_SEVERITIES
; ++ls
)
254 if (!ircncasecmp(text
, log_severity_names
[ls
], strlen(log_severity_names
[ls
])))
256 return LOG_NUM_SEVERITIES
;
259 /* Log keys are based on syslog.conf syntax:
260 * KEY := LOGSET '.' SEVSET
261 * LOGSET := LOGLIT | LOGLIT ',' LOGSET
262 * LOGLIT := a registered log type
263 * SEVSET := '*' | SEVLIT | '<' SEVLIT | '<=' SEVLIT | '>' SEVLIT | '>=' SEVLIT | SEVLIT ',' SEVSET
264 * SEVLIT := one of log_severity_names
265 * A KEY contains the Cartesian product of the logs in its LOGSET
266 * and the severities in its SEVSET.
270 log_parse_logset(char *buffer
, struct string_list
*slist
)
274 char *cont
= strchr(buffer
, ',');
277 string_list_append(slist
, strdup(buffer
));
283 log_parse_sevset(char *buffer
, char targets
[LOG_NUM_SEVERITIES
])
285 memset(targets
, 0, LOG_NUM_SEVERITIES
);
288 enum log_severity bound
;
291 cont
= strchr(buffer
, ',');
294 if (buffer
[0] == '*' && buffer
[1] == 0) {
295 for (bound
= 0; bound
< LOG_NUM_SEVERITIES
; bound
++) {
296 /* make people explicitly specify replay targets */
297 if (bound
!= LOG_REPLAY
)
300 } else if (buffer
[0] == '<') {
301 if (buffer
[1] == '=')
302 bound
= find_severity(buffer
+2) + 1;
304 bound
= find_severity(buffer
+1);
305 for (first
= 1; bound
> 0; bound
--) {
306 /* make people explicitly specify replay targets */
307 if (bound
!= LOG_REPLAY
|| first
) {
312 } else if (buffer
[0] == '>') {
313 if (buffer
[1] == '=')
314 bound
= find_severity(buffer
+2);
316 bound
= find_severity(buffer
+1) + 1;
317 for (first
= 1; bound
< LOG_NUM_SEVERITIES
; bound
++) {
318 /* make people explicitly specify replay targets */
319 if (bound
!= LOG_REPLAY
|| first
) {
325 if (buffer
[0] == '=')
327 bound
= find_severity(buffer
);
335 log_parse_cross(const char *buffer
, struct string_list
*types
, char sevset
[LOG_NUM_SEVERITIES
])
337 char *buffer_copy
, *sep
;
339 buffer_copy
= strdup(buffer
);
340 sep
= strchr(buffer_copy
, '.');
342 log_parse_logset(buffer_copy
, types
);
343 log_parse_sevset(sep
, sevset
);
348 log_parse_options(struct log_type
*type
, struct dict
*conf
)
351 opt
= database_get_data(conf
, "max_age", RECDB_QSTRING
);
353 type
->max_age
= ParseInterval(opt
);
354 opt
= database_get_data(conf
, "max_count", RECDB_QSTRING
);
356 type
->max_count
= strtoul(opt
, NULL
, 10);
362 struct record_data
*rd
, *rd2
;
365 struct log_type
*type
;
366 enum log_severity sev
;
370 dict_delete(log_dests
);
372 log_dests
= dict_new();
373 dict_set_free_keys(log_dests
, free
);
375 rd
= conf_get_node("logs");
376 if (rd
&& (rd
->type
== RECDB_OBJECT
)) {
377 for (it
= dict_first(rd
->d
.object
); it
; it
= iter_next(it
)) {
378 if ((sep
= strchr(iter_key(it
), '.'))) {
379 struct logList logList
;
380 char sevset
[LOG_NUM_SEVERITIES
];
381 struct string_list
*slist
;
383 /* It looks like a <type>.<severity> record. Try to parse it. */
384 slist
= alloc_string_list(4);
385 log_parse_cross(iter_key(it
), slist
, sevset
);
387 logList_open(&logList
, iter_data(it
));
388 for (ii
= 0; ii
< slist
->used
; ++ii
) {
389 type
= log_register_type(slist
->list
[ii
], NULL
);
390 for (sev
= 0; sev
< LOG_NUM_SEVERITIES
; ++sev
) {
393 logList_join(&type
->logs
[sev
], &logList
);
396 logList_close(&logList
);
397 free_string_list(slist
);
398 } else if ((rd2
= iter_data(it
))
399 && (rd2
->type
== RECDB_OBJECT
)
400 && (type
= log_register_type(iter_key(it
), NULL
))) {
401 log_parse_options(type
, rd2
->d
.object
);
403 log_module(MAIN_LOG
, LOG_ERROR
, "Unknown logs subkey '%s'.", iter_key(it
));
414 enum log_severity sev
;
415 struct logDestination
*log_stdout
;
416 struct logList target
;
418 log_stdout
= log_open("std:out");
419 logList_init(&target
);
420 logList_append(&target
, log_stdout
);
422 for (sev
= 0; sev
< LOG_NUM_SEVERITIES
; ++sev
)
423 logList_join(&log_default
->logs
[sev
], &target
);
425 logList_close(&target
);
433 for (it
= dict_first(log_dests
); it
; it
= iter_next(it
)) {
434 struct logDestination
*ld
= iter_data(it
);
435 ld
->vtbl
->reopen(ld
);
440 log_register_type(const char *name
, const char *default_log
)
442 struct log_type
*type
;
443 struct logDestination
*dest
;
444 enum log_severity sev
;
446 if (!(type
= dict_find(log_types
, name
, NULL
))) {
447 type
= calloc(1, sizeof(*type
));
448 type
->name
= strdup(name
);
450 type
->max_count
= 1024;
451 dict_insert(log_types
, type
->name
, type
);
453 if (default_log
&& !type
->default_set
) {
454 /* If any severity level was unspecified in the config, use the default. */
456 for (sev
= 0; sev
< LOG_NUM_SEVERITIES
; ++sev
) {
457 if (sev
== LOG_REPLAY
)
458 continue; /* never default LOG_REPLAY */
459 if (!type
->logs
[sev
].size
) {
460 logList_init(&type
->logs
[sev
]);
462 if (!(dest
= log_open(default_log
)))
466 logList_append(&type
->logs
[sev
], dest
);
470 type
->default_set
= 1;
475 /* logging functions */
478 log_audit(struct log_type
*type
, enum log_severity sev
, struct userNode
*user
, struct userNode
*bot
, const char *channel_name
, unsigned int flags
, const char *command
)
480 struct logEntry
*entry
;
481 unsigned int size
, ii
;
484 /* First make sure severity is appropriate */
485 if ((sev
!= LOG_COMMAND
) && (sev
!= LOG_OVERRIDE
) && (sev
!= LOG_STAFF
)) {
486 log_module(MAIN_LOG
, LOG_ERROR
, "Illegal audit severity %d", sev
);
489 /* Allocate and fill in the log entry */
490 size
= sizeof(*entry
) + strlen(user
->nick
) + strlen(command
) + 2;
491 if (user
->handle_info
)
492 size
+= strlen(user
->handle_info
->handle
) + 1;
494 size
+= strlen(channel_name
) + 1;
495 if (flags
& AUDIT_HOSTMASK
)
496 size
+= strlen(user
->ident
) + strlen(user
->hostname
) + 2;
497 entry
= calloc(1, size
);
498 str_next
= (char*)(entry
+ 1);
503 size
= strlen(channel_name
) + 1;
504 entry
->channel_name
= memcpy(str_next
, channel_name
, size
);
508 size
= strlen(user
->nick
) + 1;
509 entry
->user_nick
= memcpy(str_next
, user
->nick
, size
);
512 if (user
->handle_info
) {
513 size
= strlen(user
->handle_info
->handle
) + 1;
514 entry
->user_account
= memcpy(str_next
, user
->handle_info
->handle
, size
);
517 if (flags
& AUDIT_HOSTMASK
) {
518 size
= sprintf(str_next
, "%s@%s", user
->ident
, user
->hostname
) + 1;
519 entry
->user_hostmask
= str_next
;
522 entry
->user_hostmask
= 0;
525 size
= strlen(command
) + 1;
526 entry
->command
= memcpy(str_next
, command
, size
);
530 /* fill in the default text for the event */
531 log_format_audit(entry
);
533 /* insert into the linked list */
535 entry
->prev
= type
->log_newest
;
536 if (type
->log_newest
)
537 type
->log_newest
->next
= entry
;
539 type
->log_oldest
= entry
;
540 type
->log_newest
= entry
;
543 /* remove old elements from the linked list */
544 while (type
->log_count
> type
->max_count
)
545 log_type_free_oldest(type
);
546 while (type
->log_oldest
&& (type
->log_oldest
->time
+ (time_t)type
->max_age
< now
))
547 log_type_free_oldest(type
);
548 if (type
->log_oldest
)
549 type
->log_oldest
->prev
= 0;
551 type
->log_newest
= 0;
553 /* call the destination logs */
554 for (ii
=0; ii
<type
->logs
[sev
].used
; ++ii
) {
555 struct logDestination
*ld
= type
->logs
[sev
].list
[ii
];
556 ld
->vtbl
->log_audit(ld
, type
, entry
);
558 for (ii
=0; ii
<log_default
->logs
[sev
].used
; ++ii
) {
559 struct logDestination
*ld
= log_default
->logs
[sev
].list
[ii
];
560 ld
->vtbl
->log_audit(ld
, type
, entry
);
565 log_replay(struct log_type
*type
, int is_write
, const char *line
)
569 for (ii
=0; ii
<type
->logs
[LOG_REPLAY
].used
; ++ii
) {
570 struct logDestination
*ld
= type
->logs
[LOG_REPLAY
].list
[ii
];
571 ld
->vtbl
->log_replay(ld
, type
, is_write
, line
);
573 for (ii
=0; ii
<log_default
->logs
[LOG_REPLAY
].used
; ++ii
) {
574 struct logDestination
*ld
= log_default
->logs
[LOG_REPLAY
].list
[ii
];
575 ld
->vtbl
->log_replay(ld
, type
, is_write
, line
);
580 log_module(struct log_type
*type
, enum log_severity sev
, const char *format
, ...)
591 if (sev
> LOG_FATAL
) {
592 log_module(MAIN_LOG
, LOG_ERROR
, "Illegal log_module severity %d", sev
);
595 va_start(args
, format
);
596 vsnprintf(msgbuf
, sizeof(msgbuf
), format
, args
);
599 for (ii
=0; ii
<type
->logs
[sev
].used
; ++ii
) {
600 struct logDestination
*ld
= type
->logs
[sev
].list
[ii
];
601 ld
->vtbl
->log_module(ld
, type
, sev
, msgbuf
);
603 for (ii
=0; ii
<log_default
->logs
[sev
].used
; ++ii
) {
604 struct logDestination
*ld
= log_default
->logs
[sev
].list
[ii
];
605 ld
->vtbl
->log_module(ld
, type
, sev
, msgbuf
);
608 /* Special behavior before we start full operation */
609 fprintf(stderr
, "%s: %s\n", log_severity_names
[sev
], msgbuf
);
612 if (sev
== LOG_FATAL
) {
613 assert(0 && "fatal message logged");
618 /* audit log searching */
621 log_discrim_create(struct userNode
*service
, struct userNode
*user
, unsigned int argc
, char *argv
[])
624 struct logSearch
*discrim
;
626 /* Assume all criteria require arguments. */
629 send_message(user
, service
, "MSG_MISSING_PARAMS", argv
[0]);
633 discrim
= malloc(sizeof(struct logSearch
));
634 memset(discrim
, 0, sizeof(*discrim
));
636 discrim
->max_time
= INT_MAX
;
637 discrim
->severities
= ~0;
639 for (ii
=1; ii
<argc
-1; ii
++) {
640 if (!irccasecmp(argv
[ii
], "bot")) {
641 struct userNode
*bot
= GetUserH(argv
[++ii
]);
643 send_message(user
, service
, "MSG_NICK_UNKNOWN", argv
[ii
]);
645 } else if (!IsLocal(bot
)) {
646 send_message(user
, service
, "MSG_NOT_A_SERVICE", argv
[ii
]);
649 discrim
->masks
.bot
= bot
;
650 } else if (!irccasecmp(argv
[ii
], "channel")) {
651 discrim
->masks
.channel_name
= argv
[++ii
];
652 } else if (!irccasecmp(argv
[ii
], "nick")) {
653 discrim
->masks
.user_nick
= argv
[++ii
];
654 } else if (!irccasecmp(argv
[ii
], "account")) {
655 discrim
->masks
.user_account
= argv
[++ii
];
656 } else if (!irccasecmp(argv
[ii
], "hostmask")) {
657 discrim
->masks
.user_hostmask
= argv
[++ii
];
658 } else if (!irccasecmp(argv
[ii
], "command")) {
659 discrim
->masks
.command
= argv
[++ii
];
660 } else if (!irccasecmp(argv
[ii
], "age")) {
661 const char *cmp
= argv
[++ii
];
664 discrim
->min_time
= now
- ParseInterval(cmp
+2);
666 discrim
->min_time
= now
- (ParseInterval(cmp
+1) - 1);
667 } else if (cmp
[0] == '>') {
669 discrim
->max_time
= now
- ParseInterval(cmp
+2);
671 discrim
->max_time
= now
- (ParseInterval(cmp
+1) - 1);
673 discrim
->min_time
= now
- ParseInterval(cmp
);
675 } else if (!irccasecmp(argv
[ii
], "limit")) {
676 discrim
->limit
= strtoul(argv
[++ii
], NULL
, 10);
677 } else if (!irccasecmp(argv
[ii
], "level")) {
678 char *severity
= argv
[++ii
];
679 discrim
->severities
= 0;
681 enum log_severity sev
= find_severity(severity
);
682 if (sev
== LOG_NUM_SEVERITIES
) {
683 send_message(user
, service
, "MSG_INVALID_SEVERITY", severity
);
686 discrim
->severities
|= 1 << sev
;
687 severity
= strchr(severity
, ',');
692 } else if (!irccasecmp(argv
[ii
], "type")) {
693 if (!(discrim
->type
= dict_find(log_types
, argv
[++ii
], NULL
))) {
694 send_message(user
, service
, "MSG_INVALID_FACILITY", argv
[ii
]);
698 send_message(user
, service
, "MSG_INVALID_CRITERIA", argv
[ii
]);
710 entry_match(struct logSearch
*discrim
, struct logEntry
*entry
)
712 if ((entry
->time
< discrim
->min_time
)
713 || (entry
->time
> discrim
->max_time
)
714 || !(discrim
->severities
& (1 << entry
->slvl
))
715 || (discrim
->masks
.bot
&& (discrim
->masks
.bot
!= entry
->bot
))
716 /* don't do glob matching, so that !events #a*b does not match #acb */
717 || (discrim
->masks
.channel_name
718 && (!entry
->channel_name
719 || irccasecmp(entry
->channel_name
, discrim
->masks
.channel_name
)))
720 || (discrim
->masks
.user_nick
721 && !match_ircglob(entry
->user_nick
, discrim
->masks
.user_nick
))
722 || (discrim
->masks
.user_account
723 && (!entry
->user_account
724 || !match_ircglob(entry
->user_account
, discrim
->masks
.user_account
)))
725 || (discrim
->masks
.user_hostmask
726 && entry
->user_hostmask
727 && !match_ircglob(entry
->user_hostmask
, discrim
->masks
.user_hostmask
))
728 || (discrim
->masks
.command
729 && !match_ircglob(entry
->command
, discrim
->masks
.command
))) {
736 log_report_entry(struct logEntry
*match
, void *extra
)
738 struct logReport
*rpt
= extra
;
739 send_message_type(4, rpt
->user
, rpt
->reporter
, "%s", match
->default_desc
);
743 log_entry_search(struct logSearch
*discrim
, entry_search_func esf
, void *data
)
745 unsigned int matched
= 0;
748 static volatile struct logEntry
*last
;
749 struct logEntry
*entry
;
751 for (entry
= discrim
->type
->log_oldest
, last
= NULL
;
753 last
= entry
, entry
= entry
->next
) {
755 if (entry_match(discrim
, entry
)) {
757 if (++matched
>= discrim
->limit
)
764 for (it
= dict_first(log_types
); it
; it
= iter_next(it
)) {
765 discrim
->type
= iter_data(it
);
766 matched
+= log_entry_search(discrim
, esf
, data
);
773 /* generic helper functions */
776 log_format_timestamp(unsigned long when
, struct string_buffer
*sbuf
)
781 localtime_r(&feh
, &local
);
782 if (sbuf
->size
< 24) {
785 sbuf
->list
= calloc(1, 24);
787 sbuf
->used
= sprintf(sbuf
->list
, "[%02d:%02d:%02d %02d/%02d/%04d]", local
.tm_hour
, local
.tm_min
, local
.tm_sec
, local
.tm_mon
+1, local
.tm_mday
, local
.tm_year
+1900);
791 log_format_audit(struct logEntry
*entry
)
793 struct string_buffer sbuf
;
794 memset(&sbuf
, 0, sizeof(sbuf
));
795 log_format_timestamp(entry
->time
, &sbuf
);
796 string_buffer_append_string(&sbuf
, " (");
797 string_buffer_append_string(&sbuf
, entry
->bot
->nick
);
798 if (entry
->channel_name
) {
799 string_buffer_append(&sbuf
, ':');
800 string_buffer_append_string(&sbuf
, entry
->channel_name
);
802 string_buffer_append_string(&sbuf
, ") [");
803 string_buffer_append_string(&sbuf
, entry
->user_nick
);
804 if (entry
->user_hostmask
) {
805 string_buffer_append(&sbuf
, '!');
806 string_buffer_append_string(&sbuf
, entry
->user_hostmask
);
808 if (entry
->user_account
) {
809 string_buffer_append(&sbuf
, ':');
810 string_buffer_append_string(&sbuf
, entry
->user_account
);
812 string_buffer_append_string(&sbuf
, "]: ");
813 string_buffer_append_string(&sbuf
, entry
->command
);
814 entry
->default_desc
= strdup(sbuf
.list
);
818 /* shared stub log operations act as a noop */
821 ldNop_reopen(UNUSED_ARG(struct logDestination
*self_
)) {
822 /* no operation necessary */
826 ldNop_replay(UNUSED_ARG(struct logDestination
*self_
), UNUSED_ARG(struct log_type
*type
), UNUSED_ARG(int is_write
), UNUSED_ARG(const char *line
)) {
827 /* no operation necessary */
832 struct logDest_file
{
833 struct logDestination base
;
837 static struct logDest_vtable ldFile_vtbl
;
839 static struct logDestination
*
840 ldFile_open(const char *args
) {
841 struct logDest_file
*ld
;
842 ld
= calloc(1, sizeof(*ld
));
843 ld
->base
.vtbl
= &ldFile_vtbl
;
844 ld
->fname
= strdup(args
);
845 ld
->output
= fopen(ld
->fname
, "a");
850 ldFile_reopen(struct logDestination
*dest_
) {
851 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
852 fclose(dest
->output
);
853 dest
->output
= fopen(dest
->fname
, "a");
857 ldFile_close(struct logDestination
*dest_
) {
858 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
859 fclose(dest
->output
);
865 ldFile_audit(struct logDestination
*dest_
, UNUSED_ARG(struct log_type
*type
), struct logEntry
*entry
) {
866 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
867 fputs(entry
->default_desc
, dest
->output
);
868 fputc('\n', dest
->output
);
869 fflush(dest
->output
);
873 ldFile_replay(struct logDestination
*dest_
, UNUSED_ARG(struct log_type
*type
), int is_write
, const char *line
) {
874 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
875 struct string_buffer sbuf
;
876 memset(&sbuf
, 0, sizeof(sbuf
));
877 log_format_timestamp(now
, &sbuf
);
878 string_buffer_append_string(&sbuf
, is_write
? "W: " : " ");
879 string_buffer_append_string(&sbuf
, line
);
880 fputs(sbuf
.list
, dest
->output
);
881 fputc('\n', dest
->output
);
883 fflush(dest
->output
);
887 ldFile_module(struct logDestination
*dest_
, struct log_type
*type
, enum log_severity sev
, const char *message
) {
888 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
889 struct string_buffer sbuf
;
890 memset(&sbuf
, 0, sizeof(sbuf
));
891 log_format_timestamp(now
, &sbuf
);
892 fprintf(dest
->output
, "%s (%s:%s) %s\n", sbuf
.list
, type
->name
, log_severity_names
[sev
], message
);
894 fflush(dest
->output
);
897 static struct logDest_vtable ldFile_vtbl
= {
909 static struct logDest_vtable ldStd_vtbl
;
911 static struct logDestination
*
912 ldStd_open(const char *args
) {
913 struct logDest_file
*ld
;
914 ld
= calloc(1, sizeof(*ld
));
915 ld
->base
.vtbl
= &ldStd_vtbl
;
916 ld
->fname
= strdup(args
);
918 /* Print to stderr if given "err" and default to stdout otherwise. */
920 ld
->output
= fdopen(atoi(args
), "a");
921 else if (!strcasecmp(args
, "err"))
930 ldStd_close(struct logDestination
*dest_
) {
931 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
937 ldStd_replay(struct logDestination
*dest_
, UNUSED_ARG(struct log_type
*type
), int is_write
, const char *line
) {
938 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
939 fprintf(dest
->output
, "%s%s\n", is_write
? "W: " : " ", line
);
943 ldStd_module(struct logDestination
*dest_
, UNUSED_ARG(struct log_type
*type
), enum log_severity sev
, const char *message
) {
944 struct logDest_file
*dest
= (struct logDest_file
*)dest_
;
945 fprintf(dest
->output
, "%s: %s\n", log_severity_names
[sev
], message
);
948 static struct logDest_vtable ldStd_vtbl
= {
961 struct logDestination base
;
964 static struct logDest_vtable ldIrc_vtbl
;
966 static struct logDestination
*
967 ldIrc_open(const char *args
) {
968 struct logDest_irc
*ld
;
969 ld
= calloc(1, sizeof(*ld
));
970 ld
->base
.vtbl
= &ldIrc_vtbl
;
971 ld
->target
= strdup(args
);
976 ldIrc_close(struct logDestination
*dest_
) {
977 struct logDest_irc
*dest
= (struct logDest_irc
*)dest_
;
983 ldIrc_audit(struct logDestination
*dest_
, UNUSED_ARG(struct log_type
*type
), struct logEntry
*entry
) {
984 struct logDest_irc
*dest
= (struct logDest_irc
*)dest_
;
986 if (entry
->channel_name
) {
987 send_target_message(4, dest
->target
, entry
->bot
, "(%s", strchr(strchr(entry
->default_desc
, ' '), ':')+1);
989 send_target_message(4, dest
->target
, entry
->bot
, "%s", strchr(entry
->default_desc
, ')')+2);
994 ldIrc_module(struct logDestination
*dest_
, struct log_type
*type
, enum log_severity sev
, const char *message
) {
995 struct logDest_irc
*dest
= (struct logDest_irc
*)dest_
;
996 extern struct userNode
*opserv
;
998 send_target_message(4, dest
->target
, opserv
, "%s %s: %s\n", type
->name
, log_severity_names
[sev
], message
);
1001 static struct logDest_vtable ldIrc_vtbl
= {
1007 ldNop_replay
, /* totally ignore this - it would be a recipe for disaster */
1014 log_types
= dict_new();
1015 dict_set_free_keys(log_types
, free
);
1016 dict_set_free_data(log_types
, log_type_free
);
1017 log_dest_types
= dict_new();
1018 /* register log types */
1019 dict_insert(log_dest_types
, ldFile_vtbl
.type_name
, &ldFile_vtbl
);
1020 dict_insert(log_dest_types
, ldStd_vtbl
.type_name
, &ldStd_vtbl
);
1021 dict_insert(log_dest_types
, ldIrc_vtbl
.type_name
, &ldIrc_vtbl
);
1022 conf_register_reload(log_conf_read
);
1023 log_default
= log_register_type("*", NULL
);
1024 reg_exit_func(cleanup_logs
);
1025 message_register_table(msgtab
);
1029 void SyncLog(char *fmt
,...)
1032 char buff
[MAXLEN
*4];
1036 va_start(args
, fmt
);
1037 vsnprintf(buff
, MAXLEN
, fmt
, args
);
1038 buff
[MAXLEN
- 1] = '\0';
1041 for (tmp
= buff
; *tmp
; tmp
++)
1043 if ((*tmp
== '\n') || (*tmp
== '\r'))
1045 else if (*tmp
== '\001')
1049 if((LogFile
= fopen("sync.log", "a")))
1051 fprintf(LogFile
, "%s: %s\n", time2str(time(NULL
)), buff
);
1057 int parselog(char *LogLine
, struct userNode
*user
, struct chanNode
*cptr
, char *chan
, char *nuh
, char *command
, char *rest
)
1059 struct svccmd
*svccmd
;
1061 struct service
*service
;
1063 char serv
[NICKLEN
+1];
1065 char myservc
[MAXLEN
];
1078 datestr
= (char *) mysep(&LogLine
, "]");
1079 mywho
= (char *) mysep(&LogLine
, " ");
1080 mynuh
= (char *) mysep(&LogLine
, " ");
1081 mycommand
= (char *) mysep(&LogLine
, " ");
1082 myrest
= (char *) mysep(&LogLine
, "\0");
1083 myserva
= (char *) mysep(&mywho
, ":");
1084 mychana
= (char *) mysep(&mywho
, ":");
1085 myserv
= (char *) mysep(&myserva
, "(");
1086 mychan
= (char *) mysep(&mychana
, ")");
1106 if(*chan
&& strcasecmp(mychan
, chan
))
1111 info
= conf_get_data("services/opserv/nick", RECDB_QSTRING
);
1116 strcpy(myservc
, myserv
);
1119 if (!strcmp(myserv
, info
)) {
1123 if ((service
= service_find(myserv
))) {
1124 if (!(cmd
= dict_find(service
->commands
, mycommand
, NULL
)))
1127 if (!(svccmd
= svccmd_resolve_name(cmd
, mycommand
)))
1130 pos
= snprintf(buf
, sizeof(buf
), "%s.%s", svccmd
->command
->parent
->name
, svccmd
->command
->name
);
1132 if (svccmd
->alias
.used
) {
1134 unsplit_string((char**)svccmd
->alias
.list
+1, svccmd
->alias
.used
-1, buf
+pos
);
1139 if (!(strcmp(buf
+0, "OpServ.OP")))
1141 if (!(strcmp(buf
+0, "OpServ.DEOP")))
1143 if (!(strcmp(buf
+0, "OpServ.VOICE")))
1145 if (!(strcmp(buf
+0, "OpServ.DEVOICE")))
1147 if (!(strcmp(buf
+0, "OpServ.KICK")))
1149 if (!(strcmp(buf
+0, "OpServ.KICKBAN")))
1152 if (!(strcmp(buf
+0, "OpServ.OPALL")))
1154 if (!(strcmp(buf
+0, "OpServ.DEOPALL")))
1156 if (!(strcmp(buf
+0, "OpServ.VOICEALL")))
1158 if (!(strcmp(buf
+0, "OpServ.DEVOICEALL")))
1160 if (!(strcmp(buf
+0, "OpServ.KICKALL")))
1162 if (!(strcmp(buf
+0, "OpServ.KICKBANALL")))
1166 if (!(strcmp(buf
+0, "OpServ.INVITE")))
1168 if (!(strcmp(buf
+0, "OpServ.INVITEME")))
1170 if (!(strcmp(buf
+0, "OpServ.CLEARBANS")))
1172 if (!(strcmp(buf
+0, "OpServ.CLEARMODES")))
1176 send_message(user
, chanserv
, "LAST_RESULTS", datestr
, myserv
, mynuh
, mycommand
, myrest
);
1180 sprintf(serv
, "%s", "");
1181 send_message(user
, chanserv
, "LAST_RESULTS", datestr
, serv
, mynuh
, mycommand
, myrest
);
1188 int ShowLog(struct userNode
*user
, struct chanNode
*cptr
, char *chan
, char *nuh
, char *command
, char *rest
, int maxlines
)
1191 int i
, s
, Last
= 0, filelen
, first
;
1192 int line
= 0, searchline
= 0;
1195 char Buff
[Block
+1] = "", PrevBuff
[Block
+1] = "";
1196 char LogLine
[(Block
+1)*2] = ""; /* To hold our exported results. */
1198 if(!(TheFile
= fopen(AccountingLog
, "r")))
1200 send_message(user
, chanserv
, "LAST_ERROR", AccountingLog
, strerror(errno
));
1203 s
= fseek(TheFile
, 0, SEEK_END
); /* Start at the end. */
1204 filelen
= ftell(TheFile
); /* Find out the length. */
1205 FilePosition
= 0; /* (from the bottom) */
1206 send_message(user
, chanserv
, "LAST_COMMAND_LOG", cptr
->name
);
1207 send_message(user
, chanserv
, "LAST_LINE");
1210 FilePosition
+= Block
;
1211 if(FilePosition
> filelen
)
1213 FilePosition
= filelen
;
1216 if((s
= fseek(TheFile
, filelen
-FilePosition
, SEEK_SET
)) < 0)
1218 send_message(user
, chanserv
, "LAST_ERROR", AccountingLog
, strerror(errno
));
1222 s
= fread(Buff
, 1, Block
, TheFile
);
1226 send_message(user
, chanserv
, "LAST_ERROR", AccountingLog
, strerror(errno
));
1231 for(i
= s
-1; i
>= 0; i
--)
1236 strcpy(LogLine
, &Buff
[i
+1]);
1238 strcat(LogLine
, PrevBuff
);
1241 if(parselog(LogLine
, user
, cptr
, chan
, nuh
, command
, rest
))
1243 if(line
>= maxlines
)
1245 send_message(user
, chanserv
, "LAST_STOPPING_AT", maxlines
);
1248 if( searchline
>= MAXLOGSEARCHLENGTH
)
1250 send_message(user
, chanserv
, "LAST_MAX_AGE");
1257 strcpy(PrevBuff
, Buff
); /* Save the remaining bit. */
1259 send_message(user
, chanserv
, "LAST_END_OF_LOG", line
);