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 };
 542
 543 /*
 544  * This is to allow reading of DEBUGLEVEL_CLASS before the debug
 545  * system has been initialized.
 546  */
 547 static const int debug_class_list_initial[ARRAY_SIZE(default_classname_table)];
 548
 549 static int debug_num_classes = 0;
 550 int     *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
 551
 552
 553 /* -------------------------------------------------------------------------- **
 554  * Internal variables.
 555  *
 556  *  debug_count     - Number of debug messages that have been output.
 557  *                    Used to check log size.
 558  *
 559  *  current_msg_level    - Internal copy of the message debug level.  Written by
 560  *                    dbghdr() and read by Debug1().
 561  *
 562  *  format_bufr     - Used to format debug messages.  The dbgtext() function
 563  *                    prints debug messages to a string, and then passes the
 564  *                    string to format_debug_text(), which uses format_bufr
 565  *                    to build the formatted output.
 566  *
 567  *  format_pos      - Marks the first free byte of the format_bufr.
 568  *
 569  *
 570  *  log_overflow    - When this variable is true, never attempt to check the
 571  *                    size of the log. This is a hack, so that we can write
 572  *                    a message using DEBUG, from open_logs() when we
 573  *                    are unable to open a new log file for some reason.
 574  */
 575
 576 static int     debug_count    = 0;
 577 static int     current_msg_level   = 0;
 578 static char format_bufr[FORMAT_BUFR_SIZE];
 579 static size_t     format_pos     = 0;
 580 static bool    log_overflow   = false;
 581
 582 /*
 583  * Define all the debug class selection names here. Names *MUST NOT* contain
 584  * white space. There must be one name for each DBGC_<class name>, and they
 585  * must be in the table in the order of DBGC_<class name>..
 586  */
 587
 588 static char **classname_table = NULL;
 589
 590
 591 /* -------------------------------------------------------------------------- **
 592  * Functions...
 593  */
 594
 595 static void debug_init(void);
 596
 597 /***************************************************************************
 598  Free memory pointed to by global pointers.
 599 ****************************************************************************/
 600
 601 void gfree_debugsyms(void)
 602 {
 603         unsigned i;
 604
 605         TALLOC_FREE(classname_table);
 606
 607         if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
 608                 TALLOC_FREE( DEBUGLEVEL_CLASS );
 609                 DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
 610         }
 611
 612         debug_num_classes = 0;
 613
 614         state.initialized = false;
 615
 616         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 617                 SAFE_FREE(debug_backends[i].option);
 618         }
 619 }
 620
 621 /****************************************************************************
 622 utility lists registered debug class names's
 623 ****************************************************************************/
 624
 625 char *debug_list_class_names_and_levels(void)
 626 {
 627         char *buf = NULL;
 628         unsigned int i;
 629         /* prepare strings */
 630         for (i = 0; i < debug_num_classes; i++) {
 631                 buf = talloc_asprintf_append(buf,
 632                                              "%s:%d%s",
 633                                              classname_table[i],
 634                                              DEBUGLEVEL_CLASS[i],
 635                                              i == (debug_num_classes - 1) ? "\n" : " ");
 636                 if (buf == NULL) {
 637                         return NULL;
 638                 }
 639         }
 640         return buf;
 641 }
 642
 643 /****************************************************************************
 644  Utility to translate names to debug class index's (internal version).
 645 ****************************************************************************/
 646
 647 static int debug_lookup_classname_int(const char* classname)
 648 {
 649         int i;
 650
 651         if (!classname) return -1;
 652
 653         for (i=0; i < debug_num_classes; i++) {
 654                 if (strcmp(classname, classname_table[i])==0)
 655                         return i;
 656         }
 657         return -1;
 658 }
 659
 660 /****************************************************************************
 661  Add a new debug class to the system.
 662 ****************************************************************************/
 663
 664 int debug_add_class(const char *classname)
 665 {
 666         int ndx;
 667         int *new_class_list;
 668         char **new_name_list;
 669         int default_level;
 670
 671         if (!classname)
 672                 return -1;
 673
 674         /* check the init has yet been called */
 675         debug_init();
 676
 677         ndx = debug_lookup_classname_int(classname);
 678         if (ndx >= 0)
 679                 return ndx;
 680         ndx = debug_num_classes;
 681
 682         if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
 683                 /* Initial loading... */
 684                 new_class_list = NULL;
 685         } else {
 686                 new_class_list = DEBUGLEVEL_CLASS;
 687         }
 688
 689         default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
 690
 691         new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
 692         if (!new_class_list)
 693                 return -1;
 694         DEBUGLEVEL_CLASS = new_class_list;
 695
 696         DEBUGLEVEL_CLASS[ndx] = default_level;
 697
 698         new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
 699         if (!new_name_list)
 700                 return -1;
 701         classname_table = new_name_list;
 702
 703         classname_table[ndx] = talloc_strdup(classname_table, classname);
 704         if (! classname_table[ndx])
 705                 return -1;
 706
 707         debug_num_classes = ndx + 1;
 708
 709         return ndx;
 710 }
 711
 712 /****************************************************************************
 713  Utility to translate names to debug class index's (public version).
 714 ****************************************************************************/
 715
 716 static int debug_lookup_classname(const char *classname)
 717 {
 718         int ndx;
 719
 720         if (!classname || !*classname)
 721                 return -1;
 722
 723         ndx = debug_lookup_classname_int(classname);
 724
 725         if (ndx != -1)
 726                 return ndx;
 727
 728         DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
 729                   classname));
 730         return debug_add_class(classname);
 731 }
 732
 733 /****************************************************************************
 734  Dump the current registered debug levels.
 735 ****************************************************************************/
 736
 737 static void debug_dump_status(int level)
 738 {
 739         int q;
 740
 741         DEBUG(level, ("INFO: Current debug levels:\n"));
 742         for (q = 0; q < debug_num_classes; q++) {
 743                 const char *classname = classname_table[q];
 744                 DEBUGADD(level, ("  %s: %d\n",
 745                                  classname,
 746                                  DEBUGLEVEL_CLASS[q]));
 747         }
 748 }
 749
 750 static bool debug_parse_param(char *param)
 751 {
 752         char *class_name;
 753         char *class_level;
 754         char *saveptr = NULL;
 755         int ndx;
 756
 757         class_name = strtok_r(param, ":", &saveptr);
 758         if (class_name == NULL) {
 759                 return false;
 760         }
 761
 762         class_level = strtok_r(NULL, "\0", &saveptr);
 763         if (class_level == NULL) {
 764                 return false;
 765         }
 766
 767         ndx = debug_lookup_classname(class_name);
 768         if (ndx == -1) {
 769                 return false;
 770         }
 771
 772         DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
 773
 774         return true;
 775 }
 776
 777 /****************************************************************************
 778  Parse the debug levels from smb.conf. Example debug level string:
 779   3 tdb:5 printdrivers:7
 780  Note: the 1st param has no "name:" preceeding it.
 781 ****************************************************************************/
 782
 783 bool debug_parse_levels(const char *params_str)
 784 {
 785         size_t str_len = strlen(params_str);
 786         char str[str_len+1];
 787         char *tok, *saveptr;
 788         int i;
 789
 790         /* Just in case */
 791         debug_init();
 792
 793         memcpy(str, params_str, str_len+1);
 794
 795         tok = strtok_r(str, LIST_SEP, &saveptr);
 796         if (tok == NULL) {
 797                 return true;
 798         }
 799
 800         /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
 801          * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
 802          */
 803         if (isdigit(tok[0])) {
 804                 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(tok);
 805                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 806         } else {
 807                 DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
 808         }
 809
 810         /* Array is debug_num_classes long */
 811         for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
 812                 DEBUGLEVEL_CLASS[i] = DEBUGLEVEL_CLASS[DBGC_ALL];
 813         }
 814
 815         while (tok != NULL) {
 816                 bool ok;
 817
 818                 ok = debug_parse_param(tok);
 819                 if (!ok) {
 820                         DEBUG(0,("debug_parse_params: unrecognized debug "
 821                                  "class name or format [%s]\n", tok));
 822                         return false;
 823                 }
 824
 825                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 826         }
 827
 828         debug_dump_status(5);
 829
 830         return true;
 831 }
 832
 833 /* setup for logging of talloc warnings */
 834 static void talloc_log_fn(const char *msg)
 835 {
 836         DEBUG(0,("%s", msg));
 837 }
 838
 839 void debug_setup_talloc_log(void)
 840 {
 841         talloc_set_log_fn(talloc_log_fn);
 842 }
 843
 844
 845 /****************************************************************************
 846 Init debugging (one time stuff)
 847 ****************************************************************************/
 848
 849 static void debug_init(void)
 850 {
 851         size_t i;
 852
 853         if (state.initialized)
 854                 return;
 855
 856         state.initialized = true;
 857
 858         debug_setup_talloc_log();
 859
 860         for (i = 0; i < ARRAY_SIZE(default_classname_table); i++) {
 861                 debug_add_class(default_classname_table[i]);
 862         }
 863
 864         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 865                 debug_backends[i].log_level = -1;
 866                 debug_backends[i].new_log_level = -1;
 867         }
 868 }
 869
 870 void debug_set_settings(struct debug_settings *settings,
 871                         const char *logging_param,
 872                         int syslog_level, bool syslog_only)
 873 {
 874         char fake_param[256];
 875         size_t len = 0;
 876
 877         /*
 878          * This forces in some smb.conf derived values into the debug
 879          * system. There are no pointers in this structure, so we can
 880          * just structure-assign it in
 881          */
 882         state.settings = *settings;
 883
 884         /*
 885          * If 'logging' is not set, create backend settings from
 886          * deprecated 'syslog' and 'syslog only' parameters
 887          */
 888         if (logging_param != NULL) {
 889                 len = strlen(logging_param);
 890         }
 891         if (len == 0) {
 892                 if (syslog_only) {
 893                         snprintf(fake_param, sizeof(fake_param),
 894                                  "syslog@%d", syslog_level - 1);
 895                 } else {
 896                         snprintf(fake_param, sizeof(fake_param),
 897                                  "syslog@%d file@%d", syslog_level -1,
 898                                  MAX_DEBUG_LEVEL);
 899                 }
 900
 901                 logging_param = fake_param;
 902         }
 903
 904         debug_set_backends(logging_param);
 905 }
 906
 907 /**
 908   control the name of the logfile and whether logging will be to stdout, stderr
 909   or a file, and set up syslog
 910
 911   new_log indicates the destination for the debug log (an enum in
 912   order of precedence - once set to DEBUG_FILE, it is not possible to
 913   reset to DEBUG_STDOUT for example.  This makes it easy to override
 914   for debug to stderr on the command line, as the smb.conf cannot
 915   reset it back to file-based logging
 916 */
 917 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
 918 {
 919         debug_init();
 920         if (state.logtype < new_logtype) {
 921                 state.logtype = new_logtype;
 922         }
 923         if (prog_name) {
 924                 const char *p = strrchr(prog_name, '/');
 925
 926                 if (p) {
 927                         prog_name = p + 1;
 928                 }
 929
 930                 state.prog_name = prog_name;
 931         }
 932         reopen_logs_internal();
 933 }
 934
 935 /***************************************************************************
 936  Set the logfile name.
 937 **************************************************************************/
 938
 939 void debug_set_logfile(const char *name)
 940 {
 941         if (name == NULL || *name == 0) {
 942                 /* this copes with calls when smb.conf is not loaded yet */
 943                 return;
 944         }
 945         TALLOC_FREE(state.debugf);
 946         state.debugf = talloc_strdup(NULL, name);
 947 }
 948
 949 static void debug_close_fd(int fd)
 950 {
 951         if (fd > 2) {
 952                 close(fd);
 953         }
 954 }
 955
 956 bool debug_get_output_is_stderr(void)
 957 {
 958         return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
 959 }
 960
 961 bool debug_get_output_is_stdout(void)
 962 {
 963         return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
 964 }
 965
 966 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
 967 {
 968         debug_init();
 969         if (fn) {
 970                 state.logtype = DEBUG_CALLBACK;
 971                 state.callback_private = private_ptr;
 972                 state.callback = fn;
 973         } else {
 974                 state.logtype = DEBUG_DEFAULT_STDERR;
 975                 state.callback_private = NULL;
 976                 state.callback = NULL;
 977         }
 978 }
 979
 980 static void debug_callback_log(const char *msg, int msg_level)
 981 {
 982         size_t msg_len = strlen(msg);
 983         char msg_copy[msg_len];
 984
 985         if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
 986                 memcpy(msg_copy, msg, msg_len-1);
 987                 msg_copy[msg_len-1] = '\0';
 988                 msg = msg_copy;
 989         }
 990
 991         state.callback(state.callback_private, msg_level, msg);
 992 }
 993
 994 /**************************************************************************
 995  reopen the log files
 996  note that we now do this unconditionally
 997  We attempt to open the new debug fp before closing the old. This means
 998  if we run out of fd's we just keep using the old fd rather than aborting.
 999  Fix from dgibson@linuxcare.com.
1000 **************************************************************************/
1001
1002 /**
1003   reopen the log file (usually called because the log file name might have changed)
1004 */
1005 bool reopen_logs_internal(void)
1006 {
1007         mode_t oldumask;
1008         int new_fd = 0;
1009         int old_fd = 0;
1010         bool ret = true;
1011
1012         if (state.reopening_logs) {
1013                 return true;
1014         }
1015
1016         /* Now clear the SIGHUP induced flag */
1017         state.schedule_reopen_logs = false;
1018
1019         switch (state.logtype) {
1020         case DEBUG_CALLBACK:
1021                 return true;
1022         case DEBUG_STDOUT:
1023         case DEBUG_DEFAULT_STDOUT:
1024                 debug_close_fd(state.fd);
1025                 state.fd = 1;
1026                 return true;
1027
1028         case DEBUG_DEFAULT_STDERR:
1029         case DEBUG_STDERR:
1030                 debug_close_fd(state.fd);
1031                 state.fd = 2;
1032                 return true;
1033
1034         case DEBUG_FILE:
1035                 break;
1036         }
1037
1038         oldumask = umask( 022 );
1039
1040         if (!state.debugf) {
1041                 return false;
1042         }
1043
1044         state.reopening_logs = true;
1045
1046         new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
1047
1048         if (new_fd == -1) {
1049                 log_overflow = true;
1050                 DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
1051                 log_overflow = false;
1052                 ret = false;
1053         } else {
1054                 smb_set_close_on_exec(new_fd);
1055                 old_fd = state.fd;
1056                 state.fd = new_fd;
1057                 debug_close_fd(old_fd);
1058         }
1059
1060         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1061          * to fix problem where smbd's that generate less
1062          * than 100 messages keep growing the log.
1063          */
1064         force_check_log_size();
1065         (void)umask(oldumask);
1066
1067         /* Take over stderr to catch output into logs */
1068         if (state.fd > 0) {
1069                 if (dup2(state.fd, 2) == -1) {
1070                         /* Close stderr too, if dup2 can't point it -
1071                            at the logfile.  There really isn't much
1072                            that can be done on such a fundamental
1073                            failure... */
1074                         close_low_fd(2);
1075                 }
1076         }
1077
1078         state.reopening_logs = false;
1079
1080         return ret;
1081 }
1082
1083 /**************************************************************************
1084  Force a check of the log size.
1085  ***************************************************************************/
1086
1087 void force_check_log_size( void )
1088 {
1089         debug_count = 100;
1090 }
1091
1092 _PUBLIC_ void debug_schedule_reopen_logs(void)
1093 {
1094         state.schedule_reopen_logs = true;
1095 }
1096
1097
1098 /***************************************************************************
1099  Check to see if there is any need to check if the logfile has grown too big.
1100 **************************************************************************/
1101
1102 bool need_to_check_log_size( void )
1103 {
1104         int maxlog;
1105
1106         if( debug_count < 100)
1107                 return( false );
1108
1109         maxlog = state.settings.max_log_size * 1024;
1110         if ( state.fd <=2 || maxlog <= 0 ) {
1111                 debug_count = 0;
1112                 return(false);
1113         }
1114         return( true );
1115 }
1116
1117 /**************************************************************************
1118  Check to see if the log has grown to be too big.
1119  **************************************************************************/
1120
1121 void check_log_size( void )
1122 {
1123         int         maxlog;
1124         struct stat st;
1125
1126         /*
1127          *  We need to be root to check/change log-file, skip this and let the main
1128          *  loop check do a new check as root.
1129          */
1130
1131 #if _SAMBA_BUILD_ == 3
1132         if (geteuid() != sec_initial_uid())
1133 #else
1134         if( geteuid() != 0)
1135 #endif
1136         {
1137                 /* We don't check sec_initial_uid() here as it isn't
1138                  * available in common code and we don't generally
1139                  * want to rotate and the possibly lose logs in
1140                  * make test or the build farm */
1141                 return;
1142         }
1143
1144         if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
1145                 return;
1146         }
1147
1148         maxlog = state.settings.max_log_size * 1024;
1149
1150         if (state.schedule_reopen_logs) {
1151             (void)reopen_logs_internal();
1152         }
1153
1154         if (maxlog && (fstat(state.fd, &st) == 0
1155             && st.st_size > maxlog )) {
1156                 (void)reopen_logs_internal();
1157                 if (state.fd > 2 && (fstat(state.fd, &st) == 0
1158                                      && st.st_size > maxlog)) {
1159                         char name[strlen(state.debugf) + 5];
1160
1161                         snprintf(name, sizeof(name), "%s.old", state.debugf);
1162
1163                         (void)rename(state.debugf, name);
1164
1165                         if (!reopen_logs_internal()) {
1166                                 /* We failed to reopen a log - continue using the old name. */
1167                                 (void)rename(name, state.debugf);
1168                         }
1169                 }
1170         }
1171
1172         /*
1173          * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
1174          */
1175
1176         if (state.fd <= 0) {
1177                 /* This code should only be reached in very strange
1178                  * circumstances. If we merely fail to open the new log we
1179                  * should stick with the old one. ergo this should only be
1180                  * reached when opening the logs for the first time: at
1181                  * startup or when the log level is increased from zero.
1182                  * -dwg 6 June 2000
1183                  */
1184                 int fd = open( "/dev/console", O_WRONLY, 0);
1185                 if (fd != -1) {
1186                         smb_set_close_on_exec(fd);
1187                         state.fd = fd;
1188                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
1189                                         state.debugf ));
1190                 } else {
1191                         /*
1192                          * We cannot continue without a debug file handle.
1193                          */
1194                         abort();
1195                 }
1196         }
1197         debug_count = 0;
1198 }
1199
1200 /*************************************************************************
1201  Write an debug message on the debugfile.
1202  This is called by dbghdr() and format_debug_text().
1203 ************************************************************************/
1204
1205 static void Debug1(const char *msg)
1206 {
1207         int old_errno = errno;
1208
1209         debug_count++;
1210
1211         switch(state.logtype) {
1212         case DEBUG_CALLBACK:
1213                 debug_callback_log(msg, current_msg_level);
1214                 break;
1215         case DEBUG_STDOUT:
1216         case DEBUG_STDERR:
1217         case DEBUG_DEFAULT_STDOUT:
1218         case DEBUG_DEFAULT_STDERR:
1219                 if (state.fd > 0) {
1220                         ssize_t ret;
1221                         do {
1222                                 ret = write(state.fd, msg, strlen(msg));
1223                         } while (ret == -1 && errno == EINTR);
1224                 }
1225                 break;
1226         case DEBUG_FILE:
1227                 debug_backends_log(msg, current_msg_level);
1228                 break;
1229         };
1230
1231         errno = old_errno;
1232 }
1233
1234 /**************************************************************************
1235  Print the buffer content via Debug1(), then reset the buffer.
1236  Input:  none
1237  Output: none
1238 ****************************************************************************/
1239
1240 static void bufr_print( void )
1241 {
1242         format_bufr[format_pos] = '\0';
1243         (void)Debug1(format_bufr);
1244         format_pos = 0;
1245 }
1246
1247 /***************************************************************************
1248  Format the debug message text.
1249
1250  Input:  msg - Text to be added to the "current" debug message text.
1251
1252  Output: none.
1253
1254  Notes:  The purpose of this is two-fold.  First, each call to syslog()
1255          (used by Debug1(), see above) generates a new line of syslog
1256          output.  This is fixed by storing the partial lines until the
1257          newline character is encountered.  Second, printing the debug
1258          message lines when a newline is encountered allows us to add
1259          spaces, thus indenting the body of the message and making it
1260          more readable.
1261 **************************************************************************/
1262
1263 static void format_debug_text( const char *msg )
1264 {
1265         size_t i;
1266         bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
1267
1268         debug_init();
1269
1270         for( i = 0; msg[i]; i++ ) {
1271                 /* Indent two spaces at each new line. */
1272                 if(timestamp && 0 == format_pos) {
1273                         format_bufr[0] = format_bufr[1] = ' ';
1274                         format_pos = 2;
1275                 }
1276
1277                 /* If there's room, copy the character to the format buffer. */
1278                 if (format_pos < FORMAT_BUFR_SIZE - 1)
1279                         format_bufr[format_pos++] = msg[i];
1280
1281                 /* If a newline is encountered, print & restart. */
1282                 if( '\n' == msg[i] )
1283                         bufr_print();
1284
1285                 /* If the buffer is full dump it out, reset it, and put out a line
1286                  * continuation indicator.
1287                  */
1288                 if (format_pos >= FORMAT_BUFR_SIZE - 1) {
1289                         bufr_print();
1290                         (void)Debug1( " +>\n" );
1291                 }
1292         }
1293
1294         /* Just to be safe... */
1295         format_bufr[format_pos] = '\0';
1296 }
1297
1298 /***************************************************************************
1299  Flush debug output, including the format buffer content.
1300
1301  Input:  none
1302  Output: none
1303 ***************************************************************************/
1304
1305 void dbgflush( void )
1306 {
1307         bufr_print();
1308 }
1309
1310 /***************************************************************************
1311  Print a Debug Header.
1312
1313  Input:  level    - Debug level of the message (not the system-wide debug
1314                     level. )
1315          cls      - Debuglevel class of the calling module.
1316          location - Pointer to a string containing the name of the file
1317                     from which this function was called, or an empty string
1318                     if the __FILE__ macro is not implemented.
1319          func     - Pointer to a string containing the name of the function
1320                     from which this function was called, or an empty string
1321                     if the __FUNCTION__ macro is not implemented.
1322
1323  Output: Always true.  This makes it easy to fudge a call to dbghdr()
1324          in a macro, since the function can be called as part of a test.
1325          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1326
1327  Notes:  This function takes care of setting current_msg_level.
1328
1329 ****************************************************************************/
1330
1331 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1332 {
1333         /* Ensure we don't lose any real errno value. */
1334         int old_errno = errno;
1335         bool verbose = false;
1336         char header_str[300];
1337         size_t hs_len;
1338         struct timeval tv;
1339         struct timeval_buf tvbuf;
1340
1341         if( format_pos ) {
1342                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
1343                  * the *right* thing to do is to call
1344                  *   format_debug_text( "\n" );
1345                  * to write the remainder, and then proceed with the new header.
1346                  * Unfortunately, there are several places in the code at which
1347                  * the DEBUG() macro is used to build partial lines.  That in mind,
1348                  * we'll work under the assumption that an incomplete line indicates
1349                  * that a new header is *not* desired.
1350                  */
1351                 return( true );
1352         }
1353
1354         /* Set current_msg_level. */
1355         current_msg_level = level;
1356
1357         /* Don't print a header if we're logging to stdout. */
1358         if ( state.logtype != DEBUG_FILE ) {
1359                 return( true );
1360         }
1361
1362         /* Print the header if timestamps are turned on.  If parameters are
1363          * not yet loaded, then default to timestamps on.
1364          */
1365         if (!(state.settings.timestamp_logs ||
1366               state.settings.debug_prefix_timestamp)) {
1367                 return true;
1368         }
1369
1370         GetTimeOfDay(&tv);
1371         timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
1372                         &tvbuf);
1373
1374         hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
1375                           tvbuf.buf, level);
1376         if (hs_len >= sizeof(header_str)) {
1377                 goto full;
1378         }
1379
1380         if (unlikely(DEBUGLEVEL_CLASS[ cls ] >= 10)) {
1381                 verbose = true;
1382         }
1383
1384         if (verbose || state.settings.debug_pid) {
1385                 hs_len += snprintf(
1386                         header_str + hs_len, sizeof(header_str) - hs_len,
1387                         ", pid=%u", (unsigned int)getpid());
1388                 if (hs_len >= sizeof(header_str)) {
1389                         goto full;
1390                 }
1391         }
1392
1393         if (verbose || state.settings.debug_uid) {
1394                 hs_len += snprintf(
1395                         header_str + hs_len, sizeof(header_str) - hs_len,
1396                         ", effective(%u, %u), real(%u, %u)",
1397                         (unsigned int)geteuid(), (unsigned int)getegid(),
1398                         (unsigned int)getuid(), (unsigned int)getgid());
1399                 if (hs_len >= sizeof(header_str)) {
1400                         goto full;
1401                 }
1402         }
1403
1404         if ((verbose || state.settings.debug_class)
1405             && (cls != DBGC_ALL)) {
1406                 hs_len += snprintf(
1407                         header_str + hs_len, sizeof(header_str) - hs_len,
1408                         ", class=%s", classname_table[cls]);
1409                 if (hs_len >= sizeof(header_str)) {
1410                         goto full;
1411                 }
1412         }
1413
1414         /*
1415          * No +=, see man man strlcat
1416          */
1417         hs_len = strlcat(header_str, "] ", sizeof(header_str));
1418         if (hs_len >= sizeof(header_str)) {
1419                 goto full;
1420         }
1421
1422         if (!state.settings.debug_prefix_timestamp) {
1423                 hs_len += snprintf(
1424                         header_str + hs_len, sizeof(header_str) - hs_len,
1425                         "%s(%s)\n", location, func);
1426                 if (hs_len >= sizeof(header_str)) {
1427                         goto full;
1428                 }
1429         }
1430
1431 full:
1432         (void)Debug1(header_str);
1433
1434         errno = old_errno;
1435         return( true );
1436 }
1437
1438 /***************************************************************************
1439  Add text to the body of the "current" debug message via the format buffer.
1440
1441   Input:  format_str  - Format string, as used in printf(), et. al.
1442           ...         - Variable argument list.
1443
1444   ..or..  va_alist    - Old style variable parameter list starting point.
1445
1446   Output: Always true.  See dbghdr() for more info, though this is not
1447           likely to be used in the same way.
1448
1449 ***************************************************************************/
1450
1451 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1452 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1453 {
1454         char *msgbuf = NULL;
1455         bool ret = true;
1456         int res;
1457
1458         res = vasprintf(&msgbuf, format_str, ap);
1459         if (res != -1) {
1460                 format_debug_text(msgbuf);
1461         } else {
1462                 ret = false;
1463         }
1464         SAFE_FREE(msgbuf);
1465         return ret;
1466 }
1467
1468 bool dbgtext_va(const char *format_str, va_list ap)
1469 {
1470         return __dbgtext_va(format_str, ap);
1471 }
1472
1473 bool dbgtext(const char *format_str, ... )
1474 {
1475         va_list ap;
1476         bool ret;
1477
1478         va_start(ap, format_str);
1479         ret = __dbgtext_va(format_str, ap);
1480         va_end(ap);
1481
1482         return ret;
1483 }