summaryrefslogtreecommitdiff
path: root/lib/util
diff options
context:
space:
mode:
Diffstat (limited to 'lib/util')
-rw-r--r--lib/util/debug.c1059
-rw-r--r--lib/util/debug.h269
-rw-r--r--lib/util/debug_s3.c105
-rw-r--r--lib/util/debug_s3.h23
-rw-r--r--lib/util/debug_s4.c273
-rw-r--r--lib/util/debug_s4.h150
-rw-r--r--lib/util/wscript_build8
7 files changed, 1461 insertions, 426 deletions
diff --git a/lib/util/debug.c b/lib/util/debug.c
new file mode 100644
index 0000000000..d2f3d922ae
--- /dev/null
+++ b/lib/util/debug.c
@@ -0,0 +1,1059 @@
+/*
+ Unix SMB/CIFS implementation.
+ Samba utility functions
+ Copyright (C) Andrew Tridgell 1992-1998
+ Copyright (C) Elrond 2002
+ Copyright (C) Simo Sorce 2002
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "system/filesys.h"
+#include "system/syslog.h"
+#include "lib/util/time.h"
+
+/* define what facility to use for syslog */
+#ifndef SYSLOG_FACILITY
+#define SYSLOG_FACILITY LOG_DAEMON
+#endif
+
+/* -------------------------------------------------------------------------- **
+ * Defines...
+ *
+ * FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
+ * format_bufr[FORMAT_BUFR_MAX] should always be reserved
+ * for a terminating null byte.
+ */
+
+#define FORMAT_BUFR_SIZE 1024
+#define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
+
+/* -------------------------------------------------------------------------- **
+ * This module implements Samba's debugging utility.
+ *
+ * The syntax of a debugging log file is represented as:
+ *
+ * <debugfile> :== { <debugmsg> }
+ *
+ * <debugmsg> :== <debughdr> '\n' <debugtext>
+ *
+ * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
+ *
+ * <debugtext> :== { <debugline> }
+ *
+ * <debugline> :== TEXT '\n'
+ *
+ * TEXT is a string of characters excluding the newline character.
+ * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
+ * TIME is a timestamp.
+ * FILENAME is the name of the file from which the debug message was generated.
+ * FUNCTION is the function from which the debug message was generated.
+ *
+ * Basically, what that all means is:
+ *
+ * - A debugging log file is made up of debug messages.
+ *
+ * - Each debug message is made up of a header and text. The header is
+ * separated from the text by a newline.
+ *
+ * - The header begins with the timestamp and debug level of the message
+ * enclosed in brackets. The filename and function from which the
+ * message was generated may follow. The filename is terminated by a
+ * colon, and the function name is terminated by parenthesis.
+ *
+ * - The message text is made up of zero or more lines, each terminated by
+ * a newline.
+ */
+
+/* state variables for the debug system */
+static struct {
+ bool initialized;
+ int fd; /* The log file handle */
+ enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
+ const char *prog_name;
+ bool reopening_logs;
+ bool schedule_reopen_logs;
+
+ struct debug_settings settings;
+ char *debugf;
+} state = {
+ .settings = {
+ .timestamp_logs = true
+ }
+};
+
+/* -------------------------------------------------------------------------- **
+ * External variables.
+ *
+ * debugf - Debug file name.
+ * DEBUGLEVEL - System-wide debug message limit. Messages with message-
+ * levels higher than DEBUGLEVEL will not be processed.
+ */
+
+/*
+ used to check if the user specified a
+ logfile on the command line
+*/
+bool override_logfile;
+
+/*
+ * This is to allow reading of DEBUGLEVEL_CLASS before the debug
+ * system has been initialized.
+ */
+static const int debug_class_list_initial[DBGC_MAX_FIXED + 1];
+
+static int debug_num_classes = 0;
+int *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
+
+
+/* -------------------------------------------------------------------------- **
+ * Internal variables.
+ *
+ * debug_count - Number of debug messages that have been output.
+ * Used to check log size.
+ *
+ * syslog_level - Internal copy of the message debug level. Written by
+ * dbghdr() and read by Debug1().
+ *
+ * format_bufr - Used to format debug messages. The dbgtext() function
+ * prints debug messages to a string, and then passes the
+ * string to format_debug_text(), which uses format_bufr
+ * to build the formatted output.
+ *
+ * format_pos - Marks the first free byte of the format_bufr.
+ *
+ *
+ * log_overflow - When this variable is true, never attempt to check the
+ * size of the log. This is a hack, so that we can write
+ * a message using DEBUG, from open_logs() when we
+ * are unable to open a new log file for some reason.
+ */
+
+static int debug_count = 0;
+#ifdef WITH_SYSLOG
+static int syslog_level = 0;
+#endif
+static char *format_bufr = NULL;
+static size_t format_pos = 0;
+static bool log_overflow = false;
+
+/*
+ * Define all the debug class selection names here. Names *MUST NOT* contain
+ * white space. There must be one name for each DBGC_<class name>, and they
+ * must be in the table in the order of DBGC_<class name>..
+ */
+static const char *default_classname_table[] = {
+ "all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
+ "tdb", /* DBGC_TDB */
+ "printdrivers", /* DBGC_PRINTDRIVERS */
+ "lanman", /* DBGC_LANMAN */
+ "smb", /* DBGC_SMB */
+ "rpc_parse", /* DBGC_RPC_PARSE */
+ "rpc_srv", /* DBGC_RPC_SRV */
+ "rpc_cli", /* DBGC_RPC_CLI */
+ "passdb", /* DBGC_PASSDB */
+ "sam", /* DBGC_SAM */
+ "auth", /* DBGC_AUTH */
+ "winbind", /* DBGC_WINBIND */
+ "vfs", /* DBGC_VFS */
+ "idmap", /* DBGC_IDMAP */
+ "quota", /* DBGC_QUOTA */
+ "acls", /* DBGC_ACLS */
+ "locking", /* DBGC_LOCKING */
+ "msdfs", /* DBGC_MSDFS */
+ "dmapi", /* DBGC_DMAPI */
+ "registry", /* DBGC_REGISTRY */
+ NULL
+};
+
+static char **classname_table = NULL;
+
+
+/* -------------------------------------------------------------------------- **
+ * Functions...
+ */
+
+static void debug_init(void);
+
+/***************************************************************************
+ Free memory pointed to by global pointers.
+****************************************************************************/
+
+void gfree_debugsyms(void)
+{
+ TALLOC_FREE(classname_table);
+
+ if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
+ TALLOC_FREE( DEBUGLEVEL_CLASS );
+ DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
+ }
+
+ TALLOC_FREE(format_bufr);
+
+ debug_num_classes = DBGC_MAX_FIXED;
+
+ state.initialized = false;
+}
+
+/****************************************************************************
+utility lists registered debug class names's
+****************************************************************************/
+
+char *debug_list_class_names_and_levels(void)
+{
+ char *buf = NULL;
+ unsigned int i;
+ /* prepare strings */
+ for (i = 0; i < debug_num_classes; i++) {
+ buf = talloc_asprintf_append(buf,
+ "%s:%d%s",
+ classname_table[i],
+ DEBUGLEVEL_CLASS[i],
+ i == (debug_num_classes - 1) ? "\n" : " ");
+ if (buf == NULL) {
+ return NULL;
+ }
+ }
+ return buf;
+}
+
+/****************************************************************************
+ Utility to translate names to debug class index's (internal version).
+****************************************************************************/
+
+static int debug_lookup_classname_int(const char* classname)
+{
+ int i;
+
+ if (!classname) return -1;
+
+ for (i=0; i < debug_num_classes; i++) {
+ if (strcmp(classname, classname_table[i])==0)
+ return i;
+ }
+ return -1;
+}
+
+/****************************************************************************
+ Add a new debug class to the system.
+****************************************************************************/
+
+int debug_add_class(const char *classname)
+{
+ int ndx;
+ int *new_class_list;
+ char **new_name_list;
+
+ if (!classname)
+ return -1;
+
+ /* check the init has yet been called */
+ debug_init();
+
+ ndx = debug_lookup_classname_int(classname);
+ if (ndx >= 0)
+ return ndx;
+ ndx = debug_num_classes;
+
+ if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
+ /* Initial loading... */
+ new_class_list = NULL;
+ } else {
+ new_class_list = DEBUGLEVEL_CLASS;
+ }
+
+ new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
+ if (!new_class_list)
+ return -1;
+ DEBUGLEVEL_CLASS = new_class_list;
+
+ DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL_CLASS[DBGC_ALL];
+
+ new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
+ if (!new_name_list)
+ return -1;
+ classname_table = new_name_list;
+
+ classname_table[ndx] = talloc_strdup(classname_table, classname);
+ if (! classname_table[ndx])
+ return -1;
+
+ debug_num_classes = ndx + 1;
+
+ return ndx;
+}
+
+/****************************************************************************
+ 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;
+
+ ndx = debug_lookup_classname_int(classname);
+
+ if (ndx != -1)
+ return ndx;
+
+ DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
+ classname));
+ return debug_add_class(classname);
+}
+
+/****************************************************************************
+ 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++) {
+ const char *classname = classname_table[q];
+ DEBUGADD(level, (" %s: %d\n",
+ classname,
+ DEBUGLEVEL_CLASS[q]));
+ }
+}
+
+/****************************************************************************
+ parse the debug levels from smbcontrol. Example debug level parameter:
+ printdrivers:7
+****************************************************************************/
+
+static bool debug_parse_params(char **params)
+{
+ int i, ndx;
+ char *class_name;
+ char *class_level;
+
+ if (!params)
+ return false;
+
+ /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
+ * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
+ */
+ if (isdigit((int)params[0][0])) {
+ DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
+ i = 1; /* start processing at the next params */
+ } else {
+ DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
+ i = 0; /* DBGC_ALL not specified OR class name was included */
+ }
+
+ /* Array is debug_num_classes long */
+ for (ndx = DBGC_ALL; ndx < debug_num_classes; ndx++) {
+ DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL_CLASS[DBGC_ALL];
+ }
+
+ /* Fill in new debug class levels */
+ for (; i < debug_num_classes && params[i]; i++) {
+ char *saveptr;
+ if ((class_name = strtok_r(params[i],":", &saveptr)) &&
+ (class_level = strtok_r(NULL, "\0", &saveptr)) &&
+ ((ndx = debug_lookup_classname(class_name)) != -1)) {
+ DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
+ } else {
+ DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
+ return false;
+ }
+ }
+
+ return true;
+}
+
+/****************************************************************************
+ 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.
+****************************************************************************/
+
+bool debug_parse_levels(const char *params_str)
+{
+ char **params;
+
+ /* Just in case */
+ debug_init();
+
+ params = str_list_make(NULL, params_str, NULL);
+
+ if (debug_parse_params(params)) {
+ debug_dump_status(5);
+ TALLOC_FREE(params);
+ return true;
+ } else {
+ TALLOC_FREE(params);
+ return false;
+ }
+}
+
+/* setup for logging of talloc warnings */
+static void talloc_log_fn(const char *msg)
+{
+ DEBUG(0,("%s", msg));
+}
+
+void debug_setup_talloc_log(void)
+{
+ talloc_set_log_fn(talloc_log_fn);
+}
+
+
+/****************************************************************************
+Init debugging (one time stuff)
+****************************************************************************/
+
+static void debug_init(void)
+{
+ const char **p;
+
+ if (state.initialized)
+ return;
+
+ state.initialized = true;
+
+ debug_setup_talloc_log();
+
+ for(p = default_classname_table; *p; p++) {
+ debug_add_class(*p);
+ }
+ format_bufr = talloc_array(NULL, char, FORMAT_BUFR_SIZE);
+ if (!format_bufr) {
+ smb_panic("debug_init: unable to create buffer");
+ }
+}
+
+/* This forces in some smb.conf derived values into the debug system.
+ * There are no pointers in this structure, so we can just
+ * structure-assign it in */
+void debug_set_settings(struct debug_settings *settings)
+{
+ state.settings = *settings;
+}
+
+/**
+ control the name of the logfile and whether logging will be to stdout, stderr
+ or a file, and set up syslog
+
+ new_log indicates the destination for the debug log (an enum in
+ order of precedence - once set to DEBUG_FILE, it is not possible to
+ reset to DEBUG_STDOUT for example. This makes it easy to override
+ for debug to stderr on the command line, as the smb.conf cannot
+ reset it back to file-based logging
+*/
+void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
+{
+ debug_init();
+ if (state.logtype < new_logtype) {
+ state.logtype = new_logtype;
+ }
+ if (prog_name) {
+ state.prog_name = prog_name;
+ }
+ reopen_logs_internal();
+
+ if (state.logtype == DEBUG_FILE) {
+#ifdef WITH_SYSLOG
+ const char *p = strrchr_m( prog_name,'/' );
+ if (p)
+ prog_name = p + 1;
+#ifdef LOG_DAEMON
+ openlog( prog_name, LOG_PID, SYSLOG_FACILITY );
+#else
+ /* for old systems that have no facility codes. */
+ openlog( prog_name, LOG_PID );
+#endif
+#endif
+ }
+}
+
+/***************************************************************************
+ Set the logfile name.
+**************************************************************************/
+
+void debug_set_logfile(const char *name)
+{
+ TALLOC_FREE(state.debugf);
+ state.debugf = talloc_strdup(NULL, name);
+}
+
+static void debug_close_fd(int fd)
+{
+ if (fd > 2) {
+ close(fd);
+ }
+}
+
+bool debug_get_output_is_stderr(void)
+{
+ return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
+}
+
+/**************************************************************************
+ 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 file (usually called because the log file name might have changed)
+*/
+bool reopen_logs_internal(void)
+{
+ mode_t oldumask;
+ int new_fd = 0;
+ int old_fd = 0;
+ bool ret = true;
+
+ char *fname = NULL;
+ if (state.reopening_logs) {
+ return true;
+ }
+
+ /* Now clear the SIGHUP induced flag */
+ state.schedule_reopen_logs = false;
+
+ switch (state.logtype) {
+ case DEBUG_STDOUT:
+ debug_close_fd(state.fd);
+ state.fd = 1;
+ return true;
+
+ case DEBUG_DEFAULT_STDERR:
+ case DEBUG_STDERR:
+ debug_close_fd(state.fd);
+ state.fd = 2;
+ return true;
+
+ case DEBUG_FILE:
+ break;
+ }
+
+ oldumask = umask( 022 );
+
+ fname = state.debugf;
+ if (!fname) {
+ return false;
+ }
+
+ state.reopening_logs = true;
+
+ new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
+
+ if (new_fd == -1) {
+ log_overflow = true;
+ DEBUG(0, ("Unable to open new log file %s: %s\n", state.debugf, strerror(errno)));
+ log_overflow = false;
+ ret = false;
+ } else {
+ old_fd = state.fd;
+ state.fd = new_fd;
+ debug_close_fd(old_fd);
+ }
+
+ /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
+ * to fix problem where smbd's that generate less
+ * than 100 messages keep growing the log.
+ */
+ force_check_log_size();
+ (void)umask(oldumask);
+
+ /* Take over stderr to catch output into logs */
+ if (state.fd > 0 && dup2(state.fd, 2) == -1) {
+ close_low_fds(true); /* Close stderr too, if dup2 can't point it
+ at the logfile */
+ }
+
+ state.reopening_logs = false;
+
+ return ret;
+}
+
+/**************************************************************************
+ Force a check of the log size.
+ ***************************************************************************/
+
+void force_check_log_size( void )
+{
+ debug_count = 100;
+}
+
+_PUBLIC_ void debug_schedule_reopen_logs(void)
+{
+ state.schedule_reopen_logs = true;
+}
+
+
+/***************************************************************************
+ Check to see if there is any need to check if the logfile has grown too big.
+**************************************************************************/
+
+bool need_to_check_log_size( void )
+{
+ int maxlog;
+
+ if( debug_count < 100)
+ return( false );
+
+ maxlog = state.settings.max_log_size * 1024;
+ if ( state.fd <=2 || maxlog <= 0 ) {
+ debug_count = 0;
+ return(false);
+ }
+ return( true );
+}
+
+/**************************************************************************
+ Check to see if the log has grown to be too big.
+ **************************************************************************/
+
+void check_log_size( void )
+{
+ int maxlog;
+ struct stat st;
+
+ /*
+ * We need to be root to check/change log-file, skip this and let the main
+ * loop check do a new check as root.
+ */
+
+ if( geteuid() != 0) {
+ /* We don't check sec_initial_uid() here as it isn't
+ * available in common code and we don't generally
+ * want to rotate and the possibly lose logs in
+ * make test or the build farm */
+ return;
+ }
+
+ if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
+ return;
+ }
+
+ maxlog = state.settings.max_log_size * 1024;
+
+ if (state.schedule_reopen_logs ||
+ (fstat(state.fd, &st) == 0
+ && st.st_size > maxlog )) {
+ (void)reopen_logs_internal();
+ if (state.fd > 0 && fstat(state.fd, &st) == 0) {
+ if (st.st_size > maxlog) {
+ char *name = NULL;
+
+ if (asprintf(&name, "%s.old", state.debugf ) < 0) {
+ return;
+ }
+ (void)rename(state.debugf, name);
+
+ if (!reopen_logs_internal()) {
+ /* We failed to reopen a log - continue using the old name. */
+ (void)rename(name, state.debugf);
+ }
+ SAFE_FREE(name);
+ }
+ }
+ }
+
+ /*
+ * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
+ */
+
+ if (state.fd <= 0) {
+ /* This code should only be reached in very strange
+ * circumstances. If we merely fail to open the new log we
+ * should stick with the old one. ergo this should only be
+ * reached when opening the logs for the first time: at
+ * startup or when the log level is increased from zero.
+ * -dwg 6 June 2000
+ */
+ int fd = open( "/dev/console", O_WRONLY, 0);
+ if (fd != -1) {
+ state.fd = fd;
+ DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
+ state.debugf ));
+ } else {
+ /*
+ * We cannot continue without a debug file handle.
+ */
+ abort();
+ }
+ }
+ debug_count = 0;
+}
+
+/*************************************************************************
+ 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;
+
+ debug_count++;
+
+ if ( state.logtype != DEBUG_FILE ) {
+ va_start( ap, format_str );
+ if (state.fd > 0)
+ (void)vdprintf( state.fd, format_str, ap );
+ va_end( ap );
+ errno = old_errno;
+ goto done;
+ }
+
+#ifdef WITH_SYSLOG
+ if( !state.settings.syslog_only)
+#endif
+ {
+ if( state.fd <= 0 ) {
+ mode_t oldumask = umask( 022 );
+ int fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
+ (void)umask( oldumask );
+ if(fd == -1) {
+ errno = old_errno;
+ goto done;
+ }
+ state.fd = fd;
+ }
+ }
+
+#ifdef WITH_SYSLOG
+ if( syslog_level < state.settings.syslog ) {
+ /* map debug levels to syslog() priorities
+ * note that not all DEBUG(0, ...) calls are
+ * necessarily errors */
+ static const int priority_map[4] = {
+ LOG_ERR, /* 0 */
+ LOG_WARNING, /* 1 */
+ LOG_NOTICE, /* 2 */
+ LOG_INFO, /* 3 */
+ };
+ int priority;
+ char *msgbuf = NULL;
+ int ret;
+
+ if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
+ priority = LOG_DEBUG;
+ else
+ priority = priority_map[syslog_level];
+
+ /*
+ * Specify the facility to interoperate with other syslog
+ * callers (vfs_full_audit for example).
+ */
+ priority |= SYSLOG_FACILITY;
+
+ va_start(ap, format_str);
+ ret = vasprintf(&msgbuf, format_str, ap);
+ va_end(ap);
+
+ if (ret != -1) {
+ syslog(priority, "%s", msgbuf);
+ }
+ SAFE_FREE(msgbuf);
+ }
+#endif
+
+ check_log_size();
+
+#ifdef WITH_SYSLOG
+ if( !state.settings.syslog_only)
+#endif
+ {
+ va_start( ap, format_str );
+ if (state.fd > 0)
+ (void)vdprintf( state.fd, format_str, ap );
+ va_end( ap );
+ }
+
+ done:
+ errno = old_errno;
+
+ return( 0 );
+}
+
+
+/**************************************************************************
+ 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;
+}
+
+/***************************************************************************
+ 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 = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
+
+ if (!format_bufr) {
+ debug_init();
+ }
+
+ 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();
+}
+
+/***************************************************************************
+ Print a Debug Header.
+
+ Input: level - Debug level of the message (not the system-wide debug
+ level. )
+ cls - Debuglevel class of the calling module.
+ 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 dbghdrclass(int level, int cls, const char *location, const char *func)
+{
+ /* 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;
+#endif
+
+ /* Don't print a header if we're logging to stdout. */
+ if ( state.logtype != DEBUG_FILE ) {
+ return( true );
+ }
+
+ /* Print the header if timestamps are turned on. If parameters are
+ * not yet loaded, then default to timestamps on.
+ */
+ if( state.settings.timestamp_logs || state.settings.debug_prefix_timestamp) {
+ char header_str[200];
+
+ header_str[0] = '\0';
+
+ if( state.settings.debug_pid)
+ slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)getpid());
+
+ if( state.settings.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 (state.settings.debug_class && (cls != DBGC_ALL)) {
+ size_t hs_len = strlen(header_str);
+ slprintf(header_str + hs_len,
+ sizeof(header_str) -1 - hs_len,
+ ", class=%s",
+ default_classname_table[cls]);
+ }
+
+ /* Print it all out at once to prevent split syslog output. */
+ if( state.settings.debug_prefix_timestamp ) {
+ char *time_str = current_timestring(NULL,
+ state.settings.debug_hires_timestamp);
+ (void)Debug1( "[%s, %2d%s] ",
+ time_str,
+ level, header_str);
+ talloc_free(time_str);
+ } else {
+ char *time_str = current_timestring(NULL,
+ state.settings.debug_hires_timestamp);
+ (void)Debug1( "[%s, %2d%s] %s(%s)\n",
+ time_str,
+ level, header_str, location, func );
+ talloc_free(time_str);
+ }
+ }
+
+ 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;
+ char *msgbuf = NULL;
+ bool ret = true;
+ int res;
+
+ va_start(ap, format_str);
+ res = vasprintf(&msgbuf, format_str, ap);
+ va_end(ap);
+
+ if (res != -1) {
+ format_debug_text(msgbuf);
+ } else {
+ ret = false;
+ }
+ SAFE_FREE(msgbuf);
+ return ret;
+}
+
+
+/* the registered mutex handlers */
+static struct {
+ const char *name;
+ struct debug_ops ops;
+} debug_handlers;
+
+/**
+ log suspicious usage - print comments and backtrace
+*/
+_PUBLIC_ void log_suspicious_usage(const char *from, const char *info)
+{
+ if (!debug_handlers.ops.log_suspicious_usage) return;
+
+ debug_handlers.ops.log_suspicious_usage(from, info);
+}
+
+
+/**
+ print suspicious usage - print comments and backtrace
+*/
+_PUBLIC_ void print_suspicious_usage(const char* from, const char* info)
+{
+ if (!debug_handlers.ops.print_suspicious_usage) return;
+
+ debug_handlers.ops.print_suspicious_usage(from, info);
+}
+
+_PUBLIC_ uint32_t get_task_id(void)
+{
+ if (debug_handlers.ops.get_task_id) {
+ return debug_handlers.ops.get_task_id();
+ }
+ return getpid();
+}
+
+_PUBLIC_ void log_task_id(void)
+{
+ if (!debug_handlers.ops.log_task_id) return;
+
+ if (!reopen_logs_internal()) return;
+
+ debug_handlers.ops.log_task_id(state.fd);
+}
+
+/**
+ register a set of debug handlers.
+*/
+_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops)
+{
+ debug_handlers.name = name;
+ debug_handlers.ops = *ops;
+}
diff --git a/lib/util/debug.h b/lib/util/debug.h
new file mode 100644
index 0000000000..c01fa928b5
--- /dev/null
+++ b/lib/util/debug.h
@@ -0,0 +1,269 @@
+/*
+ Unix SMB/CIFS implementation.
+ SMB debug stuff
+ Copyright (C) Andrew Tridgell 1992-1998
+ Copyright (C) John H Terpstra 1996-1998
+ Copyright (C) Luke Kenneth Casson Leighton 1996-1998
+ Copyright (C) Paul Ashton 1998
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _DEBUG_H
+#define _DEBUG_H
+
+/* -------------------------------------------------------------------------- **
+ * Debugging code. See also debug.c
+ */
+
+/* the maximum debug level to compile into the code. This assumes a good
+ optimising compiler that can remove unused code
+ for embedded or low-memory systems set this to a value like 2 to get
+ only important messages. This gives *much* smaller binaries
+*/
+#ifndef MAX_DEBUG_LEVEL
+#define MAX_DEBUG_LEVEL 1000
+#endif
+
+int Debug1( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
+bool dbgtext( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
+bool dbghdrclass( int level, int cls, const char *location, const char *func);
+bool dbghdr( int level, const char *location, const char *func);
+
+/*
+ * Redefine DEBUGLEVEL because so we don't have to change every source file
+ * that *unnecessarily* references it.
+ */
+#define DEBUGLEVEL DEBUGLEVEL_CLASS[DBGC_ALL]
+
+/*
+ * Define all new debug classes here. A class is represented by an entry in
+ * the DEBUGLEVEL_CLASS array. Index zero of this arrray is equivalent to the
+ * old DEBUGLEVEL. Any source file that does NOT add the following lines:
+ *
+ * #undef DBGC_CLASS
+ * #define DBGC_CLASS DBGC_<your class name here>
+ *
+ * at the start of the file (after #include "includes.h") will default to
+ * using index zero, so it will behaive just like it always has.
+ */
+#define DBGC_ALL 0 /* index equivalent to DEBUGLEVEL */
+
+#define DBGC_TDB 1
+#define DBGC_PRINTDRIVERS 2
+#define DBGC_LANMAN 3
+#define DBGC_SMB 4
+#define DBGC_RPC_PARSE 5
+#define DBGC_RPC_SRV 6
+#define DBGC_RPC_CLI 7
+#define DBGC_PASSDB 8
+#define DBGC_SAM 9
+#define DBGC_AUTH 10
+#define DBGC_WINBIND 11
+#define DBGC_VFS 12
+#define DBGC_IDMAP 13
+#define DBGC_QUOTA 14
+#define DBGC_ACLS 15
+#define DBGC_LOCKING 16
+#define DBGC_MSDFS 17
+#define DBGC_DMAPI 18
+#define DBGC_REGISTRY 19
+
+/* Always ensure this is updated when new fixed classes area added, to ensure the array in debug.c is the right size */
+#define DBGC_MAX_FIXED 19
+
+/* So you can define DBGC_CLASS before including debug.h */
+#ifndef DBGC_CLASS
+#define DBGC_CLASS 0 /* override as shown above */
+#endif
+
+extern int *DEBUGLEVEL_CLASS;
+
+/* Debugging macros
+ *
+ * DEBUGLVL()
+ * If the 'file specific' debug class level >= level OR the system-wide
+ * DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ * generate a header using the default macros for file, line, and
+ * function name. Returns True if the debug level was <= DEBUGLEVEL.
+ *
+ * Example: if( DEBUGLVL( 2 ) ) dbgtext( "Some text.\n" );
+ *
+ * DEBUG()
+ * If the 'file specific' debug class level >= level OR the system-wide
+ * DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ * generate a header using the default macros for file, line, and
+ * function name. Each call to DEBUG() generates a new header *unless* the
+ * previous debug output was unterminated (i.e. no '\n').
+ * See debug.c:dbghdr() for more info.
+ *
+ * Example: DEBUG( 2, ("Some text and a value %d.\n", value) );
+ *
+ * DEBUGC()
+ * If the 'macro specified' debug class level >= level OR the system-wide
+ * DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ * generate a header using the default macros for file, line, and
+ * function name. Each call to DEBUG() generates a new header *unless* the
+ * previous debug output was unterminated (i.e. no '\n').
+ * See debug.c:dbghdr() for more info.
+ *
+ * Example: DEBUGC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
+ *
+ * DEBUGADD(), DEBUGADDC()
+ * Same as DEBUG() and DEBUGC() except the text is appended to the previous
+ * DEBUG(), DEBUGC(), DEBUGADD(), DEBUGADDC() with out another interviening
+ * header.
+ *
+ * Example: DEBUGADD( 2, ("Some text and a value %d.\n", value) );
+ * DEBUGADDC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
+ *
+ * Note: If the debug class has not be redeined (see above) then the optimizer
+ * will remove the extra conditional test.
+ */
+
+/*
+ * From talloc.c:
+ */
+
+/* these macros gain us a few percent of speed on gcc */
+#if (__GNUC__ >= 3)
+/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
+ as its first argument */
+#ifndef likely
+#define likely(x) __builtin_expect(!!(x), 1)
+#endif
+#ifndef unlikely
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#endif
+#else
+#ifndef likely
+#define likely(x) (x)
+#endif
+#ifndef unlikely
+#define unlikely(x) (x)
+#endif
+#endif
+
+#define CHECK_DEBUGLVL( level ) \
+ ( ((level) <= MAX_DEBUG_LEVEL) && \
+ unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level)))
+
+#define DEBUGLVL( level ) \
+ ( CHECK_DEBUGLVL(level) \
+ && dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ ) )
+
+
+#define DEBUG( level, body ) \
+ (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+ unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level)) \
+ && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
+ && (dbgtext body) )
+
+#define DEBUGC( dbgc_class, level, body ) \
+ (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+ unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level)) \
+ && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
+ && (dbgtext body) )
+
+#define DEBUGADD( level, body ) \
+ (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+ unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level)) \
+ && (dbgtext body) )
+
+#define DEBUGADDC( dbgc_class, level, body ) \
+ (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+ unlikely((DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))) \
+ && (dbgtext body) )
+
+/* Print a separator to the debug log. */
+#define DEBUGSEP(level)\
+ DEBUG((level),("===============================================================\n"))
+
+/* The following definitions come from lib/debug.c */
+
+/** Possible destinations for the debug log (in order of precedence -
+ * once set to DEBUG_FILE, it is not possible to reset to DEBUG_STDOUT
+ * for example. This makes it easy to override for debug to stderr on
+ * the command line, as the smb.conf cannot reset it back to
+ * file-based logging */
+enum debug_logtype {DEBUG_DEFAULT_STDERR = 0, DEBUG_STDOUT = 1, DEBUG_FILE = 2, DEBUG_STDERR = 3};
+
+struct debug_settings {
+ size_t max_log_size;
+ bool syslog;
+ bool syslog_only;
+ bool timestamp_logs;
+ bool debug_prefix_timestamp;
+ bool debug_hires_timestamp;
+ bool debug_pid;
+ bool debug_uid;
+ bool debug_class;
+};
+
+void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
+
+void debug_close_dbf(void);
+void gfree_debugsyms(void);
+int debug_add_class(const char *classname);
+int debug_lookup_classname(const char *classname);
+bool debug_parse_levels(const char *params_str);
+void debug_setup_talloc_log(void);
+void debug_set_logfile(const char *name);
+void debug_set_settings(struct debug_settings *settings);
+bool reopen_logs_internal( void );
+void force_check_log_size( void );
+bool need_to_check_log_size( void );
+void check_log_size( void );
+void dbgflush( void );
+bool dbghdrclass(int level, int cls, const char *location, const char *func);
+bool dbghdr(int level, const char *location, const char *func);
+bool debug_get_output_is_stderr(void);
+void debug_schedule_reopen_logs(void);
+char *debug_list_class_names_and_levels(void);
+
+/**
+ log suspicious usage - print comments and backtrace
+*/
+_PUBLIC_ void log_suspicious_usage(const char *from, const char *info);
+
+/**
+ print suspicious usage - print comments and backtrace
+*/
+_PUBLIC_ void print_suspicious_usage(const char* from, const char* info);
+_PUBLIC_ uint32_t get_task_id(void);
+_PUBLIC_ void log_task_id(void);
+
+/* the debug operations structure - contains function pointers to
+ various debug implementations of each operation */
+struct debug_ops {
+ /* function to log (using DEBUG) suspicious usage of data structure */
+ void (*log_suspicious_usage)(const char* from, const char* info);
+
+ /* function to log (using printf) suspicious usage of data structure.
+ * To be used in circumstances when using DEBUG would cause loop. */
+ void (*print_suspicious_usage)(const char* from, const char* info);
+
+ /* function to return process/thread id */
+ uint32_t (*get_task_id)(void);
+
+ /* function to log process/thread id */
+ void (*log_task_id)(int fd);
+};
+
+/**
+ register a set of debug handlers.
+*/
+_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops);
+
+#endif
diff --git a/lib/util/debug_s3.c b/lib/util/debug_s3.c
new file mode 100644
index 0000000000..b81daea5a7
--- /dev/null
+++ b/lib/util/debug_s3.c
@@ -0,0 +1,105 @@
+/*
+ Unix SMB/CIFS implementation.
+ Samba utility functions
+ Copyright (C) Andrew Bartlett 2011
+ Copyright (C) Andrew Tridgell 1992-2002
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "librpc/gen_ndr/messaging.h"
+
+/* This is the Samba3-specific implementation of reopen_logs(), which
+ * calls out to the s3 loadparm code, and means that we don't depend
+ * on loadparm directly. */
+
+bool reopen_logs(void)
+{
+ if (lp_loaded()) {
+ struct debug_settings settings;
+ debug_set_logfile(lp_logfile());
+
+ ZERO_STRUCT(settings);
+ settings.max_log_size = lp_max_log_size();
+ settings.syslog = lp_syslog();
+ settings.syslog_only = lp_syslog_only();
+ settings.timestamp_logs = lp_timestamp_logs();
+ settings.debug_prefix_timestamp = lp_debug_prefix_timestamp();
+ settings.debug_hires_timestamp = lp_debug_hires_timestamp();
+ settings.debug_pid = lp_debug_pid();
+ settings.debug_uid = lp_debug_uid();
+ settings.debug_class = lp_debug_class();
+ debug_set_settings(&settings);
+ }
+ return reopen_logs_internal();
+}
+
+/****************************************************************************
+ Receive a "set debug level" message.
+****************************************************************************/
+
+void debug_message(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
+{
+ const char *params_str = (const char *)data->data;
+
+ /* Check, it's a proper string! */
+ if (params_str[(data->length)-1] != '\0') {
+ DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
+ (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)procid_to_pid(&src)));
+
+ debug_parse_levels(params_str);
+}
+
+/****************************************************************************
+ Return current debug level.
+****************************************************************************/
+
+static void debuglevel_message(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
+{
+ char *message = debug_list_class_names_and_levels();
+
+ if (!message) {
+ DEBUG(0,("debuglevel_message - debug_list_class_names_and_levels returned NULL\n"));
+ return;
+ }
+
+ DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %s\n",
+ procid_str_static(&src)));
+ messaging_send_buf(msg_ctx, src, MSG_DEBUGLEVEL,
+ (uint8 *)message, strlen(message) + 1);
+
+ TALLOC_FREE(message);
+}
+void debug_register_msgs(struct messaging_context *msg_ctx)
+{
+ messaging_register(msg_ctx, NULL, MSG_DEBUG, debug_message);
+ messaging_register(msg_ctx, NULL, MSG_REQ_DEBUGLEVEL,
+ debuglevel_message);
+}
diff --git a/lib/util/debug_s3.h b/lib/util/debug_s3.h
new file mode 100644
index 0000000000..ce8869d64c
--- /dev/null
+++ b/lib/util/debug_s3.h
@@ -0,0 +1,23 @@
+/*
+ Unix SMB/CIFS implementation.
+ SMB debug stuff
+ Copyright (C) Andrew Tridgell 2002
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+struct messaging_context;
+void debug_message(struct messaging_context *msg_ctx, void *private_data, uint32_t msg_type, struct server_id src, DATA_BLOB *data);
+void debug_register_msgs(struct messaging_context *msg_ctx);
+bool reopen_logs( void );
diff --git a/lib/util/debug_s4.c b/lib/util/debug_s4.c
deleted file mode 100644
index 845240fdb7..0000000000
--- a/lib/util/debug_s4.c
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- Unix SMB/CIFS implementation.
- Samba debug functions
- Copyright (C) Andrew Tridgell 2003
- Copyright (C) James J Myers 2003
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "includes.h"
-#include "system/filesys.h"
-#include "system/time.h"
-#include "dynconfig/dynconfig.h"
-
-/**
- * @file
- * @brief Debug logging
- **/
-
-/**
- * this global variable determines what messages are printed
- */
-int _debug_level = 0;
-_PUBLIC_ int *debug_level = &_debug_level;
-static int debug_all_class_hack = 1;
-int *DEBUGLEVEL_CLASS = &debug_all_class_hack; /* For samba 3 */
-static bool debug_all_class_isset_hack = true;
-bool *DEBUGLEVEL_CLASS_ISSET = &debug_all_class_isset_hack; /* For samba 3 */
-
-/* the registered mutex handlers */
-static struct {
- const char *name;
- struct debug_ops ops;
-} debug_handlers;
-
-/* state variables for the debug system */
-static struct {
- int fd; /* The log file handle */
- enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
- const char *prog_name;
- bool reopening_logs;
-} state;
-
-static bool reopen_logs_scheduled;
-static bool check_reopen_logs(void)
-{
- if (state.fd == 0 || reopen_logs_scheduled) {
- reopen_logs_scheduled = false;
- reopen_logs();
- }
-
- if (state.fd <= 0)
- return false;
-
- return true;
-}
-
-_PUBLIC_ void debug_schedule_reopen_logs(void)
-{
- reopen_logs_scheduled = true;
-}
-
-static void log_timestring(int level, const char *location, const char *func)
-{
- char *t = NULL;
- char *s = NULL;
-
- if (!check_reopen_logs()) return;
-
- if (state.logtype != DEBUG_FILE) return;
-
- t = timestring(NULL, time(NULL));
- if (!t) return;
-
- asprintf(&s, "[%s, %d %s:%s()]\n", t, level, location, func);
- talloc_free(t);
- if (!s) return;
-
- write(state.fd, s, strlen(s));
- free(s);
-}
-
-/**
- the backend for debug messages. Note that the DEBUG() macro has already
- ensured that the log level has been met before this is called
-*/
-_PUBLIC_ void dbghdr(int level, const char *location, const char *func)
-{
- log_timestring(level, location, func);
- log_task_id();
-}
-
-
-_PUBLIC_ void dbghdrclass(int level, int dclass, const char *location, const char *func)
-{
- /* Simple wrapper, Samba 4 doesn't do debug classes */
- dbghdr(level, location, func);
-}
-
-/**
- the backend for debug messages. Note that the DEBUG() macro has already
- ensured that the log level has been met before this is called
-
- @note You should never have to call this function directly. Call the DEBUG()
- macro instead.
-*/
-_PUBLIC_ void dbgtext(const char *format, ...)
-{
- va_list ap;
-
- if (!check_reopen_logs()) return;
-
- va_start(ap, format);
- vdprintf(state.fd, format, ap);
- va_end(ap);
-}
-
-_PUBLIC_ const char *logfile = NULL;
-
-/**
- reopen the log file (usually called because the log file name might have changed)
-*/
-_PUBLIC_ void reopen_logs(void)
-{
- char *fname = NULL;
- int old_fd = state.fd;
- if (state.reopening_logs) {
- return;
- }
-
- switch (state.logtype) {
- case DEBUG_STDOUT:
- case DEBUG_DEFAULT_STDOUT:
- state.fd = 1;
- break;
-
- case DEBUG_STDERR:
- case DEBUG_DEFAULT_STDERR:
- state.fd = 2;
- break;
-
- case DEBUG_FILE:
- state.reopening_logs = true;
- if (logfile && (*logfile) == '/') {
- fname = strdup(logfile);
- } else {
- asprintf(&fname, "%s/%s.log", dyn_LOGFILEBASE, state.prog_name);
- }
- if (fname) {
- int newfd = open(fname, O_CREAT|O_APPEND|O_WRONLY, 0600);
- if (newfd == -1) {
- DEBUG(1, ("Failed to open new logfile: %s\n", fname));
- old_fd = -1;
- } else {
- state.fd = newfd;
- }
- free(fname);
- } else {
- DEBUG(1, ("Failed to find name for file-based logfile!\n"));
- }
- state.reopening_logs = false;
-
- break;
- }
-
- if (old_fd > 2) {
- close(old_fd);
- }
-}
-
-/* setup for logging of talloc warnings */
-static void talloc_log_fn(const char *msg)
-{
- DEBUG(0,("%s", msg));
-}
-
-void debug_setup_talloc_log(void)
-{
- talloc_set_log_fn(talloc_log_fn);
-}
-
-/**
- control the name of the logfile and whether logging will be to stdout, stderr
- or a file, and set up syslog
-
- new_log indicates the destination for the debug log (an enum in
- order of precedence - once set to DEBUG_FILE, it is not possible to
- reset to DEBUG_STDOUT for example. This makes it easy to override
- for debug to stderr on the command line, as the smb.conf cannot
- reset it back to file-based logging
-*/
-_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
-{
- debug_setup_talloc_log();
- if (state.logtype < new_logtype) {
- state.logtype = new_logtype;
- }
- if (prog_name) {
- state.prog_name = prog_name;
- }
- reopen_logs();
-}
-
-/**
- return a string constant containing n tabs
- no more than 10 tabs are returned
-*/
-_PUBLIC_ const char *do_debug_tab(int n)
-{
- const char *tabs[] = {"", "\t", "\t\t", "\t\t\t", "\t\t\t\t", "\t\t\t\t\t",
- "\t\t\t\t\t\t", "\t\t\t\t\t\t\t", "\t\t\t\t\t\t\t\t",
- "\t\t\t\t\t\t\t\t\t", "\t\t\t\t\t\t\t\t\t\t"};
- return tabs[MIN(n, 10)];
-}
-
-
-/**
- log suspicious usage - print comments and backtrace
-*/
-_PUBLIC_ void log_suspicious_usage(const char *from, const char *info)
-{
- if (!debug_handlers.ops.log_suspicious_usage) return;
-
- debug_handlers.ops.log_suspicious_usage(from, info);
-}
-
-
-/**
- print suspicious usage - print comments and backtrace
-*/
-_PUBLIC_ void print_suspicious_usage(const char* from, const char* info)
-{
- if (!debug_handlers.ops.print_suspicious_usage) return;
-
- debug_handlers.ops.print_suspicious_usage(from, info);
-}
-
-_PUBLIC_ uint32_t get_task_id(void)
-{
- if (debug_handlers.ops.get_task_id) {
- return debug_handlers.ops.get_task_id();
- }
- return getpid();
-}
-
-_PUBLIC_ void log_task_id(void)
-{
- if (!debug_handlers.ops.log_task_id) return;
-
- if (!check_reopen_logs()) return;
-
- debug_handlers.ops.log_task_id(state.fd);
-}
-
-/**
- register a set of debug handlers.
-*/
-_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops)
-{
- debug_handlers.name = name;
- debug_handlers.ops = *ops;
-}
diff --git a/lib/util/debug_s4.h b/lib/util/debug_s4.h
deleted file mode 100644
index 055edcb3c4..0000000000
--- a/lib/util/debug_s4.h
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- Unix SMB/CIFS implementation.
- Samba debug defines
- Copyright (C) Andrew Tridgell 2003
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _SAMBA_DEBUG_H_
-#define _SAMBA_DEBUG_H_
-
-/**
- * @file
- * @brief Debugging macros
- */
-
-/* the debug operations structure - contains function pointers to
- various debug implementations of each operation */
-struct debug_ops {
- /* function to log (using DEBUG) suspicious usage of data structure */
- void (*log_suspicious_usage)(const char* from, const char* info);
-
- /* function to log (using printf) suspicious usage of data structure.
- * To be used in circumstances when using DEBUG would cause loop. */
- void (*print_suspicious_usage)(const char* from, const char* info);
-
- /* function to return process/thread id */
- uint32_t (*get_task_id)(void);
-
- /* function to log process/thread id */
- void (*log_task_id)(int fd);
-};
-
-#define DEBUGLEVEL *debug_level
-extern int DEBUGLEVEL;
-
-#define DEBUGLVL(level) ((level) <= DEBUGLEVEL)
-#define _DEBUG(level, body, header) do { \
- if (DEBUGLVL(level)) { \
- if (header) { \
- dbghdr(level, __location__, __FUNCTION__); \
- } \
- dbgtext body; \
- } \
-} while (0)
-/**
- * Write to the debug log.
- */
-#define DEBUG(level, body) _DEBUG(level, body, true)
-/**
- * Add data to an existing debug log entry.
- */
-#define DEBUGADD(level, body) _DEBUG(level, body, false)
-
-/* Compatiblity macros for the source3 calling convention */
-#define DEBUGC(class, level, body) _DEBUG(level, body, true)
-#define DEBUGADDC(class, level, body) _DEBUG(level, body, false)
-
-/**
- * Obtain indentation string for the debug log.
- *
- * Level specified by n.
- */
-#define DEBUGTAB(n) do_debug_tab(n)
-
-/** Possible destinations for the debug log (in order of precedence -
- * once set to DEBUG_FILE, it is not possible to reset to DEBUG_STDOUT
- * for example. This makes it easy to override for debug to stderr on
- * the command line, as the smb.conf cannot reset it back to
- * file-based logging */
-enum debug_logtype {DEBUG_DEFAULT_STDOUT = 0,
- DEBUG_DEFAULT_STDERR,
- DEBUG_STDOUT,
- DEBUG_FILE,
- DEBUG_STDERR};
-
-/**
- the backend for debug messages. Note that the DEBUG() macro has already
- ensured that the log level has been met before this is called
-*/
-_PUBLIC_ void dbghdr(int level, const char *location, const char *func);
-
-_PUBLIC_ void dbghdrclass(int level, int cls, const char *location, const char *func);
-
-/**
- reopen the log file (usually called because the log file name might have changed)
-*/
-_PUBLIC_ void reopen_logs(void);
-
-/**
- * this global variable determines what messages are printed
- */
-_PUBLIC_ void debug_schedule_reopen_logs(void);
-
-/**
- control the name of the logfile and whether logging will be to stdout, stderr
- or a file
-*/
-_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
-
-/**
- return a string constant containing n tabs
- no more than 10 tabs are returned
-*/
-_PUBLIC_ const char *do_debug_tab(int n);
-
-/**
- log suspicious usage - print comments and backtrace
-*/
-_PUBLIC_ void log_suspicious_usage(const char *from, const char *info);
-
-/**
- print suspicious usage - print comments and backtrace
-*/
-_PUBLIC_ void print_suspicious_usage(const char* from, const char* info);
-_PUBLIC_ uint32_t get_task_id(void);
-_PUBLIC_ void log_task_id(void);
-
-/**
- register a set of debug handlers.
-*/
-_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops);
-
-/**
- the backend for debug messages. Note that the DEBUG() macro has already
- ensured that the log level has been met before this is called
-
- @note You should never have to call this function directly. Call the DEBUG()
- macro instead.
-*/
-_PUBLIC_ void dbgtext(const char *format, ...) PRINTF_ATTRIBUTE(1,2);
-
-struct _XFILE;
-extern struct _XFILE *dbf;
-
-/* setup talloc logging */
-void debug_setup_talloc_log(void);
-
-#endif
diff --git a/lib/util/wscript_build b/lib/util/wscript_build
index cc53dd3f75..0468b74546 100644
--- a/lib/util/wscript_build
+++ b/lib/util/wscript_build
@@ -7,23 +7,25 @@ bld.SAMBA_LIBRARY('samba-util-common',
util_file.c time.c rbtree.c rfc1738.c select.c
genrand.c fsusage.c blocking.c become_daemon.c
data_blob.c signal.c system.c params.c util.c util_id.c util_net.c
- util_strlist.c idtree.c''',
+ util_strlist.c idtree.c debug.c''',
public_deps='talloc pthread',
# until we get all the dependencies in this library in common
# we need to allow this library to be built with unresolved symbols
allow_undefined_symbols=True,
local_include=False,
+ public_headers='debug.h',
+ header_path= [('*', 'util') ],
private_library=True
)
if bld.env._SAMBA_BUILD_ == 4:
bld.SAMBA_LIBRARY('samba-util',
- source='''debug_s4.c dprintf.c fault.c
+ source='''dprintf.c fault.c
ms_fnmatch.c parmlist.c substitute.c util_str.c
''',
deps='samba-util-common',
public_deps='talloc LIBCRYPTO CHARSET execinfo uid_wrapper',
- public_headers='attr.h byteorder.h data_blob.h debug.h memory.h safe_string.h time.h talloc_stack.h xfile.h dlinklist.h util.h',
+ public_headers='attr.h byteorder.h data_blob.h memory.h safe_string.h time.h talloc_stack.h xfile.h dlinklist.h util.h',
header_path= [ ('dlinklist.h util.h', '.'), ('*', 'util') ],
local_include=False,
vnum='0.0.1',