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