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/>.
23
#include "system/filesys.h"
24
#include "system/syslog.h"
25
#include "lib/util/time.h"
27
/* define what facility to use for syslog */
28
#ifndef SYSLOG_FACILITY
29
#define SYSLOG_FACILITY LOG_DAEMON
32
/* -------------------------------------------------------------------------- **
35
* FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
36
* format_bufr[FORMAT_BUFR_MAX] should always be reserved
37
* for a terminating null byte.
40
#define FORMAT_BUFR_SIZE 1024
41
#define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
43
/* -------------------------------------------------------------------------- **
44
* This module implements Samba's debugging utility.
46
* The syntax of a debugging log file is represented as:
48
* <debugfile> :== { <debugmsg> }
50
* <debugmsg> :== <debughdr> '\n' <debugtext>
52
* <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
54
* <debugtext> :== { <debugline> }
56
* <debugline> :== TEXT '\n'
58
* TEXT is a string of characters excluding the newline character.
59
* LEVEL is the DEBUG level of the message (an integer in the range 0..10).
60
* TIME is a timestamp.
61
* FILENAME is the name of the file from which the debug message was generated.
62
* FUNCTION is the function from which the debug message was generated.
64
* Basically, what that all means is:
66
* - A debugging log file is made up of debug messages.
68
* - Each debug message is made up of a header and text. The header is
69
* separated from the text by a newline.
71
* - The header begins with the timestamp and debug level of the message
72
* enclosed in brackets. The filename and function from which the
73
* message was generated may follow. The filename is terminated by a
74
* colon, and the function name is terminated by parenthesis.
76
* - The message text is made up of zero or more lines, each terminated by
80
/* state variables for the debug system */
83
int fd; /* The log file handle */
84
enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
85
const char *prog_name;
87
bool schedule_reopen_logs;
89
struct debug_settings settings;
93
.timestamp_logs = true
97
/* -------------------------------------------------------------------------- **
100
* debugf - Debug file name.
101
* DEBUGLEVEL - System-wide debug message limit. Messages with message-
102
* levels higher than DEBUGLEVEL will not be processed.
106
used to check if the user specified a
107
logfile on the command line
109
bool override_logfile;
112
* This is to allow reading of DEBUGLEVEL_CLASS before the debug
113
* system has been initialized.
115
static const int debug_class_list_initial[DBGC_MAX_FIXED + 1];
117
static int debug_num_classes = 0;
118
int *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
121
/* -------------------------------------------------------------------------- **
122
* Internal variables.
124
* debug_count - Number of debug messages that have been output.
125
* Used to check log size.
127
* syslog_level - Internal copy of the message debug level. Written by
128
* dbghdr() and read by Debug1().
130
* format_bufr - Used to format debug messages. The dbgtext() function
131
* prints debug messages to a string, and then passes the
132
* string to format_debug_text(), which uses format_bufr
133
* to build the formatted output.
135
* format_pos - Marks the first free byte of the format_bufr.
138
* log_overflow - When this variable is true, never attempt to check the
139
* size of the log. This is a hack, so that we can write
140
* a message using DEBUG, from open_logs() when we
141
* are unable to open a new log file for some reason.
144
static int debug_count = 0;
146
static int syslog_level = 0;
148
static char *format_bufr = NULL;
149
static size_t format_pos = 0;
150
static bool log_overflow = false;
153
* Define all the debug class selection names here. Names *MUST NOT* contain
154
* white space. There must be one name for each DBGC_<class name>, and they
155
* must be in the table in the order of DBGC_<class name>..
157
static const char *default_classname_table[] = {
158
"all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
159
"tdb", /* DBGC_TDB */
160
"printdrivers", /* DBGC_PRINTDRIVERS */
161
"lanman", /* DBGC_LANMAN */
162
"smb", /* DBGC_SMB */
163
"rpc_parse", /* DBGC_RPC_PARSE */
164
"rpc_srv", /* DBGC_RPC_SRV */
165
"rpc_cli", /* DBGC_RPC_CLI */
166
"passdb", /* DBGC_PASSDB */
167
"sam", /* DBGC_SAM */
168
"auth", /* DBGC_AUTH */
169
"winbind", /* DBGC_WINBIND */
170
"vfs", /* DBGC_VFS */
171
"idmap", /* DBGC_IDMAP */
172
"quota", /* DBGC_QUOTA */
173
"acls", /* DBGC_ACLS */
174
"locking", /* DBGC_LOCKING */
175
"msdfs", /* DBGC_MSDFS */
176
"dmapi", /* DBGC_DMAPI */
177
"registry", /* DBGC_REGISTRY */
181
static char **classname_table = NULL;
184
/* -------------------------------------------------------------------------- **
188
static void debug_init(void);
190
/***************************************************************************
191
Free memory pointed to by global pointers.
192
****************************************************************************/
194
void gfree_debugsyms(void)
196
TALLOC_FREE(classname_table);
198
if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
199
TALLOC_FREE( DEBUGLEVEL_CLASS );
200
DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
203
TALLOC_FREE(format_bufr);
205
debug_num_classes = DBGC_MAX_FIXED;
207
state.initialized = false;
210
/****************************************************************************
211
utility lists registered debug class names's
212
****************************************************************************/
214
char *debug_list_class_names_and_levels(void)
218
/* prepare strings */
219
for (i = 0; i < debug_num_classes; i++) {
220
buf = talloc_asprintf_append(buf,
224
i == (debug_num_classes - 1) ? "\n" : " ");
232
/****************************************************************************
233
Utility to translate names to debug class index's (internal version).
234
****************************************************************************/
236
static int debug_lookup_classname_int(const char* classname)
240
if (!classname) return -1;
242
for (i=0; i < debug_num_classes; i++) {
243
if (strcmp(classname, classname_table[i])==0)
249
/****************************************************************************
250
Add a new debug class to the system.
251
****************************************************************************/
253
int debug_add_class(const char *classname)
257
char **new_name_list;
263
/* check the init has yet been called */
266
ndx = debug_lookup_classname_int(classname);
269
ndx = debug_num_classes;
271
if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
272
/* Initial loading... */
273
new_class_list = NULL;
275
new_class_list = DEBUGLEVEL_CLASS;
278
default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
280
new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
283
DEBUGLEVEL_CLASS = new_class_list;
285
DEBUGLEVEL_CLASS[ndx] = default_level;
287
new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
290
classname_table = new_name_list;
292
classname_table[ndx] = talloc_strdup(classname_table, classname);
293
if (! classname_table[ndx])
296
debug_num_classes = ndx + 1;
301
/****************************************************************************
302
Utility to translate names to debug class index's (public version).
303
****************************************************************************/
305
int debug_lookup_classname(const char *classname)
309
if (!classname || !*classname)
312
ndx = debug_lookup_classname_int(classname);
317
DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
319
return debug_add_class(classname);
322
/****************************************************************************
323
Dump the current registered debug levels.
324
****************************************************************************/
326
static void debug_dump_status(int level)
330
DEBUG(level, ("INFO: Current debug levels:\n"));
331
for (q = 0; q < debug_num_classes; q++) {
332
const char *classname = classname_table[q];
333
DEBUGADD(level, (" %s: %d\n",
335
DEBUGLEVEL_CLASS[q]));
339
/****************************************************************************
340
parse the debug levels from smbcontrol. Example debug level parameter:
342
****************************************************************************/
344
static bool debug_parse_params(char **params)
353
/* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
354
* v.s. "all:10", this is the traditional way to set DEBUGLEVEL
356
if (isdigit((int)params[0][0])) {
357
DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
358
i = 1; /* start processing at the next params */
360
DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
361
i = 0; /* DBGC_ALL not specified OR class name was included */
364
/* Array is debug_num_classes long */
365
for (ndx = DBGC_ALL; ndx < debug_num_classes; ndx++) {
366
DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL_CLASS[DBGC_ALL];
369
/* Fill in new debug class levels */
370
for (; i < debug_num_classes && params[i]; i++) {
372
if ((class_name = strtok_r(params[i],":", &saveptr)) &&
373
(class_level = strtok_r(NULL, "\0", &saveptr)) &&
374
((ndx = debug_lookup_classname(class_name)) != -1)) {
375
DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
377
DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
385
/****************************************************************************
386
Parse the debug levels from smb.conf. Example debug level string:
387
3 tdb:5 printdrivers:7
388
Note: the 1st param has no "name:" preceeding it.
389
****************************************************************************/
391
bool debug_parse_levels(const char *params_str)
398
params = str_list_make(NULL, params_str, NULL);
400
if (debug_parse_params(params)) {
401
debug_dump_status(5);
410
/* setup for logging of talloc warnings */
411
static void talloc_log_fn(const char *msg)
413
DEBUG(0,("%s", msg));
416
void debug_setup_talloc_log(void)
418
talloc_set_log_fn(talloc_log_fn);
422
/****************************************************************************
423
Init debugging (one time stuff)
424
****************************************************************************/
426
static void debug_init(void)
430
if (state.initialized)
433
state.initialized = true;
435
debug_setup_talloc_log();
437
for(p = default_classname_table; *p; p++) {
440
format_bufr = talloc_array(NULL, char, FORMAT_BUFR_SIZE);
442
smb_panic("debug_init: unable to create buffer");
446
/* This forces in some smb.conf derived values into the debug system.
447
* There are no pointers in this structure, so we can just
448
* structure-assign it in */
449
void debug_set_settings(struct debug_settings *settings)
451
state.settings = *settings;
455
control the name of the logfile and whether logging will be to stdout, stderr
456
or a file, and set up syslog
458
new_log indicates the destination for the debug log (an enum in
459
order of precedence - once set to DEBUG_FILE, it is not possible to
460
reset to DEBUG_STDOUT for example. This makes it easy to override
461
for debug to stderr on the command line, as the smb.conf cannot
462
reset it back to file-based logging
464
void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
467
if (state.logtype < new_logtype) {
468
state.logtype = new_logtype;
471
state.prog_name = prog_name;
473
reopen_logs_internal();
475
if (state.logtype == DEBUG_FILE) {
477
const char *p = strrchr_m( prog_name,'/' );
481
openlog( prog_name, LOG_PID, SYSLOG_FACILITY );
483
/* for old systems that have no facility codes. */
484
openlog( prog_name, LOG_PID );
490
/***************************************************************************
491
Set the logfile name.
492
**************************************************************************/
494
void debug_set_logfile(const char *name)
496
if (name == NULL || *name == 0) {
497
/* this copes with calls when smb.conf is not loaded yet */
500
TALLOC_FREE(state.debugf);
501
state.debugf = talloc_strdup(NULL, name);
504
static void debug_close_fd(int fd)
511
bool debug_get_output_is_stderr(void)
513
return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
516
/**************************************************************************
518
note that we now do this unconditionally
519
We attempt to open the new debug fp before closing the old. This means
520
if we run out of fd's we just keep using the old fd rather than aborting.
521
Fix from dgibson@linuxcare.com.
522
**************************************************************************/
525
reopen the log file (usually called because the log file name might have changed)
527
bool reopen_logs_internal(void)
535
if (state.reopening_logs) {
539
/* Now clear the SIGHUP induced flag */
540
state.schedule_reopen_logs = false;
542
switch (state.logtype) {
544
debug_close_fd(state.fd);
548
case DEBUG_DEFAULT_STDERR:
550
debug_close_fd(state.fd);
558
oldumask = umask( 022 );
560
fname = state.debugf;
565
state.reopening_logs = true;
567
new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
571
DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
572
log_overflow = false;
577
debug_close_fd(old_fd);
580
/* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
581
* to fix problem where smbd's that generate less
582
* than 100 messages keep growing the log.
584
force_check_log_size();
585
(void)umask(oldumask);
587
/* Take over stderr to catch output into logs */
588
if (state.fd > 0 && dup2(state.fd, 2) == -1) {
589
close_low_fds(true); /* Close stderr too, if dup2 can't point it
593
state.reopening_logs = false;
598
/**************************************************************************
599
Force a check of the log size.
600
***************************************************************************/
602
void force_check_log_size( void )
607
_PUBLIC_ void debug_schedule_reopen_logs(void)
609
state.schedule_reopen_logs = true;
613
/***************************************************************************
614
Check to see if there is any need to check if the logfile has grown too big.
615
**************************************************************************/
617
bool need_to_check_log_size( void )
621
if( debug_count < 100)
624
maxlog = state.settings.max_log_size * 1024;
625
if ( state.fd <=2 || maxlog <= 0 ) {
632
/**************************************************************************
633
Check to see if the log has grown to be too big.
634
**************************************************************************/
636
void check_log_size( void )
642
* We need to be root to check/change log-file, skip this and let the main
643
* loop check do a new check as root.
646
if( geteuid() != 0) {
647
/* We don't check sec_initial_uid() here as it isn't
648
* available in common code and we don't generally
649
* want to rotate and the possibly lose logs in
650
* make test or the build farm */
654
if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
658
maxlog = state.settings.max_log_size * 1024;
660
if (state.schedule_reopen_logs ||
661
(fstat(state.fd, &st) == 0
662
&& st.st_size > maxlog )) {
663
(void)reopen_logs_internal();
664
if (state.fd > 0 && fstat(state.fd, &st) == 0) {
665
if (st.st_size > maxlog) {
668
if (asprintf(&name, "%s.old", state.debugf ) < 0) {
671
(void)rename(state.debugf, name);
673
if (!reopen_logs_internal()) {
674
/* We failed to reopen a log - continue using the old name. */
675
(void)rename(name, state.debugf);
683
* Here's where we need to panic if state.fd == 0 or -1 (invalid values)
687
/* This code should only be reached in very strange
688
* circumstances. If we merely fail to open the new log we
689
* should stick with the old one. ergo this should only be
690
* reached when opening the logs for the first time: at
691
* startup or when the log level is increased from zero.
694
int fd = open( "/dev/console", O_WRONLY, 0);
697
DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
701
* We cannot continue without a debug file handle.
709
/*************************************************************************
710
Write an debug message on the debugfile.
711
This is called by dbghdr() and format_debug_text().
712
************************************************************************/
714
int Debug1( const char *format_str, ... )
717
int old_errno = errno;
721
if ( state.logtype != DEBUG_FILE ) {
722
va_start( ap, format_str );
724
(void)vdprintf( state.fd, format_str, ap );
731
if( !state.settings.syslog_only)
734
if( state.fd <= 0 ) {
735
mode_t oldumask = umask( 022 );
736
int fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
737
(void)umask( oldumask );
747
if( syslog_level < state.settings.syslog ) {
748
/* map debug levels to syslog() priorities
749
* note that not all DEBUG(0, ...) calls are
750
* necessarily errors */
751
static const int priority_map[4] = {
761
if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
762
priority = LOG_DEBUG;
764
priority = priority_map[syslog_level];
767
* Specify the facility to interoperate with other syslog
768
* callers (vfs_full_audit for example).
770
priority |= SYSLOG_FACILITY;
772
va_start(ap, format_str);
773
ret = vasprintf(&msgbuf, format_str, ap);
777
syslog(priority, "%s", msgbuf);
786
if( !state.settings.syslog_only)
789
va_start( ap, format_str );
791
(void)vdprintf( state.fd, format_str, ap );
802
/**************************************************************************
803
Print the buffer content via Debug1(), then reset the buffer.
806
****************************************************************************/
808
static void bufr_print( void )
810
format_bufr[format_pos] = '\0';
811
(void)Debug1( "%s", format_bufr );
815
/***************************************************************************
816
Format the debug message text.
818
Input: msg - Text to be added to the "current" debug message text.
822
Notes: The purpose of this is two-fold. First, each call to syslog()
823
(used by Debug1(), see above) generates a new line of syslog
824
output. This is fixed by storing the partial lines until the
825
newline character is encountered. Second, printing the debug
826
message lines when a newline is encountered allows us to add
827
spaces, thus indenting the body of the message and making it
829
**************************************************************************/
831
static void format_debug_text( const char *msg )
834
bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
840
for( i = 0; msg[i]; i++ ) {
841
/* Indent two spaces at each new line. */
842
if(timestamp && 0 == format_pos) {
843
format_bufr[0] = format_bufr[1] = ' ';
847
/* If there's room, copy the character to the format buffer. */
848
if( format_pos < FORMAT_BUFR_MAX )
849
format_bufr[format_pos++] = msg[i];
851
/* If a newline is encountered, print & restart. */
855
/* If the buffer is full dump it out, reset it, and put out a line
856
* continuation indicator.
858
if( format_pos >= FORMAT_BUFR_MAX ) {
860
(void)Debug1( " +>\n" );
864
/* Just to be safe... */
865
format_bufr[format_pos] = '\0';
868
/***************************************************************************
869
Flush debug output, including the format buffer content.
873
***************************************************************************/
875
void dbgflush( void )
880
/***************************************************************************
881
Print a Debug Header.
883
Input: level - Debug level of the message (not the system-wide debug
885
cls - Debuglevel class of the calling module.
886
file - Pointer to a string containing the name of the file
887
from which this function was called, or an empty string
888
if the __FILE__ macro is not implemented.
889
func - Pointer to a string containing the name of the function
890
from which this function was called, or an empty string
891
if the __FUNCTION__ macro is not implemented.
892
line - line number of the call to dbghdr, assuming __LINE__
895
Output: Always true. This makes it easy to fudge a call to dbghdr()
896
in a macro, since the function can be called as part of a test.
897
Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
899
Notes: This function takes care of setting syslog_level.
901
****************************************************************************/
903
bool dbghdrclass(int level, int cls, const char *location, const char *func)
905
/* Ensure we don't lose any real errno value. */
906
int old_errno = errno;
909
/* This is a fudge. If there is stuff sitting in the format_bufr, then
910
* the *right* thing to do is to call
911
* format_debug_text( "\n" );
912
* to write the remainder, and then proceed with the new header.
913
* Unfortunately, there are several places in the code at which
914
* the DEBUG() macro is used to build partial lines. That in mind,
915
* we'll work under the assumption that an incomplete line indicates
916
* that a new header is *not* desired.
922
/* Set syslog_level. */
923
syslog_level = level;
926
/* Don't print a header if we're logging to stdout. */
927
if ( state.logtype != DEBUG_FILE ) {
931
/* Print the header if timestamps are turned on. If parameters are
932
* not yet loaded, then default to timestamps on.
934
if( state.settings.timestamp_logs || state.settings.debug_prefix_timestamp) {
935
char header_str[200];
937
header_str[0] = '\0';
939
if( state.settings.debug_pid)
940
slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)getpid());
942
if( state.settings.debug_uid) {
943
size_t hs_len = strlen(header_str);
944
slprintf(header_str + hs_len,
945
sizeof(header_str) - 1 - hs_len,
946
", effective(%u, %u), real(%u, %u)",
947
(unsigned int)geteuid(), (unsigned int)getegid(),
948
(unsigned int)getuid(), (unsigned int)getgid());
951
if (state.settings.debug_class && (cls != DBGC_ALL)) {
952
size_t hs_len = strlen(header_str);
953
slprintf(header_str + hs_len,
954
sizeof(header_str) -1 - hs_len,
956
default_classname_table[cls]);
959
/* Print it all out at once to prevent split syslog output. */
960
if( state.settings.debug_prefix_timestamp ) {
961
char *time_str = current_timestring(NULL,
962
state.settings.debug_hires_timestamp);
963
(void)Debug1( "[%s, %2d%s] ",
966
talloc_free(time_str);
968
char *time_str = current_timestring(NULL,
969
state.settings.debug_hires_timestamp);
970
(void)Debug1( "[%s, %2d%s] %s(%s)\n",
972
level, header_str, location, func );
973
talloc_free(time_str);
981
/***************************************************************************
982
Add text to the body of the "current" debug message via the format buffer.
984
Input: format_str - Format string, as used in printf(), et. al.
985
... - Variable argument list.
987
..or.. va_alist - Old style variable parameter list starting point.
989
Output: Always true. See dbghdr() for more info, though this is not
990
likely to be used in the same way.
992
***************************************************************************/
994
bool dbgtext( const char *format_str, ... )
1001
va_start(ap, format_str);
1002
res = vasprintf(&msgbuf, format_str, ap);
1006
format_debug_text(msgbuf);
1015
/* the registered mutex handlers */
1018
struct debug_ops ops;
1022
log suspicious usage - print comments and backtrace
1024
_PUBLIC_ void log_suspicious_usage(const char *from, const char *info)
1026
if (!debug_handlers.ops.log_suspicious_usage) return;
1028
debug_handlers.ops.log_suspicious_usage(from, info);
1033
print suspicious usage - print comments and backtrace
1035
_PUBLIC_ void print_suspicious_usage(const char* from, const char* info)
1037
if (!debug_handlers.ops.print_suspicious_usage) return;
1039
debug_handlers.ops.print_suspicious_usage(from, info);
1042
_PUBLIC_ uint32_t get_task_id(void)
1044
if (debug_handlers.ops.get_task_id) {
1045
return debug_handlers.ops.get_task_id();
1050
_PUBLIC_ void log_task_id(void)
1052
if (!debug_handlers.ops.log_task_id) return;
1054
if (!reopen_logs_internal()) return;
1056
debug_handlers.ops.log_task_id(state.fd);
1060
register a set of debug handlers.
1062
_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops)
1064
debug_handlers.name = name;
1065
debug_handlers.ops = *ops;
added
removed
.pc/fix-samba-printer-browsing.patch/lib/util/debug.c
