source3/lib/debug.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5    Copyright (C) Andrew Tridgell 1992-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /* -------------------------------------------------------------------------- **
  25  * Defines...
  26  *
  27  *  FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
  28  *                    format_bufr[FORMAT_BUFR_MAX] should always be reserved
  29  *                    for a terminating nul byte.
  30  */
  31
  32 #define FORMAT_BUFR_MAX ( sizeof( format_bufr ) - 1 )
  33
  34 /* -------------------------------------------------------------------------- **
  35  * This module implements Samba's debugging utility.
  36  *
  37  * The syntax of a debugging log file is represented as:
  38  *
  39  *  <debugfile> :== { <debugmsg> }
  40  *
  41  *  <debugmsg>  :== <debughdr> '\n' <debugtext>
  42  *
  43  *  <debughdr>  :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
  44  *
  45  *  <debugtext> :== { <debugline> }
  46  *
  47  *  <debugline> :== TEXT '\n'
  48  *
  49  * TEXT     is a string of characters excluding the newline character.
  50  * LEVEL    is the DEBUG level of the message (an integer in the range 0..10).
  51  * TIME     is a timestamp.
  52  * FILENAME is the name of the file from which the debug message was generated.
  53  * FUNCTION is the function from which the debug message was generated.
  54  *
  55  * Basically, what that all means is:
  56  *
  57  * - A debugging log file is made up of debug messages.
  58  *
  59  * - Each debug message is made up of a header and text.  The header is
  60  *   separated from the text by a newline.
  61  *
  62  * - The header begins with the timestamp and debug level of the message
  63  *   enclosed in brackets.  The filename and function from which the
  64  *   message was generated may follow.  The filename is terminated by a
  65  *   colon, and the function name is terminated by parenthesis.
  66  *
  67  * - The message text is made up of zero or more lines, each terminated by
  68  *   a newline.
  69  */
  70
  71 /* -------------------------------------------------------------------------- **
  72  * External variables.
  73  *
  74  *  dbf           - Global debug file handle.
  75  *  debugf        - Debug file name.
  76  *  append_log    - If True, then the output file will be opened in append
  77  *                  mode.
  78  *  DEBUGLEVEL    - System-wide debug message limit.  Messages with message-
  79  *                  levels higher than DEBUGLEVEL will not be processed.
  80  */
  81
  82 XFILE   *dbf        = NULL;
  83 pstring debugf     = "";
  84 BOOL    append_log = False;
  85
  86 int     DEBUGLEVEL_CLASS[DBGC_LAST];
  87 BOOL    DEBUGLEVEL_CLASS_ISSET[DBGC_LAST];
  88 int     DEBUGLEVEL = DEBUGLEVEL_CLASS;
  89
  90
  91 /* -------------------------------------------------------------------------- **
  92  * Internal variables.
  93  *
  94  *  stdout_logging  - Default False, if set to True then dbf will be set to
  95  *                    stdout and debug output will go to dbf only, and not
  96  *                    to syslog.  Set in setup_logging() and read in Debug1().
  97  *
  98  *  debug_count     - Number of debug messages that have been output.
  99  *                    Used to check log size.
 100  *
 101  *  syslog_level    - Internal copy of the message debug level.  Written by
 102  *                    dbghdr() and read by Debug1().
 103  *
 104  *  format_bufr     - Used to format debug messages.  The dbgtext() function
 105  *                    prints debug messages to a string, and then passes the
 106  *                    string to format_debug_text(), which uses format_bufr
 107  *                    to build the formatted output.
 108  *
 109  *  format_pos      - Marks the first free byte of the format_bufr.
 110  *
 111  *
 112  *  log_overflow    - When this variable is True, never attempt to check the
 113  *                    size of the log. This is a hack, so that we can write
 114  *                    a message using DEBUG, from open_logs() when we
 115  *                    are unable to open a new log file for some reason.
 116  */
 117
 118 static BOOL    stdout_logging = False;
 119 static int     debug_count    = 0;
 120 #ifdef WITH_SYSLOG
 121 static int     syslog_level   = 0;
 122 #endif
 123 static pstring format_bufr    = { '\0' };
 124 static size_t     format_pos     = 0;
 125 static BOOL    log_overflow   = False;
 126
 127 /*
 128 * Define all the debug class selection names here. Names *MUST NOT* contain
 129 * white space. There must be one name for each DBGC_<class name>, and they
 130 * must be in the table in the order of DBGC_<class name>..
 131 */
 132 char *classname_table[] = {
 133         "all",               /* DBGC_ALL; index refs traditional DEBUGLEVEL */
 134         "tdb",               /* DBGC_TDB          */
 135         "printdrivers",      /* DBGC_PRINTDRIVERS */
 136         "lanman",            /* DBGC_LANMAN       */
 137         "smb",               /* DBGC_SMB          */
 138         "rpc",               /* DBGC_RPC          */
 139         "rpc_hdr",           /* DBGC_RPC_HDR      */
 140         "bdc",               /* DBGC_BDC          */
 141 };
 142
 143
 144 /* -------------------------------------------------------------------------- **
 145  * Functions...
 146  */
 147
 148 /****************************************************************************
 149 utility access to debug class names's
 150 ****************************************************************************/
 151 char* debug_classname_from_index(int ndx)
 152 {
 153         return classname_table[ndx];
 154 }
 155
 156 /****************************************************************************
 157 utility to translate names to debug class index's
 158 ****************************************************************************/
 159 int debug_lookup_classname(char* classname)
 160 {
 161         int i;
 162
 163         if (!classname) return -1;
 164
 165         for (i=0; i<DBGC_LAST; i++) {
 166                 if (strcmp(classname, classname_table[i])==0)
 167                         return i;
 168         }
 169         return -1;
 170 }
 171
 172 /****************************************************************************
 173 parse the debug levels from smbcontrol. Example debug level parameter:
 174   printdrivers:7
 175 ****************************************************************************/
 176 BOOL debug_parse_params(char **params, int *debuglevel_class,
 177                         BOOL *debuglevel_class_isset)
 178 {
 179         int   i, ndx;
 180         char *class_name;
 181         char *class_level;
 182
 183         /* Set the new debug level array to the current DEBUGLEVEL array */
 184         memcpy(debuglevel_class, DEBUGLEVEL_CLASS, sizeof(DEBUGLEVEL_CLASS));
 185
 186         /* Allow DBGC_ALL to be specifies w/o requiring its class name e.g."10"
 187          * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
 188          */
 189         if (isdigit((int)params[0][0])) {
 190                 debuglevel_class[DBGC_ALL] = atoi(params[0]);
 191                 debuglevel_class_isset[DBGC_ALL] = True;
 192                 i = 1; /* start processing at the next params */
 193         }
 194         else
 195                 i = 0; /* DBGC_ALL not specified  OR class name was included */
 196
 197         /* Fill in new debug class levels */
 198         for (; i < DBGC_LAST && params[i]; i++) {
 199                 if ((class_name=strtok(params[i],":")) &&
 200                         (class_level=strtok(NULL, "\0")) &&
 201             ((ndx = debug_lookup_classname(class_name)) != -1)) {
 202                                 debuglevel_class[ndx] = atoi(class_level);
 203                                 debuglevel_class_isset[ndx] = True;
 204                 } else {
 205                         DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
 206                         return False;
 207                 }
 208         }
 209
 210         return True;
 211 }
 212
 213 /****************************************************************************
 214 parse the debug levels from smb.conf. Example debug level string:
 215   3 tdb:5 printdrivers:7
 216 Note: the 1st param has no "name:" preceeding it.
 217 ****************************************************************************/
 218 BOOL debug_parse_levels(char *params_str)
 219 {
 220         int  i;
 221         char *params[DBGC_LAST];
 222         int  debuglevel_class[DBGC_LAST];
 223         BOOL debuglevel_class_isset[DBGC_LAST];
 224
 225         ZERO_ARRAY(params);
 226         ZERO_ARRAY(debuglevel_class);
 227         ZERO_ARRAY(debuglevel_class_isset);
 228
 229         if ((params[0]=strtok(params_str," ,"))) {
 230                 for (i=1; i<DBGC_LAST;i++) {
 231                         if ((params[i]=strtok(NULL," ,"))==NULL)
 232                                 break;
 233                 }
 234         }
 235         else
 236                 return False;
 237
 238         if (debug_parse_params(params, debuglevel_class,
 239                                debuglevel_class_isset)) {
 240                 debug_message(0, getpid(), (void*)debuglevel_class, sizeof(debuglevel_class));
 241
 242                 memcpy(DEBUGLEVEL_CLASS, debuglevel_class,
 243                        sizeof(debuglevel_class));
 244
 245                 memcpy(DEBUGLEVEL_CLASS_ISSET, debuglevel_class_isset,
 246                        sizeof(debuglevel_class_isset));
 247
 248                 {
 249                         int q;
 250
 251                         for (q = 0; q < DBGC_LAST; q++)
 252                                 DEBUG(5, ("%s: %d/%d\n",
 253                                           classname_table[q],
 254                                           DEBUGLEVEL_CLASS[q],
 255                                           DEBUGLEVEL_CLASS_ISSET[q]));
 256                 }
 257
 258                 return True;
 259         } else
 260                 return False;
 261 }
 262
 263 /****************************************************************************
 264 receive a "set debug level" message
 265 ****************************************************************************/
 266 void debug_message(int msg_type, pid_t src, void *buf, size_t len)
 267 {
 268         struct debuglevel_message *dm = (struct debuglevel_message *)buf;
 269         int i;
 270
 271         /* Set the new DEBUGLEVEL_CLASS array from the passed message */
 272         memcpy(DEBUGLEVEL_CLASS, dm->debuglevel_class, sizeof(dm->debuglevel_class));
 273         memcpy(DEBUGLEVEL_CLASS_ISSET, dm->debuglevel_class_isset, sizeof(dm->debuglevel_class_isset));
 274
 275         DEBUG(3,("INFO: Debug class %s level = %d   (pid %u from pid %u)\n",
 276                         classname_table[DBGC_ALL],
 277                         DEBUGLEVEL_CLASS[DBGC_ALL], (unsigned int)getpid(), (unsigned int)src));
 278
 279         for (i=1; i<DBGC_LAST; i++) {
 280                 if (DEBUGLEVEL_CLASS[i])
 281                          DEBUGADD(3,("INFO: Debug class %s level = %d\n",
 282                                                 classname_table[i], DEBUGLEVEL_CLASS[i]));
 283         }
 284 }
 285
 286
 287 /****************************************************************************
 288 send a "set debug level" message
 289 ****************************************************************************/
 290 void debug_message_send(pid_t pid, int level)
 291 {
 292         message_send_pid(pid, MSG_DEBUG, &level, sizeof(int), False);
 293 }
 294
 295
 296 /* ************************************************************************** **
 297  * get ready for syslog stuff
 298  * ************************************************************************** **
 299  */
 300 void setup_logging(char *pname, BOOL interactive)
 301 {
 302         message_register(MSG_DEBUG, debug_message);
 303
 304         /* reset to allow multiple setup calls, going from interactive to
 305            non-interactive */
 306         stdout_logging = False;
 307         dbf = NULL;
 308
 309         if (interactive) {
 310                 stdout_logging = True;
 311                 dbf = x_stdout;
 312         }
 313 #ifdef WITH_SYSLOG
 314         else {
 315                 char *p = strrchr_m( pname,'/' );
 316                 if (p)
 317                         pname = p + 1;
 318 #ifdef LOG_DAEMON
 319                 openlog( pname, LOG_PID, SYSLOG_FACILITY );
 320 #else /* for old systems that have no facility codes. */
 321                 openlog( pname, LOG_PID );
 322 #endif
 323         }
 324 #endif
 325 } /* setup_logging */
 326
 327 /* ************************************************************************** **
 328  * reopen the log files
 329  * note that we now do this unconditionally
 330  * We attempt to open the new debug fp before closing the old. This means
 331  * if we run out of fd's we just keep using the old fd rather than aborting.
 332  * Fix from dgibson@linuxcare.com.
 333  * ************************************************************************** **
 334  */
 335
 336 BOOL reopen_logs( void )
 337 {
 338         pstring fname;
 339         mode_t oldumask;
 340         XFILE *new_dbf = NULL;
 341         BOOL ret = True;
 342
 343         if (stdout_logging)
 344                 return True;
 345
 346         oldumask = umask( 022 );
 347
 348         pstrcpy(fname, debugf );
 349
 350         if (lp_loaded()) {
 351                 char *logfname;
 352
 353                 logfname = lp_logfile();
 354                 if (*logfname)
 355                         pstrcpy(fname, logfname);
 356         }
 357
 358         pstrcpy( debugf, fname );
 359         if (append_log)
 360                 new_dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
 361         else
 362                 new_dbf = x_fopen( debugf, O_WRONLY|O_CREAT|O_TRUNC, 0644 );
 363
 364         if (!new_dbf) {
 365                 log_overflow = True;
 366                 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
 367                 log_overflow = False;
 368                 if (dbf)
 369                         x_fflush(dbf);
 370                 ret = False;
 371         } else {
 372                 x_setbuf(new_dbf, NULL);
 373                 if (dbf)
 374                         (void) x_fclose(dbf);
 375                 dbf = new_dbf;
 376         }
 377
 378         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
 379          * to fix problem where smbd's that generate less
 380          * than 100 messages keep growing the log.
 381          */
 382         force_check_log_size();
 383         (void)umask(oldumask);
 384
 385         return ret;
 386 }
 387
 388 /* ************************************************************************** **
 389  * Force a check of the log size.
 390  * ************************************************************************** **
 391  */
 392 void force_check_log_size( void )
 393 {
 394   debug_count = 100;
 395 }
 396
 397 /***************************************************************************
 398  Check to see if there is any need to check if the logfile has grown too big.
 399 **************************************************************************/
 400
 401 BOOL need_to_check_log_size( void )
 402 {
 403         int maxlog;
 404
 405         if( debug_count++ < 100 )
 406                 return( False );
 407
 408         maxlog = lp_max_log_size() * 1024;
 409         if( !dbf || maxlog <= 0 ) {
 410                 debug_count = 0;
 411                 return(False);
 412         }
 413         return( True );
 414 }
 415
 416 /* ************************************************************************** **
 417  * Check to see if the log has grown to be too big.
 418  * ************************************************************************** **
 419  */
 420
 421 void check_log_size( void )
 422 {
 423         int         maxlog;
 424         SMB_STRUCT_STAT st;
 425
 426         /*
 427          *  We need to be root to check/change log-file, skip this and let the main
 428          *  loop check do a new check as root.
 429          */
 430
 431         if( geteuid() != 0 )
 432                 return;
 433
 434         if(log_overflow || !need_to_check_log_size() )
 435                 return;
 436
 437         maxlog = lp_max_log_size() * 1024;
 438
 439         if( sys_fstat( x_fileno( dbf ), &st ) == 0 && st.st_size > maxlog ) {
 440                 (void)reopen_logs();
 441                 if( dbf && get_file_size( debugf ) > maxlog ) {
 442                         pstring name;
 443
 444                         slprintf( name, sizeof(name)-1, "%s.old", debugf );
 445                         (void)rename( debugf, name );
 446
 447                         if (!reopen_logs()) {
 448                                 /* We failed to reopen a log - continue using the old name. */
 449                                 (void)rename(name, debugf);
 450                         }
 451                 }
 452         }
 453
 454         /*
 455          * Here's where we need to panic if dbf == NULL..
 456          */
 457
 458         if(dbf == NULL) {
 459                 /* This code should only be reached in very strange
 460                         circumstances. If we merely fail to open the new log we
 461                         should stick with the old one. ergo this should only be
 462                         reached when opening the logs for the first time: at
 463                         startup or when the log level is increased from zero.
 464                         -dwg 6 June 2000
 465                 */
 466                 dbf = x_fopen( "/dev/console", O_WRONLY, 0);
 467                 if(dbf) {
 468                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
 469                                         debugf ));
 470                 } else {
 471                         /*
 472                          * We cannot continue without a debug file handle.
 473                          */
 474                         abort();
 475                 }
 476         }
 477         debug_count = 0;
 478 } /* check_log_size */
 479
 480 /* ************************************************************************** **
 481  * Write an debug message on the debugfile.
 482  * This is called by dbghdr() and format_debug_text().
 483  * ************************************************************************** **
 484  */
 485  int Debug1( char *format_str, ... )
 486 {
 487   va_list ap;
 488   int old_errno = errno;
 489
 490   if( stdout_logging )
 491     {
 492     va_start( ap, format_str );
 493     if(dbf)
 494       (void)x_vfprintf( dbf, format_str, ap );
 495     va_end( ap );
 496     errno = old_errno;
 497     return( 0 );
 498     }
 499
 500 #ifdef WITH_SYSLOG
 501   if( !lp_syslog_only() )
 502 #endif
 503     {
 504     if( !dbf )
 505       {
 506       mode_t oldumask = umask( 022 );
 507
 508       if( append_log )
 509         dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
 510       else
 511         dbf = x_fopen( debugf, O_WRONLY|O_CREAT|O_TRUNC, 0644 );
 512       (void)umask( oldumask );
 513       if( dbf )
 514         {
 515         x_setbuf( dbf, NULL );
 516         }
 517       else
 518         {
 519         errno = old_errno;
 520         return(0);
 521         }
 522       }
 523     }
 524
 525 #ifdef WITH_SYSLOG
 526   if( syslog_level < lp_syslog() )
 527     {
 528     /* map debug levels to syslog() priorities
 529      * note that not all DEBUG(0, ...) calls are
 530      * necessarily errors
 531      */
 532     static int priority_map[] = {
 533       LOG_ERR,     /* 0 */
 534       LOG_WARNING, /* 1 */
 535       LOG_NOTICE,  /* 2 */
 536       LOG_INFO,    /* 3 */
 537       };
 538     int     priority;
 539     pstring msgbuf;
 540
 541     if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) )
 542      || syslog_level < 0)
 543       priority = LOG_DEBUG;
 544     else
 545       priority = priority_map[syslog_level];
 546
 547     va_start( ap, format_str );
 548     vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 549     va_end( ap );
 550
 551     msgbuf[255] = '\0';
 552     syslog( priority, "%s", msgbuf );
 553     }
 554 #endif
 555
 556   check_log_size();
 557
 558 #ifdef WITH_SYSLOG
 559   if( !lp_syslog_only() )
 560 #endif
 561     {
 562     va_start( ap, format_str );
 563     if(dbf)
 564       (void)x_vfprintf( dbf, format_str, ap );
 565     va_end( ap );
 566     if(dbf)
 567       (void)x_fflush( dbf );
 568     }
 569
 570   errno = old_errno;
 571
 572   return( 0 );
 573   } /* Debug1 */
 574
 575
 576 /* ************************************************************************** **
 577  * Print the buffer content via Debug1(), then reset the buffer.
 578  *
 579  *  Input:  none
 580  *  Output: none
 581  *
 582  * ************************************************************************** **
 583  */
 584 static void bufr_print( void )
 585   {
 586   format_bufr[format_pos] = '\0';
 587   (void)Debug1( "%s", format_bufr );
 588   format_pos = 0;
 589   } /* bufr_print */
 590
 591 /* ************************************************************************** **
 592  * Format the debug message text.
 593  *
 594  *  Input:  msg - Text to be added to the "current" debug message text.
 595  *
 596  *  Output: none.
 597  *
 598  *  Notes:  The purpose of this is two-fold.  First, each call to syslog()
 599  *          (used by Debug1(), see above) generates a new line of syslog
 600  *          output.  This is fixed by storing the partial lines until the
 601  *          newline character is encountered.  Second, printing the debug
 602  *          message lines when a newline is encountered allows us to add
 603  *          spaces, thus indenting the body of the message and making it
 604  *          more readable.
 605  *
 606  * ************************************************************************** **
 607  */
 608 static void format_debug_text( char *msg )
 609   {
 610   size_t i;
 611   BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() ||
 612                                         !(lp_loaded())));
 613
 614   for( i = 0; msg[i]; i++ )
 615     {
 616     /* Indent two spaces at each new line. */
 617     if(timestamp && 0 == format_pos)
 618       {
 619       format_bufr[0] = format_bufr[1] = ' ';
 620       format_pos = 2;
 621       }
 622
 623     /* If there's room, copy the character to the format buffer. */
 624     if( format_pos < FORMAT_BUFR_MAX )
 625       format_bufr[format_pos++] = msg[i];
 626
 627     /* If a newline is encountered, print & restart. */
 628     if( '\n' == msg[i] )
 629       bufr_print();
 630
 631     /* If the buffer is full dump it out, reset it, and put out a line
 632      * continuation indicator.
 633      */
 634     if( format_pos >= FORMAT_BUFR_MAX )
 635       {
 636       bufr_print();
 637       (void)Debug1( " +>\n" );
 638       }
 639     }
 640
 641   /* Just to be safe... */
 642   format_bufr[format_pos] = '\0';
 643   } /* format_debug_text */
 644
 645 /* ************************************************************************** **
 646  * Flush debug output, including the format buffer content.
 647  *
 648  *  Input:  none
 649  *  Output: none
 650  *
 651  * ************************************************************************** **
 652  */
 653 void dbgflush( void )
 654   {
 655   bufr_print();
 656   if(dbf)
 657     (void)x_fflush( dbf );
 658   } /* dbgflush */
 659
 660 /* ************************************************************************** **
 661  * Print a Debug Header.
 662  *
 663  *  Input:  level - Debug level of the message (not the system-wide debug
 664  *                  level.
 665  *          file  - Pointer to a string containing the name of the file
 666  *                  from which this function was called, or an empty string
 667  *                  if the __FILE__ macro is not implemented.
 668  *          func  - Pointer to a string containing the name of the function
 669  *                  from which this function was called, or an empty string
 670  *                  if the __FUNCTION__ macro is not implemented.
 671  *          line  - line number of the call to dbghdr, assuming __LINE__
 672  *                  works.
 673  *
 674  *  Output: Always True.  This makes it easy to fudge a call to dbghdr()
 675  *          in a macro, since the function can be called as part of a test.
 676  *          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 677  *
 678  *  Notes:  This function takes care of setting syslog_level.
 679  *
 680  * ************************************************************************** **
 681  */
 682
 683 BOOL dbghdr( int level, char *file, char *func, int line )
 684 {
 685   /* Ensure we don't lose any real errno value. */
 686   int old_errno = errno;
 687
 688   if( format_pos ) {
 689     /* This is a fudge.  If there is stuff sitting in the format_bufr, then
 690      * the *right* thing to do is to call
 691      *   format_debug_text( "\n" );
 692      * to write the remainder, and then proceed with the new header.
 693      * Unfortunately, there are several places in the code at which
 694      * the DEBUG() macro is used to build partial lines.  That in mind,
 695      * we'll work under the assumption that an incomplete line indicates
 696      * that a new header is *not* desired.
 697      */
 698     return( True );
 699   }
 700
 701 #ifdef WITH_SYSLOG
 702   /* Set syslog_level. */
 703   syslog_level = level;
 704 #endif
 705
 706   /* Don't print a header if we're logging to stdout. */
 707   if( stdout_logging )
 708     return( True );
 709
 710   /* Print the header if timestamps are turned on.  If parameters are
 711    * not yet loaded, then default to timestamps on.
 712    */
 713   if( lp_timestamp_logs() || !(lp_loaded()) ) {
 714     char header_str[200];
 715
 716         header_str[0] = '\0';
 717
 718         if( lp_debug_pid())
 719           slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
 720
 721         if( lp_debug_uid()) {
 722       size_t hs_len = strlen(header_str);
 723           slprintf(header_str + hs_len,
 724                sizeof(header_str) - 1 - hs_len,
 725                            ", effective(%u, %u), real(%u, %u)",
 726                (unsigned int)geteuid(), (unsigned int)getegid(),
 727                            (unsigned int)getuid(), (unsigned int)getgid());
 728         }
 729
 730     /* Print it all out at once to prevent split syslog output. */
 731     (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
 732                   timestring(lp_debug_hires_timestamp()), level,
 733                                   header_str, file, func, line );
 734   }
 735
 736   errno = old_errno;
 737   return( True );
 738 }
 739
 740 /* ************************************************************************** **
 741  * Add text to the body of the "current" debug message via the format buffer.
 742  *
 743  *  Input:  format_str  - Format string, as used in printf(), et. al.
 744  *          ...         - Variable argument list.
 745  *
 746  *  ..or..  va_alist    - Old style variable parameter list starting point.
 747  *
 748  *  Output: Always True.  See dbghdr() for more info, though this is not
 749  *          likely to be used in the same way.
 750  *
 751  * ************************************************************************** **
 752  */
 753  BOOL dbgtext( char *format_str, ... )
 754   {
 755   va_list ap;
 756   pstring msgbuf;
 757
 758   va_start( ap, format_str );
 759   vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 760   va_end( ap );
 761
 762   format_debug_text( msgbuf );
 763
 764   return( True );
 765   } /* dbgtext */
 766
 767
 768 /* ************************************************************************** */