source3/lib/debug.c

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