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