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