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