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 int     DEBUGLEVEL = 1;
  86
  87
  88 /* -------------------------------------------------------------------------- **
  89  * Internal variables.
  90  *
  91  *  stdout_logging  - Default False, if set to True then dbf will be set to
  92  *                    stdout and debug output will go to dbf only, and not
  93  *                    to syslog.  Set in setup_logging() and read in Debug1().
  94  *
  95  *  debug_count     - Number of debug messages that have been output.
  96  *                    Used to check log size.
  97  *
  98  *  syslog_level    - Internal copy of the message debug level.  Written by
  99  *                    dbghdr() and read by Debug1().
 100  *
 101  *  format_bufr     - Used to format debug messages.  The dbgtext() function
 102  *                    prints debug messages to a string, and then passes the
 103  *                    string to format_debug_text(), which uses format_bufr
 104  *                    to build the formatted output.
 105  *
 106  *  format_pos      - Marks the first free byte of the format_bufr.
 107  */
 108
 109 static BOOL    stdout_logging = False;
 110 static int     debug_count    = 0;
 111 static int     syslog_level   = 0;
 112 static pstring format_bufr    = { '\0' };
 113 static int     format_pos     = 0;
 114
 115
 116 /* -------------------------------------------------------------------------- **
 117  * Functions...
 118  */
 119
 120 #if defined(SIGUSR2)
 121 /* ************************************************************************** **
 122  * catch a sigusr2 - decrease the debug log level.
 123  * ************************************************************************** **
 124  */
 125 void sig_usr2( int sig )
 126   {
 127   BlockSignals( True, SIGUSR2 );
 128
 129   DEBUGLEVEL--;
 130   if( DEBUGLEVEL < 0 )
 131     DEBUGLEVEL = 0;
 132
 133   DEBUG( 0, ( "Got SIGUSR2; set debug level to %d.\n", DEBUGLEVEL ) );
 134
 135   BlockSignals( False, SIGUSR2 );
 136   CatchSignal( SIGUSR2, SIGNAL_CAST sig_usr2 );
 137
 138   } /* sig_usr2 */
 139 #endif /* SIGUSR2 */
 140
 141 #if defined(SIGUSR1)
 142 /* ************************************************************************** **
 143  * catch a sigusr1 - increase the debug log level.
 144  * ************************************************************************** **
 145  */
 146 void sig_usr1( int sig )
 147   {
 148   BlockSignals( True, SIGUSR1 );
 149
 150   DEBUGLEVEL++;
 151
 152   if( DEBUGLEVEL > 10 )
 153     DEBUGLEVEL = 10;
 154
 155   DEBUG( 0, ( "Got SIGUSR1; set debug level to %d.\n", DEBUGLEVEL ) );
 156
 157   BlockSignals( False, SIGUSR1 );
 158   CatchSignal( SIGUSR1, SIGNAL_CAST sig_usr1 );
 159
 160   } /* sig_usr1 */
 161 #endif /* SIGUSR1 */
 162
 163
 164 /* ************************************************************************** **
 165  * get ready for syslog stuff
 166  * ************************************************************************** **
 167  */
 168 void setup_logging( char *pname, BOOL interactive )
 169   {
 170   if( interactive )
 171     {
 172     stdout_logging = True;
 173     dbf = stdout;
 174     }
 175 #ifdef WITH_SYSLOG
 176   else
 177     {
 178     char *p = strrchr( pname,'/' );
 179
 180     if( p )
 181       pname = p + 1;
 182 #ifdef LOG_DAEMON
 183     openlog( pname, LOG_PID, SYSLOG_FACILITY );
 184 #else /* for old systems that have no facility codes. */
 185     openlog( pname, LOG_PID );
 186 #endif
 187     }
 188 #endif
 189   } /* setup_logging */
 190
 191 /* ************************************************************************** **
 192  * reopen the log files
 193  * ************************************************************************** **
 194  */
 195 void reopen_logs( void )
 196   {
 197   pstring fname;
 198
 199   if( DEBUGLEVEL > 0 )
 200     {
 201     pstrcpy( fname, debugf );
 202     if( lp_loaded() && (*lp_logfile()) )
 203       pstrcpy( fname, lp_logfile() );
 204
 205     if( !strcsequal( fname, debugf ) || !dbf || !file_exist( debugf, NULL ) )
 206       {
 207       int oldumask = umask( 022 );
 208
 209       pstrcpy( debugf, fname );
 210       if( dbf )
 211         (void)fclose( dbf );
 212       if( append_log )
 213         dbf = fopen( debugf, "a" );
 214       else
 215         dbf = fopen( debugf, "w" );
 216       /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
 217        * to fix problem where smbd's that generate less
 218        * than 100 messages keep growing the log.
 219        */
 220       force_check_log_size();
 221       if( dbf )
 222         setbuf( dbf, NULL );
 223       (void)umask( oldumask );
 224       }
 225     }
 226   else
 227     {
 228     if( dbf )
 229       {
 230       (void)fclose( dbf );
 231       dbf = NULL;
 232       }
 233     }
 234   } /* reopen_logs */
 235
 236 /* ************************************************************************** **
 237  * Force a check of the log size.
 238  * ************************************************************************** **
 239  */
 240 void force_check_log_size( void )
 241   {
 242   debug_count = 100;
 243   } /* force_check_log_size */
 244
 245 /* ************************************************************************** **
 246  * Check to see if the log has grown to be too big.
 247  * ************************************************************************** **
 248  */
 249 static void check_log_size( void )
 250   {
 251   int         maxlog;
 252   SMB_STRUCT_STAT st;
 253
 254   if( debug_count++ < 100 || getuid() != 0 )
 255     return;
 256
 257   maxlog = lp_max_log_size() * 1024;
 258   if( !dbf || maxlog <= 0 )
 259     return;
 260
 261   if( sys_fstat( fileno( dbf ), &st ) == 0 && st.st_size > maxlog )
 262     {
 263     (void)fclose( dbf );
 264     dbf = NULL;
 265     reopen_logs();
 266     if( dbf && file_size( debugf ) > maxlog )
 267       {
 268       pstring name;
 269
 270       (void)fclose( dbf );
 271       dbf = NULL;
 272       slprintf( name, sizeof(name)-1, "%s.old", debugf );
 273       (void)rename( debugf, name );
 274       reopen_logs();
 275       }
 276     }
 277   debug_count = 0;
 278   } /* check_log_size */
 279
 280 /* ************************************************************************** **
 281  * Write an debug message on the debugfile.
 282  * This is called by dbghdr() and format_debug_text().
 283  * ************************************************************************** **
 284  */
 285 #ifdef HAVE_STDARG_H
 286  int Debug1( char *format_str, ... )
 287 {
 288 #else
 289  int Debug1(va_alist)
 290 va_dcl
 291 {
 292   char *format_str;
 293 #endif
 294   va_list ap;
 295   int old_errno = errno;
 296
 297   if( stdout_logging )
 298     {
 299 #ifdef HAVE_STDARG_H
 300     va_start( ap, format_str );
 301 #else
 302     va_start( ap );
 303     format_str = va_arg( ap, char * );
 304 #endif
 305     (void)vfprintf( dbf, format_str, ap );
 306     va_end( ap );
 307     errno = old_errno;
 308     return( 0 );
 309     }
 310
 311 #ifdef WITH_SYSLOG
 312   if( !lp_syslog_only() )
 313 #endif
 314     {
 315     if( !dbf )
 316       {
 317       int oldumask = umask( 022 );
 318
 319       if( append_log )
 320         dbf = fopen( debugf, "a" );
 321       else
 322         dbf = fopen( debugf, "w" );
 323       (void)umask( oldumask );
 324       if( dbf )
 325         {
 326         setbuf( dbf, NULL );
 327         }
 328       else
 329         {
 330         errno = old_errno;
 331         return(0);
 332         }
 333       }
 334     }
 335
 336 #ifdef WITH_SYSLOG
 337   if( syslog_level < lp_syslog() )
 338     {
 339     /* map debug levels to syslog() priorities
 340      * note that not all DEBUG(0, ...) calls are
 341      * necessarily errors
 342      */
 343     static int priority_map[] = {
 344       LOG_ERR,     /* 0 */
 345       LOG_WARNING, /* 1 */
 346       LOG_NOTICE,  /* 2 */
 347       LOG_INFO,    /* 3 */
 348       };
 349     int     priority;
 350     pstring msgbuf;
 351
 352     if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) )
 353      || syslog_level < 0)
 354       priority = LOG_DEBUG;
 355     else
 356       priority = priority_map[syslog_level];
 357
 358 #ifdef HAVE_STDARG_H
 359     va_start( ap, format_str );
 360 #else
 361     va_start( ap );
 362     format_str = va_arg( ap, char * );
 363 #endif
 364     vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 365     va_end( ap );
 366
 367     msgbuf[255] = '\0';
 368     syslog( priority, "%s", msgbuf );
 369     }
 370 #endif
 371
 372 #ifdef WITH_SYSLOG
 373   if( !lp_syslog_only() )
 374 #endif
 375     {
 376 #ifdef HAVE_STDARG_H
 377     va_start( ap, format_str );
 378 #else
 379     va_start( ap );
 380     format_str = va_arg( ap, char * );
 381 #endif
 382     (void)vfprintf( dbf, format_str, ap );
 383     va_end( ap );
 384     (void)fflush( dbf );
 385     }
 386
 387   check_log_size();
 388
 389   errno = old_errno;
 390
 391   return( 0 );
 392   } /* Debug1 */
 393
 394
 395 /* ************************************************************************** **
 396  * Print the buffer content via Debug1(), then reset the buffer.
 397  *
 398  *  Input:  none
 399  *  Output: none
 400  *
 401  * ************************************************************************** **
 402  */
 403 static void bufr_print( void )
 404   {
 405   format_bufr[format_pos] = '\0';
 406   (void)Debug1( "%s", format_bufr );
 407   format_pos = 0;
 408   } /* bufr_print */
 409
 410 /* ************************************************************************** **
 411  * Format the debug message text.
 412  *
 413  *  Input:  msg - Text to be added to the "current" debug message text.
 414  *
 415  *  Output: none.
 416  *
 417  *  Notes:  The purpose of this is two-fold.  First, each call to syslog()
 418  *          (used by Debug1(), see above) generates a new line of syslog
 419  *          output.  This is fixed by storing the partial lines until the
 420  *          newline character is encountered.  Second, printing the debug
 421  *          message lines when a newline is encountered allows us to add
 422  *          spaces, thus indenting the body of the message and making it
 423  *          more readable.
 424  *
 425  * ************************************************************************** **
 426  */
 427 static void format_debug_text( char *msg )
 428   {
 429   int i;
 430   BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() ||
 431                                         !(lp_loaded())));
 432
 433   for( i = 0; msg[i]; i++ )
 434     {
 435     /* Indent two spaces at each new line. */
 436     if(timestamp && 0 == format_pos)
 437       {
 438       format_bufr[0] = format_bufr[1] = ' ';
 439       format_pos = 2;
 440       }
 441
 442     /* If there's room, copy the character to the format buffer. */
 443     if( format_pos < FORMAT_BUFR_MAX )
 444       format_bufr[format_pos++] = msg[i];
 445
 446     /* If a newline is encountered, print & restart. */
 447     if( '\n' == msg[i] )
 448       bufr_print();
 449
 450     /* If the buffer is full dump it out, reset it, and put out a line
 451      * continuation indicator.
 452      */
 453     if( format_pos >= FORMAT_BUFR_MAX )
 454       {
 455       bufr_print();
 456       (void)Debug1( " +>\n" );
 457       }
 458     }
 459
 460   /* Just to be safe... */
 461   format_bufr[format_pos] = '\0';
 462   } /* format_debug_text */
 463
 464 /* ************************************************************************** **
 465  * Flush debug output, including the format buffer content.
 466  *
 467  *  Input:  none
 468  *  Output: none
 469  *
 470  * ************************************************************************** **
 471  */
 472 void dbgflush( void )
 473   {
 474   bufr_print();
 475   (void)fflush( dbf );
 476   } /* dbgflush */
 477
 478 /* ************************************************************************** **
 479  * Print a Debug Header.
 480  *
 481  *  Input:  level - Debug level of the message (not the system-wide debug
 482  *                  level.
 483  *          file  - Pointer to a string containing the name of the file
 484  *                  from which this function was called, or an empty string
 485  *                  if the __FILE__ macro is not implemented.
 486  *          func  - Pointer to a string containing the name of the function
 487  *                  from which this function was called, or an empty string
 488  *                  if the __FUNCTION__ macro is not implemented.
 489  *          line  - line number of the call to dbghdr, assuming __LINE__
 490  *                  works.
 491  *
 492  *  Output: Always True.  This makes it easy to fudge a call to dbghdr()
 493  *          in a macro, since the function can be called as part of a test.
 494  *          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 495  *
 496  *  Notes:  This function takes care of setting syslog_level.
 497  *
 498  * ************************************************************************** **
 499  */
 500 BOOL dbghdr( int level, char *file, char *func, int line )
 501   {
 502   if( format_pos )
 503     {
 504     /* This is a fudge.  If there is stuff sitting in the format_bufr, then
 505      * the *right* thing to do is to call
 506      *   format_debug_text( "\n" );
 507      * to write the remainder, and then proceed with the new header.
 508      * Unfortunately, there are several places in the code at which
 509      * the DEBUG() macro is used to build partial lines.  That in mind,
 510      * we'll work under the assumption that an incomplete line indicates
 511      * that a new header is *not* desired.
 512      */
 513     return( True );
 514     }
 515
 516   /* Set syslog_level. */
 517   syslog_level = level;
 518
 519   /* Don't print a header if we're logging to stdout. */
 520   if( stdout_logging )
 521     return( True );
 522
 523   /* Print the header if timestamps are turned on.  If parameters are
 524    * not yet loaded, then default to timestamps on.
 525    */
 526   if( lp_timestamp_logs() || !(lp_loaded()) )
 527     {
 528     /* Print it all out at once to prevent split syslog output. */
 529     (void)Debug1( "[%s, %d] %s:%s(%d)\n",
 530                   timestring(), level, file, func, line );
 531     }
 532
 533   return( True );
 534   } /* dbghdr */
 535
 536 /* ************************************************************************** **
 537  * Add text to the body of the "current" debug message via the format buffer.
 538  *
 539  *  Input:  format_str  - Format string, as used in printf(), et. al.
 540  *          ...         - Variable argument list.
 541  *
 542  *  ..or..  va_alist    - Old style variable parameter list starting point.
 543  *
 544  *  Output: Always True.  See dbghdr() for more info, though this is not
 545  *          likely to be used in the same way.
 546  *
 547  * ************************************************************************** **
 548  */
 549 #ifdef HAVE_STDARG_H
 550  BOOL dbgtext( char *format_str, ... )
 551   {
 552   va_list ap;
 553   pstring msgbuf;
 554
 555   va_start( ap, format_str );
 556   vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 557   va_end( ap );
 558
 559   format_debug_text( msgbuf );
 560
 561   return( True );
 562   } /* dbgtext */
 563
 564 #else
 565  BOOL dbgtext( va_alist )
 566  va_dcl
 567   {
 568   char *format_str;
 569   va_list ap;
 570   pstring msgbuf;
 571
 572   va_start( ap );
 573   format_str = va_arg( ap, char * );
 574   vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 575   va_end( ap );
 576
 577   format_debug_text( msgbuf );
 578
 579   return( True );
 580   } /* dbgtext */
 581
 582 #endif
 583
 584 /* ************************************************************************** */