PageRenderTime 111ms CodeModel.GetById 27ms app.highlight 72ms RepoModel.GetById 2ms app.codeStats 0ms

/contrib/bind9/lib/isc/log.c

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