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 FILE   *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 = 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         FILE *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         if (lp_loaded() && (*lp_logfile()))
 350                 pstrcpy(fname, lp_logfile());
 351
 352         pstrcpy( debugf, fname );
 353         if (append_log)
 354                 new_dbf = sys_fopen( debugf, "a" );
 355         else
 356                 new_dbf = sys_fopen( debugf, "w" );
 357
 358         if (!new_dbf) {
 359                 log_overflow = True;
 360                 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
 361                 log_overflow = False;
 362                 fflush(dbf);
 363                 ret = False;
 364         } else {
 365                 setbuf(new_dbf, NULL);
 366                 if (dbf)
 367                         (void) fclose(dbf);
 368                 dbf = new_dbf;
 369         }
 370
 371         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
 372          * to fix problem where smbd's that generate less
 373          * than 100 messages keep growing the log.
 374          */
 375         force_check_log_size();
 376         (void)umask(oldumask);
 377
 378         return ret;
 379 }
 380
 381 /* ************************************************************************** **
 382  * Force a check of the log size.
 383  * ************************************************************************** **
 384  */
 385 void force_check_log_size( void )
 386 {
 387   debug_count = 100;
 388 }
 389
 390 /***************************************************************************
 391  Check to see if there is any need to check if the logfile has grown too big.
 392 **************************************************************************/
 393
 394 BOOL need_to_check_log_size( void )
 395 {
 396         int maxlog;
 397
 398         if( debug_count++ < 100 )
 399                 return( False );
 400
 401         maxlog = lp_max_log_size() * 1024;
 402         if( !dbf || maxlog <= 0 ) {
 403                 debug_count = 0;
 404                 return(False);
 405         }
 406         return( True );
 407 }
 408
 409 /* ************************************************************************** **
 410  * Check to see if the log has grown to be too big.
 411  * ************************************************************************** **
 412  */
 413
 414 void check_log_size( void )
 415 {
 416         int         maxlog;
 417         SMB_STRUCT_STAT st;
 418
 419         /*
 420          *  We need to be root to check/change log-file, skip this and let the main
 421          *  loop check do a new check as root.
 422          */
 423
 424         if( geteuid() != 0 )
 425                 return;
 426
 427         if(log_overflow || !need_to_check_log_size() )
 428                 return;
 429
 430         maxlog = lp_max_log_size() * 1024;
 431
 432         if( sys_fstat( fileno( dbf ), &st ) == 0 && st.st_size > maxlog ) {
 433                 (void)reopen_logs();
 434                 if( dbf && get_file_size( debugf ) > maxlog ) {
 435                         pstring name;
 436
 437                         slprintf( name, sizeof(name)-1, "%s.old", debugf );
 438                         (void)rename( debugf, name );
 439
 440                         if (!reopen_logs()) {
 441                                 /* We failed to reopen a log - continue using the old name. */
 442                                 (void)rename(name, debugf);
 443                         }
 444                 }
 445         }
 446
 447         /*
 448          * Here's where we need to panic if dbf == NULL..
 449          */
 450
 451         if(dbf == NULL) {
 452                 /* This code should only be reached in very strange
 453                         circumstances. If we merely fail to open the new log we
 454                         should stick with the old one. ergo this should only be
 455                         reached when opening the logs for the first time: at
 456                         startup or when the log level is increased from zero.
 457                         -dwg 6 June 2000
 458                 */
 459                 dbf = sys_fopen( "/dev/console", "w" );
 460                 if(dbf) {
 461                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
 462                                         debugf ));
 463                 } else {
 464                         /*
 465                          * We cannot continue without a debug file handle.
 466                          */
 467                         abort();
 468                 }
 469         }
 470         debug_count = 0;
 471 } /* check_log_size */
 472
 473 /* ************************************************************************** **
 474  * Write an debug message on the debugfile.
 475  * This is called by dbghdr() and format_debug_text().
 476  * ************************************************************************** **
 477  */
 478  int Debug1( char *format_str, ... )
 479 {
 480   va_list ap;
 481   int old_errno = errno;
 482
 483   if( stdout_logging )
 484     {
 485     va_start( ap, format_str );
 486     if(dbf)
 487       (void)vfprintf( dbf, format_str, ap );
 488     va_end( ap );
 489     errno = old_errno;
 490     return( 0 );
 491     }
 492
 493 #ifdef WITH_SYSLOG
 494   if( !lp_syslog_only() )
 495 #endif
 496     {
 497     if( !dbf )
 498       {
 499       mode_t oldumask = umask( 022 );
 500
 501       if( append_log )
 502         dbf = sys_fopen( debugf, "a" );
 503       else
 504         dbf = sys_fopen( debugf, "w" );
 505       (void)umask( oldumask );
 506       if( dbf )
 507         {
 508         setbuf( dbf, NULL );
 509         }
 510       else
 511         {
 512         errno = old_errno;
 513         return(0);
 514         }
 515       }
 516     }
 517
 518 #ifdef WITH_SYSLOG
 519   if( syslog_level < lp_syslog() )
 520     {
 521     /* map debug levels to syslog() priorities
 522      * note that not all DEBUG(0, ...) calls are
 523      * necessarily errors
 524      */
 525     static int priority_map[] = {
 526       LOG_ERR,     /* 0 */
 527       LOG_WARNING, /* 1 */
 528       LOG_NOTICE,  /* 2 */
 529       LOG_INFO,    /* 3 */
 530       };
 531     int     priority;
 532     pstring msgbuf;
 533
 534     if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) )
 535      || syslog_level < 0)
 536       priority = LOG_DEBUG;
 537     else
 538       priority = priority_map[syslog_level];
 539
 540     va_start( ap, format_str );
 541     vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 542     va_end( ap );
 543
 544     msgbuf[255] = '\0';
 545     syslog( priority, "%s", msgbuf );
 546     }
 547 #endif
 548
 549   check_log_size();
 550
 551 #ifdef WITH_SYSLOG
 552   if( !lp_syslog_only() )
 553 #endif
 554     {
 555     va_start( ap, format_str );
 556     if(dbf)
 557       (void)vfprintf( dbf, format_str, ap );
 558     va_end( ap );
 559     if(dbf)
 560       (void)fflush( dbf );
 561     }
 562
 563   errno = old_errno;
 564
 565   return( 0 );
 566   } /* Debug1 */
 567
 568
 569 /* ************************************************************************** **
 570  * Print the buffer content via Debug1(), then reset the buffer.
 571  *
 572  *  Input:  none
 573  *  Output: none
 574  *
 575  * ************************************************************************** **
 576  */
 577 static void bufr_print( void )
 578   {
 579   format_bufr[format_pos] = '\0';
 580   (void)Debug1( "%s", format_bufr );
 581   format_pos = 0;
 582   } /* bufr_print */
 583
 584 /* ************************************************************************** **
 585  * Format the debug message text.
 586  *
 587  *  Input:  msg - Text to be added to the "current" debug message text.
 588  *
 589  *  Output: none.
 590  *
 591  *  Notes:  The purpose of this is two-fold.  First, each call to syslog()
 592  *          (used by Debug1(), see above) generates a new line of syslog
 593  *          output.  This is fixed by storing the partial lines until the
 594  *          newline character is encountered.  Second, printing the debug
 595  *          message lines when a newline is encountered allows us to add
 596  *          spaces, thus indenting the body of the message and making it
 597  *          more readable.
 598  *
 599  * ************************************************************************** **
 600  */
 601 static void format_debug_text( char *msg )
 602   {
 603   size_t i;
 604   BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() ||
 605                                         !(lp_loaded())));
 606
 607   for( i = 0; msg[i]; i++ )
 608     {
 609     /* Indent two spaces at each new line. */
 610     if(timestamp && 0 == format_pos)
 611       {
 612       format_bufr[0] = format_bufr[1] = ' ';
 613       format_pos = 2;
 614       }
 615
 616     /* If there's room, copy the character to the format buffer. */
 617     if( format_pos < FORMAT_BUFR_MAX )
 618       format_bufr[format_pos++] = msg[i];
 619
 620     /* If a newline is encountered, print & restart. */
 621     if( '\n' == msg[i] )
 622       bufr_print();
 623
 624     /* If the buffer is full dump it out, reset it, and put out a line
 625      * continuation indicator.
 626      */
 627     if( format_pos >= FORMAT_BUFR_MAX )
 628       {
 629       bufr_print();
 630       (void)Debug1( " +>\n" );
 631       }
 632     }
 633
 634   /* Just to be safe... */
 635   format_bufr[format_pos] = '\0';
 636   } /* format_debug_text */
 637
 638 /* ************************************************************************** **
 639  * Flush debug output, including the format buffer content.
 640  *
 641  *  Input:  none
 642  *  Output: none
 643  *
 644  * ************************************************************************** **
 645  */
 646 void dbgflush( void )
 647   {
 648   bufr_print();
 649   if(dbf)
 650     (void)fflush( dbf );
 651   } /* dbgflush */
 652
 653 /* ************************************************************************** **
 654  * Print a Debug Header.
 655  *
 656  *  Input:  level - Debug level of the message (not the system-wide debug
 657  *                  level.
 658  *          file  - Pointer to a string containing the name of the file
 659  *                  from which this function was called, or an empty string
 660  *                  if the __FILE__ macro is not implemented.
 661  *          func  - Pointer to a string containing the name of the function
 662  *                  from which this function was called, or an empty string
 663  *                  if the __FUNCTION__ macro is not implemented.
 664  *          line  - line number of the call to dbghdr, assuming __LINE__
 665  *                  works.
 666  *
 667  *  Output: Always True.  This makes it easy to fudge a call to dbghdr()
 668  *          in a macro, since the function can be called as part of a test.
 669  *          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 670  *
 671  *  Notes:  This function takes care of setting syslog_level.
 672  *
 673  * ************************************************************************** **
 674  */
 675
 676 BOOL dbghdr( int level, char *file, char *func, int line )
 677 {
 678   /* Ensure we don't lose any real errno value. */
 679   int old_errno = errno;
 680
 681   if( format_pos ) {
 682     /* This is a fudge.  If there is stuff sitting in the format_bufr, then
 683      * the *right* thing to do is to call
 684      *   format_debug_text( "\n" );
 685      * to write the remainder, and then proceed with the new header.
 686      * Unfortunately, there are several places in the code at which
 687      * the DEBUG() macro is used to build partial lines.  That in mind,
 688      * we'll work under the assumption that an incomplete line indicates
 689      * that a new header is *not* desired.
 690      */
 691     return( True );
 692   }
 693
 694 #ifdef WITH_SYSLOG
 695   /* Set syslog_level. */
 696   syslog_level = level;
 697 #endif
 698
 699   /* Don't print a header if we're logging to stdout. */
 700   if( stdout_logging )
 701     return( True );
 702
 703   /* Print the header if timestamps are turned on.  If parameters are
 704    * not yet loaded, then default to timestamps on.
 705    */
 706   if( lp_timestamp_logs() || !(lp_loaded()) ) {
 707     char header_str[200];
 708
 709         header_str[0] = '\0';
 710
 711         if( lp_debug_pid())
 712           slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
 713
 714         if( lp_debug_uid()) {
 715       size_t hs_len = strlen(header_str);
 716           slprintf(header_str + hs_len,
 717                sizeof(header_str) - 1 - hs_len,
 718                            ", effective(%u, %u), real(%u, %u)",
 719                (unsigned int)geteuid(), (unsigned int)getegid(),
 720                            (unsigned int)getuid(), (unsigned int)getgid());
 721         }
 722
 723     /* Print it all out at once to prevent split syslog output. */
 724     (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
 725                   timestring(lp_debug_hires_timestamp()), level,
 726                                   header_str, file, func, line );
 727   }
 728
 729   errno = old_errno;
 730   return( True );
 731 }
 732
 733 /* ************************************************************************** **
 734  * Add text to the body of the "current" debug message via the format buffer.
 735  *
 736  *  Input:  format_str  - Format string, as used in printf(), et. al.
 737  *          ...         - Variable argument list.
 738  *
 739  *  ..or..  va_alist    - Old style variable parameter list starting point.
 740  *
 741  *  Output: Always True.  See dbghdr() for more info, though this is not
 742  *          likely to be used in the same way.
 743  *
 744  * ************************************************************************** **
 745  */
 746  BOOL dbgtext( char *format_str, ... )
 747   {
 748   va_list ap;
 749   pstring msgbuf;
 750
 751   va_start( ap, format_str );
 752   vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 753   va_end( ap );
 754
 755   format_debug_text( msgbuf );
 756
 757   return( True );
 758   } /* dbgtext */
 759
 760
 761 /* ************************************************************************** */