Changeset 988 for vendor/current/lib/util/debug.c

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

File:

• vendor/current/lib/util/debug.c (modified) (35 diffs)

vendor/current/lib/util/debug.c

@@ -20 +20 @@
 */
 
-#include "includes.h"
+#include "replace.h"
+#include <talloc.h>
 #include "system/filesys.h"
 #include "system/syslog.h"
-#include "lib/util/time.h"
+#include "system/locale.h"
+#include "time_basic.h"
+#include "close_low_fd.h"
+#include "memory.h"
+#include "samba_util.h" /* LIST_SEP */
+#include "debug.h"
 
 /* define what facility to use for syslog */
@@ -32 +38 @@
 /* -------------------------------------------------------------------------- **
  * 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.
  */
 
+/*
+ * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
+ * for a terminating null byte.
+ */
 #define FORMAT_BUFR_SIZE 1024
-#define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
 
 /* -------------------------------------------------------------------------- **
@@ -89 +94 @@
         struct debug_settings settings;
         char *debugf;
+        debug_callback_fn callback;
+        void *callback_private;
 } state = {
         .settings = {
                 .timestamp_logs = true
-        }
+        },
+        .fd = 2 /* stderr by default */
 };
+
+#if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL)
+static int debug_level_to_priority(int level)
+{
+        /*
+         * map debug levels to syslog() priorities
+         */
+        static const int priority_map[] = {
+                LOG_ERR,     /* 0 */
+                LOG_WARNING, /* 1 */
+                LOG_NOTICE,  /* 2 */
+                LOG_NOTICE,  /* 3 */
+                LOG_NOTICE,  /* 4 */
+                LOG_NOTICE,  /* 5 */
+                LOG_INFO,    /* 6 */
+                LOG_INFO,    /* 7 */
+                LOG_INFO,    /* 8 */
+                LOG_INFO,    /* 9 */
+        };
+        int priority;
+
+        if( level >= ARRAY_SIZE(priority_map) || level < 0)
+                priority = LOG_DEBUG;
+        else
+                priority = priority_map[level];
+
+        return priority;
+}
+#endif
+
+/* -------------------------------------------------------------------------- **
+ * Debug backends. When logging to DEBUG_FILE, send the log entries to
+ * all active backends.
+ */
+
+static void debug_file_log(int msg_level,
+                           const char *msg, const char *msg_no_nl)
+{
+        check_log_size();
+        write(state.fd, msg, strlen(msg));
+}
+
+#ifdef WITH_SYSLOG
+static void debug_syslog_reload(bool enabled, bool previously_enabled,
+                                const char *prog_name)
+{
+        if (enabled && !previously_enabled) {
+#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
+                return;
+        }
+
+        if (!enabled && previously_enabled) {
+                closelog();
+        }
+}
+
+static void debug_syslog_log(int msg_level,
+                             const char *msg, const char *msg_no_nl)
+{
+        int priority;
+
+        priority = debug_level_to_priority(msg_level);
+
+        /*
+         * Specify the facility to interoperate with other syslog
+         * callers (vfs_full_audit for example).
+         */
+        priority |= SYSLOG_FACILITY;
+
+        syslog(priority, "%s", msg);
+}
+#endif /* WITH_SYSLOG */
+
+#ifdef HAVE_LIBSYSTEMD_JOURNAL
+#include <systemd/sd-journal.h>
+static void debug_systemd_log(int msg_level,
+                              const char *msg, const char *msg_no_nl)
+{
+        sd_journal_send("MESSAGE=%s", msg_no_nl,
+                        "PRIORITY=%d", debug_level_to_priority(msg_level),
+                        "LEVEL=%d", msg_level,
+                        NULL);
+}
+#endif
+
+#ifdef HAVE_LTTNG_TRACEF
+#include <lttng/tracef.h>
+static void debug_lttng_log(int msg_level,
+                            const char *msg, const char *msg_no_nl)
+{
+        tracef(msg_no_nl);
+}
+#endif /* WITH_LTTNG_TRACEF */
+
+#ifdef HAVE_GPFS
+#include "gpfswrap.h"
+static void debug_gpfs_reload(bool enabled, bool previously_enabled,
+                              const char *prog_name)
+{
+        gpfswrap_init();
+
+        if (enabled && !previously_enabled) {
+                gpfswrap_init_trace();
+                return;
+        }
+
+        if (!enabled && previously_enabled) {
+                gpfswrap_fini_trace();
+                return;
+        }
+
+        if (enabled) {
+                /*
+                 * Trigger GPFS library to adjust state if necessary.
+                 */
+                gpfswrap_query_trace();
+        }
+}
+
+static void debug_gpfs_log(int msg_level,
+                           const char *msg, const char *msg_no_nl)
+{
+        gpfswrap_add_trace(msg_level, msg_no_nl);
+}
+#endif /* HAVE_GPFS */
+
+static struct debug_backend {
+        const char *name;
+        int log_level;
+        int new_log_level;
+        void (*reload)(bool enabled, bool prev_enabled, const char *prog_name);
+        void (*log)(int msg_level, const char *msg, const char *msg_no_nl);
+} debug_backends[] = {
+        {
+                .name = "file",
+                .log = debug_file_log,
+        },
+#ifdef WITH_SYSLOG
+        {
+                .name = "syslog",
+                .reload = debug_syslog_reload,
+                .log = debug_syslog_log,
+        },
+#endif
+
+#ifdef HAVE_LIBSYSTEMD_JOURNAL
+        {
+                .name = "systemd",
+                .log = debug_systemd_log,
+        },
+#endif
+
+#ifdef HAVE_LTTNG_TRACEF
+        {
+                .name = "lttng",
+                .log = debug_lttng_log,
+        },
+#endif
+
+#ifdef HAVE_GPFS
+        {
+                .name = "gpfs",
+                .reload = debug_gpfs_reload,
+                .log = debug_gpfs_log,
+        },
+#endif
+};
+
+static struct debug_backend *debug_find_backend(const char *name)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
+                if (strcmp(name, debug_backends[i].name) == 0) {
+                        return &debug_backends[i];
+                }
+        }
+
+        return NULL;
+}
+
+/*
+ * parse "backend[:option][@loglevel]
+ */
+static void debug_backend_parse_token(char *tok)
+{
+        char *backend_name_option, *backend_name,*backend_level, *saveptr;
+        struct debug_backend *b;
+
+        /*
+         * First parse into backend[:option] and loglevel
+         */
+        backend_name_option = strtok_r(tok, "@\0", &saveptr);
+        if (backend_name_option == NULL) {
+                return;
+        }
+
+        backend_level = strtok_r(NULL, "\0", &saveptr);
+
+        /*
+         * Now parse backend[:option]
+         */
+        backend_name = strtok_r(backend_name_option, ":\0", &saveptr);
+        if (backend_name == NULL) {
+                return;
+        }
+
+        /*
+         * No backend is using the option yet.
+         */
+#if 0
+        backend_option = strtok_r(NULL, "\0", &saveptr);
+#endif
+
+        /*
+         * Find and update backend
+         */
+        b = debug_find_backend(backend_name);
+        if (b == NULL) {
+                return;
+        }
+
+        if (backend_level == NULL) {
+                b->new_log_level = MAX_DEBUG_LEVEL;
+        } else {
+                b->new_log_level = atoi(backend_level);
+        }
+}
+
+/*
+ * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
+ * and enable/disable backends accordingly
+ */
+static void debug_set_backends(const char *param)
+{
+        size_t str_len = strlen(param);
+        char str[str_len+1];
+        char *tok, *saveptr;
+        int i;
+
+        /*
+         * initialize new_log_level to detect backends that have been
+         * disabled
+         */
+        for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
+                debug_backends[i].new_log_level = -1;
+        }
+
+        memcpy(str, param, str_len + 1);
+
+        tok = strtok_r(str, LIST_SEP, &saveptr);
+        if (tok == NULL) {
+                return;
+        }
+
+        while (tok != NULL) {
+                debug_backend_parse_token(tok);
+                tok = strtok_r(NULL, LIST_SEP, &saveptr);
+        }
+
+        /*
+         * Let backends react to config changes
+         */
+        for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
+                struct debug_backend *b = &debug_backends[i];
+
+                if (b->reload) {
+                        bool enabled = b->new_log_level > -1;
+                        bool previously_enabled = b->log_level > -1;
+
+                        b->reload(enabled, previously_enabled, state.prog_name);
+                }
+                b->log_level = b->new_log_level;
+        }
+}
+
+static void debug_backends_log(const char *msg, int msg_level)
+{
+        char msg_no_nl[FORMAT_BUFR_SIZE];
+        int i, len;
+
+        /*
+         * Some backends already add an extra newline, so also provide
+         * a buffer without the newline character.
+         */
+        len = MIN(strlen(msg), FORMAT_BUFR_SIZE - 1);
+        if (msg[len - 1] == '\n') {
+                len--;
+        }
+
+        memcpy(msg_no_nl, msg, len);
+        msg_no_nl[len] = '\0';
+
+        for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
+                if (msg_level <= debug_backends[i].log_level) {
+                        debug_backends[i].log(msg_level, msg, msg_no_nl);
+                }
+        }
+}
 
 /* -------------------------------------------------------------------------- **
  * External variables.
- *
- *  debugf        - Debug file name.
- *  DEBUGLEVEL    - System-wide debug message limit.  Messages with message-
- *                  levels higher than DEBUGLEVEL will not be processed.
  */
 
