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 */
127 static const char *default_classname_table
[] = {
130 [DBGC_PRINTDRIVERS
] = "printdrivers",
131 [DBGC_LANMAN
] = "lanman",
133 [DBGC_RPC_PARSE
] = "rpc_parse",
134 [DBGC_RPC_SRV
] = "rpc_srv",
135 [DBGC_RPC_CLI
] = "rpc_cli",
136 [DBGC_PASSDB
] = "passdb",
138 [DBGC_AUTH
] = "auth",
139 [DBGC_WINBIND
] = "winbind",
141 [DBGC_IDMAP
] = "idmap",
142 [DBGC_QUOTA
] = "quota",
143 [DBGC_ACLS
] = "acls",
144 [DBGC_LOCKING
] = "locking",
145 [DBGC_MSDFS
] = "msdfs",
146 [DBGC_DMAPI
] = "dmapi",
147 [DBGC_REGISTRY
] = "registry",
148 [DBGC_SCAVENGER
] = "scavenger",
151 [DBGC_TEVENT
] = "tevent",
152 [DBGC_AUTH_AUDIT
] = "auth_audit",
153 [DBGC_AUTH_AUDIT_JSON
] = "auth_json_audit",
154 [DBGC_KERBEROS
] = "kerberos",
155 [DBGC_DRS_REPL
] = "drs_repl",
156 [DBGC_SMB2
] = "smb2",
157 [DBGC_SMB2_CREDITS
] = "smb2_credits",
158 [DBGC_DSDB_AUDIT
] = "dsdb_audit",
159 [DBGC_DSDB_AUDIT_JSON
] = "dsdb_json_audit",
160 [DBGC_DSDB_PWD_AUDIT
] = "dsdb_password_audit",
161 [DBGC_DSDB_PWD_AUDIT_JSON
] = "dsdb_password_json_audit",
162 [DBGC_DSDB_TXN_AUDIT
] = "dsdb_transaction_audit",
163 [DBGC_DSDB_TXN_AUDIT_JSON
] = "dsdb_transaction_json_audit",
164 [DBGC_DSDB_GROUP_AUDIT
] = "dsdb_group_audit",
165 [DBGC_DSDB_GROUP_AUDIT_JSON
] = "dsdb_group_json_audit",
169 * This is to allow reading of dbgc_config before the debug
170 * system has been initialized.
172 static struct debug_class debug_class_list_initial
[ARRAY_SIZE(default_classname_table
)] = {
173 [DBGC_ALL
] = { .fd
= 2 },
176 static size_t debug_num_classes
= 0;
177 static struct debug_class
*dbgc_config
= debug_class_list_initial
;
179 static int current_msg_level
= 0;
180 static int current_msg_class
= 0;
182 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
183 static int debug_level_to_priority(int level
)
186 * map debug levels to syslog() priorities
188 static const int priority_map
[] = {
202 if (level
< 0 || (size_t)level
>= ARRAY_SIZE(priority_map
))
203 priority
= LOG_DEBUG
;
205 priority
= priority_map
[level
];
211 /* -------------------------------------------------------------------------- **
212 * Produce a version of the given buffer without any trailing newlines.
214 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD) || \
215 defined(HAVE_LTTNG_TRACEF) || defined(HAVE_GPFS)
216 static void copy_no_nl(char *out
,
223 * Some backends already add an extra newline, so also provide
224 * a buffer without the newline character.
226 len
= MIN(in_len
, out_size
- 1);
227 if ((len
> 0) && (in
[len
- 1] == '\n')) {
231 memcpy(out
, in
, len
);
235 static void ensure_copy_no_nl(char *out
,
241 * Assume out is a static buffer that is reused as a cache.
242 * If it isn't empty then this has already been done with the
245 if (out
[0] != '\0') {
249 copy_no_nl(out
, out_size
, in
, in_len
);
253 /* -------------------------------------------------------------------------- **
254 * Debug backends. When logging to DEBUG_FILE, send the log entries to
255 * all active backends.
258 static void debug_file_log(int msg_level
, const char *msg
, size_t msg_len
)
260 struct iovec iov
[] = {
262 .iov_base
= discard_const(state
.header_str
),
263 .iov_len
= state
.hs_len
,
266 .iov_base
= discard_const(msg
),
275 if (dbgc_config
[current_msg_class
].fd
!= -1) {
276 fd
= dbgc_config
[current_msg_class
].fd
;
278 fd
= dbgc_config
[DBGC_ALL
].fd
;
282 ret
= writev(fd
, iov
, ARRAY_SIZE(iov
));
283 } while (ret
== -1 && errno
== EINTR
);
287 static void debug_syslog_reload(bool enabled
, bool previously_enabled
,
288 const char *prog_name
, char *option
)
290 if (enabled
&& !previously_enabled
) {
291 const char *ident
= NULL
;
292 if ((prog_name
!= NULL
) && (prog_name
[0] != '\0')) {
296 openlog(ident
, LOG_PID
, SYSLOG_FACILITY
);
298 /* for old systems that have no facility codes. */
299 openlog(ident
, LOG_PID
);
304 if (!enabled
&& previously_enabled
) {
309 static void debug_syslog_log(int msg_level
, const char *msg
, size_t msg_len
)
313 priority
= debug_level_to_priority(msg_level
);
316 * Specify the facility to interoperate with other syslog
317 * callers (vfs_full_audit for example).
319 priority
|= SYSLOG_FACILITY
;
321 if (state
.hs_len
> 0) {
322 syslog(priority
, "%s", state
.header_str
);
324 syslog(priority
, "%s", msg
);
326 #endif /* WITH_SYSLOG */
328 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
329 #include <systemd/sd-journal.h>
330 static void debug_systemd_log(int msg_level
, const char *msg
, size_t msg_len
)
332 if (state
.hs_len
> 0) {
333 ensure_copy_no_nl(state
.header_str_no_nl
,
334 sizeof(state
.header_str_no_nl
),
337 sd_journal_send("MESSAGE=%s",
338 state
.header_str_no_nl
,
340 debug_level_to_priority(msg_level
),
345 ensure_copy_no_nl(state
.msg_no_nl
,
346 sizeof(state
.msg_no_nl
),
348 sd_journal_send("MESSAGE=%s", state
.msg_no_nl
,
349 "PRIORITY=%d", debug_level_to_priority(msg_level
),
350 "LEVEL=%d", msg_level
,
355 #ifdef HAVE_LTTNG_TRACEF
356 #include <lttng/tracef.h>
357 static void debug_lttng_log(int msg_level
, const char *msg
, size_t msg_len
)
359 if (state
.hs_len
> 0) {
360 ensure_copy_no_nl(state
.header_str_no_nl
,
361 sizeof(state
.header_str_no_nl
),
364 tracef(state
.header_str_no_nl
);
366 ensure_copy_no_nl(state
.msg_no_nl
,
367 sizeof(state
.msg_no_nl
),
369 tracef(state
.msg_no_nl
);
371 #endif /* WITH_LTTNG_TRACEF */
374 #include "gpfswrap.h"
375 static void debug_gpfs_reload(bool enabled
, bool previously_enabled
,
376 const char *prog_name
, char *option
)
380 if (enabled
&& !previously_enabled
) {
381 gpfswrap_init_trace();
385 if (!enabled
&& previously_enabled
) {
386 gpfswrap_fini_trace();
392 * Trigger GPFS library to adjust state if necessary.
394 gpfswrap_query_trace();
398 static void debug_gpfs_log(int msg_level
, const char *msg
, size_t msg_len
)
400 if (state
.hs_len
> 0) {
401 ensure_copy_no_nl(state
.header_str_no_nl
,
402 sizeof(state
.header_str_no_nl
),
405 gpfswrap_add_trace(msg_level
, state
.header_str_no_nl
);
407 ensure_copy_no_nl(state
.msg_no_nl
,
408 sizeof(state
.msg_no_nl
),
410 gpfswrap_add_trace(msg_level
, state
.msg_no_nl
);
412 #endif /* HAVE_GPFS */
414 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
415 #define DEBUG_RINGBUF_SIZE_OPT "size="
417 static char *debug_ringbuf
;
418 static size_t debug_ringbuf_size
;
419 static size_t debug_ringbuf_ofs
;
421 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
422 char *debug_get_ringbuf(void)
424 return debug_ringbuf
;
427 /* Return the size of the ringbuf (including a \0 terminator) */
428 size_t debug_get_ringbuf_size(void)
430 return debug_ringbuf_size
;
433 static void debug_ringbuf_reload(bool enabled
, bool previously_enabled
,
434 const char *prog_name
, char *option
)
437 size_t optlen
= strlen(DEBUG_RINGBUF_SIZE_OPT
);
439 debug_ringbuf_size
= DEBUG_RINGBUF_SIZE
;
440 debug_ringbuf_ofs
= 0;
442 SAFE_FREE(debug_ringbuf
);
448 if (option
!= NULL
) {
449 cmp
= strncmp(option
, DEBUG_RINGBUF_SIZE_OPT
, optlen
);
451 debug_ringbuf_size
= (size_t)strtoull(
452 option
+ optlen
, NULL
, 10);
456 debug_ringbuf
= calloc(debug_ringbuf_size
, sizeof(char));
457 if (debug_ringbuf
== NULL
) {
462 static void _debug_ringbuf_log(int msg_level
, const char *msg
, size_t msg_len
)
466 if (debug_ringbuf
== NULL
) {
470 /* Ensure the buffer is always \0 terminated */
471 allowed_size
= debug_ringbuf_size
- 1;
473 if (msg_len
> allowed_size
) {
477 if ((debug_ringbuf_ofs
+ msg_len
) < debug_ringbuf_ofs
) {
481 if ((debug_ringbuf_ofs
+ msg_len
) > allowed_size
) {
482 debug_ringbuf_ofs
= 0;
485 memcpy(debug_ringbuf
+ debug_ringbuf_ofs
, msg
, msg_len
);
486 debug_ringbuf_ofs
+= msg_len
;
489 static void debug_ringbuf_log(int msg_level
, const char *msg
, size_t msg_len
)
491 if (state
.hs_len
> 0) {
492 _debug_ringbuf_log(msg_level
, state
.header_str
, state
.hs_len
);
494 _debug_ringbuf_log(msg_level
, msg
, msg_len
);
497 static struct debug_backend
{
501 void (*reload
)(bool enabled
, bool prev_enabled
,
502 const char *prog_name
, char *option
);
503 void (*log
)(int msg_level
,
507 } debug_backends
[] = {
510 .log
= debug_file_log
,
515 .reload
= debug_syslog_reload
,
516 .log
= debug_syslog_log
,
520 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
523 .log
= debug_systemd_log
,
527 #ifdef HAVE_LTTNG_TRACEF
530 .log
= debug_lttng_log
,
537 .reload
= debug_gpfs_reload
,
538 .log
= debug_gpfs_log
,
543 .log
= debug_ringbuf_log
,
544 .reload
= debug_ringbuf_reload
,
548 static struct debug_backend
*debug_find_backend(const char *name
)
552 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
553 if (strcmp(name
, debug_backends
[i
].name
) == 0) {
554 return &debug_backends
[i
];
562 * parse "backend[:option][@loglevel]
564 static void debug_backend_parse_token(char *tok
)
566 char *backend_name_option
, *backend_name
,*backend_level
, *saveptr
;
567 char *backend_option
;
568 struct debug_backend
*b
;
571 * First parse into backend[:option] and loglevel
573 backend_name_option
= strtok_r(tok
, "@\0", &saveptr
);
574 if (backend_name_option
== NULL
) {
578 backend_level
= strtok_r(NULL
, "\0", &saveptr
);
581 * Now parse backend[:option]
583 backend_name
= strtok_r(backend_name_option
, ":\0", &saveptr
);
584 if (backend_name
== NULL
) {
588 backend_option
= strtok_r(NULL
, "\0", &saveptr
);
591 * Find and update backend
593 b
= debug_find_backend(backend_name
);
598 if (backend_level
== NULL
) {
599 b
->new_log_level
= MAX_DEBUG_LEVEL
;
601 b
->new_log_level
= atoi(backend_level
);
604 if (backend_option
!= NULL
) {
605 b
->option
= strdup(backend_option
);
606 if (b
->option
== NULL
) {
613 * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
614 * and enable/disable backends accordingly
616 static void debug_set_backends(const char *param
)
618 size_t str_len
= strlen(param
);
624 * initialize new_log_level to detect backends that have been
627 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
628 SAFE_FREE(debug_backends
[i
].option
);
629 debug_backends
[i
].new_log_level
= -1;
632 memcpy(str
, param
, str_len
+ 1);
634 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
639 while (tok
!= NULL
) {
640 debug_backend_parse_token(tok
);
641 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
645 * Let backends react to config changes
647 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
648 struct debug_backend
*b
= &debug_backends
[i
];
651 bool enabled
= b
->new_log_level
> -1;
652 bool previously_enabled
= b
->log_level
> -1;
654 b
->reload(enabled
, previously_enabled
, state
.prog_name
,
657 b
->log_level
= b
->new_log_level
;
661 static void debug_backends_log(const char *msg
, size_t msg_len
, int msg_level
)
666 * Some backends already add an extra newline, so initialize a
667 * buffer without the newline character. It will be filled by
668 * the first backend that needs it.
670 state
.msg_no_nl
[0] = '\0';
672 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
673 if (msg_level
<= debug_backends
[i
].log_level
) {
674 debug_backends
[i
].log(msg_level
, msg
, msg_len
);
678 /* Only log the header once */
682 int debuglevel_get_class(size_t idx
)
684 return dbgc_config
[idx
].loglevel
;
687 void debuglevel_set_class(size_t idx
, int level
)
689 dbgc_config
[idx
].loglevel
= level
;
693 /* -------------------------------------------------------------------------- **
694 * Internal variables.
696 * debug_count - Number of debug messages that have been output.
697 * Used to check log size.
699 * current_msg_level - Internal copy of the message debug level. Written by
700 * dbghdr() and read by Debug1().
702 * format_bufr - Used to format debug messages. The dbgtext() function
703 * prints debug messages to a string, and then passes the
704 * string to format_debug_text(), which uses format_bufr
705 * to build the formatted output.
707 * format_pos - Marks the first free byte of the format_bufr.
710 * log_overflow - When this variable is true, never attempt to check the
711 * size of the log. This is a hack, so that we can write
712 * a message using DEBUG, from open_logs() when we
713 * are unable to open a new log file for some reason.
716 static int debug_count
= 0;
717 static char format_bufr
[FORMAT_BUFR_SIZE
];
718 static size_t format_pos
= 0;
719 static bool log_overflow
= false;
722 * Define all the debug class selection names here. Names *MUST NOT* contain
723 * white space. There must be one name for each DBGC_<class name>, and they
724 * must be in the table in the order of DBGC_<class name>..
727 static char **classname_table
= NULL
;
730 /* -------------------------------------------------------------------------- **
734 static void debug_init(void);
736 /***************************************************************************
737 Free memory pointed to by global pointers.
738 ****************************************************************************/
740 void gfree_debugsyms(void)
744 TALLOC_FREE(classname_table
);
746 if ( dbgc_config
!= debug_class_list_initial
) {
747 TALLOC_FREE( dbgc_config
);
748 dbgc_config
= discard_const_p(struct debug_class
,
749 debug_class_list_initial
);
752 debug_num_classes
= 0;
754 state
.initialized
= false;
756 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
757 SAFE_FREE(debug_backends
[i
].option
);
761 /****************************************************************************
762 utility lists registered debug class names's
763 ****************************************************************************/
765 char *debug_list_class_names_and_levels(void)
769 /* prepare strings */
770 for (i
= 0; i
< debug_num_classes
; i
++) {
771 buf
= talloc_asprintf_append(buf
,
774 dbgc_config
[i
].loglevel
,
775 i
== (debug_num_classes
- 1) ? "\n" : " ");
783 /****************************************************************************
784 Utility to translate names to debug class index's (internal version).
785 ****************************************************************************/
787 static int debug_lookup_classname_int(const char* classname
)
791 if (classname
== NULL
) {
795 for (i
=0; i
< debug_num_classes
; i
++) {
796 char *entry
= classname_table
[i
];
797 if (entry
!= NULL
&& strcmp(classname
, entry
)==0) {
804 /****************************************************************************
805 Add a new debug class to the system.
806 ****************************************************************************/
808 int debug_add_class(const char *classname
)
811 struct debug_class
*new_class_list
= NULL
;
812 char **new_name_list
;
815 if (classname
== NULL
) {
819 /* check the init has yet been called */
822 ndx
= debug_lookup_classname_int(classname
);
826 ndx
= debug_num_classes
;
828 if (dbgc_config
== debug_class_list_initial
) {
829 /* Initial loading... */
830 new_class_list
= NULL
;
832 new_class_list
= dbgc_config
;
835 default_level
= dbgc_config
[DBGC_ALL
].loglevel
;
837 new_class_list
= talloc_realloc(NULL
,
841 if (new_class_list
== NULL
) {
845 dbgc_config
= new_class_list
;
847 dbgc_config
[ndx
] = (struct debug_class
) {
848 .loglevel
= default_level
,
852 new_name_list
= talloc_realloc(NULL
, classname_table
, char *, ndx
+ 1);
853 if (new_name_list
== NULL
) {
856 classname_table
= new_name_list
;
858 classname_table
[ndx
] = talloc_strdup(classname_table
, classname
);
859 if (classname_table
[ndx
] == NULL
) {
863 debug_num_classes
= ndx
+ 1;
868 /****************************************************************************
869 Utility to translate names to debug class index's (public version).
870 ****************************************************************************/
872 static int debug_lookup_classname(const char *classname
)
876 if (classname
== NULL
|| !*classname
)
879 ndx
= debug_lookup_classname_int(classname
);
884 DBG_WARNING("Unknown classname[%s] -> adding it...\n", classname
);
885 return debug_add_class(classname
);
888 /****************************************************************************
889 Dump the current registered debug levels.
890 ****************************************************************************/
892 static void debug_dump_status(int level
)
896 DEBUG(level
, ("INFO: Current debug levels:\n"));
897 for (q
= 0; q
< debug_num_classes
; q
++) {
898 const char *classname
= classname_table
[q
];
899 DEBUGADD(level
, (" %s: %d\n",
901 dbgc_config
[q
].loglevel
));
905 static bool debug_parse_param(char *param
)
908 char *class_file
= NULL
;
910 char *saveptr
= NULL
;
913 class_name
= strtok_r(param
, ":", &saveptr
);
914 if (class_name
== NULL
) {
918 class_level
= strtok_r(NULL
, "@\0", &saveptr
);
919 if (class_level
== NULL
) {
923 class_file
= strtok_r(NULL
, "\0", &saveptr
);
925 ndx
= debug_lookup_classname(class_name
);
930 dbgc_config
[ndx
].loglevel
= atoi(class_level
);
932 if (class_file
== NULL
) {
936 TALLOC_FREE(dbgc_config
[ndx
].logfile
);
938 dbgc_config
[ndx
].logfile
= talloc_strdup(NULL
, class_file
);
939 if (dbgc_config
[ndx
].logfile
== NULL
) {
945 /****************************************************************************
946 Parse the debug levels from smb.conf. Example debug level string:
947 3 tdb:5 printdrivers:7
948 Note: the 1st param has no "name:" preceding it.
949 ****************************************************************************/
951 bool debug_parse_levels(const char *params_str
)
953 size_t str_len
= strlen(params_str
);
961 memcpy(str
, params_str
, str_len
+1);
963 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
968 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
969 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
971 if (isdigit(tok
[0])) {
972 dbgc_config
[DBGC_ALL
].loglevel
= atoi(tok
);
973 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
975 dbgc_config
[DBGC_ALL
].loglevel
= 0;
978 /* Array is debug_num_classes long */
979 for (i
= DBGC_ALL
+1; i
< debug_num_classes
; i
++) {
980 dbgc_config
[i
].loglevel
= dbgc_config
[DBGC_ALL
].loglevel
;
981 TALLOC_FREE(dbgc_config
[i
].logfile
);
984 while (tok
!= NULL
) {
987 ok
= debug_parse_param(tok
);
989 DEBUG(0,("debug_parse_params: unrecognized debug "
990 "class name or format [%s]\n", tok
));
994 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
997 debug_dump_status(5);
1002 /* setup for logging of talloc warnings */
1003 static void talloc_log_fn(const char *msg
)
1005 DEBUG(0,("%s", msg
));
1008 void debug_setup_talloc_log(void)
1010 talloc_set_log_fn(talloc_log_fn
);
1014 /****************************************************************************
1015 Init debugging (one time stuff)
1016 ****************************************************************************/
1018 static void debug_init(void)
1022 if (state
.initialized
)
1025 state
.initialized
= true;
1027 debug_setup_talloc_log();
1029 for (i
= 0; i
< ARRAY_SIZE(default_classname_table
); i
++) {
1030 debug_add_class(default_classname_table
[i
]);
1032 dbgc_config
[DBGC_ALL
].fd
= 2;
1034 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
1035 debug_backends
[i
].log_level
= -1;
1036 debug_backends
[i
].new_log_level
= -1;
1040 void debug_set_settings(struct debug_settings
*settings
,
1041 const char *logging_param
,
1042 int syslog_level
, bool syslog_only
)
1044 char fake_param
[256];
1048 * This forces in some smb.conf derived values into the debug
1049 * system. There are no pointers in this structure, so we can
1050 * just structure-assign it in
1052 state
.settings
= *settings
;
1055 * If 'logging' is not set, create backend settings from
1056 * deprecated 'syslog' and 'syslog only' parameters
1058 if (logging_param
!= NULL
) {
1059 len
= strlen(logging_param
);
1063 snprintf(fake_param
, sizeof(fake_param
),
1064 "syslog@%d", syslog_level
- 1);
1066 snprintf(fake_param
, sizeof(fake_param
),
1067 "syslog@%d file@%d", syslog_level
-1,
1071 logging_param
= fake_param
;
1074 debug_set_backends(logging_param
);
1077 static void ensure_hostname(void)
1081 if (state
.hostname
[0] != '\0') {
1085 ret
= gethostname(state
.hostname
, sizeof(state
.hostname
));
1087 strlcpy(state
.hostname
, "unknown", sizeof(state
.hostname
));
1092 * Ensure NUL termination, since POSIX isn't clear about that.
1094 * Don't worry about truncating at the first '.' or similar,
1095 * since this is usually not fully qualified. Trying to
1096 * truncate opens up the multibyte character gates of hell.
1098 state
.hostname
[sizeof(state
.hostname
) - 1] = '\0';
1101 void debug_set_hostname(const char *name
)
1103 strlcpy(state
.hostname
, name
, sizeof(state
.hostname
));
1107 control the name of the logfile and whether logging will be to stdout, stderr
1108 or a file, and set up syslog
1110 new_log indicates the destination for the debug log (an enum in
1111 order of precedence - once set to DEBUG_FILE, it is not possible to
1112 reset to DEBUG_STDOUT for example. This makes it easy to override
1113 for debug to stderr on the command line, as the smb.conf cannot
1114 reset it back to file-based logging
1116 void setup_logging(const char *prog_name
, enum debug_logtype new_logtype
)
1119 if (state
.logtype
< new_logtype
) {
1120 state
.logtype
= new_logtype
;
1123 const char *p
= strrchr(prog_name
, '/');
1129 strlcpy(state
.prog_name
, prog_name
, sizeof(state
.prog_name
));
1131 reopen_logs_internal();
1134 /***************************************************************************
1135 Set the logfile name.
1136 **************************************************************************/
1138 void debug_set_logfile(const char *name
)
1140 if (name
== NULL
|| *name
== 0) {
1141 /* this copes with calls when smb.conf is not loaded yet */
1144 TALLOC_FREE(dbgc_config
[DBGC_ALL
].logfile
);
1145 dbgc_config
[DBGC_ALL
].logfile
= talloc_strdup(NULL
, name
);
1147 reopen_logs_internal();
1150 static void debug_close_fd(int fd
)
1157 enum debug_logtype
debug_get_log_type(void)
1159 return state
.logtype
;
1162 bool debug_get_output_is_stderr(void)
1164 return (state
.logtype
== DEBUG_DEFAULT_STDERR
) || (state
.logtype
== DEBUG_STDERR
);
1167 bool debug_get_output_is_stdout(void)
1169 return (state
.logtype
== DEBUG_DEFAULT_STDOUT
) || (state
.logtype
== DEBUG_STDOUT
);
1172 void debug_set_callback(void *private_ptr
, debug_callback_fn fn
)
1176 state
.logtype
= DEBUG_CALLBACK
;
1177 state
.callback_private
= private_ptr
;
1178 state
.callback
= fn
;
1180 state
.logtype
= DEBUG_DEFAULT_STDERR
;
1181 state
.callback_private
= NULL
;
1182 state
.callback
= NULL
;
1186 static void debug_callback_log(const char *msg
, size_t msg_len
, int msg_level
)
1188 char msg_copy
[msg_len
];
1190 if ((msg_len
> 0) && (msg
[msg_len
-1] == '\n')) {
1191 memcpy(msg_copy
, msg
, msg_len
-1);
1192 msg_copy
[msg_len
-1] = '\0';
1196 state
.callback(state
.callback_private
, msg_level
, msg
);
1199 /**************************************************************************
1200 reopen the log files
1201 note that we now do this unconditionally
1202 We attempt to open the new debug fp before closing the old. This means
1203 if we run out of fd's we just keep using the old fd rather than aborting.
1204 Fix from dgibson@linuxcare.com.
1205 **************************************************************************/
1207 static bool reopen_one_log(struct debug_class
*config
)
1209 int old_fd
= config
->fd
;
1210 const char *logfile
= config
->logfile
;
1215 if (logfile
== NULL
) {
1216 debug_close_fd(old_fd
);
1221 new_fd
= open(logfile
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
1223 log_overflow
= true;
1224 DBG_ERR("Unable to open new log file '%s': %s\n",
1225 logfile
, strerror(errno
));
1226 log_overflow
= false;
1230 debug_close_fd(old_fd
);
1231 smb_set_close_on_exec(new_fd
);
1232 config
->fd
= new_fd
;
1234 ret
= fstat(new_fd
, &st
);
1236 log_overflow
= true;
1237 DBG_ERR("Unable to fstat() new log file '%s': %s\n",
1238 logfile
, strerror(errno
));
1239 log_overflow
= false;
1243 config
->ino
= st
.st_ino
;
1248 reopen the log file (usually called because the log file name might have changed)
1250 bool reopen_logs_internal(void)
1252 struct debug_backend
*b
= NULL
;
1257 if (state
.reopening_logs
) {
1261 /* Now clear the SIGHUP induced flag */
1262 state
.schedule_reopen_logs
= false;
1264 switch (state
.logtype
) {
1265 case DEBUG_CALLBACK
:
1268 case DEBUG_DEFAULT_STDOUT
:
1269 debug_close_fd(dbgc_config
[DBGC_ALL
].fd
);
1270 dbgc_config
[DBGC_ALL
].fd
= 1;
1273 case DEBUG_DEFAULT_STDERR
:
1275 debug_close_fd(dbgc_config
[DBGC_ALL
].fd
);
1276 dbgc_config
[DBGC_ALL
].fd
= 2;
1280 b
= debug_find_backend("file");
1283 b
->log_level
= MAX_DEBUG_LEVEL
;
1287 oldumask
= umask( 022 );
1289 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1290 if (dbgc_config
[i
].logfile
!= NULL
) {
1294 if (i
== debug_num_classes
) {
1298 state
.reopening_logs
= true;
1300 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1301 ok
= reopen_one_log(&dbgc_config
[i
]);
1307 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1308 * to fix problem where smbd's that generate less
1309 * than 100 messages keep growing the log.
1311 force_check_log_size();
1312 (void)umask(oldumask
);
1315 * If log file was opened or created successfully, take over stderr to
1316 * catch output into logs.
1318 if (!state
.settings
.debug_no_stderr_redirect
&&
1319 dbgc_config
[DBGC_ALL
].fd
> 0) {
1320 if (dup2(dbgc_config
[DBGC_ALL
].fd
, 2) == -1) {
1321 /* Close stderr too, if dup2 can't point it -
1322 at the logfile. There really isn't much
1323 that can be done on such a fundamental
1329 state
.reopening_logs
= false;
1334 /**************************************************************************
1335 Force a check of the log size.
1336 ***************************************************************************/
1338 void force_check_log_size( void )
1343 _PUBLIC_
void debug_schedule_reopen_logs(void)
1345 state
.schedule_reopen_logs
= true;
1349 /***************************************************************************
1350 Check to see if there is any need to check if the logfile has grown too big.
1351 **************************************************************************/
1353 bool need_to_check_log_size(void)
1358 if (debug_count
< 100) {
1362 maxlog
= state
.settings
.max_log_size
* 1024;
1368 if (dbgc_config
[DBGC_ALL
].fd
> 2) {
1372 for (i
= DBGC_ALL
+ 1; i
< debug_num_classes
; i
++) {
1373 if (dbgc_config
[i
].fd
!= -1) {
1382 /**************************************************************************
1383 Check to see if the log has grown to be too big.
1384 **************************************************************************/
1386 static void do_one_check_log_size(off_t maxlog
, struct debug_class
*config
)
1388 char name
[strlen(config
->logfile
) + 5];
1391 bool reopen
= false;
1398 ret
= stat(config
->logfile
, &st
);
1402 if (st
.st_size
>= maxlog
) {
1406 if (st
.st_ino
!= config
->ino
) {
1414 /* reopen_logs_internal() modifies *_fd */
1415 (void)reopen_logs_internal();
1417 if (config
->fd
<= 2) {
1420 ret
= fstat(config
->fd
, &st
);
1422 config
->ino
= (ino_t
)0;
1426 config
->ino
= st
.st_ino
;
1428 if (st
.st_size
< maxlog
) {
1432 snprintf(name
, sizeof(name
), "%s.old", config
->logfile
);
1434 (void)rename(config
->logfile
, name
);
1436 ok
= reopen_logs_internal();
1440 /* We failed to reopen a log - continue using the old name. */
1441 (void)rename(name
, config
->logfile
);
1444 static void do_check_log_size(off_t maxlog
)
1448 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1449 if (dbgc_config
[i
].fd
== -1) {
1452 if (dbgc_config
[i
].logfile
== NULL
) {
1455 do_one_check_log_size(maxlog
, &dbgc_config
[i
]);
1459 void check_log_size( void )
1464 * We need to be root to check/change log-file, skip this and let the main
1465 * loop check do a new check as root.
1468 #if _SAMBA_BUILD_ == 3
1469 if (geteuid() != sec_initial_uid())
1474 /* We don't check sec_initial_uid() here as it isn't
1475 * available in common code and we don't generally
1476 * want to rotate and the possibly lose logs in
1477 * make test or the build farm */
1481 if(log_overflow
|| (!state
.schedule_reopen_logs
&& !need_to_check_log_size())) {
1485 maxlog
= state
.settings
.max_log_size
* 1024;
1487 if (state
.schedule_reopen_logs
) {
1488 (void)reopen_logs_internal();
1491 do_check_log_size(maxlog
);
1494 * Here's where we need to panic if dbgc_config[DBGC_ALL].fd == 0 or -1
1498 if (dbgc_config
[DBGC_ALL
].fd
<= 0) {
1499 /* This code should only be reached in very strange
1500 * circumstances. If we merely fail to open the new log we
1501 * should stick with the old one. ergo this should only be
1502 * reached when opening the logs for the first time: at
1503 * startup or when the log level is increased from zero.
1506 int fd
= open( "/dev/console", O_WRONLY
, 0);
1508 smb_set_close_on_exec(fd
);
1509 dbgc_config
[DBGC_ALL
].fd
= fd
;
1510 DBG_ERR("check_log_size: open of debug file %s failed "
1511 "- using console.\n",
1512 dbgc_config
[DBGC_ALL
].logfile
);
1515 * We cannot continue without a debug file handle.
1523 /*************************************************************************
1524 Write an debug message on the debugfile.
1525 This is called by format_debug_text().
1526 ************************************************************************/
1528 static void Debug1(const char *msg
, size_t msg_len
)
1530 int old_errno
= errno
;
1534 switch(state
.logtype
) {
1535 case DEBUG_CALLBACK
:
1536 debug_callback_log(msg
, msg_len
, current_msg_level
);
1540 case DEBUG_DEFAULT_STDOUT
:
1541 case DEBUG_DEFAULT_STDERR
:
1542 if (dbgc_config
[DBGC_ALL
].fd
> 0) {
1545 ret
= write(dbgc_config
[DBGC_ALL
].fd
,
1548 } while (ret
== -1 && errno
== EINTR
);
1552 debug_backends_log(msg
, msg_len
, current_msg_level
);
1559 /**************************************************************************
1560 Print the buffer content via Debug1(), then reset the buffer.
1563 ****************************************************************************/
1565 static void bufr_print( void )
1567 format_bufr
[format_pos
] = '\0';
1568 (void)Debug1(format_bufr
, format_pos
);
1572 /***************************************************************************
1573 Format the debug message text.
1575 Input: msg - Text to be added to the "current" debug message text.
1579 Notes: The purpose of this is two-fold. First, each call to syslog()
1580 (used by Debug1(), see above) generates a new line of syslog
1581 output. This is fixed by storing the partial lines until the
1582 newline character is encountered. Second, printing the debug
1583 message lines when a newline is encountered allows us to add
1584 spaces, thus indenting the body of the message and making it
1586 **************************************************************************/
1588 static void format_debug_text( const char *msg
)
1591 bool timestamp
= (state
.logtype
== DEBUG_FILE
&& (state
.settings
.timestamp_logs
));
1595 for( i
= 0; msg
[i
]; i
++ ) {
1596 /* Indent two spaces at each new line. */
1597 if(timestamp
&& 0 == format_pos
) {
1598 format_bufr
[0] = format_bufr
[1] = ' ';
1602 /* If there's room, copy the character to the format buffer. */
1603 if (format_pos
< FORMAT_BUFR_SIZE
- 1)
1604 format_bufr
[format_pos
++] = msg
[i
];
1606 /* If a newline is encountered, print & restart. */
1607 if( '\n' == msg
[i
] )
1610 /* If the buffer is full dump it out, reset it, and put out a line
1611 * continuation indicator.
1613 if (format_pos
>= FORMAT_BUFR_SIZE
- 1) {
1614 const char cont
[] = " +>\n";
1616 (void)Debug1(cont
, sizeof(cont
) - 1);
1620 /* Just to be safe... */
1621 format_bufr
[format_pos
] = '\0';
1624 /***************************************************************************
1625 Flush debug output, including the format buffer content.
1629 ***************************************************************************/
1631 void dbgflush( void )
1636 bool dbgsetclass(int level
, int cls
)
1638 /* Set current_msg_level. */
1639 current_msg_level
= level
;
1641 /* Set current message class */
1642 current_msg_class
= cls
;
1647 /***************************************************************************
1648 Put a Debug Header into header_str.
1650 Input: level - Debug level of the message (not the system-wide debug
1652 cls - Debuglevel class of the calling module.
1653 location - Pointer to a string containing the name of the file
1654 from which this function was called, or an empty string
1655 if the __FILE__ macro is not implemented.
1656 func - Pointer to a string containing the name of the function
1657 from which this function was called, or an empty string
1658 if the __FUNCTION__ macro is not implemented.
1660 Output: Always true. This makes it easy to fudge a call to dbghdr()
1661 in a macro, since the function can be called as part of a test.
1662 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1664 Notes: This function takes care of setting current_msg_level.
1666 ****************************************************************************/
1668 bool dbghdrclass(int level
, int cls
, const char *location
, const char *func
)
1670 /* Ensure we don't lose any real errno value. */
1671 int old_errno
= errno
;
1672 bool verbose
= false;
1674 struct timeval_buf tvbuf
;
1677 * This might be overkill, but if another early return is
1678 * added later then initialising these avoids potential
1682 state
.header_str
[0] = '\0';
1685 /* This is a fudge. If there is stuff sitting in the format_bufr, then
1686 * the *right* thing to do is to call
1687 * format_debug_text( "\n" );
1688 * to write the remainder, and then proceed with the new header.
1689 * Unfortunately, there are several places in the code at which
1690 * the DEBUG() macro is used to build partial lines. That in mind,
1691 * we'll work under the assumption that an incomplete line indicates
1692 * that a new header is *not* desired.
1697 dbgsetclass(level
, cls
);
1699 /* Don't print a header if we're logging to stdout. */
1700 if ( state
.logtype
!= DEBUG_FILE
) {
1704 /* Print the header if timestamps are turned on. If parameters are
1705 * not yet loaded, then default to timestamps on.
1707 if (!(state
.settings
.timestamp_logs
||
1708 state
.settings
.debug_prefix_timestamp
||
1709 state
.settings
.debug_syslog_format
)) {
1715 if (state
.settings
.debug_syslog_format
) {
1716 if (state
.settings
.debug_hires_timestamp
) {
1717 timeval_str_buf(&tv
, true, true, &tvbuf
);
1722 t
= (time_t)tv
.tv_sec
;
1726 len
= strftime(tvbuf
.buf
,
1731 /* Trigger default time format below */
1738 "%ld seconds since the Epoch", (long)t
);
1743 state
.hs_len
= snprintf(state
.header_str
,
1744 sizeof(state
.header_str
),
1749 (unsigned int) getpid());
1754 timeval_str_buf(&tv
, false, state
.settings
.debug_hires_timestamp
,
1757 state
.hs_len
= snprintf(state
.header_str
,
1758 sizeof(state
.header_str
),
1762 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1766 if (unlikely(dbgc_config
[cls
].loglevel
>= 10)) {
1770 if (verbose
|| state
.settings
.debug_pid
) {
1771 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1772 sizeof(state
.header_str
) - state
.hs_len
,
1774 (unsigned int)getpid());
1775 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1780 if (verbose
|| state
.settings
.debug_uid
) {
1781 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1782 sizeof(state
.header_str
) - state
.hs_len
,
1783 ", effective(%u, %u), real(%u, %u)",
1784 (unsigned int)geteuid(),
1785 (unsigned int)getegid(),
1786 (unsigned int)getuid(),
1787 (unsigned int)getgid());
1788 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1793 if ((verbose
|| state
.settings
.debug_class
)
1794 && (cls
!= DBGC_ALL
)) {
1795 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1796 sizeof(state
.header_str
) - state
.hs_len
,
1798 classname_table
[cls
]);
1801 if (state
.hs_len
>= sizeof(state
.header_str
) - 1) {
1804 state
.header_str
[state
.hs_len
] = ']';
1806 if (state
.hs_len
< sizeof(state
.header_str
) - 1) {
1807 state
.header_str
[state
.hs_len
] = ' ';
1810 state
.header_str
[state
.hs_len
] = '\0';
1812 if (!state
.settings
.debug_prefix_timestamp
) {
1813 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1814 sizeof(state
.header_str
) - state
.hs_len
,
1818 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1825 * Above code never overflows state.header_str and always
1826 * NUL-terminates correctly. However, state.hs_len can point
1827 * past the end of the buffer to indicate that truncation
1828 * occurred, so fix it if necessary, since state.hs_len is
1829 * expected to be used after return.
1831 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1832 state
.hs_len
= sizeof(state
.header_str
) - 1;
1835 state
.header_str_no_nl
[0] = '\0';
1841 /***************************************************************************
1842 Add text to the body of the "current" debug message via the format buffer.
1844 Input: format_str - Format string, as used in printf(), et. al.
1845 ... - Variable argument list.
1847 ..or.. va_alist - Old style variable parameter list starting point.
1849 Output: Always true. See dbghdr() for more info, though this is not
1850 likely to be used in the same way.
1852 ***************************************************************************/
1854 static inline bool __dbgtext_va(const char *format_str
, va_list ap
) PRINTF_ATTRIBUTE(1,0);
1855 static inline bool __dbgtext_va(const char *format_str
, va_list ap
)
1857 char *msgbuf
= NULL
;
1861 res
= vasprintf(&msgbuf
, format_str
, ap
);
1863 format_debug_text(msgbuf
);
1871 bool dbgtext_va(const char *format_str
, va_list ap
)
1873 return __dbgtext_va(format_str
, ap
);
1876 bool dbgtext(const char *format_str
, ... )
1881 va_start(ap
, format_str
);
1882 ret
= __dbgtext_va(format_str
, ap
);