?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
acpi.4: Add some missing references.
[dragonfly.git] / contrib / bind-9.3 / lib / isc / log.c
blob511573bcc30bcbea16ffa7ed45fe23021142dd00
1 /*
2 * Copyright (C) 2004, 2006 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: log.c,v 1.70.2.8.2.14 2006/03/02 00:37:20 marka Exp $ */
19
20 /* Principal Authors: DCL */
21
22 #include <config.h>
23
24 #include <errno.h>
25 #include <stdlib.h>
26 #include <limits.h>
27 #include <time.h>
28
29 #include <sys/types.h> /* dev_t FreeBSD 2.1 */
30
31 #include <isc/dir.h>
32 #include <isc/file.h>
33 #include <isc/log.h>
34 #include <isc/magic.h>
35 #include <isc/mem.h>
36 #include <isc/msgs.h>
37 #include <isc/print.h>
38 #include <isc/stat.h>
39 #include <isc/stdio.h>
40 #include <isc/string.h>
41 #include <isc/time.h>
42 #include <isc/util.h>
43
44 #define LCTX_MAGIC ISC_MAGIC('L', 'c', 't', 'x')
45 #define VALID_CONTEXT(lctx) ISC_MAGIC_VALID(lctx, LCTX_MAGIC)
46
47 #define LCFG_MAGIC ISC_MAGIC('L', 'c', 'f', 'g')
48 #define VALID_CONFIG(lcfg) ISC_MAGIC_VALID(lcfg, LCFG_MAGIC)
49
50 /*
51 * XXXDCL make dynamic?
52 */
53 #define LOG_BUFFER_SIZE (8 * 1024)
54
55 #ifndef PATH_MAX
56 #define PATH_MAX 1024 /* AIX and others don't define this. */
57 #endif
58
59 /*
60 * This is the structure that holds each named channel. A simple linked
61 * list chains all of the channels together, so an individual channel is
62 * found by doing strcmp()s with the names down the list. Their should
63 * be no peformance penalty from this as it is expected that the number
64 * of named channels will be no more than a dozen or so, and name lookups
65 * from the head of the list are only done when isc_log_usechannel() is
66 * called, which should also be very infrequent.
67 */
68 typedef struct isc_logchannel isc_logchannel_t;
69
70 struct isc_logchannel {
71 char * name;
72 unsigned int type;
73 int level;
74 unsigned int flags;
75 isc_logdestination_t destination;
76 ISC_LINK(isc_logchannel_t) link;
77 };
78
79 /*
80 * The logchannellist structure associates categories and modules with
81 * channels. First the appropriate channellist is found based on the
82 * category, and then each structure in the linked list is checked for
83 * a matching module. It is expected that the number of channels
84 * associated with any given category will be very short, no more than
85 * three or four in the more unusual cases.
86 */
87 typedef struct isc_logchannellist isc_logchannellist_t;
88
89 struct isc_logchannellist {
90 const isc_logmodule_t * module;
91 isc_logchannel_t * channel;
92 ISC_LINK(isc_logchannellist_t) link;
93 };
94
95 /*
96 * This structure is used to remember messages for pruning via
97 * isc_log_[v]write1().
98 */
99 typedef struct isc_logmessage isc_logmessage_t;
100
101 struct isc_logmessage {
102 char * text;
103 isc_time_t time;
104 ISC_LINK(isc_logmessage_t) link;
105 };
106
107 /*
108 * The isc_logconfig structure is used to store the configurable information
109 * about where messages are actually supposed to be sent -- the information
110 * that could changed based on some configuration file, as opposed to the
111 * the category/module specification of isc_log_[v]write[1] that is compiled
112 * into a program, or the debug_level which is dynamic state information.
113 */
114 struct isc_logconfig {
115 unsigned int magic;
116 isc_log_t * lctx;
117 ISC_LIST(isc_logchannel_t) channels;
118 ISC_LIST(isc_logchannellist_t) *channellists;
119 unsigned int channellist_count;
120 unsigned int duplicate_interval;
121 int highest_level;
122 char * tag;
123 isc_boolean_t dynamic;
124 };
125
126 /*
127 * This isc_log structure provides the context for the isc_log functions.
128 * The log context locks itself in isc_log_doit, the internal backend to
129 * isc_log_write. The locking is necessary both to provide exclusive access
130 * to the the buffer into which the message is formatted and to guard against
131 * competing threads trying to write to the same syslog resource. (On
132 * some systems, such as BSD/OS, stdio is thread safe but syslog is not.)
133 * Unfortunately, the lock cannot guard against a _different_ logging
134 * context in the same program competing for syslog's attention. Thus
135 * There Can Be Only One, but this is not enforced.
136 * XXXDCL enforce it?
137 *
138 * Note that the category and module information is not locked.
139 * This is because in the usual case, only one isc_log_t is ever created
140 * in a program, and the category/module registration happens only once.
141 * XXXDCL it might be wise to add more locking overall.
142 */
143 struct isc_log {
144 /* Not locked. */
145 unsigned int magic;
146 isc_mem_t * mctx;
147 isc_logcategory_t * categories;
148 unsigned int category_count;
149 isc_logmodule_t * modules;
150 unsigned int module_count;
151 int debug_level;
152 isc_mutex_t lock;
153 /* Locked by isc_log lock. */
154 isc_logconfig_t * logconfig;
155 char buffer[LOG_BUFFER_SIZE];
156 ISC_LIST(isc_logmessage_t) messages;
157 };
158
159 /*
160 * Used when ISC_LOG_PRINTLEVEL is enabled for a channel.
161 */
162 static const char *log_level_strings[] = {
163 "debug",
164 "info",
165 "notice",
166 "warning",
167 "error",
168 "critical"
169 };
170
171 /*
172 * Used to convert ISC_LOG_* priorities into syslog priorities.
173 * XXXDCL This will need modification for NT.
174 */
175 static const int syslog_map[] = {
176 LOG_DEBUG,
177 LOG_INFO,
178 LOG_NOTICE,
179 LOG_WARNING,
180 LOG_ERR,
181 LOG_CRIT
182 };
183
184 /*
185 * When adding new categories, a corresponding ISC_LOGCATEGORY_foo
186 * definition needs to be added to <isc/log.h>.
187 *
188 * The default category is provided so that the internal default can
189 * be overridden. Since the default is always looked up as the first
190 * channellist in the log context, it must come first in isc_categories[].
191 */
192 LIBISC_EXTERNAL_DATA isc_logcategory_t isc_categories[] = {
193 { "default", 0 }, /* "default" must come first. */
194 { "general", 0 },
195 { NULL, 0 }
196 };
197
198 /*
199 * See above comment for categories, and apply it to modules.
200 */
201 LIBISC_EXTERNAL_DATA isc_logmodule_t isc_modules[] = {
202 { "socket", 0 },
203 { "time", 0 },
204 { "interface", 0 },
205 { "timer", 0 },
206 { NULL, 0 }
207 };
208
209 /*
210 * This essentially constant structure must be filled in at run time,
211 * because its channel member is pointed to a channel that is created
212 * dynamically with isc_log_createchannel.
213 */
214 static isc_logchannellist_t default_channel;
215
216 /*
217 * libisc logs to this context.
218 */
219 LIBISC_EXTERNAL_DATA isc_log_t *isc_lctx = NULL;
220
221 /*
222 * Forward declarations.
223 */
224 static isc_result_t
225 assignchannel(isc_logconfig_t *lcfg, unsigned int category_id,
226 const isc_logmodule_t *module, isc_logchannel_t *channel);
227
228 static isc_result_t
229 sync_channellist(isc_logconfig_t *lcfg);
230
231 static isc_result_t
232 greatest_version(isc_logchannel_t *channel, int *greatest);
233
234 static isc_result_t
235 roll_log(isc_logchannel_t *channel);
236
237 static void
238 isc_log_doit(isc_log_t *lctx, isc_logcategory_t *category,
239 isc_logmodule_t *module, int level, isc_boolean_t write_once,
240 isc_msgcat_t *msgcat, int msgset, int msg,
241 const char *format, va_list args)
242 ISC_FORMAT_PRINTF(9, 0);
243
244 /*
245 * Convenience macros.
246 */
247
248 #define FACILITY(channel) (channel->destination.facility)
249 #define FILE_NAME(channel) (channel->destination.file.name)
250 #define FILE_STREAM(channel) (channel->destination.file.stream)
251 #define FILE_VERSIONS(channel) (channel->destination.file.versions)
252 #define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size)
253 #define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached)
254
255 /****
256 **** Public interfaces.
257 ****/
258
259 /*
260 * Establish a new logging context, with default channels.
261 */
262 isc_result_t
263 isc_log_create(isc_mem_t *mctx, isc_log_t **lctxp, isc_logconfig_t **lcfgp) {
264 isc_log_t *lctx;
265 isc_logconfig_t *lcfg = NULL;
266 isc_result_t result;
267
268 REQUIRE(mctx != NULL);
269 REQUIRE(lctxp != NULL && *lctxp == NULL);
270 REQUIRE(lcfgp == NULL || *lcfgp == NULL);
271
272 lctx = isc_mem_get(mctx, sizeof(*lctx));
273 if (lctx != NULL) {
274 lctx->mctx = mctx;
275 lctx->categories = NULL;
276 lctx->category_count = 0;
277 lctx->modules = NULL;
278 lctx->module_count = 0;
279 lctx->debug_level = 0;
280
281 ISC_LIST_INIT(lctx->messages);
282
283 RUNTIME_CHECK(isc_mutex_init(&lctx->lock) == ISC_R_SUCCESS);
284
285 /*
286 * Normally setting the magic number is the last step done
287 * in a creation function, but a valid log context is needed
288 * by isc_log_registercategories and isc_logconfig_create.
289 * If either fails, the lctx is destroyed and not returned
290 * to the caller.
291 */
292 lctx->magic = LCTX_MAGIC;
293
294 isc_log_registercategories(lctx, isc_categories);
295 isc_log_registermodules(lctx, isc_modules);
296 result = isc_logconfig_create(lctx, &lcfg);
297
298 } else
299 result = ISC_R_NOMEMORY;
300
301 if (result == ISC_R_SUCCESS)
302 result = sync_channellist(lcfg);
303
304 if (result == ISC_R_SUCCESS) {
305 lctx->logconfig = lcfg;
306
307 *lctxp = lctx;
308 if (lcfgp != NULL)
309 *lcfgp = lcfg;
310
311 } else {
312 if (lcfg != NULL)
313 isc_logconfig_destroy(&lcfg);
314 if (lctx != NULL)
315 isc_log_destroy(&lctx);
316 }
317
318 return (result);
319 }
320
321 isc_result_t
322 isc_logconfig_create(isc_log_t *lctx, isc_logconfig_t **lcfgp) {
323 isc_logconfig_t *lcfg;
324 isc_logdestination_t destination;
325 isc_result_t result = ISC_R_SUCCESS;
326 int level = ISC_LOG_INFO;
327
328 REQUIRE(lcfgp != NULL && *lcfgp == NULL);
329 REQUIRE(VALID_CONTEXT(lctx));
330
331 lcfg = isc_mem_get(lctx->mctx, sizeof(*lcfg));
332
333 if (lcfg != NULL) {
334 lcfg->lctx = lctx;
335 lcfg->channellists = NULL;
336 lcfg->channellist_count = 0;
337 lcfg->duplicate_interval = 0;
338 lcfg->highest_level = level;
339 lcfg->tag = NULL;
340 lcfg->dynamic = ISC_FALSE;
341
342 ISC_LIST_INIT(lcfg->channels);
343
344 /*
345 * Normally the magic number is the last thing set in the
346 * structure, but isc_log_createchannel() needs a valid
347 * config. If the channel creation fails, the lcfg is not
348 * returned to the caller.
349 */
350 lcfg->magic = LCFG_MAGIC;
351
352 } else
353 result = ISC_R_NOMEMORY;
354
355 /*
356 * Create the default channels:
357 * default_syslog, default_stderr, default_debug and null.
358 */
359 if (result == ISC_R_SUCCESS) {
360 destination.facility = LOG_DAEMON;
361 result = isc_log_createchannel(lcfg, "default_syslog",
362 ISC_LOG_TOSYSLOG, level,
363 &destination, 0);
364 }
365
366 if (result == ISC_R_SUCCESS) {
367 destination.file.stream = stderr;
368 destination.file.name = NULL;
369 destination.file.versions = ISC_LOG_ROLLNEVER;
370 destination.file.maximum_size = 0;
371 result = isc_log_createchannel(lcfg, "default_stderr",
372 ISC_LOG_TOFILEDESC,
373 level,
374 &destination,
375 ISC_LOG_PRINTTIME);
376 }
377
378 if (result == ISC_R_SUCCESS) {
379 /*
380 * Set the default category's channel to default_stderr,
381 * which is at the head of the channels list because it was
382 * just created.
383 */
384 default_channel.channel = ISC_LIST_HEAD(lcfg->channels);
385
386 destination.file.stream = stderr;
387 destination.file.name = NULL;
388 destination.file.versions = ISC_LOG_ROLLNEVER;
389 destination.file.maximum_size = 0;
390 result = isc_log_createchannel(lcfg, "default_debug",
391 ISC_LOG_TOFILEDESC,
392 ISC_LOG_DYNAMIC,
393 &destination,
394 ISC_LOG_PRINTTIME);
395 }
396
397 if (result == ISC_R_SUCCESS)
398 result = isc_log_createchannel(lcfg, "null",
399 ISC_LOG_TONULL,
400 ISC_LOG_DYNAMIC,
401 NULL, 0);
402
403 if (result == ISC_R_SUCCESS)
404 *lcfgp = lcfg;
405
406 else
407 if (lcfg != NULL)
408 isc_logconfig_destroy(&lcfg);
409
410 return (result);
411 }
412
413 isc_logconfig_t *
414 isc_logconfig_get(isc_log_t *lctx) {
415 REQUIRE(VALID_CONTEXT(lctx));
416
417 ENSURE(lctx->logconfig != NULL);
418
419 return (lctx->logconfig);
420 }
421
422 isc_result_t
423 isc_logconfig_use(isc_log_t *lctx, isc_logconfig_t *lcfg) {
424 isc_logconfig_t *old_cfg;
425 isc_result_t result;
426
427 REQUIRE(VALID_CONTEXT(lctx));
428 REQUIRE(VALID_CONFIG(lcfg));
429 REQUIRE(lcfg->lctx == lctx);
430
431 /*
432 * Ensure that lcfg->channellist_count == lctx->category_count.
433 * They won't be equal if isc_log_usechannel has not been called
434 * since any call to isc_log_registercategories.
435 */
436 result = sync_channellist(lcfg);
437 if (result != ISC_R_SUCCESS)
438 return (result);
439
440 LOCK(&lctx->lock);
441
442 old_cfg = lctx->logconfig;
443 lctx->logconfig = lcfg;
444
445 UNLOCK(&lctx->lock);
446
447 isc_logconfig_destroy(&old_cfg);
448
449 return (ISC_R_SUCCESS);
450 }
451
452 void
453 isc_log_destroy(isc_log_t **lctxp) {
454 isc_log_t *lctx;
455 isc_logconfig_t *lcfg;
456 isc_mem_t *mctx;
457 isc_logmessage_t *message;
458
459 REQUIRE(lctxp != NULL && VALID_CONTEXT(*lctxp));
460
461 lctx = *lctxp;
462 mctx = lctx->mctx;
463
464 if (lctx->logconfig != NULL) {
465 lcfg = lctx->logconfig;
466 lctx->logconfig = NULL;
467 isc_logconfig_destroy(&lcfg);
468 }
469
470 DESTROYLOCK(&lctx->lock);
471
472 while ((message = ISC_LIST_HEAD(lctx->messages)) != NULL) {
473 ISC_LIST_UNLINK(lctx->messages, message, link);
474
475 isc_mem_put(mctx, message,
476 sizeof(*message) + strlen(message->text) + 1);
477 }
478
479 lctx->buffer[0] = '\0';
480 lctx->debug_level = 0;
481 lctx->categories = NULL;
482 lctx->category_count = 0;
483 lctx->modules = NULL;
484 lctx->module_count = 0;
485 lctx->mctx = NULL;
486 lctx->magic = 0;
487
488 isc_mem_put(mctx, lctx, sizeof(*lctx));
489
490 *lctxp = NULL;
491 }
492
493 void
494 isc_logconfig_destroy(isc_logconfig_t **lcfgp) {
495 isc_logconfig_t *lcfg;
496 isc_mem_t *mctx;
497 isc_logchannel_t *channel;
498 isc_logchannellist_t *item;
499 char *filename;
500 unsigned int i;
501
502 REQUIRE(lcfgp != NULL && VALID_CONFIG(*lcfgp));
503
504 lcfg = *lcfgp;
505
506 /*
507 * This function cannot be called with a logconfig that is in
508 * use by a log context.
509 */
510 REQUIRE(lcfg->lctx != NULL && lcfg->lctx->logconfig != lcfg);
511
512 mctx = lcfg->lctx->mctx;
513
514 while ((channel = ISC_LIST_HEAD(lcfg->channels)) != NULL) {
515 ISC_LIST_UNLINK(lcfg->channels, channel, link);
516
517 if (channel->type == ISC_LOG_TOFILE) {
518 /*
519 * The filename for the channel may have ultimately
520 * started its life in user-land as a const string,
521 * but in isc_log_createchannel it gets copied
522 * into writable memory and is not longer truly const.
523 */
524 DE_CONST(FILE_NAME(channel), filename);
525 isc_mem_free(mctx, filename);
526
527 if (FILE_STREAM(channel) != NULL)
528 (void)fclose(FILE_STREAM(channel));
529 }
530
531 isc_mem_free(mctx, channel->name);
532 isc_mem_put(mctx, channel, sizeof(*channel));
533 }
534
535 for (i = 0; i < lcfg->channellist_count; i++)
536 while ((item = ISC_LIST_HEAD(lcfg->channellists[i])) != NULL) {
537 ISC_LIST_UNLINK(lcfg->channellists[i], item, link);
538 isc_mem_put(mctx, item, sizeof(*item));
539 }
540
541 if (lcfg->channellist_count > 0)
542 isc_mem_put(mctx, lcfg->channellists,
543 lcfg->channellist_count *
544 sizeof(ISC_LIST(isc_logchannellist_t)));
545
546 lcfg->dynamic = ISC_FALSE;
547 if (lcfg->tag != NULL)
548 isc_mem_free(lcfg->lctx->mctx, lcfg->tag);
549 lcfg->tag = NULL;
550 lcfg->highest_level = 0;
551 lcfg->duplicate_interval = 0;
552 lcfg->magic = 0;
553
554 isc_mem_put(mctx, lcfg, sizeof(*lcfg));
555
556 *lcfgp = NULL;
557 }
558
559 void
560 isc_log_registercategories(isc_log_t *lctx, isc_logcategory_t categories[]) {
561 isc_logcategory_t *catp;
562
563 REQUIRE(VALID_CONTEXT(lctx));
564 REQUIRE(categories != NULL && categories[0].name != NULL);
565
566 /*
567 * XXXDCL This somewhat sleazy situation of using the last pointer
568 * in one category array to point to the next array exists because
569 * this registration function returns void and I didn't want to have
570 * change everything that used it by making it return an isc_result_t.
571 * It would need to do that if it had to allocate memory to store
572 * pointers to each array passed in.
573 */
574 if (lctx->categories == NULL)
575 lctx->categories = categories;
576
577 else {
578 /*
579 * Adjust the last (NULL) pointer of the already registered
580 * categories to point to the incoming array.
581 */
582 for (catp = lctx->categories; catp->name != NULL; )
583 if (catp->id == UINT_MAX)
584 /*
585 * The name pointer points to the next array.
586 * Ick.
587 */
588 DE_CONST(catp->name, catp);
589 else
590 catp++;
591
592 catp->name = (void *)categories;
593 catp->id = UINT_MAX;
594 }
595
596 /*
597 * Update the id number of the category with its new global id.
598 */
599 for (catp = categories; catp->name != NULL; catp++)
600 catp->id = lctx->category_count++;
601 }
602
603 isc_logcategory_t *
604 isc_log_categorybyname(isc_log_t *lctx, const char *name) {
605 isc_logcategory_t *catp;
606
607 REQUIRE(VALID_CONTEXT(lctx));
608 REQUIRE(name != NULL);
609
610 for (catp = lctx->categories; catp->name != NULL; )
611 if (catp->id == UINT_MAX)
612 /*
613 * catp is neither modified nor returned to the
614 * caller, so removing its const qualifier is ok.
615 */
616 DE_CONST(catp->name, catp);
617 else {
618 if (strcmp(catp->name, name) == 0)
619 return (catp);
620 catp++;
621 }
622
623 return (NULL);
624 }
625
626 void
627 isc_log_registermodules(isc_log_t *lctx, isc_logmodule_t modules[]) {
628 isc_logmodule_t *modp;
629
630 REQUIRE(VALID_CONTEXT(lctx));
631 REQUIRE(modules != NULL && modules[0].name != NULL);
632
633 /*
634 * XXXDCL This somewhat sleazy situation of using the last pointer
635 * in one category array to point to the next array exists because
636 * this registration function returns void and I didn't want to have
637 * change everything that used it by making it return an isc_result_t.
638 * It would need to do that if it had to allocate memory to store
639 * pointers to each array passed in.
640 */
641 if (lctx->modules == NULL)
642 lctx->modules = modules;
643
644 else {
645 /*
646 * Adjust the last (NULL) pointer of the already registered
647 * modules to point to the incoming array.
648 */
649 for (modp = lctx->modules; modp->name != NULL; )
650 if (modp->id == UINT_MAX)
651 /*
652 * The name pointer points to the next array.
653 * Ick.
654 */
655 DE_CONST(modp->name, modp);
656 else
657 modp++;
658
659 modp->name = (void *)modules;
660 modp->id = UINT_MAX;
661 }
662
663 /*
664 * Update the id number of the module with its new global id.
665 */
666 for (modp = modules; modp->name != NULL; modp++)
667 modp->id = lctx->module_count++;
668 }
669
670 isc_logmodule_t *
671 isc_log_modulebyname(isc_log_t *lctx, const char *name) {
672 isc_logmodule_t *modp;
673
674 REQUIRE(VALID_CONTEXT(lctx));
675 REQUIRE(name != NULL);
676
677 for (modp = lctx->modules; modp->name != NULL; )
678 if (modp->id == UINT_MAX)
679 /*
680 * modp is neither modified nor returned to the
681 * caller, so removing its const qualifier is ok.
682 */
683 DE_CONST(modp->name, modp);
684 else {
685 if (strcmp(modp->name, name) == 0)
686 return (modp);
687 modp++;
688 }
689
690 return (NULL);
691 }
692
693 isc_result_t
694 isc_log_createchannel(isc_logconfig_t *lcfg, const char *name,
695 unsigned int type, int level,
696 const isc_logdestination_t *destination,
697 unsigned int flags)
698 {
699 isc_logchannel_t *channel;
700 isc_mem_t *mctx;
701
702 REQUIRE(VALID_CONFIG(lcfg));
703 REQUIRE(name != NULL);
704 REQUIRE(type == ISC_LOG_TOSYSLOG || type == ISC_LOG_TOFILE ||
705 type == ISC_LOG_TOFILEDESC || type == ISC_LOG_TONULL);
706 REQUIRE(destination != NULL || type == ISC_LOG_TONULL);
707 REQUIRE(level >= ISC_LOG_CRITICAL);
708 REQUIRE((flags &
709 (unsigned int)~(ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY)) == 0);
710
711 /* XXXDCL find duplicate names? */
712
713 mctx = lcfg->lctx->mctx;
714
715 channel = isc_mem_get(mctx, sizeof(*channel));
716 if (channel == NULL)
717 return (ISC_R_NOMEMORY);
718
719 channel->name = isc_mem_strdup(mctx, name);
720 if (channel->name == NULL) {
721 isc_mem_put(mctx, channel, sizeof(*channel));
722 return (ISC_R_NOMEMORY);
723 }
724
725 channel->type = type;
726 channel->level = level;
727 channel->flags = flags;
728 ISC_LINK_INIT(channel, link);
729
730 switch (type) {
731 case ISC_LOG_TOSYSLOG:
732 FACILITY(channel) = destination->facility;
733 break;
734
735 case ISC_LOG_TOFILE:
736 /*
737 * The file name is copied because greatest_version wants
738 * to scribble on it, so it needs to be definitely in
739 * writable memory.
740 */
741 FILE_NAME(channel) =
742 isc_mem_strdup(mctx, destination->file.name);
743 FILE_STREAM(channel) = NULL;
744 FILE_VERSIONS(channel) = destination->file.versions;
745 FILE_MAXSIZE(channel) = destination->file.maximum_size;
746 FILE_MAXREACHED(channel) = ISC_FALSE;
747 break;
748
749 case ISC_LOG_TOFILEDESC:
750 FILE_NAME(channel) = NULL;
751 FILE_STREAM(channel) = destination->file.stream;
752 FILE_MAXSIZE(channel) = 0;
753 FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER;
754 break;
755
756 case ISC_LOG_TONULL:
757 /* Nothing. */
758 break;
759
760 default:
761 isc_mem_put(mctx, channel->name, strlen(channel->name) + 1);
762 isc_mem_put(mctx, channel, sizeof(*channel));
763 return (ISC_R_UNEXPECTED);
764 }
765
766 ISC_LIST_PREPEND(lcfg->channels, channel, link);
767
768 /*
769 * If default_stderr was redefined, make the default category
770 * point to the new default_stderr.
771 */
772 if (strcmp(name, "default_stderr") == 0)
773 default_channel.channel = channel;
774
775 return (ISC_R_SUCCESS);
776 }
777
778 isc_result_t
779 isc_log_usechannel(isc_logconfig_t *lcfg, const char *name,
780 const isc_logcategory_t *category,
781 const isc_logmodule_t *module)
782 {
783 isc_log_t *lctx;
784 isc_logchannel_t *channel;
785 isc_result_t result = ISC_R_SUCCESS;
786 unsigned int i;
787
788 REQUIRE(VALID_CONFIG(lcfg));
789 REQUIRE(name != NULL);
790
791 lctx = lcfg->lctx;
792
793 REQUIRE(category == NULL || category->id < lctx->category_count);
794 REQUIRE(module == NULL || module->id < lctx->module_count);
795
796 for (channel = ISC_LIST_HEAD(lcfg->channels); channel != NULL;
797 channel = ISC_LIST_NEXT(channel, link))
798 if (strcmp(name, channel->name) == 0)
799 break;
800
801 if (channel == NULL)
802 return (ISC_R_NOTFOUND);
803
804 if (category != NULL)
805 result = assignchannel(lcfg, category->id, module, channel);
806
807 else
808 /*
809 * Assign to all categories. Note that this includes
810 * the default channel.
811 */
812 for (i = 0; i < lctx->category_count; i++) {
813 result = assignchannel(lcfg, i, module, channel);
814 if (result != ISC_R_SUCCESS)
815 break;
816 }
817
818 return (result);
819 }
820
821 void
822 isc_log_write(isc_log_t *lctx, isc_logcategory_t *category,
823 isc_logmodule_t *module, int level, const char *format, ...)
824 {
825 va_list args;
826
827 /*
828 * Contract checking is done in isc_log_doit().
829 */
830
831 va_start(args, format);
832 isc_log_doit(lctx, category, module, level, ISC_FALSE,
833 NULL, 0, 0, format, args);
834 va_end(args);
835 }
836
837 void
838 isc_log_vwrite(isc_log_t *lctx, isc_logcategory_t *category,
839 isc_logmodule_t *module, int level,
840 const char *format, va_list args)
841 {
842 /*
843 * Contract checking is done in isc_log_doit().
844 */
845 isc_log_doit(lctx, category, module, level, ISC_FALSE,
846 NULL, 0, 0, format, args);
847 }
848
849 void
850 isc_log_write1(isc_log_t *lctx, isc_logcategory_t *category,
851 isc_logmodule_t *module, int level, const char *format, ...)
852 {
853 va_list args;
854
855 /*
856 * Contract checking is done in isc_log_doit().
857 */
858
859 va_start(args, format);
860 isc_log_doit(lctx, category, module, level, ISC_TRUE,
861 NULL, 0, 0, format, args);
862 va_end(args);
863 }
864
865 void
866 isc_log_vwrite1(isc_log_t *lctx, isc_logcategory_t *category,
867 isc_logmodule_t *module, int level,
868 const char *format, va_list args)
869 {
870 /*
871 * Contract checking is done in isc_log_doit().
872 */
873 isc_log_doit(lctx, category, module, level, ISC_TRUE,
874 NULL, 0, 0, format, args);
875 }
876
877 void
878 isc_log_iwrite(isc_log_t *lctx, isc_logcategory_t *category,
879 isc_logmodule_t *module, int level,
880 isc_msgcat_t *msgcat, int msgset, int msg,
881 const char *format, ...)
882 {
883 va_list args;
884
885 /*
886 * Contract checking is done in isc_log_doit().
887 */
888
889 va_start(args, format);
890 isc_log_doit(lctx, category, module, level, ISC_FALSE,
891 msgcat, msgset, msg, format, args);
892 va_end(args);
893 }
894
895 void
896 isc_log_ivwrite(isc_log_t *lctx, isc_logcategory_t *category,
897 isc_logmodule_t *module, int level,
898 isc_msgcat_t *msgcat, int msgset, int msg,
899 const char *format, va_list args)
900 {
901 /*
902 * Contract checking is done in isc_log_doit().
903 */
904 isc_log_doit(lctx, category, module, level, ISC_FALSE,
905 msgcat, msgset, msg, format, args);
906 }
907
908 void
909 isc_log_iwrite1(isc_log_t *lctx, isc_logcategory_t *category,
910 isc_logmodule_t *module, int level,
911 isc_msgcat_t *msgcat, int msgset, int msg,
912 const char *format, ...)
913 {
914 va_list args;
915
916 /*
917 * Contract checking is done in isc_log_doit().
918 */
919
920 va_start(args, format);
921 isc_log_doit(lctx, category, module, level, ISC_TRUE,
922 msgcat, msgset, msg, format, args);
923 va_end(args);
924 }
925
926 void
927 isc_log_ivwrite1(isc_log_t *lctx, isc_logcategory_t *category,
928 isc_logmodule_t *module, int level,
929 isc_msgcat_t *msgcat, int msgset, int msg,
930 const char *format, va_list args)
931 {
932 /*
933 * Contract checking is done in isc_log_doit().
934 */
935 isc_log_doit(lctx, category, module, level, ISC_TRUE,
936 msgcat, msgset, msg, format, args);
937 }
938
939 void
940 isc_log_setcontext(isc_log_t *lctx) {
941 isc_lctx = lctx;
942 }
943
944 void
945 isc_log_setdebuglevel(isc_log_t *lctx, unsigned int level) {
946 isc_logchannel_t *channel;
947
948 REQUIRE(VALID_CONTEXT(lctx));
949
950 LOCK(&lctx->lock);
951
952 lctx->debug_level = level;
953 /*
954 * Close ISC_LOG_DEBUGONLY channels if level is zero.
955 */
956 if (lctx->debug_level == 0)
957 for (channel = ISC_LIST_HEAD(lctx->logconfig->channels);
958 channel != NULL;
959 channel = ISC_LIST_NEXT(channel, link))
960 if (channel->type == ISC_LOG_TOFILE &&
961 (channel->flags & ISC_LOG_DEBUGONLY) != 0 &&
962 FILE_STREAM(channel) != NULL) {
963 (void)fclose(FILE_STREAM(channel));
964 FILE_STREAM(channel) = NULL;
965 }
966 UNLOCK(&lctx->lock);
967 }
968
969 unsigned int
970 isc_log_getdebuglevel(isc_log_t *lctx) {
971 REQUIRE(VALID_CONTEXT(lctx));
972
973 return (lctx->debug_level);
974 }
975
976 void
977 isc_log_setduplicateinterval(isc_logconfig_t *lcfg, unsigned int interval) {
978 REQUIRE(VALID_CONFIG(lcfg));
979
980 lcfg->duplicate_interval = interval;
981 }
982
983 unsigned int
984 isc_log_getduplicateinterval(isc_logconfig_t *lcfg) {
985 REQUIRE(VALID_CONTEXT(lcfg));
986
987 return (lcfg->duplicate_interval);
988 }
989
990 isc_result_t
991 isc_log_settag(isc_logconfig_t *lcfg, const char *tag) {
992 REQUIRE(VALID_CONFIG(lcfg));
993
994 if (tag != NULL && *tag != '\0') {
995 if (lcfg->tag != NULL)
996 isc_mem_free(lcfg->lctx->mctx, lcfg->tag);
997 lcfg->tag = isc_mem_strdup(lcfg->lctx->mctx, tag);
998 if (lcfg->tag == NULL)
999 return (ISC_R_NOMEMORY);
1000
1001 } else {
1002 if (lcfg->tag != NULL)
1003 isc_mem_free(lcfg->lctx->mctx, lcfg->tag);
1004 lcfg->tag = NULL;
1005 }
1006
1007 return (ISC_R_SUCCESS);
1008 }
1009
1010 char *
1011 isc_log_gettag(isc_logconfig_t *lcfg) {
1012 REQUIRE(VALID_CONFIG(lcfg));
1013
1014 return (lcfg->tag);
1015 }
1016
1017 /* XXXDCL NT -- This interface will assuredly be changing. */
1018 void
1019 isc_log_opensyslog(const char *tag, int options, int facility) {
1020 (void)openlog(tag, options, facility);
1021 }
1022
1023 void
1024 isc_log_closefilelogs(isc_log_t *lctx) {
1025 isc_logchannel_t *channel;
1026
1027 REQUIRE(VALID_CONTEXT(lctx));
1028
1029 LOCK(&lctx->lock);
1030 for (channel = ISC_LIST_HEAD(lctx->logconfig->channels);
1031 channel != NULL;
1032 channel = ISC_LIST_NEXT(channel, link))
1033
1034 if (channel->type == ISC_LOG_TOFILE &&
1035 FILE_STREAM(channel) != NULL) {
1036 (void)fclose(FILE_STREAM(channel));
1037 FILE_STREAM(channel) = NULL;
1038 }
1039 UNLOCK(&lctx->lock);
1040 }
1041
1042 /****
1043 **** Internal functions
1044 ****/
1045
1046 static isc_result_t
1047 assignchannel(isc_logconfig_t *lcfg, unsigned int category_id,
1048 const isc_logmodule_t *module, isc_logchannel_t *channel)
1049 {
1050 isc_logchannellist_t *new_item;
1051 isc_log_t *lctx;
1052 isc_result_t result;
1053
1054 REQUIRE(VALID_CONFIG(lcfg));
1055
1056 lctx = lcfg->lctx;
1057
1058 REQUIRE(category_id < lctx->category_count);
1059 REQUIRE(module == NULL || module->id < lctx->module_count);
1060 REQUIRE(channel != NULL);
1061
1062 /*
1063 * Ensure lcfg->channellist_count == lctx->category_count.
1064 */
1065 result = sync_channellist(lcfg);
1066 if (result != ISC_R_SUCCESS)
1067 return (result);
1068
1069 new_item = isc_mem_get(lctx->mctx, sizeof(*new_item));
1070 if (new_item == NULL)
1071 return (ISC_R_NOMEMORY);
1072
1073 new_item->channel = channel;
1074 new_item->module = module;
1075 ISC_LIST_INITANDPREPEND(lcfg->channellists[category_id],
1076 new_item, link);
1077
1078 /*
1079 * Remember the highest logging level set by any channel in the
1080 * logging config, so isc_log_doit() can quickly return if the
1081 * message is too high to be logged by any channel.
1082 */
1083 if (channel->type != ISC_LOG_TONULL) {
1084 if (lcfg->highest_level < channel->level)
1085 lcfg->highest_level = channel->level;
1086 if (channel->level == ISC_LOG_DYNAMIC)
1087 lcfg->dynamic = ISC_TRUE;
1088 }
1089
1090 return (ISC_R_SUCCESS);
1091 }
1092
1093 /*
1094 * This would ideally be part of isc_log_registercategories(), except then
1095 * that function would have to return isc_result_t instead of void.
1096 */
1097 static isc_result_t
1098 sync_channellist(isc_logconfig_t *lcfg) {
1099 unsigned int bytes;
1100 isc_log_t *lctx;
1101 void *lists;
1102
1103 REQUIRE(VALID_CONFIG(lcfg));
1104
1105 lctx = lcfg->lctx;
1106
1107 REQUIRE(lctx->category_count != 0);
1108
1109 if (lctx->category_count == lcfg->channellist_count)
1110 return (ISC_R_SUCCESS);
1111
1112 bytes = lctx->category_count * sizeof(ISC_LIST(isc_logchannellist_t));
1113
1114 lists = isc_mem_get(lctx->mctx, bytes);
1115
1116 if (lists == NULL)
1117 return (ISC_R_NOMEMORY);
1118
1119 memset(lists, 0, bytes);
1120
1121 if (lcfg->channellist_count != 0) {
1122 bytes = lcfg->channellist_count *
1123 sizeof(ISC_LIST(isc_logchannellist_t));
1124 memcpy(lists, lcfg->channellists, bytes);
1125 isc_mem_put(lctx->mctx, lcfg->channellists, bytes);
1126 }
1127
1128 lcfg->channellists = lists;
1129 lcfg->channellist_count = lctx->category_count;
1130
1131 return (ISC_R_SUCCESS);
1132 }
1133
1134 static isc_result_t
1135 greatest_version(isc_logchannel_t *channel, int *greatestp) {
1136 /* XXXDCL HIGHLY NT */
1137 char *basename, *digit_end;
1138 const char *dirname;
1139 int version, greatest = -1;
1140 unsigned int basenamelen;
1141 isc_dir_t dir;
1142 isc_result_t result;
1143 char sep = '/';
1144 #ifdef _WIN32
1145 char *basename2;
1146 #endif
1147
1148 REQUIRE(channel->type == ISC_LOG_TOFILE);
1149
1150 /*
1151 * It is safe to DE_CONST the file.name because it was copied
1152 * with isc_mem_strdup in isc_log_createchannel.
1153 */
1154 basename = strrchr(FILE_NAME(channel), sep);
1155 #ifdef _WIN32
1156 basename2 = strrchr(FILE_NAME(channel), '\\');
1157 if ((basename != NULL && basename2 != NULL && basename2 > basename) ||
1158 (basename == NULL && basename2 != NULL)) {
1159 basename = basename2;
1160 sep = '\\';
1161 }
1162 #endif
1163 if (basename != NULL) {
1164 *basename++ = '\0';
1165 dirname = FILE_NAME(channel);
1166 } else {
1167 DE_CONST(FILE_NAME(channel), basename);
1168 dirname = ".";
1169 }
1170 basenamelen = strlen(basename);
1171
1172 isc_dir_init(&dir);
1173 result = isc_dir_open(&dir, dirname);
1174
1175 /*
1176 * Replace the file separator if it was taken out.
1177 */
1178 if (basename != FILE_NAME(channel))
1179 *(basename - 1) = sep;
1180
1181 /*
1182 * Return if the directory open failed.
1183 */
1184 if (result != ISC_R_SUCCESS)
1185 return (result);
1186
1187 while (isc_dir_read(&dir) == ISC_R_SUCCESS) {
1188 if (dir.entry.length > basenamelen &&
1189 strncmp(dir.entry.name, basename, basenamelen) == 0 &&
1190 dir.entry.name[basenamelen] == '.') {
1191
1192 version = strtol(&dir.entry.name[basenamelen + 1],
1193 &digit_end, 10);
1194 if (*digit_end == '\0' && version > greatest)
1195 greatest = version;
1196 }
1197 }
1198 isc_dir_close(&dir);
1199
1200 *greatestp = ++greatest;
1201
1202 return (ISC_R_SUCCESS);
1203 }
1204
1205 static isc_result_t
1206 roll_log(isc_logchannel_t *channel) {
1207 int i, n, greatest;
1208 char current[PATH_MAX + 1];
1209 char new[PATH_MAX + 1];
1210 const char *path;
1211 isc_result_t result;
1212
1213 /*
1214 * Do nothing (not even excess version trimming) if ISC_LOG_ROLLNEVER
1215 * is specified. Apparently complete external control over the log
1216 * files is desired.
1217 */
1218 if (FILE_VERSIONS(channel) == ISC_LOG_ROLLNEVER)
1219 return (ISC_R_SUCCESS);
1220
1221 path = FILE_NAME(channel);
1222
1223 /*
1224 * Set greatest_version to the greatest existing version
1225 * (not the maximum requested version). This is 1 based even
1226 * though the file names are 0 based, so an oldest log of log.1
1227 * is a greatest_version of 2.
1228 */
1229 result = greatest_version(channel, &greatest);
1230 if (result != ISC_R_SUCCESS)
1231 return (result);
1232
1233 /*
1234 * Now greatest should be set to the highest version number desired.
1235 * Since the highest number is one less than FILE_VERSIONS(channel)
1236 * when not doing infinite log rolling, greatest will need to be
1237 * decremented when it is equal to -- or greater than --
1238 * FILE_VERSIONS(channel). When greatest is less than
1239 * FILE_VERSIONS(channel), it is already suitable for use as
1240 * the maximum version number.
1241 */
1242
1243 if (FILE_VERSIONS(channel) == ISC_LOG_ROLLINFINITE ||
1244 FILE_VERSIONS(channel) > greatest)
1245 ; /* Do nothing. */
1246 else
1247 /*
1248 * When greatest is >= FILE_VERSIONS(channel), it needs to
1249 * be reduced until it is FILE_VERSIONS(channel) - 1.
1250 * Remove any excess logs on the way to that value.
1251 */
1252 while (--greatest >= FILE_VERSIONS(channel)) {
1253 n = snprintf(current, sizeof(current), "%s.%d",
1254 path, greatest);
1255 if (n >= (int)sizeof(current) || n < 0)
1256 result = ISC_R_NOSPACE;
1257 else
1258 result = isc_file_remove(current);
1259 if (result != ISC_R_SUCCESS &&
1260 result != ISC_R_FILENOTFOUND)
1261 syslog(LOG_ERR,
1262 "unable to remove log file '%s.%d': %s",
1263 path, greatest,
1264 isc_result_totext(result));
1265 }
1266
1267 for (i = greatest; i > 0; i--) {
1268 result = ISC_R_SUCCESS;
1269 n = snprintf(current, sizeof(current), "%s.%d", path, i - 1);
1270 if (n >= (int)sizeof(current) || n < 0)
1271 result = ISC_R_NOSPACE;
1272 if (result == ISC_R_SUCCESS) {
1273 n = snprintf(new, sizeof(new), "%s.%d", path, i);
1274 if (n >= (int)sizeof(new) || n < 0)
1275 result = ISC_R_NOSPACE;
1276 }
1277 if (result == ISC_R_SUCCESS)
1278 result = isc_file_rename(current, new);
1279 if (result != ISC_R_SUCCESS &&
1280 result != ISC_R_FILENOTFOUND)
1281 syslog(LOG_ERR,
1282 "unable to rename log file '%s.%d' to "
1283 "'%s.%d': %s", path, i - 1, path, i,
1284 isc_result_totext(result));
1285 }
1286
1287 if (FILE_VERSIONS(channel) != 0) {
1288 n = snprintf(new, sizeof(new), "%s.0", path);
1289 if (n >= (int)sizeof(new) || n < 0)
1290 result = ISC_R_NOSPACE;
1291 else
1292 result = isc_file_rename(path, new);
1293 if (result != ISC_R_SUCCESS &&
1294 result != ISC_R_FILENOTFOUND)
1295 syslog(LOG_ERR,
1296 "unable to rename log file '%s' to '%s.0': %s",
1297 path, path, isc_result_totext(result));
1298 } else {
1299 result = isc_file_remove(path);
1300 if (result != ISC_R_SUCCESS &&
1301 result != ISC_R_FILENOTFOUND)
1302 syslog(LOG_ERR, "unable to remove log file '%s': %s",
1303 path, isc_result_totext(result));
1304 }
1305
1306 return (ISC_R_SUCCESS);
1307 }
1308
1309 static isc_result_t
1310 isc_log_open(isc_logchannel_t *channel) {
1311 struct stat statbuf;
1312 isc_boolean_t regular_file;
1313 isc_boolean_t roll = ISC_FALSE;
1314 isc_result_t result = ISC_R_SUCCESS;
1315 const char *path;
1316
1317 REQUIRE(channel->type == ISC_LOG_TOFILE);
1318 REQUIRE(FILE_STREAM(channel) == NULL);
1319
1320 path = FILE_NAME(channel);
1321
1322 REQUIRE(path != NULL && *path != '\0');
1323
1324 /*
1325 * Determine type of file; only regular files will be
1326 * version renamed, and only if the base file exists
1327 * and either has no size limit or has reached its size limit.
1328 */
1329 if (stat(path, &statbuf) == 0) {
1330 regular_file = S_ISREG(statbuf.st_mode) ? ISC_TRUE : ISC_FALSE;
1331 /* XXXDCL if not regular_file complain? */
1332 if ((FILE_MAXSIZE(channel) == 0 &&
1333 FILE_VERSIONS(channel) != ISC_LOG_ROLLNEVER) ||
1334 (FILE_MAXSIZE(channel) > 0 &&
1335 statbuf.st_size >= FILE_MAXSIZE(channel)))
1336 roll = regular_file;
1337 } else if (errno == ENOENT)
1338 regular_file = ISC_TRUE;
1339 else
1340 result = ISC_R_INVALIDFILE;
1341
1342 /*
1343 * Version control.
1344 */
1345 if (result == ISC_R_SUCCESS && roll) {
1346 if (FILE_VERSIONS(channel) == ISC_LOG_ROLLNEVER)
1347 return (ISC_R_MAXSIZE);
1348 result = roll_log(channel);
1349 if (result != ISC_R_SUCCESS) {
1350 if ((channel->flags & ISC_LOG_OPENERR) == 0) {
1351 syslog(LOG_ERR,
1352 "isc_log_open: roll_log '%s' "
1353 "failed: %s",
1354 FILE_NAME(channel),
1355 isc_result_totext(result));
1356 channel->flags |= ISC_LOG_OPENERR;
1357 }
1358 return (result);
1359 }
1360 }
1361
1362 result = isc_stdio_open(path, "a", &FILE_STREAM(channel));
1363
1364 return (result);
1365 }
1366
1367 isc_boolean_t
1368 isc_log_wouldlog(isc_log_t *lctx, int level) {
1369 /*
1370 * Try to avoid locking the mutex for messages which can't
1371 * possibly be logged to any channels -- primarily debugging
1372 * messages that the debug level is not high enough to print.
1373 *
1374 * If the level is (mathematically) less than or equal to the
1375 * highest_level, or if there is a dynamic channel and the level is
1376 * less than or equal to the debug level, the main loop must be
1377 * entered to see if the message should really be output.
1378 *
1379 * NOTE: this is UNLOCKED access to the logconfig. However,
1380 * the worst thing that can happen is that a bad decision is made
1381 * about returning without logging, and that's not a big concern,
1382 * because that's a risk anyway if the logconfig is being
1383 * dynamically changed.
1384 */
1385
1386 if (lctx == NULL || lctx->logconfig == NULL)
1387 return (ISC_FALSE);
1388
1389 return (ISC_TF(level <= lctx->logconfig->highest_level ||
1390 (lctx->logconfig->dynamic &&
1391 level <= lctx->debug_level)));
1392 }
1393
1394 static void
1395 isc_log_doit(isc_log_t *lctx, isc_logcategory_t *category,
1396 isc_logmodule_t *module, int level, isc_boolean_t write_once,
1397 isc_msgcat_t *msgcat, int msgset, int msg,
1398 const char *format, va_list args)
1399 {
1400 int syslog_level;
1401 char time_string[64];
1402 char level_string[24];
1403 const char *iformat;
1404 struct stat statbuf;
1405 isc_boolean_t matched = ISC_FALSE;
1406 isc_boolean_t printtime, printtag;
1407 isc_boolean_t printcategory, printmodule, printlevel;
1408 isc_logconfig_t *lcfg;
1409 isc_logchannel_t *channel;
1410 isc_logchannellist_t *category_channels;
1411 isc_result_t result;
1412
1413 REQUIRE(lctx == NULL || VALID_CONTEXT(lctx));
1414 REQUIRE(category != NULL);
1415 REQUIRE(module != NULL);
1416 REQUIRE(level != ISC_LOG_DYNAMIC);
1417 REQUIRE(format != NULL);
1418
1419 /*
1420 * Programs can use libraries that use this logging code without
1421 * wanting to do any logging, thus the log context is allowed to
1422 * be non-existent.
1423 */
1424 if (lctx == NULL)
1425 return;
1426
1427 REQUIRE(category->id < lctx->category_count);
1428 REQUIRE(module->id < lctx->module_count);
1429
1430 if (! isc_log_wouldlog(lctx, level))
1431 return;
1432
1433 if (msgcat != NULL)
1434 iformat = isc_msgcat_get(msgcat, msgset, msg, format);
1435 else
1436 iformat = format;
1437
1438 time_string[0] = '\0';
1439 level_string[0] = '\0';
1440
1441 LOCK(&lctx->lock);
1442
1443 lctx->buffer[0] = '\0';
1444
1445 lcfg = lctx->logconfig;
1446
1447 category_channels = ISC_LIST_HEAD(lcfg->channellists[category->id]);
1448
1449 /*
1450 * XXXDCL add duplicate filtering? (To not write multiple times to
1451 * the same source via various channels).
1452 */
1453 do {
1454 /*
1455 * If the channel list end was reached and a match was made,
1456 * everything is finished.
1457 */
1458 if (category_channels == NULL && matched)
1459 break;
1460
1461 if (category_channels == NULL && ! matched &&
1462 category_channels != ISC_LIST_HEAD(lcfg->channellists[0]))
1463 /*
1464 * No category/module pair was explicitly configured.
1465 * Try the category named "default".
1466 */
1467 category_channels =
1468 ISC_LIST_HEAD(lcfg->channellists[0]);
1469
1470 if (category_channels == NULL && ! matched)
1471 /*
1472 * No matching module was explicitly configured
1473 * for the category named "default". Use the internal
1474 * default channel.
1475 */
1476 category_channels = &default_channel;
1477
1478 if (category_channels->module != NULL &&
1479 category_channels->module != module) {
1480 category_channels = ISC_LIST_NEXT(category_channels,
1481 link);
1482 continue;
1483 }
1484
1485 matched = ISC_TRUE;
1486
1487 channel = category_channels->channel;
1488 category_channels = ISC_LIST_NEXT(category_channels, link);
1489
1490 if (((channel->flags & ISC_LOG_DEBUGONLY) != 0) &&
1491 lctx->debug_level == 0)
1492 continue;
1493
1494 if (channel->level == ISC_LOG_DYNAMIC) {
1495 if (lctx->debug_level < level)
1496 continue;
1497 } else if (channel->level < level)
1498 continue;
1499
1500 if ((channel->flags & ISC_LOG_PRINTTIME) != 0 &&
1501 time_string[0] == '\0') {
1502 isc_time_t isctime;
1503
1504 TIME_NOW(&isctime);
1505 isc_time_formattimestamp(&isctime, time_string,
1506 sizeof(time_string));
1507 }
1508
1509 if ((channel->flags & ISC_LOG_PRINTLEVEL) != 0 &&
1510 level_string[0] == '\0') {
1511 if (level < ISC_LOG_CRITICAL)
1512 snprintf(level_string, sizeof(level_string),
1513 isc_msgcat_get(isc_msgcat,
1514 ISC_MSGSET_LOG,
1515 ISC_MSG_LEVEL,
1516 "level %d: "),
1517 level);
1518 else if (level > ISC_LOG_DYNAMIC)
1519 snprintf(level_string, sizeof(level_string),
1520 "%s %d: ", log_level_strings[0],
1521 level);
1522 else
1523 snprintf(level_string, sizeof(level_string),
1524 "%s: ", log_level_strings[-level]);
1525 }
1526
1527 /*
1528 * Only format the message once.
1529 */
1530 if (lctx->buffer[0] == '\0') {
1531 (void)vsnprintf(lctx->buffer, sizeof(lctx->buffer),
1532 iformat, args);
1533
1534 /*
1535 * Check for duplicates.
1536 */
1537 if (write_once) {
1538 isc_logmessage_t *message, *new;
1539 isc_time_t oldest;
1540 isc_interval_t interval;
1541
1542 isc_interval_set(&interval,
1543 lcfg->duplicate_interval, 0);
1544
1545 /*
1546 * 'oldest' is the age of the oldest messages
1547 * which fall within the duplicate_interval
1548 * range.
1549 */
1550 TIME_NOW(&oldest);
1551 if (isc_time_subtract(&oldest, &interval, &oldest)
1552 != ISC_R_SUCCESS)
1553 /*
1554 * Can't effectively do the checking
1555 * without having a valid time.
1556 */
1557 message = NULL;
1558 else
1559 message =ISC_LIST_HEAD(lctx->messages);
1560
1561 while (message != NULL) {
1562 if (isc_time_compare(&message->time,
1563 &oldest) < 0) {
1564 /*
1565 * This message is older
1566 * than the duplicate_interval,
1567 * so it should be dropped from
1568 * the history.
1569 *
1570 * Setting the interval to be
1571 * to be longer will obviously
1572 * not cause the expired
1573 * message to spring back into
1574 * existence.
1575 */
1576 new = ISC_LIST_NEXT(message,
1577 link);
1578
1579 ISC_LIST_UNLINK(lctx->messages,
1580 message, link);
1581
1582 isc_mem_put(lctx->mctx,
1583 message,
1584 sizeof(*message) + 1 +
1585 strlen(message->text));
1586
1587 message = new;
1588 continue;
1589 }
1590
1591 /*
1592 * This message is in the duplicate
1593 * filtering interval ...
1594 */
1595 if (strcmp(lctx->buffer, message->text)
1596 == 0) {
1597 /*
1598 * ... and it is a duplicate.
1599 * Unlock the mutex and
1600 * get the hell out of Dodge.
1601 */
1602 UNLOCK(&lctx->lock);
1603 return;
1604 }
1605
1606 message = ISC_LIST_NEXT(message, link);
1607 }
1608
1609 /*
1610 * It wasn't in the duplicate interval,
1611 * so add it to the message list.
1612 */
1613 new = isc_mem_get(lctx->mctx,
1614 sizeof(isc_logmessage_t) +
1615 strlen(lctx->buffer) + 1);
1616 if (new != NULL) {
1617 /*
1618 * Put the text immediately after
1619 * the struct. The strcpy is safe.
1620 */
1621 new->text = (char *)(new + 1);
1622 strcpy(new->text, lctx->buffer);
1623
1624 TIME_NOW(&new->time);
1625
1626 ISC_LIST_APPEND(lctx->messages,
1627 new, link);
1628 }
1629 }
1630 }
1631
1632 printtime = ISC_TF((channel->flags & ISC_LOG_PRINTTIME)
1633 != 0);
1634 printtag = ISC_TF((channel->flags & ISC_LOG_PRINTTAG)
1635 != 0 && lcfg->tag != NULL);
1636 printcategory = ISC_TF((channel->flags & ISC_LOG_PRINTCATEGORY)
1637 != 0);
1638 printmodule = ISC_TF((channel->flags & ISC_LOG_PRINTMODULE)
1639 != 0);
1640 printlevel = ISC_TF((channel->flags & ISC_LOG_PRINTLEVEL)
1641 != 0);
1642
1643 switch (channel->type) {
1644 case ISC_LOG_TOFILE:
1645 if (FILE_MAXREACHED(channel)) {
1646 /*
1647 * If the file can be rolled, OR
1648 * If the file no longer exists, OR
1649 * If the file is less than the maximum size,
1650 * (such as if it had been renamed and
1651 * a new one touched, or it was truncated
1652 * in place)
1653 * ... then close it to trigger reopening.
1654 */
1655 if (FILE_VERSIONS(channel) !=
1656 ISC_LOG_ROLLNEVER ||
1657 (stat(FILE_NAME(channel), &statbuf) != 0 &&
1658 errno == ENOENT) ||
1659 statbuf.st_size < FILE_MAXSIZE(channel)) {
1660 (void)fclose(FILE_STREAM(channel));
1661 FILE_STREAM(channel) = NULL;
1662 FILE_MAXREACHED(channel) = ISC_FALSE;
1663 } else
1664 /*
1665 * Eh, skip it.
1666 */
1667 break;
1668 }
1669
1670 if (FILE_STREAM(channel) == NULL) {
1671 result = isc_log_open(channel);
1672 if (result != ISC_R_SUCCESS &&
1673 result != ISC_R_MAXSIZE &&
1674 (channel->flags & ISC_LOG_OPENERR) == 0) {
1675 syslog(LOG_ERR,
1676 "isc_log_open '%s' failed: %s",
1677 FILE_NAME(channel),
1678 isc_result_totext(result));
1679 channel->flags |= ISC_LOG_OPENERR;
1680 }
1681 if (result != ISC_R_SUCCESS)
1682 break;
1683 channel->flags &= ~ISC_LOG_OPENERR;
1684 }
1685 /* FALLTHROUGH */
1686
1687 case ISC_LOG_TOFILEDESC:
1688 fprintf(FILE_STREAM(channel), "%s%s%s%s%s%s%s%s%s%s\n",
1689 printtime ? time_string : "",
1690 printtime ? " " : "",
1691 printtag ? lcfg->tag : "",
1692 printtag ? ": " : "",
1693 printcategory ? category->name : "",
1694 printcategory ? ": " : "",
1695 printmodule ? (module != NULL ? module->name
1696 : "no_module")
1697 : "",
1698 printmodule ? ": " : "",
1699 printlevel ? level_string : "",
1700 lctx->buffer);
1701
1702 fflush(FILE_STREAM(channel));
1703
1704 /*
1705 * If the file now exceeds its maximum size
1706 * threshold, note it so that it will not be logged
1707 * to any more.
1708 */
1709 if (FILE_MAXSIZE(channel) > 0) {
1710 INSIST(channel->type == ISC_LOG_TOFILE);
1711
1712 /* XXXDCL NT fstat/fileno */
1713 /* XXXDCL complain if fstat fails? */
1714 if (fstat(fileno(FILE_STREAM(channel)),
1715 &statbuf) >= 0 &&
1716 statbuf.st_size > FILE_MAXSIZE(channel))
1717 FILE_MAXREACHED(channel) = ISC_TRUE;
1718 }
1719
1720 break;
1721
1722 case ISC_LOG_TOSYSLOG:
1723 if (level > 0)
1724 syslog_level = LOG_DEBUG;
1725 else if (level < ISC_LOG_CRITICAL)
1726 syslog_level = LOG_CRIT;
1727 else
1728 syslog_level = syslog_map[-level];
1729
1730 (void)syslog(FACILITY(channel) | syslog_level,
1731 "%s%s%s%s%s%s%s%s%s%s",
1732 printtime ? time_string : "",
1733 printtime ? " " : "",
1734 printtag ? lcfg->tag : "",
1735 printtag ? ": " : "",
1736 printcategory ? category->name : "",
1737 printcategory ? ": " : "",
1738 printmodule ? (module != NULL ? module->name
1739 : "no_module")
1740 : "",
1741 printmodule ? ": " : "",
1742 printlevel ? level_string : "",
1743 lctx->buffer);
1744 break;
1745
1746 case ISC_LOG_TONULL:
1747 break;
1748
1749 }
1750
1751 } while (1);
1752
1753 UNLOCK(&lctx->lock);
1754 }
DragonFly BSD