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