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
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.
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.
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/>.
23 #include "system/filesys.h"
24 #include "system/syslog.h"
25 #include "lib/util/time.h"
27 /* define what facility to use for syslog */
28 #ifndef SYSLOG_FACILITY
29 #define SYSLOG_FACILITY LOG_DAEMON
32 /* -------------------------------------------------------------------------- **
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.
40 #define FORMAT_BUFR_SIZE 1024
41 #define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
43 /* -------------------------------------------------------------------------- **
44 * This module implements Samba's debugging utility.
46 * The syntax of a debugging log file is represented as:
48 * <debugfile> :== { <debugmsg> }
50 * <debugmsg> :== <debughdr> '\n' <debugtext>
52 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
54 * <debugtext> :== { <debugline> }
56 * <debugline> :== TEXT '\n'
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.
64 * Basically, what that all means is:
66 * - A debugging log file is made up of debug messages.
68 * - Each debug message is made up of a header and text. The header is
69 * separated from the text by a newline.
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.
76 * - The message text is made up of zero or more lines, each terminated by
80 /* state variables for the debug system */
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
;
87 bool schedule_reopen_logs
;
89 struct debug_settings settings
;
91 debug_callback_fn callback
;
92 void *callback_private
;
95 .timestamp_logs
= true
97 .fd
= 2 /* stderr by default */
100 /* -------------------------------------------------------------------------- **
101 * External variables.
103 * debugf - Debug file name.
104 * DEBUGLEVEL - System-wide debug message limit. Messages with message-
105 * levels higher than DEBUGLEVEL will not be processed.
109 used to check if the user specified a
110 logfile on the command line
112 bool override_logfile
;
115 * This is to allow reading of DEBUGLEVEL_CLASS before the debug
116 * system has been initialized.
118 static const int debug_class_list_initial
[DBGC_MAX_FIXED
+ 1];
120 static int debug_num_classes
= 0;
121 int *DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
124 /* -------------------------------------------------------------------------- **
125 * Internal variables.
127 * debug_count - Number of debug messages that have been output.
128 * Used to check log size.
130 * current_msg_level - Internal copy of the message debug level. Written by
131 * dbghdr() and read by Debug1().
133 * format_bufr - Used to format debug messages. The dbgtext() function
134 * prints debug messages to a string, and then passes the
135 * string to format_debug_text(), which uses format_bufr
136 * to build the formatted output.
138 * format_pos - Marks the first free byte of the format_bufr.
141 * log_overflow - When this variable is true, never attempt to check the
142 * size of the log. This is a hack, so that we can write
143 * a message using DEBUG, from open_logs() when we
144 * are unable to open a new log file for some reason.
147 static int debug_count
= 0;
148 static int current_msg_level
= 0;
149 static char *format_bufr
= NULL
;
150 static size_t format_pos
= 0;
151 static bool log_overflow
= false;
154 * Define all the debug class selection names here. Names *MUST NOT* contain
155 * white space. There must be one name for each DBGC_<class name>, and they
156 * must be in the table in the order of DBGC_<class name>..
158 static const char *default_classname_table
[] = {
159 "all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
160 "tdb", /* DBGC_TDB */
161 "printdrivers", /* DBGC_PRINTDRIVERS */
162 "lanman", /* DBGC_LANMAN */
163 "smb", /* DBGC_SMB */
164 "rpc_parse", /* DBGC_RPC_PARSE */
165 "rpc_srv", /* DBGC_RPC_SRV */
166 "rpc_cli", /* DBGC_RPC_CLI */
167 "passdb", /* DBGC_PASSDB */
168 "sam", /* DBGC_SAM */
169 "auth", /* DBGC_AUTH */
170 "winbind", /* DBGC_WINBIND */
171 "vfs", /* DBGC_VFS */
172 "idmap", /* DBGC_IDMAP */
173 "quota", /* DBGC_QUOTA */
174 "acls", /* DBGC_ACLS */
175 "locking", /* DBGC_LOCKING */
176 "msdfs", /* DBGC_MSDFS */
177 "dmapi", /* DBGC_DMAPI */
178 "registry", /* DBGC_REGISTRY */
179 "scavenger", /* DBGC_SCAVENGER */
183 static char **classname_table
= NULL
;
186 /* -------------------------------------------------------------------------- **
190 static void debug_init(void);
192 /***************************************************************************
193 Free memory pointed to by global pointers.
194 ****************************************************************************/
196 void gfree_debugsyms(void)
198 TALLOC_FREE(classname_table
);
200 if ( DEBUGLEVEL_CLASS
!= debug_class_list_initial
) {
201 TALLOC_FREE( DEBUGLEVEL_CLASS
);
202 DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
205 TALLOC_FREE(format_bufr
);
207 debug_num_classes
= 0;
209 state
.initialized
= false;
212 /****************************************************************************
213 utility lists registered debug class names's
214 ****************************************************************************/
216 char *debug_list_class_names_and_levels(void)
220 /* prepare strings */
221 for (i
= 0; i
< debug_num_classes
; i
++) {
222 buf
= talloc_asprintf_append(buf
,
226 i
== (debug_num_classes
- 1) ? "\n" : " ");
234 /****************************************************************************
235 Utility to translate names to debug class index's (internal version).
236 ****************************************************************************/
238 static int debug_lookup_classname_int(const char* classname
)
242 if (!classname
) return -1;
244 for (i
=0; i
< debug_num_classes
; i
++) {
245 if (strcmp(classname
, classname_table
[i
])==0)
251 /****************************************************************************
252 Add a new debug class to the system.
253 ****************************************************************************/
255 int debug_add_class(const char *classname
)
259 char **new_name_list
;
265 /* check the init has yet been called */
268 ndx
= debug_lookup_classname_int(classname
);
271 ndx
= debug_num_classes
;
273 if (DEBUGLEVEL_CLASS
== debug_class_list_initial
) {
274 /* Initial loading... */
275 new_class_list
= NULL
;
277 new_class_list
= DEBUGLEVEL_CLASS
;
280 default_level
= DEBUGLEVEL_CLASS
[DBGC_ALL
];
282 new_class_list
= talloc_realloc(NULL
, new_class_list
, int, ndx
+ 1);
285 DEBUGLEVEL_CLASS
= new_class_list
;
287 DEBUGLEVEL_CLASS
[ndx
] = default_level
;
289 new_name_list
= talloc_realloc(NULL
, classname_table
, char *, ndx
+ 1);
292 classname_table
= new_name_list
;
294 classname_table
[ndx
] = talloc_strdup(classname_table
, classname
);
295 if (! classname_table
[ndx
])
298 debug_num_classes
= ndx
+ 1;
303 /****************************************************************************
304 Utility to translate names to debug class index's (public version).
305 ****************************************************************************/
307 int debug_lookup_classname(const char *classname
)
311 if (!classname
|| !*classname
)
314 ndx
= debug_lookup_classname_int(classname
);
319 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
321 return debug_add_class(classname
);
324 /****************************************************************************
325 Dump the current registered debug levels.
326 ****************************************************************************/
328 static void debug_dump_status(int level
)
332 DEBUG(level
, ("INFO: Current debug levels:\n"));
333 for (q
= 0; q
< debug_num_classes
; q
++) {
334 const char *classname
= classname_table
[q
];
335 DEBUGADD(level
, (" %s: %d\n",
337 DEBUGLEVEL_CLASS
[q
]));
341 /****************************************************************************
342 parse the debug levels from smbcontrol. Example debug level parameter:
344 ****************************************************************************/
346 static bool debug_parse_params(char **params
)
355 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
356 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
358 if (isdigit((int)params
[0][0])) {
359 DEBUGLEVEL_CLASS
[DBGC_ALL
] = atoi(params
[0]);
360 i
= 1; /* start processing at the next params */
362 DEBUGLEVEL_CLASS
[DBGC_ALL
] = 0;
363 i
= 0; /* DBGC_ALL not specified OR class name was included */
366 /* Array is debug_num_classes long */
367 for (ndx
= DBGC_ALL
; ndx
< debug_num_classes
; ndx
++) {
368 DEBUGLEVEL_CLASS
[ndx
] = DEBUGLEVEL_CLASS
[DBGC_ALL
];
371 /* Fill in new debug class levels */
372 for (; i
< debug_num_classes
&& params
[i
]; i
++) {
374 if ((class_name
= strtok_r(params
[i
],":", &saveptr
)) &&
375 (class_level
= strtok_r(NULL
, "\0", &saveptr
)) &&
376 ((ndx
= debug_lookup_classname(class_name
)) != -1)) {
377 DEBUGLEVEL_CLASS
[ndx
] = atoi(class_level
);
379 DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params
[i
]));
387 /****************************************************************************
388 Parse the debug levels from smb.conf. Example debug level string:
389 3 tdb:5 printdrivers:7
390 Note: the 1st param has no "name:" preceeding it.
391 ****************************************************************************/
393 bool debug_parse_levels(const char *params_str
)
400 params
= str_list_make(NULL
, params_str
, NULL
);
402 if (debug_parse_params(params
)) {
403 debug_dump_status(5);
412 /* setup for logging of talloc warnings */
413 static void talloc_log_fn(const char *msg
)
415 DEBUG(0,("%s", msg
));
418 void debug_setup_talloc_log(void)
420 talloc_set_log_fn(talloc_log_fn
);
424 /****************************************************************************
425 Init debugging (one time stuff)
426 ****************************************************************************/
428 static void debug_init(void)
432 if (state
.initialized
)
435 state
.initialized
= true;
437 debug_setup_talloc_log();
439 for(p
= default_classname_table
; *p
; p
++) {
442 format_bufr
= talloc_array(NULL
, char, FORMAT_BUFR_SIZE
);
444 smb_panic("debug_init: unable to create buffer");
448 /* This forces in some smb.conf derived values into the debug system.
449 * There are no pointers in this structure, so we can just
450 * structure-assign it in */
451 void debug_set_settings(struct debug_settings
*settings
)
453 state
.settings
= *settings
;
457 control the name of the logfile and whether logging will be to stdout, stderr
458 or a file, and set up syslog
460 new_log indicates the destination for the debug log (an enum in
461 order of precedence - once set to DEBUG_FILE, it is not possible to
462 reset to DEBUG_STDOUT for example. This makes it easy to override
463 for debug to stderr on the command line, as the smb.conf cannot
464 reset it back to file-based logging
466 void setup_logging(const char *prog_name
, enum debug_logtype new_logtype
)
469 if (state
.logtype
< new_logtype
) {
470 state
.logtype
= new_logtype
;
473 state
.prog_name
= prog_name
;
475 reopen_logs_internal();
477 if (state
.logtype
== DEBUG_FILE
) {
479 const char *p
= strrchr_m( prog_name
,'/' );
483 openlog( prog_name
, LOG_PID
, SYSLOG_FACILITY
);
485 /* for old systems that have no facility codes. */
486 openlog( prog_name
, LOG_PID
);
492 /***************************************************************************
493 Set the logfile name.
494 **************************************************************************/
496 void debug_set_logfile(const char *name
)
498 if (name
== NULL
|| *name
== 0) {
499 /* this copes with calls when smb.conf is not loaded yet */
502 TALLOC_FREE(state
.debugf
);
503 state
.debugf
= talloc_strdup(NULL
, name
);
506 static void debug_close_fd(int fd
)
513 bool debug_get_output_is_stderr(void)
515 return (state
.logtype
== DEBUG_DEFAULT_STDERR
) || (state
.logtype
== DEBUG_STDERR
);
518 bool debug_get_output_is_stdout(void)
520 return (state
.logtype
== DEBUG_DEFAULT_STDOUT
) || (state
.logtype
== DEBUG_STDOUT
);
523 void debug_set_callback(void *private_ptr
, debug_callback_fn fn
)
527 state
.logtype
= DEBUG_CALLBACK
;
528 state
.callback_private
= private_ptr
;
531 state
.logtype
= DEBUG_DEFAULT_STDERR
;
532 state
.callback_private
= NULL
;
533 state
.callback
= NULL
;
537 /**************************************************************************
539 note that we now do this unconditionally
540 We attempt to open the new debug fp before closing the old. This means
541 if we run out of fd's we just keep using the old fd rather than aborting.
542 Fix from dgibson@linuxcare.com.
543 **************************************************************************/
546 reopen the log file (usually called because the log file name might have changed)
548 bool reopen_logs_internal(void)
555 if (state
.reopening_logs
) {
559 /* Now clear the SIGHUP induced flag */
560 state
.schedule_reopen_logs
= false;
562 switch (state
.logtype
) {
566 case DEBUG_DEFAULT_STDOUT
:
567 debug_close_fd(state
.fd
);
571 case DEBUG_DEFAULT_STDERR
:
573 debug_close_fd(state
.fd
);
581 oldumask
= umask( 022 );
587 state
.reopening_logs
= true;
589 new_fd
= open( state
.debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
593 DEBUG(0, ("Unable to open new log file '%s': %s\n", state
.debugf
, strerror(errno
)));
594 log_overflow
= false;
599 debug_close_fd(old_fd
);
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.
606 force_check_log_size();
607 (void)umask(oldumask
);
609 /* Take over stderr to catch output into logs */
611 if (dup2(state
.fd
, 2) == -1) {
612 /* Close stderr too, if dup2 can't point it -
613 at the logfile. There really isn't much
614 that can be done on such a fundemental
616 close_low_fds(false, false, true);
620 state
.reopening_logs
= false;
625 /**************************************************************************
626 Force a check of the log size.
627 ***************************************************************************/
629 void force_check_log_size( void )
634 _PUBLIC_
void debug_schedule_reopen_logs(void)
636 state
.schedule_reopen_logs
= true;
640 /***************************************************************************
641 Check to see if there is any need to check if the logfile has grown too big.
642 **************************************************************************/
644 bool need_to_check_log_size( void )
648 if( debug_count
< 100)
651 maxlog
= state
.settings
.max_log_size
* 1024;
652 if ( state
.fd
<=2 || maxlog
<= 0 ) {
659 /**************************************************************************
660 Check to see if the log has grown to be too big.
661 **************************************************************************/
663 void check_log_size( void )
669 * We need to be root to check/change log-file, skip this and let the main
670 * loop check do a new check as root.
673 #if _SAMBA_BUILD_ == 3
674 if (geteuid() != sec_initial_uid())
679 /* We don't check sec_initial_uid() here as it isn't
680 * available in common code and we don't generally
681 * want to rotate and the possibly lose logs in
682 * make test or the build farm */
686 if(log_overflow
|| (!state
.schedule_reopen_logs
&& !need_to_check_log_size())) {
690 maxlog
= state
.settings
.max_log_size
* 1024;
692 if (state
.schedule_reopen_logs
) {
693 (void)reopen_logs_internal();
696 if (maxlog
&& (fstat(state
.fd
, &st
) == 0
697 && st
.st_size
> maxlog
)) {
698 (void)reopen_logs_internal();
699 if (state
.fd
> 2 && (fstat(state
.fd
, &st
) == 0
700 && st
.st_size
> maxlog
)) {
703 if (asprintf(&name
, "%s.old", state
.debugf
) < 0) {
706 (void)rename(state
.debugf
, name
);
708 if (!reopen_logs_internal()) {
709 /* We failed to reopen a log - continue using the old name. */
710 (void)rename(name
, state
.debugf
);
717 * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
721 /* This code should only be reached in very strange
722 * circumstances. If we merely fail to open the new log we
723 * should stick with the old one. ergo this should only be
724 * reached when opening the logs for the first time: at
725 * startup or when the log level is increased from zero.
728 int fd
= open( "/dev/console", O_WRONLY
, 0);
731 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
735 * We cannot continue without a debug file handle.
743 /*************************************************************************
744 Write an debug message on the debugfile.
745 This is called by dbghdr() and format_debug_text().
746 ************************************************************************/
748 int Debug1( const char *format_str
, ... )
751 int old_errno
= errno
;
755 if (state
.logtype
== DEBUG_CALLBACK
) {
758 va_start( ap
, format_str
);
759 ret
= vasprintf( &msg
, format_str
, ap
);
761 if (msg
[ret
- 1] == '\n') {
764 state
.callback(state
.callback_private
, current_msg_level
, msg
);
771 } else if ( state
.logtype
!= DEBUG_FILE
) {
772 va_start( ap
, format_str
);
774 (void)vdprintf( state
.fd
, format_str
, ap
);
781 if( !state
.settings
.syslog_only
)
784 if( state
.fd
<= 0 ) {
785 mode_t oldumask
= umask( 022 );
786 int fd
= open( state
.debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644 );
787 (void)umask( oldumask
);
798 if( current_msg_level
< state
.settings
.syslog
) {
799 /* map debug levels to syslog() priorities
800 * note that not all DEBUG(0, ...) calls are
801 * necessarily errors */
802 static const int priority_map
[4] = {
812 if( current_msg_level
>= ARRAY_SIZE(priority_map
) || current_msg_level
< 0)
813 priority
= LOG_DEBUG
;
815 priority
= priority_map
[current_msg_level
];
818 * Specify the facility to interoperate with other syslog
819 * callers (vfs_full_audit for example).
821 priority
|= SYSLOG_FACILITY
;
823 va_start(ap
, format_str
);
824 ret
= vasprintf(&msgbuf
, format_str
, ap
);
828 syslog(priority
, "%s", msgbuf
);
837 if( !state
.settings
.syslog_only
)
840 va_start( ap
, format_str
);
842 (void)vdprintf( state
.fd
, format_str
, ap
);
853 /**************************************************************************
854 Print the buffer content via Debug1(), then reset the buffer.
857 ****************************************************************************/
859 static void bufr_print( void )
861 format_bufr
[format_pos
] = '\0';
862 (void)Debug1( "%s", format_bufr
);
866 /***************************************************************************
867 Format the debug message text.
869 Input: msg - Text to be added to the "current" debug message text.
873 Notes: The purpose of this is two-fold. First, each call to syslog()
874 (used by Debug1(), see above) generates a new line of syslog
875 output. This is fixed by storing the partial lines until the
876 newline character is encountered. Second, printing the debug
877 message lines when a newline is encountered allows us to add
878 spaces, thus indenting the body of the message and making it
880 **************************************************************************/
882 static void format_debug_text( const char *msg
)
885 bool timestamp
= (state
.logtype
== DEBUG_FILE
&& (state
.settings
.timestamp_logs
));
891 for( i
= 0; msg
[i
]; i
++ ) {
892 /* Indent two spaces at each new line. */
893 if(timestamp
&& 0 == format_pos
) {
894 format_bufr
[0] = format_bufr
[1] = ' ';
898 /* If there's room, copy the character to the format buffer. */
899 if( format_pos
< FORMAT_BUFR_MAX
)
900 format_bufr
[format_pos
++] = msg
[i
];
902 /* If a newline is encountered, print & restart. */
906 /* If the buffer is full dump it out, reset it, and put out a line
907 * continuation indicator.
909 if( format_pos
>= FORMAT_BUFR_MAX
) {
911 (void)Debug1( " +>\n" );
915 /* Just to be safe... */
916 format_bufr
[format_pos
] = '\0';
919 /***************************************************************************
920 Flush debug output, including the format buffer content.
924 ***************************************************************************/
926 void dbgflush( void )
931 /***************************************************************************
932 Print a Debug Header.
934 Input: level - Debug level of the message (not the system-wide debug
936 cls - Debuglevel class of the calling module.
937 file - Pointer to a string containing the name of the file
938 from which this function was called, or an empty string
939 if the __FILE__ macro is not implemented.
940 func - Pointer to a string containing the name of the function
941 from which this function was called, or an empty string
942 if the __FUNCTION__ macro is not implemented.
943 line - line number of the call to dbghdr, assuming __LINE__
946 Output: Always true. This makes it easy to fudge a call to dbghdr()
947 in a macro, since the function can be called as part of a test.
948 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
950 Notes: This function takes care of setting current_msg_level.
952 ****************************************************************************/
954 bool dbghdrclass(int level
, int cls
, const char *location
, const char *func
)
956 /* Ensure we don't lose any real errno value. */
957 int old_errno
= errno
;
960 /* This is a fudge. If there is stuff sitting in the format_bufr, then
961 * the *right* thing to do is to call
962 * format_debug_text( "\n" );
963 * to write the remainder, and then proceed with the new header.
964 * Unfortunately, there are several places in the code at which
965 * the DEBUG() macro is used to build partial lines. That in mind,
966 * we'll work under the assumption that an incomplete line indicates
967 * that a new header is *not* desired.
972 /* Set current_msg_level. */
973 current_msg_level
= level
;
975 /* Don't print a header if we're logging to stdout. */
976 if ( state
.logtype
!= DEBUG_FILE
) {
980 /* Print the header if timestamps are turned on. If parameters are
981 * not yet loaded, then default to timestamps on.
983 if( state
.settings
.timestamp_logs
|| state
.settings
.debug_prefix_timestamp
) {
984 bool verbose
= false;
985 char header_str
[200];
987 header_str
[0] = '\0';
989 if (unlikely(DEBUGLEVEL_CLASS
[ cls
] >= 10)) {
993 if (verbose
|| state
.settings
.debug_pid
)
994 slprintf(header_str
,sizeof(header_str
)-1,", pid=%u",(unsigned int)getpid());
996 if (verbose
|| state
.settings
.debug_uid
) {
997 size_t hs_len
= strlen(header_str
);
998 slprintf(header_str
+ hs_len
,
999 sizeof(header_str
) - 1 - hs_len
,
1000 ", effective(%u, %u), real(%u, %u)",
1001 (unsigned int)geteuid(), (unsigned int)getegid(),
1002 (unsigned int)getuid(), (unsigned int)getgid());
1005 if ((verbose
|| state
.settings
.debug_class
)
1006 && (cls
!= DBGC_ALL
)) {
1007 size_t hs_len
= strlen(header_str
);
1008 slprintf(header_str
+ hs_len
,
1009 sizeof(header_str
) -1 - hs_len
,
1011 classname_table
[cls
]);
1014 /* Print it all out at once to prevent split syslog output. */
1015 if( state
.settings
.debug_prefix_timestamp
) {
1016 char *time_str
= current_timestring(NULL
,
1017 state
.settings
.debug_hires_timestamp
);
1018 (void)Debug1( "[%s, %2d%s] ",
1021 talloc_free(time_str
);
1023 char *time_str
= current_timestring(NULL
,
1024 state
.settings
.debug_hires_timestamp
);
1025 (void)Debug1( "[%s, %2d%s] %s(%s)\n",
1027 level
, header_str
, location
, func
);
1028 talloc_free(time_str
);
1036 /***************************************************************************
1037 Add text to the body of the "current" debug message via the format buffer.
1039 Input: format_str - Format string, as used in printf(), et. al.
1040 ... - Variable argument list.
1042 ..or.. va_alist - Old style variable parameter list starting point.
1044 Output: Always true. See dbghdr() for more info, though this is not
1045 likely to be used in the same way.
1047 ***************************************************************************/
1049 bool dbgtext( const char *format_str
, ... )
1052 char *msgbuf
= NULL
;
1056 va_start(ap
, format_str
);
1057 res
= vasprintf(&msgbuf
, format_str
, ap
);
1061 format_debug_text(msgbuf
);
1070 /* the registered mutex handlers */
1073 struct debug_ops ops
;
1077 log suspicious usage - print comments and backtrace
1079 _PUBLIC_
void log_suspicious_usage(const char *from
, const char *info
)
1081 if (!debug_handlers
.ops
.log_suspicious_usage
) return;
1083 debug_handlers
.ops
.log_suspicious_usage(from
, info
);
1088 print suspicious usage - print comments and backtrace
1090 _PUBLIC_
void print_suspicious_usage(const char* from
, const char* info
)
1092 if (!debug_handlers
.ops
.print_suspicious_usage
) return;
1094 debug_handlers
.ops
.print_suspicious_usage(from
, info
);
1097 _PUBLIC_
uint32_t get_task_id(void)
1099 if (debug_handlers
.ops
.get_task_id
) {
1100 return debug_handlers
.ops
.get_task_id();
1105 _PUBLIC_
void log_task_id(void)
1107 if (!debug_handlers
.ops
.log_task_id
) return;
1109 if (!reopen_logs_internal()) return;
1111 debug_handlers
.ops
.log_task_id(state
.fd
);
1115 register a set of debug handlers.
1117 _PUBLIC_
void register_debug_handlers(const char *name
, struct debug_ops
*ops
)
1119 debug_handlers
.name
= name
;
1120 debug_handlers
.ops
= *ops
;