BOOL debug_auto_add_unknown_class = True;
BOOL AllowDebugChange = True;
+/*
+ used to check if the user specified a
+ logfile on the command line
+*/
+BOOL override_logfile;
+
+
/*
* This is to allow assignment to DEBUGLEVEL before the debug
* system has been initialised.
"auth", /* DBGC_AUTH */
"winbind", /* DBGC_WINBIND */
"vfs", /* DBGC_VFS */
+ "idmap", /* DBGC_IDMAP */
+ "quota", /* DBGC_QUOTA */
+ "acls", /* DBGC_ACLS */
+ "locking", /* DBGC_LOCKING */
+ "msdfs", /* DBGC_MSDFS */
NULL
};
if (DEBUGLEVEL_CLASS == &debug_all_class_hack)
return NULL;
- list = calloc(debug_num_classes + 1, sizeof(char *));
+ list = SMB_CALLOC_ARRAY(char *, debug_num_classes + 1);
if (!list)
return NULL;
dim += l;
}
- /* create single string list */
- b = buf = malloc(dim);
+ /* create single string list - add space for newline */
+ b = buf = SMB_MALLOC(dim+1);
if (!buf) {
err = True;
goto done;
strncpy(b, list[i], l);
b = b + l;
}
- b[-1] = '\0';
+ b[-1] = '\n'; /* replace last space with newline */
+ b[0] = '\0'; /* null terminate string */
done:
/* free strings list */
}
/****************************************************************************
-utility access to debug class names's
+ Utility access to debug class names's.
****************************************************************************/
+
const char *debug_classname_from_index(int ndx)
{
if (ndx < 0 || ndx >= debug_num_classes)
}
/****************************************************************************
-utility to translate names to debug class index's (internal version)
+ Utility to translate names to debug class index's (internal version).
****************************************************************************/
+
static int debug_lookup_classname_int(const char* classname)
{
int i;
}
/****************************************************************************
-Add a new debug class to the system
+ Add a new debug class to the system.
****************************************************************************/
+
int debug_add_class(const char *classname)
{
int ndx;
ndx = debug_num_classes;
new_ptr = DEBUGLEVEL_CLASS;
- if (DEBUGLEVEL_CLASS == &debug_all_class_hack)
- {
+ if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
/* Initial loading... */
new_ptr = NULL;
}
- new_ptr = Realloc(new_ptr,
- sizeof(int) * (debug_num_classes + 1));
+ new_ptr = SMB_REALLOC_ARRAY(new_ptr, int, debug_num_classes + 1);
if (!new_ptr)
return -1;
DEBUGLEVEL_CLASS = new_ptr;
DEBUGLEVEL_CLASS[ndx] = 0;
/* debug_level is the pointer used for the DEBUGLEVEL-thingy */
- if (ndx==0)
- {
+ if (ndx==0) {
/* Transfer the initial level from debug_all_class_hack */
DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL;
}
debug_level = DEBUGLEVEL_CLASS;
new_ptr = DEBUGLEVEL_CLASS_ISSET;
- if (new_ptr == &debug_all_class_isset_hack)
- {
+ if (new_ptr == &debug_all_class_isset_hack) {
new_ptr = NULL;
}
- new_ptr = Realloc(new_ptr,
- sizeof(BOOL) * (debug_num_classes + 1));
+ new_ptr = SMB_REALLOC_ARRAY(new_ptr, BOOL, debug_num_classes + 1);
if (!new_ptr)
return -1;
DEBUGLEVEL_CLASS_ISSET = new_ptr;
DEBUGLEVEL_CLASS_ISSET[ndx] = False;
- new_ptr = Realloc(classname_table,
- sizeof(char *) * (debug_num_classes + 1));
+ new_ptr = SMB_REALLOC_ARRAY(classname_table, char *, debug_num_classes + 1);
if (!new_ptr)
return -1;
classname_table = new_ptr;
- classname_table[ndx] = strdup(classname);
+ classname_table[ndx] = SMB_STRDUP(classname);
if (! classname_table[ndx])
return -1;
}
/****************************************************************************
-utility to translate names to debug class index's (public version)
+ Utility to translate names to debug class index's (public version).
****************************************************************************/
+
int debug_lookup_classname(const char *classname)
{
int ndx;
- if (!classname || !*classname) return -1;
+ if (!classname || !*classname)
+ return -1;
ndx = debug_lookup_classname_int(classname);
if (ndx != -1)
return ndx;
- if (debug_warn_unknown_class)
- {
+ if (debug_warn_unknown_class) {
DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
classname));
}
- if (debug_auto_add_unknown_class)
- {
+ if (debug_auto_add_unknown_class) {
return debug_add_class(classname);
}
return -1;
}
-
/****************************************************************************
-dump the current registered debug levels
+ Dump the current registered debug levels.
****************************************************************************/
+
static void debug_dump_status(int level)
{
int q;
DEBUG(level, ("INFO: Current debug levels:\n"));
- for (q = 0; q < debug_num_classes; q++)
- {
+ for (q = 0; q < debug_num_classes; q++) {
DEBUGADD(level, (" %s: %s/%d\n",
classname_table[q],
(DEBUGLEVEL_CLASS_ISSET[q]
}
/****************************************************************************
-parse the debug levels from smbcontrol. Example debug level parameter:
- printdrivers:7
+ parse the debug levels from smbcontrol. Example debug level parameter:
+ printdrivers:7
****************************************************************************/
+
static BOOL debug_parse_params(char **params)
{
int i, ndx;
DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
DEBUGLEVEL_CLASS_ISSET[DBGC_ALL] = True;
i = 1; /* start processing at the next params */
- }
- else
+ } else {
i = 0; /* DBGC_ALL not specified OR class name was included */
+ }
/* Fill in new debug class levels */
for (; i < debug_num_classes && params[i]; i++) {
}
/****************************************************************************
-parse the debug levels from smb.conf. Example debug level string:
+ Parse the debug levels from smb.conf. Example debug level string:
3 tdb:5 printdrivers:7
-Note: the 1st param has no "name:" preceeding it.
+ Note: the 1st param has no "name:" preceeding it.
****************************************************************************/
+
BOOL debug_parse_levels(const char *params_str)
{
char **params;
params = str_list_make(params_str, NULL);
- if (debug_parse_params(params))
- {
+ if (debug_parse_params(params)) {
debug_dump_status(5);
str_list_free(¶ms);
return True;
}
/****************************************************************************
-receive a "set debug level" message
+ Receive a "set debug level" message.
****************************************************************************/
-static void debug_message(int msg_type, pid_t src, void *buf, size_t len)
+
+static void debug_message(int msg_type, struct process_id src,
+ void *buf, size_t len)
{
const char *params_str = buf;
/* Check, it's a proper string! */
- if (params_str[len-1] != '\0')
- {
+ if (params_str[len-1] != '\0') {
DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
- (unsigned int)src, (unsigned int)getpid()));
+ (unsigned int)procid_to_pid(&src),
+ (unsigned int)getpid()));
return;
}
DEBUG(3, ("INFO: Remote set of debug to `%s' (pid %u from pid %u)\n",
- params_str, (unsigned int)getpid(), (unsigned int)src));
+ params_str, (unsigned int)getpid(),
+ (unsigned int)procid_to_pid(&src)));
debug_parse_levels(params_str);
}
-
/****************************************************************************
-send a "set debug level" message
+ Send a "set debug level" message.
****************************************************************************/
+
void debug_message_send(pid_t pid, const char *params_str)
{
if (!params_str)
return;
- message_send_pid(pid, MSG_DEBUG, params_str, strlen(params_str) + 1,
+ message_send_pid(pid_to_procid(pid), MSG_DEBUG,
+ params_str, strlen(params_str) + 1,
False);
}
-
/****************************************************************************
Return current debug level.
****************************************************************************/
-static void debuglevel_message(int msg_type, pid_t src, void *buf, size_t len)
+static void debuglevel_message(int msg_type, struct process_id src,
+ void *buf, size_t len)
{
- char *debug_level_classes;
- DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %u\n",(unsigned int)src));
+ char *message = debug_list_class_names_and_levels();
- if ((debug_level_classes = debug_list_class_names_and_levels())) {
- /*{ debug_level_classes = "test:1000";*/
- message_send_pid(src, MSG_DEBUGLEVEL, debug_level_classes, strlen(debug_level_classes) + 1, True);
- SAFE_FREE(debug_level_classes);
- } else {
- DEBUG(0, ("debuglevel_message: error retrieving class levels!\n"));
- }
+ DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %u\n",
+ (unsigned int)procid_to_pid(&src)));
+ message_send_pid(src, MSG_DEBUGLEVEL, message, strlen(message) + 1, True);
+
+ SAFE_FREE(message);
}
/****************************************************************************
Init debugging (one time stuff)
****************************************************************************/
+
void debug_init(void)
{
static BOOL initialised = False;
message_register(MSG_DEBUG, debug_message);
message_register(MSG_REQ_DEBUGLEVEL, debuglevel_message);
- for(p = default_classname_table; *p; p++)
- {
+ for(p = default_classname_table; *p; p++) {
debug_add_class(*p);
}
}
+/***************************************************************************
+ Get ready for syslog stuff
+**************************************************************************/
-/* ************************************************************************** **
- * get ready for syslog stuff
- * ************************************************************************** **
- */
void setup_logging(const char *pname, BOOL interactive)
{
debug_init();
/* reset to allow multiple setup calls, going from interactive to
non-interactive */
stdout_logging = False;
+ if (dbf) {
+ x_fflush(dbf);
+ (void) x_fclose(dbf);
+ }
+
dbf = NULL;
if (interactive) {
#endif
}
#endif
-} /* setup_logging */
-
-/* ************************************************************************** **
- * reopen the log files
- * note that we now do this unconditionally
- * We attempt to open the new debug fp before closing the old. This means
- * if we run out of fd's we just keep using the old fd rather than aborting.
- * Fix from dgibson@linuxcare.com.
- * ************************************************************************** **
- */
+}
+
+/**************************************************************************
+ reopen the log files
+ note that we now do this unconditionally
+ We attempt to open the new debug fp before closing the old. This means
+ if we run out of fd's we just keep using the old fd rather than aborting.
+ Fix from dgibson@linuxcare.com.
+**************************************************************************/
BOOL reopen_logs( void )
{
oldumask = umask( 022 );
pstrcpy(fname, debugf );
+ debugf[0] = '\0';
if (lp_loaded()) {
char *logfname;
return ret;
}
-/* ************************************************************************** **
- * Force a check of the log size.
- * ************************************************************************** **
- */
+/**************************************************************************
+ Force a check of the log size.
+ ***************************************************************************/
+
void force_check_log_size( void )
{
- debug_count = 100;
+ debug_count = 100;
}
/***************************************************************************
{
int maxlog;
- if( debug_count++ < 100 )
+ if( debug_count < 100 )
return( False );
maxlog = lp_max_log_size() * 1024;
return( True );
}
-/* ************************************************************************** **
- * Check to see if the log has grown to be too big.
- * ************************************************************************** **
- */
+/**************************************************************************
+ Check to see if the log has grown to be too big.
+ **************************************************************************/
void check_log_size( void )
{
}
}
debug_count = 0;
-} /* check_log_size */
+}
+
+/*************************************************************************
+ Write an debug message on the debugfile.
+ This is called by dbghdr() and format_debug_text().
+************************************************************************/
-/* ************************************************************************** **
- * Write an debug message on the debugfile.
- * This is called by dbghdr() and format_debug_text().
- * ************************************************************************** **
- */
int Debug1( const char *format_str, ... )
{
- va_list ap;
- int old_errno = errno;
-
- if( stdout_logging )
- {
- va_start( ap, format_str );
- if(dbf)
- (void)x_vfprintf( dbf, format_str, ap );
- va_end( ap );
- errno = old_errno;
- return( 0 );
- }
-
+ va_list ap;
+ int old_errno = errno;
+
+ debug_count++;
+
+ if( stdout_logging ) {
+ va_start( ap, format_str );
+ if(dbf)
+ (void)x_vfprintf( dbf, format_str, ap );
+ va_end( ap );
+ errno = old_errno;
+ return( 0 );
+ }
+
+ /* prevent recursion by checking if reopen_logs() has temporaily
+ set the debugf string to "" */
+ if( debugf[0] == '\0')
+ return( 0 );
+
#ifdef WITH_SYSLOG
- if( !lp_syslog_only() )
+ if( !lp_syslog_only() )
#endif
- {
- if( !dbf )
- {
- mode_t oldumask = umask( 022 );
-
- dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
- (void)umask( oldumask );
- if( dbf )
- {
- x_setbuf( dbf, NULL );
- }
- else
- {
- errno = old_errno;
- return(0);
- }
- }
- }
+ {
+ if( !dbf ) {
+ mode_t oldumask = umask( 022 );
+
+ dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
+ (void)umask( oldumask );
+ if( dbf ) {
+ x_setbuf( dbf, NULL );
+ } else {
+ errno = old_errno;
+ return(0);
+ }
+ }
+ }
#ifdef WITH_SYSLOG
- if( syslog_level < lp_syslog() )
- {
- /* map debug levels to syslog() priorities
- * note that not all DEBUG(0, ...) calls are
- * necessarily errors
- */
- static int priority_map[] = {
- LOG_ERR, /* 0 */
- LOG_WARNING, /* 1 */
- LOG_NOTICE, /* 2 */
- LOG_INFO, /* 3 */
- };
- int priority;
- pstring msgbuf;
-
- if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) )
- || syslog_level < 0)
- priority = LOG_DEBUG;
- else
- priority = priority_map[syslog_level];
-
- va_start( ap, format_str );
- vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
- va_end( ap );
-
- msgbuf[255] = '\0';
- syslog( priority, "%s", msgbuf );
- }
+ if( syslog_level < lp_syslog() ) {
+ /* map debug levels to syslog() priorities
+ * note that not all DEBUG(0, ...) calls are
+ * necessarily errors */
+ static int priority_map[] = {
+ LOG_ERR, /* 0 */
+ LOG_WARNING, /* 1 */
+ LOG_NOTICE, /* 2 */
+ LOG_INFO, /* 3 */
+ };
+ int priority;
+ pstring msgbuf;
+
+ if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) ) || syslog_level < 0)
+ priority = LOG_DEBUG;
+ else
+ priority = priority_map[syslog_level];
+
+ va_start( ap, format_str );
+ vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
+ va_end( ap );
+
+ msgbuf[255] = '\0';
+ syslog( priority, "%s", msgbuf );
+ }
#endif
- check_log_size();
+ check_log_size();
#ifdef WITH_SYSLOG
- if( !lp_syslog_only() )
+ if( !lp_syslog_only() )
#endif
- {
- va_start( ap, format_str );
- if(dbf)
- (void)x_vfprintf( dbf, format_str, ap );
- va_end( ap );
- if(dbf)
- (void)x_fflush( dbf );
- }
+ {
+ va_start( ap, format_str );
+ if(dbf)
+ (void)x_vfprintf( dbf, format_str, ap );
+ va_end( ap );
+ if(dbf)
+ (void)x_fflush( dbf );
+ }
- errno = old_errno;
+ errno = old_errno;
- return( 0 );
- } /* Debug1 */
+ return( 0 );
+}
-/* ************************************************************************** **
- * Print the buffer content via Debug1(), then reset the buffer.
- *
- * Input: none
- * Output: none
- *
- * ************************************************************************** **
- */
+/**************************************************************************
+ Print the buffer content via Debug1(), then reset the buffer.
+ Input: none
+ Output: none
+****************************************************************************/
+
static void bufr_print( void )
- {
- format_bufr[format_pos] = '\0';
- (void)Debug1( "%s", format_bufr );
- format_pos = 0;
- } /* bufr_print */
-
-/* ************************************************************************** **
- * Format the debug message text.
- *
- * Input: msg - Text to be added to the "current" debug message text.
- *
- * Output: none.
- *
- * Notes: The purpose of this is two-fold. First, each call to syslog()
- * (used by Debug1(), see above) generates a new line of syslog
- * output. This is fixed by storing the partial lines until the
- * newline character is encountered. Second, printing the debug
- * message lines when a newline is encountered allows us to add
- * spaces, thus indenting the body of the message and making it
- * more readable.
- *
- * ************************************************************************** **
- */
-static void format_debug_text( char *msg )
- {
- size_t i;
- BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() ||
- !(lp_loaded())));
-
- for( i = 0; msg[i]; i++ )
- {
- /* Indent two spaces at each new line. */
- if(timestamp && 0 == format_pos)
- {
- format_bufr[0] = format_bufr[1] = ' ';
- format_pos = 2;
- }
-
- /* If there's room, copy the character to the format buffer. */
- if( format_pos < FORMAT_BUFR_MAX )
- format_bufr[format_pos++] = msg[i];
-
- /* If a newline is encountered, print & restart. */
- if( '\n' == msg[i] )
- bufr_print();
-
- /* If the buffer is full dump it out, reset it, and put out a line
- * continuation indicator.
- */
- if( format_pos >= FORMAT_BUFR_MAX )
- {
- bufr_print();
- (void)Debug1( " +>\n" );
- }
- }
-
- /* Just to be safe... */
- format_bufr[format_pos] = '\0';
- } /* format_debug_text */
-
-/* ************************************************************************** **
- * Flush debug output, including the format buffer content.
- *
- * Input: none
- * Output: none
- *
- * ************************************************************************** **
- */
+{
+ format_bufr[format_pos] = '\0';
+ (void)Debug1( "%s", format_bufr );
+ format_pos = 0;
+}
+
+/***************************************************************************
+ Format the debug message text.
+
+ Input: msg - Text to be added to the "current" debug message text.
+
+ Output: none.
+
+ Notes: The purpose of this is two-fold. First, each call to syslog()
+ (used by Debug1(), see above) generates a new line of syslog
+ output. This is fixed by storing the partial lines until the
+ newline character is encountered. Second, printing the debug
+ message lines when a newline is encountered allows us to add
+ spaces, thus indenting the body of the message and making it
+ more readable.
+**************************************************************************/
+
+static void format_debug_text( const char *msg )
+{
+ size_t i;
+ BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() || !(lp_loaded())));
+
+ for( i = 0; msg[i]; i++ ) {
+ /* Indent two spaces at each new line. */
+ if(timestamp && 0 == format_pos) {
+ format_bufr[0] = format_bufr[1] = ' ';
+ format_pos = 2;
+ }
+
+ /* If there's room, copy the character to the format buffer. */
+ if( format_pos < FORMAT_BUFR_MAX )
+ format_bufr[format_pos++] = msg[i];
+
+ /* If a newline is encountered, print & restart. */
+ if( '\n' == msg[i] )
+ bufr_print();
+
+ /* If the buffer is full dump it out, reset it, and put out a line
+ * continuation indicator.
+ */
+ if( format_pos >= FORMAT_BUFR_MAX ) {
+ bufr_print();
+ (void)Debug1( " +>\n" );
+ }
+ }
+
+ /* Just to be safe... */
+ format_bufr[format_pos] = '\0';
+}
+
+/***************************************************************************
+ Flush debug output, including the format buffer content.
+
+ Input: none
+ Output: none
+***************************************************************************/
+
void dbgflush( void )
- {
- bufr_print();
- if(dbf)
- (void)x_fflush( dbf );
- } /* dbgflush */
-
-/* ************************************************************************** **
- * Print a Debug Header.
- *
- * Input: level - Debug level of the message (not the system-wide debug
- * level. )
- * file - Pointer to a string containing the name of the file
- * from which this function was called, or an empty string
- * if the __FILE__ macro is not implemented.
- * func - Pointer to a string containing the name of the function
- * from which this function was called, or an empty string
- * if the __FUNCTION__ macro is not implemented.
- * line - line number of the call to dbghdr, assuming __LINE__
- * works.
- *
- * Output: Always True. This makes it easy to fudge a call to dbghdr()
- * in a macro, since the function can be called as part of a test.
- * Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
- *
- * Notes: This function takes care of setting syslog_level.
- *
- * ************************************************************************** **
- */
+{
+ bufr_print();
+ if(dbf)
+ (void)x_fflush( dbf );
+}
+
+/***************************************************************************
+ Print a Debug Header.
+
+ Input: level - Debug level of the message (not the system-wide debug
+ level. )
+ file - Pointer to a string containing the name of the file
+ from which this function was called, or an empty string
+ if the __FILE__ macro is not implemented.
+ func - Pointer to a string containing the name of the function
+ from which this function was called, or an empty string
+ if the __FUNCTION__ macro is not implemented.
+ line - line number of the call to dbghdr, assuming __LINE__
+ works.
+
+ Output: Always True. This makes it easy to fudge a call to dbghdr()
+ in a macro, since the function can be called as part of a test.
+ Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
+
+ Notes: This function takes care of setting syslog_level.
+
+****************************************************************************/
BOOL dbghdr( int level, const char *file, const char *func, int line )
{
- /* Ensure we don't lose any real errno value. */
- int old_errno = errno;
-
- if( format_pos ) {
- /* This is a fudge. If there is stuff sitting in the format_bufr, then
- * the *right* thing to do is to call
- * format_debug_text( "\n" );
- * to write the remainder, and then proceed with the new header.
- * Unfortunately, there are several places in the code at which
- * the DEBUG() macro is used to build partial lines. That in mind,
- * we'll work under the assumption that an incomplete line indicates
- * that a new header is *not* desired.
- */
- return( True );
- }
+ /* Ensure we don't lose any real errno value. */
+ int old_errno = errno;
+
+ if( format_pos ) {
+ /* This is a fudge. If there is stuff sitting in the format_bufr, then
+ * the *right* thing to do is to call
+ * format_debug_text( "\n" );
+ * to write the remainder, and then proceed with the new header.
+ * Unfortunately, there are several places in the code at which
+ * the DEBUG() macro is used to build partial lines. That in mind,
+ * we'll work under the assumption that an incomplete line indicates
+ * that a new header is *not* desired.
+ */
+ return( True );
+ }
#ifdef WITH_SYSLOG
- /* Set syslog_level. */
- syslog_level = level;
+ /* Set syslog_level. */
+ syslog_level = level;
#endif
- /* Don't print a header if we're logging to stdout. */
- if( stdout_logging )
- return( True );
+ /* Don't print a header if we're logging to stdout. */
+ if( stdout_logging )
+ return( True );
- /* Print the header if timestamps are turned on. If parameters are
- * not yet loaded, then default to timestamps on.
- */
- if( lp_timestamp_logs() || !(lp_loaded()) ) {
- char header_str[200];
+ /* Print the header if timestamps are turned on. If parameters are
+ * not yet loaded, then default to timestamps on.
+ */
+ if( lp_timestamp_logs() || !(lp_loaded()) ) {
+ char header_str[200];
- header_str[0] = '\0';
+ header_str[0] = '\0';
- if( lp_debug_pid())
- slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
+ if( lp_debug_pid())
+ slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
- if( lp_debug_uid()) {
- size_t hs_len = strlen(header_str);
- slprintf(header_str + hs_len,
- sizeof(header_str) - 1 - hs_len,
- ", effective(%u, %u), real(%u, %u)",
- (unsigned int)geteuid(), (unsigned int)getegid(),
- (unsigned int)getuid(), (unsigned int)getgid());
- }
+ if( lp_debug_uid()) {
+ size_t hs_len = strlen(header_str);
+ slprintf(header_str + hs_len,
+ sizeof(header_str) - 1 - hs_len,
+ ", effective(%u, %u), real(%u, %u)",
+ (unsigned int)geteuid(), (unsigned int)getegid(),
+ (unsigned int)getuid(), (unsigned int)getgid());
+ }
- /* Print it all out at once to prevent split syslog output. */
- (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
- timestring(lp_debug_hires_timestamp()), level,
- header_str, file, func, line );
- }
+ /* Print it all out at once to prevent split syslog output. */
+ (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
+ timestring(lp_debug_hires_timestamp()), level,
+ header_str, file, func, line );
+ }
- errno = old_errno;
- return( True );
+ errno = old_errno;
+ return( True );
}
-/* ************************************************************************** **
- * Add text to the body of the "current" debug message via the format buffer.
- *
- * Input: format_str - Format string, as used in printf(), et. al.
- * ... - Variable argument list.
- *
- * ..or.. va_alist - Old style variable parameter list starting point.
- *
- * Output: Always True. See dbghdr() for more info, though this is not
- * likely to be used in the same way.
- *
- * ************************************************************************** **
- */
- BOOL dbgtext( const char *format_str, ... )
- {
- va_list ap;
- pstring msgbuf;
+/***************************************************************************
+ Add text to the body of the "current" debug message via the format buffer.
- va_start( ap, format_str );
- vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
- va_end( ap );
+ Input: format_str - Format string, as used in printf(), et. al.
+ ... - Variable argument list.
- format_debug_text( msgbuf );
+ ..or.. va_alist - Old style variable parameter list starting point.
- return( True );
- } /* dbgtext */
+ Output: Always True. See dbghdr() for more info, though this is not
+ likely to be used in the same way.
+
+***************************************************************************/
+
+ BOOL dbgtext( const char *format_str, ... )
+{
+ va_list ap;
+ pstring msgbuf;
+
+ va_start( ap, format_str );
+ vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
+ va_end( ap );
+ format_debug_text( msgbuf );
-/* ************************************************************************** */
+ return( True );
+}