source: branches/samba-3.0/source/lib/debug.c@ 432

Last change on this file since 432 was 279, checked in by Herwig Bauernfeind, 16 years ago

Change in debug.c (by ydario)
File size: 29.2 KB
Line 
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 "locking", /* DBGC_LOCKING */
168 "msdfs", /* DBGC_MSDFS */
169 "dmapi", /* DBGC_DMAPI */
170 NULL
171};
172
173static char **classname_table = NULL;
174
175
176/* -------------------------------------------------------------------------- **
177 * Functions...
178 */
179
180/***************************************************************************
181 Free memory pointed to by global pointers.
182****************************************************************************/
183
184void gfree_debugsyms(void)
185{
186 int i;
187
188 if ( classname_table ) {
189 for ( i = 0; i < debug_num_classes; i++ ) {
190 SAFE_FREE( classname_table[i] );
191 }
192 SAFE_FREE( classname_table );
193 }
194
195 if ( DEBUGLEVEL_CLASS != &debug_all_class_hack )
196 SAFE_FREE( DEBUGLEVEL_CLASS );
197
198 if ( DEBUGLEVEL_CLASS_ISSET != &debug_all_class_isset_hack )
199 SAFE_FREE( DEBUGLEVEL_CLASS_ISSET );
200}
201
202/****************************************************************************
203utility lists registered debug class names's
204****************************************************************************/
205
206#define MAX_CLASS_NAME_SIZE 1024
207
208static char *debug_list_class_names_and_levels(void)
209{
210 int i, dim;
211 char **list;
212 char *buf = NULL;
213 char *b;
214 BOOL err = False;
215
216 if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
217 return NULL;
218 }
219
220 list = SMB_CALLOC_ARRAY(char *, debug_num_classes + 1);
221 if (!list) {
222 return NULL;
223 }
224
225 /* prepare strings */
226 for (i = 0, dim = 0; i < debug_num_classes; i++) {
227 int l = asprintf(&list[i],
228 "%s:%d ",
229 classname_table[i],
230 DEBUGLEVEL_CLASS_ISSET[i]?DEBUGLEVEL_CLASS[i]:DEBUGLEVEL);
231 if (l < 0 || l > MAX_CLASS_NAME_SIZE) {
232 err = True;
233 goto done;
234 }
235 dim += l;
236 }
237
238 /* create single string list - add space for newline */
239 b = buf = (char *)SMB_MALLOC(dim+1);
240 if (!buf) {
241 err = True;
242 goto done;
243 }
244 for (i = 0; i < debug_num_classes; i++) {
245 int l = strlen(list[i]);
246 strncpy(b, list[i], l);
247 b = b + l;
248 }
249 b[-1] = '\n'; /* replace last space with newline */
250 b[0] = '\0'; /* null terminate string */
251
252done:
253 /* free strings list */
254 for (i = 0; i < debug_num_classes; i++) {
255 SAFE_FREE(list[i]);
256 }
257 SAFE_FREE(list);
258
259 if (err) {
260 return NULL;
261 } else {
262 return buf;
263 }
264}
265
266/****************************************************************************
267 Utility access to debug class names's.
268****************************************************************************/
269
270const char *debug_classname_from_index(int ndx)
271{
272 if (ndx < 0 || ndx >= debug_num_classes)
273 return NULL;
274 else
275 return classname_table[ndx];
276}
277
278/****************************************************************************
279 Utility to translate names to debug class index's (internal version).
280****************************************************************************/
281
282static int debug_lookup_classname_int(const char* classname)
283{
284 int i;
285
286 if (!classname) return -1;
287
288 for (i=0; i < debug_num_classes; i++) {
289 if (strcmp(classname, classname_table[i])==0)
290 return i;
291 }
292 return -1;
293}
294
295/****************************************************************************
296 Add a new debug class to the system.
297****************************************************************************/
298
299int debug_add_class(const char *classname)
300{
301 int ndx;
302 void *new_ptr;
303
304 if (!classname)
305 return -1;
306
307 /* check the init has yet been called */
308 debug_init();
309
310 ndx = debug_lookup_classname_int(classname);
311 if (ndx >= 0)
312 return ndx;
313 ndx = debug_num_classes;
314
315 new_ptr = DEBUGLEVEL_CLASS;
316 if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
317 /* Initial loading... */
318 new_ptr = NULL;
319 }
320 new_ptr = SMB_REALLOC_ARRAY(new_ptr, int, debug_num_classes + 1);
321 if (!new_ptr)
322 return -1;
323 DEBUGLEVEL_CLASS = (int *)new_ptr;
324 DEBUGLEVEL_CLASS[ndx] = 0;
325
326 /* debug_level is the pointer used for the DEBUGLEVEL-thingy */
327 if (ndx==0) {
328 /* Transfer the initial level from debug_all_class_hack */
329 DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL;
330 }
331 debug_level = DEBUGLEVEL_CLASS;
332
333 new_ptr = DEBUGLEVEL_CLASS_ISSET;
334 if (new_ptr == &debug_all_class_isset_hack) {
335 new_ptr = NULL;
336 }
337 new_ptr = SMB_REALLOC_ARRAY(new_ptr, BOOL, debug_num_classes + 1);
338 if (!new_ptr)
339 return -1;
340 DEBUGLEVEL_CLASS_ISSET = (int *)new_ptr;
341 DEBUGLEVEL_CLASS_ISSET[ndx] = False;
342
343 new_ptr = SMB_REALLOC_ARRAY(classname_table, char *, debug_num_classes + 1);
344 if (!new_ptr)
345 return -1;
346 classname_table = (char **)new_ptr;
347
348 classname_table[ndx] = SMB_STRDUP(classname);
349 if (! classname_table[ndx])
350 return -1;
351
352 debug_num_classes++;
353
354 return ndx;
355}
356
357/****************************************************************************
358 Utility to translate names to debug class index's (public version).
359****************************************************************************/
360
361int debug_lookup_classname(const char *classname)
362{
363 int ndx;
364
365 if (!classname || !*classname)
366 return -1;
367
368 ndx = debug_lookup_classname_int(classname);
369
370 if (ndx != -1)
371 return ndx;
372
373 if (debug_warn_unknown_class) {
374 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
375 classname));
376 }
377 if (debug_auto_add_unknown_class) {
378 return debug_add_class(classname);
379 }
380 return -1;
381}
382
383/****************************************************************************
384 Dump the current registered debug levels.
385****************************************************************************/
386
387static void debug_dump_status(int level)
388{
389 int q;
390
391 DEBUG(level, ("INFO: Current debug levels:\n"));
392 for (q = 0; q < debug_num_classes; q++) {
393 DEBUGADD(level, (" %s: %s/%d\n",
394 classname_table[q],
395 (DEBUGLEVEL_CLASS_ISSET[q]
396 ? "True" : "False"),
397 DEBUGLEVEL_CLASS[q]));
398 }
399}
400
401/****************************************************************************
402 parse the debug levels from smbcontrol. Example debug level parameter:
403 printdrivers:7
404****************************************************************************/
405
406static BOOL debug_parse_params(char **params)
407{
408 int i, ndx;
409 char *class_name;
410 char *class_level;
411
412 if (!params)
413 return False;
414
415 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
416 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
417 */
418 if (isdigit((int)params[0][0])) {
419 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
420 DEBUGLEVEL_CLASS_ISSET[DBGC_ALL] = True;
421 i = 1; /* start processing at the next params */
422 } else {
423 i = 0; /* DBGC_ALL not specified OR class name was included */
424 }
425
426 /* Fill in new debug class levels */
427 for (; i < debug_num_classes && params[i]; i++) {
428 if ((class_name=strtok(params[i],":")) &&
429 (class_level=strtok(NULL, "\0")) &&
430 ((ndx = debug_lookup_classname(class_name)) != -1)) {
431 DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
432 DEBUGLEVEL_CLASS_ISSET[ndx] = True;
433 } else {
434 DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
435 return False;
436 }
437 }
438
439 return True;
440}
441
442/****************************************************************************
443 Parse the debug levels from smb.conf. Example debug level string:
444 3 tdb:5 printdrivers:7
445 Note: the 1st param has no "name:" preceeding it.
446****************************************************************************/
447
448BOOL debug_parse_levels(const char *params_str)
449{
450 char **params;
451
452 /* Just in case */
453 debug_init();
454
455 if (AllowDebugChange == False)
456 return True;
457
458 params = str_list_make(params_str, NULL);
459
460 if (debug_parse_params(params)) {
461 debug_dump_status(5);
462 str_list_free(&params);
463 return True;
464 } else {
465 str_list_free(&params);
466 return False;
467 }
468}
469
470/****************************************************************************
471 Receive a "set debug level" message.
472****************************************************************************/
473
474static void debug_message(int msg_type, struct process_id src,
475 void *buf, size_t len, void *private_data)
476{
477 const char *params_str = (const char *)buf;
478
479 /* Check, it's a proper string! */
480 if (params_str[len-1] != '\0') {
481 DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
482 (unsigned int)procid_to_pid(&src),
483 (unsigned int)getpid()));
484 return;
485 }
486
487 DEBUG(3, ("INFO: Remote set of debug to `%s' (pid %u from pid %u)\n",
488 params_str, (unsigned int)getpid(),
489 (unsigned int)procid_to_pid(&src)));
490
491 debug_parse_levels(params_str);
492}
493
494/****************************************************************************
495 Send a "set debug level" message.
496****************************************************************************/
497
498void debug_message_send(pid_t pid, const char *params_str)
499{
500 if (!params_str)
501 return;
502 message_send_pid(pid_to_procid(pid), MSG_DEBUG,
503 params_str, strlen(params_str) + 1,
504 False);
505}
506
507/****************************************************************************
508 Return current debug level.
509****************************************************************************/
510
511static void debuglevel_message(int msg_type, struct process_id src,
512 void *buf, size_t len, void *private_data)
513{
514 char *message = debug_list_class_names_and_levels();
515
516 if (!message) {
517 DEBUG(0,("debuglevel_message - debug_list_class_names_and_levels returned NULL\n"));
518 return;
519 }
520
521 DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %u\n",
522 (unsigned int)procid_to_pid(&src)));
523 message_send_pid(src, MSG_DEBUGLEVEL, message, strlen(message) + 1, True);
524
525 SAFE_FREE(message);
526}
527
528/****************************************************************************
529Init debugging (one time stuff)
530****************************************************************************/
531
532void debug_init(void)
533{
534 static BOOL initialised = False;
535 const char **p;
536
537 if (initialised)
538 return;
539
540 initialised = True;
541
542 message_register(MSG_DEBUG, debug_message, NULL);
543 message_register(MSG_REQ_DEBUGLEVEL, debuglevel_message, NULL);
544
545 for(p = default_classname_table; *p; p++) {
546 debug_add_class(*p);
547 }
548}
549
550/***************************************************************************
551 Get ready for syslog stuff
552**************************************************************************/
553
554void setup_logging(const char *pname, BOOL interactive)
555{
556 debug_init();
557
558 /* reset to allow multiple setup calls, going from interactive to
559 non-interactive */
560 stdout_logging = False;
561 if (dbf) {
562 x_fflush(dbf);
563 (void) x_fclose(dbf);
564 }
565
566 dbf = NULL;
567
568 if (interactive) {
569 stdout_logging = True;
570 dbf = x_stdout;
571 x_setbuf( x_stdout, NULL );
572 }
573#ifdef WITH_SYSLOG
574 else {
575 const char *p = strrchr_m( pname,'/' );
576 if (!p)
577 p = strrchr_m( pname,'\\' );
578 if (p)
579 pname = p + 1;
580#ifdef LOG_DAEMON
581 openlog( pname, LOG_PID, SYSLOG_FACILITY );
582#else
583 /* for old systems that have no facility codes. */
584 openlog( pname, LOG_PID );
585#endif
586 }
587#endif
588}
589
590/**************************************************************************
591 reopen the log files
592 note that we now do this unconditionally
593 We attempt to open the new debug fp before closing the old. This means
594 if we run out of fd's we just keep using the old fd rather than aborting.
595 Fix from dgibson@linuxcare.com.
596**************************************************************************/
597
598BOOL reopen_logs( void )
599{
600 pstring fname;
601 mode_t oldumask;
602 XFILE *new_dbf = NULL;
603 XFILE *old_dbf = NULL;
604 BOOL ret = True;
605
606 if (stdout_logging)
607 return True;
608
609 oldumask = umask( 022 );
610
611 pstrcpy(fname, debugf );
612 debugf[0] = '\0';
613
614 if (lp_loaded()) {
615 char *logfname;
616
617 logfname = lp_logfile();
618 if (*logfname)
619 pstrcpy(fname, logfname);
620 }
621
622 pstrcpy( debugf, fname );
623
624#ifdef __OS2__
625 // YD we need to close the file before reopening, otherwise it is not
626 // possible to rename the log
627 if (dbf) {
628 (void) x_fclose(dbf);
629 dbf = NULL;
630 }
631#endif
632
633 new_dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0777);
634
635 if (!new_dbf) {
636 log_overflow = True;
637 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
638 log_overflow = False;
639 if (dbf)
640 x_fflush(dbf);
641 ret = False;
642 } else {
643 x_setbuf(new_dbf, NULL);
644 old_dbf = dbf;
645 dbf = new_dbf;
646 if (old_dbf)
647 (void) x_fclose(old_dbf);
648 }
649
650 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
651 * to fix problem where smbd's that generate less
652 * than 100 messages keep growing the log.
653 */
654 force_check_log_size();
655 (void)umask(oldumask);
656
657 /* Take over stderr to catch ouput into logs */
658#ifndef __OS2__
659 // this opens debug file twice!
660 if (dbf && sys_dup2(x_fileno(dbf), 2) == -1) {
661 close_low_fds(True); /* Close stderr too, if dup2 can't point it
662 at the logfile */
663 }
664#endif
665
666 return ret;
667}
668
669/**************************************************************************
670 Force a check of the log size.
671 ***************************************************************************/
672
673void force_check_log_size( void )
674{
675 debug_count = 100;
676}
677
678/***************************************************************************
679 Check to see if there is any need to check if the logfile has grown too big.
680**************************************************************************/
681
682BOOL need_to_check_log_size( void )
683{
684 int maxlog;
685
686 if( debug_count < 100 )
687 return( False );
688
689 maxlog = lp_max_log_size() * 1024;
690 if( !dbf || maxlog <= 0 ) {
691 debug_count = 0;
692 return(False);
693 }
694 return( True );
695}
696
697/**************************************************************************
698 Check to see if the log has grown to be too big.
699 **************************************************************************/
700
701void check_log_size( void )
702{
703 int maxlog;
704 SMB_STRUCT_STAT st;
705
706 /*
707 * We need to be root to check/change log-file, skip this and let the main
708 * loop check do a new check as root.
709 */
710
711 if( geteuid() != 0 )
712 return;
713
714 if(log_overflow || !need_to_check_log_size() )
715 return;
716
717 maxlog = lp_max_log_size() * 1024;
718
719 if( sys_fstat( x_fileno( dbf ), &st ) == 0 && st.st_size > maxlog ) {
720 (void)reopen_logs();
721 if( dbf && get_file_size( debugf ) > maxlog ) {
722 pstring name;
723
724 slprintf( name, sizeof(name)-1, "%s.old", debugf );
725#ifdef __OS2__
726 (void)unlink( name );
727#endif
728 (void)rename( debugf, name );
729
730 if (!reopen_logs()) {
731 /* We failed to reopen a log - continue using the old name. */
732 (void)rename(name, debugf);
733 }
734 }
735 }
736
737 /*
738 * Here's where we need to panic if dbf == NULL..
739 */
740
741 if(dbf == NULL) {
742 /* This code should only be reached in very strange
743 * circumstances. If we merely fail to open the new log we
744 * should stick with the old one. ergo this should only be
745 * reached when opening the logs for the first time: at
746 * startup or when the log level is increased from zero.
747 * -dwg 6 June 2000
748 */
749 dbf = x_fopen( "/dev/console", O_WRONLY, 0);
750 if(dbf) {
751 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
752 debugf ));
753 } else {
754 /*
755 * We cannot continue without a debug file handle.
756 */
757 abort();
758 }
759 }
760 debug_count = 0;
761}
762
763/*************************************************************************
764 Write an debug message on the debugfile.
765 This is called by dbghdr() and format_debug_text().
766************************************************************************/
767
768 int Debug1( const char *format_str, ... )
769{
770 va_list ap;
771 int old_errno = errno;
772
773 debug_count++;
774
775 if( stdout_logging ) {
776 va_start( ap, format_str );
777 if(dbf)
778 (void)x_vfprintf( dbf, format_str, ap );
779 va_end( ap );
780 errno = old_errno;
781 return( 0 );
782 }
783
784 /* prevent recursion by checking if reopen_logs() has temporaily
785 set the debugf string to "" */
786 if( debugf[0] == '\0')
787 return( 0 );
788
789#ifdef WITH_SYSLOG
790 if( !lp_syslog_only() )
791#endif
792 {
793 if( !dbf ) {
794 mode_t oldumask = umask( 022 );
795
796 dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
797 (void)umask( oldumask );
798 if( dbf ) {
799 x_setbuf( dbf, NULL );
800 } else {
801 errno = old_errno;
802 return(0);
803 }
804 }
805 }
806
807#ifdef WITH_SYSLOG
808 if( syslog_level < lp_syslog() ) {
809 /* map debug levels to syslog() priorities
810 * note that not all DEBUG(0, ...) calls are
811 * necessarily errors */
812 static int priority_map[] = {
813 LOG_ERR, /* 0 */
814 LOG_WARNING, /* 1 */
815 LOG_NOTICE, /* 2 */
816 LOG_INFO, /* 3 */
817 };
818 int priority;
819 pstring msgbuf;
820
821 if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) ) || syslog_level < 0)
822 priority = LOG_DEBUG;
823 else
824 priority = priority_map[syslog_level];
825
826 va_start( ap, format_str );
827 vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
828 va_end( ap );
829
830 msgbuf[255] = '\0';
831 syslog( priority, "%s", msgbuf );
832 }
833#endif
834
835 check_log_size();
836
837#ifdef WITH_SYSLOG
838 if( !lp_syslog_only() )
839#endif
840 {
841 va_start( ap, format_str );
842 if(dbf)
843 (void)x_vfprintf( dbf, format_str, ap );
844 va_end( ap );
845 if(dbf)
846 (void)x_fflush( dbf );
847 }
848
849 errno = old_errno;
850
851 return( 0 );
852}
853
854
855/**************************************************************************
856 Print the buffer content via Debug1(), then reset the buffer.
857 Input: none
858 Output: none
859****************************************************************************/
860
861static void bufr_print( void )
862{
863 format_bufr[format_pos] = '\0';
864 (void)Debug1( "%s", format_bufr );
865 format_pos = 0;
866}
867
868/***************************************************************************
869 Format the debug message text.
870
871 Input: msg - Text to be added to the "current" debug message text.
872
873 Output: none.
874
875 Notes: The purpose of this is two-fold. First, each call to syslog()
876 (used by Debug1(), see above) generates a new line of syslog
877 output. This is fixed by storing the partial lines until the
878 newline character is encountered. Second, printing the debug
879 message lines when a newline is encountered allows us to add
880 spaces, thus indenting the body of the message and making it
881 more readable.
882**************************************************************************/
883
884static void format_debug_text( const char *msg )
885{
886 size_t i;
887 BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() || !(lp_loaded())));
888
889 for( i = 0; msg[i]; i++ ) {
890 /* Indent two spaces at each new line. */
891 if(timestamp && 0 == format_pos) {
892 format_bufr[0] = format_bufr[1] = ' ';
893 format_pos = 2;
894 }
895
896 /* If there's room, copy the character to the format buffer. */
897 if( format_pos < FORMAT_BUFR_MAX )
898 format_bufr[format_pos++] = msg[i];
899
900 /* If a newline is encountered, print & restart. */
901 if( '\n' == msg[i] )
902 bufr_print();
903
904 /* If the buffer is full dump it out, reset it, and put out a line
905 * continuation indicator.
906 */
907 if( format_pos >= FORMAT_BUFR_MAX ) {
908 bufr_print();
909 (void)Debug1( " +>\n" );
910 }
911 }
912
913 /* Just to be safe... */
914 format_bufr[format_pos] = '\0';
915}
916
917/***************************************************************************
918 Flush debug output, including the format buffer content.
919
920 Input: none
921 Output: none
922***************************************************************************/
923
924void dbgflush( void )
925{
926 bufr_print();
927 if(dbf)
928 (void)x_fflush( dbf );
929}
930
931/***************************************************************************
932 Print a Debug Header.
933
934 Input: level - Debug level of the message (not the system-wide debug
935 level. )
936 file - Pointer to a string containing the name of the file
937 from which this function was called, or an empty string
938 if the __FILE__ macro is not implemented.
939 func - Pointer to a string containing the name of the function
940 from which this function was called, or an empty string
941 if the __FUNCTION__ macro is not implemented.
942 line - line number of the call to dbghdr, assuming __LINE__
943 works.
944
945 Output: Always True. This makes it easy to fudge a call to dbghdr()
946 in a macro, since the function can be called as part of a test.
947 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
948
949 Notes: This function takes care of setting syslog_level.
950
951****************************************************************************/
952
953BOOL dbghdr( int level, const char *file, const char *func, int line )
954{
955 /* Ensure we don't lose any real errno value. */
956 int old_errno = errno;
957
958 if( format_pos ) {
959 /* This is a fudge. If there is stuff sitting in the format_bufr, then
960 * the *right* thing to do is to call
961 * format_debug_text( "\n" );
962 * to write the remainder, and then proceed with the new header.
963 * Unfortunately, there are several places in the code at which
964 * the DEBUG() macro is used to build partial lines. That in mind,
965 * we'll work under the assumption that an incomplete line indicates
966 * that a new header is *not* desired.
967 */
968 return( True );
969 }
970
971#ifdef WITH_SYSLOG
972 /* Set syslog_level. */
973 syslog_level = level;
974#endif
975
976 /* Don't print a header if we're logging to stdout. */
977 if( stdout_logging )
978 return( True );
979
980 /* Print the header if timestamps are turned on. If parameters are
981 * not yet loaded, then default to timestamps on.
982 */
983 if( lp_timestamp_logs() || lp_debug_prefix_timestamp() || !(lp_loaded()) ) {
984 char header_str[200];
985
986 header_str[0] = '\0';
987
988 if( lp_debug_pid())
989 slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
990
991 if( lp_debug_uid()) {
992 size_t hs_len = strlen(header_str);
993 slprintf(header_str + hs_len,
994 sizeof(header_str) - 1 - hs_len,
995 ", effective(%u, %u), real(%u, %u)",
996 (unsigned int)geteuid(), (unsigned int)getegid(),
997 (unsigned int)getuid(), (unsigned int)getgid());
998 }
999
1000 /* Print it all out at once to prevent split syslog output. */
1001 if( lp_debug_prefix_timestamp() ) {
1002 (void)Debug1( "[%s, %d%s] ",
1003 current_timestring(lp_debug_hires_timestamp()), level,
1004 header_str);
1005 } else {
1006 (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
1007 current_timestring(lp_debug_hires_timestamp()), level,
1008 header_str, file, func, line );
1009 }
1010 }
1011
1012 errno = old_errno;
1013 return( True );
1014}
1015
1016/***************************************************************************
1017 Add text to the body of the "current" debug message via the format buffer.
1018
1019 Input: format_str - Format string, as used in printf(), et. al.
1020 ... - Variable argument list.
1021
1022 ..or.. va_alist - Old style variable parameter list starting point.
1023
1024 Output: Always True. See dbghdr() for more info, though this is not
1025 likely to be used in the same way.
1026
1027***************************************************************************/
1028
1029 BOOL dbgtext( const char *format_str, ... )
1030{
1031 va_list ap;
1032 pstring msgbuf;
1033
1034 va_start( ap, format_str );
1035 vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
1036 va_end( ap );
1037
1038 format_debug_text( msgbuf );
1039
1040 return( True );
1041}
Note: See TracBrowser for help on using the repository browser.