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