@@ -109 +417 @@
 bool    override_logfile;
 
+static const char *default_classname_table[] = {
+        [DBGC_ALL] =            "all",
+        [DBGC_TDB] =            "tdb",
+        [DBGC_PRINTDRIVERS] =   "printdrivers",
+        [DBGC_LANMAN] =         "lanman",
+        [DBGC_SMB] =            "smb",
+        [DBGC_RPC_PARSE] =      "rpc_parse",
+        [DBGC_RPC_SRV] =        "rpc_srv",
+        [DBGC_RPC_CLI] =        "rpc_cli",
+        [DBGC_PASSDB] =         "passdb",
+        [DBGC_SAM] =            "sam",
+        [DBGC_AUTH] =           "auth",
+        [DBGC_WINBIND] =        "winbind",
+        [DBGC_VFS] =            "vfs",
+        [DBGC_IDMAP] =          "idmap",
+        [DBGC_QUOTA] =          "quota",
+        [DBGC_ACLS] =           "acls",
+        [DBGC_LOCKING] =        "locking",
+        [DBGC_MSDFS] =          "msdfs",
+        [DBGC_DMAPI] =          "dmapi",
+        [DBGC_REGISTRY] =       "registry",
+        [DBGC_SCAVENGER] =      "scavenger",
+        [DBGC_DNS] =            "dns",
+        [DBGC_LDB] =            "ldb",
+        [DBGC_TEVENT] =         "tevent",
+};
+
 /*
  * 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 const int debug_class_list_initial[ARRAY_SIZE(default_classname_table)];
 
 static int debug_num_classes = 0;
@@ -125 +460 @@
  *                    Used to check log size.
  *
- *  syslog_level    - Internal copy of the message debug level.  Written by
+ *  current_msg_level    - Internal copy of the message debug level.  Written by
  *                    dbghdr() and read by Debug1().
  *
@@ -143 +478 @@
 
 static int     debug_count    = 0;
-#ifdef WITH_SYSLOG
-static int     syslog_level   = 0;
-#endif
-static char *format_bufr = NULL;
+static int     current_msg_level   = 0;
+static char format_bufr[FORMAT_BUFR_SIZE];
 static size_t     format_pos     = 0;
 static bool    log_overflow   = false;
@@ -155 +488 @@
  * 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;
@@ -200 +510 @@
                 DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
         }
-
-        TALLOC_FREE(format_bufr);
 
         debug_num_classes = 0;
@@ -218 +526 @@
         /* prepare strings */
         for (i = 0; i < debug_num_classes; i++) {
-                buf = talloc_asprintf_append(buf, 
+                buf = talloc_asprintf_append(buf,
                                              "%s:%d%s",
                                              classname_table[i],
@@ -303 +611 @@
 ****************************************************************************/
 
-int debug_lookup_classname(const char *classname)
+static int debug_lookup_classname(const char *classname)
 {
         int ndx;
@@ -337 +645 @@
 }
 
-/****************************************************************************
- parse the debug levels from smbcontrol. Example debug level parameter:
- printdrivers:7
-****************************************************************************/
-
-static bool debug_parse_params(char **params)
-{
-        int   i, ndx;
+static bool debug_parse_param(char *param)
+{
         char *class_name;
         char *class_level;
-
-        if (!params)
+        char *saveptr;
+        int ndx;
+
+        class_name = strtok_r(param, ":", &saveptr);
+        if (class_name == NULL) {
                 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;
-                }
-        }
+        }
+
+        class_level = strtok_r(NULL, "\0", &saveptr);
+        if (class_level == NULL) {
+                return false;
+        }
+
+        ndx = debug_lookup_classname(class_name);
+        if (ndx == -1) {
+                return false;
+        }
+
+        DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
 
         return true;
@@ -391 +680 @@
 bool debug_parse_levels(const char *params_str)
 {
-        char **params;
+        size_t str_len = strlen(params_str);
+        char str[str_len+1];
+        char *tok, *saveptr;
+        int i;
 
         /* 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);
+        memcpy(str, params_str, str_len+1);
+
+        tok = strtok_r(str, LIST_SEP, &saveptr);
+        if (tok == NULL) {
                 return true;
+        }
+
+        /* 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(tok[0])) {
+                DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(tok);
+                tok = strtok_r(NULL, LIST_SEP, &saveptr);
         } else {
-                TALLOC_FREE(params);
-                return false;
-        }
+                DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
+        }
+
+        /* Array is debug_num_classes long */
+        for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
+                DEBUGLEVEL_CLASS[i] = DEBUGLEVEL_CLASS[DBGC_ALL];
+        }
+
+        while (tok != NULL) {
+                bool ok;
+
+                ok = debug_parse_param(tok);
+                if (!ok) {
+                        DEBUG(0,("debug_parse_params: unrecognized debug "
+                                 "class name or format [%s]\n", tok));
+                        return false;
+                }
+
+                tok = strtok_r(NULL, LIST_SEP, &saveptr);
+        }
+
+        debug_dump_status(5);
+
+        return true;
 }
 
@@ -426 +746 @@
 static void debug_init(void)
 {
-        const char **p;
+        size_t i;
 
         if (state.initialized)
@@ -435 +755 @@
         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)
-{
+        for (i = 0; i < ARRAY_SIZE(default_classname_table); i++) {
+                debug_add_class(default_classname_table[i]);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
+                debug_backends[i].log_level = -1;
+                debug_backends[i].new_log_level = -1;
+        }
+}
+
+void debug_set_settings(struct debug_settings *settings,
+                        const char *logging_param,
+                        int syslog_level, bool syslog_only)
+{
+        char fake_param[256];
+        size_t len = 0;
+
+        /*
+         * 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
+         */
         state.settings = *settings;
+
+        /*
+         * If 'logging' is not set, create backend settings from
+         * deprecated 'syslog' and 'syslog only' parameters
+         */
+        if (logging_param != NULL) {
+                len = strlen(logging_param);
+        }
+        if (len == 0) {
+                if (syslog_only) {
+                        snprintf(fake_param, sizeof(fake_param),
+                                 "syslog@%d", syslog_level - 1);
+                } else {
+                        snprintf(fake_param, sizeof(fake_param),
+                                 "syslog@%d file@%d", syslog_level -1,
+                                 MAX_DEBUG_LEVEL);
+                }
+
+                logging_param = fake_param;
+        }
+
+        debug_set_backends(logging_param);
 }
 
@@ -469 +819 @@
         }
         if (prog_name) {
+                const char *p = strrchr(prog_name, '/');
+
+                if (p) {
+                        prog_name = p + 1;
+                }
+
                 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
-        }
 }
 
