2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Elrond 2002
6 Copyright (C) Simo Sorce 2002
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "system/filesys.h"
25 #include "system/syslog.h"
26 #include "system/locale.h"
27 #include "time_basic.h"
28 #include "close_low_fd.h"
30 #include "util_strlist.h" /* LIST_SEP */
34 /* define what facility to use for syslog */
35 #ifndef SYSLOG_FACILITY
36 #define SYSLOG_FACILITY LOG_DAEMON
39 /* -------------------------------------------------------------------------- **
44 * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
45 * for a terminating null byte.
47 #define FORMAT_BUFR_SIZE 1024
49 /* -------------------------------------------------------------------------- **
50 * This module implements Samba's debugging utility.
52 * The syntax of a debugging log file is represented as:
54 * <debugfile> :== { <debugmsg> }
56 * <debugmsg> :== <debughdr> '\n' <debugtext>
58 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
60 * <debugtext> :== { <debugline> }
62 * <debugline> :== TEXT '\n'
64 * TEXT is a string of characters excluding the newline character.
65 * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
66 * TIME is a timestamp.
67 * FILENAME is the name of the file from which the debug message was generated.
68 * FUNCTION is the function from which the debug message was generated.
70 * Basically, what that all means is:
72 * - A debugging log file is made up of debug messages.
74 * - Each debug message is made up of a header and text. The header is
75 * separated from the text by a newline.
77 * - The header begins with the timestamp and debug level of the message
78 * enclosed in brackets. The filename and function from which the
79 * message was generated may follow. The filename is terminated by a
80 * colon, and the function name is terminated by parenthesis.
82 * - The message text is made up of zero or more lines, each terminated by
86 /* state variables for the debug system */
89 enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
92 bool schedule_reopen_logs;
94 struct debug_settings settings;
95 debug_callback_fn callback;
96 void *callback_private;
99 .timestamp_logs = true
105 * The debug loglevel of the class.
110 * An optional class specific logfile, may be NULL in which case the
111 * "global" logfile is used and fd is -1.
117 static const char *default_classname_table[] = {
120 [DBGC_PRINTDRIVERS] = "printdrivers",
121 [DBGC_LANMAN] = "lanman",
123 [DBGC_RPC_PARSE] = "rpc_parse",
124 [DBGC_RPC_SRV] = "rpc_srv",
125 [DBGC_RPC_CLI] = "rpc_cli",
126 [DBGC_PASSDB] = "passdb",
128 [DBGC_AUTH] = "auth",
129 [DBGC_WINBIND] = "winbind",
131 [DBGC_IDMAP] = "idmap",
132 [DBGC_QUOTA] = "quota",
133 [DBGC_ACLS] = "acls",
134 [DBGC_LOCKING] = "locking",
135 [DBGC_MSDFS] = "msdfs",
136 [DBGC_DMAPI] = "dmapi",
137 [DBGC_REGISTRY] = "registry",
138 [DBGC_SCAVENGER] = "scavenger",
141 [DBGC_TEVENT] = "tevent",
142 [DBGC_AUTH_AUDIT] = "auth_audit",
143 [DBGC_AUTH_AUDIT_JSON] = "auth_json_audit",
144 [DBGC_KERBEROS] = "kerberos",
145 [DBGC_DRS_REPL] = "drs_repl",
146 [DBGC_SMB2] = "smb2",
147 [DBGC_SMB2_CREDITS] = "smb2_credits",
148 [DBGC_DSDB_AUDIT] = "dsdb_audit",
149 [DBGC_DSDB_AUDIT_JSON] = "dsdb_json_audit",
150 [DBGC_DSDB_PWD_AUDIT] = "dsdb_password_audit",
151 [DBGC_DSDB_PWD_AUDIT_JSON] = "dsdb_password_json_audit",
152 [DBGC_DSDB_TXN_AUDIT] = "dsdb_transaction_audit",
153 [DBGC_DSDB_TXN_AUDIT_JSON] = "dsdb_transaction_json_audit",
154 [DBGC_DSDB_GROUP_AUDIT] = "dsdb_group_audit",
155 [DBGC_DSDB_GROUP_AUDIT_JSON] = "dsdb_group_json_audit",
159 * This is to allow reading of dbgc_config before the debug
160 * system has been initialized.
162 static struct debug_class debug_class_list_initial[ARRAY_SIZE(default_classname_table)] = {
163 [DBGC_ALL] = (struct debug_class) { .fd = 2 },
166 static size_t debug_num_classes = 0;
167 static struct debug_class *dbgc_config = debug_class_list_initial;
169 static int current_msg_level = 0;
170 static int current_msg_class = 0;
172 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
173 static int debug_level_to_priority(int level)
176 * map debug levels to syslog() priorities
178 static const int priority_map[] = {
192 if( level >= ARRAY_SIZE(priority_map) || level < 0)
193 priority = LOG_DEBUG;
195 priority = priority_map[level];
201 /* -------------------------------------------------------------------------- **
202 * Debug backends. When logging to DEBUG_FILE, send the log entries to
203 * all active backends.
206 static void debug_file_log(int msg_level,
207 const char *msg, const char *msg_no_nl)
214 if (dbgc_config[current_msg_class].fd != -1) {
215 fd = dbgc_config[current_msg_class].fd;
217 fd = dbgc_config[DBGC_ALL].fd;
221 ret = write(fd, msg, strlen(msg));
222 } while (ret == -1 && errno == EINTR);
226 static void debug_syslog_reload(bool enabled, bool previously_enabled,
227 const char *prog_name, char *option)
229 if (enabled && !previously_enabled) {
230 const char *ident = NULL;
231 if ((prog_name != NULL) && (prog_name[0] != '\0')) {
235 openlog(ident, LOG_PID, SYSLOG_FACILITY);
237 /* for old systems that have no facility codes. */
238 openlog(ident, LOG_PID);
243 if (!enabled && previously_enabled) {
248 static void debug_syslog_log(int msg_level,
249 const char *msg, const char *msg_no_nl)
253 priority = debug_level_to_priority(msg_level);
256 * Specify the facility to interoperate with other syslog
257 * callers (vfs_full_audit for example).
259 priority |= SYSLOG_FACILITY;
261 syslog(priority, "%s", msg);
263 #endif /* WITH_SYSLOG */
265 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
266 #include <systemd/sd-journal.h>
267 static void debug_systemd_log(int msg_level,
268 const char *msg, const char *msg_no_nl)
270 sd_journal_send("MESSAGE=%s", msg_no_nl,
271 "PRIORITY=%d", debug_level_to_priority(msg_level),
272 "LEVEL=%d", msg_level,
277 #ifdef HAVE_LTTNG_TRACEF
278 #include <lttng/tracef.h>
279 static void debug_lttng_log(int msg_level,
280 const char *msg, const char *msg_no_nl)
284 #endif /* WITH_LTTNG_TRACEF */
287 #include "gpfswrap.h"
288 static void debug_gpfs_reload(bool enabled, bool previously_enabled,
289 const char *prog_name, char *option)
293 if (enabled && !previously_enabled) {
294 gpfswrap_init_trace();
298 if (!enabled && previously_enabled) {
299 gpfswrap_fini_trace();
305 * Trigger GPFS library to adjust state if necessary.
307 gpfswrap_query_trace();
311 static void debug_gpfs_log(int msg_level,
312 const char *msg, const char *msg_no_nl)
314 gpfswrap_add_trace(msg_level, msg_no_nl);
316 #endif /* HAVE_GPFS */
318 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
319 #define DEBUG_RINGBUF_SIZE_OPT "size="
321 static char *debug_ringbuf;
322 static size_t debug_ringbuf_size;
323 static size_t debug_ringbuf_ofs;
325 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
326 char *debug_get_ringbuf(void)
328 return debug_ringbuf;
331 /* Return the size of the ringbuf (including a \0 terminator) */
332 size_t debug_get_ringbuf_size(void)
334 return debug_ringbuf_size;
337 static void debug_ringbuf_reload(bool enabled, bool previously_enabled,
338 const char *prog_name, char *option)
341 size_t optlen = strlen(DEBUG_RINGBUF_SIZE_OPT);
343 debug_ringbuf_size = DEBUG_RINGBUF_SIZE;
344 debug_ringbuf_ofs = 0;
346 SAFE_FREE(debug_ringbuf);
352 if (option != NULL) {
353 cmp = strncmp(option, DEBUG_RINGBUF_SIZE_OPT, optlen);
355 debug_ringbuf_size = (size_t)strtoull(
356 option + optlen, NULL, 10);
360 debug_ringbuf = calloc(debug_ringbuf_size, sizeof(char));
361 if (debug_ringbuf == NULL) {
366 static void debug_ringbuf_log(int msg_level,
368 const char *msg_no_nl)
370 size_t msglen = strlen(msg);
373 if (debug_ringbuf == NULL) {
377 /* Ensure the buffer is always \0 terminated */
378 allowed_size = debug_ringbuf_size - 1;
380 if (msglen > allowed_size) {
384 if ((debug_ringbuf_ofs + msglen) < debug_ringbuf_ofs) {
388 if ((debug_ringbuf_ofs + msglen) > allowed_size) {
389 debug_ringbuf_ofs = 0;
392 memcpy(debug_ringbuf + debug_ringbuf_ofs, msg, msglen);
393 debug_ringbuf_ofs += msglen;
396 static struct debug_backend {
400 void (*reload)(bool enabled, bool prev_enabled,
401 const char *prog_name, char *option);
402 void (*log)(int msg_level, const char *msg, const char *msg_no_nl);
404 } debug_backends[] = {
407 .log = debug_file_log,
412 .reload = debug_syslog_reload,
413 .log = debug_syslog_log,
417 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
420 .log = debug_systemd_log,
424 #ifdef HAVE_LTTNG_TRACEF
427 .log = debug_lttng_log,
434 .reload = debug_gpfs_reload,
435 .log = debug_gpfs_log,
440 .log = debug_ringbuf_log,
441 .reload = debug_ringbuf_reload,
445 static struct debug_backend *debug_find_backend(const char *name)
449 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
450 if (strcmp(name, debug_backends[i].name) == 0) {
451 return &debug_backends[i];
459 * parse "backend[:option][@loglevel]
461 static void debug_backend_parse_token(char *tok)
463 char *backend_name_option, *backend_name,*backend_level, *saveptr;
464 char *backend_option;
465 struct debug_backend *b;
468 * First parse into backend[:option] and loglevel
470 backend_name_option = strtok_r(tok, "@\0", &saveptr);
471 if (backend_name_option == NULL) {
475 backend_level = strtok_r(NULL, "\0", &saveptr);
478 * Now parse backend[:option]
480 backend_name = strtok_r(backend_name_option, ":\0", &saveptr);
481 if (backend_name == NULL) {
485 backend_option = strtok_r(NULL, "\0", &saveptr);
488 * Find and update backend
490 b = debug_find_backend(backend_name);
495 if (backend_level == NULL) {
496 b->new_log_level = MAX_DEBUG_LEVEL;
498 b->new_log_level = atoi(backend_level);
501 if (backend_option != NULL) {
502 b->option = strdup(backend_option);
503 if (b->option == NULL) {
510 * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
511 * and enable/disable backends accordingly
513 static void debug_set_backends(const char *param)
515 size_t str_len = strlen(param);
521 * initialize new_log_level to detect backends that have been
524 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
525 SAFE_FREE(debug_backends[i].option);
526 debug_backends[i].new_log_level = -1;
529 memcpy(str, param, str_len + 1);
531 tok = strtok_r(str, LIST_SEP, &saveptr);
536 while (tok != NULL) {
537 debug_backend_parse_token(tok);
538 tok = strtok_r(NULL, LIST_SEP, &saveptr);
542 * Let backends react to config changes
544 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
545 struct debug_backend *b = &debug_backends[i];
548 bool enabled = b->new_log_level > -1;
549 bool previously_enabled = b->log_level > -1;
551 b->reload(enabled, previously_enabled, state.prog_name,
554 b->log_level = b->new_log_level;
558 static void debug_backends_log(const char *msg, int msg_level)
560 char msg_no_nl[FORMAT_BUFR_SIZE];
565 * Some backends already add an extra newline, so also provide
566 * a buffer without the newline character.
568 len = MIN(strlen(msg), FORMAT_BUFR_SIZE - 1);
569 if ((len > 0) && (msg[len - 1] == '\n')) {
573 memcpy(msg_no_nl, msg, len);
574 msg_no_nl[len] = '\0';
576 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
577 if (msg_level <= debug_backends[i].log_level) {
578 debug_backends[i].log(msg_level, msg, msg_no_nl);
583 /* -------------------------------------------------------------------------- **
584 * External variables.
588 used to check if the user specified a
589 logfile on the command line
591 bool override_logfile;
593 int debuglevel_get_class(size_t idx)
595 return dbgc_config[idx].loglevel;
598 void debuglevel_set_class(size_t idx, int level)
600 dbgc_config[idx].loglevel = level;
604 /* -------------------------------------------------------------------------- **
605 * Internal variables.
607 * debug_count - Number of debug messages that have been output.
608 * Used to check log size.
610 * current_msg_level - Internal copy of the message debug level. Written by
611 * dbghdr() and read by Debug1().
613 * format_bufr - Used to format debug messages. The dbgtext() function
614 * prints debug messages to a string, and then passes the
615 * string to format_debug_text(), which uses format_bufr
616 * to build the formatted output.
618 * format_pos - Marks the first free byte of the format_bufr.
621 * log_overflow - When this variable is true, never attempt to check the
622 * size of the log. This is a hack, so that we can write
623 * a message using DEBUG, from open_logs() when we
624 * are unable to open a new log file for some reason.
627 static int debug_count = 0;
628 static char format_bufr[FORMAT_BUFR_SIZE];
629 static size_t format_pos = 0;
630 static bool log_overflow = false;
633 * Define all the debug class selection names here. Names *MUST NOT* contain
634 * white space. There must be one name for each DBGC_<class name>, and they
635 * must be in the table in the order of DBGC_<class name>..
638 static char **classname_table = NULL;
641 /* -------------------------------------------------------------------------- **
645 static void debug_init(void);
647 /***************************************************************************
648 Free memory pointed to by global pointers.
649 ****************************************************************************/
651 void gfree_debugsyms(void)
655 TALLOC_FREE(classname_table);
657 if ( dbgc_config != debug_class_list_initial ) {
658 TALLOC_FREE( dbgc_config );
659 dbgc_config = discard_const_p(struct debug_class,
660 debug_class_list_initial);
663 debug_num_classes = 0;
665 state.initialized = false;
667 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
668 SAFE_FREE(debug_backends[i].option);
672 /****************************************************************************
673 utility lists registered debug class names's
674 ****************************************************************************/
676 char *debug_list_class_names_and_levels(void)
680 /* prepare strings */
681 for (i = 0; i < debug_num_classes; i++) {
682 buf = talloc_asprintf_append(buf,
685 dbgc_config[i].loglevel,
686 i == (debug_num_classes - 1) ? "\n" : " ");
694 /****************************************************************************
695 Utility to translate names to debug class index's (internal version).
696 ****************************************************************************/
698 static int debug_lookup_classname_int(const char* classname)
702 if (!classname) return -1;
704 for (i=0; i < debug_num_classes; i++) {
705 if (strcmp(classname, classname_table[i])==0)
711 /****************************************************************************
712 Add a new debug class to the system.
713 ****************************************************************************/
715 int debug_add_class(const char *classname)
718 struct debug_class *new_class_list = NULL;
719 char **new_name_list;
722 if (classname == NULL) {
726 /* check the init has yet been called */
729 ndx = debug_lookup_classname_int(classname);
733 ndx = debug_num_classes;
735 if (dbgc_config == debug_class_list_initial) {
736 /* Initial loading... */
737 new_class_list = NULL;
739 new_class_list = dbgc_config;
742 default_level = dbgc_config[DBGC_ALL].loglevel;
744 new_class_list = talloc_realloc(NULL,
748 if (new_class_list == NULL) {
752 dbgc_config = new_class_list;
754 dbgc_config[ndx] = (struct debug_class) {
755 .loglevel = default_level,
759 new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
760 if (new_name_list == NULL) {
763 classname_table = new_name_list;
765 classname_table[ndx] = talloc_strdup(classname_table, classname);
766 if (classname_table[ndx] == NULL) {
770 debug_num_classes = ndx + 1;
775 /****************************************************************************
776 Utility to translate names to debug class index's (public version).
777 ****************************************************************************/
779 static int debug_lookup_classname(const char *classname)
783 if (!classname || !*classname)
786 ndx = debug_lookup_classname_int(classname);
791 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
793 return debug_add_class(classname);
796 /****************************************************************************
797 Dump the current registered debug levels.
798 ****************************************************************************/
800 static void debug_dump_status(int level)
804 DEBUG(level, ("INFO: Current debug levels:\n"));
805 for (q = 0; q < debug_num_classes; q++) {
806 const char *classname = classname_table[q];
807 DEBUGADD(level, (" %s: %d\n",
809 dbgc_config[q].loglevel));
813 static bool debug_parse_param(char *param)
816 char *class_file = NULL;
818 char *saveptr = NULL;
821 class_name = strtok_r(param, ":", &saveptr);
822 if (class_name == NULL) {
826 class_level = strtok_r(NULL, "@\0", &saveptr);
827 if (class_level == NULL) {
831 class_file = strtok_r(NULL, "\0", &saveptr);
833 ndx = debug_lookup_classname(class_name);
838 dbgc_config[ndx].loglevel = atoi(class_level);
840 if (class_file == NULL) {
844 TALLOC_FREE(dbgc_config[ndx].logfile);
846 dbgc_config[ndx].logfile = talloc_strdup(NULL, class_file);
847 if (dbgc_config[ndx].logfile == NULL) {
853 /****************************************************************************
854 Parse the debug levels from smb.conf. Example debug level string:
855 3 tdb:5 printdrivers:7
856 Note: the 1st param has no "name:" preceeding it.
857 ****************************************************************************/
859 bool debug_parse_levels(const char *params_str)
861 size_t str_len = strlen(params_str);
869 memcpy(str, params_str, str_len+1);
871 tok = strtok_r(str, LIST_SEP, &saveptr);
876 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
877 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
879 if (isdigit(tok[0])) {
880 dbgc_config[DBGC_ALL].loglevel = atoi(tok);
881 tok = strtok_r(NULL, LIST_SEP, &saveptr);
883 dbgc_config[DBGC_ALL].loglevel = 0;
886 /* Array is debug_num_classes long */
887 for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
888 dbgc_config[i].loglevel = dbgc_config[DBGC_ALL].loglevel;
889 TALLOC_FREE(dbgc_config[i].logfile);
892 while (tok != NULL) {
895 ok = debug_parse_param(tok);
897 DEBUG(0,("debug_parse_params: unrecognized debug "
898 "class name or format [%s]\n", tok));
902 tok = strtok_r(NULL, LIST_SEP, &saveptr);
905 debug_dump_status(5);
910 /* setup for logging of talloc warnings */
911 static void talloc_log_fn(const char *msg)
913 DEBUG(0,("%s", msg));
916 void debug_setup_talloc_log(void)
918 talloc_set_log_fn(talloc_log_fn);
922 /****************************************************************************
923 Init debugging (one time stuff)
924 ****************************************************************************/
926 static void debug_init(void)
930 if (state.initialized)
933 state.initialized = true;
935 debug_setup_talloc_log();
937 for (i = 0; i < ARRAY_SIZE(default_classname_table); i++) {
938 debug_add_class(default_classname_table[i]);
940 dbgc_config[DBGC_ALL].fd = 2;
942 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
943 debug_backends[i].log_level = -1;
944 debug_backends[i].new_log_level = -1;
948 void debug_set_settings(struct debug_settings *settings,
949 const char *logging_param,
950 int syslog_level, bool syslog_only)
952 char fake_param[256];
956 * This forces in some smb.conf derived values into the debug
957 * system. There are no pointers in this structure, so we can
958 * just structure-assign it in
960 state.settings = *settings;
963 * If 'logging' is not set, create backend settings from
964 * deprecated 'syslog' and 'syslog only' parameters
966 if (logging_param != NULL) {
967 len = strlen(logging_param);
971 snprintf(fake_param, sizeof(fake_param),
972 "syslog@%d", syslog_level - 1);
974 snprintf(fake_param, sizeof(fake_param),
975 "syslog@%d file@%d", syslog_level -1,
979 logging_param = fake_param;
982 debug_set_backends(logging_param);
986 control the name of the logfile and whether logging will be to stdout, stderr
987 or a file, and set up syslog
989 new_log indicates the destination for the debug log (an enum in
990 order of precedence - once set to DEBUG_FILE, it is not possible to
991 reset to DEBUG_STDOUT for example. This makes it easy to override
992 for debug to stderr on the command line, as the smb.conf cannot
993 reset it back to file-based logging
995 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
998 if (state.logtype < new_logtype) {
999 state.logtype = new_logtype;
1002 const char *p = strrchr(prog_name, '/');
1008 strlcpy(state.prog_name, prog_name, sizeof(state.prog_name));
1010 reopen_logs_internal();
1013 /***************************************************************************
1014 Set the logfile name.
1015 **************************************************************************/
1017 void debug_set_logfile(const char *name)
1019 if (name == NULL || *name == 0) {
1020 /* this copes with calls when smb.conf is not loaded yet */
1023 TALLOC_FREE(dbgc_config[DBGC_ALL].logfile);
1024 dbgc_config[DBGC_ALL].logfile = talloc_strdup(NULL, name);
1027 static void debug_close_fd(int fd)
1034 bool debug_get_output_is_stderr(void)
1036 return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
1039 bool debug_get_output_is_stdout(void)
1041 return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
1044 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
1048 state.logtype = DEBUG_CALLBACK;
1049 state.callback_private = private_ptr;
1050 state.callback = fn;
1052 state.logtype = DEBUG_DEFAULT_STDERR;
1053 state.callback_private = NULL;
1054 state.callback = NULL;
1058 static void debug_callback_log(const char *msg, int msg_level)
1060 size_t msg_len = strlen(msg);
1061 char msg_copy[msg_len];
1063 if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
1064 memcpy(msg_copy, msg, msg_len-1);
1065 msg_copy[msg_len-1] = '\0';
1069 state.callback(state.callback_private, msg_level, msg);
1072 /**************************************************************************
1073 reopen the log files
1074 note that we now do this unconditionally
1075 We attempt to open the new debug fp before closing the old. This means
1076 if we run out of fd's we just keep using the old fd rather than aborting.
1077 Fix from dgibson@linuxcare.com.
1078 **************************************************************************/
1080 static bool reopen_one_log(int *fd, const char *logfile)
1085 if (logfile == NULL) {
1086 debug_close_fd(old_fd);
1091 new_fd = open(logfile, O_WRONLY|O_APPEND|O_CREAT, 0644);
1093 log_overflow = true;
1094 DBG_ERR("Unable to open new log file '%s': %s\n",
1095 logfile, strerror(errno));
1096 log_overflow = false;
1100 debug_close_fd(old_fd);
1101 smb_set_close_on_exec(new_fd);
1108 reopen the log file (usually called because the log file name might have changed)
1110 bool reopen_logs_internal(void)
1117 if (state.reopening_logs) {
1121 /* Now clear the SIGHUP induced flag */
1122 state.schedule_reopen_logs = false;
1124 switch (state.logtype) {
1125 case DEBUG_CALLBACK:
1128 case DEBUG_DEFAULT_STDOUT:
1129 debug_close_fd(dbgc_config[DBGC_ALL].fd);
1130 dbgc_config[DBGC_ALL].fd = 1;
1133 case DEBUG_DEFAULT_STDERR:
1135 debug_close_fd(dbgc_config[DBGC_ALL].fd);
1136 dbgc_config[DBGC_ALL].fd = 2;
1143 oldumask = umask( 022 );
1145 for (i = DBGC_ALL; i < debug_num_classes; i++) {
1146 if (dbgc_config[DBGC_ALL].logfile != NULL) {
1150 if (i == debug_num_classes) {
1154 state.reopening_logs = true;
1156 for (i = DBGC_ALL; i < debug_num_classes; i++) {
1157 ok = reopen_one_log(&dbgc_config[i].fd,
1158 dbgc_config[i].logfile);
1164 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1165 * to fix problem where smbd's that generate less
1166 * than 100 messages keep growing the log.
1168 force_check_log_size();
1169 (void)umask(oldumask);
1172 * If log file was opened or created successfully, take over stderr to
1173 * catch output into logs.
1176 if (dup2(dbgc_config[DBGC_ALL].fd, 2) == -1) {
1177 /* Close stderr too, if dup2 can't point it -
1178 at the logfile. There really isn't much
1179 that can be done on such a fundamental
1185 state.reopening_logs = false;
1190 /**************************************************************************
1191 Force a check of the log size.
1192 ***************************************************************************/
1194 void force_check_log_size( void )
1199 _PUBLIC_ void debug_schedule_reopen_logs(void)
1201 state.schedule_reopen_logs = true;
1205 /***************************************************************************
1206 Check to see if there is any need to check if the logfile has grown too big.
1207 **************************************************************************/
1209 bool need_to_check_log_size(void)
1214 if (debug_count < 100) {
1218 maxlog = state.settings.max_log_size * 1024;
1224 if (dbgc_config[DBGC_ALL].fd > 2) {
1228 for (i = DBGC_ALL + 1; i < debug_num_classes; i++) {
1229 if (dbgc_config[i].fd != -1) {
1238 /**************************************************************************
1239 Check to see if the log has grown to be too big.
1240 **************************************************************************/
1242 static void do_one_check_log_size(off_t maxlog, int *_fd, const char *logfile)
1244 char name[strlen(logfile) + 5];
1254 ret = fstat(fd, &st);
1258 if (st.st_size < maxlog ) {
1262 /* reopen_logs_internal() modifies *_fd */
1263 (void)reopen_logs_internal();
1269 ret = fstat(fd, &st);
1273 if (st.st_size < maxlog) {
1277 snprintf(name, sizeof(name), "%s.old", logfile);
1279 (void)rename(logfile, name);
1281 ok = reopen_logs_internal();
1285 /* We failed to reopen a log - continue using the old name. */
1286 (void)rename(name, logfile);
1289 static void do_check_log_size(off_t maxlog)
1293 for (i = DBGC_ALL; i < debug_num_classes; i++) {
1294 if (dbgc_config[i].fd == -1) {
1297 if (dbgc_config[i].logfile == NULL) {
1300 do_one_check_log_size(maxlog,
1302 dbgc_config[i].logfile);
1306 void check_log_size( void )
1311 * We need to be root to check/change log-file, skip this and let the main
1312 * loop check do a new check as root.
1315 #if _SAMBA_BUILD_ == 3
1316 if (geteuid() != sec_initial_uid())
1321 /* We don't check sec_initial_uid() here as it isn't
1322 * available in common code and we don't generally
1323 * want to rotate and the possibly lose logs in
1324 * make test or the build farm */
1328 if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
1332 maxlog = state.settings.max_log_size * 1024;
1334 if (state.schedule_reopen_logs) {
1335 (void)reopen_logs_internal();
1338 do_check_log_size(maxlog);
1341 * Here's where we need to panic if dbgc_config[DBGC_ALL].fd == 0 or -1
1345 if (dbgc_config[DBGC_ALL].fd <= 0) {
1346 /* This code should only be reached in very strange
1347 * circumstances. If we merely fail to open the new log we
1348 * should stick with the old one. ergo this should only be
1349 * reached when opening the logs for the first time: at
1350 * startup or when the log level is increased from zero.
1353 int fd = open( "/dev/console", O_WRONLY, 0);
1355 smb_set_close_on_exec(fd);
1356 dbgc_config[DBGC_ALL].fd = fd;
1357 DBG_ERR("check_log_size: open of debug file %s failed "
1358 "- using console.\n",
1359 dbgc_config[DBGC_ALL].logfile);
1362 * We cannot continue without a debug file handle.
1370 /*************************************************************************
1371 Write an debug message on the debugfile.
1372 This is called by dbghdr() and format_debug_text().
1373 ************************************************************************/
1375 static void Debug1(const char *msg)
1377 int old_errno = errno;
1381 switch(state.logtype) {
1382 case DEBUG_CALLBACK:
1383 debug_callback_log(msg, current_msg_level);
1387 case DEBUG_DEFAULT_STDOUT:
1388 case DEBUG_DEFAULT_STDERR:
1389 if (dbgc_config[DBGC_ALL].fd > 0) {
1392 ret = write(dbgc_config[DBGC_ALL].fd,
1395 } while (ret == -1 && errno == EINTR);
1399 debug_backends_log(msg, current_msg_level);
1406 /**************************************************************************
1407 Print the buffer content via Debug1(), then reset the buffer.
1410 ****************************************************************************/
1412 static void bufr_print( void )
1414 format_bufr[format_pos] = '\0';
1415 (void)Debug1(format_bufr);
1419 /***************************************************************************
1420 Format the debug message text.
1422 Input: msg - Text to be added to the "current" debug message text.
1426 Notes: The purpose of this is two-fold. First, each call to syslog()
1427 (used by Debug1(), see above) generates a new line of syslog
1428 output. This is fixed by storing the partial lines until the
1429 newline character is encountered. Second, printing the debug
1430 message lines when a newline is encountered allows us to add
1431 spaces, thus indenting the body of the message and making it
1433 **************************************************************************/
1435 static void format_debug_text( const char *msg )
1438 bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
1442 for( i = 0; msg[i]; i++ ) {
1443 /* Indent two spaces at each new line. */
1444 if(timestamp && 0 == format_pos) {
1445 format_bufr[0] = format_bufr[1] = ' ';
1449 /* If there's room, copy the character to the format buffer. */
1450 if (format_pos < FORMAT_BUFR_SIZE - 1)
1451 format_bufr[format_pos++] = msg[i];
1453 /* If a newline is encountered, print & restart. */
1454 if( '\n' == msg[i] )
1457 /* If the buffer is full dump it out, reset it, and put out a line
1458 * continuation indicator.
1460 if (format_pos >= FORMAT_BUFR_SIZE - 1) {
1462 (void)Debug1( " +>\n" );
1466 /* Just to be safe... */
1467 format_bufr[format_pos] = '\0';
1470 /***************************************************************************
1471 Flush debug output, including the format buffer content.
1475 ***************************************************************************/
1477 void dbgflush( void )
1482 /***************************************************************************
1483 Print a Debug Header.
1485 Input: level - Debug level of the message (not the system-wide debug
1487 cls - Debuglevel class of the calling module.
1488 location - Pointer to a string containing the name of the file
1489 from which this function was called, or an empty string
1490 if the __FILE__ macro is not implemented.
1491 func - Pointer to a string containing the name of the function
1492 from which this function was called, or an empty string
1493 if the __FUNCTION__ macro is not implemented.
1495 Output: Always true. This makes it easy to fudge a call to dbghdr()
1496 in a macro, since the function can be called as part of a test.
1497 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1499 Notes: This function takes care of setting current_msg_level.
1501 ****************************************************************************/
1503 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1505 /* Ensure we don't lose any real errno value. */
1506 int old_errno = errno;
1507 bool verbose = false;
1508 char header_str[300];
1511 struct timeval_buf tvbuf;
1514 /* This is a fudge. If there is stuff sitting in the format_bufr, then
1515 * the *right* thing to do is to call
1516 * format_debug_text( "\n" );
1517 * to write the remainder, and then proceed with the new header.
1518 * Unfortunately, there are several places in the code at which
1519 * the DEBUG() macro is used to build partial lines. That in mind,
1520 * we'll work under the assumption that an incomplete line indicates
1521 * that a new header is *not* desired.
1526 /* Set current_msg_level. */
1527 current_msg_level = level;
1529 /* Set current message class */
1530 current_msg_class = cls;
1532 /* Don't print a header if we're logging to stdout. */
1533 if ( state.logtype != DEBUG_FILE ) {
1537 /* Print the header if timestamps are turned on. If parameters are
1538 * not yet loaded, then default to timestamps on.
1540 if (!(state.settings.timestamp_logs ||
1541 state.settings.debug_prefix_timestamp)) {
1546 timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
1549 hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
1551 if (hs_len >= sizeof(header_str)) {
1555 if (unlikely(dbgc_config[cls].loglevel >= 10)) {
1559 if (verbose || state.settings.debug_pid) {
1561 header_str + hs_len, sizeof(header_str) - hs_len,
1562 ", pid=%u", (unsigned int)getpid());
1563 if (hs_len >= sizeof(header_str)) {
1568 if (verbose || state.settings.debug_uid) {
1570 header_str + hs_len, sizeof(header_str) - hs_len,
1571 ", effective(%u, %u), real(%u, %u)",
1572 (unsigned int)geteuid(), (unsigned int)getegid(),
1573 (unsigned int)getuid(), (unsigned int)getgid());
1574 if (hs_len >= sizeof(header_str)) {
1579 if ((verbose || state.settings.debug_class)
1580 && (cls != DBGC_ALL)) {
1582 header_str + hs_len, sizeof(header_str) - hs_len,
1583 ", class=%s", classname_table[cls]);
1584 if (hs_len >= sizeof(header_str)) {
1590 * No +=, see man man strlcat
1592 hs_len = strlcat(header_str, "] ", sizeof(header_str));
1593 if (hs_len >= sizeof(header_str)) {
1597 if (!state.settings.debug_prefix_timestamp) {
1599 header_str + hs_len, sizeof(header_str) - hs_len,
1600 "%s(%s)\n", location, func);
1601 if (hs_len >= sizeof(header_str)) {
1607 (void)Debug1(header_str);
1613 /***************************************************************************
1614 Add text to the body of the "current" debug message via the format buffer.
1616 Input: format_str - Format string, as used in printf(), et. al.
1617 ... - Variable argument list.
1619 ..or.. va_alist - Old style variable parameter list starting point.
1621 Output: Always true. See dbghdr() for more info, though this is not
1622 likely to be used in the same way.
1624 ***************************************************************************/
1626 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1627 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1629 char *msgbuf = NULL;
1633 res = vasprintf(&msgbuf, format_str, ap);
1635 format_debug_text(msgbuf);
1643 bool dbgtext_va(const char *format_str, va_list ap)
1645 return __dbgtext_va(format_str, ap);
1648 bool dbgtext(const char *format_str, ... )
1653 va_start(ap, format_str);
1654 ret = __dbgtext_va(format_str, ap);