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