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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 /* -------------------------------------------------------------------------- **
28 * FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
29 * format_bufr[FORMAT_BUFR_MAX] should always be reserved
30 * for a terminating null byte.
33 #define FORMAT_BUFR_MAX ( sizeof( format_bufr ) - 1 )
35 /* -------------------------------------------------------------------------- **
36 * This module implements Samba's debugging utility.
38 * The syntax of a debugging log file is represented as:
40 * <debugfile> :== { <debugmsg> }
42 * <debugmsg> :== <debughdr> '\n' <debugtext>
44 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
46 * <debugtext> :== { <debugline> }
48 * <debugline> :== TEXT '\n'
50 * TEXT is a string of characters excluding the newline character.
51 * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
52 * TIME is a timestamp.
53 * FILENAME is the name of the file from which the debug message was generated.
54 * FUNCTION is the function from which the debug message was generated.
56 * Basically, what that all means is:
58 * - A debugging log file is made up of debug messages.
60 * - Each debug message is made up of a header and text. The header is
61 * separated from the text by a newline.
63 * - The header begins with the timestamp and debug level of the message
64 * enclosed in brackets. The filename and function from which the
65 * message was generated may follow. The filename is terminated by a
66 * colon, and the function name is terminated by parenthesis.
68 * - The message text is made up of zero or more lines, each terminated by
72 /* -------------------------------------------------------------------------- **
75 * dbf - Global debug file handle.
76 * debugf - Debug file name.
77 * DEBUGLEVEL - System-wide debug message limit. Messages with message-
78 * levels higher than DEBUGLEVEL will not be processed.
83 BOOL debug_warn_unknown_class
= True
;
84 BOOL debug_auto_add_unknown_class
= True
;
85 BOOL AllowDebugChange
= True
;
88 used to check if the user specified a
89 logfile on the command line
91 BOOL override_logfile
;
95 * This is to allow assignment to DEBUGLEVEL before the debug
96 * system has been initialised.
98 static int debug_all_class_hack
= 1;
99 static BOOL debug_all_class_isset_hack
= True
;
101 static int debug_num_classes
= 0;
102 int *DEBUGLEVEL_CLASS
= &debug_all_class_hack
;
103 BOOL
*DEBUGLEVEL_CLASS_ISSET
= &debug_all_class_isset_hack
;
105 /* DEBUGLEVEL is #defined to *debug_level */
106 int DEBUGLEVEL
= &debug_all_class_hack
;
109 /* -------------------------------------------------------------------------- **
110 * Internal variables.
112 * stdout_logging - Default False, if set to True then dbf will be set to
113 * stdout and debug output will go to dbf only, and not
114 * to syslog. Set in setup_logging() and read in Debug1().
116 * debug_count - Number of debug messages that have been output.
117 * Used to check log size.
119 * syslog_level - Internal copy of the message debug level. Written by
120 * dbghdr() and read by Debug1().
122 * format_bufr - Used to format debug messages. The dbgtext() function
123 * prints debug messages to a string, and then passes the
124 * string to format_debug_text(), which uses format_bufr
125 * to build the formatted output.
127 * format_pos - Marks the first free byte of the format_bufr.
130 * log_overflow - When this variable is True, never attempt to check the
131 * size of the log. This is a hack, so that we can write
132 * a message using DEBUG, from open_logs() when we
133 * are unable to open a new log file for some reason.
136 static BOOL stdout_logging
= False
;
137 static int debug_count
= 0;
139 static int syslog_level
= 0;
141 static pstring format_bufr
= { '\0' };
142 static size_t format_pos
= 0;
143 static BOOL log_overflow
= False
;
146 * Define all the debug class selection names here. Names *MUST NOT* contain
147 * white space. There must be one name for each DBGC_<class name>, and they
148 * must be in the table in the order of DBGC_<class name>..
150 static const char *default_classname_table
[] = {
151 "all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
152 "tdb", /* DBGC_TDB */
153 "printdrivers", /* DBGC_PRINTDRIVERS */
154 "lanman", /* DBGC_LANMAN */
155 "smb", /* DBGC_SMB */
156 "rpc_parse", /* DBGC_RPC_PARSE */
157 "rpc_srv", /* DBGC_RPC_SRV */
158 "rpc_cli", /* DBGC_RPC_CLI */
159 "passdb", /* DBGC_PASSDB */
160 "sam", /* DBGC_SAM */
161 "auth", /* DBGC_AUTH */
162 "winbind", /* DBGC_WINBIND */
163 "vfs", /* DBGC_VFS */
164 "idmap", /* DBGC_IDMAP */
165 "quota", /* DBGC_QUOTA */
169 static char **classname_table
= NULL
;
172 /* -------------------------------------------------------------------------- **
177 /****************************************************************************
178 utility lists registered debug class names's
179 ****************************************************************************/
181 #define MAX_CLASS_NAME_SIZE 1024
183 static char *debug_list_class_names_and_levels(void)
191 if (DEBUGLEVEL_CLASS
== &debug_all_class_hack
)
194 list
= calloc(debug_num_classes
+ 1, sizeof(char *));
198 /* prepare strings */
199 for (i
= 0, dim
= 0; i
< debug_num_classes
; i
++) {
200 int l
= asprintf(&list
[i
],
203 DEBUGLEVEL_CLASS_ISSET
[i
]?DEBUGLEVEL_CLASS
[i
]:DEBUGLEVEL
);
204 if (l
< 0 || l
> MAX_CLASS_NAME_SIZE
) {
211 /* create single string list - add space for newline */
212 b
= buf
= malloc(dim
+1);
217 for (i
= 0; i
< debug_num_classes
; i
++) {
218 int l
= strlen(list
[i
]);
219 strncpy(b
, list
[i
], l
);
222 b
[-1] = '\n'; /* replace last space with newline */
223 b
[0] = '\0'; /* null terminate string */
226 /* free strings list */
227 for (i
= 0; i
< debug_num_classes
; i
++)
228 if (list
[i
]) free(list
[i
]);
240 /****************************************************************************
241 utility access to debug class names's
242 ****************************************************************************/
243 const char *debug_classname_from_index(int ndx
)
245 if (ndx
< 0 || ndx
>= debug_num_classes
)
248 return classname_table
[ndx
];
251 /****************************************************************************
252 utility to translate names to debug class index's (internal version)
253 ****************************************************************************/
254 static int debug_lookup_classname_int(const char* classname
)
258 if (!classname
) return -1;
260 for (i
=0; i
< debug_num_classes
; i
++) {
261 if (strcmp(classname
, classname_table
[i
])==0)
267 /****************************************************************************
268 Add a new debug class to the system
269 ****************************************************************************/
270 int debug_add_class(const char *classname
)
278 /* check the init has yet been called */
281 ndx
= debug_lookup_classname_int(classname
);
284 ndx
= debug_num_classes
;
286 new_ptr
= DEBUGLEVEL_CLASS
;
287 if (DEBUGLEVEL_CLASS
== &debug_all_class_hack
)
289 /* Initial loading... */
292 new_ptr
= Realloc(new_ptr
,
293 sizeof(int) * (debug_num_classes
+ 1));
296 DEBUGLEVEL_CLASS
= new_ptr
;
297 DEBUGLEVEL_CLASS
[ndx
] = 0;
299 /* debug_level is the pointer used for the DEBUGLEVEL-thingy */
302 /* Transfer the initial level from debug_all_class_hack */
303 DEBUGLEVEL_CLASS
[ndx
] = DEBUGLEVEL
;
305 debug_level
= DEBUGLEVEL_CLASS
;
307 new_ptr
= DEBUGLEVEL_CLASS_ISSET
;
308 if (new_ptr
== &debug_all_class_isset_hack
)
312 new_ptr
= Realloc(new_ptr
,
313 sizeof(BOOL
) * (debug_num_classes
+ 1));
316 DEBUGLEVEL_CLASS_ISSET
= new_ptr
;
317 DEBUGLEVEL_CLASS_ISSET
[ndx
] = False
;
319 new_ptr
= Realloc(classname_table
,
320 sizeof(char *) * (debug_num_classes
+ 1));
323 classname_table
= new_ptr
;
325 classname_table
[ndx
] = strdup(classname
);
326 if (! classname_table
[ndx
])
334 /****************************************************************************
335 utility to translate names to debug class index's (public version)
336 ****************************************************************************/
337 int debug_lookup_classname(const char *classname
)
341 if (!classname
|| !*classname
) return -1;
343 ndx
= debug_lookup_classname_int(classname
);
348 if (debug_warn_unknown_class
)
350 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
353 if (debug_auto_add_unknown_class
)
355 return debug_add_class(classname
);
361 /****************************************************************************
362 dump the current registered debug levels
363 ****************************************************************************/
364 static void debug_dump_status(int level
)
368 DEBUG(level
, ("INFO: Current debug levels:\n"));
369 for (q
= 0; q
< debug_num_classes
; q
++)
371 DEBUGADD(level
, (" %s: %s/%d\n",
373 (DEBUGLEVEL_CLASS_ISSET
[q
]
375 DEBUGLEVEL_CLASS
[q
]));
379 /****************************************************************************
380 parse the debug levels from smbcontrol. Example debug level parameter:
382 ****************************************************************************/
383 static BOOL
debug_parse_params(char **params
)
392 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
393 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
395 if (isdigit((int)params
[0][0])) {
396 DEBUGLEVEL_CLASS
[DBGC_ALL
] = atoi(params
[0]);
397 DEBUGLEVEL_CLASS_ISSET
[DBGC_ALL
] = True
;
398 i
= 1; /* start processing at the next params */
401 i
= 0; /* DBGC_ALL not specified OR class name was included */
403 /* Fill in new debug class levels */
404 for (; i
< debug_num_classes
&& params
[i
]; i
++) {
405 if ((class_name
=strtok(params
[i
],":")) &&
406 (class_level
=strtok(NULL
, "\0")) &&
407 ((ndx
= debug_lookup_classname(class_name
)) != -1)) {
408 DEBUGLEVEL_CLASS
[ndx
] = atoi(class_level
);
409 DEBUGLEVEL_CLASS_ISSET
[ndx
] = True
;
411 DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params
[i
]));
419 /****************************************************************************
420 parse the debug levels from smb.conf. Example debug level string:
421 3 tdb:5 printdrivers:7
422 Note: the 1st param has no "name:" preceeding it.
423 ****************************************************************************/
424 BOOL
debug_parse_levels(const char *params_str
)
431 if (AllowDebugChange
== False
)
434 params
= str_list_make(params_str
, NULL
);
436 if (debug_parse_params(params
))
438 debug_dump_status(5);
439 str_list_free(¶ms
);
442 str_list_free(¶ms
);
447 /****************************************************************************
448 receive a "set debug level" message
449 ****************************************************************************/
450 static void debug_message(int msg_type
, pid_t src
, void *buf
, size_t len
)
452 const char *params_str
= buf
;
454 /* Check, it's a proper string! */
455 if (params_str
[len
-1] != '\0')
457 DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
458 (unsigned int)src
, (unsigned int)getpid()));
462 DEBUG(3, ("INFO: Remote set of debug to `%s' (pid %u from pid %u)\n",
463 params_str
, (unsigned int)getpid(), (unsigned int)src
));
465 debug_parse_levels(params_str
);
469 /****************************************************************************
470 send a "set debug level" message
471 ****************************************************************************/
472 void debug_message_send(pid_t pid
, const char *params_str
)
476 message_send_pid(pid
, MSG_DEBUG
, params_str
, strlen(params_str
) + 1,
480 /****************************************************************************
481 Return current debug level.
482 ****************************************************************************/
484 static void debuglevel_message(int msg_type
, pid_t src
, void *buf
, size_t len
)
486 char *message
= debug_list_class_names_and_levels();
488 DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %u\n",(unsigned int)src
));
489 message_send_pid(src
, MSG_DEBUGLEVEL
, message
, strlen(message
) + 1, True
);
494 /****************************************************************************
495 Init debugging (one time stuff)
496 ****************************************************************************/
497 void debug_init(void)
499 static BOOL initialised
= False
;
507 message_register(MSG_DEBUG
, debug_message
);
508 message_register(MSG_REQ_DEBUGLEVEL
, debuglevel_message
);
510 for(p
= default_classname_table
; *p
; p
++)
517 /* ************************************************************************** **
518 * get ready for syslog stuff
519 * ************************************************************************** **
521 void setup_logging(const char *pname
, BOOL interactive
)
525 /* reset to allow multiple setup calls, going from interactive to
527 stdout_logging
= False
;
531 stdout_logging
= True
;
533 x_setbuf( x_stdout
, NULL
);
537 const char *p
= strrchr_m( pname
,'/' );
541 openlog( pname
, LOG_PID
, SYSLOG_FACILITY
);
543 /* for old systems that have no facility codes. */
544 openlog( pname
, LOG_PID
);
548 } /* setup_logging */
550 /* ************************************************************************** **
551 * reopen the log files
552 * note that we now do this unconditionally
553 * We attempt to open the new debug fp before closing the old. This means
554 * if we run out of fd's we just keep using the old fd rather than aborting.
555 * Fix from dgibson@linuxcare.com.
556 * ************************************************************************** **
559 BOOL
reopen_logs( void )
563 XFILE
*new_dbf
= NULL
;
564 XFILE
*old_dbf
= NULL
;
570 oldumask
= umask( 022 );
572 pstrcpy(fname
, debugf
);
577 logfname
= lp_logfile();
579 pstrcpy(fname
, logfname
);
582 pstrcpy( debugf
, fname
);
583 new_dbf
= x_fopen( debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644);
587 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf
, strerror(errno
)));
588 log_overflow
= False
;
593 x_setbuf(new_dbf
, NULL
);
597 (void) x_fclose(old_dbf
);
600 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
601 * to fix problem where smbd's that generate less
602 * than 100 messages keep growing the log.
604 force_check_log_size();
605 (void)umask(oldumask
);
607 /* Take over stderr to catch ouput into logs */
608 if (dbf
&& sys_dup2(x_fileno(dbf
), 2) == -1) {
609 close_low_fds(True
); /* Close stderr too, if dup2 can't point it
616 /* ************************************************************************** **
617 * Force a check of the log size.
618 * ************************************************************************** **
620 void force_check_log_size( void )
625 /***************************************************************************
626 Check to see if there is any need to check if the logfile has grown too big.
627 **************************************************************************/
629 BOOL
need_to_check_log_size( void )
633 if( debug_count
< 100 )
636 maxlog
= lp_max_log_size() * 1024;
637 if( !dbf
|| maxlog
<= 0 ) {
644 /* ************************************************************************** **
645 * Check to see if the log has grown to be too big.
646 * ************************************************************************** **
649 void check_log_size( void )
655 * We need to be root to check/change log-file, skip this and let the main
656 * loop check do a new check as root.
662 if(log_overflow
|| !need_to_check_log_size() )
665 maxlog
= lp_max_log_size() * 1024;
667 if( sys_fstat( x_fileno( dbf
), &st
) == 0 && st
.st_size
> maxlog
) {
669 if( dbf
&& get_file_size( debugf
) > maxlog
) {
672 slprintf( name
, sizeof(name
)-1, "%s.old", debugf
);
673 (void)rename( debugf
, name
);
675 if (!reopen_logs()) {
676 /* We failed to reopen a log - continue using the old name. */
677 (void)rename(name
, debugf
);
683 * Here's where we need to panic if dbf == NULL..
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 dbf
= x_fopen( "/dev/console", O_WRONLY
, 0);
696 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
700 * We cannot continue without a debug file handle.
706 } /* check_log_size */
708 /* ************************************************************************** **
709 * Write an debug message on the debugfile.
710 * This is called by dbghdr() and format_debug_text().
711 * ************************************************************************** **
713 int Debug1( const char *format_str
, ... )
716 int old_errno
= errno
;
722 va_start( ap
, format_str
);
724 (void)x_vfprintf( dbf
, format_str
, ap
);
731 if( !lp_syslog_only() )
736 mode_t oldumask
= umask( 022 );
738 dbf
= x_fopen( debugf
, O_WRONLY
|O_APPEND
|O_CREAT
, 0644 );
739 (void)umask( oldumask
);
742 x_setbuf( dbf
, NULL
);
753 if( syslog_level
< lp_syslog() )
755 /* map debug levels to syslog() priorities
756 * note that not all DEBUG(0, ...) calls are
759 static int priority_map
[] = {
768 if( syslog_level
>= ( sizeof(priority_map
) / sizeof(priority_map
[0]) )
770 priority
= LOG_DEBUG
;
772 priority
= priority_map
[syslog_level
];
774 va_start( ap
, format_str
);
775 vslprintf( msgbuf
, sizeof(msgbuf
)-1, format_str
, ap
);
779 syslog( priority
, "%s", msgbuf
);
786 if( !lp_syslog_only() )
789 va_start( ap
, format_str
);
791 (void)x_vfprintf( dbf
, format_str
, ap
);
794 (void)x_fflush( dbf
);
803 /* ************************************************************************** **
804 * Print the buffer content via Debug1(), then reset the buffer.
809 * ************************************************************************** **
811 static void bufr_print( void )
813 format_bufr
[format_pos
] = '\0';
814 (void)Debug1( "%s", format_bufr
);
818 /* ************************************************************************** **
819 * Format the debug message text.
821 * Input: msg - Text to be added to the "current" debug message text.
825 * Notes: The purpose of this is two-fold. First, each call to syslog()
826 * (used by Debug1(), see above) generates a new line of syslog
827 * output. This is fixed by storing the partial lines until the
828 * newline character is encountered. Second, printing the debug
829 * message lines when a newline is encountered allows us to add
830 * spaces, thus indenting the body of the message and making it
833 * ************************************************************************** **
835 static void format_debug_text( char *msg
)
838 BOOL timestamp
= (!stdout_logging
&& (lp_timestamp_logs() ||
841 for( i
= 0; msg
[i
]; i
++ )
843 /* Indent two spaces at each new line. */
844 if(timestamp
&& 0 == format_pos
)
846 format_bufr
[0] = format_bufr
[1] = ' ';
850 /* If there's room, copy the character to the format buffer. */
851 if( format_pos
< FORMAT_BUFR_MAX
)
852 format_bufr
[format_pos
++] = msg
[i
];
854 /* If a newline is encountered, print & restart. */
858 /* If the buffer is full dump it out, reset it, and put out a line
859 * continuation indicator.
861 if( format_pos
>= FORMAT_BUFR_MAX
)
864 (void)Debug1( " +>\n" );
868 /* Just to be safe... */
869 format_bufr
[format_pos
] = '\0';
870 } /* format_debug_text */
872 /* ************************************************************************** **
873 * Flush debug output, including the format buffer content.
878 * ************************************************************************** **
880 void dbgflush( void )
884 (void)x_fflush( dbf
);
887 /* ************************************************************************** **
888 * Print a Debug Header.
890 * Input: level - Debug level of the message (not the system-wide debug
892 * file - Pointer to a string containing the name of the file
893 * from which this function was called, or an empty string
894 * if the __FILE__ macro is not implemented.
895 * func - Pointer to a string containing the name of the function
896 * from which this function was called, or an empty string
897 * if the __FUNCTION__ macro is not implemented.
898 * line - line number of the call to dbghdr, assuming __LINE__
901 * Output: Always True. This makes it easy to fudge a call to dbghdr()
902 * in a macro, since the function can be called as part of a test.
903 * Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
905 * Notes: This function takes care of setting syslog_level.
907 * ************************************************************************** **
910 BOOL
dbghdr( int level
, const char *file
, const char *func
, int line
)
912 /* Ensure we don't lose any real errno value. */
913 int old_errno
= errno
;
916 /* This is a fudge. If there is stuff sitting in the format_bufr, then
917 * the *right* thing to do is to call
918 * format_debug_text( "\n" );
919 * to write the remainder, and then proceed with the new header.
920 * Unfortunately, there are several places in the code at which
921 * the DEBUG() macro is used to build partial lines. That in mind,
922 * we'll work under the assumption that an incomplete line indicates
923 * that a new header is *not* desired.
929 /* Set syslog_level. */
930 syslog_level
= level
;
933 /* Don't print a header if we're logging to stdout. */
937 /* Print the header if timestamps are turned on. If parameters are
938 * not yet loaded, then default to timestamps on.
940 if( lp_timestamp_logs() || !(lp_loaded()) ) {
941 char header_str
[200];
943 header_str
[0] = '\0';
946 slprintf(header_str
,sizeof(header_str
)-1,", pid=%u",(unsigned int)sys_getpid());
948 if( lp_debug_uid()) {
949 size_t hs_len
= strlen(header_str
);
950 slprintf(header_str
+ hs_len
,
951 sizeof(header_str
) - 1 - hs_len
,
952 ", effective(%u, %u), real(%u, %u)",
953 (unsigned int)geteuid(), (unsigned int)getegid(),
954 (unsigned int)getuid(), (unsigned int)getgid());
957 /* Print it all out at once to prevent split syslog output. */
958 (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
959 timestring(lp_debug_hires_timestamp()), level
,
960 header_str
, file
, func
, line
);
967 /* ************************************************************************** **
968 * Add text to the body of the "current" debug message via the format buffer.
970 * Input: format_str - Format string, as used in printf(), et. al.
971 * ... - Variable argument list.
973 * ..or.. va_alist - Old style variable parameter list starting point.
975 * Output: Always True. See dbghdr() for more info, though this is not
976 * likely to be used in the same way.
978 * ************************************************************************** **
980 BOOL
dbgtext( const char *format_str
, ... )
985 va_start( ap
, format_str
);
986 vslprintf( msgbuf
, sizeof(msgbuf
)-1, format_str
, ap
);
989 format_debug_text( msgbuf
);
995 /* ************************************************************************** */