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
 576         if (lp_loaded()) {
 577                 char *logfname;
 578
 579                 logfname = lp_logfile();
 580                 if (*logfname)
 581                         pstrcpy(fname, logfname);
 582         }
 583
 584         pstrcpy( debugf, fname );
 585         new_dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
 586
 587         if (!new_dbf) {
 588                 log_overflow = True;
 589                 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
 590                 log_overflow = False;
 591                 if (dbf)
 592                         x_fflush(dbf);
 593                 ret = False;
 594         } else {
 595                 x_setbuf(new_dbf, NULL);
 596                 old_dbf = dbf;
 597                 dbf = new_dbf;
 598                 if (old_dbf)
 599                         (void) x_fclose(old_dbf);
 600         }
 601
 602         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
 603          * to fix problem where smbd's that generate less
 604          * than 100 messages keep growing the log.
 605          */
 606         force_check_log_size();
 607         (void)umask(oldumask);
 608
 609         /* Take over stderr to catch ouput into logs */
 610         if (dbf && sys_dup2(x_fileno(dbf), 2) == -1) {
 611                 close_low_fds(True); /* Close stderr too, if dup2 can't point it
 612                                         at the logfile */
 613         }
 614
 615         return ret;
 616 }
 617
 618 /**************************************************************************
 619  Force a check of the log size.
 620  ***************************************************************************/
 621
 622 void force_check_log_size( void )
 623 {
 624         debug_count = 100;
 625 }
 626
 627 /***************************************************************************
 628  Check to see if there is any need to check if the logfile has grown too big.
 629 **************************************************************************/
 630
 631 BOOL need_to_check_log_size( void )
 632 {
 633         int maxlog;
 634
 635         if( debug_count < 100 )
 636                 return( False );
 637
 638         maxlog = lp_max_log_size() * 1024;
 639         if( !dbf || maxlog <= 0 ) {
 640                 debug_count = 0;
 641                 return(False);
 642         }
 643         return( True );
 644 }
 645
 646 /**************************************************************************
 647  Check to see if the log has grown to be too big.
 648  **************************************************************************/
 649
 650 void check_log_size( void )
 651 {
 652         int         maxlog;
 653         SMB_STRUCT_STAT st;
 654
 655         /*
 656          *  We need to be root to check/change log-file, skip this and let the main
 657          *  loop check do a new check as root.
 658          */
 659
 660         if( geteuid() != 0 )
 661                 return;
 662
 663         if(log_overflow || !need_to_check_log_size() )
 664                 return;
 665
 666         maxlog = lp_max_log_size() * 1024;
 667
 668         if( sys_fstat( x_fileno( dbf ), &st ) == 0 && st.st_size > maxlog ) {
 669                 (void)reopen_logs();
 670                 if( dbf && get_file_size( debugf ) > maxlog ) {
 671                         pstring name;
 672
 673                         slprintf( name, sizeof(name)-1, "%s.old", debugf );
 674                         (void)rename( debugf, name );
 675
 676                         if (!reopen_logs()) {
 677                                 /* We failed to reopen a log - continue using the old name. */
 678                                 (void)rename(name, debugf);
 679                         }
 680                 }
 681         }
 682
 683         /*
 684          * Here's where we need to panic if dbf == NULL..
 685          */
 686
 687         if(dbf == NULL) {
 688                 /* This code should only be reached in very strange
 689                  * circumstances. If we merely fail to open the new log we
 690                  * should stick with the old one. ergo this should only be
 691                  * reached when opening the logs for the first time: at
 692                  * startup or when the log level is increased from zero.
 693                  * -dwg 6 June 2000
 694                  */
 695                 dbf = x_fopen( "/dev/console", O_WRONLY, 0);
 696                 if(dbf) {
 697                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
 698                                         debugf ));
 699                 } else {
 700                         /*
 701                          * We cannot continue without a debug file handle.
 702                          */
 703                         abort();
 704                 }
 705         }
 706         debug_count = 0;
 707 }
 708
 709 /*************************************************************************
 710  Write an debug message on the debugfile.
 711  This is called by dbghdr() and format_debug_text().
 712 ************************************************************************/
 713
 714  int Debug1( const char *format_str, ... )
 715 {
 716         va_list ap;
 717         int old_errno = errno;
 718
 719         debug_count++;
 720
 721         if( stdout_logging ) {
 722                 va_start( ap, format_str );
 723                 if(dbf)
 724                         (void)x_vfprintf( dbf, format_str, ap );
 725                 va_end( ap );
 726                 errno = old_errno;
 727                 return( 0 );
 728         }
 729
 730 #ifdef WITH_SYSLOG
 731         if( !lp_syslog_only() )
 732 #endif
 733         {
 734                 if( !dbf ) {
 735                         mode_t oldumask = umask( 022 );
 736
 737                         dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
 738                         (void)umask( oldumask );
 739                         if( dbf ) {
 740                                 x_setbuf( dbf, NULL );
 741                         } else {
 742                                 errno = old_errno;
 743                                 return(0);
 744                         }
 745                 }
 746         }
 747
 748 #ifdef WITH_SYSLOG
 749         if( syslog_level < lp_syslog() ) {
 750                 /* map debug levels to syslog() priorities
 751                  * note that not all DEBUG(0, ...) calls are
 752                  * necessarily errors */
 753                 static int priority_map[] = {
 754                         LOG_ERR,     /* 0 */
 755                         LOG_WARNING, /* 1 */
 756                         LOG_NOTICE,  /* 2 */
 757                         LOG_INFO,    /* 3 */
 758                 };
 759                 int     priority;
 760                 pstring msgbuf;
 761
 762                 if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) ) || syslog_level < 0)
 763                         priority = LOG_DEBUG;
 764                 else
 765                         priority = priority_map[syslog_level];
 766
 767                 va_start( ap, format_str );
 768                 vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 769                 va_end( ap );
 770
 771                 msgbuf[255] = '\0';
 772                 syslog( priority, "%s", msgbuf );
 773         }
 774 #endif
 775
 776         check_log_size();
 777
 778 #ifdef WITH_SYSLOG
 779         if( !lp_syslog_only() )
 780 #endif
 781         {
 782                 va_start( ap, format_str );
 783                 if(dbf)
 784                         (void)x_vfprintf( dbf, format_str, ap );
 785                 va_end( ap );
 786                 if(dbf)
 787                         (void)x_fflush( dbf );
 788         }
 789
 790         errno = old_errno;
 791
 792         return( 0 );
 793 }
 794
 795
 796 /**************************************************************************
 797  Print the buffer content via Debug1(), then reset the buffer.
 798  Input:  none
 799  Output: none
 800 ****************************************************************************/
 801
 802 static void bufr_print( void )
 803 {
 804         format_bufr[format_pos] = '\0';
 805         (void)Debug1( "%s", format_bufr );
 806         format_pos = 0;
 807 }
 808
 809 /***************************************************************************
 810  Format the debug message text.
 811
 812  Input:  msg - Text to be added to the "current" debug message text.
 813
 814  Output: none.
 815
 816  Notes:  The purpose of this is two-fold.  First, each call to syslog()
 817          (used by Debug1(), see above) generates a new line of syslog
 818          output.  This is fixed by storing the partial lines until the
 819          newline character is encountered.  Second, printing the debug
 820          message lines when a newline is encountered allows us to add
 821          spaces, thus indenting the body of the message and making it
 822          more readable.
 823 **************************************************************************/
 824
 825 static void format_debug_text( const char *msg )
 826 {
 827         size_t i;
 828         BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() || !(lp_loaded())));
 829
 830         for( i = 0; msg[i]; i++ ) {
 831                 /* Indent two spaces at each new line. */
 832                 if(timestamp && 0 == format_pos) {
 833                         format_bufr[0] = format_bufr[1] = ' ';
 834                         format_pos = 2;
 835                 }
 836
 837                 /* If there's room, copy the character to the format buffer. */
 838                 if( format_pos < FORMAT_BUFR_MAX )
 839                         format_bufr[format_pos++] = msg[i];
 840
 841                 /* If a newline is encountered, print & restart. */
 842                 if( '\n' == msg[i] )
 843                         bufr_print();
 844
 845                 /* If the buffer is full dump it out, reset it, and put out a line
 846                  * continuation indicator.
 847                  */
 848                 if( format_pos >= FORMAT_BUFR_MAX ) {
 849                         bufr_print();
 850                         (void)Debug1( " +>\n" );
 851                 }
 852         }
 853
 854         /* Just to be safe... */
 855         format_bufr[format_pos] = '\0';
 856 }
 857
 858 /***************************************************************************
 859  Flush debug output, including the format buffer content.
 860
 861  Input:  none
 862  Output: none
 863 ***************************************************************************/
 864
 865 void dbgflush( void )
 866 {
 867         bufr_print();
 868         if(dbf)
 869                 (void)x_fflush( dbf );
 870 }
 871
 872 /***************************************************************************
 873  Print a Debug Header.
 874
 875  Input:  level - Debug level of the message (not the system-wide debug
 876                   level. )
 877           file  - Pointer to a string containing the name of the file
 878                   from which this function was called, or an empty string
 879                   if the __FILE__ macro is not implemented.
 880           func  - Pointer to a string containing the name of the function
 881                   from which this function was called, or an empty string
 882                   if the __FUNCTION__ macro is not implemented.
 883          line  - line number of the call to dbghdr, assuming __LINE__
 884                  works.
 885
 886   Output: Always True.  This makes it easy to fudge a call to dbghdr()
 887           in a macro, since the function can be called as part of a test.
 888           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 889
 890   Notes:  This function takes care of setting syslog_level.
 891
 892 ****************************************************************************/
 893
 894 BOOL dbghdr( int level, const char *file, const char *func, int line )
 895 {
 896         /* Ensure we don't lose any real errno value. */
 897         int old_errno = errno;
 898
 899         if( format_pos ) {
 900                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
 901                  * the *right* thing to do is to call
 902                  *   format_debug_text( "\n" );
 903                  * to write the remainder, and then proceed with the new header.
 904                  * Unfortunately, there are several places in the code at which
 905                  * the DEBUG() macro is used to build partial lines.  That in mind,
 906                  * we'll work under the assumption that an incomplete line indicates
 907                  * that a new header is *not* desired.
 908                  */
 909                 return( True );
 910         }
 911
 912 #ifdef WITH_SYSLOG
 913         /* Set syslog_level. */
 914         syslog_level = level;
 915 #endif
 916
 917         /* Don't print a header if we're logging to stdout. */
 918         if( stdout_logging )
 919                 return( True );
 920
 921         /* Print the header if timestamps are turned on.  If parameters are
 922          * not yet loaded, then default to timestamps on.
 923          */
 924         if( lp_timestamp_logs() || !(lp_loaded()) ) {
 925                 char header_str[200];
 926
 927                 header_str[0] = '\0';
 928
 929                 if( lp_debug_pid())
 930                         slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
 931
 932                 if( lp_debug_uid()) {
 933                         size_t hs_len = strlen(header_str);
 934                         slprintf(header_str + hs_len,
 935                         sizeof(header_str) - 1 - hs_len,
 936                                 ", effective(%u, %u), real(%u, %u)",
 937                                 (unsigned int)geteuid(), (unsigned int)getegid(),
 938                                 (unsigned int)getuid(), (unsigned int)getgid());
 939                 }
 940
 941                 /* Print it all out at once to prevent split syslog output. */
 942                 (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
 943                         timestring(lp_debug_hires_timestamp()), level,
 944                         header_str, file, func, line );
 945         }
 946
 947         errno = old_errno;
 948         return( True );
 949 }
 950
 951 /***************************************************************************
 952  Add text to the body of the "current" debug message via the format buffer.
 953
 954   Input:  format_str  - Format string, as used in printf(), et. al.
 955           ...         - Variable argument list.
 956
 957   ..or..  va_alist    - Old style variable parameter list starting point.
 958
 959   Output: Always True.  See dbghdr() for more info, though this is not
 960           likely to be used in the same way.
 961
 962 ***************************************************************************/
 963
 964  BOOL dbgtext( const char *format_str, ... )
 965 {
 966         va_list ap;
 967         pstring msgbuf;
 968
 969         va_start( ap, format_str );
 970         vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
 971         va_end( ap );
 972
 973         format_debug_text( msgbuf );
 974
 975   return( True );
 976 }