s3/lib/ctdbd_conn: assert hdr following read/recv
[Samba.git] / lib / util / debug.c
blob6f081d45110423ba8e52ebc5e38a444745bf423a
1 /*
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/>.
22 #include "replace.h"
23 #include <talloc.h>
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"
29 #include "memory.h"
30 #include "util_strlist.h" /* LIST_SEP */
31 #include "blocking.h"
32 #include "debug.h"
34 /* define what facility to use for syslog */
35 #ifndef SYSLOG_FACILITY
36 #define SYSLOG_FACILITY LOG_DAEMON
37 #endif
39 /* -------------------------------------------------------------------------- **
40 * Defines...
44 * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
45 * for a terminating null byte.
47 #define FORMAT_BUFR_SIZE 4096
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
83 * a newline.
86 /* state variables for the debug system */
87 static struct {
88 bool initialized;
89 enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
90 char prog_name[255];
91 bool reopening_logs;
92 bool schedule_reopen_logs;
94 struct debug_settings settings;
95 debug_callback_fn callback;
96 void *callback_private;
97 } state = {
98 .settings = {
99 .timestamp_logs = true
103 struct debug_class {
105 * The debug loglevel of the class.
107 int loglevel;
110 * An optional class specific logfile, may be NULL in which case the
111 * "global" logfile is used and fd is -1.
113 char *logfile;
114 int fd;
117 static const char *default_classname_table[] = {
118 [DBGC_ALL] = "all",
119 [DBGC_TDB] = "tdb",
120 [DBGC_PRINTDRIVERS] = "printdrivers",
121 [DBGC_LANMAN] = "lanman",
122 [DBGC_SMB] = "smb",
123 [DBGC_RPC_PARSE] = "rpc_parse",
124 [DBGC_RPC_SRV] = "rpc_srv",
125 [DBGC_RPC_CLI] = "rpc_cli",
126 [DBGC_PASSDB] = "passdb",
127 [DBGC_SAM] = "sam",
128 [DBGC_AUTH] = "auth",
129 [DBGC_WINBIND] = "winbind",
130 [DBGC_VFS] = "vfs",
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",
139 [DBGC_DNS] = "dns",
140 [DBGC_LDB] = "ldb",
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[] = {
179 LOG_ERR, /* 0 */
180 LOG_WARNING, /* 1 */
181 LOG_NOTICE, /* 2 */
182 LOG_NOTICE, /* 3 */
183 LOG_NOTICE, /* 4 */
184 LOG_NOTICE, /* 5 */
185 LOG_INFO, /* 6 */
186 LOG_INFO, /* 7 */
187 LOG_INFO, /* 8 */
188 LOG_INFO, /* 9 */
190 int priority;
192 if( level >= ARRAY_SIZE(priority_map) || level < 0)
193 priority = LOG_DEBUG;
194 else
195 priority = priority_map[level];
197 return priority;
199 #endif
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)
209 ssize_t ret;
210 int fd;
212 check_log_size();
214 if (dbgc_config[current_msg_class].fd != -1) {
215 fd = dbgc_config[current_msg_class].fd;
216 } else {
217 fd = dbgc_config[DBGC_ALL].fd;
220 do {
221 ret = write(fd, msg, strlen(msg));
222 } while (ret == -1 && errno == EINTR);
225 #ifdef WITH_SYSLOG
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')) {
232 ident = prog_name;
234 #ifdef LOG_DAEMON
235 openlog(ident, LOG_PID, SYSLOG_FACILITY);
236 #else
237 /* for old systems that have no facility codes. */
238 openlog(ident, LOG_PID);
239 #endif
240 return;
243 if (!enabled && previously_enabled) {
244 closelog();
248 static void debug_syslog_log(int msg_level,
249 const char *msg, const char *msg_no_nl)
251 int priority;
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,
273 NULL);
275 #endif
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)
282 tracef(msg_no_nl);
284 #endif /* WITH_LTTNG_TRACEF */
286 #ifdef HAVE_GPFS
287 #include "gpfswrap.h"
288 static void debug_gpfs_reload(bool enabled, bool previously_enabled,
289 const char *prog_name, char *option)
291 gpfswrap_init();
293 if (enabled && !previously_enabled) {
294 gpfswrap_init_trace();
295 return;
298 if (!enabled && previously_enabled) {
299 gpfswrap_fini_trace();
300 return;
303 if (enabled) {
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)
340 bool cmp;
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);
348 if (!enabled) {
349 return;
352 if (option != NULL) {
353 cmp = strncmp(option, DEBUG_RINGBUF_SIZE_OPT, optlen);
354 if (cmp == 0) {
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) {
362 return;
366 static void debug_ringbuf_log(int msg_level,
367 const char *msg,
368 const char *msg_no_nl)
370 size_t msglen = strlen(msg);
371 size_t allowed_size;
373 if (debug_ringbuf == NULL) {
374 return;
377 /* Ensure the buffer is always \0 terminated */
378 allowed_size = debug_ringbuf_size - 1;
380 if (msglen > allowed_size) {
381 return;
384 if ((debug_ringbuf_ofs + msglen) < debug_ringbuf_ofs) {
385 return;
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 {
397 const char *name;
398 int log_level;
399 int new_log_level;
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);
403 char *option;
404 } debug_backends[] = {
406 .name = "file",
407 .log = debug_file_log,
409 #ifdef WITH_SYSLOG
411 .name = "syslog",
412 .reload = debug_syslog_reload,
413 .log = debug_syslog_log,
415 #endif
417 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
419 .name = "systemd",
420 .log = debug_systemd_log,
422 #endif
424 #ifdef HAVE_LTTNG_TRACEF
426 .name = "lttng",
427 .log = debug_lttng_log,
429 #endif
431 #ifdef HAVE_GPFS
433 .name = "gpfs",
434 .reload = debug_gpfs_reload,
435 .log = debug_gpfs_log,
437 #endif
439 .name = "ringbuf",
440 .log = debug_ringbuf_log,
441 .reload = debug_ringbuf_reload,
445 static struct debug_backend *debug_find_backend(const char *name)
447 unsigned i;
449 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
450 if (strcmp(name, debug_backends[i].name) == 0) {
451 return &debug_backends[i];
455 return NULL;
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) {
472 return;
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) {
482 return;
485 backend_option = strtok_r(NULL, "\0", &saveptr);
488 * Find and update backend
490 b = debug_find_backend(backend_name);
491 if (b == NULL) {
492 return;
495 if (backend_level == NULL) {
496 b->new_log_level = MAX_DEBUG_LEVEL;
497 } else {
498 b->new_log_level = atoi(backend_level);
501 if (backend_option != NULL) {
502 b->option = strdup(backend_option);
503 if (b->option == NULL) {
504 return;
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);
516 char str[str_len+1];
517 char *tok, *saveptr;
518 unsigned i;
521 * initialize new_log_level to detect backends that have been
522 * disabled
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);
532 if (tok == NULL) {
533 return;
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];
547 if (b->reload) {
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,
552 b->option);
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];
561 size_t i;
562 size_t len;
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')) {
570 len--;
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 /* -------------------------------------------------------------------------- **
642 * Functions...
645 static void debug_init(void);
647 /***************************************************************************
648 Free memory pointed to by global pointers.
649 ****************************************************************************/
651 void gfree_debugsyms(void)
653 unsigned i;
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)
678 char *buf = NULL;
679 size_t i;
680 /* prepare strings */
681 for (i = 0; i < debug_num_classes; i++) {
682 buf = talloc_asprintf_append(buf,
683 "%s:%d%s",
684 classname_table[i],
685 dbgc_config[i].loglevel,
686 i == (debug_num_classes - 1) ? "\n" : " ");
687 if (buf == NULL) {
688 return NULL;
691 return buf;
694 /****************************************************************************
695 Utility to translate names to debug class index's (internal version).
696 ****************************************************************************/
698 static int debug_lookup_classname_int(const char* classname)
700 size_t i;
702 if (classname == NULL) {
703 return -1;
706 for (i=0; i < debug_num_classes; i++) {
707 char *entry = classname_table[i];
708 if (entry != NULL && strcmp(classname, entry)==0) {
709 return i;
712 return -1;
715 /****************************************************************************
716 Add a new debug class to the system.
717 ****************************************************************************/
719 int debug_add_class(const char *classname)
721 int ndx;
722 struct debug_class *new_class_list = NULL;
723 char **new_name_list;
724 int default_level;
726 if (classname == NULL) {
727 return -1;
730 /* check the init has yet been called */
731 debug_init();
733 ndx = debug_lookup_classname_int(classname);
734 if (ndx >= 0) {
735 return ndx;
737 ndx = debug_num_classes;
739 if (dbgc_config == debug_class_list_initial) {
740 /* Initial loading... */
741 new_class_list = NULL;
742 } else {
743 new_class_list = dbgc_config;
746 default_level = dbgc_config[DBGC_ALL].loglevel;
748 new_class_list = talloc_realloc(NULL,
749 new_class_list,
750 struct debug_class,
751 ndx + 1);
752 if (new_class_list == NULL) {
753 return -1;
756 dbgc_config = new_class_list;
758 dbgc_config[ndx] = (struct debug_class) {
759 .loglevel = default_level,
760 .fd = -1,
763 new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
764 if (new_name_list == NULL) {
765 return -1;
767 classname_table = new_name_list;
769 classname_table[ndx] = talloc_strdup(classname_table, classname);
770 if (classname_table[ndx] == NULL) {
771 return -1;
774 debug_num_classes = ndx + 1;
776 return ndx;
779 /****************************************************************************
780 Utility to translate names to debug class index's (public version).
781 ****************************************************************************/
783 static int debug_lookup_classname(const char *classname)
785 int ndx;
787 if (classname == NULL || !*classname)
788 return -1;
790 ndx = debug_lookup_classname_int(classname);
792 if (ndx != -1)
793 return ndx;
795 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
796 classname));
797 return debug_add_class(classname);
800 /****************************************************************************
801 Dump the current registered debug levels.
802 ****************************************************************************/
804 static void debug_dump_status(int level)
806 size_t q;
808 DEBUG(level, ("INFO: Current debug levels:\n"));
809 for (q = 0; q < debug_num_classes; q++) {
810 const char *classname = classname_table[q];
811 DEBUGADD(level, (" %s: %d\n",
812 classname,
813 dbgc_config[q].loglevel));
817 static bool debug_parse_param(char *param)
819 char *class_name;
820 char *class_file = NULL;
821 char *class_level;
822 char *saveptr = NULL;
823 int ndx;
825 class_name = strtok_r(param, ":", &saveptr);
826 if (class_name == NULL) {
827 return false;
830 class_level = strtok_r(NULL, "@\0", &saveptr);
831 if (class_level == NULL) {
832 return false;
835 class_file = strtok_r(NULL, "\0", &saveptr);
837 ndx = debug_lookup_classname(class_name);
838 if (ndx == -1) {
839 return false;
842 dbgc_config[ndx].loglevel = atoi(class_level);
844 if (class_file == NULL) {
845 return true;
848 TALLOC_FREE(dbgc_config[ndx].logfile);
850 dbgc_config[ndx].logfile = talloc_strdup(NULL, class_file);
851 if (dbgc_config[ndx].logfile == NULL) {
852 return false;
854 return true;
857 /****************************************************************************
858 Parse the debug levels from smb.conf. Example debug level string:
859 3 tdb:5 printdrivers:7
860 Note: the 1st param has no "name:" preceding it.
861 ****************************************************************************/
863 bool debug_parse_levels(const char *params_str)
865 size_t str_len = strlen(params_str);
866 char str[str_len+1];
867 char *tok, *saveptr;
868 size_t i;
870 /* Just in case */
871 debug_init();
873 memcpy(str, params_str, str_len+1);
875 tok = strtok_r(str, LIST_SEP, &saveptr);
876 if (tok == NULL) {
877 return true;
880 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
881 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
883 if (isdigit(tok[0])) {
884 dbgc_config[DBGC_ALL].loglevel = atoi(tok);
885 tok = strtok_r(NULL, LIST_SEP, &saveptr);
886 } else {
887 dbgc_config[DBGC_ALL].loglevel = 0;
890 /* Array is debug_num_classes long */
891 for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
892 dbgc_config[i].loglevel = dbgc_config[DBGC_ALL].loglevel;
893 TALLOC_FREE(dbgc_config[i].logfile);
896 while (tok != NULL) {
897 bool ok;
899 ok = debug_parse_param(tok);
900 if (!ok) {
901 DEBUG(0,("debug_parse_params: unrecognized debug "
902 "class name or format [%s]\n", tok));
903 return false;
906 tok = strtok_r(NULL, LIST_SEP, &saveptr);
909 debug_dump_status(5);
911 return true;
914 /* setup for logging of talloc warnings */
915 static void talloc_log_fn(const char *msg)
917 DEBUG(0,("%s", msg));
920 void debug_setup_talloc_log(void)
922 talloc_set_log_fn(talloc_log_fn);
926 /****************************************************************************
927 Init debugging (one time stuff)
928 ****************************************************************************/
930 static void debug_init(void)
932 size_t i;
934 if (state.initialized)
935 return;
937 state.initialized = true;
939 debug_setup_talloc_log();
941 for (i = 0; i < ARRAY_SIZE(default_classname_table); i++) {
942 debug_add_class(default_classname_table[i]);
944 dbgc_config[DBGC_ALL].fd = 2;
946 for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
947 debug_backends[i].log_level = -1;
948 debug_backends[i].new_log_level = -1;
952 void debug_set_settings(struct debug_settings *settings,
953 const char *logging_param,
954 int syslog_level, bool syslog_only)
956 char fake_param[256];
957 size_t len = 0;
960 * This forces in some smb.conf derived values into the debug
961 * system. There are no pointers in this structure, so we can
962 * just structure-assign it in
964 state.settings = *settings;
967 * If 'logging' is not set, create backend settings from
968 * deprecated 'syslog' and 'syslog only' parameters
970 if (logging_param != NULL) {
971 len = strlen(logging_param);
973 if (len == 0) {
974 if (syslog_only) {
975 snprintf(fake_param, sizeof(fake_param),
976 "syslog@%d", syslog_level - 1);
977 } else {
978 snprintf(fake_param, sizeof(fake_param),
979 "syslog@%d file@%d", syslog_level -1,
980 MAX_DEBUG_LEVEL);
983 logging_param = fake_param;
986 debug_set_backends(logging_param);
990 control the name of the logfile and whether logging will be to stdout, stderr
991 or a file, and set up syslog
993 new_log indicates the destination for the debug log (an enum in
994 order of precedence - once set to DEBUG_FILE, it is not possible to
995 reset to DEBUG_STDOUT for example. This makes it easy to override
996 for debug to stderr on the command line, as the smb.conf cannot
997 reset it back to file-based logging
999 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
1001 debug_init();
1002 if (state.logtype < new_logtype) {
1003 state.logtype = new_logtype;
1005 if (prog_name) {
1006 const char *p = strrchr(prog_name, '/');
1008 if (p) {
1009 prog_name = p + 1;
1012 strlcpy(state.prog_name, prog_name, sizeof(state.prog_name));
1014 reopen_logs_internal();
1017 /***************************************************************************
1018 Set the logfile name.
1019 **************************************************************************/
1021 void debug_set_logfile(const char *name)
1023 if (name == NULL || *name == 0) {
1024 /* this copes with calls when smb.conf is not loaded yet */
1025 return;
1027 TALLOC_FREE(dbgc_config[DBGC_ALL].logfile);
1028 dbgc_config[DBGC_ALL].logfile = talloc_strdup(NULL, name);
1031 static void debug_close_fd(int fd)
1033 if (fd > 2) {
1034 close(fd);
1038 bool debug_get_output_is_stderr(void)
1040 return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
1043 bool debug_get_output_is_stdout(void)
1045 return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
1048 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
1050 debug_init();
1051 if (fn) {
1052 state.logtype = DEBUG_CALLBACK;
1053 state.callback_private = private_ptr;
1054 state.callback = fn;
1055 } else {
1056 state.logtype = DEBUG_DEFAULT_STDERR;
1057 state.callback_private = NULL;
1058 state.callback = NULL;
1062 static void debug_callback_log(const char *msg, int msg_level)
1064 size_t msg_len = strlen(msg);
1065 char msg_copy[msg_len];
1067 if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
1068 memcpy(msg_copy, msg, msg_len-1);
1069 msg_copy[msg_len-1] = '\0';
1070 msg = msg_copy;
1073 state.callback(state.callback_private, msg_level, msg);
1076 /**************************************************************************
1077 reopen the log files
1078 note that we now do this unconditionally
1079 We attempt to open the new debug fp before closing the old. This means
1080 if we run out of fd's we just keep using the old fd rather than aborting.
1081 Fix from dgibson@linuxcare.com.
1082 **************************************************************************/
1084 static bool reopen_one_log(int *fd, const char *logfile)
1086 int old_fd = *fd;
1087 int new_fd;
1089 if (logfile == NULL) {
1090 debug_close_fd(old_fd);
1091 *fd = -1;
1092 return true;
1095 new_fd = open(logfile, O_WRONLY|O_APPEND|O_CREAT, 0644);
1096 if (new_fd == -1) {
1097 log_overflow = true;
1098 DBG_ERR("Unable to open new log file '%s': %s\n",
1099 logfile, strerror(errno));
1100 log_overflow = false;
1101 return false;
1104 debug_close_fd(old_fd);
1105 smb_set_close_on_exec(new_fd);
1106 *fd = new_fd;
1108 return true;
1112 reopen the log file (usually called because the log file name might have changed)
1114 bool reopen_logs_internal(void)
1116 mode_t oldumask;
1117 int new_fd = 0;
1118 size_t i;
1119 bool ok;
1121 if (state.reopening_logs) {
1122 return true;
1125 /* Now clear the SIGHUP induced flag */
1126 state.schedule_reopen_logs = false;
1128 switch (state.logtype) {
1129 case DEBUG_CALLBACK:
1130 return true;
1131 case DEBUG_STDOUT:
1132 case DEBUG_DEFAULT_STDOUT:
1133 debug_close_fd(dbgc_config[DBGC_ALL].fd);
1134 dbgc_config[DBGC_ALL].fd = 1;
1135 return true;
1137 case DEBUG_DEFAULT_STDERR:
1138 case DEBUG_STDERR:
1139 debug_close_fd(dbgc_config[DBGC_ALL].fd);
1140 dbgc_config[DBGC_ALL].fd = 2;
1141 return true;
1143 case DEBUG_FILE:
1144 break;
1147 oldumask = umask( 022 );
1149 for (i = DBGC_ALL; i < debug_num_classes; i++) {
1150 if (dbgc_config[DBGC_ALL].logfile != NULL) {
1151 break;
1154 if (i == debug_num_classes) {
1155 return false;
1158 state.reopening_logs = true;
1160 for (i = DBGC_ALL; i < debug_num_classes; i++) {
1161 ok = reopen_one_log(&dbgc_config[i].fd,
1162 dbgc_config[i].logfile);
1163 if (!ok) {
1164 break;
1168 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1169 * to fix problem where smbd's that generate less
1170 * than 100 messages keep growing the log.
1172 force_check_log_size();
1173 (void)umask(oldumask);
1176 * If log file was opened or created successfully, take over stderr to
1177 * catch output into logs.
1179 if (new_fd != -1) {
1180 if (dup2(dbgc_config[DBGC_ALL].fd, 2) == -1) {
1181 /* Close stderr too, if dup2 can't point it -
1182 at the logfile. There really isn't much
1183 that can be done on such a fundamental
1184 failure... */
1185 close_low_fd(2);
1189 state.reopening_logs = false;
1191 return ok;
1194 /**************************************************************************
1195 Force a check of the log size.
1196 ***************************************************************************/
1198 void force_check_log_size( void )
1200 debug_count = 100;
1203 _PUBLIC_ void debug_schedule_reopen_logs(void)
1205 state.schedule_reopen_logs = true;
1209 /***************************************************************************
1210 Check to see if there is any need to check if the logfile has grown too big.
1211 **************************************************************************/
1213 bool need_to_check_log_size(void)
1215 int maxlog;
1216 size_t i;
1218 if (debug_count < 100) {
1219 return false;
1222 maxlog = state.settings.max_log_size * 1024;
1223 if (maxlog <= 0) {
1224 debug_count = 0;
1225 return false;
1228 if (dbgc_config[DBGC_ALL].fd > 2) {
1229 return true;
1232 for (i = DBGC_ALL + 1; i < debug_num_classes; i++) {
1233 if (dbgc_config[i].fd != -1) {
1234 return true;
1238 debug_count = 0;
1239 return false;
1242 /**************************************************************************
1243 Check to see if the log has grown to be too big.
1244 **************************************************************************/
1246 static void do_one_check_log_size(off_t maxlog, int *_fd, const char *logfile)
1248 char name[strlen(logfile) + 5];
1249 struct stat st;
1250 int fd = *_fd;
1251 int ret;
1252 bool ok;
1254 if (maxlog == 0) {
1255 return;
1258 ret = fstat(fd, &st);
1259 if (ret != 0) {
1260 return;
1262 if (st.st_size < maxlog ) {
1263 return;
1266 /* reopen_logs_internal() modifies *_fd */
1267 (void)reopen_logs_internal();
1268 fd = *_fd;
1270 if (fd <= 2) {
1271 return;
1273 ret = fstat(fd, &st);
1274 if (ret != 0) {
1275 return;
1277 if (st.st_size < maxlog) {
1278 return;
1281 snprintf(name, sizeof(name), "%s.old", logfile);
1283 (void)rename(logfile, name);
1285 ok = reopen_logs_internal();
1286 if (ok) {
1287 return;
1289 /* We failed to reopen a log - continue using the old name. */
1290 (void)rename(name, logfile);
1293 static void do_check_log_size(off_t maxlog)
1295 size_t i;
1297 for (i = DBGC_ALL; i < debug_num_classes; i++) {
1298 if (dbgc_config[i].fd == -1) {
1299 continue;
1301 if (dbgc_config[i].logfile == NULL) {
1302 continue;
1304 do_one_check_log_size(maxlog,
1305 &dbgc_config[i].fd,
1306 dbgc_config[i].logfile);
1310 void check_log_size( void )
1312 off_t maxlog;
1315 * We need to be root to check/change log-file, skip this and let the main
1316 * loop check do a new check as root.
1319 #if _SAMBA_BUILD_ == 3
1320 if (geteuid() != sec_initial_uid())
1321 #else
1322 if( geteuid() != 0)
1323 #endif
1325 /* We don't check sec_initial_uid() here as it isn't
1326 * available in common code and we don't generally
1327 * want to rotate and the possibly lose logs in
1328 * make test or the build farm */
1329 return;
1332 if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
1333 return;
1336 maxlog = state.settings.max_log_size * 1024;
1338 if (state.schedule_reopen_logs) {
1339 (void)reopen_logs_internal();
1342 do_check_log_size(maxlog);
1345 * Here's where we need to panic if dbgc_config[DBGC_ALL].fd == 0 or -1
1346 * (invalid values)
1349 if (dbgc_config[DBGC_ALL].fd <= 0) {
1350 /* This code should only be reached in very strange
1351 * circumstances. If we merely fail to open the new log we
1352 * should stick with the old one. ergo this should only be
1353 * reached when opening the logs for the first time: at
1354 * startup or when the log level is increased from zero.
1355 * -dwg 6 June 2000
1357 int fd = open( "/dev/console", O_WRONLY, 0);
1358 if (fd != -1) {
1359 smb_set_close_on_exec(fd);
1360 dbgc_config[DBGC_ALL].fd = fd;
1361 DBG_ERR("check_log_size: open of debug file %s failed "
1362 "- using console.\n",
1363 dbgc_config[DBGC_ALL].logfile);
1364 } else {
1366 * We cannot continue without a debug file handle.
1368 abort();
1371 debug_count = 0;
1374 /*************************************************************************
1375 Write an debug message on the debugfile.
1376 This is called by dbghdr() and format_debug_text().
1377 ************************************************************************/
1379 static void Debug1(const char *msg)
1381 int old_errno = errno;
1383 debug_count++;
1385 switch(state.logtype) {
1386 case DEBUG_CALLBACK:
1387 debug_callback_log(msg, current_msg_level);
1388 break;
1389 case DEBUG_STDOUT:
1390 case DEBUG_STDERR:
1391 case DEBUG_DEFAULT_STDOUT:
1392 case DEBUG_DEFAULT_STDERR:
1393 if (dbgc_config[DBGC_ALL].fd > 0) {
1394 ssize_t ret;
1395 do {
1396 ret = write(dbgc_config[DBGC_ALL].fd,
1397 msg,
1398 strlen(msg));
1399 } while (ret == -1 && errno == EINTR);
1401 break;
1402 case DEBUG_FILE:
1403 debug_backends_log(msg, current_msg_level);
1404 break;
1407 errno = old_errno;
1410 /**************************************************************************
1411 Print the buffer content via Debug1(), then reset the buffer.
1412 Input: none
1413 Output: none
1414 ****************************************************************************/
1416 static void bufr_print( void )
1418 format_bufr[format_pos] = '\0';
1419 (void)Debug1(format_bufr);
1420 format_pos = 0;
1423 /***************************************************************************
1424 Format the debug message text.
1426 Input: msg - Text to be added to the "current" debug message text.
1428 Output: none.
1430 Notes: The purpose of this is two-fold. First, each call to syslog()
1431 (used by Debug1(), see above) generates a new line of syslog
1432 output. This is fixed by storing the partial lines until the
1433 newline character is encountered. Second, printing the debug
1434 message lines when a newline is encountered allows us to add
1435 spaces, thus indenting the body of the message and making it
1436 more readable.
1437 **************************************************************************/
1439 static void format_debug_text( const char *msg )
1441 size_t i;
1442 bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
1444 debug_init();
1446 for( i = 0; msg[i]; i++ ) {
1447 /* Indent two spaces at each new line. */
1448 if(timestamp && 0 == format_pos) {
1449 format_bufr[0] = format_bufr[1] = ' ';
1450 format_pos = 2;
1453 /* If there's room, copy the character to the format buffer. */
1454 if (format_pos < FORMAT_BUFR_SIZE - 1)
1455 format_bufr[format_pos++] = msg[i];
1457 /* If a newline is encountered, print & restart. */
1458 if( '\n' == msg[i] )
1459 bufr_print();
1461 /* If the buffer is full dump it out, reset it, and put out a line
1462 * continuation indicator.
1464 if (format_pos >= FORMAT_BUFR_SIZE - 1) {
1465 bufr_print();
1466 (void)Debug1( " +>\n" );
1470 /* Just to be safe... */
1471 format_bufr[format_pos] = '\0';
1474 /***************************************************************************
1475 Flush debug output, including the format buffer content.
1477 Input: none
1478 Output: none
1479 ***************************************************************************/
1481 void dbgflush( void )
1483 bufr_print();
1486 bool dbgsetclass(int level, int cls)
1488 /* Set current_msg_level. */
1489 current_msg_level = level;
1491 /* Set current message class */
1492 current_msg_class = cls;
1494 return true;
1497 /***************************************************************************
1498 Print a Debug Header.
1500 Input: level - Debug level of the message (not the system-wide debug
1501 level. )
1502 cls - Debuglevel class of the calling module.
1503 location - Pointer to a string containing the name of the file
1504 from which this function was called, or an empty string
1505 if the __FILE__ macro is not implemented.
1506 func - Pointer to a string containing the name of the function
1507 from which this function was called, or an empty string
1508 if the __FUNCTION__ macro is not implemented.
1510 Output: Always true. This makes it easy to fudge a call to dbghdr()
1511 in a macro, since the function can be called as part of a test.
1512 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1514 Notes: This function takes care of setting current_msg_level.
1516 ****************************************************************************/
1518 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1520 /* Ensure we don't lose any real errno value. */
1521 int old_errno = errno;
1522 bool verbose = false;
1523 char header_str[300];
1524 size_t hs_len;
1525 struct timeval tv;
1526 struct timeval_buf tvbuf;
1528 if( format_pos ) {
1529 /* This is a fudge. If there is stuff sitting in the format_bufr, then
1530 * the *right* thing to do is to call
1531 * format_debug_text( "\n" );
1532 * to write the remainder, and then proceed with the new header.
1533 * Unfortunately, there are several places in the code at which
1534 * the DEBUG() macro is used to build partial lines. That in mind,
1535 * we'll work under the assumption that an incomplete line indicates
1536 * that a new header is *not* desired.
1538 return( true );
1541 dbgsetclass(level, cls);
1543 /* Don't print a header if we're logging to stdout. */
1544 if ( state.logtype != DEBUG_FILE ) {
1545 return( true );
1548 /* Print the header if timestamps are turned on. If parameters are
1549 * not yet loaded, then default to timestamps on.
1551 if (!(state.settings.timestamp_logs ||
1552 state.settings.debug_prefix_timestamp)) {
1553 return true;
1556 GetTimeOfDay(&tv);
1557 timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
1558 &tvbuf);
1560 hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
1561 tvbuf.buf, level);
1562 if (hs_len >= sizeof(header_str)) {
1563 goto full;
1566 if (unlikely(dbgc_config[cls].loglevel >= 10)) {
1567 verbose = true;
1570 if (verbose || state.settings.debug_pid) {
1571 hs_len += snprintf(
1572 header_str + hs_len, sizeof(header_str) - hs_len,
1573 ", pid=%u", (unsigned int)getpid());
1574 if (hs_len >= sizeof(header_str)) {
1575 goto full;
1579 if (verbose || state.settings.debug_uid) {
1580 hs_len += snprintf(
1581 header_str + hs_len, sizeof(header_str) - hs_len,
1582 ", effective(%u, %u), real(%u, %u)",
1583 (unsigned int)geteuid(), (unsigned int)getegid(),
1584 (unsigned int)getuid(), (unsigned int)getgid());
1585 if (hs_len >= sizeof(header_str)) {
1586 goto full;
1590 if ((verbose || state.settings.debug_class)
1591 && (cls != DBGC_ALL)) {
1592 hs_len += snprintf(
1593 header_str + hs_len, sizeof(header_str) - hs_len,
1594 ", class=%s", classname_table[cls]);
1595 if (hs_len >= sizeof(header_str)) {
1596 goto full;
1601 * No +=, see man man strlcat
1603 hs_len = strlcat(header_str, "] ", sizeof(header_str));
1604 if (hs_len >= sizeof(header_str)) {
1605 goto full;
1608 if (!state.settings.debug_prefix_timestamp) {
1609 hs_len += snprintf(
1610 header_str + hs_len, sizeof(header_str) - hs_len,
1611 "%s(%s)\n", location, func);
1612 if (hs_len >= sizeof(header_str)) {
1613 goto full;
1617 full:
1618 (void)Debug1(header_str);
1620 errno = old_errno;
1621 return( true );
1624 /***************************************************************************
1625 Add text to the body of the "current" debug message via the format buffer.
1627 Input: format_str - Format string, as used in printf(), et. al.
1628 ... - Variable argument list.
1630 ..or.. va_alist - Old style variable parameter list starting point.
1632 Output: Always true. See dbghdr() for more info, though this is not
1633 likely to be used in the same way.
1635 ***************************************************************************/
1637 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1638 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1640 char *msgbuf = NULL;
1641 bool ret = true;
1642 int res;
1644 res = vasprintf(&msgbuf, format_str, ap);
1645 if (res != -1) {
1646 format_debug_text(msgbuf);
1647 } else {
1648 ret = false;
1650 SAFE_FREE(msgbuf);
1651 return ret;
1654 bool dbgtext_va(const char *format_str, va_list ap)
1656 return __dbgtext_va(format_str, ap);
1659 bool dbgtext(const char *format_str, ... )
1661 va_list ap;
1662 bool ret;
1664 va_start(ap, format_str);
1665 ret = __dbgtext_va(format_str, ap);
1666 va_end(ap);
1668 return ret;