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 _SAMBA_BUILD_ == 3
 647         if (geteuid() != sec_initial_uid())
 648 #else
 649         if( geteuid() != 0)
 650 #endif
 651         {
 652                 /* We don't check sec_initial_uid() here as it isn't
 653                  * available in common code and we don't generally
 654                  * want to rotate and the possibly lose logs in
 655                  * make test or the build farm */
 656                 return;
 657         }
 658
 659         if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
 660                 return;
 661         }
 662
 663         maxlog = state.settings.max_log_size * 1024;
 664
 665         if (state.schedule_reopen_logs ||
 666            (fstat(state.fd, &st) == 0
 667             && st.st_size > maxlog )) {
 668                 (void)reopen_logs_internal();
 669                 if (state.fd > 0 && fstat(state.fd, &st) == 0) {
 670                         if (st.st_size > maxlog) {
 671                                 char *name = NULL;
 672
 673                                 if (asprintf(&name, "%s.old", state.debugf ) < 0) {
 674                                         return;
 675                                 }
 676                                 (void)rename(state.debugf, name);
 677
 678                                 if (!reopen_logs_internal()) {
 679                                         /* We failed to reopen a log - continue using the old name. */
 680                                         (void)rename(name, state.debugf);
 681                                 }
 682                                 SAFE_FREE(name);
 683                         }
 684                 }
 685         }
 686
 687         /*
 688          * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
 689          */
 690
 691         if (state.fd <= 0) {
 692                 /* This code should only be reached in very strange
 693                  * circumstances. If we merely fail to open the new log we
 694                  * should stick with the old one. ergo this should only be
 695                  * reached when opening the logs for the first time: at
 696                  * startup or when the log level is increased from zero.
 697                  * -dwg 6 June 2000
 698                  */
 699                 int fd = open( "/dev/console", O_WRONLY, 0);
 700                 if (fd != -1) {
 701                         state.fd = fd;
 702                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
 703                                         state.debugf ));
 704                 } else {
 705                         /*
 706                          * We cannot continue without a debug file handle.
 707                          */
 708                         abort();
 709                 }
 710         }
 711         debug_count = 0;
 712 }
 713
 714 /*************************************************************************
 715  Write an debug message on the debugfile.
 716  This is called by dbghdr() and format_debug_text().
 717 ************************************************************************/
 718
 719  int Debug1( const char *format_str, ... )
 720 {
 721         va_list ap;
 722         int old_errno = errno;
 723
 724         debug_count++;
 725
 726         if ( state.logtype != DEBUG_FILE ) {
 727                 va_start( ap, format_str );
 728                 if (state.fd > 0)
 729                         (void)vdprintf( state.fd, format_str, ap );
 730                 va_end( ap );
 731                 errno = old_errno;
 732                 goto done;
 733         }
 734
 735 #ifdef WITH_SYSLOG
 736         if( !state.settings.syslog_only)
 737 #endif
 738         {
 739                 if( state.fd <= 0 ) {
 740                         mode_t oldumask = umask( 022 );
 741                         int fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
 742                         (void)umask( oldumask );
 743                         if(fd == -1) {
 744                                 errno = old_errno;
 745                                 goto done;
 746                         }
 747                         state.fd = fd;
 748                 }
 749         }
 750
 751 #ifdef WITH_SYSLOG
 752         if( syslog_level < state.settings.syslog ) {
 753                 /* map debug levels to syslog() priorities
 754                  * note that not all DEBUG(0, ...) calls are
 755                  * necessarily errors */
 756                 static const int priority_map[4] = {
 757                         LOG_ERR,     /* 0 */
 758                         LOG_WARNING, /* 1 */
 759                         LOG_NOTICE,  /* 2 */
 760                         LOG_INFO,    /* 3 */
 761                 };
 762                 int     priority;
 763                 char *msgbuf = NULL;
 764                 int ret;
 765
 766                 if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
 767                         priority = LOG_DEBUG;
 768                 else
 769                         priority = priority_map[syslog_level];
 770
 771                 /*
 772                  * Specify the facility to interoperate with other syslog
 773                  * callers (vfs_full_audit for example).
 774                  */
 775                 priority |= SYSLOG_FACILITY;
 776
 777                 va_start(ap, format_str);
 778                 ret = vasprintf(&msgbuf, format_str, ap);
 779                 va_end(ap);
 780
 781                 if (ret != -1) {
 782                         syslog(priority, "%s", msgbuf);
 783                 }
 784                 SAFE_FREE(msgbuf);
 785         }
 786 #endif
 787
 788         check_log_size();
 789
 790 #ifdef WITH_SYSLOG
 791         if( !state.settings.syslog_only)
 792 #endif
 793         {
 794                 va_start( ap, format_str );
 795                 if (state.fd > 0)
 796                         (void)vdprintf( state.fd, format_str, ap );
 797                 va_end( ap );
 798         }
 799
 800  done:
 801         errno = old_errno;
 802
 803         return( 0 );
 804 }
 805
 806
 807 /**************************************************************************
 808  Print the buffer content via Debug1(), then reset the buffer.
 809  Input:  none
 810  Output: none
 811 ****************************************************************************/
 812
 813 static void bufr_print( void )
 814 {
 815         format_bufr[format_pos] = '\0';
 816         (void)Debug1( "%s", format_bufr );
 817         format_pos = 0;
 818 }
 819
 820 /***************************************************************************
 821  Format the debug message text.
 822
 823  Input:  msg - Text to be added to the "current" debug message text.
 824
 825  Output: none.
 826
 827  Notes:  The purpose of this is two-fold.  First, each call to syslog()
 828          (used by Debug1(), see above) generates a new line of syslog
 829          output.  This is fixed by storing the partial lines until the
 830          newline character is encountered.  Second, printing the debug
 831          message lines when a newline is encountered allows us to add
 832          spaces, thus indenting the body of the message and making it
 833          more readable.
 834 **************************************************************************/
 835
 836 static void format_debug_text( const char *msg )
 837 {
 838         size_t i;
 839         bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
 840
 841         if (!format_bufr) {
 842                 debug_init();
 843         }
 844
 845         for( i = 0; msg[i]; i++ ) {
 846                 /* Indent two spaces at each new line. */
 847                 if(timestamp && 0 == format_pos) {
 848                         format_bufr[0] = format_bufr[1] = ' ';
 849                         format_pos = 2;
 850                 }
 851
 852                 /* If there's room, copy the character to the format buffer. */
 853                 if( format_pos < FORMAT_BUFR_MAX )
 854                         format_bufr[format_pos++] = msg[i];
 855
 856                 /* If a newline is encountered, print & restart. */
 857                 if( '\n' == msg[i] )
 858                         bufr_print();
 859
 860                 /* If the buffer is full dump it out, reset it, and put out a line
 861                  * continuation indicator.
 862                  */
 863                 if( format_pos >= FORMAT_BUFR_MAX ) {
 864                         bufr_print();
 865                         (void)Debug1( " +>\n" );
 866                 }
 867         }
 868
 869         /* Just to be safe... */
 870         format_bufr[format_pos] = '\0';
 871 }
 872
 873 /***************************************************************************
 874  Flush debug output, including the format buffer content.
 875
 876  Input:  none
 877  Output: none
 878 ***************************************************************************/
 879
 880 void dbgflush( void )
 881 {
 882         bufr_print();
 883 }
 884
 885 /***************************************************************************
 886  Print a Debug Header.
 887
 888  Input:  level - Debug level of the message (not the system-wide debug
 889                   level. )
 890           cls   - Debuglevel class of the calling module.
 891           file  - Pointer to a string containing the name of the file
 892                   from which this function was called, or an empty string
 893                   if the __FILE__ macro is not implemented.
 894           func  - Pointer to a string containing the name of the function
 895                   from which this function was called, or an empty string
 896                   if the __FUNCTION__ macro is not implemented.
 897          line  - line number of the call to dbghdr, assuming __LINE__
 898                  works.
 899
 900   Output: Always true.  This makes it easy to fudge a call to dbghdr()
 901           in a macro, since the function can be called as part of a test.
 902           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 903
 904   Notes:  This function takes care of setting syslog_level.
 905
 906 ****************************************************************************/
 907
 908 bool dbghdrclass(int level, int cls, const char *location, const char *func)
 909 {
 910         /* Ensure we don't lose any real errno value. */
 911         int old_errno = errno;
 912
 913         if( format_pos ) {
 914                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
 915                  * the *right* thing to do is to call
 916                  *   format_debug_text( "\n" );
 917                  * to write the remainder, and then proceed with the new header.
 918                  * Unfortunately, there are several places in the code at which
 919                  * the DEBUG() macro is used to build partial lines.  That in mind,
 920                  * we'll work under the assumption that an incomplete line indicates
 921                  * that a new header is *not* desired.
 922                  */
 923                 return( true );
 924         }
 925
 926 #ifdef WITH_SYSLOG
 927         /* Set syslog_level. */
 928         syslog_level = level;
 929 #endif
 930
 931         /* Don't print a header if we're logging to stdout. */
 932         if ( state.logtype != DEBUG_FILE ) {
 933                 return( true );
 934         }
 935
 936         /* Print the header if timestamps are turned on.  If parameters are
 937          * not yet loaded, then default to timestamps on.
 938          */
 939         if( state.settings.timestamp_logs || state.settings.debug_prefix_timestamp) {
 940                 char header_str[200];
 941
 942                 header_str[0] = '\0';
 943
 944                 if( state.settings.debug_pid)
 945                         slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)getpid());
 946
 947                 if( state.settings.debug_uid) {
 948                         size_t hs_len = strlen(header_str);
 949                         slprintf(header_str + hs_len,
 950                         sizeof(header_str) - 1 - hs_len,
 951                                 ", effective(%u, %u), real(%u, %u)",
 952                                 (unsigned int)geteuid(), (unsigned int)getegid(),
 953                                 (unsigned int)getuid(), (unsigned int)getgid());
 954                 }
 955
 956                 if (state.settings.debug_class && (cls != DBGC_ALL)) {
 957                         size_t hs_len = strlen(header_str);
 958                         slprintf(header_str + hs_len,
 959                                  sizeof(header_str) -1 - hs_len,
 960                                  ", class=%s",
 961                                  default_classname_table[cls]);
 962                 }
 963
 964                 /* Print it all out at once to prevent split syslog output. */
 965                 if( state.settings.debug_prefix_timestamp ) {
 966                         char *time_str = current_timestring(NULL,
 967                                                             state.settings.debug_hires_timestamp);
 968                         (void)Debug1( "[%s, %2d%s] ",
 969                                       time_str,
 970                                       level, header_str);
 971                         talloc_free(time_str);
 972                 } else {
 973                         char *time_str = current_timestring(NULL,
 974                                                             state.settings.debug_hires_timestamp);
 975                         (void)Debug1( "[%s, %2d%s] %s(%s)\n",
 976                                       time_str,
 977                                       level, header_str, location, func );
 978                         talloc_free(time_str);
 979                 }
 980         }
 981
 982         errno = old_errno;
 983         return( true );
 984 }
 985
 986 /***************************************************************************
 987  Add text to the body of the "current" debug message via the format buffer.
 988
 989   Input:  format_str  - Format string, as used in printf(), et. al.
 990           ...         - Variable argument list.
 991
 992   ..or..  va_alist    - Old style variable parameter list starting point.
 993
 994   Output: Always true.  See dbghdr() for more info, though this is not
 995           likely to be used in the same way.
 996
 997 ***************************************************************************/
 998
 999  bool dbgtext( const char *format_str, ... )
