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