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