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_basic.h"
26 #include "lib/util/close_low_fd.h"
28 /* define what facility to use for syslog */
29 #ifndef SYSLOG_FACILITY
30 #define SYSLOG_FACILITY LOG_DAEMON
33 /* -------------------------------------------------------------------------- **
36 * FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
37 * format_bufr[FORMAT_BUFR_MAX] should always be reserved
38 * for a terminating null byte.
41 #define FORMAT_BUFR_SIZE 1024
42 #define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
44 /* -------------------------------------------------------------------------- **
45 * This module implements Samba's debugging utility.
47 * The syntax of a debugging log file is represented as:
49 * <debugfile> :== { <debugmsg> }
51 * <debugmsg> :== <debughdr> '\n' <debugtext>
53 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
55 * <debugtext> :== { <debugline> }
57 * <debugline> :== TEXT '\n'
59 * TEXT is a string of characters excluding the newline character.
60 * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
61 * TIME is a timestamp.
62 * FILENAME is the name of the file from which the debug message was generated.
63 * FUNCTION is the function from which the debug message was generated.
65 * Basically, what that all means is:
67 * - A debugging log file is made up of debug messages.
69 * - Each debug message is made up of a header and text. The header is
70 * separated from the text by a newline.
72 * - The header begins with the timestamp and debug level of the message
73 * enclosed in brackets. The filename and function from which the
74 * message was generated may follow. The filename is terminated by a
75 * colon, and the function name is terminated by parenthesis.
77 * - The message text is made up of zero or more lines, each terminated by
81 /* state variables for the debug system */
84 int fd
; /* The log file handle */
85 enum debug_logtype logtype
; /* The type of logging we are doing: eg stdout, file, stderr */
86 const char *prog_name
;
88 bool schedule_reopen_logs
;
90 struct debug_settings settings
;
92 debug_callback_fn callback
;
93 void *callback_private
;
96 .timestamp_logs
= true
98 .fd
= 2 /* stderr by default */
101 /* -------------------------------------------------------------------------- **
102 * External variables.
106 used to check if the user specified a
107 logfile on the command line
109 bool override_logfile
;
112 * This is to allow reading of DEBUGLEVEL_CLASS before the debug
113 * system has been initialized.
115 static const int debug_class_list_initial
[DBGC_MAX_FIXED
+ 1];
117 static int debug_num_classes
= 0;
118 int *DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
121 /* -------------------------------------------------------------------------- **
122 * Internal variables.
124 * debug_count - Number of debug messages that have been output.
125 * Used to check log size.
127 * current_msg_level - Internal copy of the message debug level. Written by
128 * dbghdr() and read by Debug1().
130 * format_bufr - Used to format debug messages. The dbgtext() function
131 * prints debug messages to a string, and then passes the
132 * string to format_debug_text(), which uses format_bufr
133 * to build the formatted output.
135 * format_pos - Marks the first free byte of the format_bufr.
138 * log_overflow - When this variable is true, never attempt to check the
139 * size of the log. This is a hack, so that we can write
140 * a message using DEBUG, from open_logs() when we
141 * are unable to open a new log file for some reason.
144 static int debug_count
= 0;
145 static int current_msg_level
= 0;
146 static char format_bufr
[FORMAT_BUFR_SIZE
];
147 static size_t format_pos
= 0;
148 static bool log_overflow
= false;
151 * Define all the debug class selection names here. Names *MUST NOT* contain
152 * white space. There must be one name for each DBGC_<class name>, and they
153 * must be in the table in the order of DBGC_<class name>..
155 static const char *default_classname_table
[] = {
156 "all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
157 "tdb", /* DBGC_TDB */
158 "printdrivers", /* DBGC_PRINTDRIVERS */
159 "lanman", /* DBGC_LANMAN */
160 "smb", /* DBGC_SMB */
161 "rpc_parse", /* DBGC_RPC_PARSE */
162 "rpc_srv", /* DBGC_RPC_SRV */
163 "rpc_cli", /* DBGC_RPC_CLI */
164 "passdb", /* DBGC_PASSDB */
165 "sam", /* DBGC_SAM */
166 "auth", /* DBGC_AUTH */
167 "winbind", /* DBGC_WINBIND */
168 "vfs", /* DBGC_VFS */
169 "idmap", /* DBGC_IDMAP */
170 "quota", /* DBGC_QUOTA */
171 "acls", /* DBGC_ACLS */
172 "locking", /* DBGC_LOCKING */
173 "msdfs", /* DBGC_MSDFS */
174 "dmapi", /* DBGC_DMAPI */
175 "registry", /* DBGC_REGISTRY */
176 "scavenger", /* DBGC_SCAVENGER */
177 "dns", /* DBGC_DNS */
178 "ldb", /* DBGC_LDB */
182 static char **classname_table
= NULL
;
185 /* -------------------------------------------------------------------------- **
189 static void debug_init(void);
191 /***************************************************************************
192 Free memory pointed to by global pointers.
193 ****************************************************************************/
195 void gfree_debugsyms(void)
197 TALLOC_FREE(classname_table
);
199 if ( DEBUGLEVEL_CLASS
!= debug_class_list_initial
) {
200 TALLOC_FREE( DEBUGLEVEL_CLASS
);
201 DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
204 debug_num_classes
= 0;
206 state
.initialized
= false;
209 /****************************************************************************
210 utility lists registered debug class names's
211 ****************************************************************************/
213 char *debug_list_class_names_and_levels(void)
217 /* prepare strings */
218 for (i
= 0; i
< debug_num_classes
; i
++) {
219 buf
= talloc_asprintf_append(buf
,
223 i
== (debug_num_classes
- 1) ? "\n" : " ");
231 /****************************************************************************
232 Utility to translate names to debug class index's (internal version).
233 ****************************************************************************/
235 static int debug_lookup_classname_int(const char* classname
)
239 if (!classname
) return -1;
241 for (i
=0; i
< debug_num_classes
; i
++) {
242 if (strcmp(classname
, classname_table
[i
])==0)
248 /****************************************************************************
249 Add a new debug class to the system.
250 ****************************************************************************/
252 int debug_add_class(const char *classname
)
256 char **new_name_list
;
262 /* check the init has yet been called */
265 ndx
= debug_lookup_classname_int(classname
);
268 ndx
= debug_num_classes
;
270 if (DEBUGLEVEL_CLASS
== debug_class_list_initial
) {
271 /* Initial loading... */
272 new_class_list
= NULL
;
274 new_class_list
= DEBUGLEVEL_CLASS
;
277 default_level
= DEBUGLEVEL_CLASS
[DBGC_ALL
];
279 new_class_list
= talloc_realloc(NULL
, new_class_list
, int, ndx
+ 1);
282 DEBUGLEVEL_CLASS
= new_class_list
;
284 DEBUGLEVEL_CLASS
[ndx
] = default_level
;
286 new_name_list
= talloc_realloc(NULL
, classname_table
, char *, ndx
+ 1);
289 classname_table
= new_name_list
;
291 classname_table
[ndx
] = talloc_strdup(classname_table
, classname
);
292 if (! classname_table
[ndx
])
295 debug_num_classes
= ndx
+ 1;
300 /****************************************************************************
301 Utility to translate names to debug class index's (public version).
302 ****************************************************************************/
304 int debug_lookup_classname(const char *classname
)
308 if (!classname
|| !*classname
)
311 ndx
= debug_lookup_classname_int(classname
);
316 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
318 return debug_add_class(classname
);
321 /****************************************************************************
322 Dump the current registered debug levels.
323 ****************************************************************************/
325 static void debug_dump_status(int level
)
329 DEBUG(level
, ("INFO: Current debug levels:\n"));
330 for (q
= 0; q
< debug_num_classes
; q
++) {
331 const char *classname
= classname_table
[q
];
332 DEBUGADD(level
, (" %s: %d\n",
334 DEBUGLEVEL_CLASS
[q
]));
338 static bool debug_parse_param(char *param
)
345 class_name
= strtok_r(param
, ":", &saveptr
);
346 if (class_name
== NULL
) {
350 class_level
= strtok_r(NULL
, "\0", &saveptr
);
351 if (class_level
== NULL
) {
355 ndx
= debug_lookup_classname(class_name
);
360 DEBUGLEVEL_CLASS
[ndx
] = atoi(class_level
);
365 /****************************************************************************
366 Parse the debug levels from smb.conf. Example debug level string:
367 3 tdb:5 printdrivers:7
368 Note: the 1st param has no "name:" preceeding it.
369 ****************************************************************************/
371 bool debug_parse_levels(const char *params_str
)
373 size_t str_len
= strlen(params_str
);
381 memcpy(str
, params_str
, str_len
+1);
383 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
388 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
389 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
391 if (isdigit(tok
[0])) {
392 DEBUGLEVEL_CLASS
[DBGC_ALL
] = atoi(tok
);
393 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
395 DEBUGLEVEL_CLASS
[DBGC_ALL
] = 0;
398 /* Array is debug_num_classes long */
399 for (i
= DBGC_ALL
+1; i
< debug_num_classes
; i
++) {
400 DEBUGLEVEL_CLASS
[i
] = DEBUGLEVEL_CLASS
[DBGC_ALL
];
403 while (tok
!= NULL
) {
406 ok
= debug_parse_param(tok
);
408 DEBUG(0,("debug_parse_params: unrecognized debug "
409 "class name or format [%s]\n", tok
));
413 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
416 debug_dump_status(5);
421 /* setup for logging of talloc warnings */
422 static void talloc_log_fn(const char *msg
)
424 DEBUG(0,("%s", msg
));
427 void debug_setup_talloc_log(void)
429 talloc_set_log_fn(talloc_log_fn
);
433 /****************************************************************************
434 Init debugging (one time stuff)
435 ****************************************************************************/
437 static void debug_init(void)
441 if (state
.initialized
)
444 state
.initialized
= true;
446 debug_setup_talloc_log();
448 for(p
= default_classname_table
; *p
; p
++) {
453 /* This forces in some smb.conf derived values into the debug system.
454 * There are no pointers in this structure, so we can just
455 * structure-assign it in */
456 void debug_set_settings(struct debug_settings
*settings
)
458 state
.settings
= *settings
;
462 control the name of the logfile and whether logging will be to stdout, stderr
463 or a file, and set up syslog
465 new_log indicates the destination for the debug log (an enum in
466 order of precedence - once set to DEBUG_FILE, it is not possible to
467 reset to DEBUG_STDOUT for example. This makes it easy to override
468 for debug to stderr on the command line, as the smb.conf cannot
469 reset it back to file-based logging
471 void setup_logging(const char *prog_name
, enum debug_logtype new_logtype
)
474 if (state
.logtype
< new_logtype
) {
475 state
.logtype
= new_logtype
;
478 state
.prog_name
= prog_name
;
480 reopen_logs_internal();
482 if (state
.logtype
== DEBUG_FILE
) {
484 const char *p
= strrchr(prog_name
, '/');
488 openlog( prog_name
, LOG_PID
, SYSLOG_FACILITY
);
490 /* for old systems that have no facility codes. */
491 openlog( prog_name
, LOG_PID
);
497 /***************************************************************************
498 Set the logfile name.
499 **************************************************************************/
501 void debug_set_logfile(const char *name
)
503 if (name
== NULL
|| *name
== 0) {
504 /* this copes with calls when smb.conf is not loaded yet */
507 TALLOC_FREE(state
.debugf
);
508 state
.debugf
= talloc_strdup(NULL
, name
);
511 static void debug_close_fd(int fd
)
518 bool debug_get_output_is_stderr(void)
520 return (state
.logtype
== DEBUG_DEFAULT_STDERR
) || (state
.logtype
== DEBUG_STDERR
);
523 bool debug_get_output_is_stdout(void)
525 return (state
.logtype
== DEBUG_DEFAULT_STDOUT
) || (state
.logtype
== DEBUG_STDOUT
);
528 void debug_set_callback(void *private_ptr
, debug_callback_fn fn
)
532 state
.logtype
= DEBUG_CALLBACK
;
533 state
.callback_private
= private_ptr
;
536 state
.logtype
= DEBUG_DEFAULT_STDERR
;
537 state
.callback_private
= NULL
;
538 state
.callback
= NULL
;
542 /**************************************************************************
544 note that we now do this unconditionally
545 We attempt to open the new debug fp before closing the old. This means
546 if we run out of fd's we just keep using the old fd rather than aborting.
547 Fix from dgibson@linuxcare.com.
548 **************************************************************************/
551 reopen the log file (usually called because the log file name might have changed)
553 bool reopen_logs_internal(void)
560 if (state
.reopening_logs
) {
564 /* Now clear the SIGHUP induced flag */
565 state
.schedule_reopen_logs
= false;
567 switch (state
.logtype
) {
571 case DEBUG_DEFAULT_STDOUT
:
572 debug_close_fd(state
.fd
);
576 case DEBUG_DEFAULT_STDERR
:
578 debug_close_fd(state
.fd
);
586 oldumask
= umask( 022 );
592 state
.reopening_logs
= true;
594 new_fd
= open( state
.debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
598 DEBUG(0, ("Unable to open new log file '%s': %s\n", state
.debugf
, strerror(errno
)));
599 log_overflow
= false;
604 debug_close_fd(old_fd
);
607 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
608 * to fix problem where smbd's that generate less
609 * than 100 messages keep growing the log.
611 force_check_log_size();
612 (void)umask(oldumask
);
614 /* Take over stderr to catch output into logs */
616 if (dup2(state
.fd
, 2) == -1) {
617 /* Close stderr too, if dup2 can't point it -
618 at the logfile. There really isn't much
619 that can be done on such a fundamental
625 state
.reopening_logs
= false;
630 /**************************************************************************
631 Force a check of the log size.
632 ***************************************************************************/
634 void force_check_log_size( void )
639 _PUBLIC_
void debug_schedule_reopen_logs(void)
641 state
.schedule_reopen_logs
= true;
645 /***************************************************************************
646 Check to see if there is any need to check if the logfile has grown too big.
647 **************************************************************************/
649 bool need_to_check_log_size( void )
653 if( debug_count
< 100)
656 maxlog
= state
.settings
.max_log_size
* 1024;
657 if ( state
.fd
<=2 || maxlog
<= 0 ) {
664 /**************************************************************************
665 Check to see if the log has grown to be too big.
666 **************************************************************************/
668 void check_log_size( void )
674 * We need to be root to check/change log-file, skip this and let the main
675 * loop check do a new check as root.
678 #if _SAMBA_BUILD_ == 3
679 if (geteuid() != sec_initial_uid())
684 /* We don't check sec_initial_uid() here as it isn't
685 * available in common code and we don't generally
686 * want to rotate and the possibly lose logs in
687 * make test or the build farm */
691 if(log_overflow
|| (!state
.schedule_reopen_logs
&& !need_to_check_log_size())) {
695 maxlog
= state
.settings
.max_log_size
* 1024;
697 if (state
.schedule_reopen_logs
) {
698 (void)reopen_logs_internal();
701 if (maxlog
&& (fstat(state
.fd
, &st
) == 0
702 && st
.st_size
> maxlog
)) {
703 (void)reopen_logs_internal();
704 if (state
.fd
> 2 && (fstat(state
.fd
, &st
) == 0
705 && st
.st_size
> maxlog
)) {
708 if (asprintf(&name
, "%s.old", state
.debugf
) < 0) {
711 (void)rename(state
.debugf
, name
);
713 if (!reopen_logs_internal()) {
714 /* We failed to reopen a log - continue using the old name. */
715 (void)rename(name
, state
.debugf
);
722 * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
726 /* This code should only be reached in very strange
727 * circumstances. If we merely fail to open the new log we
728 * should stick with the old one. ergo this should only be
729 * reached when opening the logs for the first time: at
730 * startup or when the log level is increased from zero.
733 int fd
= open( "/dev/console", O_WRONLY
, 0);
736 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
740 * We cannot continue without a debug file handle.
748 /*************************************************************************
749 Write an debug message on the debugfile.
750 This is called by dbghdr() and format_debug_text().
751 ************************************************************************/
753 static int Debug1(const char *msg
)
755 int old_errno
= errno
;
759 if (state
.logtype
== DEBUG_CALLBACK
) {
760 size_t msg_len
= strlen(msg
);
761 char msg_copy
[msg_len
];
763 if ((msg_len
> 0) && (msg
[msg_len
-1] == '\n')) {
764 memcpy(msg_copy
, msg
, msg_len
-1);
765 msg_copy
[msg_len
-1] = '\0';
769 state
.callback(state
.callback_private
, current_msg_level
, msg
);
773 if ( state
.logtype
!= DEBUG_FILE
) {
775 write(state
.fd
, msg
, strlen(msg
));
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
);
797 if( current_msg_level
< state
.settings
.syslog
) {
798 /* map debug levels to syslog() priorities
799 * note that not all DEBUG(0, ...) calls are
800 * necessarily errors */
801 static const int priority_map
[4] = {
809 if( current_msg_level
>= ARRAY_SIZE(priority_map
) || current_msg_level
< 0)
810 priority
= LOG_DEBUG
;
812 priority
= priority_map
[current_msg_level
];
815 * Specify the facility to interoperate with other syslog
816 * callers (vfs_full_audit for example).
818 priority
|= SYSLOG_FACILITY
;
820 syslog(priority
, "%s", msg
);
827 if( !state
.settings
.syslog_only
)
831 write(state
.fd
, msg
, strlen(msg
));
842 /**************************************************************************
843 Print the buffer content via Debug1(), then reset the buffer.
846 ****************************************************************************/
848 static void bufr_print( void )
850 format_bufr
[format_pos
] = '\0';
851 (void)Debug1(format_bufr
);
855 /***************************************************************************
856 Format the debug message text.
858 Input: msg - Text to be added to the "current" debug message text.
862 Notes: The purpose of this is two-fold. First, each call to syslog()
863 (used by Debug1(), see above) generates a new line of syslog
864 output. This is fixed by storing the partial lines until the
865 newline character is encountered. Second, printing the debug
866 message lines when a newline is encountered allows us to add
867 spaces, thus indenting the body of the message and making it
869 **************************************************************************/
871 static void format_debug_text( const char *msg
)
874 bool timestamp
= (state
.logtype
== DEBUG_FILE
&& (state
.settings
.timestamp_logs
));
878 for( i
= 0; msg
[i
]; i
++ ) {
879 /* Indent two spaces at each new line. */
880 if(timestamp
&& 0 == format_pos
) {
881 format_bufr
[0] = format_bufr
[1] = ' ';
885 /* If there's room, copy the character to the format buffer. */
886 if( format_pos
< FORMAT_BUFR_MAX
)
887 format_bufr
[format_pos
++] = msg
[i
];
889 /* If a newline is encountered, print & restart. */
893 /* If the buffer is full dump it out, reset it, and put out a line
894 * continuation indicator.
896 if( format_pos
>= FORMAT_BUFR_MAX
) {
898 (void)Debug1( " +>\n" );
902 /* Just to be safe... */
903 format_bufr
[format_pos
] = '\0';
906 /***************************************************************************
907 Flush debug output, including the format buffer content.
911 ***************************************************************************/
913 void dbgflush( void )
918 /***************************************************************************
919 Print a Debug Header.
921 Input: level - Debug level of the message (not the system-wide debug
923 cls - Debuglevel class of the calling module.
924 file - Pointer to a string containing the name of the file
925 from which this function was called, or an empty string
926 if the __FILE__ macro is not implemented.
927 func - Pointer to a string containing the name of the function
928 from which this function was called, or an empty string
929 if the __FUNCTION__ macro is not implemented.
930 line - line number of the call to dbghdr, assuming __LINE__
933 Output: Always true. This makes it easy to fudge a call to dbghdr()
934 in a macro, since the function can be called as part of a test.
935 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
937 Notes: This function takes care of setting current_msg_level.
939 ****************************************************************************/
941 bool dbghdrclass(int level
, int cls
, const char *location
, const char *func
)
943 /* Ensure we don't lose any real errno value. */
944 int old_errno
= errno
;
945 bool verbose
= false;
946 char header_str
[300];
949 struct timeval_buf tvbuf
;
952 /* This is a fudge. If there is stuff sitting in the format_bufr, then
953 * the *right* thing to do is to call
954 * format_debug_text( "\n" );
955 * to write the remainder, and then proceed with the new header.
956 * Unfortunately, there are several places in the code at which
957 * the DEBUG() macro is used to build partial lines. That in mind,
958 * we'll work under the assumption that an incomplete line indicates
959 * that a new header is *not* desired.
964 /* Set current_msg_level. */
965 current_msg_level
= level
;
967 /* Don't print a header if we're logging to stdout. */
968 if ( state
.logtype
!= DEBUG_FILE
) {
972 /* Print the header if timestamps are turned on. If parameters are
973 * not yet loaded, then default to timestamps on.
975 if (!(state
.settings
.timestamp_logs
||
976 state
.settings
.debug_prefix_timestamp
)) {
981 timeval_str_buf(&tv
, state
.settings
.debug_hires_timestamp
, &tvbuf
);
983 hs_len
= snprintf(header_str
, sizeof(header_str
), "[%s, %2d",
985 if (hs_len
>= sizeof(header_str
)) {
989 if (unlikely(DEBUGLEVEL_CLASS
[ cls
] >= 10)) {
993 if (verbose
|| state
.settings
.debug_pid
) {
995 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
996 ", pid=%u", (unsigned int)getpid());
997 if (hs_len
>= sizeof(header_str
)) {
1002 if (verbose
|| state
.settings
.debug_uid
) {
1004 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
1005 ", effective(%u, %u), real(%u, %u)",
1006 (unsigned int)geteuid(), (unsigned int)getegid(),
1007 (unsigned int)getuid(), (unsigned int)getgid());
1008 if (hs_len
>= sizeof(header_str
)) {
1013 if ((verbose
|| state
.settings
.debug_class
)
1014 && (cls
!= DBGC_ALL
)) {
1016 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
1017 ", class=%s", classname_table
[cls
]);
1018 if (hs_len
>= sizeof(header_str
)) {
1024 * No +=, see man man strlcat
1026 hs_len
= strlcat(header_str
, "] ", sizeof(header_str
));
1027 if (hs_len
>= sizeof(header_str
)) {
1031 if (!state
.settings
.debug_prefix_timestamp
) {
1033 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
1034 "%s(%s)\n", location
, func
);
1035 if (hs_len
>= sizeof(header_str
)) {
1041 (void)Debug1(header_str
);
1047 /***************************************************************************
1048 Add text to the body of the "current" debug message via the format buffer.
1050 Input: format_str - Format string, as used in printf(), et. al.
1051 ... - Variable argument list.
1053 ..or.. va_alist - Old style variable parameter list starting point.
1055 Output: Always true. See dbghdr() for more info, though this is not
1056 likely to be used in the same way.
1058 ***************************************************************************/
1060 bool dbgtext( const char *format_str
, ... )
1063 char *msgbuf
= NULL
;
1067 va_start(ap
, format_str
);
1068 res
= vasprintf(&msgbuf
, format_str
, ap
);
1072 format_debug_text(msgbuf
);