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