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