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