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_SYSTEMD_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_SYSTEMD_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_SYSTEMD_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[20];
 767
 768         /*
 769          * This forces in some smb.conf derived values into the debug
 770          * system. There are no pointers in this structure, so we can
 771          * just structure-assign it in
 772          */
 773         state.settings = *settings;
 774
 775         /*
 776          * If 'logging' is not set, create backend settings from
 777          * deprecated 'syslog' and 'syslog only' paramters
 778          */
 779         if (!logging_param) {
 780                 if (syslog_only) {
 781                         snprintf(fake_param, sizeof(fake_param),
 782                                  "syslog:%d", syslog_level - 1);
 783                 } else {
 784                         snprintf(fake_param, sizeof(fake_param),
 785                                  "syslog:%d file:%d", syslog_level -1,
 786                                  MAX_DEBUG_LEVEL);
 787                 }
 788
 789                 logging_param = fake_param;
 790         }
 791
 792         debug_set_backends(logging_param);
 793 }
 794
 795 /**
 796   control the name of the logfile and whether logging will be to stdout, stderr
 797   or a file, and set up syslog
 798
 799   new_log indicates the destination for the debug log (an enum in
 800   order of precedence - once set to DEBUG_FILE, it is not possible to
 801   reset to DEBUG_STDOUT for example.  This makes it easy to override
 802   for debug to stderr on the command line, as the smb.conf cannot
 803   reset it back to file-based logging
 804 */
 805 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
 806 {
 807         debug_init();
 808         if (state.logtype < new_logtype) {
 809                 state.logtype = new_logtype;
 810         }
 811         if (prog_name) {
 812                 const char *p = strrchr(prog_name, '/');
 813
 814                 if (p) {
 815                         prog_name = p + 1;
 816                 }
 817
 818                 state.prog_name = prog_name;
 819         }
 820         reopen_logs_internal();
 821 }
 822
 823 /***************************************************************************
 824  Set the logfile name.
 825 **************************************************************************/
 826
 827 void debug_set_logfile(const char *name)
 828 {
 829         if (name == NULL || *name == 0) {
 830                 /* this copes with calls when smb.conf is not loaded yet */
 831                 return;
 832         }
 833         TALLOC_FREE(state.debugf);
 834         state.debugf = talloc_strdup(NULL, name);
 835 }
 836
 837 static void debug_close_fd(int fd)
 838 {
 839         if (fd > 2) {
 840                 close(fd);
 841         }
 842 }
 843
 844 bool debug_get_output_is_stderr(void)
 845 {
 846         return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
 847 }
 848
 849 bool debug_get_output_is_stdout(void)
 850 {
 851         return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
 852 }
 853
 854 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
 855 {
 856         debug_init();
 857         if (fn) {
 858                 state.logtype = DEBUG_CALLBACK;
 859                 state.callback_private = private_ptr;
 860                 state.callback = fn;
 861         } else {
 862                 state.logtype = DEBUG_DEFAULT_STDERR;
 863                 state.callback_private = NULL;
 864                 state.callback = NULL;
 865         }
 866 }
 867
 868 static void debug_callback_log(const char *msg, int msg_level)
 869 {
 870         size_t msg_len = strlen(msg);
 871         char msg_copy[msg_len];
 872
 873         if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
 874                 memcpy(msg_copy, msg, msg_len-1);
 875                 msg_copy[msg_len-1] = '\0';
 876                 msg = msg_copy;
 877         }
 878
 879         state.callback(state.callback_private, msg_level, msg);
 880 }
 881
 882 /**************************************************************************
 883  reopen the log files
 884  note that we now do this unconditionally
 885  We attempt to open the new debug fp before closing the old. This means
 886  if we run out of fd's we just keep using the old fd rather than aborting.
 887  Fix from dgibson@linuxcare.com.
 888 **************************************************************************/
 889
 890 /**
 891   reopen the log file (usually called because the log file name might have changed)
 892 */
 893 bool reopen_logs_internal(void)
 894 {
 895         mode_t oldumask;
 896         int new_fd = 0;
 897         int old_fd = 0;
 898         bool ret = true;
 899
 900         if (state.reopening_logs) {
 901                 return true;
 902         }
 903
 904         /* Now clear the SIGHUP induced flag */
 905         state.schedule_reopen_logs = false;
 906
 907         switch (state.logtype) {
 908         case DEBUG_CALLBACK:
 909                 return true;
 910         case DEBUG_STDOUT:
 911         case DEBUG_DEFAULT_STDOUT:
 912                 debug_close_fd(state.fd);
 913                 state.fd = 1;
 914                 return true;
 915
 916         case DEBUG_DEFAULT_STDERR:
 917         case DEBUG_STDERR:
 918                 debug_close_fd(state.fd);
 919                 state.fd = 2;
 920                 return true;
 921
 922         case DEBUG_FILE:
 923                 break;
 924         }
 925
 926         oldumask = umask( 022 );
 927
 928         if (!state.debugf) {
 929                 return false;
 930         }
 931
 932         state.reopening_logs = true;
 933
 934         new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
 935
 936         if (new_fd == -1) {
 937                 log_overflow = true;
 938                 DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
 939                 log_overflow = false;
 940                 ret = false;
 941         } else {
 942                 smb_set_close_on_exec(new_fd);
 943                 old_fd = state.fd;
 944                 state.fd = new_fd;
 945                 debug_close_fd(old_fd);
 946         }
 947
 948         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
 949          * to fix problem where smbd's that generate less
 950          * than 100 messages keep growing the log.
 951          */
 952         force_check_log_size();
 953         (void)umask(oldumask);
 954
 955         /* Take over stderr to catch output into logs */
 956         if (state.fd > 0) {
 957                 if (dup2(state.fd, 2) == -1) {
 958                         /* Close stderr too, if dup2 can't point it -
 959                            at the logfile.  There really isn't much
 960                            that can be done on such a fundamental
 961                            failure... */
 962                         close_low_fd(2);
 963                 }
 964         }
 965
 966         state.reopening_logs = false;
 967
 968         return ret;
 969 }
 970
 971 /**************************************************************************
 972  Force a check of the log size.
 973  ***************************************************************************/
 974
 975 void force_check_log_size( void )
 976 {
 977         debug_count = 100;
 978 }
 979
 980 _PUBLIC_ void debug_schedule_reopen_logs(void)
 981 {
 982         state.schedule_reopen_logs = true;
 983 }
 984
 985
 986 /***************************************************************************
 987  Check to see if there is any need to check if the logfile has grown too big.
 988 **************************************************************************/
 989
 990 bool need_to_check_log_size( void )
 991 {
 992         int maxlog;
 993
 994         if( debug_count < 100)
 995                 return( false );
 996
 997         maxlog = state.settings.max_log_size * 1024;
 998         if ( state.fd <=2 || maxlog <= 0 ) {
 999                 debug_count = 0;
1000                 return(false);
1001         }
1002         return( true );
1003 }
1004
1005 /**************************************************************************
1006  Check to see if the log has grown to be too big.
1007  **************************************************************************/
1008
1009 void check_log_size( void )
1010 {
1011         int         maxlog;
1012         struct stat st;
1013
1014         /*
1015          *  We need to be root to check/change log-file, skip this and let the main
1016          *  loop check do a new check as root.
1017          */
1018
1019 #if _SAMBA_BUILD_ == 3
1020         if (geteuid() != sec_initial_uid())
1021 #else
1022         if( geteuid() != 0)
1023 #endif
1024         {
1025                 /* We don't check sec_initial_uid() here as it isn't
1026                  * available in common code and we don't generally
1027                  * want to rotate and the possibly lose logs in
1028                  * make test or the build farm */
1029                 return;
1030         }
1031
1032         if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
1033                 return;
1034         }
1035
1036         maxlog = state.settings.max_log_size * 1024;
1037
1038         if (state.schedule_reopen_logs) {
1039             (void)reopen_logs_internal();
1040         }
1041
1042         if (maxlog && (fstat(state.fd, &st) == 0
1043             && st.st_size > maxlog )) {
1044                 (void)reopen_logs_internal();
1045                 if (state.fd > 2 && (fstat(state.fd, &st) == 0
1046                                      && st.st_size > maxlog)) {
1047                         char name[strlen(state.debugf) + 5];
1048
1049                         snprintf(name, sizeof(name), "%s.old", state.debugf);
1050
1051                         (void)rename(state.debugf, name);
1052
1053                         if (!reopen_logs_internal()) {
1054                                 /* We failed to reopen a log - continue using the old name. */
1055                                 (void)rename(name, state.debugf);
1056                         }
1057                 }
1058         }
1059
1060         /*
1061          * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
1062          */
1063
1064         if (state.fd <= 0) {
1065                 /* This code should only be reached in very strange
1066                  * circumstances. If we merely fail to open the new log we
1067                  * should stick with the old one. ergo this should only be
1068                  * reached when opening the logs for the first time: at
1069                  * startup or when the log level is increased from zero.
1070                  * -dwg 6 June 2000
1071                  */
1072                 int fd = open( "/dev/console", O_WRONLY, 0);
1073                 if (fd != -1) {
1074                         smb_set_close_on_exec(fd);
1075                         state.fd = fd;
1076                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
1077                                         state.debugf ));
1078                 } else {
1079                         /*
1080                          * We cannot continue without a debug file handle.
1081                          */
1082                         abort();
1083                 }
1084         }
1085         debug_count = 0;
1086 }
1087
1088 /*************************************************************************
1089  Write an debug message on the debugfile.
1090  This is called by dbghdr() and format_debug_text().
1091 ************************************************************************/
1092
1093 static void Debug1(const char *msg)
1094 {
1095         int old_errno = errno;
1096
1097         debug_count++;
1098
1099         switch(state.logtype) {
1100         case DEBUG_CALLBACK:
1101                 debug_callback_log(msg, current_msg_level);
1102                 break;
1103         case DEBUG_STDOUT:
1104         case DEBUG_STDERR:
1105         case DEBUG_DEFAULT_STDOUT:
1106         case DEBUG_DEFAULT_STDERR:
1107                 if (state.fd > 0) {
1108                         write(state.fd, msg, strlen(msg));
1109                 }
1110                 break;
1111         case DEBUG_FILE:
1112                 debug_backends_log(msg, current_msg_level);
1113                 break;
1114         };
1115
1116         errno = old_errno;
1117 }
1118
1119 /**************************************************************************
1120  Print the buffer content via Debug1(), then reset the buffer.
1121  Input:  none
1122  Output: none
1123 ****************************************************************************/
1124
1125 static void bufr_print( void )
1126 {
1127         format_bufr[format_pos] = '\0';
1128         (void)Debug1(format_bufr);
1129         format_pos = 0;
1130 }
1131
1132 /***************************************************************************
1133  Format the debug message text.
1134
1135  Input:  msg - Text to be added to the "current" debug message text.
1136
1137  Output: none.
1138
1139  Notes:  The purpose of this is two-fold.  First, each call to syslog()
1140          (used by Debug1(), see above) generates a new line of syslog
1141          output.  This is fixed by storing the partial lines until the
1142          newline character is encountered.  Second, printing the debug
1143          message lines when a newline is encountered allows us to add
1144          spaces, thus indenting the body of the message and making it
1145          more readable.
1146 **************************************************************************/
1147
1148 static void format_debug_text( const char *msg )
1149 {
1150         size_t i;
1151         bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
1152
1153         debug_init();
1154
1155         for( i = 0; msg[i]; i++ ) {
1156                 /* Indent two spaces at each new line. */
1157                 if(timestamp && 0 == format_pos) {
1158                         format_bufr[0] = format_bufr[1] = ' ';
1159                         format_pos = 2;
1160                 }
1161
1162                 /* If there's room, copy the character to the format buffer. */
1163                 if (format_pos < FORMAT_BUFR_SIZE - 1)
1164                         format_bufr[format_pos++] = msg[i];
1165
1166                 /* If a newline is encountered, print & restart. */
1167                 if( '\n' == msg[i] )
1168                         bufr_print();
1169
1170                 /* If the buffer is full dump it out, reset it, and put out a line
1171                  * continuation indicator.
1172                  */
1173                 if (format_pos >= FORMAT_BUFR_SIZE - 1) {
1174                         bufr_print();
1175                         (void)Debug1( " +>\n" );
1176                 }
1177         }
1178
1179         /* Just to be safe... */
1180         format_bufr[format_pos] = '\0';
1181 }
1182
1183 /***************************************************************************
1184  Flush debug output, including the format buffer content.
1185
1186  Input:  none
1187  Output: none
1188 ***************************************************************************/
1189
1190 void dbgflush( void )
1191 {
1192         bufr_print();
1193 }
1194
1195 /***************************************************************************
1196  Print a Debug Header.
1197
1198  Input:  level - Debug level of the message (not the system-wide debug
1199                   level. )
1200           cls   - Debuglevel class of the calling module.
1201           file  - Pointer to a string containing the name of the file
1202                   from which this function was called, or an empty string
1203                   if the __FILE__ macro is not implemented.
1204           func  - Pointer to a string containing the name of the function
1205                   from which this function was called, or an empty string
1206                   if the __FUNCTION__ macro is not implemented.
1207          line  - line number of the call to dbghdr, assuming __LINE__
1208                  works.
1209
1210   Output: Always true.  This makes it easy to fudge a call to dbghdr()
1211           in a macro, since the function can be called as part of a test.
1212           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1213
1214   Notes:  This function takes care of setting current_msg_level.
1215
1216 ****************************************************************************/
1217
1218 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1219 {
1220         /* Ensure we don't lose any real errno value. */
1221         int old_errno = errno;
1222         bool verbose = false;
1223         char header_str[300];
1224         size_t hs_len;
1225         struct timeval tv;
1226         struct timeval_buf tvbuf;
1227
1228         if( format_pos ) {
1229                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
1230                  * the *right* thing to do is to call
1231                  *   format_debug_text( "\n" );
1232                  * to write the remainder, and then proceed with the new header.
1233                  * Unfortunately, there are several places in the code at which
1234                  * the DEBUG() macro is used to build partial lines.  That in mind,
1235                  * we'll work under the assumption that an incomplete line indicates
1236                  * that a new header is *not* desired.
1237                  */
1238                 return( true );
1239         }
1240
1241         /* Set current_msg_level. */
1242         current_msg_level = level;
1243
1244         /* Don't print a header if we're logging to stdout. */
1245         if ( state.logtype != DEBUG_FILE ) {
1246                 return( true );
1247         }
1248
1249         /* Print the header if timestamps are turned on.  If parameters are
1250          * not yet loaded, then default to timestamps on.
1251          */
1252         if (!(state.settings.timestamp_logs ||
1253               state.settings.debug_prefix_timestamp)) {
1254                 return true;
1255         }
1256
1257         GetTimeOfDay(&tv);
1258         timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
1259                         &tvbuf);
1260
1261         hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
1262                           tvbuf.buf, level);
1263         if (hs_len >= sizeof(header_str)) {
1264                 goto full;
1265         }
1266
1267         if (unlikely(DEBUGLEVEL_CLASS[ cls ] >= 10)) {
1268                 verbose = true;
1269         }
1270
1271         if (verbose || state.settings.debug_pid) {
1272                 hs_len += snprintf(
1273                         header_str + hs_len, sizeof(header_str) - hs_len,
1274                         ", pid=%u", (unsigned int)getpid());
1275                 if (hs_len >= sizeof(header_str)) {
1276                         goto full;
1277                 }
1278         }
1279
1280         if (verbose || state.settings.debug_uid) {
1281                 hs_len += snprintf(
1282                         header_str + hs_len, sizeof(header_str) - hs_len,
1283                         ", effective(%u, %u), real(%u, %u)",
1284                         (unsigned int)geteuid(), (unsigned int)getegid(),
1285                         (unsigned int)getuid(), (unsigned int)getgid());
1286                 if (hs_len >= sizeof(header_str)) {
1287                         goto full;
1288                 }
1289         }
1290
1291         if ((verbose || state.settings.debug_class)
1292             && (cls != DBGC_ALL)) {
1293                 hs_len += snprintf(
1294                         header_str + hs_len, sizeof(header_str) - hs_len,
1295                         ", class=%s", classname_table[cls]);
1296                 if (hs_len >= sizeof(header_str)) {
1297                         goto full;
1298                 }
1299         }
1300
1301         /*
1302          * No +=, see man man strlcat
1303          */
1304         hs_len = strlcat(header_str, "] ", sizeof(header_str));
1305         if (hs_len >= sizeof(header_str)) {
1306                 goto full;
1307         }
1308
1309         if (!state.settings.debug_prefix_timestamp) {
1310                 hs_len += snprintf(
1311                         header_str + hs_len, sizeof(header_str) - hs_len,
1312                         "%s(%s)\n", location, func);
1313                 if (hs_len >= sizeof(header_str)) {
1314                         goto full;
1315                 }
1316         }
1317
1318 full:
1319         (void)Debug1(header_str);
1320
1321         errno = old_errno;
1322         return( true );
1323 }
1324
1325 /***************************************************************************
1326  Add text to the body of the "current" debug message via the format buffer.
1327
1328   Input:  format_str  - Format string, as used in printf(), et. al.
1329           ...         - Variable argument list.
1330
1331   ..or..  va_alist    - Old style variable parameter list starting point.
1332
1333   Output: Always true.  See dbghdr() for more info, though this is not
1334           likely to be used in the same way.
1335
1336 ***************************************************************************/
1337
1338 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1339 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1340 {
1341         char *msgbuf = NULL;
1342         bool ret = true;
1343         int res;
1344
1345         res = vasprintf(&msgbuf, format_str, ap);
1346         if (res != -1) {
1347                 format_debug_text(msgbuf);
1348         } else {
1349                 ret = false;
1350         }
1351         SAFE_FREE(msgbuf);
1352         return ret;
1353 }
1354
1355 bool dbgtext_va(const char *format_str, va_list ap)
1356 {
1357         return __dbgtext_va(format_str, ap);
1358 }
1359
1360 bool dbgtext(const char *format_str, ... )
1361 {
1362         va_list ap;
1363         bool ret;
1364
1365         va_start(ap, format_str);
1366         ret = __dbgtext_va(format_str, ap);
1367         va_end(ap);
1368
1369         return ret;
1370 }