source: branches/samba-3.0/source/lib/debug.c@ 715

Last change on this file since 715 was 279, checked in by Herwig Bauernfeind, 17 years ago

Change in debug.c (by ydario)
File size: 29.2 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Elrond 2002
6 Copyright (C) Simo Sorce 2002
7
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.
12
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.
17
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.
21*/
22
23#include "includes.h"
24
25/* -------------------------------------------------------------------------- **
26 * Defines...
27 *
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.
31 */
32
33#define FORMAT_BUFR_MAX ( sizeof( format_bufr ) - 1 )
34
35/* -------------------------------------------------------------------------- **
36 * This module implements Samba's debugging utility.
37 *
38 * The syntax of a debugging log file is represented as:
39 *
40 * <debugfile> :== { <debugmsg> }
41 *
42 * <debugmsg> :== <debughdr> '\n' <debugtext>
43 *
44 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
45 *
46 * <debugtext> :== { <debugline> }
47 *
48 * <debugline> :== TEXT '\n'
49 *
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.
55 *
56 * Basically, what that all means is:
57 *
58 * - A debugging log file is made up of debug messages.
59 *
60 * - Each debug message is made up of a header and text. The header is
61 * separated from the text by a newline.
62 *
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.
67 *
68 * - The message text is made up of zero or more lines, each terminated by
69 * a newline.
70 */
71
72/* -------------------------------------------------------------------------- **
73 * External variables.
74 *
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.
79 */
80
81XFILE *dbf = NULL;
82pstring debugf = "";
83BOOL debug_warn_unknown_class = True;
84BOOL debug_auto_add_unknown_class = True;
85BOOL AllowDebugChange = True;
86
87/*
88 used to check if the user specified a
89 logfile on the command line
90*/
91BOOL override_logfile;
92
93
94/*
95 * This is to allow assignment to DEBUGLEVEL before the debug
96 * system has been initialised.
97 */
98static int debug_all_class_hack = 1;
99static BOOL debug_all_class_isset_hack = True;
100
101static int debug_num_classes = 0;
102int *DEBUGLEVEL_CLASS = &debug_all_class_hack;
103BOOL *DEBUGLEVEL_CLASS_ISSET = &debug_all_class_isset_hack;
104
105/* DEBUGLEVEL is #defined to *debug_level */
106int DEBUGLEVEL = &debug_all_class_hack;
107
108
109/* -------------------------------------------------------------------------- **
110 * Internal variables.
111 *
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().
115 *
116 * debug_count - Number of debug messages that have been output.
117 * Used to check log size.
118 *
119 * syslog_level - Internal copy of the message debug level. Written by
120 * dbghdr() and read by Debug1().
121 *
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.
126 *
127 * format_pos - Marks the first free byte of the format_bufr.
128 *
129 *
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.
134 */
135
136static BOOL stdout_logging = False;
137static int debug_count = 0;
138#ifdef WITH_SYSLOG
139static int syslog_level = 0;
140#endif
141static pstring format_bufr = { '\0' };
142static size_t format_pos = 0;
143static BOOL log_overflow = False;
144
145/*
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>..
149 */
150static 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 */
166 "acls", /* DBGC_ACLS */
167 "locking", /* DBGC_LOCKING */
168 "msdfs", /* DBGC_MSDFS */
169 "dmapi", /* DBGC_DMAPI */
170 NULL
171};
172
173static char **classname_table = NULL;
174
175
176/* -------------------------------------------------------------------------- **
177 * Functions...
178 */
179
180/***************************************************************************
181 Free memory pointed to by global pointers.
182****************************************************************************/
183
184void gfree_debugsyms(void)
185{
186 int i;
187
188 if ( classname_table ) {
189 for ( i = 0; i < debug_num_classes; i++ ) {
190 SAFE_FREE( classname_table[i] );
191 }
192 SAFE_FREE( classname_table );
193 }
194
195 if ( DEBUGLEVEL_CLASS != &debug_all_class_hack )
196 SAFE_FREE( DEBUGLEVEL_CLASS );
197
198 if ( DEBUGLEVEL_CLASS_ISSET != &debug_all_class_isset_hack )
199 SAFE_FREE( DEBUGLEVEL_CLASS_ISSET );
200}
201
202/****************************************************************************
203utility lists registered debug class names's
204****************************************************************************/
205
206#define MAX_CLASS_NAME_SIZE 1024
207
208static char *debug_list_class_names_and_levels(void)
209{
210 int i, dim;
211 char **list;
212 char *buf = NULL;
213 char *b;
214 BOOL err = False;
215
216 if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
217 return NULL;
218 }
219
220 list = SMB_CALLOC_ARRAY(char *, debug_num_classes + 1);
221 if (!list) {
222 return NULL;
223 }
224
225 /* prepare strings */
226 for (i = 0, dim = 0; i < debug_num_classes; i++) {
227 int l = asprintf(&list[i],
228 "%s:%d ",
229 classname_table[i],
230 DEBUGLEVEL_CLASS_ISSET[i]?DEBUGLEVEL_CLASS[i]:DEBUGLEVEL);
231 if (l < 0 || l > MAX_CLASS_NAME_SIZE) {
232 err = True;
233 goto done;
234 }
235 dim += l;
236 }
237
238 /* create single string list - add space for newline */
239 b = buf = (char *)SMB_MALLOC(dim+1);
240 if (!buf) {
241 err = True;
242 goto done;
243 }
244 for (i = 0; i < debug_num_classes; i++) {
245 int l = strlen(list[i]);
246 strncpy(b, list[i], l);
247 b = b + l;
248 }
249 b[-1] = '\n'; /* replace last space with newline */
250 b[0] = '\0'; /* null terminate string */
251
252done:
253 /* free strings list */
254 for (i = 0; i < debug_num_classes; i++) {
255 SAFE_FREE(list[i]);
256 }
257 SAFE_FREE(list);
258
259 if (err) {
260 return NULL;
261 } else {
262 return buf;
263 }
264}
265
266/****************************************************************************
267 Utility access to debug class names's.
268****************************************************************************/
269
270const char *debug_classname_from_index(int ndx)
271{
272 if (ndx < 0 || ndx >= debug_num_classes)
273 return NULL;
274 else
275 return classname_table[ndx];
276}
277
278/****************************************************************************
279 Utility to translate names to debug class index's (internal version).
280****************************************************************************/
281
282static int debug_lookup_classname_int(const char* classname)
283{
284 int i;
285
286 if (!classname) return -1;
287
288 for (i=0; i < debug_num_classes; i++) {
289 if (strcmp(classname, classname_table[i])==0)
290 return i;
291 }
292 return -1;
293}
294
295/****************************************************************************
296 Add a new debug class to the system.
297****************************************************************************/
298
299int debug_add_class(const char *classname)
300{
301 int ndx;
302 void *new_ptr;
303
304 if (!classname)
305 return -1;
306
307 /* check the init has yet been called */
308 debug_init();
309
310 ndx = debug_lookup_classname_int(classname);
311 if (ndx >= 0)
312 return ndx;
313 ndx = debug_num_classes;
314
315 new_ptr = DEBUGLEVEL_CLASS;
316 if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
317 /* Initial loading... */
318 new_ptr = NULL;
319 }
320 new_ptr = SMB_REALLOC_ARRAY(new_ptr, int, debug_num_classes + 1);
321 if (!new_ptr)
322 return -1;
323 DEBUGLEVEL_CLASS = (int *)new_ptr;
324 DEBUGLEVEL_CLASS[ndx] = 0;
325
326 /* debug_level is the pointer used for the DEBUGLEVEL-thingy */
327 if (ndx==0) {
328 /* Transfer the initial level from debug_all_class_hack */
329 DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL;
330 }
331 debug_level = DEBUGLEVEL_CLASS;
332
333 new_ptr = DEBUGLEVEL_CLASS_ISSET;
334 if (new_ptr == &debug_all_class_isset_hack) {
335 new_ptr = NULL;
336 }
337 new_ptr = SMB_REALLOC_ARRAY(new_ptr, BOOL, debug_num_classes + 1);
338 if (!new_ptr)
339 return -1;
340 DEBUGLEVEL_CLASS_ISSET = (int *)new_ptr;
341 DEBUGLEVEL_CLASS_ISSET[ndx] = False;
342
343 new_ptr = SMB_REALLOC_ARRAY(classname_table, char *, debug_num_classes + 1);
344 if (!new_ptr)
345 return -1;
346 classname_table = (char **)new_ptr;
347
348 classname_table[ndx] = SMB_STRDUP(classname);
349 if (! classname_table[ndx])
350 return -1;
351
352 debug_num_classes++;
353
354 return ndx;
355}
356
357/****************************************************************************
358 Utility to translate names to debug class index's (public version).
359****************************************************************************/
360
361int debug_lookup_classname(const char *classname)
362{
363 int ndx;
364
365 if (!classname || !*classname)
366 return -1;
367
368 ndx = debug_lookup_classname_int(classname);
369
370 if (ndx != -1)
371 return ndx;
372
373 if (debug_warn_unknown_class) {
374 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
375 classname));
376 }
377 if (debug_auto_add_unknown_class) {
378 return debug_add_class(classname);
379 }
380 return -1;
381}
382
383/****************************************************************************
384 Dump the current registered debug levels.
385****************************************************************************/
386
387static void debug_dump_status(int level)
388{
389 int q;
390
391 DEBUG(level, ("INFO: Current debug levels:\n"));
392 for (q = 0; q < debug_num_classes; q++) {
393 DEBUGADD(level, (" %s: %s/%d\n",
394 classname_table[q],
395 (DEBUGLEVEL_CLASS_ISSET[q]
396 ? "True" : "False"),
397 DEBUGLEVEL_CLASS[q]));
398 }
399}
400
401/****************************************************************************
402 parse the debug levels from smbcontrol. Example debug level parameter:
403 printdrivers:7
404****************************************************************************/
405
406static BOOL debug_parse_params(char **params)
407{
408 int i, ndx;
409 char *class_name;
410 char *class_level;
411
412 if (!params)
413 return False;
414
415 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
416 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
417 */
418 if (isdigit((int)params[0][0])) {
419 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
420 DEBUGLEVEL_CLASS_ISSET[DBGC_ALL] = True;
421 i = 1; /* start processing at the next params */
422 } else {
423 i = 0; /* DBGC_ALL not specified OR class name was included */
424 }
425
426 /* Fill in new debug class levels */
427 for (; i < debug_num_classes && params[i]; i++) {
428 if ((class_name=strtok(params[i],":")) &&
429 (class_level=strtok(NULL, "\0")) &&
430 ((ndx = debug_lookup_classname(class_name)) != -1)) {
431 DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
432 DEBUGLEVEL_CLASS_ISSET[ndx] = True;
433 } else {
434 DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
435 return False;
436 }
437 }
438
439 return True;
440}
441
442/****************************************************************************
443 Parse the debug levels from smb.conf. Example debug level string:
444 3 tdb:5 printdrivers:7
445 Note: the 1st param has no "name:" preceeding it.
446****************************************************************************/
447
448BOOL debug_parse_levels(const char *params_str)
449{
450 char **params;
451
452 /* Just in case */
453 debug_init();
454
455 if (AllowDebugChange == False)
456 return True;
457
458 params = str_list_make(params_str, NULL);
459
460 if (debug_parse_params(params)) {
461 debug_dump_status(5);
462 str_list_free(&params);
463 return True;
464 } else {
465 str_list_free(&params);
466 return False;
467 }
468}
469
470/****************************************************************************
471 Receive a "set debug level" message.
472****************************************************************************/
473
474static void debug_message(int msg_type, struct process_id src,
475 void *buf, size_t len, void *private_data)
476{
477 const char *params_str = (const char *)buf;
478
479 /* Check, it's a proper string! */
480 if (params_str[len-1] != '\0') {
481 DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
482 (unsigned int)procid_to_pid(&src),
483 (unsigned int)getpid()));
484 return;
485 }
486
487 DEBUG(3, ("INFO: Remote set of debug to `%s' (pid %u from pid %u)\n",
488 params_str, (unsigned int)getpid(),
489 (unsigned int)procid_to_pid(&src)));
490
491 debug_parse_levels(params_str);
492}
493
494/****************************************************************************
495 Send a "set debug level" message.
496****************************************************************************/
497
498void debug_message_send(pid_t pid, const char *params_str)
499{
500 if (!params_str)
501 return;
502 message_send_pid(pid_to_procid(pid), MSG_DEBUG,
503 params_str, strlen(params_str) + 1,
504 False);
505}
506
507/****************************************************************************
508 Return current debug level.
509****************************************************************************/
510
511static void debuglevel_message(int msg_type, struct process_id src,
512 void *buf, size_t len, void *private_data)
513{
514 char *message = debug_list_class_names_and_levels();
515
516 if (!message) {
517 DEBUG(0,("debuglevel_message - debug_list_class_names_and_levels returned NULL\n"));
518 return;
519 }
520
521 DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %u\n",
522 (unsigned int)procid_to_pid(&src)));
523 message_send_pid(src, MSG_DEBUGLEVEL, message, strlen(message) + 1, True);
524
525 SAFE_FREE(message);
526}
527
528/****************************************************************************
529Init debugging (one time stuff)
530****************************************************************************/
531
532void debug_init(void)
533{
534 static BOOL initialised = False;
535 const char **p;
536
537 if (initialised)
538 return;
539
540 initialised = True;
541
542 message_register(MSG_DEBUG, debug_message, NULL);
543 message_register(MSG_REQ_DEBUGLEVEL, debuglevel_message, NULL);
544
545 for(p = default_classname_table; *p; p++) {
546 debug_add_class(*p);
547 }
548}
549
550/***************************************************************************
551 Get ready for syslog stuff
552**************************************************************************/
553
554void setup_logging(const char *pname, BOOL interactive)
555{
556 debug_init();
557
558 /* reset to allow multiple setup calls, going from interactive to
559 non-interactive */
560 stdout_logging = False;
561 if (dbf) {
562 x_fflush(dbf);
563 (void) x_fclose(dbf);
564 }
565
566 dbf = NULL;
567
568 if (interactive) {
569 stdout_logging = True;
570 dbf = x_stdout;
571 x_setbuf( x_stdout, NULL );
572 }
573#ifdef WITH_SYSLOG
574 else {
575 const char *p = strrchr_m( pname,'/' );
576 if (!p)
577 p = strrchr_m( pname,'\\' );
578 if (p)
579 pname = p + 1;
580#ifdef LOG_DAEMON
581 openlog( pname, LOG_PID, SYSLOG_FACILITY );
582#else
583 /* for old systems that have no facility codes. */
584 openlog( pname, LOG_PID );
585#endif
586 }
587#endif
588}
589
590/**************************************************************************
591 reopen the log files
592 note that we now do this unconditionally
593 We attempt to open the new debug fp before closing the old. This means
594 if we run out of fd's we just keep using the old fd rather than aborting.
595 Fix from [email protected].
596**************************************************************************/
597
598BOOL reopen_logs( void )
599{
600 pstring fname;
601 mode_t oldumask;
602 XFILE *new_dbf = NULL;
603 XFILE *old_dbf = NULL;
604 BOOL ret = True;
605
606 if (stdout_logging)
607 return True;
608
609 oldumask = umask( 022 );