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 "system/network.h"
28 #include "system/time.h"
29 #include "time_basic.h"
30 #include "close_low_fd.h"
32 #include "util_strlist.h" /* LIST_SEP */
37 /* define what facility to use for syslog */
38 #ifndef SYSLOG_FACILITY
39 #define SYSLOG_FACILITY LOG_DAEMON
42 /* -------------------------------------------------------------------------- **
47 * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
48 * for a terminating null byte.
50 #define FORMAT_BUFR_SIZE 4096
52 /* -------------------------------------------------------------------------- **
53 * This module implements Samba's debugging utility.
55 * The syntax of a debugging log file is represented as:
57 * <debugfile> :== { <debugmsg> }
59 * <debugmsg> :== <debughdr> '\n' <debugtext>
61 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
63 * <debugtext> :== { <debugline> }
65 * <debugline> :== TEXT '\n'
67 * TEXT is a string of characters excluding the newline character.
68 * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
69 * TIME is a timestamp.
70 * FILENAME is the name of the file from which the debug message was generated.
71 * FUNCTION is the function from which the debug message was generated.
73 * Basically, what that all means is:
75 * - A debugging log file is made up of debug messages.
77 * - Each debug message is made up of a header and text. The header is
78 * separated from the text by a newline.
80 * - The header begins with the timestamp and debug level of the message
81 * enclosed in brackets. The filename and function from which the
82 * message was generated may follow. The filename is terminated by a
83 * colon, and the function name is terminated by parenthesis.
85 * - The message text is made up of zero or more lines, each terminated by
89 /* state variables for the debug system */
92 enum debug_logtype logtype
; /* The type of logging we are doing: eg stdout, file, stderr */
94 char hostname
[HOST_NAME_MAX
+1];
96 bool schedule_reopen_logs
;
98 struct debug_settings settings
;
99 debug_callback_fn callback
;
100 void *callback_private
;
101 char header_str
[300];
102 char header_str_no_nl
[300];
104 char msg_no_nl
[FORMAT_BUFR_SIZE
];
107 .timestamp_logs
= true
113 * The debug loglevel of the class.
118 * An optional class specific logfile, may be NULL in which case the
119 * "global" logfile is used and fd is -1.
123 /* inode number of the logfile to detect logfile rotation */
128 * default_classname_table[] is read in from debug-classname-table.c
129 * so that test_logging.c can use it too.
131 #include "lib/util/debug-classes/debug-classname-table.c"
134 * This is to allow reading of dbgc_config before the debug
135 * system has been initialized.
137 static struct debug_class debug_class_list_initial
[ARRAY_SIZE(default_classname_table
)] = {
138 [DBGC_ALL
] = { .fd
= 2 },
141 static size_t debug_num_classes
= 0;
142 static struct debug_class
*dbgc_config
= debug_class_list_initial
;
144 static int current_msg_level
= 0;
145 static int current_msg_class
= 0;
148 * DBG_DEV(): when and how to user it.
150 * As a developer, you sometimes want verbose logging between point A and
151 * point B, where the relationship between these points is not easily defined
152 * in terms of the call stack.
154 * For example, you might be interested in what is going on in functions in
155 * lib/util/util_str.c in an ldap worker process after a particular query. If
156 * you use gdb, something will time out and you won't get the full
157 * conversation. If you add fprintf() or DBG_ERR()s to util_str.c, you'll get
158 * a massive flood, and there's a chance one will accidentally slip into a
159 * release and the whole world will flood. DBG_DEV is a solution.
161 * On start-up, DBG_DEV() is switched OFF. Nothing is printed.
163 * 1. Add `DBG_DEV("formatted msg %d, etc\n", i);` where needed.
165 * 2. At each point you want to start debugging, add `debug_developer_enable()`.
167 * 3. At each point you want debugging to stop, add `debug_developer_disable()`.
169 * In DEVELOPER builds, the message will be printed at level 0, as with
170 * DBG_ERR(). In production builds, the macro resolves to nothing.
172 * The messages are printed with a "<function_name>:DEV:<pid>:" prefix.
175 static bool debug_developer_is_enabled
= false;
177 bool debug_developer_enabled(void)
179 return debug_developer_is_enabled
;
183 * debug_developer_disable() will turn DBG_DEV() on in the current
184 * process and children.
186 void debug_developer_enable(void)
188 debug_developer_is_enabled
= true;
192 * debug_developer_disable() will make DBG_DEV() do nothing in the current
193 * process (and children).
195 void debug_developer_disable(void)
197 debug_developer_is_enabled
= false;
201 * Within debug.c, DBG_DEV() always writes to stderr, because some functions
202 * here will attempt infinite recursion with normal DEBUG macros.
206 #define DBG_DEV(fmt, ...) \
207 (void)((debug_developer_enabled()) \
208 && (fprintf(stderr, "%s:DEV:%d: " fmt "%s", \
209 __func__, getpid(), ##__VA_ARGS__, "")) )
213 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
214 static int debug_level_to_priority(int level
)
217 * map debug levels to syslog() priorities
219 static const int priority_map
[] = {
233 if (level
< 0 || (size_t)level
>= ARRAY_SIZE(priority_map
))
234 priority
= LOG_DEBUG
;
236 priority
= priority_map
[level
];
242 /* -------------------------------------------------------------------------- **
243 * Produce a version of the given buffer without any trailing newlines.
245 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD) || \
246 defined(HAVE_LTTNG_TRACEF) || defined(HAVE_GPFS)
247 static void copy_no_nl(char *out
,
254 * Some backends already add an extra newline, so also provide
255 * a buffer without the newline character.
257 len
= MIN(in_len
, out_size
- 1);
258 if ((len
> 0) && (in
[len
- 1] == '\n')) {
262 memcpy(out
, in
, len
);
266 static void ensure_copy_no_nl(char *out
,
272 * Assume out is a static buffer that is reused as a cache.
273 * If it isn't empty then this has already been done with the
276 if (out
[0] != '\0') {
280 copy_no_nl(out
, out_size
, in
, in_len
);
284 /* -------------------------------------------------------------------------- **
285 * Debug backends. When logging to DEBUG_FILE, send the log entries to
286 * all active backends.
289 static void debug_file_log(int msg_level
, const char *msg
, size_t msg_len
)
291 struct iovec iov
[] = {
293 .iov_base
= discard_const(state
.header_str
),
294 .iov_len
= state
.hs_len
,
297 .iov_base
= discard_const(msg
),
306 if (dbgc_config
[current_msg_class
].fd
!= -1) {
307 fd
= dbgc_config
[current_msg_class
].fd
;
309 fd
= dbgc_config
[DBGC_ALL
].fd
;
313 ret
= writev(fd
, iov
, ARRAY_SIZE(iov
));
314 } while (ret
== -1 && errno
== EINTR
);
318 static void debug_syslog_reload(bool enabled
, bool previously_enabled
,
319 const char *prog_name
, char *option
)
321 if (enabled
&& !previously_enabled
) {
322 const char *ident
= NULL
;
323 if ((prog_name
!= NULL
) && (prog_name
[0] != '\0')) {
327 openlog(ident
, LOG_PID
, SYSLOG_FACILITY
);
329 /* for old systems that have no facility codes. */
330 openlog(ident
, LOG_PID
);
335 if (!enabled
&& previously_enabled
) {
340 static void debug_syslog_log(int msg_level
, const char *msg
, size_t msg_len
)
344 priority
= debug_level_to_priority(msg_level
);
347 * Specify the facility to interoperate with other syslog
348 * callers (vfs_full_audit for example).
350 priority
|= SYSLOG_FACILITY
;
352 if (state
.hs_len
> 0) {
353 syslog(priority
, "%s", state
.header_str
);
355 syslog(priority
, "%s", msg
);
357 #endif /* WITH_SYSLOG */
359 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
360 #include <systemd/sd-journal.h>
361 static void debug_systemd_log(int msg_level
, const char *msg
, size_t msg_len
)
363 if (state
.hs_len
> 0) {
364 ensure_copy_no_nl(state
.header_str_no_nl
,
365 sizeof(state
.header_str_no_nl
),
368 sd_journal_send("MESSAGE=%s",
369 state
.header_str_no_nl
,
371 debug_level_to_priority(msg_level
),
376 ensure_copy_no_nl(state
.msg_no_nl
,
377 sizeof(state
.msg_no_nl
),
379 sd_journal_send("MESSAGE=%s", state
.msg_no_nl
,
380 "PRIORITY=%d", debug_level_to_priority(msg_level
),
381 "LEVEL=%d", msg_level
,
386 #ifdef HAVE_LTTNG_TRACEF
387 #include <lttng/tracef.h>
388 static void debug_lttng_log(int msg_level
, const char *msg
, size_t msg_len
)
390 if (state
.hs_len
> 0) {
391 ensure_copy_no_nl(state
.header_str_no_nl
,
392 sizeof(state
.header_str_no_nl
),
395 tracef(state
.header_str_no_nl
);
397 ensure_copy_no_nl(state
.msg_no_nl
,
398 sizeof(state
.msg_no_nl
),
400 tracef(state
.msg_no_nl
);
402 #endif /* WITH_LTTNG_TRACEF */
405 #include "gpfswrap.h"
406 static void debug_gpfs_reload(bool enabled
, bool previously_enabled
,
407 const char *prog_name
, char *option
)
413 if (enabled
&& !previously_enabled
) {
414 gpfswrap_init_trace();
418 if (!enabled
&& previously_enabled
) {
419 gpfswrap_fini_trace();
425 * Trigger GPFS library to adjust state if necessary.
427 gpfswrap_query_trace();
431 static void debug_gpfs_log(int msg_level
, const char *msg
, size_t msg_len
)
433 if (state
.hs_len
> 0) {
434 ensure_copy_no_nl(state
.header_str_no_nl
,
435 sizeof(state
.header_str_no_nl
),
438 gpfswrap_add_trace(msg_level
, state
.header_str_no_nl
);
440 ensure_copy_no_nl(state
.msg_no_nl
,
441 sizeof(state
.msg_no_nl
),
443 gpfswrap_add_trace(msg_level
, state
.msg_no_nl
);
445 #endif /* HAVE_GPFS */
447 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
448 #define DEBUG_RINGBUF_SIZE_OPT "size="
450 static char *debug_ringbuf
;
451 static size_t debug_ringbuf_size
;
452 static size_t debug_ringbuf_ofs
;
454 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
455 char *debug_get_ringbuf(void)
457 return debug_ringbuf
;
460 /* Return the size of the ringbuf (including a \0 terminator) */
461 size_t debug_get_ringbuf_size(void)
463 return debug_ringbuf_size
;
466 static void debug_ringbuf_reload(bool enabled
, bool previously_enabled
,
467 const char *prog_name
, char *option
)
470 size_t optlen
= strlen(DEBUG_RINGBUF_SIZE_OPT
);
472 debug_ringbuf_size
= DEBUG_RINGBUF_SIZE
;
473 debug_ringbuf_ofs
= 0;
475 SAFE_FREE(debug_ringbuf
);
481 if (option
!= NULL
) {
482 cmp
= strncmp(option
, DEBUG_RINGBUF_SIZE_OPT
, optlen
);
484 debug_ringbuf_size
= (size_t)strtoull(
485 option
+ optlen
, NULL
, 10);
489 debug_ringbuf
= calloc(debug_ringbuf_size
, sizeof(char));
490 if (debug_ringbuf
== NULL
) {
495 static void _debug_ringbuf_log(int msg_level
, const char *msg
, size_t msg_len
)
499 if (debug_ringbuf
== NULL
) {
503 /* Ensure the buffer is always \0 terminated */
504 allowed_size
= debug_ringbuf_size
- 1;
506 if (msg_len
> allowed_size
) {
510 if ((debug_ringbuf_ofs
+ msg_len
) < debug_ringbuf_ofs
) {
514 if ((debug_ringbuf_ofs
+ msg_len
) > allowed_size
) {
515 debug_ringbuf_ofs
= 0;
518 memcpy(debug_ringbuf
+ debug_ringbuf_ofs
, msg
, msg_len
);
519 debug_ringbuf_ofs
+= msg_len
;
522 static void debug_ringbuf_log(int msg_level
, const char *msg
, size_t msg_len
)
524 if (state
.hs_len
> 0) {
525 _debug_ringbuf_log(msg_level
, state
.header_str
, state
.hs_len
);
527 _debug_ringbuf_log(msg_level
, msg
, msg_len
);
530 static struct debug_backend
{
534 void (*reload
)(bool enabled
, bool prev_enabled
,
535 const char *prog_name
, char *option
);
536 void (*log
)(int msg_level
,
540 } debug_backends
[] = {
543 .log
= debug_file_log
,
548 .reload
= debug_syslog_reload
,
549 .log
= debug_syslog_log
,
553 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
556 .log
= debug_systemd_log
,
560 #ifdef HAVE_LTTNG_TRACEF
563 .log
= debug_lttng_log
,
570 .reload
= debug_gpfs_reload
,
571 .log
= debug_gpfs_log
,
576 .log
= debug_ringbuf_log
,
577 .reload
= debug_ringbuf_reload
,
581 static struct debug_backend
*debug_find_backend(const char *name
)
585 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
586 if (strcmp(name
, debug_backends
[i
].name
) == 0) {
587 return &debug_backends
[i
];
595 * parse "backend[:option][@loglevel]
597 static void debug_backend_parse_token(char *tok
)
599 char *backend_name_option
, *backend_name
,*backend_level
, *saveptr
;
600 char *backend_option
;
601 struct debug_backend
*b
;
604 * First parse into backend[:option] and loglevel
606 backend_name_option
= strtok_r(tok
, "@\0", &saveptr
);
607 if (backend_name_option
== NULL
) {
611 backend_level
= strtok_r(NULL
, "\0", &saveptr
);
614 * Now parse backend[:option]
616 backend_name
= strtok_r(backend_name_option
, ":\0", &saveptr
);
617 if (backend_name
== NULL
) {
621 backend_option
= strtok_r(NULL
, "\0", &saveptr
);
624 * Find and update backend
626 b
= debug_find_backend(backend_name
);
631 if (backend_level
== NULL
) {
632 b
->new_log_level
= MAX_DEBUG_LEVEL
;
634 b
->new_log_level
= atoi(backend_level
);
637 if (backend_option
!= NULL
) {
638 b
->option
= strdup(backend_option
);
639 if (b
->option
== NULL
) {
646 * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
647 * and enable/disable backends accordingly
649 static void debug_set_backends(const char *param
)
651 size_t str_len
= strlen(param
);
657 * initialize new_log_level to detect backends that have been
660 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
661 SAFE_FREE(debug_backends
[i
].option
);
662 debug_backends
[i
].new_log_level
= -1;
665 memcpy(str
, param
, str_len
+ 1);
667 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
672 while (tok
!= NULL
) {
673 debug_backend_parse_token(tok
);
674 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
678 * Let backends react to config changes
680 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
681 struct debug_backend
*b
= &debug_backends
[i
];
684 bool enabled
= b
->new_log_level
> -1;
685 bool previously_enabled
= b
->log_level
> -1;
687 b
->reload(enabled
, previously_enabled
, state
.prog_name
,
690 b
->log_level
= b
->new_log_level
;
694 static void debug_backends_log(const char *msg
, size_t msg_len
, int msg_level
)
699 * Some backends already add an extra newline, so initialize a
700 * buffer without the newline character. It will be filled by
701 * the first backend that needs it.
703 state
.msg_no_nl
[0] = '\0';
705 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
706 if (msg_level
<= debug_backends
[i
].log_level
) {
707 debug_backends
[i
].log(msg_level
, msg
, msg_len
);
711 /* Only log the header once */
715 int debuglevel_get_class(size_t idx
)
717 return dbgc_config
[idx
].loglevel
;
720 void debuglevel_set_class(size_t idx
, int level
)
722 dbgc_config
[idx
].loglevel
= level
;
726 /* -------------------------------------------------------------------------- **
727 * Internal variables.
729 * debug_count - Number of debug messages that have been output.
730 * Used to check log size.
732 * current_msg_level - Internal copy of the message debug level. Written by
733 * dbghdr() and read by Debug1().
735 * format_bufr - Used to format debug messages. The dbgtext() function
736 * prints debug messages to a string, and then passes the
737 * string to format_debug_text(), which uses format_bufr
738 * to build the formatted output.
740 * format_pos - Marks the first free byte of the format_bufr.
743 * log_overflow - When this variable is true, never attempt to check the
744 * size of the log. This is a hack, so that we can write
745 * a message using DEBUG, from open_logs() when we
746 * are unable to open a new log file for some reason.
749 static int debug_count
= 0;
750 static char format_bufr
[FORMAT_BUFR_SIZE
];
751 static size_t format_pos
= 0;
752 static bool log_overflow
= false;
755 * Define all the debug class selection names here. Names *MUST NOT* contain
756 * white space. There must be one name for each DBGC_<class name>, and they
757 * must be in the table in the order of DBGC_<class name>..
760 static char **classname_table
= NULL
;
763 /* -------------------------------------------------------------------------- **
767 static void debug_init(void);
769 /***************************************************************************
770 Free memory pointed to by global pointers.
771 ****************************************************************************/
773 void gfree_debugsyms(void)
777 TALLOC_FREE(classname_table
);
779 if ( dbgc_config
!= debug_class_list_initial
) {
780 TALLOC_FREE( dbgc_config
);
781 dbgc_config
= discard_const_p(struct debug_class
,
782 debug_class_list_initial
);
785 debug_num_classes
= 0;
787 state
.initialized
= false;
789 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
790 SAFE_FREE(debug_backends
[i
].option
);
794 /****************************************************************************
795 utility lists registered debug class names's
796 ****************************************************************************/
798 char *debug_list_class_names_and_levels(void)
800 char *buf
= talloc_strdup(NULL
, "");
802 /* prepare strings */
803 for (i
= 0; i
< debug_num_classes
; i
++) {
804 talloc_asprintf_addbuf(&buf
,
807 dbgc_config
[i
].loglevel
,
808 i
== (debug_num_classes
- 1) ? "\n" : " ");
813 /****************************************************************************
814 Utility to translate names to debug class index's (internal version).
815 ****************************************************************************/
817 static int debug_lookup_classname_int(const char* classname
)
821 if (classname
== NULL
) {
825 for (i
=0; i
< debug_num_classes
; i
++) {
826 char *entry
= classname_table
[i
];
827 if (entry
!= NULL
&& strcmp(classname
, entry
)==0) {
834 /****************************************************************************
835 Add a new debug class to the system.
836 ****************************************************************************/
838 int debug_add_class(const char *classname
)
841 struct debug_class
*new_class_list
= NULL
;
842 char **new_name_list
;
845 if (classname
== NULL
) {
849 /* check the init has yet been called */
852 ndx
= debug_lookup_classname_int(classname
);
856 ndx
= debug_num_classes
;
858 if (dbgc_config
== debug_class_list_initial
) {
859 /* Initial loading... */
860 new_class_list
= NULL
;
862 new_class_list
= dbgc_config
;
865 default_level
= dbgc_config
[DBGC_ALL
].loglevel
;
867 new_class_list
= talloc_realloc(NULL
,
871 if (new_class_list
== NULL
) {
875 dbgc_config
= new_class_list
;
877 dbgc_config
[ndx
] = (struct debug_class
) {
878 .loglevel
= default_level
,
882 new_name_list
= talloc_realloc(NULL
, classname_table
, char *, ndx
+ 1);
883 if (new_name_list
== NULL
) {
886 classname_table
= new_name_list
;
888 classname_table
[ndx
] = talloc_strdup(classname_table
, classname
);
889 if (classname_table
[ndx
] == NULL
) {
893 debug_num_classes
= ndx
+ 1;
898 /****************************************************************************
899 Utility to translate names to debug class index's (public version).
900 ****************************************************************************/
902 static int debug_lookup_classname(const char *classname
)
906 if (classname
== NULL
|| !*classname
)
909 ndx
= debug_lookup_classname_int(classname
);
914 DBG_WARNING("Unknown classname[%s] -> adding it...\n", classname
);
915 return debug_add_class(classname
);
918 /****************************************************************************
919 Dump the current registered debug levels.
920 ****************************************************************************/
922 static void debug_dump_status(int level
)
926 DEBUG(level
, ("INFO: Current debug levels:\n"));
927 for (q
= 0; q
< debug_num_classes
; q
++) {
928 const char *classname
= classname_table
[q
];
929 DEBUGADD(level
, (" %s: %d\n",
931 dbgc_config
[q
].loglevel
));
935 static bool debug_parse_param(char *param
)
938 char *class_file
= NULL
;
940 char *saveptr
= NULL
;
943 class_name
= strtok_r(param
, ":", &saveptr
);
944 if (class_name
== NULL
) {
948 class_level
= strtok_r(NULL
, "@\0", &saveptr
);
949 if (class_level
== NULL
) {
953 class_file
= strtok_r(NULL
, "\0", &saveptr
);
955 ndx
= debug_lookup_classname(class_name
);
960 dbgc_config
[ndx
].loglevel
= atoi(class_level
);
962 if (class_file
== NULL
) {
966 TALLOC_FREE(dbgc_config
[ndx
].logfile
);
968 dbgc_config
[ndx
].logfile
= talloc_strdup(NULL
, class_file
);
969 if (dbgc_config
[ndx
].logfile
== NULL
) {
975 /****************************************************************************
976 Parse the debug levels from smb.conf. Example debug level string:
977 3 tdb:5 printdrivers:7
978 Note: the 1st param has no "name:" preceding it.
979 ****************************************************************************/
981 bool debug_parse_levels(const char *params_str
)
983 size_t str_len
= strlen(params_str
);
991 memcpy(str
, params_str
, str_len
+1);
993 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
998 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
999 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
1001 if (isdigit(tok
[0])) {
1002 dbgc_config
[DBGC_ALL
].loglevel
= atoi(tok
);
1003 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
1005 dbgc_config
[DBGC_ALL
].loglevel
= 0;
1008 /* Array is debug_num_classes long */
1009 for (i
= DBGC_ALL
+1; i
< debug_num_classes
; i
++) {
1010 dbgc_config
[i
].loglevel
= dbgc_config
[DBGC_ALL
].loglevel
;
1011 TALLOC_FREE(dbgc_config
[i
].logfile
);
1014 while (tok
!= NULL
) {
1017 ok
= debug_parse_param(tok
);
1019 DEBUG(0,("debug_parse_params: unrecognized debug "
1020 "class name or format [%s]\n", tok
));
1024 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
1027 debug_dump_status(5);
1032 /* setup for logging of talloc warnings */
1033 static void talloc_log_fn(const char *msg
)
1035 DEBUG(0,("%s", msg
));
1038 void debug_setup_talloc_log(void)
1040 talloc_set_log_fn(talloc_log_fn
);
1044 /****************************************************************************
1045 Init debugging (one time stuff)
1046 ****************************************************************************/
1048 static void debug_init(void)
1052 if (state
.initialized
)
1055 state
.initialized
= true;
1057 debug_setup_talloc_log();
1059 for (i
= 0; i
< ARRAY_SIZE(default_classname_table
); i
++) {
1060 debug_add_class(default_classname_table
[i
]);
1062 dbgc_config
[DBGC_ALL
].fd
= 2;
1064 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
1065 debug_backends
[i
].log_level
= -1;
1066 debug_backends
[i
].new_log_level
= -1;
1070 void debug_set_settings(struct debug_settings
*settings
,
1071 const char *logging_param
,
1072 int syslog_level
, bool syslog_only
)
1074 char fake_param
[256];
1078 * This forces in some smb.conf derived values into the debug
1079 * system. There are no pointers in this structure, so we can
1080 * just structure-assign it in
1082 state
.settings
= *settings
;
1085 * If 'logging' is not set, create backend settings from
1086 * deprecated 'syslog' and 'syslog only' parameters
1088 if (logging_param
!= NULL
) {
1089 len
= strlen(logging_param
);
1093 snprintf(fake_param
, sizeof(fake_param
),
1094 "syslog@%d", syslog_level
- 1);
1096 snprintf(fake_param
, sizeof(fake_param
),
1097 "syslog@%d file@%d", syslog_level
-1,
1101 logging_param
= fake_param
;
1104 debug_set_backends(logging_param
);
1107 static void ensure_hostname(void)
1111 if (state
.hostname
[0] != '\0') {
1115 ret
= gethostname(state
.hostname
, sizeof(state
.hostname
));
1117 strlcpy(state
.hostname
, "unknown", sizeof(state
.hostname
));
1122 * Ensure NUL termination, since POSIX isn't clear about that.
1124 * Don't worry about truncating at the first '.' or similar,
1125 * since this is usually not fully qualified. Trying to
1126 * truncate opens up the multibyte character gates of hell.
1128 state
.hostname
[sizeof(state
.hostname
) - 1] = '\0';
1131 void debug_set_hostname(const char *name
)
1133 strlcpy(state
.hostname
, name
, sizeof(state
.hostname
));
1137 * Ensure debug logs are initialised.
1139 * setup_logging() is called to direct logging to the correct outputs, whether
1140 * those be stderr, stdout, files, or syslog, and set the program name used in
1141 * the logs. It can be called multiple times.
1143 * There is an order of precedence to the log type. Once set to DEBUG_FILE, it
1144 * cannot be reset DEFAULT_DEBUG_STDERR, but can be set to DEBUG_STDERR, after
1145 * which DEBUG_FILE is unavailable). This makes it possible to override for
1146 * debug to stderr on the command line, as the smb.conf cannot reset it back
1147 * to file-based logging. See enum debug_logtype.
1149 * @param prog_name the program name. Directory path component will be
1152 * @param new_logtype the requested destination for the debug log,
1153 * as an enum debug_logtype.
1155 void setup_logging(const char *prog_name
, enum debug_logtype new_logtype
)
1158 if (state
.logtype
< new_logtype
) {
1159 state
.logtype
= new_logtype
;
1162 const char *p
= strrchr(prog_name
, '/');
1168 strlcpy(state
.prog_name
, prog_name
, sizeof(state
.prog_name
));
1170 reopen_logs_internal();
1173 /***************************************************************************
1174 Set the logfile name.
1175 **************************************************************************/
1177 void debug_set_logfile(const char *name
)
1179 if (name
== NULL
|| *name
== 0) {
1180 /* this copes with calls when smb.conf is not loaded yet */
1183 TALLOC_FREE(dbgc_config
[DBGC_ALL
].logfile
);
1184 dbgc_config
[DBGC_ALL
].logfile
= talloc_strdup(NULL
, name
);
1186 reopen_logs_internal();
1189 static void debug_close_fd(int fd
)
1196 enum debug_logtype
debug_get_log_type(void)
1198 return state
.logtype
;
1201 bool debug_get_output_is_stderr(void)
1203 return (state
.logtype
== DEBUG_DEFAULT_STDERR
) || (state
.logtype
== DEBUG_STDERR
);
1206 bool debug_get_output_is_stdout(void)
1208 return (state
.logtype
== DEBUG_DEFAULT_STDOUT
) || (state
.logtype
== DEBUG_STDOUT
);
1211 void debug_set_callback(void *private_ptr
, debug_callback_fn fn
)
1215 state
.logtype
= DEBUG_CALLBACK
;
1216 state
.callback_private
= private_ptr
;
1217 state
.callback
= fn
;
1219 state
.logtype
= DEBUG_DEFAULT_STDERR
;
1220 state
.callback_private
= NULL
;
1221 state
.callback
= NULL
;
1225 static void debug_callback_log(const char *msg
, size_t msg_len
, int msg_level
)
1227 char msg_copy
[msg_len
];
1229 if ((msg_len
> 0) && (msg
[msg_len
-1] == '\n')) {
1230 memcpy(msg_copy
, msg
, msg_len
-1);
1231 msg_copy
[msg_len
-1] = '\0';
1235 state
.callback(state
.callback_private
, msg_level
, msg
);
1238 /**************************************************************************
1239 reopen the log files
1240 note that we now do this unconditionally
1241 We attempt to open the new debug fp before closing the old. This means
1242 if we run out of fd's we just keep using the old fd rather than aborting.
1243 Fix from dgibson@linuxcare.com.
1244 **************************************************************************/
1246 static bool reopen_one_log(struct debug_class
*config
)
1248 int old_fd
= config
->fd
;
1249 const char *logfile
= config
->logfile
;
1254 if (logfile
== NULL
) {
1255 debug_close_fd(old_fd
);
1260 new_fd
= open(logfile
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
1262 log_overflow
= true;
1263 DBG_ERR("Unable to open new log file '%s': %s\n",
1264 logfile
, strerror(errno
));
1265 log_overflow
= false;
1269 debug_close_fd(old_fd
);
1270 smb_set_close_on_exec(new_fd
);
1271 config
->fd
= new_fd
;
1273 ret
= fstat(new_fd
, &st
);
1275 log_overflow
= true;
1276 DBG_ERR("Unable to fstat() new log file '%s': %s\n",
1277 logfile
, strerror(errno
));
1278 log_overflow
= false;
1282 config
->ino
= st
.st_ino
;
1287 reopen the log file (usually called because the log file name might have changed)
1289 bool reopen_logs_internal(void)
1291 struct debug_backend
*b
= NULL
;
1296 if (state
.reopening_logs
) {
1300 /* Now clear the SIGHUP induced flag */
1301 state
.schedule_reopen_logs
= false;
1303 switch (state
.logtype
) {
1304 case DEBUG_CALLBACK
:
1307 case DEBUG_DEFAULT_STDOUT
:
1308 debug_close_fd(dbgc_config
[DBGC_ALL
].fd
);
1309 dbgc_config
[DBGC_ALL
].fd
= 1;
1312 case DEBUG_DEFAULT_STDERR
:
1314 debug_close_fd(dbgc_config
[DBGC_ALL
].fd
);
1315 dbgc_config
[DBGC_ALL
].fd
= 2;
1319 b
= debug_find_backend("file");
1322 b
->log_level
= MAX_DEBUG_LEVEL
;
1326 oldumask
= umask( 022 );
1328 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1329 if (dbgc_config
[i
].logfile
!= NULL
) {
1333 if (i
== debug_num_classes
) {
1337 state
.reopening_logs
= true;
1339 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1340 ok
= reopen_one_log(&dbgc_config
[i
]);
1346 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1347 * to fix problem where smbd's that generate less
1348 * than 100 messages keep growing the log.
1350 force_check_log_size();
1351 (void)umask(oldumask
);
1354 * If log file was opened or created successfully, take over stderr to
1355 * catch output into logs.
1357 if (!state
.settings
.debug_no_stderr_redirect
&&
1358 dbgc_config
[DBGC_ALL
].fd
> 0) {
1359 if (dup2(dbgc_config
[DBGC_ALL
].fd
, 2) == -1) {
1360 /* Close stderr too, if dup2 can't point it -
1361 at the logfile. There really isn't much
1362 that can be done on such a fundamental
1368 state
.reopening_logs
= false;
1373 /**************************************************************************
1374 Force a check of the log size.
1375 ***************************************************************************/
1377 void force_check_log_size( void )
1382 _PUBLIC_
void debug_schedule_reopen_logs(void)
1384 state
.schedule_reopen_logs
= true;
1388 /***************************************************************************
1389 Check to see if there is any need to check if the logfile has grown too big.
1390 **************************************************************************/
1392 bool need_to_check_log_size(void)
1397 if (debug_count
< 100) {
1401 maxlog
= state
.settings
.max_log_size
* 1024;
1407 if (dbgc_config
[DBGC_ALL
].fd
> 2) {
1411 for (i
= DBGC_ALL
+ 1; i
< debug_num_classes
; i
++) {
1412 if (dbgc_config
[i
].fd
!= -1) {
1421 /**************************************************************************
1422 Check to see if the log has grown to be too big.
1423 **************************************************************************/
1425 static void do_one_check_log_size(off_t maxlog
, struct debug_class
*config
)
1427 char name
[strlen(config
->logfile
) + 5];
1430 bool reopen
= false;
1437 ret
= stat(config
->logfile
, &st
);
1441 if (st
.st_size
>= maxlog
) {
1445 if (st
.st_ino
!= config
->ino
) {
1453 /* reopen_logs_internal() modifies *_fd */
1454 (void)reopen_logs_internal();
1456 if (config
->fd
<= 2) {
1459 ret
= fstat(config
->fd
, &st
);
1461 config
->ino
= (ino_t
)0;
1465 config
->ino
= st
.st_ino
;
1467 if (st
.st_size
< maxlog
) {
1471 snprintf(name
, sizeof(name
), "%s.old", config
->logfile
);
1473 (void)rename(config
->logfile
, name
);
1475 ok
= reopen_logs_internal();
1479 /* We failed to reopen a log - continue using the old name. */
1480 (void)rename(name
, config
->logfile
);
1483 static void do_check_log_size(off_t maxlog
)
1487 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1488 if (dbgc_config
[i
].fd
== -1) {
1491 if (dbgc_config
[i
].logfile
== NULL
) {
1494 do_one_check_log_size(maxlog
, &dbgc_config
[i
]);
1498 void check_log_size( void )
1502 if (geteuid() != 0) {
1504 * We need to be root to change the log file (tests use a fake
1505 * geteuid() from third_party/uid_wrapper). Otherwise we skip
1506 * this and let the main smbd loop or some other process do
1512 if(log_overflow
|| (!state
.schedule_reopen_logs
&& !need_to_check_log_size())) {
1516 maxlog
= state
.settings
.max_log_size
* 1024;
1518 if (state
.schedule_reopen_logs
) {
1519 (void)reopen_logs_internal();
1522 do_check_log_size(maxlog
);
1525 * Here's where we need to panic if dbgc_config[DBGC_ALL].fd == 0 or -1
1529 if (dbgc_config
[DBGC_ALL
].fd
<= 0) {
1530 /* This code should only be reached in very strange
1531 * circumstances. If we merely fail to open the new log we
1532 * should stick with the old one. ergo this should only be
1533 * reached when opening the logs for the first time: at
1534 * startup or when the log level is increased from zero.
1537 int fd
= open( "/dev/console", O_WRONLY
, 0);
1539 smb_set_close_on_exec(fd
);
1540 dbgc_config
[DBGC_ALL
].fd
= fd
;
1541 DBG_ERR("check_log_size: open of debug file %s failed "
1542 "- using console.\n",
1543 dbgc_config
[DBGC_ALL
].logfile
);
1546 * We cannot continue without a debug file handle.
1554 /*************************************************************************
1555 Write an debug message on the debugfile.
1556 This is called by format_debug_text().
1557 ************************************************************************/
1559 static void Debug1(const char *msg
, size_t msg_len
)
1561 int old_errno
= errno
;
1562 enum debug_logtype logtype
= state
.logtype
;
1566 if (state
.settings
.debug_syslog_format
== DEBUG_SYSLOG_FORMAT_ALWAYS
) {
1567 switch(state
.logtype
) {
1570 case DEBUG_DEFAULT_STDOUT
:
1571 case DEBUG_DEFAULT_STDERR
:
1572 /* Behave the same as logging to a file */
1573 logtype
= DEBUG_FILE
;
1581 case DEBUG_CALLBACK
:
1582 debug_callback_log(msg
, msg_len
, current_msg_level
);
1586 case DEBUG_DEFAULT_STDOUT
:
1587 case DEBUG_DEFAULT_STDERR
:
1588 if (dbgc_config
[DBGC_ALL
].fd
> 0) {
1591 ret
= write(dbgc_config
[DBGC_ALL
].fd
,
1594 } while (ret
== -1 && errno
== EINTR
);
1598 debug_backends_log(msg
, msg_len
, current_msg_level
);
1605 /**************************************************************************
1606 Print the buffer content via Debug1(), then reset the buffer.
1609 ****************************************************************************/
1611 static void bufr_print( void )
1613 format_bufr
[format_pos
] = '\0';
1614 (void)Debug1(format_bufr
, format_pos
);
1619 * If set (by tevent_thread_call_depth_set()) to value > 0, debug code will use
1620 * it for the trace indentation.
1622 static size_t debug_call_depth
= 0;
1624 size_t *debug_call_depth_addr(void)
1626 return &debug_call_depth
;
1629 /***************************************************************************
1630 Format the debug message text.
1632 Input: msg - Text to be added to the "current" debug message text.
1636 Notes: The purpose of this is two-fold. First, each call to syslog()
1637 (used by Debug1(), see above) generates a new line of syslog
1638 output. This is fixed by storing the partial lines until the
1639 newline character is encountered. Second, printing the debug
1640 message lines when a newline is encountered allows us to add
1641 spaces, thus indenting the body of the message and making it
1643 **************************************************************************/
1645 static void format_debug_text( const char *msg
)
1648 bool timestamp
= (state
.logtype
== DEBUG_FILE
&& (state
.settings
.timestamp_logs
));
1652 for( i
= 0; msg
[i
]; i
++ ) {
1653 /* Indent two spaces at each new line. */
1654 if(timestamp
&& 0 == format_pos
) {
1655 /* Limit the maximum indentation to 20 levels */
1656 size_t depth
= MIN(20, debug_call_depth
);
1657 format_bufr
[0] = format_bufr
[1] = ' ';
1660 * Indent by four spaces for each depth level,
1661 * but only if the current debug level is >= 8.
1663 if (depth
> 0 && debuglevel_get() >= 8 &&
1664 format_pos
+ 4 * depth
< FORMAT_BUFR_SIZE
) {
1665 memset(&format_bufr
[format_pos
],
1668 format_pos
+= 4 * depth
;
1672 /* If there's room, copy the character to the format buffer. */
1673 if (format_pos
< FORMAT_BUFR_SIZE
- 1)
1674 format_bufr
[format_pos
++] = msg
[i
];
1676 /* If a newline is encountered, print & restart. */
1677 if( '\n' == msg
[i
] )
1680 /* If the buffer is full dump it out, reset it, and put out a line
1681 * continuation indicator.
1683 if (format_pos
>= FORMAT_BUFR_SIZE
- 1) {
1684 const char cont
[] = " +>\n";
1686 (void)Debug1(cont
, sizeof(cont
) - 1);
1690 /* Just to be safe... */
1691 format_bufr
[format_pos
] = '\0';
1694 /***************************************************************************
1695 Flush debug output, including the format buffer content.
1699 ***************************************************************************/
1701 void dbgflush( void )
1706 bool dbgsetclass(int level
, int cls
)
1708 /* Set current_msg_level. */
1709 current_msg_level
= level
;
1711 /* Set current message class */
1712 current_msg_class
= cls
;
1717 /***************************************************************************
1718 Put a Debug Header into header_str.
1720 Input: level - Debug level of the message (not the system-wide debug
1722 cls - Debuglevel class of the calling module.
1723 location - Pointer to a string containing the name of the file
1724 from which this function was called, or an empty string
1725 if the __FILE__ macro is not implemented.
1726 func - Pointer to a string containing the name of the function
1727 from which this function was called, or an empty string
1728 if the __FUNCTION__ macro is not implemented.
1730 Output: Always true. This makes it easy to fudge a call to dbghdr()
1731 in a macro, since the function can be called as part of a test.
1732 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1734 Notes: This function takes care of setting current_msg_level.
1736 ****************************************************************************/
1738 bool dbghdrclass(int level
, int cls
, const char *location
, const char *func
)
1740 /* Ensure we don't lose any real errno value. */
1741 int old_errno
= errno
;
1742 bool verbose
= false;
1744 struct timeval_buf tvbuf
;
1747 * This might be overkill, but if another early return is
1748 * added later then initialising these avoids potential
1752 state
.header_str
[0] = '\0';
1755 /* This is a fudge. If there is stuff sitting in the format_bufr, then
1756 * the *right* thing to do is to call
1757 * format_debug_text( "\n" );
1758 * to write the remainder, and then proceed with the new header.
1759 * Unfortunately, there are several places in the code at which
1760 * the DEBUG() macro is used to build partial lines. That in mind,
1761 * we'll work under the assumption that an incomplete line indicates
1762 * that a new header is *not* desired.
1767 dbgsetclass(level
, cls
);
1770 * Don't print a header if we're logging to stdout,
1771 * unless 'debug syslog format = always'
1773 if (state
.logtype
!= DEBUG_FILE
&&
1774 state
.settings
.debug_syslog_format
!= DEBUG_SYSLOG_FORMAT_ALWAYS
)
1780 * Print the header if timestamps (or debug syslog format) is
1781 * turned on. If parameters are not yet loaded, then default
1784 if (!(state
.settings
.timestamp_logs
||
1785 state
.settings
.debug_prefix_timestamp
||
1786 state
.settings
.debug_syslog_format
!= DEBUG_SYSLOG_FORMAT_NO
))
1793 if (state
.settings
.debug_syslog_format
!= DEBUG_SYSLOG_FORMAT_NO
) {
1794 if (state
.settings
.debug_hires_timestamp
) {
1795 timeval_str_buf(&tv
, true, true, &tvbuf
);
1800 t
= (time_t)tv
.tv_sec
;
1804 len
= strftime(tvbuf
.buf
,
1809 /* Trigger default time format below */
1816 "%ld seconds since the Epoch", (long)t
);
1821 state
.hs_len
= snprintf(state
.header_str
,
1822 sizeof(state
.header_str
),
1825 (int)(sizeof(state
.hostname
) - 1),
1828 (unsigned int) getpid());
1833 timeval_str_buf(&tv
, false, state
.settings
.debug_hires_timestamp
,
1836 state
.hs_len
= snprintf(state
.header_str
,
1837 sizeof(state
.header_str
),
1841 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1845 if (unlikely(dbgc_config
[cls
].loglevel
>= 10)) {
1849 if (verbose
|| state
.settings
.debug_pid
) {
1850 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1851 sizeof(state
.header_str
) - state
.hs_len
,
1853 (unsigned int)getpid());
1854 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1859 if (verbose
|| state
.settings
.debug_uid
) {
1860 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1861 sizeof(state
.header_str
) - state
.hs_len
,
1862 ", effective(%u, %u), real(%u, %u)",
1863 (unsigned int)geteuid(),
1864 (unsigned int)getegid(),
1865 (unsigned int)getuid(),
1866 (unsigned int)getgid());
1867 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1872 if ((verbose
|| state
.settings
.debug_class
)
1873 && (cls
!= DBGC_ALL
)) {
1874 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1875 sizeof(state
.header_str
) - state
.hs_len
,
1877 classname_table
[cls
]);
1878 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1883 if (debug_traceid_get() != 0) {
1884 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1885 sizeof(state
.header_str
) - state
.hs_len
,
1886 ", traceid=%" PRIu64
,
1887 debug_traceid_get());
1888 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1893 if (debug_call_depth
> 0) {
1894 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1895 sizeof(state
.header_str
) - state
.hs_len
,
1898 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1903 state
.header_str
[state
.hs_len
] = ']';
1905 if (state
.hs_len
< sizeof(state
.header_str
) - 1) {
1906 state
.header_str
[state
.hs_len
] = ' ';
1909 state
.header_str
[state
.hs_len
] = '\0';
1911 if (!state
.settings
.debug_prefix_timestamp
) {
1912 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1913 sizeof(state
.header_str
) - state
.hs_len
,
1917 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1924 * Above code never overflows state.header_str and always
1925 * NUL-terminates correctly. However, state.hs_len can point
1926 * past the end of the buffer to indicate that truncation
1927 * occurred, so fix it if necessary, since state.hs_len is
1928 * expected to be used after return.
1930 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1931 state
.hs_len
= sizeof(state
.header_str
) - 1;
1934 state
.header_str_no_nl
[0] = '\0';
1940 /***************************************************************************
1941 Add text to the body of the "current" debug message via the format buffer.
1943 Input: format_str - Format string, as used in printf(), et. al.
1944 ... - Variable argument list.
1946 ..or.. va_alist - Old style variable parameter list starting point.
1948 Output: Always true. See dbghdr() for more info, though this is not
1949 likely to be used in the same way.
1951 ***************************************************************************/
1953 static inline bool __dbgtext_va(const char *format_str
, va_list ap
) PRINTF_ATTRIBUTE(1,0);
1954 static inline bool __dbgtext_va(const char *format_str
, va_list ap
)
1956 char *msgbuf
= NULL
;
1960 res
= vasprintf(&msgbuf
, format_str
, ap
);
1962 format_debug_text(msgbuf
);
1970 bool dbgtext_va(const char *format_str
, va_list ap
)
1972 return __dbgtext_va(format_str
, ap
);
1975 bool dbgtext(const char *format_str
, ... )
1980 va_start(ap
, format_str
);
1981 ret
= __dbgtext_va(format_str
, ap
);
1987 static uint64_t debug_traceid
= 0;
1989 uint64_t debug_traceid_set(uint64_t id
)
1991 uint64_t old_id
= debug_traceid
;
1996 uint64_t debug_traceid_get(void)
1998 return debug_traceid
;