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