lib/util/debug.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Elrond               2002
   6    Copyright (C) Simo Sorce           2002
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "replace.h"
  23 #include <talloc.h>
  24 #include "system/filesys.h"
  25 #include "system/syslog.h"
  26 #include "system/locale.h"
  27 #include "time_basic.h"
  28 #include "close_low_fd.h"
  29 #include "memory.h"
  30 #include "util_strlist.h" /* LIST_SEP */
  31 #include "blocking.h"
  32 #include "debug.h"
  33
  34 /* define what facility to use for syslog */
  35 #ifndef SYSLOG_FACILITY
  36 #define SYSLOG_FACILITY LOG_DAEMON
  37 #endif
  38
  39 /* -------------------------------------------------------------------------- **
  40  * Defines...
  41  */
  42
  43 /*
  44  * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
  45  * for a terminating null byte.
  46  */
  47 #define FORMAT_BUFR_SIZE 1024
  48
  49 /* -------------------------------------------------------------------------- **
  50  * This module implements Samba's debugging utility.
  51  *
  52  * The syntax of a debugging log file is represented as:
  53  *
  54  *  <debugfile> :== { <debugmsg> }
  55  *
  56  *  <debugmsg>  :== <debughdr> '\n' <debugtext>
  57  *
  58  *  <debughdr>  :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
  59  *
  60  *  <debugtext> :== { <debugline> }
  61  *
  62  *  <debugline> :== TEXT '\n'
  63  *
  64  * TEXT     is a string of characters excluding the newline character.
  65  * LEVEL    is the DEBUG level of the message (an integer in the range 0..10).
  66  * TIME     is a timestamp.
  67  * FILENAME is the name of the file from which the debug message was generated.
  68  * FUNCTION is the function from which the debug message was generated.
  69  *
  70  * Basically, what that all means is:
  71  *
  72  * - A debugging log file is made up of debug messages.
  73  *
  74  * - Each debug message is made up of a header and text.  The header is
  75  *   separated from the text by a newline.
  76  *
  77  * - The header begins with the timestamp and debug level of the message
  78  *   enclosed in brackets.  The filename and function from which the
  79  *   message was generated may follow.  The filename is terminated by a
  80  *   colon, and the function name is terminated by parenthesis.
  81  *
  82  * - The message text is made up of zero or more lines, each terminated by
  83  *   a newline.
  84  */
  85
  86 /* state variables for the debug system */
  87 static struct {
  88         bool initialized;
  89         int fd;   /* The log file handle */
  90         enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
  91         const char *prog_name;
  92         bool reopening_logs;
  93         bool schedule_reopen_logs;
  94
  95         struct debug_settings settings;
  96         char *debugf;
  97         debug_callback_fn callback;
  98         void *callback_private;
  99 } state = {
 100         .settings = {
 101                 .timestamp_logs = true
 102         },
 103         .fd = 2 /* stderr by default */
 104 };
 105
 106 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
 107 static int debug_level_to_priority(int level)
 108 {
 109         /*
 110          * map debug levels to syslog() priorities
 111          */
 112         static const int priority_map[] = {
 113                 LOG_ERR,     /* 0 */
 114                 LOG_WARNING, /* 1 */
 115                 LOG_NOTICE,  /* 2 */
 116                 LOG_NOTICE,  /* 3 */
 117                 LOG_NOTICE,  /* 4 */
 118                 LOG_NOTICE,  /* 5 */
 119                 LOG_INFO,    /* 6 */
 120                 LOG_INFO,    /* 7 */
 121                 LOG_INFO,    /* 8 */
 122                 LOG_INFO,    /* 9 */
 123         };
 124         int priority;
 125
 126         if( level >= ARRAY_SIZE(priority_map) || level < 0)
 127                 priority = LOG_DEBUG;
 128         else
 129                 priority = priority_map[level];
 130
 131         return priority;
 132 }
 133 #endif
 134
 135 /* -------------------------------------------------------------------------- **
 136  * Debug backends. When logging to DEBUG_FILE, send the log entries to
 137  * all active backends.
 138  */
 139
 140 static void debug_file_log(int msg_level,
 141                            const char *msg, const char *msg_no_nl)
 142 {
 143         ssize_t ret;
 144
 145         check_log_size();
 146         do {
 147                 ret = write(state.fd, msg, strlen(msg));
 148         } while (ret == -1 && errno == EINTR);
 149 }
 150
 151 #ifdef WITH_SYSLOG
 152 static void debug_syslog_reload(bool enabled, bool previously_enabled,
 153                                 const char *prog_name, char *option)
 154 {
 155         if (enabled && !previously_enabled) {
 156 #ifdef LOG_DAEMON
 157                 openlog(prog_name, LOG_PID, SYSLOG_FACILITY);
 158 #else
 159                 /* for old systems that have no facility codes. */
 160                 openlog(prog_name, LOG_PID );
 161 #endif
 162                 return;
 163         }
 164
 165         if (!enabled && previously_enabled) {
 166                 closelog();
 167         }
 168 }
 169
 170 static void debug_syslog_log(int msg_level,
 171                              const char *msg, const char *msg_no_nl)
 172 {
 173         int priority;
 174
 175         priority = debug_level_to_priority(msg_level);
 176
 177         /*
 178          * Specify the facility to interoperate with other syslog
 179          * callers (vfs_full_audit for example).
 180          */
 181         priority |= SYSLOG_FACILITY;
 182
 183         syslog(priority, "%s", msg);
 184 }
 185 #endif /* WITH_SYSLOG */
 186
 187 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
 188 #include <systemd/sd-journal.h>
 189 static void debug_systemd_log(int msg_level,
 190                               const char *msg, const char *msg_no_nl)
 191 {
 192         sd_journal_send("MESSAGE=%s", msg_no_nl,
 193                         "PRIORITY=%d", debug_level_to_priority(msg_level),
 194                         "LEVEL=%d", msg_level,
 195                         NULL);
 196 }
 197 #endif
 198
 199 #ifdef HAVE_LTTNG_TRACEF
 200 #include <lttng/tracef.h>
 201 static void debug_lttng_log(int msg_level,
 202                             const char *msg, const char *msg_no_nl)
 203 {
 204         tracef(msg_no_nl);
 205 }
 206 #endif /* WITH_LTTNG_TRACEF */
 207
 208 #ifdef HAVE_GPFS
 209 #include "gpfswrap.h"
 210 static void debug_gpfs_reload(bool enabled, bool previously_enabled,
 211                               const char *prog_name, char *option)
 212 {
 213         gpfswrap_init();
 214
 215         if (enabled && !previously_enabled) {
 216                 gpfswrap_init_trace();
 217                 return;
 218         }
 219
 220         if (!enabled && previously_enabled) {
 221                 gpfswrap_fini_trace();
 222                 return;
 223         }
 224
 225         if (enabled) {
 226                 /*
 227                  * Trigger GPFS library to adjust state if necessary.
 228                  */
 229                 gpfswrap_query_trace();
 230         }
 231 }
 232
 233 static void debug_gpfs_log(int msg_level,
 234                            const char *msg, const char *msg_no_nl)
 235 {
 236         gpfswrap_add_trace(msg_level, msg_no_nl);
 237 }
 238 #endif /* HAVE_GPFS */
 239
 240 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
 241 #define DEBUG_RINGBUF_SIZE_OPT "size="
 242
 243 static char *debug_ringbuf;
 244 static size_t debug_ringbuf_size;
 245 static size_t debug_ringbuf_ofs;
 246
 247 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
 248 char *debug_get_ringbuf(void)
 249 {
 250         return debug_ringbuf;
 251 }
 252
 253 /* Return the size of the ringbuf (including a \0 terminator) */
 254 size_t debug_get_ringbuf_size(void)
 255 {
 256         return debug_ringbuf_size;
 257 }
 258
 259 static void debug_ringbuf_reload(bool enabled, bool previously_enabled,
 260                                  const char *prog_name, char *option)
 261 {
 262         bool cmp;
 263         size_t optlen = strlen(DEBUG_RINGBUF_SIZE_OPT);
 264
 265         debug_ringbuf_size = DEBUG_RINGBUF_SIZE;
 266         debug_ringbuf_ofs = 0;
 267
 268         SAFE_FREE(debug_ringbuf);
 269
 270         if (!enabled) {
 271                 return;
 272         }
 273
 274         if (option != NULL) {
 275                 cmp = strncmp(option, DEBUG_RINGBUF_SIZE_OPT, optlen);
 276                 if (cmp == 0) {
 277                         debug_ringbuf_size = (size_t)strtoull(
 278                                 option + optlen, NULL, 10);
 279                 }
 280         }
 281
 282         debug_ringbuf = calloc(debug_ringbuf_size, sizeof(char));
 283         if (debug_ringbuf == NULL) {
 284                 return;
 285         }
 286 }
 287
 288 static void debug_ringbuf_log(int msg_level,
 289                               const char *msg,
 290                               const char *msg_no_nl)
 291 {
 292         size_t msglen = strlen(msg);
 293         size_t allowed_size;
 294
 295         if (debug_ringbuf == NULL) {
 296                 return;
 297         }
 298
 299         /* Ensure the buffer is always \0 terminated */
 300         allowed_size = debug_ringbuf_size - 1;
 301
 302         if (msglen > allowed_size) {
 303                 return;
 304         }
 305
 306         if ((debug_ringbuf_ofs + msglen) < debug_ringbuf_ofs) {
 307                 return;
 308         }
 309
 310         if ((debug_ringbuf_ofs + msglen) > allowed_size) {
 311                 debug_ringbuf_ofs = 0;
 312         }
 313
 314         memcpy(debug_ringbuf + debug_ringbuf_ofs, msg, msglen);
 315         debug_ringbuf_ofs += msglen;
 316 }
 317
 318 static struct debug_backend {
 319         const char *name;
 320         int log_level;
 321         int new_log_level;
 322         void (*reload)(bool enabled, bool prev_enabled,
 323                        const char *prog_name, char *option);
 324         void (*log)(int msg_level, const char *msg, const char *msg_no_nl);
 325         char *option;
 326 } debug_backends[] = {
 327         {
 328                 .name = "file",
 329                 .log = debug_file_log,
 330         },
 331 #ifdef WITH_SYSLOG
 332         {
 333                 .name = "syslog",
 334                 .reload = debug_syslog_reload,
 335                 .log = debug_syslog_log,
 336         },
 337 #endif
 338
 339 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
 340         {
 341                 .name = "systemd",
 342                 .log = debug_systemd_log,
 343         },
 344 #endif
 345
 346 #ifdef HAVE_LTTNG_TRACEF
 347         {
 348                 .name = "lttng",
 349                 .log = debug_lttng_log,
 350         },
 351 #endif
 352
 353 #ifdef HAVE_GPFS
 354         {
 355                 .name = "gpfs",
 356                 .reload = debug_gpfs_reload,
 357                 .log = debug_gpfs_log,
 358         },
 359 #endif
 360         {
 361                 .name = "ringbuf",
 362                 .log = debug_ringbuf_log,
 363                 .reload = debug_ringbuf_reload,
 364         },
 365 };
 366
 367 static struct debug_backend *debug_find_backend(const char *name)
 368 {
 369         unsigned i;
 370
 371         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 372                 if (strcmp(name, debug_backends[i].name) == 0) {
 373                         return &debug_backends[i];
 374                 }
 375         }
 376
 377         return NULL;
 378 }
 379
 380 /*
 381  * parse "backend[:option][@loglevel]
 382  */
 383 static void debug_backend_parse_token(char *tok)
 384 {
 385         char *backend_name_option, *backend_name,*backend_level, *saveptr;
 386         char *backend_option;
 387         struct debug_backend *b;
 388
 389         /*
 390          * First parse into backend[:option] and loglevel
 391          */
 392         backend_name_option = strtok_r(tok, "@\0", &saveptr);
 393         if (backend_name_option == NULL) {
 394                 return;
 395         }
 396
 397         backend_level = strtok_r(NULL, "\0", &saveptr);
 398
 399         /*
 400          * Now parse backend[:option]
 401          */
 402         backend_name = strtok_r(backend_name_option, ":\0", &saveptr);
 403         if (backend_name == NULL) {
 404                 return;
 405         }
 406
 407         backend_option = strtok_r(NULL, "\0", &saveptr);
 408
 409         /*
 410          * Find and update backend
 411          */
 412         b = debug_find_backend(backend_name);
 413         if (b == NULL) {
 414                 return;
 415         }
 416
 417         if (backend_level == NULL) {
 418                 b->new_log_level = MAX_DEBUG_LEVEL;
 419         } else {
 420                 b->new_log_level = atoi(backend_level);
 421         }
 422
 423         if (backend_option != NULL) {
 424                 b->option = strdup(backend_option);
 425                 if (b->option == NULL) {
 426                         return;
 427                 }
 428         }
 429 }
 430
 431 /*
 432  * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
 433  * and enable/disable backends accordingly
 434  */
 435 static void debug_set_backends(const char *param)
 436 {
 437         size_t str_len = strlen(param);
 438         char str[str_len+1];
 439         char *tok, *saveptr;
 440         unsigned i;
 441
 442         /*
 443          * initialize new_log_level to detect backends that have been
 444          * disabled
 445          */
 446         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 447                 SAFE_FREE(debug_backends[i].option);
 448                 debug_backends[i].new_log_level = -1;
 449         }
 450
 451         memcpy(str, param, str_len + 1);
 452
 453         tok = strtok_r(str, LIST_SEP, &saveptr);
 454         if (tok == NULL) {
 455                 return;
 456         }
 457
 458         while (tok != NULL) {
 459                 debug_backend_parse_token(tok);
 460                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 461         }
 462
 463         /*
 464          * Let backends react to config changes
 465          */
 466         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 467                 struct debug_backend *b = &debug_backends[i];
 468
 469                 if (b->reload) {
 470                         bool enabled = b->new_log_level > -1;
 471                         bool previously_enabled = b->log_level > -1;
 472
 473                         b->reload(enabled, previously_enabled, state.prog_name,
 474                                   b->option);
 475                 }
 476                 b->log_level = b->new_log_level;
 477         }
 478 }
 479
 480 static void debug_backends_log(const char *msg, int msg_level)
 481 {
 482         char msg_no_nl[FORMAT_BUFR_SIZE];
 483         unsigned i;
 484         int len;
 485
 486         /*
 487          * Some backends already add an extra newline, so also provide
 488          * a buffer without the newline character.
 489          */
 490         len = MIN(strlen(msg), FORMAT_BUFR_SIZE - 1);
 491         if (msg[len - 1] == '\n') {
 492                 len--;
 493         }
 494
 495         memcpy(msg_no_nl, msg, len);
 496         msg_no_nl[len] = '\0';
 497
 498         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 499                 if (msg_level <= debug_backends[i].log_level) {
 500                         debug_backends[i].log(msg_level, msg, msg_no_nl);
 501                 }
 502         }
 503 }
 504
 505 /* -------------------------------------------------------------------------- **
 506  * External variables.
 507  */
 508
 509 /*
 510    used to check if the user specified a
 511    logfile on the command line
 512 */
 513 bool    override_logfile;
 514
 515 static const char *default_classname_table[] = {
 516         [DBGC_ALL] =            "all",
 517         [DBGC_TDB] =            "tdb",
 518         [DBGC_PRINTDRIVERS] =   "printdrivers",
 519         [DBGC_LANMAN] =         "lanman",
 520         [DBGC_SMB] =            "smb",
 521         [DBGC_RPC_PARSE] =      "rpc_parse",
 522         [DBGC_RPC_SRV] =        "rpc_srv",
 523         [DBGC_RPC_CLI] =        "rpc_cli",
 524         [DBGC_PASSDB] =         "passdb",
 525         [DBGC_SAM] =            "sam",
 526         [DBGC_AUTH] =           "auth",
 527         [DBGC_WINBIND] =        "winbind",
 528         [DBGC_VFS] =            "vfs",
 529         [DBGC_IDMAP] =          "idmap",
 530         [DBGC_QUOTA] =          "quota",
 531         [DBGC_ACLS] =           "acls",
 532         [DBGC_LOCKING] =        "locking",
 533         [DBGC_MSDFS] =          "msdfs",
 534         [DBGC_DMAPI] =          "dmapi",
 535         [DBGC_REGISTRY] =       "registry",
 536         [DBGC_SCAVENGER] =      "scavenger",
 537         [DBGC_DNS] =            "dns",
 538         [DBGC_LDB] =            "ldb",
 539         [DBGC_TEVENT] =         "tevent",
 540         [DBGC_AUTH_AUDIT] =     "auth_audit",
 541         [DBGC_AUTH_AUDIT_JSON] = "auth_json_audit",
 542 };
 543
 544 /*
 545  * This is to allow reading of DEBUGLEVEL_CLASS before the debug
 546  * system has been initialized.
 547  */
 548 static const int debug_class_list_initial[ARRAY_SIZE(default_classname_table)];
 549
 550 static int debug_num_classes = 0;
 551 int     *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
 552
 553
 554 /* -------------------------------------------------------------------------- **
 555  * Internal variables.
 556  *
 557  *  debug_count     - Number of debug messages that have been output.
 558  *                    Used to check log size.
 559  *
 560  *  current_msg_level    - Internal copy of the message debug level.  Written by
 561  *                    dbghdr() and read by Debug1().
 562  *
 563  *  format_bufr     - Used to format debug messages.  The dbgtext() function
 564  *                    prints debug messages to a string, and then passes the
 565  *                    string to format_debug_text(), which uses format_bufr
 566  *                    to build the formatted output.
 567  *
 568  *  format_pos      - Marks the first free byte of the format_bufr.
 569  *
 570  *
 571  *  log_overflow    - When this variable is true, never attempt to check the
 572  *                    size of the log. This is a hack, so that we can write
 573  *                    a message using DEBUG, from open_logs() when we
 574  *                    are unable to open a new log file for some reason.
 575  */
 576
 577 static int     debug_count    = 0;
 578 static int     current_msg_level   = 0;
 579 static char format_bufr[FORMAT_BUFR_SIZE];
 580 static size_t     format_pos     = 0;
 581 static bool    log_overflow   = false;
 582
 583 /*
 584  * Define all the debug class selection names here. Names *MUST NOT* contain
 585  * white space. There must be one name for each DBGC_<class name>, and they
 586  * must be in the table in the order of DBGC_<class name>..
 587  */
 588
 589 static char **classname_table = NULL;
 590
 591
 592 /* -------------------------------------------------------------------------- **
 593  * Functions...
 594  */
 595
 596 static void debug_init(void);
 597
 598 /***************************************************************************
 599  Free memory pointed to by global pointers.
 600 ****************************************************************************/
 601
 602 void gfree_debugsyms(void)
 603 {
 604         unsigned i;
 605
 606         TALLOC_FREE(classname_table);
 607
 608         if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
 609                 TALLOC_FREE( DEBUGLEVEL_CLASS );
 610                 DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
 611         }
 612
 613         debug_num_classes = 0;
 614
 615         state.initialized = false;
 616
 617         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 618                 SAFE_FREE(debug_backends[i].option);
 619         }
 620 }
 621
 622 /****************************************************************************
 623 utility lists registered debug class names's
 624 ****************************************************************************/
 625
 626 char *debug_list_class_names_and_levels(void)
 627 {
 628         char *buf = NULL;
 629         unsigned int i;
 630         /* prepare strings */
 631         for (i = 0; i < debug_num_classes; i++) {
 632                 buf = talloc_asprintf_append(buf,
 633                                              "%s:%d%s",
 634                                              classname_table[i],
 635                                              DEBUGLEVEL_CLASS[i],
 636                                              i == (debug_num_classes - 1) ? "\n" : " ");
 637                 if (buf == NULL) {
 638                         return NULL;
 639                 }
 640         }
 641         return buf;
 642 }
 643
 644 /****************************************************************************
 645  Utility to translate names to debug class index's (internal version).
 646 ****************************************************************************/
 647
 648 static int debug_lookup_classname_int(const char* classname)
 649 {
 650         int i;
 651
 652         if (!classname) return -1;
 653
 654         for (i=0; i < debug_num_classes; i++) {
 655                 if (strcmp(classname, classname_table[i])==0)
 656                         return i;
 657         }
 658         return -1;
 659 }
 660
 661 /****************************************************************************
 662  Add a new debug class to the system.
 663 ****************************************************************************/
 664
 665 int debug_add_class(const char *classname)
 666 {
 667         int ndx;
 668         int *new_class_list;
 669         char **new_name_list;
 670         int default_level;
 671
 672         if (!classname)
 673                 return -1;
 674
 675         /* check the init has yet been called */
 676         debug_init();
 677
 678         ndx = debug_lookup_classname_int(classname);
 679         if (ndx >= 0)
 680                 return ndx;
 681         ndx = debug_num_classes;
 682
 683         if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
 684                 /* Initial loading... */
 685                 new_class_list = NULL;
 686         } else {
 687                 new_class_list = DEBUGLEVEL_CLASS;
 688         }
 689
 690         default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
 691
 692         new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
 693         if (!new_class_list)
 694                 return -1;
 695         DEBUGLEVEL_CLASS = new_class_list;
 696
 697         DEBUGLEVEL_CLASS[ndx] = default_level;
 698
 699         new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
 700         if (!new_name_list)
 701                 return -1;
 702         classname_table = new_name_list;
 703
 704         classname_table[ndx] = talloc_strdup(classname_table, classname);
 705         if (! classname_table[ndx])
 706                 return -1;
 707
 708         debug_num_classes = ndx + 1;
 709
 710         return ndx;
 711 }
 712
 713 /****************************************************************************
 714  Utility to translate names to debug class index's (public version).
 715 ****************************************************************************/
 716
 717 static int debug_lookup_classname(const char *classname)
 718 {
 719         int ndx;
 720
 721         if (!classname || !*classname)
 722                 return -1;
 723
 724         ndx = debug_lookup_classname_int(classname);
 725
 726         if (ndx != -1)
 727                 return ndx;
 728
 729         DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
 730                   classname));
 731         return debug_add_class(classname);
 732 }
 733
 734 /****************************************************************************
 735  Dump the current registered debug levels.
 736 ****************************************************************************/
 737
 738 static void debug_dump_status(int level)
 739 {
 740         int q;
 741
 742         DEBUG(level, ("INFO: Current debug levels:\n"));
 743         for (q = 0; q < debug_num_classes; q++) {
 744                 const char *classname = classname_table[q];
 745                 DEBUGADD(level, ("  %s: %d\n",
 746                                  classname,
 747                                  DEBUGLEVEL_CLASS[q]));
 748         }
 749 }
 750
 751 static bool debug_parse_param(char *param)
 752 {
 753         char *class_name;
 754         char *class_level;
 755         char *saveptr = NULL;
 756         int ndx;
 757
 758         class_name = strtok_r(param, ":", &saveptr);
 759         if (class_name == NULL) {
 760                 return false;
 761         }
 762
 763         class_level = strtok_r(NULL, "\0", &saveptr);
 764         if (class_level == NULL) {
 765                 return false;
 766         }
 767
 768         ndx = debug_lookup_classname(class_name);
 769         if (ndx == -1) {
 770                 return false;
 771         }
 772
 773         DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
 774
 775         return true;
 776 }
 777
 778 /****************************************************************************
 779  Parse the debug levels from smb.conf. Example debug level string:
 780   3 tdb:5 printdrivers:7
 781  Note: the 1st param has no "name:" preceeding it.
 782 ****************************************************************************/
 783
 784 bool debug_parse_levels(const char *params_str)
 785 {
 786         size_t str_len = strlen(params_str);
 787         char str[str_len+1];
 788         char *tok, *saveptr;
 789         int i;
 790
 791         /* Just in case */
 792         debug_init();
 793
 794         memcpy(str, params_str, str_len+1);
 795
 796         tok = strtok_r(str, LIST_SEP, &saveptr);
 797         if (tok == NULL) {
 798                 return true;
 799         }
 800
 801         /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
 802          * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
 803          */
 804         if (isdigit(tok[0])) {
 805                 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(tok);
 806                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 807         } else {
 808                 DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
 809         }
 810
 811         /* Array is debug_num_classes long */
 812         for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
 813                 DEBUGLEVEL_CLASS[i] = DEBUGLEVEL_CLASS[DBGC_ALL];
 814         }
 815
 816         while (tok != NULL) {
 817                 bool ok;
 818
 819                 ok = debug_parse_param(tok);
 820                 if (!ok) {
 821                         DEBUG(0,("debug_parse_params: unrecognized debug "
 822                                  "class name or format [%s]\n", tok));
 823                         return false;
 824                 }
 825
 826                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 827         }
 828
 829         debug_dump_status(5);
 830
 831         return true;
 832 }
 833
 834 /* setup for logging of talloc warnings */
 835 static void talloc_log_fn(const char *msg)
 836 {
 837         DEBUG(0,("%s", msg));
 838 }
 839
 840 void debug_setup_talloc_log(void)
 841 {
 842         talloc_set_log_fn(talloc_log_fn);
 843 }
 844
 845
 846 /****************************************************************************
 847 Init debugging (one time stuff)
 848 ****************************************************************************/
 849
 850 static void debug_init(void)
 851 {
 852         size_t i;
 853
 854         if (state.initialized)
 855                 return;
 856
 857         state.initialized = true;
 858
 859         debug_setup_talloc_log();
 860
 861         for (i = 0; i < ARRAY_SIZE(default_classname_table); i++) {
 862                 debug_add_class(default_classname_table[i]);
 863         }
 864
 865         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 866                 debug_backends[i].log_level = -1;
 867                 debug_backends[i].new_log_level = -1;
 868         }
 869 }
 870
 871 void debug_set_settings(struct debug_settings *settings,
 872                         const char *logging_param,
 873                         int syslog_level, bool syslog_only)
 874 {
 875         char fake_param[256];
 876         size_t len = 0;
 877
 878         /*
 879          * This forces in some smb.conf derived values into the debug
 880          * system. There are no pointers in this structure, so we can
 881          * just structure-assign it in
 882          */
 883         state.settings = *settings;
 884
 885         /*
 886          * If 'logging' is not set, create backend settings from
 887          * deprecated 'syslog' and 'syslog only' parameters
 888          */
 889         if (logging_param != NULL) {
 890                 len = strlen(logging_param);
 891         }
 892         if (len == 0) {
 893                 if (syslog_only) {
 894                         snprintf(fake_param, sizeof(fake_param),
 895                                  "syslog@%d", syslog_level - 1);
 896                 } else {
 897                         snprintf(fake_param, sizeof(fake_param),
 898                                  "syslog@%d file@%d", syslog_level -1,
 899                                  MAX_DEBUG_LEVEL);
 900                 }
 901
 902                 logging_param = fake_param;
 903         }
 904
 905         debug_set_backends(logging_param);
 906 }
 907
 908 /**
 909   control the name of the logfile and whether logging will be to stdout, stderr
 910   or a file, and set up syslog
 911
 912   new_log indicates the destination for the debug log (an enum in
 913   order of precedence - once set to DEBUG_FILE, it is not possible to
 914   reset to DEBUG_STDOUT for example.  This makes it easy to override
 915   for debug to stderr on the command line, as the smb.conf cannot
 916   reset it back to file-based logging
 917 */
 918 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
 919 {
 920         debug_init();
 921         if (state.logtype < new_logtype) {
 922                 state.logtype = new_logtype;
 923         }
 924         if (prog_name) {
 925                 const char *p = strrchr(prog_name, '/');
 926
 927                 if (p) {
 928                         prog_name = p + 1;
 929                 }
 930
 931                 state.prog_name = prog_name;
 932         }
 933         reopen_logs_internal();
 934 }
 935
 936 /***************************************************************************
 937  Set the logfile name.
 938 **************************************************************************/
 939
 940 void debug_set_logfile(const char *name)
 941 {
 942         if (name == NULL || *name == 0) {
 943                 /* this copes with calls when smb.conf is not loaded yet */
 944                 return;
 945         }
 946         TALLOC_FREE(state.debugf);
 947         state.debugf = talloc_strdup(NULL, name);
 948 }
 949
 950 static void debug_close_fd(int fd)
 951 {
 952         if (fd > 2) {
 953                 close(fd);
 954         }
 955 }
 956
 957 bool debug_get_output_is_stderr(void)
 958 {
 959         return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
 960 }
 961
 962 bool debug_get_output_is_stdout(void)
 963 {
 964         return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
 965 }
 966
 967 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
 968 {
 969         debug_init();
 970         if (fn) {
 971                 state.logtype = DEBUG_CALLBACK;
 972                 state.callback_private = private_ptr;
 973                 state.callback = fn;
 974         } else {
 975                 state.logtype = DEBUG_DEFAULT_STDERR;
 976                 state.callback_private = NULL;
 977                 state.callback = NULL;
 978         }
 979 }
 980
 981 static void debug_callback_log(const char *msg, int msg_level)
 982 {
 983         size_t msg_len = strlen(msg);
 984         char msg_copy[msg_len];
 985
 986         if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
 987                 memcpy(msg_copy, msg, msg_len-1);
 988                 msg_copy[msg_len-1] = '\0';
 989                 msg = msg_copy;
 990         }
 991
 992         state.callback(state.callback_private, msg_level, msg);
 993 }
 994
 995 /**************************************************************************
 996  reopen the log files
 997  note that we now do this unconditionally
 998  We attempt to open the new debug fp before closing the old. This means
 999  if we run out of fd's we just keep using the old fd rather than aborting.
1000  Fix from dgibson@linuxcare.com.
1001 **************************************************************************/
1002
1003 /**
1004   reopen the log file (usually called because the log file name might have changed)
1005 */
1006 bool reopen_logs_internal(void)
1007 {
1008         mode_t oldumask;
1009         int new_fd = 0;
1010         int old_fd = 0;
1011         bool ret = true;
1012
1013         if (state.reopening_logs) {
1014                 return true;
1015         }
1016
1017         /* Now clear the SIGHUP induced flag */
1018         state.schedule_reopen_logs = false;
1019
1020         switch (state.logtype) {
1021         case DEBUG_CALLBACK:
1022                 return true;
1023         case DEBUG_STDOUT:
1024         case DEBUG_DEFAULT_STDOUT:
1025                 debug_close_fd(state.fd);
1026                 state.fd = 1;
1027                 return true;
1028
1029         case DEBUG_DEFAULT_STDERR:
1030         case DEBUG_STDERR:
1031                 debug_close_fd(state.fd);
1032                 state.fd = 2;
1033                 return true;
1034
1035         case DEBUG_FILE:
1036                 break;
1037         }
1038
1039         oldumask = umask( 022 );
1040
1041         if (!state.debugf) {
1042                 return false;
1043         }
1044
1045         state.reopening_logs = true;
1046
1047         new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
1048
1049         if (new_fd == -1) {
1050                 log_overflow = true;
1051                 DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
1052                 log_overflow = false;
1053                 ret = false;
1054         } else {
1055                 smb_set_close_on_exec(new_fd);
1056                 old_fd = state.fd;
1057                 state.fd = new_fd;
1058                 debug_close_fd(old_fd);
1059         }
1060
1061         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1062          * to fix problem where smbd's that generate less
1063          * than 100 messages keep growing the log.
1064          */
1065         force_check_log_size();
1066         (void)umask(oldumask);
1067
1068         /* Take over stderr to catch output into logs */
1069         if (state.fd > 0) {
1070                 if (dup2(state.fd, 2) == -1) {
1071                         /* Close stderr too, if dup2 can't point it -
1072                            at the logfile.  There really isn't much
1073                            that can be done on such a fundamental
1074                            failure... */
1075                         close_low_fd(2);
1076                 }
1077         }
1078
1079         state.reopening_logs = false;
1080
1081         return ret;
1082 }
1083
1084 /**************************************************************************
1085  Force a check of the log size.
1086  ***************************************************************************/
1087
1088 void force_check_log_size( void )
1089 {
1090         debug_count = 100;
1091 }
1092
1093 _PUBLIC_ void debug_schedule_reopen_logs(void)
1094 {
1095         state.schedule_reopen_logs = true;
1096 }
1097
1098
1099 /***************************************************************************
1100  Check to see if there is any need to check if the logfile has grown too big.
1101 **************************************************************************/
1102
1103 bool need_to_check_log_size( void )
1104 {
1105         int maxlog;
1106
1107         if( debug_count < 100)
1108                 return( false );
1109
1110         maxlog = state.settings.max_log_size * 1024;
1111         if ( state.fd <=2 || maxlog <= 0 ) {
1112                 debug_count = 0;
1113                 return(false);
1114         }
1115         return( true );
1116 }
1117
1118 /**************************************************************************
1119  Check to see if the log has grown to be too big.
1120  **************************************************************************/
1121
1122 void check_log_size( void )
1123 {
1124         int         maxlog;
1125         struct stat st;
1126
1127         /*
1128          *  We need to be root to check/change log-file, skip this and let the main
1129          *  loop check do a new check as root.
1130          */
1131
1132 #if _SAMBA_BUILD_ == 3
1133         if (geteuid() != sec_initial_uid())
1134 #else
1135         if( geteuid() != 0)
1136 #endif
1137         {
1138                 /* We don't check sec_initial_uid() here as it isn't
1139                  * available in common code and we don't generally
1140                  * want to rotate and the possibly lose logs in
1141                  * make test or the build farm */
1142                 return;
1143         }
1144
1145         if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
1146                 return;
1147         }
1148
1149         maxlog = state.settings.max_log_size * 1024;
1150
1151         if (state.schedule_reopen_logs) {
1152             (void)reopen_logs_internal();
1153         }
1154
1155         if (maxlog && (fstat(state.fd, &st) == 0
1156             && st.st_size > maxlog )) {
1157                 (void)reopen_logs_internal();
1158                 if (state.fd > 2 && (fstat(state.fd, &st) == 0
1159                                      && st.st_size > maxlog)) {
1160                         char name[strlen(state.debugf) + 5];
1161
1162                         snprintf(name, sizeof(name), "%s.old", state.debugf);
1163
1164                         (void)rename(state.debugf, name);
1165
1166                         if (!reopen_logs_internal()) {
1167                                 /* We failed to reopen a log - continue using the old name. */
1168                                 (void)rename(name, state.debugf);
1169                         }
1170                 }
1171         }
1172
1173         /*
1174          * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
1175          */
1176
1177         if (state.fd <= 0) {
1178                 /* This code should only be reached in very strange
1179                  * circumstances. If we merely fail to open the new log we
1180                  * should stick with the old one. ergo this should only be
1181                  * reached when opening the logs for the first time: at
1182                  * startup or when the log level is increased from zero.
1183                  * -dwg 6 June 2000
1184                  */
1185                 int fd = open( "/dev/console", O_WRONLY, 0);
1186                 if (fd != -1) {
1187                         smb_set_close_on_exec(fd);
1188                         state.fd = fd;
1189                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
1190                                         state.debugf ));
1191                 } else {
1192                         /*
1193                          * We cannot continue without a debug file handle.
1194                          */
1195                         abort();
1196                 }
1197         }
1198         debug_count = 0;
1199 }
1200
1201 /*************************************************************************
1202  Write an debug message on the debugfile.
1203  This is called by dbghdr() and format_debug_text().
1204 ************************************************************************/
1205
1206 static void Debug1(const char *msg)
1207 {
1208         int old_errno = errno;
1209
1210         debug_count++;
1211
1212         switch(state.logtype) {
1213         case DEBUG_CALLBACK:
1214                 debug_callback_log(msg, current_msg_level);
1215                 break;
1216         case DEBUG_STDOUT:
1217         case DEBUG_STDERR:
1218         case DEBUG_DEFAULT_STDOUT:
1219         case DEBUG_DEFAULT_STDERR:
1220                 if (state.fd > 0) {
1221                         ssize_t ret;
1222                         do {
1223                                 ret = write(state.fd, msg, strlen(msg));
1224                         } while (ret == -1 && errno == EINTR);
1225                 }
1226                 break;
1227         case DEBUG_FILE:
1228                 debug_backends_log(msg, current_msg_level);
1229                 break;
1230         };
1231
1232         errno = old_errno;
1233 }
1234
1235 /**************************************************************************
1236  Print the buffer content via Debug1(), then reset the buffer.
1237  Input:  none
1238  Output: none
1239 ****************************************************************************/
1240
1241 static void bufr_print( void )
1242 {
1243         format_bufr[format_pos] = '\0';
1244         (void)Debug1(format_bufr);
1245         format_pos = 0;
1246 }
1247
1248 /***************************************************************************
1249  Format the debug message text.
1250
1251  Input:  msg - Text to be added to the "current" debug message text.
1252
1253  Output: none.
1254
1255  Notes:  The purpose of this is two-fold.  First, each call to syslog()
1256          (used by Debug1(), see above) generates a new line of syslog
1257          output.  This is fixed by storing the partial lines until the
1258          newline character is encountered.  Second, printing the debug
1259          message lines when a newline is encountered allows us to add
1260          spaces, thus indenting the body of the message and making it
1261          more readable.
1262 **************************************************************************/
1263
1264 static void format_debug_text( const char *msg )
1265 {
1266         size_t i;
1267         bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
1268
1269         debug_init();
1270
1271         for( i = 0; msg[i]; i++ ) {
1272                 /* Indent two spaces at each new line. */
1273                 if(timestamp && 0 == format_pos) {
1274                         format_bufr[0] = format_bufr[1] = ' ';
1275                         format_pos = 2;
1276                 }
1277
1278                 /* If there's room, copy the character to the format buffer. */
1279                 if (format_pos < FORMAT_BUFR_SIZE - 1)
1280                         format_bufr[format_pos++] = msg[i];
1281
1282                 /* If a newline is encountered, print & restart. */
1283                 if( '\n' == msg[i] )
1284                         bufr_print();
1285
1286                 /* If the buffer is full dump it out, reset it, and put out a line
1287                  * continuation indicator.
1288                  */
1289                 if (format_pos >= FORMAT_BUFR_SIZE - 1) {
1290                         bufr_print();
1291                         (void)Debug1( " +>\n" );
1292                 }
1293         }
1294
1295         /* Just to be safe... */
1296         format_bufr[format_pos] = '\0';
1297 }
1298
1299 /***************************************************************************
1300  Flush debug output, including the format buffer content.
1301
1302  Input:  none
1303  Output: none
1304 ***************************************************************************/
1305
1306 void dbgflush( void )
1307 {
1308         bufr_print();
1309 }
1310
1311 /***************************************************************************
1312  Print a Debug Header.
1313
1314  Input:  level    - Debug level of the message (not the system-wide debug
1315                     level. )
1316          cls      - Debuglevel class of the calling module.
1317          location - Pointer to a string containing the name of the file
1318                     from which this function was called, or an empty string
1319                     if the __FILE__ macro is not implemented.
1320          func     - Pointer to a string containing the name of the function
1321                     from which this function was called, or an empty string
1322                     if the __FUNCTION__ macro is not implemented.
1323
1324  Output: Always true.  This makes it easy to fudge a call to dbghdr()
1325          in a macro, since the function can be called as part of a test.
1326          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1327
1328  Notes:  This function takes care of setting current_msg_level.
1329
1330 ****************************************************************************/
1331
1332 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1333 {
1334         /* Ensure we don't lose any real errno value. */
1335         int old_errno = errno;
1336         bool verbose = false;
1337         char header_str[300];
1338         size_t hs_len;
1339         struct timeval tv;
1340         struct timeval_buf tvbuf;
1341
1342         if( format_pos ) {
1343                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
1344                  * the *right* thing to do is to call
1345                  *   format_debug_text( "\n" );
1346                  * to write the remainder, and then proceed with the new header.
1347                  * Unfortunately, there are several places in the code at which
1348                  * the DEBUG() macro is used to build partial lines.  That in mind,
1349                  * we'll work under the assumption that an incomplete line indicates
1350                  * that a new header is *not* desired.
1351                  */
1352                 return( true );
1353         }
1354
1355         /* Set current_msg_level. */
1356         current_msg_level = level;
1357
1358         /* Don't print a header if we're logging to stdout. */
1359         if ( state.logtype != DEBUG_FILE ) {
1360                 return( true );
1361         }
1362
1363         /* Print the header if timestamps are turned on.  If parameters are
1364          * not yet loaded, then default to timestamps on.
1365          */
1366         if (!(state.settings.timestamp_logs ||
1367               state.settings.debug_prefix_timestamp)) {
1368                 return true;
1369         }
1370
1371         GetTimeOfDay(&tv);
1372         timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
1373                         &tvbuf);
1374
1375         hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
1376                           tvbuf.buf, level);
1377         if (hs_len >= sizeof(header_str)) {
1378                 goto full;
1379         }
1380
1381         if (unlikely(DEBUGLEVEL_CLASS[ cls ] >= 10)) {
1382                 verbose = true;
1383         }
1384
1385         if (verbose || state.settings.debug_pid) {
1386                 hs_len += snprintf(
1387                         header_str + hs_len, sizeof(header_str) - hs_len,
1388                         ", pid=%u", (unsigned int)getpid());
1389                 if (hs_len >= sizeof(header_str)) {
1390                         goto full;
1391                 }
1392         }
1393
1394         if (verbose || state.settings.debug_uid) {
1395                 hs_len += snprintf(
1396                         header_str + hs_len, sizeof(header_str) - hs_len,
1397                         ", effective(%u, %u), real(%u, %u)",
1398                         (unsigned int)geteuid(), (unsigned int)getegid(),
1399                         (unsigned int)getuid(), (unsigned int)getgid());
1400                 if (hs_len >= sizeof(header_str)) {
1401                         goto full;
1402                 }
1403         }
1404
1405         if ((verbose || state.settings.debug_class)
1406             && (cls != DBGC_ALL)) {
1407                 hs_len += snprintf(
1408                         header_str + hs_len, sizeof(header_str) - hs_len,
1409                         ", class=%s", classname_table[cls]);
1410                 if (hs_len >= sizeof(header_str)) {
1411                         goto full;
1412                 }
1413         }
1414
1415         /*
1416          * No +=, see man man strlcat
1417          */
1418         hs_len = strlcat(header_str, "] ", sizeof(header_str));
1419         if (hs_len >= sizeof(header_str)) {
1420                 goto full;
1421         }
1422
1423         if (!state.settings.debug_prefix_timestamp) {
1424                 hs_len += snprintf(
1425                         header_str + hs_len, sizeof(header_str) - hs_len,
1426                         "%s(%s)\n", location, func);
1427                 if (hs_len >= sizeof(header_str)) {
1428                         goto full;
1429                 }
1430         }
1431
1432 full:
1433         (void)Debug1(header_str);
1434
1435         errno = old_errno;
1436         return( true );
1437 }
1438
1439 /***************************************************************************
1440  Add text to the body of the "current" debug message via the format buffer.
1441
1442   Input:  format_str  - Format string, as used in printf(), et. al.
1443           ...         - Variable argument list.
1444
1445   ..or..  va_alist    - Old style variable parameter list starting point.
1446
1447   Output: Always true.  See dbghdr() for more info, though this is not
1448           likely to be used in the same way.
1449
1450 ***************************************************************************/
1451
1452 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1453 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1454 {
1455         char *msgbuf = NULL;
1456         bool ret = true;
1457         int res;
1458
1459         res = vasprintf(&msgbuf, format_str, ap);
1460         if (res != -1) {
1461                 format_debug_text(msgbuf);
1462         } else {
1463                 ret = false;
1464         }
1465         SAFE_FREE(msgbuf);
1466         return ret;
1467 }
1468
1469 bool dbgtext_va(const char *format_str, va_list ap)
1470 {
1471         return __dbgtext_va(format_str, ap);
1472 }
1473
1474 bool dbgtext(const char *format_str, ... )
1475 {
1476         va_list ap;
1477         bool ret;
1478
1479         va_start(ap, format_str);
1480         ret = __dbgtext_va(format_str, ap);
1481         va_end(ap);
1482
1483         return ret;
1484 }