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