source: branches/samba-3.3.x/source/lib/debug.c@ 356

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

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