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