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