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.
105 used to check if the user specified a
106 logfile on the command line
108 bool override_logfile
;
111 * This is to allow reading of DEBUGLEVEL_CLASS before the debug
112 * system has been initialized.
114 static const int debug_class_list_initial
[DBGC_MAX_FIXED
+ 1];
116 static int debug_num_classes
= 0;
117 int *DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
120 /* -------------------------------------------------------------------------- **
121 * Internal variables.
123 * debug_count - Number of debug messages that have been output.
124 * Used to check log size.
126 * current_msg_level - Internal copy of the message debug level. Written by
127 * dbghdr() and read by Debug1().
129 * format_bufr - Used to format debug messages. The dbgtext() function
130 * prints debug messages to a string, and then passes the
131 * string to format_debug_text(), which uses format_bufr
132 * to build the formatted output.
134 * format_pos - Marks the first free byte of the format_bufr.
137 * log_overflow - When this variable is true, never attempt to check the
138 * size of the log. This is a hack, so that we can write
139 * a message using DEBUG, from open_logs() when we
140 * are unable to open a new log file for some reason.
143 static int debug_count
= 0;
144 static int current_msg_level
= 0;
145 static char *format_bufr
= NULL
;
146 static size_t format_pos
= 0;
147 static bool log_overflow
= false;
150 * Define all the debug class selection names here. Names *MUST NOT* contain
151 * white space. There must be one name for each DBGC_<class name>, and they
152 * must be in the table in the order of DBGC_<class name>..
154 static const char *default_classname_table
[] = {
155 "all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
156 "tdb", /* DBGC_TDB */
157 "printdrivers", /* DBGC_PRINTDRIVERS */
158 "lanman", /* DBGC_LANMAN */
159 "smb", /* DBGC_SMB */
160 "rpc_parse", /* DBGC_RPC_PARSE */
161 "rpc_srv", /* DBGC_RPC_SRV */
162 "rpc_cli", /* DBGC_RPC_CLI */
163 "passdb", /* DBGC_PASSDB */
164 "sam", /* DBGC_SAM */
165 "auth", /* DBGC_AUTH */
166 "winbind", /* DBGC_WINBIND */
167 "vfs", /* DBGC_VFS */
168 "idmap", /* DBGC_IDMAP */
169 "quota", /* DBGC_QUOTA */
170 "acls", /* DBGC_ACLS */
171 "locking", /* DBGC_LOCKING */
172 "msdfs", /* DBGC_MSDFS */
173 "dmapi", /* DBGC_DMAPI */
174 "registry", /* DBGC_REGISTRY */
175 "scavenger", /* DBGC_SCAVENGER */
176 "dns", /* DBGC_DNS */
177 "ldb", /* DBGC_LDB */
181 static char **classname_table
= NULL
;
184 /* -------------------------------------------------------------------------- **
188 static void debug_init(void);
190 /***************************************************************************
191 Free memory pointed to by global pointers.
192 ****************************************************************************/
194 void gfree_debugsyms(void)
196 TALLOC_FREE(classname_table
);
198 if ( DEBUGLEVEL_CLASS
!= debug_class_list_initial
) {
199 TALLOC_FREE( DEBUGLEVEL_CLASS
);
200 DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
203 TALLOC_FREE(format_bufr
);
205 debug_num_classes
= 0;
207 state
.initialized
= false;
210 /****************************************************************************
211 utility lists registered debug class names's
212 ****************************************************************************/
214 char *debug_list_class_names_and_levels(void)
218 /* prepare strings */
219 for (i
= 0; i
< debug_num_classes
; i
++) {
220 buf
= talloc_asprintf_append(buf
,
224 i
== (debug_num_classes
- 1) ? "\n" : " ");
232 /****************************************************************************
233 Utility to translate names to debug class index's (internal version).
234 ****************************************************************************/
236 static int debug_lookup_classname_int(const char* classname
)
240 if (!classname
) return -1;
242 for (i
=0; i
< debug_num_classes
; i
++) {
243 if (strcmp(classname
, classname_table
[i
])==0)
249 /****************************************************************************
250 Add a new debug class to the system.
251 ****************************************************************************/
253 int debug_add_class(const char *classname
)
257 char **new_name_list
;
263 /* check the init has yet been called */
266 ndx
= debug_lookup_classname_int(classname
);
269 ndx
= debug_num_classes
;
271 if (DEBUGLEVEL_CLASS
== debug_class_list_initial
) {
272 /* Initial loading... */
273 new_class_list
= NULL
;
275 new_class_list
= DEBUGLEVEL_CLASS
;
278 default_level
= DEBUGLEVEL_CLASS
[DBGC_ALL
];
280 new_class_list
= talloc_realloc(NULL
, new_class_list
, int, ndx
+ 1);
283 DEBUGLEVEL_CLASS
= new_class_list
;
285 DEBUGLEVEL_CLASS
[ndx
] = default_level
;
287 new_name_list
= talloc_realloc(NULL
, classname_table
, char *, ndx
+ 1);
290 classname_table
= new_name_list
;
292 classname_table
[ndx
] = talloc_strdup(classname_table
, classname
);
293 if (! classname_table
[ndx
])
296 debug_num_classes
= ndx
+ 1;
301 /****************************************************************************
302 Utility to translate names to debug class index's (public version).
303 ****************************************************************************/
305 int debug_lookup_classname(const char *classname
)
309 if (!classname
|| !*classname
)
312 ndx
= debug_lookup_classname_int(classname
);
317 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
319 return debug_add_class(classname
);
322 /****************************************************************************
323 Dump the current registered debug levels.
324 ****************************************************************************/
326 static void debug_dump_status(int level
)
330 DEBUG(level
, ("INFO: Current debug levels:\n"));
331 for (q
= 0; q
< debug_num_classes
; q
++) {
332 const char *classname
= classname_table
[q
];
333 DEBUGADD(level
, (" %s: %d\n",
335 DEBUGLEVEL_CLASS
[q
]));
339 /****************************************************************************
340 parse the debug levels from smbcontrol. Example debug level parameter:
342 ****************************************************************************/
344 static bool debug_parse_params(char **params
)
353 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
354 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
356 if (isdigit((int)params
[0][0])) {
357 DEBUGLEVEL_CLASS
[DBGC_ALL
] = atoi(params
[0]);
358 i
= 1; /* start processing at the next params */
360 DEBUGLEVEL_CLASS
[DBGC_ALL
] = 0;
361 i
= 0; /* DBGC_ALL not specified OR class name was included */
364 /* Array is debug_num_classes long */
365 for (ndx
= DBGC_ALL
; ndx
< debug_num_classes
; ndx
++) {
366 DEBUGLEVEL_CLASS
[ndx
] = DEBUGLEVEL_CLASS
[DBGC_ALL
];
369 /* Fill in new debug class levels */
370 for (; i
< debug_num_classes
&& params
[i
]; i
++) {
372 if ((class_name
= strtok_r(params
[i
],":", &saveptr
)) &&
373 (class_level
= strtok_r(NULL
, "\0", &saveptr
)) &&
374 ((ndx
= debug_lookup_classname(class_name
)) != -1)) {
375 DEBUGLEVEL_CLASS
[ndx
] = atoi(class_level
);
377 DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params
[i
]));
385 /****************************************************************************
386 Parse the debug levels from smb.conf. Example debug level string:
387 3 tdb:5 printdrivers:7
388 Note: the 1st param has no "name:" preceeding it.
389 ****************************************************************************/
391 bool debug_parse_levels(const char *params_str
)
398 params
= str_list_make(NULL
, params_str
, NULL
);
400 if (debug_parse_params(params
)) {
401 debug_dump_status(5);
410 /* setup for logging of talloc warnings */
411 static void talloc_log_fn(const char *msg
)
413 DEBUG(0,("%s", msg
));
416 void debug_setup_talloc_log(void)
418 talloc_set_log_fn(talloc_log_fn
);
422 /****************************************************************************
423 Init debugging (one time stuff)
424 ****************************************************************************/
426 static void debug_init(void)
430 if (state
.initialized
)
433 state
.initialized
= true;
435 debug_setup_talloc_log();
437 for(p
= default_classname_table
; *p
; p
++) {
440 format_bufr
= talloc_array(NULL
, char, FORMAT_BUFR_SIZE
);
442 smb_panic("debug_init: unable to create buffer");
446 /* This forces in some smb.conf derived values into the debug system.
447 * There are no pointers in this structure, so we can just
448 * structure-assign it in */
449 void debug_set_settings(struct debug_settings
*settings
)
451 state
.settings
= *settings
;
455 control the name of the logfile and whether logging will be to stdout, stderr
456 or a file, and set up syslog
458 new_log indicates the destination for the debug log (an enum in
459 order of precedence - once set to DEBUG_FILE, it is not possible to
460 reset to DEBUG_STDOUT for example. This makes it easy to override
461 for debug to stderr on the command line, as the smb.conf cannot
462 reset it back to file-based logging
464 void setup_logging(const char *prog_name
, enum debug_logtype new_logtype
)
467 if (state
.logtype
< new_logtype
) {
468 state
.logtype
= new_logtype
;
471 state
.prog_name
= prog_name
;
473 reopen_logs_internal();
475 if (state
.logtype
== DEBUG_FILE
) {
477 const char *p
= strrchr_m( prog_name
,'/' );
481 openlog( prog_name
, LOG_PID
, SYSLOG_FACILITY
);
483 /* for old systems that have no facility codes. */
484 openlog( prog_name
, LOG_PID
);
490 /***************************************************************************
491 Set the logfile name.
492 **************************************************************************/
494 void debug_set_logfile(const char *name
)
496 if (name
== NULL
|| *name
== 0) {
497 /* this copes with calls when smb.conf is not loaded yet */
500 TALLOC_FREE(state
.debugf
);
501 state
.debugf
= talloc_strdup(NULL
, name
);
504 static void debug_close_fd(int fd
)
511 bool debug_get_output_is_stderr(void)
513 return (state
.logtype
== DEBUG_DEFAULT_STDERR
) || (state
.logtype
== DEBUG_STDERR
);
516 bool debug_get_output_is_stdout(void)
518 return (state
.logtype
== DEBUG_DEFAULT_STDOUT
) || (state
.logtype
== DEBUG_STDOUT
);
521 void debug_set_callback(void *private_ptr
, debug_callback_fn fn
)
525 state
.logtype
= DEBUG_CALLBACK
;
526 state
.callback_private
= private_ptr
;
529 state
.logtype
= DEBUG_DEFAULT_STDERR
;
530 state
.callback_private
= NULL
;
531 state
.callback
= NULL
;
535 /**************************************************************************
537 note that we now do this unconditionally
538 We attempt to open the new debug fp before closing the old. This means
539 if we run out of fd's we just keep using the old fd rather than aborting.
540 Fix from dgibson@linuxcare.com.
541 **************************************************************************/
544 reopen the log file (usually called because the log file name might have changed)
546 bool reopen_logs_internal(void)
553 if (state
.reopening_logs
) {
557 /* Now clear the SIGHUP induced flag */
558 state
.schedule_reopen_logs
= false;
560 switch (state
.logtype
) {
564 case DEBUG_DEFAULT_STDOUT
:
565 debug_close_fd(state
.fd
);
569 case DEBUG_DEFAULT_STDERR
:
571 debug_close_fd(state
.fd
);
579 oldumask
= umask( 022 );
585 state
.reopening_logs
= true;
587 new_fd
= open( state
.debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
591 DEBUG(0, ("Unable to open new log file '%s': %s\n", state
.debugf
, strerror(errno
)));
592 log_overflow
= false;
597 debug_close_fd(old_fd
);
600 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
601 * to fix problem where smbd's that generate less
602 * than 100 messages keep growing the log.
604 force_check_log_size();
605 (void)umask(oldumask
);
607 /* Take over stderr to catch output into logs */
609 if (dup2(state
.fd
, 2) == -1) {
610 /* Close stderr too, if dup2 can't point it -
611 at the logfile. There really isn't much
612 that can be done on such a fundemental
614 close_low_fds(false, false, true);
618 state
.reopening_logs
= false;
623 /**************************************************************************
624 Force a check of the log size.
625 ***************************************************************************/
627 void force_check_log_size( void )
632 _PUBLIC_
void debug_schedule_reopen_logs(void)
634 state
.schedule_reopen_logs
= true;
638 /***************************************************************************
639 Check to see if there is any need to check if the logfile has grown too big.
640 **************************************************************************/
642 bool need_to_check_log_size( void )
646 if( debug_count
< 100)
649 maxlog
= state
.settings
.max_log_size
* 1024;
650 if ( state
.fd
<=2 || maxlog
<= 0 ) {
657 /**************************************************************************
658 Check to see if the log has grown to be too big.
659 **************************************************************************/
661 void check_log_size( void )
667 * We need to be root to check/change log-file, skip this and let the main
668 * loop check do a new check as root.
671 #if _SAMBA_BUILD_ == 3
672 if (geteuid() != sec_initial_uid())
677 /* We don't check sec_initial_uid() here as it isn't
678 * available in common code and we don't generally
679 * want to rotate and the possibly lose logs in
680 * make test or the build farm */
684 if(log_overflow
|| (!state
.schedule_reopen_logs
&& !need_to_check_log_size())) {
688 maxlog
= state
.settings
.max_log_size
* 1024;
690 if (state
.schedule_reopen_logs
) {
691 (void)reopen_logs_internal();
694 if (maxlog
&& (fstat(state
.fd
, &st
) == 0
695 && st
.st_size
> maxlog
)) {
696 (void)reopen_logs_internal();
697 if (state
.fd
> 2 && (fstat(state
.fd
, &st
) == 0
698 && st
.st_size
> maxlog
)) {
701 if (asprintf(&name
, "%s.old", state
.debugf
) < 0) {
704 (void)rename(state
.debugf
, name
);
706 if (!reopen_logs_internal()) {
707 /* We failed to reopen a log - continue using the old name. */
708 (void)rename(name
, state
.debugf
);
715 * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
719 /* This code should only be reached in very strange
720 * circumstances. If we merely fail to open the new log we
721 * should stick with the old one. ergo this should only be
722 * reached when opening the logs for the first time: at
723 * startup or when the log level is increased from zero.
726 int fd
= open( "/dev/console", O_WRONLY
, 0);
729 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
733 * We cannot continue without a debug file handle.
741 /*************************************************************************
742 Write an debug message on the debugfile.
743 This is called by dbghdr() and format_debug_text().
744 ************************************************************************/
746 int Debug1( const char *format_str
, ... )
749 int old_errno
= errno
;
753 if (state
.logtype
== DEBUG_CALLBACK
) {
756 va_start( ap
, format_str
);
757 ret
= vasprintf( &msg
, format_str
, ap
);
759 if (msg
[ret
- 1] == '\n') {
762 state
.callback(state
.callback_private
, current_msg_level
, msg
);
769 } else if ( state
.logtype
!= DEBUG_FILE
) {
770 va_start( ap
, format_str
);
772 (void)vdprintf( state
.fd
, format_str
, ap
);
779 if( !state
.settings
.syslog_only
)
782 if( state
.fd
<= 0 ) {
783 mode_t oldumask
= umask( 022 );
784 int fd
= open( state
.debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644 );
785 (void)umask( oldumask
);
796 if( current_msg_level
< state
.settings
.syslog
) {
797 /* map debug levels to syslog() priorities
798 * note that not all DEBUG(0, ...) calls are
799 * necessarily errors */
800 static const int priority_map
[4] = {
810 if( current_msg_level
>= ARRAY_SIZE(priority_map
) || current_msg_level
< 0)
811 priority
= LOG_DEBUG
;
813 priority
= priority_map
[current_msg_level
];
816 * Specify the facility to interoperate with other syslog
817 * callers (vfs_full_audit for example).
819 priority
|= SYSLOG_FACILITY
;
821 va_start(ap
, format_str
);
822 ret
= vasprintf(&msgbuf
, format_str
, ap
);
826 syslog(priority
, "%s", msgbuf
);
835 if( !state
.settings
.syslog_only
)
838 va_start( ap
, format_str
);
840 (void)vdprintf( state
.fd
, format_str
, ap
);
851 /**************************************************************************
852 Print the buffer content via Debug1(), then reset the buffer.
855 ****************************************************************************/
857 static void bufr_print( void )
859 format_bufr
[format_pos
] = '\0';
860 (void)Debug1( "%s", format_bufr
);
864 /***************************************************************************
865 Format the debug message text.
867 Input: msg - Text to be added to the "current" debug message text.
871 Notes: The purpose of this is two-fold. First, each call to syslog()
872 (used by Debug1(), see above) generates a new line of syslog
873 output. This is fixed by storing the partial lines until the
874 newline character is encountered. Second, printing the debug
875 message lines when a newline is encountered allows us to add
876 spaces, thus indenting the body of the message and making it
878 **************************************************************************/
880 static void format_debug_text( const char *msg
)
883 bool timestamp
= (state
.logtype
== DEBUG_FILE
&& (state
.settings
.timestamp_logs
));
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] = ' ';
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
];
900 /* If a newline is encountered, print & restart. */
904 /* If the buffer is full dump it out, reset it, and put out a line
905 * continuation indicator.
907 if( format_pos
>= FORMAT_BUFR_MAX
) {
909 (void)Debug1( " +>\n" );
913 /* Just to be safe... */
914 format_bufr
[format_pos
] = '\0';
917 /***************************************************************************
918 Flush debug output, including the format buffer content.
922 ***************************************************************************/
924 void dbgflush( void )
929 /***************************************************************************
930 Print a Debug Header.
932 Input: level - Debug level of the message (not the system-wide debug
934 cls - Debuglevel class of the calling module.
935 file - Pointer to a string containing the name of the file
936 from which this function was called, or an empty string
937 if the __FILE__ macro is not implemented.
938 func - Pointer to a string containing the name of the function
939 from which this function was called, or an empty string
940 if the __FUNCTION__ macro is not implemented.
941 line - line number of the call to dbghdr, assuming __LINE__
944 Output: Always true. This makes it easy to fudge a call to dbghdr()
945 in a macro, since the function can be called as part of a test.
946 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
948 Notes: This function takes care of setting current_msg_level.
950 ****************************************************************************/
952 bool dbghdrclass(int level
, int cls
, const char *location
, const char *func
)
954 /* Ensure we don't lose any real errno value. */
955 int old_errno
= errno
;
958 /* This is a fudge. If there is stuff sitting in the format_bufr, then
959 * the *right* thing to do is to call
960 * format_debug_text( "\n" );
961 * to write the remainder, and then proceed with the new header.
962 * Unfortunately, there are several places in the code at which
963 * the DEBUG() macro is used to build partial lines. That in mind,
964 * we'll work under the assumption that an incomplete line indicates
965 * that a new header is *not* desired.
970 /* Set current_msg_level. */
971 current_msg_level
= level
;
973 /* Don't print a header if we're logging to stdout. */
974 if ( state
.logtype
!= DEBUG_FILE
) {
978 /* Print the header if timestamps are turned on. If parameters are
979 * not yet loaded, then default to timestamps on.
981 if( state
.settings
.timestamp_logs
|| state
.settings
.debug_prefix_timestamp
) {
982 bool verbose
= false;
983 char header_str
[200];
985 header_str
[0] = '\0';
987 if (unlikely(DEBUGLEVEL_CLASS
[ cls
] >= 10)) {
991 if (verbose
|| state
.settings
.debug_pid
)
992 slprintf(header_str
,sizeof(header_str
)-1,", pid=%u",(unsigned int)getpid());
994 if (verbose
|| state
.settings
.debug_uid
) {
995 size_t hs_len
= strlen(header_str
);
996 slprintf(header_str
+ hs_len
,
997 sizeof(header_str
) - 1 - hs_len
,
998 ", effective(%u, %u), real(%u, %u)",
999 (unsigned int)geteuid(), (unsigned int)getegid(),
1000 (unsigned int)getuid(), (unsigned int)getgid());
1003 if ((verbose
|| state
.settings
.debug_class
)
1004 && (cls
!= DBGC_ALL
)) {
1005 size_t hs_len
= strlen(header_str
);
1006 slprintf(header_str
+ hs_len
,
1007 sizeof(header_str
) -1 - hs_len
,
1009 classname_table
[cls
]);
1012 /* Print it all out at once to prevent split syslog output. */
1013 if( state
.settings
.debug_prefix_timestamp
) {
1014 char *time_str
= current_timestring(NULL
,
1015 state
.settings
.debug_hires_timestamp
);
1016 (void)Debug1( "[%s, %2d%s] ",
1019 talloc_free(time_str
);
1021 char *time_str
= current_timestring(NULL
,
1022 state
.settings
.debug_hires_timestamp
);
1023 (void)Debug1( "[%s, %2d%s] %s(%s)\n",
1025 level
, header_str
, location
, func
);
1026 talloc_free(time_str
);
1034 /***************************************************************************
1035 Add text to the body of the "current" debug message via the format buffer.
1037 Input: format_str - Format string, as used in printf(), et. al.
1038 ... - Variable argument list.
1040 ..or.. va_alist - Old style variable parameter list starting point.
1042 Output: Always true. See dbghdr() for more info, though this is not
1043 likely to be used in the same way.
1045 ***************************************************************************/
1047 bool dbgtext( const char *format_str
, ... )
1050 char *msgbuf
= NULL
;
1054 va_start(ap
, format_str
);
1055 res
= vasprintf(&msgbuf
, format_str
, ap
);
1059 format_debug_text(msgbuf
);
1068 /* the registered mutex handlers */
1071 struct debug_ops ops
;
1075 log suspicious usage - print comments and backtrace
1077 _PUBLIC_
void log_suspicious_usage(const char *from
, const char *info
)
1079 if (!debug_handlers
.ops
.log_suspicious_usage
) return;
1081 debug_handlers
.ops
.log_suspicious_usage(from
, info
);
1086 print suspicious usage - print comments and backtrace
1088 _PUBLIC_
void print_suspicious_usage(const char* from
, const char* info
)
1090 if (!debug_handlers
.ops
.print_suspicious_usage
) return;
1092 debug_handlers
.ops
.print_suspicious_usage(from
, info
);
1095 _PUBLIC_
uint32_t get_task_id(void)
1097 if (debug_handlers
.ops
.get_task_id
) {
1098 return debug_handlers
.ops
.get_task_id();
1103 _PUBLIC_
void log_task_id(void)
1105 if (!debug_handlers
.ops
.log_task_id
) return;
1107 if (!reopen_logs_internal()) return;
1109 debug_handlers
.ops
.log_task_id(state
.fd
);
1113 register a set of debug handlers.
1115 _PUBLIC_
void register_debug_handlers(const char *name
, struct debug_ops
*ops
)
1117 debug_handlers
.name
= name
;
1118 debug_handlers
.ops
= *ops
;