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