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         for( i = 0; msg[i]; i++ ) {
 898                 /* Indent two spaces at each new line. */
 899                 if(timestamp && 0 == format_pos) {
 900                         format_bufr[0] = format_bufr[1] = ' ';
 901                         format_pos = 2;
 902                 }
 903
 904                 /* If there's room, copy the character to the format buffer. */
 905                 if( format_pos < FORMAT_BUFR_MAX )
 906                         format_bufr[format_pos++] = msg[i];
 907
 908                 /* If a newline is encountered, print & restart. */
 909                 if( '\n' == msg[i] )
 910                         bufr_print();
 911
 912                 /* If the buffer is full dump it out, reset it, and put out a line
 913                  * continuation indicator.
 914                  */
 915                 if( format_pos >= FORMAT_BUFR_MAX ) {
 916                         bufr_print();
 917                         (void)Debug1( " +>\n" );
 918                 }
 919         }
 920
 921         /* Just to be safe... */
 922         format_bufr[format_pos] = '\0';
 923 }
 924
 925 /***************************************************************************
 926  Flush debug output, including the format buffer content.
 927
 928  Input:  none
 929  Output: none
 930 ***************************************************************************/
 931
 932 void dbgflush( void )
 933 {
 934         bufr_print();
 935         if(dbf)
 936                 (void)x_fflush( dbf );
 937 }
 938
 939 /***************************************************************************
 940  Print a Debug Header.
 941
 942  Input:  level - Debug level of the message (not the system-wide debug
 943                   level. )
 944           cls   - Debuglevel class of the calling module.
 945           file  - Pointer to a string containing the name of the file
 946                   from which this function was called, or an empty string
 947                   if the __FILE__ macro is not implemented.
 948           func  - Pointer to a string containing the name of the function
 949                   from which this function was called, or an empty string
 950                   if the __FUNCTION__ macro is not implemented.
 951          line  - line number of the call to dbghdr, assuming __LINE__
 952                  works.
 953
 954   Output: Always True.  This makes it easy to fudge a call to dbghdr()
 955           in a macro, since the function can be called as part of a test.
 956           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 957
 958   Notes:  This function takes care of setting syslog_level.
 959
 960 ****************************************************************************/
 961
 962 bool dbghdr(int level, int cls, const char *file, const char *func, int line)
 963 {
 964         /* Ensure we don't lose any real errno value. */
 965         int old_errno = errno;
 966
 967         if( format_pos ) {
 968                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
 969                  * the *right* thing to do is to call
 970                  *   format_debug_text( "\n" );
 971                  * to write the remainder, and then proceed with the new header.
 972                  * Unfortunately, there are several places in the code at which
 973                  * the DEBUG() macro is used to build partial lines.  That in mind,
 974                  * we'll work under the assumption that an incomplete line indicates
 975                  * that a new header is *not* desired.
 976                  */
 977                 return( True );
 978         }
 979
 980 #ifdef WITH_SYSLOG
 981         /* Set syslog_level. */
 982         syslog_level = level;
 983 #endif
 984
 985         /* Don't print a header if we're logging to stdout. */
 986         if( stdout_logging )
 987                 return( True );
 988
 989         /* Print the header if timestamps are turned on.  If parameters are
 990          * not yet loaded, then default to timestamps on.
 991          */
 992         if( lp_timestamp_logs() || lp_debug_prefix_timestamp() || !(lp_loaded()) ) {
 993                 char header_str[200];
 994
 995                 header_str[0] = '\0';
 996
 997                 if( lp_debug_pid())
 998                         slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
 999
1000                 if( lp_debug_uid()) {
1001                         size_t hs_len = strlen(header_str);
1002                         slprintf(header_str + hs_len,
1003                         sizeof(header_str) - 1 - hs_len,
1004                                 ", effective(%u, %u), real(%u, %u)",
1005                                 (unsigned int)geteuid(), (unsigned int)getegid(),
1006                                 (unsigned int)getuid(), (unsigned int)getgid());
1007                 }
1008
1009                 if (lp_debug_class() && (cls != DBGC_ALL)) {
1010                         size_t hs_len = strlen(header_str);
1011                         slprintf(header_str + hs_len,
1012                                  sizeof(header_str) -1 - hs_len,
1013                                  ", class=%s",
1014                                  default_classname_table[cls]);
1015                 }
1016
1017                 /* Print it all out at once to prevent split syslog output. */
1018                 if( lp_debug_prefix_timestamp() ) {
1019                     (void)Debug1( "[%s, %2d%s] ",
1020                         current_timestring(lp_debug_hires_timestamp()), level,
1021                         header_str);
1022                 } else {
1023                     (void)Debug1( "[%s, %2d%s] %s:%s(%d)\n",
1024                         current_timestring(lp_debug_hires_timestamp()), level,
1025                         header_str, file, func, line );
1026                 }
1027         }
1028
1029         errno = old_errno;
1030         return( True );
1031 }
1032
1033 /***************************************************************************
1034  Add text to the body of the "current" debug message via the format buffer.
1035
1036   Input:  format_str  - Format string, as used in printf(), et. al.
1037           ...         - Variable argument list.
1038
1039   ..or..  va_alist    - Old style variable parameter list starting point.
1040
1041   Output: Always True.  See dbghdr() for more info, though this is not
1042           likely to be used in the same way.
1043
1044 ***************************************************************************/
1045
1046  bool dbgtext( const char *format_str, ... )
1047 {
1048         va_list ap;
1049         char *msgbuf = NULL;
1050         bool ret = true;
1051
1052         va_start(ap, format_str);
1053         vasprintf(&msgbuf, format_str, ap);
1054         va_end(ap);
1055
1056         if (msgbuf) {
1057                 format_debug_text(msgbuf);
1058         } else {
1059                 ret = false;
1060         }
1061         SAFE_FREE(msgbuf);
1062         return ret;
1063 }