Context Navigation

debug.c@ 742

Visit:

Last change on this file since 742 was 736, checked in by Silvan Scherrer, 13 years ago
Samba Server 3.5: update branche to 3.5.16
File size: 30.5 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 3 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, see <http://www.gnu.org/licenses/>.
20	*/
21
22	#include "includes.h"
23
24	/* -------------------------------------------------------------------------- **
25	* Defines...
26	*
27	* FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
28	* format_bufr[FORMAT_BUFR_MAX] should always be reserved
29	* for a terminating null byte.
30	*/
31
32	#define FORMAT_BUFR_SIZE 1024
33	#define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 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
81	XFILE *dbf = NULL;
82	static char *debugf = NULL;
83	bool debug_warn_unknown_class = True;
84	bool debug_auto_add_unknown_class = True;
85	bool AllowDebugChange = True;
86
87	/*
88	used to check if the user specified a
89	logfile on the command line
90	*/
91	bool override_logfile;
92
93	/*
94	* This is to allow assignment to DEBUGLEVEL before the debug
95	* system has been initialized.
96	*/
97	static int debug_all_class_hack = 1;
98	static bool debug_all_class_isset_hack = True;
99
100	static int debug_num_classes = 0;
101	int *DEBUGLEVEL_CLASS = &debug_all_class_hack;
102	bool *DEBUGLEVEL_CLASS_ISSET = &debug_all_class_isset_hack;
103
104	/* DEBUGLEVEL is #defined to debug_level /
105	int DEBUGLEVEL = &debug_all_class_hack;
106
107
108	/* -------------------------------------------------------------------------- **
109	* Internal variables.
110	*
111	* stdout_logging - Default False, if set to True then dbf will be set to
112	* stdout and debug output will go to dbf only, and not
113	* to syslog. Set in setup_logging() and read in Debug1().
114	*
115	* debug_count - Number of debug messages that have been output.
116	* Used to check log size.
117	*
118	* syslog_level - Internal copy of the message debug level. Written by
119	* dbghdr() and read by Debug1().
120	*
121	* format_bufr - Used to format debug messages. The dbgtext() function
122	* prints debug messages to a string, and then passes the
123	* string to format_debug_text(), which uses format_bufr
124	* to build the formatted output.
125	*
126	* format_pos - Marks the first free byte of the format_bufr.
127	*
128	*
129	* log_overflow - When this variable is True, never attempt to check the
130	* size of the log. This is a hack, so that we can write
131	* a message using DEBUG, from open_logs() when we
132	* are unable to open a new log file for some reason.
133	*/
134
135	static bool stdout_logging = False;
136	static int debug_count = 0;
137	#ifdef WITH_SYSLOG
138	static int syslog_level = 0;
139	#endif
140	static char *format_bufr = NULL;
141	static size_t format_pos = 0;
142	static bool log_overflow = False;
143
144	/*
145	* Define all the debug class selection names here. Names MUST NOT contain
146	* white space. There must be one name for each DBGC_<class name>, and they
147	* must be in the table in the order of DBGC_<class name>..
148	*/
149	static const char *default_classname_table[] = {
150	"all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
151	"tdb", /* DBGC_TDB */
152	"printdrivers", /* DBGC_PRINTDRIVERS */
153	"lanman", /* DBGC_LANMAN */
154	"smb", /* DBGC_SMB */
155	"rpc_parse", /* DBGC_RPC_PARSE */
156	"rpc_srv", /* DBGC_RPC_SRV */
157	"rpc_cli", /* DBGC_RPC_CLI */
158	"passdb", /* DBGC_PASSDB */
159	"sam", /* DBGC_SAM */
160	"auth", /* DBGC_AUTH */
161	"winbind", /* DBGC_WINBIND */
162	"vfs", /* DBGC_VFS */
163	"idmap", /* DBGC_IDMAP */
164	"quota", /* DBGC_QUOTA */
165	"acls", /* DBGC_ACLS */
166	"locking", /* DBGC_LOCKING */
167	"msdfs", /* DBGC_MSDFS */
168	"dmapi", /* DBGC_DMAPI */
169	"registry", /* DBGC_REGISTRY */
170	NULL
171	};
172
173	static char **classname_table = NULL;
174
175
176	/* -------------------------------------------------------------------------- **
177	* Functions...
178	*/
179
180	/***************************************************************************
181	Free memory pointed to by global pointers.
182	****************************************************************************/
183
184	static bool initialized;
185
186	void gfree_debugsyms(void)
187	{
188	int i;
189
190	if ( classname_table ) {
191	for ( i = 0; i < debug_num_classes; i++ ) {
192	SAFE_FREE( classname_table[i] );
193	}
194	SAFE_FREE( classname_table );
195	}
196
197	if ( DEBUGLEVEL_CLASS != &debug_all_class_hack ) {
198	SAFE_FREE( DEBUGLEVEL_CLASS );
199	DEBUGLEVEL_CLASS = &debug_all_class_hack;
200	}
201
202	if ( DEBUGLEVEL_CLASS_ISSET != &debug_all_class_isset_hack ) {
203	SAFE_FREE( DEBUGLEVEL_CLASS_ISSET );
204	DEBUGLEVEL_CLASS_ISSET = &debug_all_class_isset_hack;
205	}
206
207	SAFE_FREE(format_bufr);
208
209	debug_num_classes = 0;
210
211	debug_level = DEBUGLEVEL_CLASS;
212
213	initialized = false;
214	}
215
216	/****************************************************************************
217	utility lists registered debug class names's
218	****************************************************************************/
219
220	#define MAX_CLASS_NAME_SIZE 1024
221
222	static char *debug_list_class_names_and_levels(void)
223	{
224	int i, dim;
225	char **list;
226	char *buf = NULL;
227	char *b;
228	bool err = False;
229
230	if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
231	return NULL;
232	}
233
234	list = SMB_CALLOC_ARRAY(char *, debug_num_classes + 1);
235	if (!list) {
236	return NULL;
237	}
238
239	/* prepare strings */
240	for (i = 0, dim = 0; i < debug_num_classes; i++) {
241	int l = asprintf(&list[i],
242	"%s:%d ",
243	classname_table[i],
244	DEBUGLEVEL_CLASS_ISSET[i]?DEBUGLEVEL_CLASS[i]:DEBUGLEVEL);
245	if (l < 0 \|\| l > MAX_CLASS_NAME_SIZE) {
246	err = True;
247	goto done;
248	}
249	dim += l;
250	}
251
252	/* create single string list - add space for newline */
253	b = buf = (char *)SMB_MALLOC(dim+1);
254	if (!buf) {
255	err = True;
256	goto done;
257	}
258	for (i = 0; i < debug_num_classes; i++) {
259	int l = strlen(list[i]);
260	strncpy(b, list[i], l);
261	b = b + l;
262	}
263	b[-1] = '\n'; /* replace last space with newline */
264	b[0] = '\0'; /* null terminate string */
265
266	done:
267	/* free strings list */
268	for (i = 0; i < debug_num_classes; i++) {
269	SAFE_FREE(list[i]);
270	}
271	SAFE_FREE(list);
272
273	if (err) {
274	return NULL;
275	} else {
276	return buf;
277	}
278	}
279
280	/****************************************************************************
281	Utility access to debug class names's.
282	****************************************************************************/
283
284	const char *debug_classname_from_index(int ndx)
285	{
286	if (ndx < 0 \|\| ndx >= debug_num_classes)
287	return NULL;
288	else
289	return classname_table[ndx];
290	}
291
292	/****************************************************************************
293	Utility to translate names to debug class index's (internal version).
294	****************************************************************************/
295
296	static int debug_lookup_classname_int(const char* classname)
297	{
298	int i;
299
300	if (!classname) return -1;
301
302	for (i=0; i < debug_num_classes; i++) {
303	if (strcmp(classname, classname_table[i])==0)
304	return i;
305	}
306	return -1;
307	}
308
309	/****************************************************************************
310	Add a new debug class to the system.
311	****************************************************************************/
312
313	int debug_add_class(const char *classname)
314	{
315	int ndx;
316	void *new_ptr;
317
318	if (!classname)
319	return -1;
320
321	/* check the init has yet been called */
322	debug_init();
323
324	ndx = debug_lookup_classname_int(classname);
325	if (ndx >= 0)
326	return ndx;
327	ndx = debug_num_classes;
328
329	new_ptr = DEBUGLEVEL_CLASS;
330	if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
331	/* Initial loading... */
332	new_ptr = NULL;
333	}
334	new_ptr = SMB_REALLOC_ARRAY(new_ptr, int, debug_num_classes + 1);
335	if (!new_ptr)
336	return -1;
337	DEBUGLEVEL_CLASS = (int *)new_ptr;
338	DEBUGLEVEL_CLASS[ndx] = 0;
339
340	/* debug_level is the pointer used for the DEBUGLEVEL-thingy */
341	if (ndx==0) {
342	/* Transfer the initial level from debug_all_class_hack */
343	DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL;
344	}
345	debug_level = DEBUGLEVEL_CLASS;
346
347	new_ptr = DEBUGLEVEL_CLASS_ISSET;
348	if (new_ptr == &debug_all_class_isset_hack) {
349	new_ptr = NULL;
350	}
351	new_ptr = SMB_REALLOC_ARRAY(new_ptr, bool, debug_num_classes + 1);
352	if (!new_ptr)
353	return -1;
354	DEBUGLEVEL_CLASS_ISSET = (bool *)new_ptr;
355	DEBUGLEVEL_CLASS_ISSET[ndx] = False;
356
357	new_ptr = SMB_REALLOC_ARRAY(classname_table, char *, debug_num_classes + 1);
358	if (!new_ptr)
359	return -1;
360	classname_table = (char **)new_ptr;
361
362	classname_table[ndx] = SMB_STRDUP(classname);
363	if (! classname_table[ndx])
364	return -1;
365
366	debug_num_classes++;
367
368	return ndx;
369	}
370
371	/****************************************************************************
372	Utility to translate names to debug class index's (public version).
373	****************************************************************************/
374
375	int debug_lookup_classname(const char *classname)
376	{
377	int ndx;
378
379	if (!classname \|\| !*classname)
380	return -1;
381
382	ndx = debug_lookup_classname_int(classname);
383
384	if (ndx != -1)
385	return ndx;
386
387	if (debug_warn_unknown_class) {
388	DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
389	classname));
390	}
391	if (debug_auto_add_unknown_class) {
392	return debug_add_class(classname);
393	}
394	return -1;
395	}
396
397	/****************************************************************************
398	Dump the current registered debug levels.
399	****************************************************************************/
400
401	static void debug_dump_status(int level)
402	{
403	int q;
404
405	DEBUG(level, ("INFO: Current debug levels:\n"));
406	for (q = 0; q < debug_num_classes; q++) {
407	DEBUGADD(level, (" %s: %s/%d\n",
408	classname_table[q],
409	(DEBUGLEVEL_CLASS_ISSET[q]
410	? "True" : "False"),
411	DEBUGLEVEL_CLASS[q]));
412	}
413	}
414
415	/****************************************************************************
416	parse the debug levels from smbcontrol. Example debug level parameter:
417	printdrivers:7
418	****************************************************************************/
419
420	static bool debug_parse_params(char **params)
421	{
422	int i, ndx;
423	char *class_name;
424	char *class_level;
425
426	if (!params)
427	return False;
428
429	/* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
430	* v.s. "all:10", this is the traditional way to set DEBUGLEVEL
431	*/
432	if (isdigit((int)params[0][0])) {
433	DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
434	DEBUGLEVEL_CLASS_ISSET[DBGC_ALL] = True;
435	i = 1; /* start processing at the next params */
436	} else {
437	i = 0; /* DBGC_ALL not specified OR class name was included */
438	}
439
440	/* Fill in new debug class levels */
441	for (; i < debug_num_classes && params[i]; i++) {
442	char *saveptr;
443	if ((class_name = strtok_r(params[i],":", &saveptr)) &&
444	(class_level = strtok_r(NULL, "\0", &saveptr)) &&
445	((ndx = debug_lookup_classname(class_name)) != -1)) {
446	DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
447	DEBUGLEVEL_CLASS_ISSET[ndx] = True;
448	} else {
449	DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
450	return False;
451	}
452	}
453
454	return True;
455	}
456
457	/****************************************************************************
458	Parse the debug levels from smb.conf. Example debug level string:
459	3 tdb:5 printdrivers:7
460	Note: the 1st param has no "name:" preceeding it.
461	****************************************************************************/
462
463	bool debug_parse_levels(const char *params_str)
464	{
465	char **params;
466
467	/* Just in case */
468	debug_init();
469
470	if (AllowDebugChange == False)
471	return True;
472
473	params = str_list_make_v3(talloc_tos(), params_str, NULL);
474
475	if (debug_parse_params(params)) {
476	debug_dump_status(5);
477	TALLOC_FREE(params);
478	return True;
479	} else {
480	TALLOC_FREE(params);
481	return False;
482	}
483	}
484
485	/****************************************************************************
486	Receive a "set debug level" message.
487	****************************************************************************/
488
489	void debug_message(struct messaging_context *msg_ctx,
490	void *private_data,
491	uint32_t msg_type,
492	struct server_id src,
493	DATA_BLOB *data)
494	{
495	const char params_str = (const char )data->data;
496
497	/* Check, it's a proper string! */
498	if (params_str[(data->length)-1] != '\0') {
499	DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
500	(unsigned int)procid_to_pid(&src),
501	(unsigned int)getpid()));
502	return;
503	}
504
505	DEBUG(3, ("INFO: Remote set of debug to `%s' (pid %u from pid %u)\n",
506	params_str, (unsigned int)getpid(),
507	(unsigned int)procid_to_pid(&src)));
508
509	debug_parse_levels(params_str);
510	}
511
512	/****************************************************************************
513	Return current debug level.
514	****************************************************************************/
515
516	static void debuglevel_message(struct messaging_context *msg_ctx,
517	void *private_data,
518	uint32_t msg_type,
519	struct server_id src,
520	DATA_BLOB *data)
521	{
522	char *message = debug_list_class_names_and_levels();
523
524	if (!message) {
525	DEBUG(0,("debuglevel_message - debug_list_class_names_and_levels returned NULL\n"));
526	return;
527	}
528
529	DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %s\n",
530	procid_str_static(&src)));
531	messaging_send_buf(msg_ctx, src, MSG_DEBUGLEVEL,
532	(uint8 *)message, strlen(message) + 1);
533
534	SAFE_FREE(message);
535	}
536
537	/****************************************************************************
538	Init debugging (one time stuff)
539	****************************************************************************/
540
541	void debug_init(void)
542	{
543	const char **p;
544
545	if (initialized)
546	return;
547
548	initialized = true;
549
550	for(p = default_classname_table; *p; p++) {
551	debug_add_class(*p);
552	}
553	format_bufr = (char *)SMB_MALLOC(FORMAT_BUFR_SIZE);
554	if (!format_bufr) {
555	smb_panic("debug_init: unable to create buffer");
556	}
557	}
558
559	void debug_register_msgs(struct messaging_context *msg_ctx)
560	{
561	messaging_register(msg_ctx, NULL, MSG_DEBUG, debug_message);
562	messaging_register(msg_ctx, NULL, MSG_REQ_DEBUGLEVEL,
563	debuglevel_message);
564	}
565
566	/***************************************************************************
567	Get ready for syslog stuff
568	**************************************************************************/
569
570	void setup_logging(const char *pname, bool interactive)
571	{
572	debug_init();
573
574	/* reset to allow multiple setup calls, going from interactive to
575	non-interactive */
576	stdout_logging = False;
577	if (dbf) {
578	x_fflush(dbf);
579	if (dbf != x_stdout) {
580	(void) x_fclose(dbf);
581	}
582	}
583
584	dbf = NULL;
585
586	if (interactive) {
587	stdout_logging = True;
588	dbf = x_stdout;
589	x_setbuf( x_stdout, NULL );
590	}
591	#ifdef WITH_SYSLOG
592	else {
593	const char *p = strrchr_m( pname,'/' );
594	if (p)
595	pname = p + 1;
596	#ifdef LOG_DAEMON
597	openlog( pname, LOG_PID, SYSLOG_FACILITY );
598	#else
599	/* for old systems that have no facility codes. */
600	openlog( pname, LOG_PID );
601	#endif
602	}
603	#endif
604	}
605
606	/**
607	Just run logging to stdout for this program
608	*/
609	_PUBLIC_ void setup_logging_stdout(void)
610	{
611	setup_logging(NULL, True);
612	}
613
614
615	/***************************************************************************
616	Set the logfile name.
617	**************************************************************************/
618
619	void debug_set_logfile(const char *name)
620	{
621	SAFE_FREE(debugf);
622	debugf = SMB_STRDUP(name);
623	}
624
625	/**************************************************************************
626	reopen the log files
627	note that we now do this unconditionally
628	We attempt to open the new debug fp before closing the old. This means
629	if we run out of fd's we just keep using the old fd rather than aborting.
630	Fix from dgibson@linuxcare.com.
631	**************************************************************************/
632
633	bool reopen_logs( void )
634	{
635	char *fname = NULL;
636	mode_t oldumask;
637	XFILE *new_dbf = NULL;
638	XFILE *old_dbf = NULL;
639	bool ret = True;
640
641	if (stdout_logging)
642	return True;
643
644	oldumask = umask( 022 );
645
646	fname = debugf;
647	if (!fname) {
648	return false;
649	}
650	debugf = NULL;
651
652	if (lp_loaded()) {
653	char *logfname;
654
655	logfname = lp_logfile();
656	if (*logfname) {
657	SAFE_FREE(fname);
658	fname = SMB_STRDUP(logfname);
659	if (!fname) {
660	TALLOC_FREE(logfname);
661	return false;
662	}
663	}
664	TALLOC_FREE(logfname);
665	}
666
667	debugf = fname;
668	new_dbf = x_fopen( debugf, O_WRONLY\|O_APPEND\|O_CREAT, 0644);
669
670	if (!new_dbf) {
671	log_overflow = True;
672	DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
673	log_overflow = False;
674	if (dbf)
675	x_fflush(dbf);
676	ret = False;
677	} else {
678	x_setbuf(new_dbf, NULL);
679	old_dbf = dbf;
680	dbf = new_dbf;
681	if (old_dbf)
682	(void) x_fclose(old_dbf);
683	}
684
685	/* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
686	* to fix problem where smbd's that generate less
687	* than 100 messages keep growing the log.
688	*/
689	force_check_log_size();
690	(void)umask(oldumask);
691
692	/* Take over stderr to catch output into logs */
693	if (dbf && dup2(x_fileno(dbf), 2) == -1) {
694	close_low_fds(True); /* Close stderr too, if dup2 can't point it
695	at the logfile */
696	}
697
698	return ret;
699	}
700
701	/**************************************************************************
702	Force a check of the log size.
703	***************************************************************************/
704
705	void force_check_log_size( void )
706	{
707	debug_count = 100;
708	}
709
710	/***************************************************************************
711	Check to see if there is any need to check if the logfile has grown too big.
712	**************************************************************************/
713
714	bool need_to_check_log_size( void )
715	{
716	int maxlog;
717
718	if( debug_count < 100 )
719	return( False );
720
721	maxlog = lp_max_log_size() * 1024;
722	if( !dbf \|\| maxlog <= 0 ) {
723	debug_count = 0;
724	return(False);
725	}
726	return( True );
727	}
728
729	/**************************************************************************
730	Check to see if the log has grown to be too big.
731	**************************************************************************/
732
733	void check_log_size( void )
734	{
735	int maxlog;
736	SMB_STRUCT_STAT st;
737
738	/*
739	* We need to be root to check/change log-file, skip this and let the main
740	* loop check do a new check as root.
741	*/
742
743	if( geteuid() != 0 )
744	return;
745
746	if(log_overflow \|\| !need_to_check_log_size() )
747	return;
748
749	maxlog = lp_max_log_size() * 1024;
750
751	if(sys_fstat(x_fileno(dbf), &st, false) == 0
752	&& st.st_ex_size > maxlog ) {
753	(void)reopen_logs();
754	if( dbf && get_file_size( debugf ) > maxlog ) {
755	char *name = NULL;
756
757	if (asprintf(&name, "%s.old", debugf ) < 0) {
758	return;
759	}
760	(void)rename(debugf, name);
761
762	if (!reopen_logs()) {
763	/* We failed to reopen a log - continue using the old name. */
764	(void)rename(name, debugf);
765	}
766	SAFE_FREE(name);
767	}
768	}
769
770	/*
771	* Here's where we need to panic if dbf == NULL..
772	*/
773
774	if(dbf == NULL) {
775	/* This code should only be reached in very strange
776	* circumstances. If we merely fail to open the new log we
777	* should stick with the old one. ergo this should only be
778	* reached when opening the logs for the first time: at
779	* startup or when the log level is increased from zero.
780	* -dwg 6 June 2000
781	*/
782	dbf = x_fopen( "/dev/console", O_WRONLY, 0);
783	if(dbf) {
784	DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
785	debugf ));
786	} else {
787	/*
788	* We cannot continue without a debug file handle.
789	*/
790	abort();
791	}
792	}
793	debug_count = 0;
794	}
795
796	/*************************************************************************
797	Write an debug message on the debugfile.
798	This is called by dbghdr() and format_debug_text().
799	************************************************************************/
800
801	int Debug1( const char *format_str, ... )
802	{
803	va_list ap;
804	int old_errno = errno;
805
806	debug_count++;
807
808	if( stdout_logging ) {
809	va_start( ap, format_str );
810	if(dbf)
811	(void)x_vfprintf( dbf, format_str, ap );
812	va_end( ap );
813	errno = old_errno;
814	goto done;
815	}
816
817	/* prevent recursion by checking if reopen_logs() has temporaily
818	set the debugf string to NULL */
819	if( debugf == NULL)
820	goto done;
821
822	#ifdef WITH_SYSLOG
823	if( !lp_syslog_only() )
824	#endif
825	{
826	if( !dbf ) {
827	mode_t oldumask = umask( 022 );
828
829	dbf = x_fopen( debugf, O_WRONLY\|O_APPEND\|O_CREAT, 0644 );
830	(void)umask( oldumask );
831	if( dbf ) {
832	x_setbuf( dbf, NULL );
833	} else {
834	errno = old_errno;
835	goto done;
836	}
837	}
838	}
839
840	#ifdef WITH_SYSLOG
841	if( syslog_level < lp_syslog() ) {
842	/* map debug levels to syslog() priorities
843	* note that not all DEBUG(0, ...) calls are
844	* necessarily errors */
845	static const int priority_map[4] = {
846	LOG_ERR, /* 0 */
847	LOG_WARNING, /* 1 */
848	LOG_NOTICE, /* 2 */
849	LOG_INFO, /* 3 */
850	};
851	int priority;
852	char *msgbuf = NULL;
853	int ret;
854
855	if( syslog_level >= ARRAY_SIZE(priority_map) \|\| syslog_level < 0)
856	priority = LOG_DEBUG;
857	else
858	priority = priority_map[syslog_level];
859
860	/*
861	* Specify the facility to interoperate with other syslog
862	* callers (vfs_full_audit for example).
863	*/
864	priority \|= SYSLOG_FACILITY;
865
866	va_start(ap, format_str);
867	ret = vasprintf(&msgbuf, format_str, ap);
868	va_end(ap);
869
870	if (ret != -1) {
871	syslog(priority, "%s", msgbuf);
872	}
873	SAFE_FREE(msgbuf);
874	}
875	#endif
876
877	check_log_size();
878
879	#ifdef WITH_SYSLOG
880	if( !lp_syslog_only() )
881	#endif
882	{
883	va_start( ap, format_str );
884	if(dbf)
885	(void)x_vfprintf( dbf, format_str, ap );
886	va_end( ap );
887	if(dbf)
888	(void)x_fflush( dbf );
889	}
890
891	done:
892	errno = old_errno;
893
894	return( 0 );
895	}
896
897
898	/**************************************************************************
899	Print the buffer content via Debug1(), then reset the buffer.
900	Input: none
901	Output: none
902	****************************************************************************/
903
904	static void bufr_print( void )
905	{
906	format_bufr[format_pos] = '\0';
907	(void)Debug1( "%s", format_bufr );
908	format_pos = 0;
909	}
910
911	/***************************************************************************
912	Format the debug message text.
913
914	Input: msg - Text to be added to the "current" debug message text.
915
916	Output: none.
917
918	Notes: The purpose of this is two-fold. First, each call to syslog()
919	(used by Debug1(), see above) generates a new line of syslog
920	output. This is fixed by storing the partial lines until the
921	newline character is encountered. Second, printing the debug
922	message lines when a newline is encountered allows us to add
923	spaces, thus indenting the body of the message and making it
924	more readable.
925	**************************************************************************/
926
927	static void format_debug_text( const char *msg )
928	{
929	size_t i;
930	bool timestamp = (!stdout_logging && (lp_timestamp_logs() \|\| !(lp_loaded())));
931
932	if (!format_bufr) {
933	debug_init();
934	}
935
936	for( i = 0; msg[i]; i++ ) {
937	/* Indent two spaces at each new line. */
938	if(timestamp && 0 == format_pos) {
939	format_bufr[0] = format_bufr[1] = ' ';
940	format_pos = 2;
941	}
942
943	/* If there's room, copy the character to the format buffer. */
944	if( format_pos < FORMAT_BUFR_MAX )
945	format_bufr[format_pos++] = msg[i];
946
947	/* If a newline is encountered, print & restart. */
948	if( '\n' == msg[i] )
949	bufr_print();
950
951	/* If the buffer is full dump it out, reset it, and put out a line
952	* continuation indicator.
953	*/
954	if( format_pos >= FORMAT_BUFR_MAX ) {
955	bufr_print();
956	(void)Debug1( " +>\n" );
957	}
958	}
959
960	/* Just to be safe... */
961	format_bufr[format_pos] = '\0';
962	}
963
964	/***************************************************************************
965	Flush debug output, including the format buffer content.
966
967	Input: none
968	Output: none
969	***************************************************************************/
970
971	void dbgflush( void )
972	{
973	bufr_print();
974	if(dbf)
975	(void)x_fflush( dbf );
976	}
977
978	/***************************************************************************
979	Print a Debug Header.
980
981	Input: level - Debug level of the message (not the system-wide debug
982	level. )
983	cls - Debuglevel class of the calling module.
984	file - Pointer to a string containing the name of the file
985	from which this function was called, or an empty string
986	if the __FILE__ macro is not implemented.
987	func - Pointer to a string containing the name of the function
988	from which this function was called, or an empty string
989	if the __FUNCTION__ macro is not implemented.
990	line - line number of the call to dbghdr, assuming __LINE__
991	works.
992
993	Output: Always True. This makes it easy to fudge a call to dbghdr()
994	in a macro, since the function can be called as part of a test.
995	Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
996
997	Notes: This function takes care of setting syslog_level.
998
999	****************************************************************************/
1000
1001	bool dbghdrclass(int level, int cls, const char location, const char func)
1002	{
1003	/* Ensure we don't lose any real errno value. */
1004	int old_errno = errno;
1005
1006	if( format_pos ) {
1007	/* This is a fudge. If there is stuff sitting in the format_bufr, then
1008	* the right thing to do is to call
1009	* format_debug_text( "\n" );
1010	* to write the remainder, and then proceed with the new header.
1011	* Unfortunately, there are several places in the code at which
1012	* the DEBUG() macro is used to build partial lines. That in mind,
1013	* we'll work under the assumption that an incomplete line indicates
1014	* that a new header is not desired.
1015	*/
1016	return( True );
1017	}
1018
1019	#ifdef WITH_SYSLOG
1020	/* Set syslog_level. */
1021	syslog_level = level;
1022	#endif
1023
1024	/* Don't print a header if we're logging to stdout. */
1025	if( stdout_logging )
1026	return( True );
1027
1028	/* Print the header if timestamps are turned on. If parameters are
1029	* not yet loaded, then default to timestamps on.
1030	*/
1031	if( lp_timestamp_logs() \|\| lp_debug_prefix_timestamp() \|\| !(lp_loaded()) ) {
1032	char header_str[200];
1033	char *curtime = current_timestring(talloc_tos(),
1034	lp_debug_hires_timestamp());
1035
1036	header_str[0] = '\0';
1037
1038	if( lp_debug_pid())
1039	slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
1040
1041	if( lp_debug_uid()) {
1042	size_t hs_len = strlen(header_str);
1043	slprintf(header_str + hs_len,
1044	sizeof(header_str) - 1 - hs_len,
1045	", effective(%u, %u), real(%u, %u)",
1046	(unsigned int)geteuid(), (unsigned int)getegid(),
1047	(unsigned int)getuid(), (unsigned int)getgid());
1048	}
1049
1050	if (lp_debug_class() && (cls != DBGC_ALL)) {
1051	size_t hs_len = strlen(header_str);
1052	slprintf(header_str + hs_len,
1053	sizeof(header_str) -1 - hs_len,
1054	", class=%s",
1055	default_classname_table[cls]);
1056	}
1057
1058	/* Print it all out at once to prevent split syslog output. */
1059	if( lp_debug_prefix_timestamp() ) {
1060	(void)Debug1( "[%s, %2d%s] ",
1061	curtime,
1062	level, header_str);
1063	} else {
1064	(void)Debug1( "[%s, %2d%s] %s(%s)\n",
1065	curtime,
1066	level, header_str, location, func );
1067	}
1068	TALLOC_FREE(curtime);
1069	}
1070
1071	errno = old_errno;
1072	return( True );
1073	}
1074
1075	bool dbghdr(int level, const char location, const char func)
1076	{
1077	/* For compatibility with Samba 4, which doesn't have debug classes */
1078	return dbghdrclass(level, 0, location, func);
1079	}
1080
1081	/***************************************************************************
1082	Add text to the body of the "current" debug message via the format buffer.
1083
1084	Input: format_str - Format string, as used in printf(), et. al.
1085	... - Variable argument list.
1086
1087	..or.. va_alist - Old style variable parameter list starting point.
1088
1089	Output: Always True. See dbghdr() for more info, though this is not
1090	likely to be used in the same way.
1091
1092	***************************************************************************/
1093
1094	bool dbgtext( const char *format_str, ... )
1095	{
1096	va_list ap;
1097	char *msgbuf = NULL;
1098	bool ret = true;
1099	int res;
1100
1101	va_start(ap, format_str);
1102	res = vasprintf(&msgbuf, format_str, ap);
1103	va_end(ap);
1104
1105	if (res != -1) {
1106	format_debug_text(msgbuf);
1107	} else {
1108	ret = false;
1109	}
1110	SAFE_FREE(msgbuf);
1111	return ret;
1112	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: branches/samba-3.5.x/source3/lib/debug.c@ 742

Download in other formats: