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