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