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_v3(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                 if (dbf != x_stdout) {
 582                         (void) x_fclose(dbf);
 583                 }
 584         }
 585
 586         dbf = NULL;
 587
 588         if (interactive) {
 589                 stdout_logging = True;
 590                 dbf = x_stdout;
 591                 x_setbuf( x_stdout, NULL );
 592         }
 593 #ifdef WITH_SYSLOG
 594         else {
 595                 const char *p = strrchr_m( pname,'/' );
 596                 if (p)
 597                         pname = p + 1;
 598 #ifdef LOG_DAEMON
 599                 openlog( pname, LOG_PID, SYSLOG_FACILITY );
 600 #else
 601                 /* for old systems that have no facility codes. */
 602                 openlog( pname, LOG_PID );
 603 #endif
 604         }
 605 #endif
 606 }
 607
 608 /**
 609    Just run logging to stdout for this program
 610 */
 611 _PUBLIC_ void setup_logging_stdout(void)
 612 {
 613         setup_logging(NULL, True);
 614 }
 615
 616
 617 /***************************************************************************
 618  Set the logfile name.
 619 **************************************************************************/
 620
 621 void debug_set_logfile(const char *name)
 622 {
 623         SAFE_FREE(debugf);
 624         debugf = SMB_STRDUP(name);
 625 }
 626
 627 /**************************************************************************
 628  reopen the log files
 629  note that we now do this unconditionally
 630  We attempt to open the new debug fp before closing the old. This means
 631  if we run out of fd's we just keep using the old fd rather than aborting.
 632  Fix from dgibson@linuxcare.com.
 633 **************************************************************************/
 634
 635 bool reopen_logs( void )
 636 {
 637         char *fname = NULL;
 638         mode_t oldumask;
 639         XFILE *new_dbf = NULL;
 640         XFILE *old_dbf = NULL;
 641         bool ret = True;
 642
 643         if (stdout_logging)
 644                 return True;
 645
 646         oldumask = umask( 022 );
 647
 648         fname = debugf;
 649         if (!fname) {
 650                 return false;
 651         }
 652         debugf = NULL;
 653
 654         if (lp_loaded()) {
 655                 char *logfname;
 656
 657                 logfname = lp_logfile();
 658                 if (*logfname) {
 659                         SAFE_FREE(fname);
 660                         fname = SMB_STRDUP(logfname);
 661                         if (!fname) {
 662                                 return false;
 663                         }
 664                 }
 665         }
 666
 667         debugf = fname;
 668         new_dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
 669
 670         if (!new_dbf) {
 671                 log_overflow = True;
 672                 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
 673                 log_overflow = False;
 674                 if (dbf)
 675                         x_fflush(dbf);
 676                 ret = False;
 677         } else {
 678                 x_setbuf(new_dbf, NULL);
 679                 old_dbf = dbf;
 680                 dbf = new_dbf;
 681                 if (old_dbf)
 682                         (void) x_fclose(old_dbf);
 683         }
 684
 685         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
 686          * to fix problem where smbd's that generate less
 687          * than 100 messages keep growing the log.
 688          */
 689         force_check_log_size();
 690         (void)umask(oldumask);
 691
 692         /* Take over stderr to catch output into logs */
 693         if (dbf && dup2(x_fileno(dbf), 2) == -1) {
 694                 close_low_fds(True); /* Close stderr too, if dup2 can't point it
 695                                         at the logfile */
 696         }
 697
 698         return ret;
 699 }
 700
 701 /**************************************************************************
 702  Force a check of the log size.
 703  ***************************************************************************/
 704
 705 void force_check_log_size( void )
 706 {
 707         debug_count = 100;
 708 }
 709
 710 /***************************************************************************
 711  Check to see if there is any need to check if the logfile has grown too big.
 712 **************************************************************************/
 713
 714 bool need_to_check_log_size( void )
 715 {
 716         int maxlog;
 717
 718         if( debug_count < 100 )
 719                 return( False );
 720
 721         maxlog = lp_max_log_size() * 1024;
 722         if( !dbf || maxlog <= 0 ) {
 723                 debug_count = 0;
 724                 return(False);
 725         }
 726         return( True );
 727 }
 728
 729 /**************************************************************************
 730  Check to see if the log has grown to be too big.
 731  **************************************************************************/
 732
 733 void check_log_size( void )
 734 {
 735         int         maxlog;
 736         SMB_STRUCT_STAT st;
 737
 738         /*
 739          *  We need to be root to check/change log-file, skip this and let the main
 740          *  loop check do a new check as root.
 741          */
 742
 743         if( geteuid() != 0 )
 744                 return;
 745
 746         if(log_overflow || !need_to_check_log_size() )
 747                 return;
 748
 749         maxlog = lp_max_log_size() * 1024;
 750
 751         if( sys_fstat( x_fileno( dbf ), &st ) == 0 && st.st_ex_size > maxlog ) {
 752                 (void)reopen_logs();
 753                 if( dbf && get_file_size( debugf ) > maxlog ) {
 754                         char *name = NULL;
 755
 756                         if (asprintf(&name, "%s.old", debugf ) < 0) {
 757                                 return;
 758                         }
 759                         (void)rename(debugf, name);
 760
 761                         if (!reopen_logs()) {
 762                                 /* We failed to reopen a log - continue using the old name. */
 763                                 (void)rename(name, debugf);
 764                         }
 765                         SAFE_FREE(name);
 766                 }
 767         }
 768
 769         /*
 770          * Here's where we need to panic if dbf == NULL..
 771          */
 772
 773         if(dbf == NULL) {
 774                 /* This code should only be reached in very strange
 775                  * circumstances. If we merely fail to open the new log we
 776                  * should stick with the old one. ergo this should only be
 777                  * reached when opening the logs for the first time: at
 778                  * startup or when the log level is increased from zero.
 779                  * -dwg 6 June 2000
 780                  */
 781                 dbf = x_fopen( "/dev/console", O_WRONLY, 0);
 782                 if(dbf) {
 783                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
 784                                         debugf ));
 785                 } else {
 786                         /*
 787                          * We cannot continue without a debug file handle.
 788                          */
 789                         abort();
 790                 }
 791         }
 792         debug_count = 0;
 793 }
 794
 795 /*************************************************************************
 796  Write an debug message on the debugfile.
 797  This is called by dbghdr() and format_debug_text().
 798 ************************************************************************/
 799
 800  int Debug1( const char *format_str, ... )
 801 {
 802         va_list ap;
 803         int old_errno = errno;
 804
 805         debug_count++;
 806
 807         if( stdout_logging ) {
 808                 va_start( ap, format_str );
 809                 if(dbf)
 810                         (void)x_vfprintf( dbf, format_str, ap );
 811                 va_end( ap );
 812                 errno = old_errno;
 813                 goto done;
 814         }
 815
 816         /* prevent recursion by checking if reopen_logs() has temporaily
 817            set the debugf string to NULL */
 818         if( debugf == NULL)
 819                 goto done;
 820
 821 #ifdef WITH_SYSLOG
 822         if( !lp_syslog_only() )
 823 #endif
 824         {
 825                 if( !dbf ) {
 826                         mode_t oldumask = umask( 022 );
 827
 828                         dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
 829                         (void)umask( oldumask );
 830                         if( dbf ) {
 831                                 x_setbuf( dbf, NULL );
 832                         } else {
 833                                 errno = old_errno;
 834                                 goto done;
 835                         }
 836                 }
 837         }
 838
 839 #ifdef WITH_SYSLOG
 840         if( syslog_level < lp_syslog() ) {
 841                 /* map debug levels to syslog() priorities
 842                  * note that not all DEBUG(0, ...) calls are
 843                  * necessarily errors */
 844                 static const int priority_map[4] = {
 845                         LOG_ERR,     /* 0 */
 846                         LOG_WARNING, /* 1 */
 847                         LOG_NOTICE,  /* 2 */
 848                         LOG_INFO,    /* 3 */
 849                 };
 850                 int     priority;
 851                 char *msgbuf = NULL;
 852                 int ret;
 853
 854                 if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
 855                         priority = LOG_DEBUG;
 856                 else
 857                         priority = priority_map[syslog_level];
 858
 859                 /*
 860                  * Specify the facility to interoperate with other syslog
 861                  * callers (vfs_full_audit for example).
 862                  */
 863                 priority |= SYSLOG_FACILITY;
 864
 865                 va_start(ap, format_str);
 866                 ret = vasprintf(&msgbuf, format_str, ap);
 867                 va_end(ap);
 868
 869                 if (ret != -1) {
 870                         syslog(priority, "%s", msgbuf);
 871                 }
 872                 SAFE_FREE(msgbuf);
 873         }
 874 #endif
 875
 876         check_log_size();
 877
 878 #ifdef WITH_SYSLOG
 879         if( !lp_syslog_only() )
 880 #endif
 881         {
 882                 va_start( ap, format_str );
 883                 if(dbf)
 884                         (void)x_vfprintf( dbf, format_str, ap );
 885                 va_end( ap );
 886                 if(dbf)
 887                         (void)x_fflush( dbf );
 888         }
 889
 890  done:
 891         TALLOC_FREE(tmp_debug_ctx);
 892
 893         errno = old_errno;
 894
 895         return( 0 );
 896 }
 897
 898
 899 /**************************************************************************
 900  Print the buffer content via Debug1(), then reset the buffer.
 901  Input:  none
 902  Output: none
 903 ****************************************************************************/
 904
 905 static void bufr_print( void )
 906 {
 907         format_bufr[format_pos] = '\0';
 908         (void)Debug1( "%s", format_bufr );
 909         format_pos = 0;
 910 }
 911
 912 /***************************************************************************
 913  Format the debug message text.
 914
 915  Input:  msg - Text to be added to the "current" debug message text.
 916
 917  Output: none.
 918
 919  Notes:  The purpose of this is two-fold.  First, each call to syslog()
 920          (used by Debug1(), see above) generates a new line of syslog
 921          output.  This is fixed by storing the partial lines until the
 922          newline character is encountered.  Second, printing the debug
 923          message lines when a newline is encountered allows us to add
 924          spaces, thus indenting the body of the message and making it
 925          more readable.
 926 **************************************************************************/
 927
 928 static void format_debug_text( const char *msg )
 929 {
 930         size_t i;
 931         bool timestamp = (!stdout_logging && (lp_timestamp_logs() || !(lp_loaded())));
 932
 933         if (!format_bufr) {
 934                 debug_init();
 935         }
 936
 937         for( i = 0; msg[i]; i++ ) {
 938                 /* Indent two spaces at each new line. */
 939                 if(timestamp && 0 == format_pos) {
 940                         format_bufr[0] = format_bufr[1] = ' ';
 941                         format_pos = 2;
 942                 }
 943
 944                 /* If there's room, copy the character to the format buffer. */
 945                 if( format_pos < FORMAT_BUFR_MAX )
 946                         format_bufr[format_pos++] = msg[i];
 947
 948                 /* If a newline is encountered, print & restart. */
 949                 if( '\n' == msg[i] )
 950                         bufr_print();
 951
 952                 /* If the buffer is full dump it out, reset it, and put out a line
 953                  * continuation indicator.
 954                  */
 955                 if( format_pos >= FORMAT_BUFR_MAX ) {
 956                         bufr_print();
 957                         (void)Debug1( " +>\n" );
 958                 }
 959         }
 960
 961         /* Just to be safe... */
 962         format_bufr[format_pos] = '\0';
 963 }
 964
 965 /***************************************************************************
 966  Flush debug output, including the format buffer content.
 967
 968  Input:  none
 969  Output: none
 970 ***************************************************************************/
 971
 972 void dbgflush( void )
 973 {
 974         bufr_print();
 975         if(dbf)
 976                 (void)x_fflush( dbf );
 977 }
 978
 979 /***************************************************************************
 980  Print a Debug Header.
 981
 982  Input:  level - Debug level of the message (not the system-wide debug
 983                   level. )
 984           cls   - Debuglevel class of the calling module.
 985           file  - Pointer to a string containing the name of the file
 986                   from which this function was called, or an empty string
 987                   if the __FILE__ macro is not implemented.
 988           func  - Pointer to a string containing the name of the function
 989                   from which this function was called, or an empty string
 990                   if the __FUNCTION__ macro is not implemented.
 991          line  - line number of the call to dbghdr, assuming __LINE__
 992                  works.
 993
 994   Output: Always True.  This makes it easy to fudge a call to dbghdr()
 995           in a macro, since the function can be called as part of a test.
 996           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 997
 998   Notes:  This function takes care of setting syslog_level.
 999
1000 ****************************************************************************/
1001
1002 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1003 {
1004         /* Ensure we don't lose any real errno value. */
1005         int old_errno = errno;
1006
1007         if( format_pos ) {
1008                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
1009                  * the *right* thing to do is to call
1010                  *   format_debug_text( "\n" );
1011                  * to write the remainder, and then proceed with the new header.
1012                  * Unfortunately, there are several places in the code at which
1013                  * the DEBUG() macro is used to build partial lines.  That in mind,
1014                  * we'll work under the assumption that an incomplete line indicates
1015                  * that a new header is *not* desired.
1016                  */
1017                 return( True );
1018         }
1019
1020 #ifdef WITH_SYSLOG
1021         /* Set syslog_level. */
1022         syslog_level = level;
1023 #endif
1024
1025         /* Don't print a header if we're logging to stdout. */
1026         if( stdout_logging )
1027                 return( True );
1028
1029         /* Print the header if timestamps are turned on.  If parameters are
1030          * not yet loaded, then default to timestamps on.
1031          */
1032         if( lp_timestamp_logs() || lp_debug_prefix_timestamp() || !(lp_loaded()) ) {
1033                 char header_str[200];
1034
1035                 header_str[0] = '\0';
1036
1037                 if( lp_debug_pid())
1038                         slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
1039
1040                 if( lp_debug_uid()) {
1041                         size_t hs_len = strlen(header_str);
1042                         slprintf(header_str + hs_len,
1043                         sizeof(header_str) - 1 - hs_len,
1044                                 ", effective(%u, %u), real(%u, %u)",
1045                                 (unsigned int)geteuid(), (unsigned int)getegid(),
1046                                 (unsigned int)getuid(), (unsigned int)getgid());
1047                 }
1048
1049                 if (lp_debug_class() && (cls != DBGC_ALL)) {
1050                         size_t hs_len = strlen(header_str);
1051                         slprintf(header_str + hs_len,
1052                                  sizeof(header_str) -1 - hs_len,
1053                                  ", class=%s",
1054                                  default_classname_table[cls]);
1055                 }
1056
1057                 /* Print it all out at once to prevent split syslog output. */
1058                 if( lp_debug_prefix_timestamp() ) {
1059                     (void)Debug1( "[%s, %2d%s] ",
1060                         current_timestring(debug_ctx(),
1061                                            lp_debug_hires_timestamp()),
1062                         level, header_str);
1063                 } else {
1064                     (void)Debug1( "[%s, %2d%s] %s(%s)\n",
1065                         current_timestring(debug_ctx(),
1066                                            lp_debug_hires_timestamp()),
1067                         level, header_str, location, func );
1068                 }
1069         }
1070
1071         errno = old_errno;
1072         return( True );
1073 }
1074
1075 bool dbghdr(int level, const char *location, const char *func)
1076 {
1077         /* For compatibility with Samba 4, which doesn't have debug classes */
1078         return dbghdrclass(level, 0, location, func);
1079 }
1080
1081 /***************************************************************************
1082  Add text to the body of the "current" debug message via the format buffer.
1083
1084   Input:  format_str  - Format string, as used in printf(), et. al.
1085           ...         - Variable argument list.
1086
1087   ..or..  va_alist    - Old style variable parameter list starting point.
1088
1089   Output: Always True.  See dbghdr() for more info, though this is not
1090           likely to be used in the same way.
1091
1092 ***************************************************************************/
1093
1094  bool dbgtext( const char *format_str, ... )
1095 {
1096         va_list ap;
1097         char *msgbuf = NULL;
1098         bool ret = true;
1099         int res;
1100
1101         va_start(ap, format_str);
1102         res = vasprintf(&msgbuf, format_str, ap);
1103         va_end(ap);
1104
1105         if (res != -1) {
1106                 format_debug_text(msgbuf);
1107         } else {
1108                 ret = false;
1109         }
1110         SAFE_FREE(msgbuf);
1111         return ret;
1112 }
1113
1114 /*
1115  * Get us a temporary talloc context usable just for DEBUG arguments
1116  */
1117 TALLOC_CTX *debug_ctx(void)
1118 {
1119         if (tmp_debug_ctx == NULL) {
1120                 tmp_debug_ctx = talloc_named_const(NULL, 0, "debug_ctx");
1121         }
1122         return tmp_debug_ctx;
1123 }