2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Elrond 2002
6 Copyright (C) Simo Sorce 2002
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "system/filesys.h"
25 #include "system/syslog.h"
26 #include "system/locale.h"
27 #include "time_basic.h"
28 #include "close_low_fd.h"
30 #include "util_strlist.h" /* LIST_SEP */
35 /* define what facility to use for syslog */
36 #ifndef SYSLOG_FACILITY
37 #define SYSLOG_FACILITY LOG_DAEMON
40 /* -------------------------------------------------------------------------- **
45 * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
46 * for a terminating null byte.
48 #define FORMAT_BUFR_SIZE 4096
50 /* -------------------------------------------------------------------------- **
51 * This module implements Samba's debugging utility.
53 * The syntax of a debugging log file is represented as:
55 * <debugfile> :== { <debugmsg> }
57 * <debugmsg> :== <debughdr> '\n' <debugtext>
59 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
61 * <debugtext> :== { <debugline> }
63 * <debugline> :== TEXT '\n'
65 * TEXT is a string of characters excluding the newline character.
66 * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
67 * TIME is a timestamp.
68 * FILENAME is the name of the file from which the debug message was generated.
69 * FUNCTION is the function from which the debug message was generated.
71 * Basically, what that all means is:
73 * - A debugging log file is made up of debug messages.
75 * - Each debug message is made up of a header and text. The header is
76 * separated from the text by a newline.
78 * - The header begins with the timestamp and debug level of the message
79 * enclosed in brackets. The filename and function from which the
80 * message was generated may follow. The filename is terminated by a
81 * colon, and the function name is terminated by parenthesis.
83 * - The message text is made up of zero or more lines, each terminated by
87 /* state variables for the debug system */
90 enum debug_logtype logtype
; /* The type of logging we are doing: eg stdout, file, stderr */
93 bool schedule_reopen_logs
;
95 struct debug_settings settings
;
96 debug_callback_fn callback
;
97 void *callback_private
;
102 .timestamp_logs
= true
108 * The debug loglevel of the class.
113 * An optional class specific logfile, may be NULL in which case the
114 * "global" logfile is used and fd is -1.
118 /* inode number of the logfile to detect logfile rotation */
122 static const char *default_classname_table
[] = {
125 [DBGC_PRINTDRIVERS
] = "printdrivers",
126 [DBGC_LANMAN
] = "lanman",
128 [DBGC_RPC_PARSE
] = "rpc_parse",
129 [DBGC_RPC_SRV
] = "rpc_srv",
130 [DBGC_RPC_CLI
] = "rpc_cli",
131 [DBGC_PASSDB
] = "passdb",
133 [DBGC_AUTH
] = "auth",
134 [DBGC_WINBIND
] = "winbind",
136 [DBGC_IDMAP
] = "idmap",
137 [DBGC_QUOTA
] = "quota",
138 [DBGC_ACLS
] = "acls",
139 [DBGC_LOCKING
] = "locking",
140 [DBGC_MSDFS
] = "msdfs",
141 [DBGC_DMAPI
] = "dmapi",
142 [DBGC_REGISTRY
] = "registry",
143 [DBGC_SCAVENGER
] = "scavenger",
146 [DBGC_TEVENT
] = "tevent",
147 [DBGC_AUTH_AUDIT
] = "auth_audit",
148 [DBGC_AUTH_AUDIT_JSON
] = "auth_json_audit",
149 [DBGC_KERBEROS
] = "kerberos",
150 [DBGC_DRS_REPL
] = "drs_repl",
151 [DBGC_SMB2
] = "smb2",
152 [DBGC_SMB2_CREDITS
] = "smb2_credits",
153 [DBGC_DSDB_AUDIT
] = "dsdb_audit",
154 [DBGC_DSDB_AUDIT_JSON
] = "dsdb_json_audit",
155 [DBGC_DSDB_PWD_AUDIT
] = "dsdb_password_audit",
156 [DBGC_DSDB_PWD_AUDIT_JSON
] = "dsdb_password_json_audit",
157 [DBGC_DSDB_TXN_AUDIT
] = "dsdb_transaction_audit",
158 [DBGC_DSDB_TXN_AUDIT_JSON
] = "dsdb_transaction_json_audit",
159 [DBGC_DSDB_GROUP_AUDIT
] = "dsdb_group_audit",
160 [DBGC_DSDB_GROUP_AUDIT_JSON
] = "dsdb_group_json_audit",
164 * This is to allow reading of dbgc_config before the debug
165 * system has been initialized.
167 static struct debug_class debug_class_list_initial
[ARRAY_SIZE(default_classname_table
)] = {
168 [DBGC_ALL
] = { .fd
= 2 },
171 static size_t debug_num_classes
= 0;
172 static struct debug_class
*dbgc_config
= debug_class_list_initial
;
174 static int current_msg_level
= 0;
175 static int current_msg_class
= 0;
177 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
178 static int debug_level_to_priority(int level
)
181 * map debug levels to syslog() priorities
183 static const int priority_map
[] = {
197 if (level
< 0 || (size_t)level
>= ARRAY_SIZE(priority_map
))
198 priority
= LOG_DEBUG
;
200 priority
= priority_map
[level
];
206 /* -------------------------------------------------------------------------- **
207 * Debug backends. When logging to DEBUG_FILE, send the log entries to
208 * all active backends.
211 static void debug_file_log(int msg_level
,
212 const char *msg
, const char *msg_no_nl
)
219 if (dbgc_config
[current_msg_class
].fd
!= -1) {
220 fd
= dbgc_config
[current_msg_class
].fd
;
222 fd
= dbgc_config
[DBGC_ALL
].fd
;
226 ret
= write(fd
, msg
, strlen(msg
));
227 } while (ret
== -1 && errno
== EINTR
);
231 static void debug_syslog_reload(bool enabled
, bool previously_enabled
,
232 const char *prog_name
, char *option
)
234 if (enabled
&& !previously_enabled
) {
235 const char *ident
= NULL
;
236 if ((prog_name
!= NULL
) && (prog_name
[0] != '\0')) {
240 openlog(ident
, LOG_PID
, SYSLOG_FACILITY
);
242 /* for old systems that have no facility codes. */
243 openlog(ident
, LOG_PID
);
248 if (!enabled
&& previously_enabled
) {
253 static void debug_syslog_log(int msg_level
,
254 const char *msg
, const char *msg_no_nl
)
258 priority
= debug_level_to_priority(msg_level
);
261 * Specify the facility to interoperate with other syslog
262 * callers (vfs_full_audit for example).
264 priority
|= SYSLOG_FACILITY
;
266 syslog(priority
, "%s", msg
);
268 #endif /* WITH_SYSLOG */
270 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
271 #include <systemd/sd-journal.h>
272 static void debug_systemd_log(int msg_level
,
273 const char *msg
, const char *msg_no_nl
)
275 sd_journal_send("MESSAGE=%s", msg_no_nl
,
276 "PRIORITY=%d", debug_level_to_priority(msg_level
),
277 "LEVEL=%d", msg_level
,
282 #ifdef HAVE_LTTNG_TRACEF
283 #include <lttng/tracef.h>
284 static void debug_lttng_log(int msg_level
,
285 const char *msg
, const char *msg_no_nl
)
289 #endif /* WITH_LTTNG_TRACEF */
292 #include "gpfswrap.h"
293 static void debug_gpfs_reload(bool enabled
, bool previously_enabled
,
294 const char *prog_name
, char *option
)
298 if (enabled
&& !previously_enabled
) {
299 gpfswrap_init_trace();
303 if (!enabled
&& previously_enabled
) {
304 gpfswrap_fini_trace();
310 * Trigger GPFS library to adjust state if necessary.
312 gpfswrap_query_trace();
316 static void debug_gpfs_log(int msg_level
,
317 const char *msg
, const char *msg_no_nl
)
319 gpfswrap_add_trace(msg_level
, msg_no_nl
);
321 #endif /* HAVE_GPFS */
323 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
324 #define DEBUG_RINGBUF_SIZE_OPT "size="
326 static char *debug_ringbuf
;
327 static size_t debug_ringbuf_size
;
328 static size_t debug_ringbuf_ofs
;
330 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
331 char *debug_get_ringbuf(void)
333 return debug_ringbuf
;
336 /* Return the size of the ringbuf (including a \0 terminator) */
337 size_t debug_get_ringbuf_size(void)
339 return debug_ringbuf_size
;
342 static void debug_ringbuf_reload(bool enabled
, bool previously_enabled
,
343 const char *prog_name
, char *option
)
346 size_t optlen
= strlen(DEBUG_RINGBUF_SIZE_OPT
);
348 debug_ringbuf_size
= DEBUG_RINGBUF_SIZE
;
349 debug_ringbuf_ofs
= 0;
351 SAFE_FREE(debug_ringbuf
);
357 if (option
!= NULL
) {
358 cmp
= strncmp(option
, DEBUG_RINGBUF_SIZE_OPT
, optlen
);
360 debug_ringbuf_size
= (size_t)strtoull(
361 option
+ optlen
, NULL
, 10);
365 debug_ringbuf
= calloc(debug_ringbuf_size
, sizeof(char));
366 if (debug_ringbuf
== NULL
) {
371 static void _debug_ringbuf_log(int msg_level
,
374 size_t msglen
= strlen(msg
);
377 if (debug_ringbuf
== NULL
) {
381 /* Ensure the buffer is always \0 terminated */
382 allowed_size
= debug_ringbuf_size
- 1;
384 if (msglen
> allowed_size
) {
388 if ((debug_ringbuf_ofs
+ msglen
) < debug_ringbuf_ofs
) {
392 if ((debug_ringbuf_ofs
+ msglen
) > allowed_size
) {
393 debug_ringbuf_ofs
= 0;
396 memcpy(debug_ringbuf
+ debug_ringbuf_ofs
, msg
, msglen
);
397 debug_ringbuf_ofs
+= msglen
;
400 static void debug_ringbuf_log(int msg_level
,
402 const char *msg_no_nl
)
404 _debug_ringbuf_log(msg_level
, msg
);
407 static struct debug_backend
{
411 void (*reload
)(bool enabled
, bool prev_enabled
,
412 const char *prog_name
, char *option
);
413 void (*log
)(int msg_level
, const char *msg
, const char *msg_no_nl
);
415 } debug_backends
[] = {
418 .log
= debug_file_log
,
423 .reload
= debug_syslog_reload
,
424 .log
= debug_syslog_log
,
428 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
431 .log
= debug_systemd_log
,
435 #ifdef HAVE_LTTNG_TRACEF
438 .log
= debug_lttng_log
,
445 .reload
= debug_gpfs_reload
,
446 .log
= debug_gpfs_log
,
451 .log
= debug_ringbuf_log
,
452 .reload
= debug_ringbuf_reload
,
456 static struct debug_backend
*debug_find_backend(const char *name
)
460 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
461 if (strcmp(name
, debug_backends
[i
].name
) == 0) {
462 return &debug_backends
[i
];
470 * parse "backend[:option][@loglevel]
472 static void debug_backend_parse_token(char *tok
)
474 char *backend_name_option
, *backend_name
,*backend_level
, *saveptr
;
475 char *backend_option
;
476 struct debug_backend
*b
;
479 * First parse into backend[:option] and loglevel
481 backend_name_option
= strtok_r(tok
, "@\0", &saveptr
);
482 if (backend_name_option
== NULL
) {
486 backend_level
= strtok_r(NULL
, "\0", &saveptr
);
489 * Now parse backend[:option]
491 backend_name
= strtok_r(backend_name_option
, ":\0", &saveptr
);
492 if (backend_name
== NULL
) {
496 backend_option
= strtok_r(NULL
, "\0", &saveptr
);
499 * Find and update backend
501 b
= debug_find_backend(backend_name
);
506 if (backend_level
== NULL
) {
507 b
->new_log_level
= MAX_DEBUG_LEVEL
;
509 b
->new_log_level
= atoi(backend_level
);
512 if (backend_option
!= NULL
) {
513 b
->option
= strdup(backend_option
);
514 if (b
->option
== NULL
) {
521 * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
522 * and enable/disable backends accordingly
524 static void debug_set_backends(const char *param
)
526 size_t str_len
= strlen(param
);
532 * initialize new_log_level to detect backends that have been
535 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
536 SAFE_FREE(debug_backends
[i
].option
);
537 debug_backends
[i
].new_log_level
= -1;
540 memcpy(str
, param
, str_len
+ 1);
542 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
547 while (tok
!= NULL
) {
548 debug_backend_parse_token(tok
);
549 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
553 * Let backends react to config changes
555 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
556 struct debug_backend
*b
= &debug_backends
[i
];
559 bool enabled
= b
->new_log_level
> -1;
560 bool previously_enabled
= b
->log_level
> -1;
562 b
->reload(enabled
, previously_enabled
, state
.prog_name
,
565 b
->log_level
= b
->new_log_level
;
569 static void debug_backends_log(const char *msg
, int msg_level
)
571 char msg_no_nl
[FORMAT_BUFR_SIZE
];
576 * Some backends already add an extra newline, so also provide
577 * a buffer without the newline character.
579 len
= MIN(strlen(msg
), FORMAT_BUFR_SIZE
- 1);
580 if ((len
> 0) && (msg
[len
- 1] == '\n')) {
584 memcpy(msg_no_nl
, msg
, len
);
585 msg_no_nl
[len
] = '\0';
587 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
588 if (msg_level
<= debug_backends
[i
].log_level
) {
589 debug_backends
[i
].log(msg_level
, msg
, msg_no_nl
);
594 int debuglevel_get_class(size_t idx
)
596 return dbgc_config
[idx
].loglevel
;
599 void debuglevel_set_class(size_t idx
, int level
)
601 dbgc_config
[idx
].loglevel
= level
;
605 /* -------------------------------------------------------------------------- **
606 * Internal variables.
608 * debug_count - Number of debug messages that have been output.
609 * Used to check log size.
611 * current_msg_level - Internal copy of the message debug level. Written by
612 * dbghdr() and read by Debug1().
614 * format_bufr - Used to format debug messages. The dbgtext() function
615 * prints debug messages to a string, and then passes the
616 * string to format_debug_text(), which uses format_bufr
617 * to build the formatted output.
619 * format_pos - Marks the first free byte of the format_bufr.
622 * log_overflow - When this variable is true, never attempt to check the
623 * size of the log. This is a hack, so that we can write
624 * a message using DEBUG, from open_logs() when we
625 * are unable to open a new log file for some reason.
628 static int debug_count
= 0;
629 static char format_bufr
[FORMAT_BUFR_SIZE
];
630 static size_t format_pos
= 0;
631 static bool log_overflow
= false;
634 * Define all the debug class selection names here. Names *MUST NOT* contain
635 * white space. There must be one name for each DBGC_<class name>, and they
636 * must be in the table in the order of DBGC_<class name>..
639 static char **classname_table
= NULL
;
642 /* -------------------------------------------------------------------------- **
646 static void debug_init(void);
648 /***************************************************************************
649 Free memory pointed to by global pointers.
650 ****************************************************************************/
652 void gfree_debugsyms(void)
656 TALLOC_FREE(classname_table
);
658 if ( dbgc_config
!= debug_class_list_initial
) {
659 TALLOC_FREE( dbgc_config
);
660 dbgc_config
= discard_const_p(struct debug_class
,
661 debug_class_list_initial
);
664 debug_num_classes
= 0;
666 state
.initialized
= false;
668 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
669 SAFE_FREE(debug_backends
[i
].option
);
673 /****************************************************************************
674 utility lists registered debug class names's
675 ****************************************************************************/
677 char *debug_list_class_names_and_levels(void)
681 /* prepare strings */
682 for (i
= 0; i
< debug_num_classes
; i
++) {
683 buf
= talloc_asprintf_append(buf
,
686 dbgc_config
[i
].loglevel
,
687 i
== (debug_num_classes
- 1) ? "\n" : " ");
695 /****************************************************************************
696 Utility to translate names to debug class index's (internal version).
697 ****************************************************************************/
699 static int debug_lookup_classname_int(const char* classname
)
703 if (classname
== NULL
) {
707 for (i
=0; i
< debug_num_classes
; i
++) {
708 char *entry
= classname_table
[i
];
709 if (entry
!= NULL
&& strcmp(classname
, entry
)==0) {
716 /****************************************************************************
717 Add a new debug class to the system.
718 ****************************************************************************/
720 int debug_add_class(const char *classname
)
723 struct debug_class
*new_class_list
= NULL
;
724 char **new_name_list
;
727 if (classname
== NULL
) {
731 /* check the init has yet been called */
734 ndx
= debug_lookup_classname_int(classname
);
738 ndx
= debug_num_classes
;
740 if (dbgc_config
== debug_class_list_initial
) {
741 /* Initial loading... */
742 new_class_list
= NULL
;
744 new_class_list
= dbgc_config
;
747 default_level
= dbgc_config
[DBGC_ALL
].loglevel
;
749 new_class_list
= talloc_realloc(NULL
,
753 if (new_class_list
== NULL
) {
757 dbgc_config
= new_class_list
;
759 dbgc_config
[ndx
] = (struct debug_class
) {
760 .loglevel
= default_level
,
764 new_name_list
= talloc_realloc(NULL
, classname_table
, char *, ndx
+ 1);
765 if (new_name_list
== NULL
) {
768 classname_table
= new_name_list
;
770 classname_table
[ndx
] = talloc_strdup(classname_table
, classname
);
771 if (classname_table
[ndx
] == NULL
) {
775 debug_num_classes
= ndx
+ 1;
780 /****************************************************************************
781 Utility to translate names to debug class index's (public version).
782 ****************************************************************************/
784 static int debug_lookup_classname(const char *classname
)
788 if (classname
== NULL
|| !*classname
)
791 ndx
= debug_lookup_classname_int(classname
);
796 DBG_WARNING("Unknown classname[%s] -> adding it...\n", classname
);
797 return debug_add_class(classname
);
800 /****************************************************************************
801 Dump the current registered debug levels.
802 ****************************************************************************/
804 static void debug_dump_status(int level
)
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",
813 dbgc_config
[q
].loglevel
));
817 static bool debug_parse_param(char *param
)
820 char *class_file
= NULL
;
822 char *saveptr
= NULL
;
825 class_name
= strtok_r(param
, ":", &saveptr
);
826 if (class_name
== NULL
) {
830 class_level
= strtok_r(NULL
, "@\0", &saveptr
);
831 if (class_level
== NULL
) {
835 class_file
= strtok_r(NULL
, "\0", &saveptr
);
837 ndx
= debug_lookup_classname(class_name
);
842 dbgc_config
[ndx
].loglevel
= atoi(class_level
);
844 if (class_file
== NULL
) {
848 TALLOC_FREE(dbgc_config
[ndx
].logfile
);
850 dbgc_config
[ndx
].logfile
= talloc_strdup(NULL
, class_file
);
851 if (dbgc_config
[ndx
].logfile
== NULL
) {
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
);
873 memcpy(str
, params_str
, str_len
+1);
875 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
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
);
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
) {
899 ok
= debug_parse_param(tok
);
901 DEBUG(0,("debug_parse_params: unrecognized debug "
902 "class name or format [%s]\n", tok
));
906 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
909 debug_dump_status(5);
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)
934 if (state
.initialized
)
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];
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
);
975 snprintf(fake_param
, sizeof(fake_param
),
976 "syslog@%d", syslog_level
- 1);
978 snprintf(fake_param
, sizeof(fake_param
),
979 "syslog@%d file@%d", syslog_level
-1,
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
)
1002 if (state
.logtype
< new_logtype
) {
1003 state
.logtype
= new_logtype
;
1006 const char *p
= strrchr(prog_name
, '/');
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 */
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
)
1038 enum debug_logtype
debug_get_log_type(void)
1040 return state
.logtype
;
1043 bool debug_get_output_is_stderr(void)
1045 return (state
.logtype
== DEBUG_DEFAULT_STDERR
) || (state
.logtype
== DEBUG_STDERR
);
1048 bool debug_get_output_is_stdout(void)
1050 return (state
.logtype
== DEBUG_DEFAULT_STDOUT
) || (state
.logtype
== DEBUG_STDOUT
);
1053 void debug_set_callback(void *private_ptr
, debug_callback_fn fn
)
1057 state
.logtype
= DEBUG_CALLBACK
;
1058 state
.callback_private
= private_ptr
;
1059 state
.callback
= fn
;
1061 state
.logtype
= DEBUG_DEFAULT_STDERR
;
1062 state
.callback_private
= NULL
;
1063 state
.callback
= NULL
;
1067 static void debug_callback_log(const char *msg
, int msg_level
)
1069 size_t msg_len
= strlen(msg
);
1070 char msg_copy
[msg_len
];
1072 if ((msg_len
> 0) && (msg
[msg_len
-1] == '\n')) {
1073 memcpy(msg_copy
, msg
, msg_len
-1);
1074 msg_copy
[msg_len
-1] = '\0';
1078 state
.callback(state
.callback_private
, msg_level
, msg
);
1081 /**************************************************************************
1082 reopen the log files
1083 note that we now do this unconditionally
1084 We attempt to open the new debug fp before closing the old. This means
1085 if we run out of fd's we just keep using the old fd rather than aborting.
1086 Fix from dgibson@linuxcare.com.
1087 **************************************************************************/
1089 static bool reopen_one_log(struct debug_class
*config
)
1091 int old_fd
= config
->fd
;
1092 const char *logfile
= config
->logfile
;
1097 if (logfile
== NULL
) {
1098 debug_close_fd(old_fd
);
1103 new_fd
= open(logfile
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
1105 log_overflow
= true;
1106 DBG_ERR("Unable to open new log file '%s': %s\n",
1107 logfile
, strerror(errno
));
1108 log_overflow
= false;
1112 debug_close_fd(old_fd
);
1113 smb_set_close_on_exec(new_fd
);
1114 config
->fd
= new_fd
;
1116 ret
= fstat(new_fd
, &st
);
1118 log_overflow
= true;
1119 DBG_ERR("Unable to fstat() new log file '%s': %s\n",
1120 logfile
, strerror(errno
));
1121 log_overflow
= false;
1125 config
->ino
= st
.st_ino
;
1130 reopen the log file (usually called because the log file name might have changed)
1132 bool reopen_logs_internal(void)
1134 struct debug_backend
*b
= NULL
;
1140 if (state
.reopening_logs
) {
1144 /* Now clear the SIGHUP induced flag */
1145 state
.schedule_reopen_logs
= false;
1147 switch (state
.logtype
) {
1148 case DEBUG_CALLBACK
:
1151 case DEBUG_DEFAULT_STDOUT
:
1152 debug_close_fd(dbgc_config
[DBGC_ALL
].fd
);
1153 dbgc_config
[DBGC_ALL
].fd
= 1;
1156 case DEBUG_DEFAULT_STDERR
:
1158 debug_close_fd(dbgc_config
[DBGC_ALL
].fd
);
1159 dbgc_config
[DBGC_ALL
].fd
= 2;
1163 b
= debug_find_backend("file");
1166 b
->log_level
= MAX_DEBUG_LEVEL
;
1170 oldumask
= umask( 022 );
1172 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1173 if (dbgc_config
[i
].logfile
!= NULL
) {
1177 if (i
== debug_num_classes
) {
1181 state
.reopening_logs
= true;
1183 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1184 ok
= reopen_one_log(&dbgc_config
[i
]);
1190 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1191 * to fix problem where smbd's that generate less
1192 * than 100 messages keep growing the log.
1194 force_check_log_size();
1195 (void)umask(oldumask
);
1198 * If log file was opened or created successfully, take over stderr to
1199 * catch output into logs.
1202 if (dup2(dbgc_config
[DBGC_ALL
].fd
, 2) == -1) {
1203 /* Close stderr too, if dup2 can't point it -
1204 at the logfile. There really isn't much
1205 that can be done on such a fundamental
1211 state
.reopening_logs
= false;
1216 /**************************************************************************
1217 Force a check of the log size.
1218 ***************************************************************************/
1220 void force_check_log_size( void )
1225 _PUBLIC_
void debug_schedule_reopen_logs(void)
1227 state
.schedule_reopen_logs
= true;
1231 /***************************************************************************
1232 Check to see if there is any need to check if the logfile has grown too big.
1233 **************************************************************************/
1235 bool need_to_check_log_size(void)
1240 if (debug_count
< 100) {
1244 maxlog
= state
.settings
.max_log_size
* 1024;
1250 if (dbgc_config
[DBGC_ALL
].fd
> 2) {
1254 for (i
= DBGC_ALL
+ 1; i
< debug_num_classes
; i
++) {
1255 if (dbgc_config
[i
].fd
!= -1) {
1264 /**************************************************************************
1265 Check to see if the log has grown to be too big.
1266 **************************************************************************/
1268 static void do_one_check_log_size(off_t maxlog
, struct debug_class
*config
)
1270 char name
[strlen(config
->logfile
) + 5];
1273 bool reopen
= false;
1280 ret
= stat(config
->logfile
, &st
);
1284 if (st
.st_size
>= maxlog
) {
1288 if (st
.st_ino
!= config
->ino
) {
1296 /* reopen_logs_internal() modifies *_fd */
1297 (void)reopen_logs_internal();
1299 if (config
->fd
<= 2) {
1302 ret
= fstat(config
->fd
, &st
);
1304 config
->ino
= (ino_t
)0;
1308 config
->ino
= st
.st_ino
;
1310 if (st
.st_size
< maxlog
) {
1314 snprintf(name
, sizeof(name
), "%s.old", config
->logfile
);
1316 (void)rename(config
->logfile
, name
);
1318 ok
= reopen_logs_internal();
1322 /* We failed to reopen a log - continue using the old name. */
1323 (void)rename(name
, config
->logfile
);
1326 static void do_check_log_size(off_t maxlog
)
1330 for (i
= DBGC_ALL
; i
< debug_num_classes
; i
++) {
1331 if (dbgc_config
[i
].fd
== -1) {
1334 if (dbgc_config
[i
].logfile
== NULL
) {
1337 do_one_check_log_size(maxlog
, &dbgc_config
[i
]);
1341 void check_log_size( void )
1346 * We need to be root to check/change log-file, skip this and let the main
1347 * loop check do a new check as root.
1350 #if _SAMBA_BUILD_ == 3
1351 if (geteuid() != sec_initial_uid())
1356 /* We don't check sec_initial_uid() here as it isn't
1357 * available in common code and we don't generally
1358 * want to rotate and the possibly lose logs in
1359 * make test or the build farm */
1363 if(log_overflow
|| (!state
.schedule_reopen_logs
&& !need_to_check_log_size())) {
1367 maxlog
= state
.settings
.max_log_size
* 1024;
1369 if (state
.schedule_reopen_logs
) {
1370 (void)reopen_logs_internal();
1373 do_check_log_size(maxlog
);
1376 * Here's where we need to panic if dbgc_config[DBGC_ALL].fd == 0 or -1
1380 if (dbgc_config
[DBGC_ALL
].fd
<= 0) {
1381 /* This code should only be reached in very strange
1382 * circumstances. If we merely fail to open the new log we
1383 * should stick with the old one. ergo this should only be
1384 * reached when opening the logs for the first time: at
1385 * startup or when the log level is increased from zero.
1388 int fd
= open( "/dev/console", O_WRONLY
, 0);
1390 smb_set_close_on_exec(fd
);
1391 dbgc_config
[DBGC_ALL
].fd
= fd
;
1392 DBG_ERR("check_log_size: open of debug file %s failed "
1393 "- using console.\n",
1394 dbgc_config
[DBGC_ALL
].logfile
);
1397 * We cannot continue without a debug file handle.
1405 /*************************************************************************
1406 Write an debug message on the debugfile.
1407 This is called by dbghdr() and format_debug_text().
1408 ************************************************************************/
1410 static void Debug1(const char *msg
)
1412 int old_errno
= errno
;
1416 switch(state
.logtype
) {
1417 case DEBUG_CALLBACK
:
1418 debug_callback_log(msg
, current_msg_level
);
1422 case DEBUG_DEFAULT_STDOUT
:
1423 case DEBUG_DEFAULT_STDERR
:
1424 if (dbgc_config
[DBGC_ALL
].fd
> 0) {
1427 ret
= write(dbgc_config
[DBGC_ALL
].fd
,
1430 } while (ret
== -1 && errno
== EINTR
);
1434 debug_backends_log(msg
, current_msg_level
);
1441 /**************************************************************************
1442 Print the buffer content via Debug1(), then reset the buffer.
1445 ****************************************************************************/
1447 static void bufr_print( void )
1449 format_bufr
[format_pos
] = '\0';
1450 (void)Debug1(format_bufr
);
1454 /***************************************************************************
1455 Format the debug message text.
1457 Input: msg - Text to be added to the "current" debug message text.
1461 Notes: The purpose of this is two-fold. First, each call to syslog()
1462 (used by Debug1(), see above) generates a new line of syslog
1463 output. This is fixed by storing the partial lines until the
1464 newline character is encountered. Second, printing the debug
1465 message lines when a newline is encountered allows us to add
1466 spaces, thus indenting the body of the message and making it
1468 **************************************************************************/
1470 static void format_debug_text( const char *msg
)
1473 bool timestamp
= (state
.logtype
== DEBUG_FILE
&& (state
.settings
.timestamp_logs
));
1477 for( i
= 0; msg
[i
]; i
++ ) {
1478 /* Indent two spaces at each new line. */
1479 if(timestamp
&& 0 == format_pos
) {
1480 format_bufr
[0] = format_bufr
[1] = ' ';
1484 /* If there's room, copy the character to the format buffer. */
1485 if (format_pos
< FORMAT_BUFR_SIZE
- 1)
1486 format_bufr
[format_pos
++] = msg
[i
];
1488 /* If a newline is encountered, print & restart. */
1489 if( '\n' == msg
[i
] )
1492 /* If the buffer is full dump it out, reset it, and put out a line
1493 * continuation indicator.
1495 if (format_pos
>= FORMAT_BUFR_SIZE
- 1) {
1497 (void)Debug1( " +>\n" );
1501 /* Just to be safe... */
1502 format_bufr
[format_pos
] = '\0';
1505 /***************************************************************************
1506 Flush debug output, including the format buffer content.
1510 ***************************************************************************/
1512 void dbgflush( void )
1517 bool dbgsetclass(int level
, int cls
)
1519 /* Set current_msg_level. */
1520 current_msg_level
= level
;
1522 /* Set current message class */
1523 current_msg_class
= cls
;
1528 /***************************************************************************
1529 Print a Debug Header.
1531 Input: level - Debug level of the message (not the system-wide debug
1533 cls - Debuglevel class of the calling module.
1534 location - Pointer to a string containing the name of the file
1535 from which this function was called, or an empty string
1536 if the __FILE__ macro is not implemented.
1537 func - Pointer to a string containing the name of the function
1538 from which this function was called, or an empty string
1539 if the __FUNCTION__ macro is not implemented.
1541 Output: Always true. This makes it easy to fudge a call to dbghdr()
1542 in a macro, since the function can be called as part of a test.
1543 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1545 Notes: This function takes care of setting current_msg_level.
1547 ****************************************************************************/
1549 bool dbghdrclass(int level
, int cls
, const char *location
, const char *func
)
1551 /* Ensure we don't lose any real errno value. */
1552 int old_errno
= errno
;
1553 bool verbose
= false;
1555 struct timeval_buf tvbuf
;
1558 * This might be overkill, but if another early return is
1559 * added later then initialising these avoids potential
1563 state
.header_str
[0] = '\0';
1566 /* This is a fudge. If there is stuff sitting in the format_bufr, then
1567 * the *right* thing to do is to call
1568 * format_debug_text( "\n" );
1569 * to write the remainder, and then proceed with the new header.
1570 * Unfortunately, there are several places in the code at which
1571 * the DEBUG() macro is used to build partial lines. That in mind,
1572 * we'll work under the assumption that an incomplete line indicates
1573 * that a new header is *not* desired.
1578 dbgsetclass(level
, cls
);
1580 /* Don't print a header if we're logging to stdout. */
1581 if ( state
.logtype
!= DEBUG_FILE
) {
1585 /* Print the header if timestamps are turned on. If parameters are
1586 * not yet loaded, then default to timestamps on.
1588 if (!(state
.settings
.timestamp_logs
||
1589 state
.settings
.debug_prefix_timestamp
)) {
1594 timeval_str_buf(&tv
, false, state
.settings
.debug_hires_timestamp
,
1597 state
.hs_len
= snprintf(state
.header_str
,
1598 sizeof(state
.header_str
),
1602 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1606 if (unlikely(dbgc_config
[cls
].loglevel
>= 10)) {
1610 if (verbose
|| state
.settings
.debug_pid
) {
1611 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1612 sizeof(state
.header_str
) - state
.hs_len
,
1614 (unsigned int)getpid());
1615 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1620 if (verbose
|| state
.settings
.debug_uid
) {
1621 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1622 sizeof(state
.header_str
) - state
.hs_len
,
1623 ", effective(%u, %u), real(%u, %u)",
1624 (unsigned int)geteuid(),
1625 (unsigned int)getegid(),
1626 (unsigned int)getuid(),
1627 (unsigned int)getgid());
1628 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1633 if ((verbose
|| state
.settings
.debug_class
)
1634 && (cls
!= DBGC_ALL
)) {
1635 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1636 sizeof(state
.header_str
) - state
.hs_len
,
1638 classname_table
[cls
]);
1639 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1645 * No +=, see man man strlcat
1647 state
.hs_len
= strlcat(state
.header_str
, "] ", sizeof(state
.header_str
));
1648 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1652 if (!state
.settings
.debug_prefix_timestamp
) {
1653 state
.hs_len
+= snprintf(state
.header_str
+ state
.hs_len
,
1654 sizeof(state
.header_str
) - state
.hs_len
,
1658 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1665 * Above code never overflows state.header_str and always
1666 * NUL-terminates correctly. However, state.hs_len can point
1667 * past the end of the buffer to indicate that truncation
1668 * occurred, so fix it if necessary, since state.hs_len is
1669 * expected to be used after return.
1671 if (state
.hs_len
>= sizeof(state
.header_str
)) {
1672 state
.hs_len
= sizeof(state
.header_str
) - 1;
1675 (void)Debug1(state
.header_str
);
1681 /***************************************************************************
1682 Add text to the body of the "current" debug message via the format buffer.
1684 Input: format_str - Format string, as used in printf(), et. al.
1685 ... - Variable argument list.
1687 ..or.. va_alist - Old style variable parameter list starting point.
1689 Output: Always true. See dbghdr() for more info, though this is not
1690 likely to be used in the same way.
1692 ***************************************************************************/
1694 static inline bool __dbgtext_va(const char *format_str
, va_list ap
) PRINTF_ATTRIBUTE(1,0);
1695 static inline bool __dbgtext_va(const char *format_str
, va_list ap
)
1697 char *msgbuf
= NULL
;
1701 res
= vasprintf(&msgbuf
, format_str
, ap
);
1703 format_debug_text(msgbuf
);
1711 bool dbgtext_va(const char *format_str
, va_list ap
)
1713 return __dbgtext_va(format_str
, ap
);
1716 bool dbgtext(const char *format_str
, ... )
1721 va_start(ap
, format_str
);
1722 ret
= __dbgtext_va(format_str
, ap
);