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