source3/lib/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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 /* -------------------------------------------------------------------------- **
  26  * Defines...
  27  *
  28  *  FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
  29  *                    format_bufr[FORMAT_BUFR_MAX] should always be reserved
  30  *                    for a terminating null byte.
  31  */
  32
  33 #define FORMAT_BUFR_MAX ( sizeof( format_bufr ) - 1 )
  34
  35 /* -------------------------------------------------------------------------- **
  36  * This module implements Samba's debugging utility.
  37  *
  38  * The syntax of a debugging log file is represented as:
  39  *
  40  *  <debugfile> :== { <debugmsg> }
  41  *
  42  *  <debugmsg>  :== <debughdr> '\n' <debugtext>
  43  *
  44  *  <debughdr>  :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
  45  *
  46  *  <debugtext> :== { <debugline> }
  47  *
  48  *  <debugline> :== TEXT '\n'
  49  *
  50  * TEXT     is a string of characters excluding the newline character.
  51  * LEVEL    is the DEBUG level of the message (an integer in the range 0..10).
  52  * TIME     is a timestamp.
  53  * FILENAME is the name of the file from which the debug message was generated.
  54  * FUNCTION is the function from which the debug message was generated.
  55  *
  56  * Basically, what that all means is:
  57  *
  58  * - A debugging log file is made up of debug messages.
  59  *
  60  * - Each debug message is made up of a header and text.  The header is
  61  *   separated from the text by a newline.
  62  *
  63  * - The header begins with the timestamp and debug level of the message
  64  *   enclosed in brackets.  The filename and function from which the
  65  *   message was generated may follow.  The filename is terminated by a
  66  *   colon, and the function name is terminated by parenthesis.
  67  *
  68  * - The message text is made up of zero or more lines, each terminated by
  69  *   a newline.
  70  */
  71
  72 /* -------------------------------------------------------------------------- **
  73  * External variables.
  74  *
  75  *  dbf           - Global debug file handle.
  76  *  debugf        - Debug file name.
  77  *  DEBUGLEVEL    - System-wide debug message limit.  Messages with message-
  78  *                  levels higher than DEBUGLEVEL will not be processed.
  79  */
  80
  81 XFILE   *dbf        = NULL;
  82 pstring debugf     = "";
  83 BOOL    debug_warn_unknown_class = True;
  84 BOOL    debug_auto_add_unknown_class = True;
  85 BOOL    AllowDebugChange = True;
  86
  87 /*
  88    used to check if the user specified a
  89    logfile on the command line
  90 */
  91 BOOL    override_logfile;
  92
  93
  94 /*
  95  * This is to allow assignment to DEBUGLEVEL before the debug
  96  * system has been initialised.
  97  */
  98 static int debug_all_class_hack = 1;
  99 static BOOL debug_all_class_isset_hack = True;
 100
 101 static int debug_num_classes = 0;
 102 int     *DEBUGLEVEL_CLASS = &debug_all_class_hack;
 103 BOOL    *DEBUGLEVEL_CLASS_ISSET = &debug_all_class_isset_hack;
 104
 105 /* DEBUGLEVEL is #defined to *debug_level */
 106 int     DEBUGLEVEL = &debug_all_class_hack;
 107
 108
 109 /* -------------------------------------------------------------------------- **
 110  * Internal variables.
 111  *
 112  *  stdout_logging  - Default False, if set to True then dbf will be set to
 113  *                    stdout and debug output will go to dbf only, and not
 114  *                    to syslog.  Set in setup_logging() and read in Debug1().
 115  *
 116  *  debug_count     - Number of debug messages that have been output.
 117  *                    Used to check log size.
 118  *
 119  *  syslog_level    - Internal copy of the message debug level.  Written by
 120  *                    dbghdr() and read by Debug1().
 121  *
 122  *  format_bufr     - Used to format debug messages.  The dbgtext() function
 123  *                    prints debug messages to a string, and then passes the
 124  *                    string to format_debug_text(), which uses format_bufr
 125  *                    to build the formatted output.
 126  *
 127  *  format_pos      - Marks the first free byte of the format_bufr.
 128  *
 129  *
 130  *  log_overflow    - When this variable is True, never attempt to check the
 131  *                    size of the log. This is a hack, so that we can write
 132  *                    a message using DEBUG, from open_logs() when we
 133  *                    are unable to open a new log file for some reason.
 134  */
 135
 136 static BOOL    stdout_logging = False;
 137 static int     debug_count    = 0;
 138 #ifdef WITH_SYSLOG
 139 static int     syslog_level   = 0;
 140 #endif
 141 static pstring format_bufr    = { '\0' };
 142 static size_t     format_pos     = 0;
 143 static BOOL    log_overflow   = False;
 144
 145 /*
 146  * Define all the debug class selection names here. Names *MUST NOT* contain
 147  * white space. There must be one name for each DBGC_<class name>, and they
 148  * must be in the table in the order of DBGC_<class name>..
 149  */
 150 static const char *default_classname_table[] = {
 151         "all",               /* DBGC_ALL; index refs traditional DEBUGLEVEL */
 152         "tdb",               /* DBGC_TDB          */
 153         "printdrivers",      /* DBGC_PRINTDRIVERS */
 154         "lanman",            /* DBGC_LANMAN       */
 155         "smb",               /* DBGC_SMB          */
 156         "rpc_parse",         /* DBGC_RPC_PARSE    */
 157         "rpc_srv",           /* DBGC_RPC_SRV      */
 158         "rpc_cli",           /* DBGC_RPC_CLI      */
 159         "passdb",            /* DBGC_PASSDB       */
 160         "sam",               /* DBGC_SAM          */
 161         "auth",              /* DBGC_AUTH         */
 162         "winbind",           /* DBGC_WINBIND      */
 163         "vfs",               /* DBGC_VFS          */
 164         "idmap",             /* DBGC_IDMAP        */
 165         "quota",             /* DBGC_QUOTA        */
 166         "acls",              /* DBGC_ACLS         */
 167         "locking",           /* DBGC_LOCKING      */
 168         "msdfs",             /* DBGC_MSDFS        */
 169         "dmapi",             /* DBGC_DMAPI        */
 170         NULL
 171 };
 172
 173 static char **classname_table = NULL;
 174
 175
 176 /* -------------------------------------------------------------------------- **
 177  * Functions...
 178  */
 179
 180 /***************************************************************************
 181  Free memory pointed to by global pointers.
 182 ****************************************************************************/
 183
 184 void gfree_debugsyms(void)
 185 {
 186         int i;
 187
 188         if ( classname_table ) {
 189                 for ( i = 0; i < debug_num_classes; i++ ) {
 190                         SAFE_FREE( classname_table[i] );
 191                 }
 192                 SAFE_FREE( classname_table );
 193         }
 194
 195         if ( DEBUGLEVEL_CLASS != &debug_all_class_hack )
 196                 SAFE_FREE( DEBUGLEVEL_CLASS );
 197
 198         if ( DEBUGLEVEL_CLASS_ISSET != &debug_all_class_isset_hack )
 199                 SAFE_FREE( DEBUGLEVEL_CLASS_ISSET );
 200 }
 201
 202 /****************************************************************************
 203 utility lists registered debug class names's
 204 ****************************************************************************/
 205
 206 #define MAX_CLASS_NAME_SIZE 1024
 207
 208 static char *debug_list_class_names_and_levels(void)
 209 {
 210         int i, dim;
 211         char **list;
 212         char *buf = NULL;
 213         char *b;
 214         BOOL err = False;
 215
 216         if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
 217                 return NULL;
 218         }
 219
 220         list = SMB_CALLOC_ARRAY(char *, debug_num_classes + 1);
 221         if (!list) {
 222                 return NULL;
 223         }
 224
 225         /* prepare strings */
 226         for (i = 0, dim = 0; i < debug_num_classes; i++) {
 227                 int l = asprintf(&list[i],
 228                                 "%s:%d ",
 229                                 classname_table[i],
 230                                 DEBUGLEVEL_CLASS_ISSET[i]?DEBUGLEVEL_CLASS[i]:DEBUGLEVEL);
 231                 if (l < 0 || l > MAX_CLASS_NAME_SIZE) {
 232                         err = True;
 233                         goto done;
 234                 }
 235                 dim += l;
 236         }
 237
 238         /* create single string list - add space for newline */
 239         b = buf = SMB_MALLOC(dim+1);
 240         if (!buf) {
 241                 err = True;
 242                 goto done;
 243         }
 244         for (i = 0; i < debug_num_classes; i++) {
 245                 int l = strlen(list[i]);
 246                 strncpy(b, list[i], l);
 247                 b = b + l;
 248         }
 249         b[-1] = '\n'; /* replace last space with newline */
 250         b[0] = '\0';  /* null terminate string */
 251
 252 done:
 253         /* free strings list */
 254         for (i = 0; i < debug_num_classes; i++) {
 255                 SAFE_FREE(list[i]);
 256         }
 257         SAFE_FREE(list);
 258
 259         if (err) {
 260                 return NULL;
 261         } else {
 262                 return buf;
 263         }
 264 }
 265
 266 /****************************************************************************
 267  Utility access to debug class names's.
 268 ****************************************************************************/
 269
 270 const char *debug_classname_from_index(int ndx)
 271 {
 272         if (ndx < 0 || ndx >= debug_num_classes)
 273                 return NULL;
 274         else
 275                 return classname_table[ndx];
 276 }
 277
 278 /****************************************************************************
 279  Utility to translate names to debug class index's (internal version).
 280 ****************************************************************************/
 281
 282 static int debug_lookup_classname_int(const char* classname)
 283 {
 284         int i;
 285
 286         if (!classname) return -1;
 287
 288         for (i=0; i < debug_num_classes; i++) {
 289                 if (strcmp(classname, classname_table[i])==0)
 290                         return i;
 291         }
 292         return -1;
 293 }
 294
 295 /****************************************************************************
 296  Add a new debug class to the system.
 297 ****************************************************************************/
 298
 299 int debug_add_class(const char *classname)
 300 {
 301         int ndx;
 302         void *new_ptr;
 303
 304         if (!classname)
 305                 return -1;
 306
 307         /* check the init has yet been called */
 308         debug_init();
 309
 310         ndx = debug_lookup_classname_int(classname);
 311         if (ndx >= 0)
 312                 return ndx;
 313         ndx = debug_num_classes;
 314
 315         new_ptr = DEBUGLEVEL_CLASS;
 316         if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
 317                 /* Initial loading... */
 318                 new_ptr = NULL;
 319         }
 320         new_ptr = SMB_REALLOC_ARRAY(new_ptr, int, debug_num_classes + 1);
 321         if (!new_ptr)
 322                 return -1;
 323         DEBUGLEVEL_CLASS = new_ptr;
 324         DEBUGLEVEL_CLASS[ndx] = 0;
 325
 326         /* debug_level is the pointer used for the DEBUGLEVEL-thingy */
 327         if (ndx==0) {
 328                 /* Transfer the initial level from debug_all_class_hack */
 329                 DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL;
 330         }
 331         debug_level = DEBUGLEVEL_CLASS;
 332
 333         new_ptr = DEBUGLEVEL_CLASS_ISSET;
 334         if (new_ptr == &debug_all_class_isset_hack) {
 335                 new_ptr = NULL;
 336         }
 337         new_ptr = SMB_REALLOC_ARRAY(new_ptr, BOOL, debug_num_classes + 1);
 338         if (!new_ptr)
 339                 return -1;
 340         DEBUGLEVEL_CLASS_ISSET = new_ptr;
 341         DEBUGLEVEL_CLASS_ISSET[ndx] = False;
 342
 343         new_ptr = SMB_REALLOC_ARRAY(classname_table, char *, debug_num_classes + 1);
 344         if (!new_ptr)
 345                 return -1;
 346         classname_table = new_ptr;
 347
 348         classname_table[ndx] = SMB_STRDUP(classname);
 349         if (! classname_table[ndx])
 350                 return -1;
 351
 352         debug_num_classes++;
 353
 354         return ndx;
 355 }
 356
 357 /****************************************************************************
 358  Utility to translate names to debug class index's (public version).
 359 ****************************************************************************/
 360
 361 int debug_lookup_classname(const char *classname)
 362 {
 363         int ndx;
 364
 365         if (!classname || !*classname)
 366                 return -1;
 367
 368         ndx = debug_lookup_classname_int(classname);
 369
 370         if (ndx != -1)
 371                 return ndx;
 372
 373         if (debug_warn_unknown_class) {
 374                 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
 375                           classname));
 376         }
 377         if (debug_auto_add_unknown_class) {
 378                 return debug_add_class(classname);
 379         }
 380         return -1;
 381 }
 382
 383 /****************************************************************************
 384  Dump the current registered debug levels.
 385 ****************************************************************************/
 386
 387 static void debug_dump_status(int level)
 388 {
 389         int q;
 390
 391         DEBUG(level, ("INFO: Current debug levels:\n"));
 392         for (q = 0; q < debug_num_classes; q++) {
 393                 DEBUGADD(level, ("  %s: %s/%d\n",
 394                                  classname_table[q],
 395                                  (DEBUGLEVEL_CLASS_ISSET[q]
 396                                   ? "True" : "False"),
 397                                  DEBUGLEVEL_CLASS[q]));
 398         }
 399 }
 400
 401 /****************************************************************************
 402  parse the debug levels from smbcontrol. Example debug level parameter:
 403  printdrivers:7
 404 ****************************************************************************/
 405
 406 static BOOL debug_parse_params(char **params)
 407 {
 408         int   i, ndx;
 409         char *class_name;
 410         char *class_level;
 411
 412         if (!params)
 413                 return False;
 414
 415         /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
 416          * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
 417          */
 418         if (isdigit((int)params[0][0])) {
 419                 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
 420                 DEBUGLEVEL_CLASS_ISSET[DBGC_ALL] = True;
 421                 i = 1; /* start processing at the next params */
 422         } else {
 423                 i = 0; /* DBGC_ALL not specified OR class name was included */
 424         }
 425
 426         /* Fill in new debug class levels */
 427         for (; i < debug_num_classes && params[i]; i++) {
 428                 if ((class_name=strtok(params[i],":")) &&
 429                         (class_level=strtok(NULL, "\0")) &&
 430             ((ndx = debug_lookup_classname(class_name)) != -1)) {
 431                                 DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
 432                                 DEBUGLEVEL_CLASS_ISSET[ndx] = True;
 433                 } else {
 434                         DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
 435                         return False;
 436                 }
 437         }
 438
 439         return True;
 440 }
 441
 442 /****************************************************************************
 443  Parse the debug levels from smb.conf. Example debug level string:
 444   3 tdb:5 printdrivers:7
 445  Note: the 1st param has no "name:" preceeding it.
 446 ****************************************************************************/
 447
 448 BOOL debug_parse_levels(const char *params_str)
 449 {
 450         char **params;
 451
 452         /* Just in case */
 453         debug_init();
 454
 455         if (AllowDebugChange == False)
 456                 return True;
 457
 458         params = str_list_make(params_str, NULL);
 459
 460         if (debug_parse_params(params)) {
 461                 debug_dump_status(5);
 462                 str_list_free(&params);
 463                 return True;
 464         } else {
 465                 str_list_free(&params);
 466                 return False;
 467         }
 468 }
 469
 470 /****************************************************************************
 471  Receive a "set debug level" message.
 472 ****************************************************************************/
 473
 474 static void debug_message(int msg_type, struct process_id src,
 475                           void *buf, size_t len)
 476 {
 477         const char *params_str = buf;
 478
 479         /* Check, it's a proper string! */
 480         if (params_str[len-1] != '\0') {
 481                 DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
 482                           (unsigned int)procid_to_pid(&src),
 483                           (unsigned int)getpid()));
 484                 return;
 485         }
 486
 487         DEBUG(3, ("INFO: Remote set of debug to `%s'  (pid %u from pid %u)\n",
 488                   params_str, (unsigned int)getpid(),
 489                   (unsigned int)procid_to_pid(&src)));
 490
 491         debug_parse_levels(params_str);
 492 }
 493
 494 /****************************************************************************
 495  Send a "set debug level" message.
 496 ****************************************************************************/
 497
 498 void debug_message_send(pid_t pid, const char *params_str)
 499 {
 500         if (!params_str)
 501                 return;
 502         message_send_pid(pid_to_procid(pid), MSG_DEBUG,
 503                          params_str, strlen(params_str) + 1,
 504                          False);
 505 }
 506
 507 /****************************************************************************
 508  Return current debug level.
 509 ****************************************************************************/
 510
 511 static void debuglevel_message(int msg_type, struct process_id src,
 512                                void *buf, size_t len)
 513 {
 514         char *message = debug_list_class_names_and_levels();
 515
 516         DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %u\n",
 517                  (unsigned int)procid_to_pid(&src)));
 518         message_send_pid(src, MSG_DEBUGLEVEL, message, strlen(message) + 1, True);
 519
 520         SAFE_FREE(message);
 521 }
 522
 523 /****************************************************************************
 524 Init debugging (one time stuff)
 525 ****************************************************************************/
 526
 527 void debug_init(void)
 528 {
 529         static BOOL initialised = False;
 530         const char **p;
 531
 532         if (initialised)
 533                 return;
 534
 535         initialised = True;
 536
 537         message_register(MSG_DEBUG, debug_message);
 538         message_register(MSG_REQ_DEBUGLEVEL, debuglevel_message);
 539
 540         for(p = default_classname_table; *p; p++) {
 541                 debug_add_class(*p);
 542         }
 543 }
 544
 545 /***************************************************************************
 546  Get ready for syslog stuff
 547 **************************************************************************/
 548
 549 void setup_logging(const char *pname, BOOL interactive)
 550 {
 551         debug_init();
 552
 553         /* reset to allow multiple setup calls, going from interactive to
 554            non-interactive */
 555         stdout_logging = False;
 556         if (dbf) {
 557                 x_fflush(dbf);
 558                 (void) x_fclose(dbf);
 559         }
 560
 561         dbf = NULL;
 562
 563         if (interactive) {
 564                 stdout_logging = True;
 565                 dbf = x_stdout;
 566                 x_setbuf( x_stdout, NULL );
 567         }
 568 #ifdef WITH_SYSLOG
 569         else {
 570                 const char *p = strrchr_m( pname,'/' );
 571                 if (p)
 572                         pname = p + 1;
 573 #ifdef LOG_DAEMON
 574                 openlog( pname, LOG_PID, SYSLOG_FACILITY );
 575 #else
 576                 /* for old systems that have no facility codes. */
 577                 openlog( pname, LOG_PID );
 578 #endif
 579         }
 580 #endif
 581 }
 582
 583 /**************************************************************************
 584  reopen the log files
 585  note that we now do this unconditionally
 586  We attempt to open the new debug fp before closing the old. This means
 587  if we run out of fd's we just keep using the old fd rather than aborting.
 588  Fix from dgibson@linuxcare.com.
 589 **************************************************************************/
 590
 591 BOOL reopen_logs( void )
 592 {
 593         pstring fname;
 594         mode_t oldumask;
 595         XFILE *new_dbf = NULL;
 596         XFILE *old_dbf = NULL;
 597         BOOL ret = True;
 598
 599         if (stdout_logging)
 600                 return True;
 601
 602         oldumask = umask( 022 );
 603
 604         pstrcpy(fname, debugf );
 605         debugf[0] = '\0';
 606
 607         if (lp_loaded()) {
 608                 char *logfname;
 609
 610                 logfname = lp_logfile();
 611                 if (*logfname)
 612                         pstrcpy(fname, logfname);
 613         }
 614
 615         pstrcpy( debugf, fname );
 616         new_dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
 617
 618         if (!new_dbf) {
 619                 log_overflow = True;
 620                 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
 621                 log_overflow = False;
 622                 if (dbf)
 623                         x_fflush(dbf);
 624                 ret = False;
 625         } else {
 626                 x_setbuf(new_dbf, NULL);
 627                 old_dbf = dbf;
 628                 dbf = new_dbf;
 629                 if (old_dbf)
 630                         (void) x_fclose(old_dbf);
 631         }
 632
 633         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
 634          * to fix problem where smbd's that generate less
 635          * than 100 messages keep growing the log.
 636          */
 637         force_check_log_size();
 638         (void)umask(oldumask);
 639
 640         /* Take over stderr to catch ouput into logs */
 641         if (dbf && sys_dup2(x_fileno(dbf), 2) == -1) {
 642                 close_low_fds(True); /* Close stderr too, if dup2 can't point it
 643                                         at the logfile */
 644         }
 645
 646         return ret;
 647 }
 648
 649 /**************************************************************************
 650  Force a check of the log size.
 651  ***************************************************************************/
 652
 653 void force_check_log_size( void )
 654 {
 655         debug_count = 100;
 656 }
 657
 658 /***************************************************************************
 659  Check to see if there is any need to check if the logfile has grown too big.
 660 **************************************************************************/
 661
 662 BOOL need_to_check_log_size( void )
 663 {
 664         int maxlog;
 665
 666         if( debug_count < 100 )
 667                 return( False );
 668
 669         maxlog = lp_max_log_size() * 1024;
 670         if( !dbf || maxlog <= 0 ) {
 671                 debug_count = 0;
 672                 return(False);
 673         }
 674         return( True );
 675 }
 676
 677 /**************************************************************************
 678  Check to see if the log has grown to be too big.
 679  **************************************************************************/
 680
 681 void check_log_size( void )
 682 {
 683         int         maxlog;
 684         SMB_STRUCT_STAT st;
 685
 686         /*
 687          *  We need to be root to check/change log-file, skip this and let the main
 688          *  loop check do a new check as root.
 689          */
 690
 691         if( geteuid() != 0 )
 692                 return;
 693
 694         if(log_overflow || !need_to_check_log_size() )
 695                 return;
 696
 697         maxlog = lp_max_log_size() * 1024;
 698
 699         if( sys_fstat( x_fileno( dbf ), &st ) == 0 && st.st_size > maxlog ) {
 700                 (void)reopen_logs();
 701                 if( dbf && get_file_size( debugf ) > maxlog ) {
 702                         pstring name;
 703
 704                         slprintf( name, sizeof(name)-1, "%s.old", debugf );
 705                         (void)rename( debugf, name );
 706
 707                         if (!reopen_logs()) {
 708                                 /* We failed to reopen a log - continue using the old name. */
 709                                 (void)rename(name, debugf);
 710                         }
 711                 }
 712         }
 713
 714         /*
 715          * Here's where we need to panic if dbf == NULL..
 716          */
 717
 718         if(dbf == NULL) {
 719                 /* This code should only be reached in very strange
 720                  * circumstances. If we merely fail to open the new log we
 721                  * should stick with the old one. ergo this should only be
 722                  * reached when opening the logs for the first time: at
 723                  * startup or when the log level is increased from zero.
 724                  * -dwg 6 June 2000
 725                  */
 726                 dbf = x_fopen( "/dev/console", O_WRONLY, 0);
 727                 if(dbf) {
 728                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
 729                                         debugf ));
 730                 } else {
 731                         /*
 732                          * We cannot continue without a debug file handle.
 733                          */
 734                         abort();
 735                 }
 736         }
 737         debug_count = 0;
 738 }
 739
 740 /*************************************************************************
 741  Write an debug message on the debugfile.
 742  This is called by dbghdr() and format_debug_text().
 743 ************************************************************************/
 744
 745  int Debug1( const char *format_str, ... )
 746 {
 747         va_list ap;
 748         int old_errno = errno;
 749
 750         debug_count++;
 751
 752         if( stdout_logging ) {
 753                 va_start( ap, format_str );
 754                 if(dbf)
 755                         (void)x_vfprintf( dbf, format_str, ap );
 756                 va_end( ap );
 757                 errno = old_errno;
 758                 return( 0 );
 759         }
 760
 761         /* prevent recursion by checking if reopen_logs() has temporaily
 762            set the debugf string to "" */
 763         if( debugf[0] == '\0')
 764                 return( 0 );
 765
 766 #ifdef WITH_SYSLOG
 767         if( !lp_syslog_only() )
 768 #endif
 769         {
 770                 if( !dbf ) {
 771                         mode_t oldumask = umask( 022 );
 772
 773                         dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
 774                         (void)umask( oldumask );
 775                         if( dbf ) {
 776                                 x_setbuf( dbf, NULL );
 777                         } else {
 778                                 errno = old_errno;
 779                                 return(0);
 780                         }
 781                 }
 782         }
 783
 784 #ifdef WITH_SYSLOG
 785         if( syslog_level < lp_syslog() ) {
 786                 /* map debug levels to syslog() priorities
 787                  * note that not all DEBUG(0, ...) calls are
 788                  * necessarily errors */
 789                 static int priority_map[] = {
 790                         LOG_ERR,     /* 0 */
 791                         LOG_WARNING, /* 1 */
 792                         LOG_NOTICE,  /* 2 */
 793                         LOG_INFO,    /* 3 */
 794                 };
 795                 int     priority;
 796                 pstring msgbuf;
 797
 798                 if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) ) || syslog_level < 0)
 799                         priority = LOG_DEBUG;
 800                 else
 801                         priority = priority_map[syslog_level];
 802
 803                 va_start( ap, format_str );
 804                 vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 805                 va_end( ap );
 806
 807                 msgbuf[255] = '\0';
 808                 syslog( priority, "%s", msgbuf );
 809         }
 810 #endif
 811
 812         check_log_size();
 813
 814 #ifdef WITH_SYSLOG
 815         if( !lp_syslog_only() )
 816 #endif
 817         {
 818                 va_start( ap, format_str );
 819                 if(dbf)
 820                         (void)x_vfprintf( dbf, format_str, ap );
 821                 va_end( ap );
 822                 if(dbf)
 823                         (void)x_fflush( dbf );
 824         }
 825
 826         errno = old_errno;
 827
 828         return( 0 );
 829 }
 830
 831
 832 /**************************************************************************
 833  Print the buffer content via Debug1(), then reset the buffer.
 834  Input:  none
 835  Output: none
 836 ****************************************************************************/
 837
 838 static void bufr_print( void )
 839 {
 840         format_bufr[format_pos] = '\0';
 841         (void)Debug1( "%s", format_bufr );
 842         format_pos = 0;
 843 }
 844
 845 /***************************************************************************
 846  Format the debug message text.
 847
 848  Input:  msg - Text to be added to the "current" debug message text.
 849
 850  Output: none.
 851
 852  Notes:  The purpose of this is two-fold.  First, each call to syslog()
 853          (used by Debug1(), see above) generates a new line of syslog
 854          output.  This is fixed by storing the partial lines until the
 855          newline character is encountered.  Second, printing the debug
 856          message lines when a newline is encountered allows us to add
 857          spaces, thus indenting the body of the message and making it
 858          more readable.
 859 **************************************************************************/
 860
 861 static void format_debug_text( const char *msg )
 862 {
 863         size_t i;
 864         BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() || !(lp_loaded())));
 865
 866         for( i = 0; msg[i]; i++ ) {
 867                 /* Indent two spaces at each new line. */
 868                 if(timestamp && 0 == format_pos) {
 869                         format_bufr[0] = format_bufr[1] = ' ';
 870                         format_pos = 2;
 871                 }
 872
 873                 /* If there's room, copy the character to the format buffer. */
 874                 if( format_pos < FORMAT_BUFR_MAX )
 875                         format_bufr[format_pos++] = msg[i];
 876
 877                 /* If a newline is encountered, print & restart. */
 878                 if( '\n' == msg[i] )
 879                         bufr_print();
 880
 881                 /* If the buffer is full dump it out, reset it, and put out a line
 882                  * continuation indicator.
 883                  */
 884                 if( format_pos >= FORMAT_BUFR_MAX ) {
 885                         bufr_print();
 886                         (void)Debug1( " +>\n" );
 887                 }
 888         }
 889
 890         /* Just to be safe... */
 891         format_bufr[format_pos] = '\0';
 892 }
 893
 894 /***************************************************************************
 895  Flush debug output, including the format buffer content.
 896
 897  Input:  none
 898  Output: none
 899 ***************************************************************************/
 900
 901 void dbgflush( void )
 902 {
 903         bufr_print();
 904         if(dbf)
 905                 (void)x_fflush( dbf );
 906 }
 907
 908 /***************************************************************************
 909  Print a Debug Header.
 910
 911  Input:  level - Debug level of the message (not the system-wide debug
 912                   level. )
 913           file  - Pointer to a string containing the name of the file
 914                   from which this function was called, or an empty string
 915                   if the __FILE__ macro is not implemented.
 916           func  - Pointer to a string containing the name of the function
 917                   from which this function was called, or an empty string
 918                   if the __FUNCTION__ macro is not implemented.
 919          line  - line number of the call to dbghdr, assuming __LINE__
 920                  works.
 921
 922   Output: Always True.  This makes it easy to fudge a call to dbghdr()
 923           in a macro, since the function can be called as part of a test.
 924           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 925
 926   Notes:  This function takes care of setting syslog_level.
 927
 928 ****************************************************************************/
 929
 930 BOOL dbghdr( int level, const char *file, const char *func, int line )
 931 {
 932         /* Ensure we don't lose any real errno value. */
 933         int old_errno = errno;
 934
 935         if( format_pos ) {
 936                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
 937                  * the *right* thing to do is to call
 938                  *   format_debug_text( "\n" );
 939                  * to write the remainder, and then proceed with the new header.
 940                  * Unfortunately, there are several places in the code at which
 941                  * the DEBUG() macro is used to build partial lines.  That in mind,
 942                  * we'll work under the assumption that an incomplete line indicates
 943                  * that a new header is *not* desired.
 944                  */
 945                 return( True );
 946         }
 947
 948 #ifdef WITH_SYSLOG
 949         /* Set syslog_level. */
 950         syslog_level = level;
 951 #endif
 952
 953         /* Don't print a header if we're logging to stdout. */
 954         if( stdout_logging )
 955                 return( True );
 956
 957         /* Print the header if timestamps are turned on.  If parameters are
 958          * not yet loaded, then default to timestamps on.
 959          */
 960         if( lp_timestamp_logs() || !(lp_loaded()) ) {
 961                 char header_str[200];
 962
 963                 header_str[0] = '\0';
 964
 965                 if( lp_debug_pid())
 966                         slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
 967
 968                 if( lp_debug_uid()) {
 969                         size_t hs_len = strlen(header_str);
 970                         slprintf(header_str + hs_len,
 971                         sizeof(header_str) - 1 - hs_len,
 972                                 ", effective(%u, %u), real(%u, %u)",
 973                                 (unsigned int)geteuid(), (unsigned int)getegid(),
 974                                 (unsigned int)getuid(), (unsigned int)getgid());
 975                 }
 976
 977                 /* Print it all out at once to prevent split syslog output. */
 978                 (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
 979                         timestring(lp_debug_hires_timestamp()), level,
 980                         header_str, file, func, line );
 981         }
 982
 983         errno = old_errno;
 984         return( True );
 985 }
 986
 987 /***************************************************************************
 988  Add text to the body of the "current" debug message via the format buffer.
 989
 990   Input:  format_str  - Format string, as used in printf(), et. al.
 991           ...         - Variable argument list.
 992
 993   ..or..  va_alist    - Old style variable parameter list starting point.
 994
 995   Output: Always True.  See dbghdr() for more info, though this is not
 996           likely to be used in the same way.
 997
 998 ***************************************************************************/
 999
1000  BOOL dbgtext( const char *format_str, ... )
1001 {
1002         va_list ap;
1003         pstring msgbuf;
1004
1005         va_start( ap, format_str );
1006         vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
1007         va_end( ap );
1008
1009         format_debug_text( msgbuf );
1010
1011   return( True );
1012 }