@@ -512 +854 @@
 {
         return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
+}
+
+bool debug_get_output_is_stdout(void)
+{
+        return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
+}
+
+void debug_set_callback(void *private_ptr, debug_callback_fn fn)
+{
+        debug_init();
+        if (fn) {
+                state.logtype = DEBUG_CALLBACK;
+                state.callback_private = private_ptr;
+                state.callback = fn;
+        } else {
+                state.logtype = DEBUG_DEFAULT_STDERR;
+                state.callback_private = NULL;
+                state.callback = NULL;
+        }
+}
+
+static void debug_callback_log(const char *msg, int msg_level)
+{
+        size_t msg_len = strlen(msg);
+        char msg_copy[msg_len];
+
+        if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
+                memcpy(msg_copy, msg, msg_len-1);
+                msg_copy[msg_len-1] = '\0';
+                msg = msg_copy;
+        }
+
+        state.callback(state.callback_private, msg_level, msg);
 }
 
@@ -532 +907 @@
         bool ret = true;
 
-        char *fname = NULL;
         if (state.reopening_logs) {
                 return true;
@@ -541 +915 @@
 
         switch (state.logtype) {
+        case DEBUG_CALLBACK:
+                return true;
         case DEBUG_STDOUT:
+        case DEBUG_DEFAULT_STDOUT:
                 debug_close_fd(state.fd);
                 state.fd = 1;
@@ -558 +935 @@
         oldumask = umask( 022 );
 
-        fname = state.debugf;
-        if (!fname) {
+        if (!state.debugf) {
                 return false;
         }
@@ -573 +949 @@
                 ret = false;
         } else {
+                smb_set_close_on_exec(new_fd);
                 old_fd = state.fd;
                 state.fd = new_fd;
@@ -586 +963 @@
 
         /* 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 */
+        if (state.fd > 0) {
+                if (dup2(state.fd, 2) == -1) {
+                        /* Close stderr too, if dup2 can't point it -
+                           at the logfile.  There really isn't much
+                           that can be done on such a fundamental
+                           failure... */
+                        close_low_fd(2);
+                }
         }
 
@@ -644 +1026 @@
          */
 
-        if( geteuid() != 0) {
+#if _SAMBA_BUILD_ == 3
+        if (geteuid() != sec_initial_uid())
+#else
+        if( geteuid() != 0)
+#endif
+        {
                 /* We don't check sec_initial_uid() here as it isn't
                  * available in common code and we don't generally
@@ -658 +1045 @@
         maxlog = state.settings.max_log_size * 1024;
 
-        if (state.schedule_reopen_logs ||
-           (fstat(state.fd, &st) == 0
+        if (state.schedule_reopen_logs) {
+            (void)reopen_logs_internal();
+        }
+
+        if (maxlog && (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);
+                if (state.fd > 2 && (fstat(state.fd, &st) == 0
+                                     && st.st_size > maxlog)) {
+                        char name[strlen(state.debugf) + 5];
+
+                        snprintf(name, sizeof(name), "%s.old", state.debugf);
+
+                        (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);
                         }
                 }
@@ -694 +1081 @@
                 int fd = open( "/dev/console", O_WRONLY, 0);
                 if (fd != -1) {
+                        smb_set_close_on_exec(fd);
                         state.fd = fd;
                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
@@ -712 +1100 @@
 ************************************************************************/
 
- int Debug1( const char *format_str, ... )
-{
-        va_list ap;
+static void Debug1(const char *msg)
+{
         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:
+        switch(state.logtype) {
+        case DEBUG_CALLBACK:
+                debug_callback_log(msg, current_msg_level);
+                break;
+        case DEBUG_STDOUT:
+        case DEBUG_STDERR:
+        case DEBUG_DEFAULT_STDOUT:
+        case DEBUG_DEFAULT_STDERR:
+                if (state.fd > 0) {
+                        write(state.fd, msg, strlen(msg));
+                }
+                break;
+        case DEBUG_FILE:
+                debug_backends_log(msg, current_msg_level);
+                break;
+        };
+
         errno = old_errno;
-
-        return( 0 );
-}
-
+}
 
 /**************************************************************************
@@ -809 +1135 @@
 {
         format_bufr[format_pos] = '\0';
-        (void)Debug1( "%s", format_bufr );
+        (void)Debug1(format_bufr);
         format_pos = 0;
 }
@@ -834 +1160 @@
         bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
 
-        if (!format_bufr) {
-                debug_init();
-        }
+        debug_init();
 
         for( i = 0; msg[i]; i++ ) {
@@ -846 +1170 @@
 
                 /* If there's room, copy the character to the format buffer. */
-                if( format_pos < FORMAT_BUFR_MAX )
+                if (format_pos < FORMAT_BUFR_SIZE - 1)
                         format_bufr[format_pos++] = msg[i];
 
@@ -856 +1180 @@
                  * continuation indicator.
                  */
-                if( format_pos >= FORMAT_BUFR_MAX ) {
+                if (format_pos >= FORMAT_BUFR_SIZE - 1) {
                         bufr_print();
                         (void)Debug1( " +>\n" );
@@ -897 +1221 @@
           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
 
-  Notes:  This function takes care of setting syslog_level.
+  Notes:  This function takes care of setting current_msg_level.
 
 ****************************************************************************/
@@ -905 +1229 @@
         /* Ensure we don't lose any real errno value. */
         int old_errno = errno;
+        bool verbose = false;
+        char header_str[300];
+        size_t hs_len;
+        struct timeval tv;
+        struct timeval_buf tvbuf;
 
         if( format_pos ) {
@@ -919 +1248 @@
         }
 
-#ifdef WITH_SYSLOG
-        /* Set syslog_level. */
-        syslog_level = level;
-#endif
+        /* Set current_msg_level. */
+        current_msg_level = level;
 
         /* Don't print a header if we're logging to stdout. */
@@ -932 +1259 @@
          * 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",
-                                 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);
-                }
-        }
+        if (!(state.settings.timestamp_logs ||
+              state.settings.debug_prefix_timestamp)) {
+                return true;
+        }
+
+        GetTimeOfDay(&tv);
+        timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
+                        &tvbuf);
+
+        hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
+                          tvbuf.buf, level);
+        if (hs_len >= sizeof(header_str)) {
+                goto full;
+        }
+
+        if (unlikely(DEBUGLEVEL_CLASS[ cls ] >= 10)) {
+                verbose = true;
+        }
+
+        if (verbose || state.settings.debug_pid) {
+                hs_len += snprintf(
+                        header_str + hs_len, sizeof(header_str) - hs_len,
+                        ", pid=%u", (unsigned int)getpid());
+                if (hs_len >= sizeof(header_str)) {
+                        goto full;
+                }
+        }
+
+        if (verbose || state.settings.debug_uid) {
+                hs_len += snprintf(
+                        header_str + hs_len, sizeof(header_str) - hs_len,
+                        ", effective(%u, %u), real(%u, %u)",
+                        (unsigned int)geteuid(), (unsigned int)getegid(),
+                        (unsigned int)getuid(), (unsigned int)getgid());
+                if (hs_len >= sizeof(header_str)) {
+                        goto full;
+                }
+        }
+
+        if ((verbose || state.settings.debug_class)
+            && (cls != DBGC_ALL)) {
+                hs_len += snprintf(
+                        header_str + hs_len, sizeof(header_str) - hs_len,
+                        ", class=%s", classname_table[cls]);
+                if (hs_len >= sizeof(header_str)) {
+                        goto full;
+                }
+        }
+
+        /*
+         * No +=, see man man strlcat
+         */
+        hs_len = strlcat(header_str, "] ", sizeof(header_str));
+        if (hs_len >= sizeof(header_str)) {
+                goto full;
+        }
+
+        if (!state.settings.debug_prefix_timestamp) {
+                hs_len += snprintf(
+                        header_str + hs_len, sizeof(header_str) - hs_len,
+                        "%s(%s)\n", location, func);
+                if (hs_len >= sizeof(header_str)) {
+                        goto full;
+                }
+        }
+
+full:
+        (void)Debug1(header_str);
 
         errno = old_errno;
@@ -992 +1345 @@
 ***************************************************************************/
 
- bool dbgtext( const char *format_str, ... )
-{
-        va_list ap;
+static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
+static inline bool __dbgtext_va(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);
@@ -1012 +1362 @@
 }
 
-
-/* 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;
-}
+bool dbgtext_va(const char *format_str, va_list ap)
+{
+        return __dbgtext_va(format_str, ap);
+}
+
+bool dbgtext(const char *format_str, ... )
+{
+        va_list ap;
+        bool ret;
+
+        va_start(ap, format_str);
+        ret = __dbgtext_va(format_str, ap);
+        va_end(ap);
+
+        return ret;
+}