2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Elrond 2002
6 Copyright (C) Simo Sorce 2002
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "system/filesys.h"
25 #include "system/syslog.h"
26 #include "system/locale.h"
27 #include "time_basic.h"
28 #include "close_low_fd.h"
30 #include "util_strlist.h" /* LIST_SEP */
34 /* define what facility to use for syslog */
35 #ifndef SYSLOG_FACILITY
36 #define SYSLOG_FACILITY LOG_DAEMON
39 /* -------------------------------------------------------------------------- **
44 * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
45 * for a terminating null byte.
47 #define FORMAT_BUFR_SIZE 1024
49 /* -------------------------------------------------------------------------- **
50 * This module implements Samba's debugging utility.
52 * The syntax of a debugging log file is represented as:
54 * <debugfile> :== { <debugmsg> }
56 * <debugmsg> :== <debughdr> '\n' <debugtext>
58 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
60 * <debugtext> :== { <debugline> }
62 * <debugline> :== TEXT '\n'
64 * TEXT is a string of characters excluding the newline character.
65 * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
66 * TIME is a timestamp.
67 * FILENAME is the name of the file from which the debug message was generated.
68 * FUNCTION is the function from which the debug message was generated.
70 * Basically, what that all means is:
72 * - A debugging log file is made up of debug messages.
74 * - Each debug message is made up of a header and text. The header is
75 * separated from the text by a newline.
77 * - The header begins with the timestamp and debug level of the message
78 * enclosed in brackets. The filename and function from which the
79 * message was generated may follow. The filename is terminated by a
80 * colon, and the function name is terminated by parenthesis.
82 * - The message text is made up of zero or more lines, each terminated by
86 /* state variables for the debug system */
89 int fd
; /* The log file handle */
90 enum debug_logtype logtype
; /* The type of logging we are doing: eg stdout, file, stderr */
91 const char *prog_name
;
93 bool schedule_reopen_logs
;
95 struct debug_settings settings
;
97 debug_callback_fn callback
;
98 void *callback_private
;
101 .timestamp_logs
= true
103 .fd
= 2 /* stderr by default */
106 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
107 static int debug_level_to_priority(int level
)
110 * map debug levels to syslog() priorities
112 static const int priority_map
[] = {
126 if( level
>= ARRAY_SIZE(priority_map
) || level
< 0)
127 priority
= LOG_DEBUG
;
129 priority
= priority_map
[level
];
135 /* -------------------------------------------------------------------------- **
136 * Debug backends. When logging to DEBUG_FILE, send the log entries to
137 * all active backends.
140 static void debug_file_log(int msg_level
,
141 const char *msg
, const char *msg_no_nl
)
147 ret
= write(state
.fd
, msg
, strlen(msg
));
148 } while (ret
== -1 && errno
== EINTR
);
152 static void debug_syslog_reload(bool enabled
, bool previously_enabled
,
153 const char *prog_name
, char *option
)
155 if (enabled
&& !previously_enabled
) {
157 openlog(prog_name
, LOG_PID
, SYSLOG_FACILITY
);
159 /* for old systems that have no facility codes. */
160 openlog(prog_name
, LOG_PID
);
165 if (!enabled
&& previously_enabled
) {
170 static void debug_syslog_log(int msg_level
,
171 const char *msg
, const char *msg_no_nl
)
175 priority
= debug_level_to_priority(msg_level
);
178 * Specify the facility to interoperate with other syslog
179 * callers (vfs_full_audit for example).
181 priority
|= SYSLOG_FACILITY
;
183 syslog(priority
, "%s", msg
);
185 #endif /* WITH_SYSLOG */
187 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
188 #include <systemd/sd-journal.h>
189 static void debug_systemd_log(int msg_level
,
190 const char *msg
, const char *msg_no_nl
)
192 sd_journal_send("MESSAGE=%s", msg_no_nl
,
193 "PRIORITY=%d", debug_level_to_priority(msg_level
),
194 "LEVEL=%d", msg_level
,
199 #ifdef HAVE_LTTNG_TRACEF
200 #include <lttng/tracef.h>
201 static void debug_lttng_log(int msg_level
,
202 const char *msg
, const char *msg_no_nl
)
206 #endif /* WITH_LTTNG_TRACEF */
209 #include "gpfswrap.h"
210 static void debug_gpfs_reload(bool enabled
, bool previously_enabled
,
211 const char *prog_name
, char *option
)
215 if (enabled
&& !previously_enabled
) {
216 gpfswrap_init_trace();
220 if (!enabled
&& previously_enabled
) {
221 gpfswrap_fini_trace();
227 * Trigger GPFS library to adjust state if necessary.
229 gpfswrap_query_trace();
233 static void debug_gpfs_log(int msg_level
,
234 const char *msg
, const char *msg_no_nl
)
236 gpfswrap_add_trace(msg_level
, msg_no_nl
);
238 #endif /* HAVE_GPFS */
240 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
241 #define DEBUG_RINGBUF_SIZE_OPT "size="
243 static char *debug_ringbuf
;
244 static size_t debug_ringbuf_size
;
245 static size_t debug_ringbuf_ofs
;
247 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
248 char *debug_get_ringbuf(void)
250 return debug_ringbuf
;
253 /* Return the size of the ringbuf (including a \0 terminator) */
254 size_t debug_get_ringbuf_size(void)
256 return debug_ringbuf_size
;
259 static void debug_ringbuf_reload(bool enabled
, bool previously_enabled
,
260 const char *prog_name
, char *option
)
263 size_t optlen
= strlen(DEBUG_RINGBUF_SIZE_OPT
);
265 debug_ringbuf_size
= DEBUG_RINGBUF_SIZE
;
266 debug_ringbuf_ofs
= 0;
268 SAFE_FREE(debug_ringbuf
);
274 if (option
!= NULL
) {
275 cmp
= strncmp(option
, DEBUG_RINGBUF_SIZE_OPT
, optlen
);
277 debug_ringbuf_size
= (size_t)strtoull(
278 option
+ optlen
, NULL
, 10);
282 debug_ringbuf
= calloc(debug_ringbuf_size
, sizeof(char));
283 if (debug_ringbuf
== NULL
) {
288 static void debug_ringbuf_log(int msg_level
,
290 const char *msg_no_nl
)
292 size_t msglen
= strlen(msg
);
295 if (debug_ringbuf
== NULL
) {
299 /* Ensure the buffer is always \0 terminated */
300 allowed_size
= debug_ringbuf_size
- 1;
302 if (msglen
> allowed_size
) {
306 if ((debug_ringbuf_ofs
+ msglen
) < debug_ringbuf_ofs
) {
310 if ((debug_ringbuf_ofs
+ msglen
) > allowed_size
) {
311 debug_ringbuf_ofs
= 0;
314 memcpy(debug_ringbuf
+ debug_ringbuf_ofs
, msg
, msglen
);
315 debug_ringbuf_ofs
+= msglen
;
318 static struct debug_backend
{
322 void (*reload
)(bool enabled
, bool prev_enabled
,
323 const char *prog_name
, char *option
);
324 void (*log
)(int msg_level
, const char *msg
, const char *msg_no_nl
);
326 } debug_backends
[] = {
329 .log
= debug_file_log
,
334 .reload
= debug_syslog_reload
,
335 .log
= debug_syslog_log
,
339 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
342 .log
= debug_systemd_log
,
346 #ifdef HAVE_LTTNG_TRACEF
349 .log
= debug_lttng_log
,
356 .reload
= debug_gpfs_reload
,
357 .log
= debug_gpfs_log
,
362 .log
= debug_ringbuf_log
,
363 .reload
= debug_ringbuf_reload
,
367 static struct debug_backend
*debug_find_backend(const char *name
)
371 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
372 if (strcmp(name
, debug_backends
[i
].name
) == 0) {
373 return &debug_backends
[i
];
381 * parse "backend[:option][@loglevel]
383 static void debug_backend_parse_token(char *tok
)
385 char *backend_name_option
, *backend_name
,*backend_level
, *saveptr
;
386 char *backend_option
;
387 struct debug_backend
*b
;
390 * First parse into backend[:option] and loglevel
392 backend_name_option
= strtok_r(tok
, "@\0", &saveptr
);
393 if (backend_name_option
== NULL
) {
397 backend_level
= strtok_r(NULL
, "\0", &saveptr
);
400 * Now parse backend[:option]
402 backend_name
= strtok_r(backend_name_option
, ":\0", &saveptr
);
403 if (backend_name
== NULL
) {
407 backend_option
= strtok_r(NULL
, "\0", &saveptr
);
410 * Find and update backend
412 b
= debug_find_backend(backend_name
);
417 if (backend_level
== NULL
) {
418 b
->new_log_level
= MAX_DEBUG_LEVEL
;
420 b
->new_log_level
= atoi(backend_level
);
423 if (backend_option
!= NULL
) {
424 b
->option
= strdup(backend_option
);
425 if (b
->option
== NULL
) {
432 * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
433 * and enable/disable backends accordingly
435 static void debug_set_backends(const char *param
)
437 size_t str_len
= strlen(param
);
443 * initialize new_log_level to detect backends that have been
446 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
447 SAFE_FREE(debug_backends
[i
].option
);
448 debug_backends
[i
].new_log_level
= -1;
451 memcpy(str
, param
, str_len
+ 1);
453 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
458 while (tok
!= NULL
) {
459 debug_backend_parse_token(tok
);
460 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
464 * Let backends react to config changes
466 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
467 struct debug_backend
*b
= &debug_backends
[i
];
470 bool enabled
= b
->new_log_level
> -1;
471 bool previously_enabled
= b
->log_level
> -1;
473 b
->reload(enabled
, previously_enabled
, state
.prog_name
,
476 b
->log_level
= b
->new_log_level
;
480 static void debug_backends_log(const char *msg
, int msg_level
)
482 char msg_no_nl
[FORMAT_BUFR_SIZE
];
487 * Some backends already add an extra newline, so also provide
488 * a buffer without the newline character.
490 len
= MIN(strlen(msg
), FORMAT_BUFR_SIZE
- 1);
491 if ((len
> 0) && (msg
[len
- 1] == '\n')) {
495 memcpy(msg_no_nl
, msg
, len
);
496 msg_no_nl
[len
] = '\0';
498 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
499 if (msg_level
<= debug_backends
[i
].log_level
) {
500 debug_backends
[i
].log(msg_level
, msg
, msg_no_nl
);
505 /* -------------------------------------------------------------------------- **
506 * External variables.
510 used to check if the user specified a
511 logfile on the command line
513 bool override_logfile
;
515 static const char *default_classname_table
[] = {
518 [DBGC_PRINTDRIVERS
] = "printdrivers",
519 [DBGC_LANMAN
] = "lanman",
521 [DBGC_RPC_PARSE
] = "rpc_parse",
522 [DBGC_RPC_SRV
] = "rpc_srv",
523 [DBGC_RPC_CLI
] = "rpc_cli",
524 [DBGC_PASSDB
] = "passdb",
526 [DBGC_AUTH
] = "auth",
527 [DBGC_WINBIND
] = "winbind",
529 [DBGC_IDMAP
] = "idmap",
530 [DBGC_QUOTA
] = "quota",
531 [DBGC_ACLS
] = "acls",
532 [DBGC_LOCKING
] = "locking",
533 [DBGC_MSDFS
] = "msdfs",
534 [DBGC_DMAPI
] = "dmapi",
535 [DBGC_REGISTRY
] = "registry",
536 [DBGC_SCAVENGER
] = "scavenger",
539 [DBGC_TEVENT
] = "tevent",
540 [DBGC_AUTH_AUDIT
] = "auth_audit",
541 [DBGC_AUTH_AUDIT_JSON
] = "auth_json_audit",
542 [DBGC_KERBEROS
] = "kerberos",
543 [DBGC_DRS_REPL
] = "drs_repl",
544 [DBGC_SMB2
] = "smb2",
545 [DBGC_SMB2_CREDITS
] = "smb2_credits",
546 [DBGC_DSDB_AUDIT
] = "dsdb_audit",
547 [DBGC_DSDB_AUDIT_JSON
] = "dsdb_json_audit",
548 [DBGC_DSDB_PWD_AUDIT
] = "dsdb_password_audit",
549 [DBGC_DSDB_PWD_AUDIT_JSON
] = "dsdb_password_json_audit",
550 [DBGC_DSDB_TXN_AUDIT
] = "dsdb_transaction_audit",
551 [DBGC_DSDB_TXN_AUDIT_JSON
] = "dsdb_transaction_json_audit",
552 [DBGC_DSDB_GROUP_AUDIT
] = "dsdb_group_audit",
553 [DBGC_DSDB_GROUP_AUDIT_JSON
] = "dsdb_group_json_audit",
557 * This is to allow reading of DEBUGLEVEL_CLASS before the debug
558 * system has been initialized.
560 static const int debug_class_list_initial
[ARRAY_SIZE(default_classname_table
)];
562 static size_t debug_num_classes
= 0;
563 int *DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
566 /* -------------------------------------------------------------------------- **
567 * Internal variables.
569 * debug_count - Number of debug messages that have been output.
570 * Used to check log size.
572 * current_msg_level - Internal copy of the message debug level. Written by
573 * dbghdr() and read by Debug1().
575 * format_bufr - Used to format debug messages. The dbgtext() function
576 * prints debug messages to a string, and then passes the
577 * string to format_debug_text(), which uses format_bufr
578 * to build the formatted output.
580 * format_pos - Marks the first free byte of the format_bufr.
583 * log_overflow - When this variable is true, never attempt to check the
584 * size of the log. This is a hack, so that we can write
585 * a message using DEBUG, from open_logs() when we
586 * are unable to open a new log file for some reason.
589 static int debug_count
= 0;
590 static int current_msg_level
= 0;
591 static char format_bufr
[FORMAT_BUFR_SIZE
];
592 static size_t format_pos
= 0;
593 static bool log_overflow
= false;
596 * Define all the debug class selection names here. Names *MUST NOT* contain
597 * white space. There must be one name for each DBGC_<class name>, and they
598 * must be in the table in the order of DBGC_<class name>..
601 static char **classname_table
= NULL
;
604 /* -------------------------------------------------------------------------- **
608 static void debug_init(void);
610 /***************************************************************************
611 Free memory pointed to by global pointers.
612 ****************************************************************************/
614 void gfree_debugsyms(void)
618 TALLOC_FREE(classname_table
);
620 if ( DEBUGLEVEL_CLASS
!= debug_class_list_initial
) {
621 TALLOC_FREE( DEBUGLEVEL_CLASS
);
622 DEBUGLEVEL_CLASS
= discard_const_p(int, debug_class_list_initial
);
625 debug_num_classes
= 0;
627 state
.initialized
= false;
629 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
630 SAFE_FREE(debug_backends
[i
].option
);
634 /****************************************************************************
635 utility lists registered debug class names's
636 ****************************************************************************/
638 char *debug_list_class_names_and_levels(void)
642 /* prepare strings */
643 for (i
= 0; i
< debug_num_classes
; i
++) {
644 buf
= talloc_asprintf_append(buf
,
648 i
== (debug_num_classes
- 1) ? "\n" : " ");
656 /****************************************************************************
657 Utility to translate names to debug class index's (internal version).
658 ****************************************************************************/
660 static int debug_lookup_classname_int(const char* classname
)
664 if (!classname
) return -1;
666 for (i
=0; i
< debug_num_classes
; i
++) {
667 if (strcmp(classname
, classname_table
[i
])==0)
673 /****************************************************************************
674 Add a new debug class to the system.
675 ****************************************************************************/
677 int debug_add_class(const char *classname
)
681 char **new_name_list
;
687 /* check the init has yet been called */
690 ndx
= debug_lookup_classname_int(classname
);
693 ndx
= debug_num_classes
;
695 if (DEBUGLEVEL_CLASS
== debug_class_list_initial
) {
696 /* Initial loading... */
697 new_class_list
= NULL
;
699 new_class_list
= DEBUGLEVEL_CLASS
;
702 default_level
= DEBUGLEVEL_CLASS
[DBGC_ALL
];
704 new_class_list
= talloc_realloc(NULL
, new_class_list
, int, ndx
+ 1);
707 DEBUGLEVEL_CLASS
= new_class_list
;
709 DEBUGLEVEL_CLASS
[ndx
] = default_level
;
711 new_name_list
= talloc_realloc(NULL
, classname_table
, char *, ndx
+ 1);
714 classname_table
= new_name_list
;
716 classname_table
[ndx
] = talloc_strdup(classname_table
, classname
);
717 if (! classname_table
[ndx
])
720 debug_num_classes
= ndx
+ 1;
725 /****************************************************************************
726 Utility to translate names to debug class index's (public version).
727 ****************************************************************************/
729 static int debug_lookup_classname(const char *classname
)
733 if (!classname
|| !*classname
)
736 ndx
= debug_lookup_classname_int(classname
);
741 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
743 return debug_add_class(classname
);
746 /****************************************************************************
747 Dump the current registered debug levels.
748 ****************************************************************************/
750 static void debug_dump_status(int level
)
754 DEBUG(level
, ("INFO: Current debug levels:\n"));
755 for (q
= 0; q
< debug_num_classes
; q
++) {
756 const char *classname
= classname_table
[q
];
757 DEBUGADD(level
, (" %s: %d\n",
759 DEBUGLEVEL_CLASS
[q
]));
763 static bool debug_parse_param(char *param
)
767 char *saveptr
= NULL
;
770 class_name
= strtok_r(param
, ":", &saveptr
);
771 if (class_name
== NULL
) {
775 class_level
= strtok_r(NULL
, "\0", &saveptr
);
776 if (class_level
== NULL
) {
780 ndx
= debug_lookup_classname(class_name
);
785 DEBUGLEVEL_CLASS
[ndx
] = atoi(class_level
);
790 /****************************************************************************
791 Parse the debug levels from smb.conf. Example debug level string:
792 3 tdb:5 printdrivers:7
793 Note: the 1st param has no "name:" preceeding it.
794 ****************************************************************************/
796 bool debug_parse_levels(const char *params_str
)
798 size_t str_len
= strlen(params_str
);
806 memcpy(str
, params_str
, str_len
+1);
808 tok
= strtok_r(str
, LIST_SEP
, &saveptr
);
813 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
814 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
816 if (isdigit(tok
[0])) {
817 DEBUGLEVEL_CLASS
[DBGC_ALL
] = atoi(tok
);
818 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
820 DEBUGLEVEL_CLASS
[DBGC_ALL
] = 0;
823 /* Array is debug_num_classes long */
824 for (i
= DBGC_ALL
+1; i
< debug_num_classes
; i
++) {
825 DEBUGLEVEL_CLASS
[i
] = DEBUGLEVEL_CLASS
[DBGC_ALL
];
828 while (tok
!= NULL
) {
831 ok
= debug_parse_param(tok
);
833 DEBUG(0,("debug_parse_params: unrecognized debug "
834 "class name or format [%s]\n", tok
));
838 tok
= strtok_r(NULL
, LIST_SEP
, &saveptr
);
841 debug_dump_status(5);
846 /* setup for logging of talloc warnings */
847 static void talloc_log_fn(const char *msg
)
849 DEBUG(0,("%s", msg
));
852 void debug_setup_talloc_log(void)
854 talloc_set_log_fn(talloc_log_fn
);
858 /****************************************************************************
859 Init debugging (one time stuff)
860 ****************************************************************************/
862 static void debug_init(void)
866 if (state
.initialized
)
869 state
.initialized
= true;
871 debug_setup_talloc_log();
873 for (i
= 0; i
< ARRAY_SIZE(default_classname_table
); i
++) {
874 debug_add_class(default_classname_table
[i
]);
877 for (i
= 0; i
< ARRAY_SIZE(debug_backends
); i
++) {
878 debug_backends
[i
].log_level
= -1;
879 debug_backends
[i
].new_log_level
= -1;
883 void debug_set_settings(struct debug_settings
*settings
,
884 const char *logging_param
,
885 int syslog_level
, bool syslog_only
)
887 char fake_param
[256];
891 * This forces in some smb.conf derived values into the debug
892 * system. There are no pointers in this structure, so we can
893 * just structure-assign it in
895 state
.settings
= *settings
;
898 * If 'logging' is not set, create backend settings from
899 * deprecated 'syslog' and 'syslog only' parameters
901 if (logging_param
!= NULL
) {
902 len
= strlen(logging_param
);
906 snprintf(fake_param
, sizeof(fake_param
),
907 "syslog@%d", syslog_level
- 1);
909 snprintf(fake_param
, sizeof(fake_param
),
910 "syslog@%d file@%d", syslog_level
-1,
914 logging_param
= fake_param
;
917 debug_set_backends(logging_param
);
921 control the name of the logfile and whether logging will be to stdout, stderr
922 or a file, and set up syslog
924 new_log indicates the destination for the debug log (an enum in
925 order of precedence - once set to DEBUG_FILE, it is not possible to
926 reset to DEBUG_STDOUT for example. This makes it easy to override
927 for debug to stderr on the command line, as the smb.conf cannot
928 reset it back to file-based logging
930 void setup_logging(const char *prog_name
, enum debug_logtype new_logtype
)
933 if (state
.logtype
< new_logtype
) {
934 state
.logtype
= new_logtype
;
937 const char *p
= strrchr(prog_name
, '/');
943 state
.prog_name
= prog_name
;
945 reopen_logs_internal();
948 /***************************************************************************
949 Set the logfile name.
950 **************************************************************************/
952 void debug_set_logfile(const char *name
)
954 if (name
== NULL
|| *name
== 0) {
955 /* this copes with calls when smb.conf is not loaded yet */
958 TALLOC_FREE(state
.debugf
);
959 state
.debugf
= talloc_strdup(NULL
, name
);
962 static void debug_close_fd(int fd
)
969 bool debug_get_output_is_stderr(void)
971 return (state
.logtype
== DEBUG_DEFAULT_STDERR
) || (state
.logtype
== DEBUG_STDERR
);
974 bool debug_get_output_is_stdout(void)
976 return (state
.logtype
== DEBUG_DEFAULT_STDOUT
) || (state
.logtype
== DEBUG_STDOUT
);
979 void debug_set_callback(void *private_ptr
, debug_callback_fn fn
)
983 state
.logtype
= DEBUG_CALLBACK
;
984 state
.callback_private
= private_ptr
;
987 state
.logtype
= DEBUG_DEFAULT_STDERR
;
988 state
.callback_private
= NULL
;
989 state
.callback
= NULL
;
993 static void debug_callback_log(const char *msg
, int msg_level
)
995 size_t msg_len
= strlen(msg
);
996 char msg_copy
[msg_len
];
998 if ((msg_len
> 0) && (msg
[msg_len
-1] == '\n')) {
999 memcpy(msg_copy
, msg
, msg_len
-1);
1000 msg_copy
[msg_len
-1] = '\0';
1004 state
.callback(state
.callback_private
, msg_level
, msg
);
1007 /**************************************************************************
1008 reopen the log files
1009 note that we now do this unconditionally
1010 We attempt to open the new debug fp before closing the old. This means
1011 if we run out of fd's we just keep using the old fd rather than aborting.
1012 Fix from dgibson@linuxcare.com.
1013 **************************************************************************/
1016 reopen the log file (usually called because the log file name might have changed)
1018 bool reopen_logs_internal(void)
1025 if (state
.reopening_logs
) {
1029 /* Now clear the SIGHUP induced flag */
1030 state
.schedule_reopen_logs
= false;
1032 switch (state
.logtype
) {
1033 case DEBUG_CALLBACK
:
1036 case DEBUG_DEFAULT_STDOUT
:
1037 debug_close_fd(state
.fd
);
1041 case DEBUG_DEFAULT_STDERR
:
1043 debug_close_fd(state
.fd
);
1051 oldumask
= umask( 022 );
1053 if (!state
.debugf
) {
1057 state
.reopening_logs
= true;
1059 new_fd
= open( state
.debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
1062 log_overflow
= true;
1063 DEBUG(0, ("Unable to open new log file '%s': %s\n", state
.debugf
, strerror(errno
)));
1064 log_overflow
= false;
1067 smb_set_close_on_exec(new_fd
);
1070 debug_close_fd(old_fd
);
1073 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1074 * to fix problem where smbd's that generate less
1075 * than 100 messages keep growing the log.
1077 force_check_log_size();
1078 (void)umask(oldumask
);
1080 /* Take over stderr to catch output into logs */
1082 if (dup2(state
.fd
, 2) == -1) {
1083 /* Close stderr too, if dup2 can't point it -
1084 at the logfile. There really isn't much
1085 that can be done on such a fundamental
1091 state
.reopening_logs
= false;
1096 /**************************************************************************
1097 Force a check of the log size.
1098 ***************************************************************************/
1100 void force_check_log_size( void )
1105 _PUBLIC_
void debug_schedule_reopen_logs(void)
1107 state
.schedule_reopen_logs
= true;
1111 /***************************************************************************
1112 Check to see if there is any need to check if the logfile has grown too big.
1113 **************************************************************************/
1115 bool need_to_check_log_size( void )
1119 if( debug_count
< 100)
1122 maxlog
= state
.settings
.max_log_size
* 1024;
1123 if ( state
.fd
<=2 || maxlog
<= 0 ) {
1130 /**************************************************************************
1131 Check to see if the log has grown to be too big.
1132 **************************************************************************/
1134 void check_log_size( void )
1140 * We need to be root to check/change log-file, skip this and let the main
1141 * loop check do a new check as root.
1144 #if _SAMBA_BUILD_ == 3
1145 if (geteuid() != sec_initial_uid())
1150 /* We don't check sec_initial_uid() here as it isn't
1151 * available in common code and we don't generally
1152 * want to rotate and the possibly lose logs in
1153 * make test or the build farm */
1157 if(log_overflow
|| (!state
.schedule_reopen_logs
&& !need_to_check_log_size())) {
1161 maxlog
= state
.settings
.max_log_size
* 1024;
1163 if (state
.schedule_reopen_logs
) {
1164 (void)reopen_logs_internal();
1167 if (maxlog
&& (fstat(state
.fd
, &st
) == 0
1168 && st
.st_size
> maxlog
)) {
1169 (void)reopen_logs_internal();
1170 if (state
.fd
> 2 && (fstat(state
.fd
, &st
) == 0
1171 && st
.st_size
> maxlog
)) {
1172 char name
[strlen(state
.debugf
) + 5];
1174 snprintf(name
, sizeof(name
), "%s.old", state
.debugf
);
1176 (void)rename(state
.debugf
, name
);
1178 if (!reopen_logs_internal()) {
1179 /* We failed to reopen a log - continue using the old name. */
1180 (void)rename(name
, state
.debugf
);
1186 * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
1189 if (state
.fd
<= 0) {
1190 /* This code should only be reached in very strange
1191 * circumstances. If we merely fail to open the new log we
1192 * should stick with the old one. ergo this should only be
1193 * reached when opening the logs for the first time: at
1194 * startup or when the log level is increased from zero.
1197 int fd
= open( "/dev/console", O_WRONLY
, 0);
1199 smb_set_close_on_exec(fd
);
1201 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
1205 * We cannot continue without a debug file handle.
1213 /*************************************************************************
1214 Write an debug message on the debugfile.
1215 This is called by dbghdr() and format_debug_text().
1216 ************************************************************************/
1218 static void Debug1(const char *msg
)
1220 int old_errno
= errno
;
1224 switch(state
.logtype
) {
1225 case DEBUG_CALLBACK
:
1226 debug_callback_log(msg
, current_msg_level
);
1230 case DEBUG_DEFAULT_STDOUT
:
1231 case DEBUG_DEFAULT_STDERR
:
1235 ret
= write(state
.fd
, msg
, strlen(msg
));
1236 } while (ret
== -1 && errno
== EINTR
);
1240 debug_backends_log(msg
, current_msg_level
);
1247 /**************************************************************************
1248 Print the buffer content via Debug1(), then reset the buffer.
1251 ****************************************************************************/
1253 static void bufr_print( void )
1255 format_bufr
[format_pos
] = '\0';
1256 (void)Debug1(format_bufr
);
1260 /***************************************************************************
1261 Format the debug message text.
1263 Input: msg - Text to be added to the "current" debug message text.
1267 Notes: The purpose of this is two-fold. First, each call to syslog()
1268 (used by Debug1(), see above) generates a new line of syslog
1269 output. This is fixed by storing the partial lines until the
1270 newline character is encountered. Second, printing the debug
1271 message lines when a newline is encountered allows us to add
1272 spaces, thus indenting the body of the message and making it
1274 **************************************************************************/
1276 static void format_debug_text( const char *msg
)
1279 bool timestamp
= (state
.logtype
== DEBUG_FILE
&& (state
.settings
.timestamp_logs
));
1283 for( i
= 0; msg
[i
]; i
++ ) {
1284 /* Indent two spaces at each new line. */
1285 if(timestamp
&& 0 == format_pos
) {
1286 format_bufr
[0] = format_bufr
[1] = ' ';
1290 /* If there's room, copy the character to the format buffer. */
1291 if (format_pos
< FORMAT_BUFR_SIZE
- 1)
1292 format_bufr
[format_pos
++] = msg
[i
];
1294 /* If a newline is encountered, print & restart. */
1295 if( '\n' == msg
[i
] )
1298 /* If the buffer is full dump it out, reset it, and put out a line
1299 * continuation indicator.
1301 if (format_pos
>= FORMAT_BUFR_SIZE
- 1) {
1303 (void)Debug1( " +>\n" );
1307 /* Just to be safe... */
1308 format_bufr
[format_pos
] = '\0';
1311 /***************************************************************************
1312 Flush debug output, including the format buffer content.
1316 ***************************************************************************/
1318 void dbgflush( void )
1323 /***************************************************************************
1324 Print a Debug Header.
1326 Input: level - Debug level of the message (not the system-wide debug
1328 cls - Debuglevel class of the calling module.
1329 location - Pointer to a string containing the name of the file
1330 from which this function was called, or an empty string
1331 if the __FILE__ macro is not implemented.
1332 func - Pointer to a string containing the name of the function
1333 from which this function was called, or an empty string
1334 if the __FUNCTION__ macro is not implemented.
1336 Output: Always true. This makes it easy to fudge a call to dbghdr()
1337 in a macro, since the function can be called as part of a test.
1338 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1340 Notes: This function takes care of setting current_msg_level.
1342 ****************************************************************************/
1344 bool dbghdrclass(int level
, int cls
, const char *location
, const char *func
)
1346 /* Ensure we don't lose any real errno value. */
1347 int old_errno
= errno
;
1348 bool verbose
= false;
1349 char header_str
[300];
1352 struct timeval_buf tvbuf
;
1355 /* This is a fudge. If there is stuff sitting in the format_bufr, then
1356 * the *right* thing to do is to call
1357 * format_debug_text( "\n" );
1358 * to write the remainder, and then proceed with the new header.
1359 * Unfortunately, there are several places in the code at which
1360 * the DEBUG() macro is used to build partial lines. That in mind,
1361 * we'll work under the assumption that an incomplete line indicates
1362 * that a new header is *not* desired.
1367 /* Set current_msg_level. */
1368 current_msg_level
= level
;
1370 /* Don't print a header if we're logging to stdout. */
1371 if ( state
.logtype
!= DEBUG_FILE
) {
1375 /* Print the header if timestamps are turned on. If parameters are
1376 * not yet loaded, then default to timestamps on.
1378 if (!(state
.settings
.timestamp_logs
||
1379 state
.settings
.debug_prefix_timestamp
)) {
1384 timeval_str_buf(&tv
, false, state
.settings
.debug_hires_timestamp
,
1387 hs_len
= snprintf(header_str
, sizeof(header_str
), "[%s, %2d",
1389 if (hs_len
>= sizeof(header_str
)) {
1393 if (unlikely(DEBUGLEVEL_CLASS
[ cls
] >= 10)) {
1397 if (verbose
|| state
.settings
.debug_pid
) {
1399 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
1400 ", pid=%u", (unsigned int)getpid());
1401 if (hs_len
>= sizeof(header_str
)) {
1406 if (verbose
|| state
.settings
.debug_uid
) {
1408 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
1409 ", effective(%u, %u), real(%u, %u)",
1410 (unsigned int)geteuid(), (unsigned int)getegid(),
1411 (unsigned int)getuid(), (unsigned int)getgid());
1412 if (hs_len
>= sizeof(header_str
)) {
1417 if ((verbose
|| state
.settings
.debug_class
)
1418 && (cls
!= DBGC_ALL
)) {
1420 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
1421 ", class=%s", classname_table
[cls
]);
1422 if (hs_len
>= sizeof(header_str
)) {
1428 * No +=, see man man strlcat
1430 hs_len
= strlcat(header_str
, "] ", sizeof(header_str
));
1431 if (hs_len
>= sizeof(header_str
)) {
1435 if (!state
.settings
.debug_prefix_timestamp
) {
1437 header_str
+ hs_len
, sizeof(header_str
) - hs_len
,
1438 "%s(%s)\n", location
, func
);
1439 if (hs_len
>= sizeof(header_str
)) {
1445 (void)Debug1(header_str
);
1451 /***************************************************************************
1452 Add text to the body of the "current" debug message via the format buffer.
1454 Input: format_str - Format string, as used in printf(), et. al.
1455 ... - Variable argument list.
1457 ..or.. va_alist - Old style variable parameter list starting point.
1459 Output: Always true. See dbghdr() for more info, though this is not
1460 likely to be used in the same way.
1462 ***************************************************************************/
1464 static inline bool __dbgtext_va(const char *format_str
, va_list ap
) PRINTF_ATTRIBUTE(1,0);
1465 static inline bool __dbgtext_va(const char *format_str
, va_list ap
)
1467 char *msgbuf
= NULL
;
1471 res
= vasprintf(&msgbuf
, format_str
, ap
);
1473 format_debug_text(msgbuf
);
1481 bool dbgtext_va(const char *format_str
, va_list ap
)
1483 return __dbgtext_va(format_str
, ap
);
1486 bool dbgtext(const char *format_str
, ... )
1491 va_start(ap
, format_str
);
1492 ret
= __dbgtext_va(format_str
, ap
);