1000 {
1001         va_list ap;
1002         char *msgbuf = NULL;
1003         bool ret = true;
1004         int res;
1005
1006         va_start(ap, format_str);
1007         res = vasprintf(&msgbuf, format_str, ap);
1008         va_end(ap);
1009
1010         if (res != -1) {
1011                 format_debug_text(msgbuf);
1012         } else {
1013                 ret = false;
1014         }
1015         SAFE_FREE(msgbuf);
1016         return ret;
1017 }
1018
1019
1020 /* the registered mutex handlers */
1021 static struct {
1022         const char *name;
1023         struct debug_ops ops;
1024 } debug_handlers;
1025
1026 /**
1027   log suspicious usage - print comments and backtrace
1028 */
1029 _PUBLIC_ void log_suspicious_usage(const char *from, const char *info)
1030 {
1031         if (!debug_handlers.ops.log_suspicious_usage) return;
1032
1033         debug_handlers.ops.log_suspicious_usage(from, info);
1034 }
1035
1036
1037 /**
1038   print suspicious usage - print comments and backtrace
1039 */
1040 _PUBLIC_ void print_suspicious_usage(const char* from, const char* info)
1041 {
1042         if (!debug_handlers.ops.print_suspicious_usage) return;
1043
1044         debug_handlers.ops.print_suspicious_usage(from, info);
1045 }
1046
1047 _PUBLIC_ uint32_t get_task_id(void)
1048 {
1049         if (debug_handlers.ops.get_task_id) {
1050                 return debug_handlers.ops.get_task_id();
1051         }
1052         return getpid();
1053 }
1054
1055 _PUBLIC_ void log_task_id(void)
1056 {
1057         if (!debug_handlers.ops.log_task_id) return;
1058
1059         if (!reopen_logs_internal()) return;
1060
1061         debug_handlers.ops.log_task_id(state.fd);
1062 }
1063
1064 /**
1065   register a set of debug handlers.
1066 */
1067 _PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops)
1068 {
1069         debug_handlers.name = name;
1070         debug_handlers.ops = *ops;
1071 }