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