source: trunk/server/lib/util/debug.c

Last change on this file was 948, checked in by dmik, 9 years ago

samba server: Implement max log size with truncating when rename fails #2.

This fixes a wrong r947 commit.
File size: 29.3 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#include "system/filesys.h"
24#include "system/syslog.h"
25#include "lib/util/time.h"
26
27/* define what facility to use for syslog */
28#ifndef SYSLOG_FACILITY
29#define SYSLOG_FACILITY LOG_DAEMON
30#endif
31
32/* -------------------------------------------------------------------------- **
33 * Defines...
34 *
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.
38 */
39
40#define FORMAT_BUFR_SIZE 1024
41#define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
42
43/* -------------------------------------------------------------------------- **
44 * This module implements Samba's debugging utility.
45 *
46 * The syntax of a debugging log file is represented as:
47 *
48 * <debugfile> :== { <debugmsg> }
49 *
50 * <debugmsg> :== <debughdr> '\n' <debugtext>
51 *
52 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
53 *
54 * <debugtext> :== { <debugline> }
55 *
56 * <debugline> :== TEXT '\n'
57 *
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.
63 *
64 * Basically, what that all means is:
65 *
66 * - A debugging log file is made up of debug messages.
67 *
68 * - Each debug message is made up of a header and text. The header is
69 * separated from the text by a newline.
70 *
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.
75 *
76 * - The message text is made up of zero or more lines, each terminated by
77 * a newline.
78 */
79
80/* state variables for the debug system */
81static struct {
82 bool initialized;
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;
86 bool reopening_logs;
87 bool schedule_reopen_logs;
88
89 struct debug_settings settings;
90 char *debugf;
91} state = {
92 .settings = {
93 .timestamp_logs = true
94 }
95};
96
97/* -------------------------------------------------------------------------- **
98 * External variables.
99 *
100 * debugf - Debug file name.
101 * DEBUGLEVEL - System-wide debug message limit. Messages with message-
102 * levels higher than DEBUGLEVEL will not be processed.
103 */
104
105/*
106 used to check if the user specified a
107 logfile on the command line
108*/
109bool override_logfile;
110
111/*
112 * This is to allow reading of DEBUGLEVEL_CLASS before the debug
113 * system has been initialized.
114 */
115static const int debug_class_list_initial[DBGC_MAX_FIXED + 1];
116
117static int debug_num_classes = 0;
118int *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
119
120
121/* -------------------------------------------------------------------------- **
122 * Internal variables.
123 *
124 * debug_count - Number of debug messages that have been output.
125 * Used to check log size.
126 *
127 * syslog_level - Internal copy of the message debug level. Written by
128 * dbghdr() and read by Debug1().
129 *
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.
134 *
135 * format_pos - Marks the first free byte of the format_bufr.
136 *
137 *
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.
142 */
143
144static int debug_count = 0;
145#ifdef WITH_SYSLOG
146static int syslog_level = 0;
147#endif
148static char *format_bufr = NULL;
149static size_t format_pos = 0;
150static bool log_overflow = false;
151
152/*
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>..
156 */
157static 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 */
178 NULL
179};
180
181static char **classname_table = NULL;
182
183
184/* -------------------------------------------------------------------------- **
185 * Functions...
186 */
187
188static void debug_init(void);
189
190/***************************************************************************
191 Free memory pointed to by global pointers.
192****************************************************************************/
193
194void gfree_debugsyms(void)
195{
196 TALLOC_FREE(classname_table);
197
198 if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
199 TALLOC_FREE( DEBUGLEVEL_CLASS );
200 DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
201 }
202
203 TALLOC_FREE(format_bufr);
204
205 debug_num_classes = 0;
206
207 state.initialized = false;
208}
209
210/****************************************************************************
211utility lists registered debug class names's
212****************************************************************************/
213
214char *debug_list_class_names_and_levels(void)
215{
216 char *buf = NULL;
217 unsigned int i;
218 /* prepare strings */
219 for (i = 0; i < debug_num_classes; i++) {
220 buf = talloc_asprintf_append(buf,
221 "%s:%d%s",
222 classname_table[i],
223 DEBUGLEVEL_CLASS[i],
224 i == (debug_num_classes - 1) ? "\n" : " ");
225 if (buf == NULL) {
226 return NULL;
227 }
228 }
229 return buf;
230}
231
232/****************************************************************************
233 Utility to translate names to debug class index's (internal version).
234****************************************************************************/
235
236static int debug_lookup_classname_int(const char* classname)
237{
238 int i;
239
240 if (!classname) return -1;
241
242 for (i=0; i < debug_num_classes; i++) {
243 if (strcmp(classname, classname_table[i])==0)
244 return i;
245 }
246 return -1;
247}
248
249/****************************************************************************
250 Add a new debug class to the system.
251****************************************************************************/
252
253int debug_add_class(const char *classname)
254{
255 int ndx;
256 int *new_class_list;
257 char **new_name_list;
258 int default_level;
259
260 if (!classname)
261 return -1;
262
263 /* check the init has yet been called */
264 debug_init();
265
266 ndx = debug_lookup_classname_int(classname);
267 if (ndx >= 0)
268 return ndx;
269 ndx = debug_num_classes;
270
271 if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
272 /* Initial loading... */
273 new_class_list = NULL;
274 } else {
275 new_class_list = DEBUGLEVEL_CLASS;
276 }
277
278 default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
279
280 new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
281 if (!new_class_list)
282 return -1;
283 DEBUGLEVEL_CLASS = new_class_list;
284
285 DEBUGLEVEL_CLASS[ndx] = default_level;
286
287 new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
288 if (!new_name_list)
289 return -1;
290 classname_table = new_name_list;
291
292 classname_table[ndx] = talloc_strdup(classname_table, classname);
293 if (! classname_table[ndx])
294 return -1;
295
296 debug_num_classes = ndx + 1;
297
298 return ndx;
299}
300
301/****************************************************************************
302 Utility to translate names to debug class index's (public version).
303****************************************************************************/
304
305int debug_lookup_classname(const char *classname)
306{
307 int ndx;
308
309 if (!classname || !*classname)
310 return -1;
311
312 ndx = debug_lookup_classname_int(classname);
313
314 if (ndx != -1)
315 return ndx;
316
317 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
318 classname));
319 return debug_add_class(classname);
320}
321
322/****************************************************************************
323 Dump the current registered debug levels.
324****************************************************************************/
325
326static void debug_dump_status(int level)
327{
328 int q;
329
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",
334 classname,
335 DEBUGLEVEL_CLASS[q]));
336 }
337}
338
339/****************************************************************************
340 parse the debug levels from smbcontrol. Example debug level parameter:
341 printdrivers:7
342****************************************************************************/
343
344static bool debug_parse_params(char **params)
345{
346 int i, ndx;
347 char *class_name;
348 char *class_level;
349
350 if (!params)
351 return false;
352
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
355 */
356 if (isdigit((int)params[0][0])) {
357 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
358 i = 1; /* start processing at the next params */
359 } else {
360 DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
361 i = 0; /* DBGC_ALL not specified OR class name was included */
362 }
363
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];
367 }
368
369 /* Fill in new debug class levels */
370 for (; i < debug_num_classes && params[i]; i++) {
371 char *saveptr;
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);
376 } else {
377 DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
378 return false;
379 }
380 }
381
382 return true;
383}
384
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****************************************************************************/
390
391bool debug_parse_levels(const char *params_str)
392{
393 char **params;
394
395 /* Just in case */
396 debug_init();
397
398 params = str_list_make(NULL, params_str, NULL);
399
400 if (debug_parse_params(params)) {
401 debug_dump_status(5);
402 TALLOC_FREE(params);
403 return true;
404 } else {
405 TALLOC_FREE(params);
406 return false;
407 }
408}
409
410/* setup for logging of talloc warnings */
411static void talloc_log_fn(const char *msg)
412{
413 DEBUG(0,("%s", msg));
414}
415
416void debug_setup_talloc_log(void)
417{
418 talloc_set_log_fn(talloc_log_fn);
419}
420
421
422/****************************************************************************
423Init debugging (one time stuff)
424****************************************************************************/
425
426static void debug_init(void)
427{
428 const char **p;
429
430 if (state.initialized)
431 return;
432
433 state.initialized = true;
434
435 debug_setup_talloc_log();
436
437 for(p = default_classname_table; *p; p++) {
438 debug_add_class(*p);
439 }
440 format_bufr = talloc_array(NULL, char, FORMAT_BUFR_SIZE);
441 if (!format_bufr) {
442 smb_panic("debug_init: unable to create buffer");
443 }
444}
445
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 */
449void debug_set_settings(struct debug_settings *settings)
450{
451 state.settings = *settings;
452}
453
454/**
455 control the name of the logfile and whether logging will be to stdout, stderr
456 or a file, and set up syslog
457
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
463*/
464void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
465{
466 debug_init();
467 if (state.logtype < new_logtype) {
468 state.logtype = new_logtype;
469 }
470 if (prog_name) {
471 state.prog_name = prog_name;
472 }
473 reopen_logs_internal();
474
475 if (state.logtype == DEBUG_FILE) {
476#ifdef WITH_SYSLOG
477 const char *p = strrchr_m( prog_name,'/' );
478 if (p)
479 prog_name = p + 1;
480#ifdef LOG_DAEMON
481 openlog( prog_name, LOG_PID, SYSLOG_FACILITY );
482#else
483 /* for old systems that have no facility codes. */
484 openlog( prog_name, LOG_PID );
485#endif
486#endif
487 }
488}
489
490/***************************************************************************
491 Set the logfile name.
492**************************************************************************/
493
494void debug_set_logfile(const char *name)
495{
496 if (name == NULL || *name == 0) {
497 /* this copes with calls when smb.conf is not loaded yet */
498 return;
499 }
500 TALLOC_FREE(state.debugf);
501 state.debugf = talloc_strdup(NULL, name);
502#ifdef __OS2__
503 /* Remove trailing dots that may appear after using % variables in the
504 * file name specification - rename() barfs on them. */
505 size_t len = strlen(state.debugf);
506 while (len && state.debugf[--len] == '.')
507 state.debugf[len] = '\0';
508#endif
509}
510
511static void debug_close_fd(int fd)
512{
513 if (fd > 2) {
514 close(fd);
515 }
516}
517
518bool debug_get_output_is_stderr(void)
519{
520 return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
521}
522
523/**************************************************************************
524 reopen the log files
525 note that we now do this unconditionally
526 We attempt to open the new debug fp before closing the old. This means
527 if we run out of fd's we just keep using the old fd rather than aborting.
528 Fix from dgibson@linuxcare.com.
529**************************************************************************/
530
531/**
532 reopen the log file (usually called because the log file name might have changed)
533*/
534bool reopen_logs_internal(void)
535{
536 mode_t oldumask;
537 int new_fd = 0;
538 int old_fd = 0;
539 bool ret = true;
540
541 char *fname = NULL;
542 if (state.reopening_logs) {
543 return true;
544 }
545
546 /* Now clear the SIGHUP induced flag */
547 state.schedule_reopen_logs = false;
548
549 switch (state.logtype) {
550 case DEBUG_STDOUT:
551 debug_close_fd(state.fd);
552 state.fd = 1;
553 return true;
554
555 case DEBUG_DEFAULT_STDERR:
556 case DEBUG_STDERR:
557 debug_close_fd(state.fd);
558 state.fd = 2;
559 return true;
560
561 case DEBUG_FILE:
562 break;
563 }
564
565 oldumask = umask( 022 );
566
567 fname = state.debugf;
568 if (!fname) {
569 return false;
570 }
571
572 state.reopening_logs = true;
573
574 new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
575
576 if (new_fd == -1) {
577 log_overflow = true;
578 DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
579 log_overflow = false;
580 ret = false;
581 } else {
582 old_fd = state.fd;
583 state.fd = new_fd;
584 debug_close_fd(old_fd);
585 }
586
587 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
588 * to fix problem where smbd's that generate less
589 * than 100 messages keep growing the log.
590 */
591 force_check_log_size();
592 (void)umask(oldumask);
593
594 /* Take over stderr to catch output into logs */
595 if (state.fd > 0 && dup2(state.fd, 2) == -1) {
596 close_low_fds(true); /* Close stderr too, if dup2 can't point it
597 at the logfile */
598 }
599
600 state.reopening_logs = false;
601
602 return ret;
603}
604
605/**************************************************************************
606 Force a check of the log size.
607 ***************************************************************************/
608
609void force_check_log_size( void )
610{
611 debug_count = 100;
612}
613
614_PUBLIC_ void debug_schedule_reopen_logs(void)
615{
616 state.schedule_reopen_logs = true;
617}
618
619
620/***************************************************************************
621 Check to see if there is any need to check if the logfile has grown too big.
622**************************************************************************/
623
624bool need_to_check_log_size( void )
625{
626 int maxlog;
627
628 if( debug_count < 100)
629 return( false );
630
631 maxlog = state.settings.max_log_size * 1024;
632 if ( state.fd <=2 || maxlog <= 0 ) {
633 debug_count = 0;
634 return(false);
635 }
636 return( true );
637}
638
639/**************************************************************************
640 Check to see if the log has grown to be too big.
641 **************************************************************************/
642
643void check_log_size( void )
644{
645 int maxlog;
646 struct stat st;
647#ifdef __OS2__
648 int force_trunc = 0;
649#endif
650
651 /*
652 * We need to be root to check/change log-file, skip this and let the main
653 * loop check do a new check as root.
654 */
655
656 if( geteuid() != 0) {
657 /* We don't check sec_initial_uid() here as it isn't
658 * available in common code and we don't generally
659 * want to rotate and the possibly lose logs in
660 * make test or the build farm */
661 return;
662 }
663
664 if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
665 return;
666 }
667
668 maxlog = state.settings.max_log_size * 1024;
669
670 if (state.schedule_reopen_logs ||
671 (fstat(state.fd, &st) == 0
672 && st.st_size > maxlog )) {
673 (void)reopen_logs_internal();
674 if (state.fd > 0 && fstat(state.fd, &st) == 0) {
675 if (st.st_size > maxlog) {
676 char *name = NULL;
677
678 if (asprintf(&name, "%s.old", state.debugf ) < 0) {
679 return;
680 }
681#ifdef __OS2__
682 /* Renaming an open file is not possible on
683 * OS/2 so we close it and then rename. Note
684 * that if this log file is also in use by
685 * another process, rename will still fail; in
686 * this case we fall back to simply truncating
687 * the current file to stop its growth. */
688 debug_close_fd(state.fd);
689 state.fd = -1;
690 if (rename(state.debugf, name) == -1) {
691 /* Most likely, some other samba process
692 * is using this log file. In either case
693 * our only option is to truncate it. */
694 force_trunc = 1;
695 }
696 if (reopen_logs_internal() && force_trunc) {
697 ftruncate(state.fd, 0);
698 }
699#else
700 (void)rename(state.debugf, name);
701
702 if (!reopen_logs_internal()) {
703 /* We failed to reopen a log - continue using the old name. */
704 (void)rename(name, state.debugf);
705 }
706#endif
707 SAFE_FREE(name);
708 }
709 }
710 }
711
712 /*
713 * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
714 */
715
716 if (state.fd <= 0) {
717 /* This code should only be reached in very strange
718 * circumstances. If we merely fail to open the new log we
719 * should stick with the old one. ergo this should only be
720 * reached when opening the logs for the first time: at
721 * startup or when the log level is increased from zero.
722 * -dwg 6 June 2000
723 */
724 int fd = open( "/dev/console", O_WRONLY, 0);
725 if (fd != -1) {
726 state.fd = fd;
727 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
728 state.debugf ));
729 } else {
730 /*
731 * We cannot continue without a debug file handle.
732 */
733 abort();
734 }
735 }
736 debug_count = 0;
737}
738
739/*************************************************************************
740 Write an debug message on the debugfile.
741 This is called by dbghdr() and format_debug_text().
742************************************************************************/
743
744 int Debug1( const char *format_str, ... )
745{
746 va_list ap;
747 int old_errno = errno;
748
749 debug_count++;
750
751 if ( state.logtype != DEBUG_FILE ) {
752 va_start( ap, format_str );
753 if (state.fd > 0)
754 (void)vdprintf( state.fd, format_str, ap );
755 va_end( ap );
756 errno = old_errno;
757 goto done;
758 }
759
760#ifdef WITH_SYSLOG
761 if( !state.settings.syslog_only)
762#endif
763 {
764 if( state.fd <= 0 ) {
765 mode_t oldumask = umask( 022 );
766 int fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
767 (void)umask( oldumask );
768 if(fd == -1) {
769 errno = old_errno;
770 goto done;
771 }
772 state.fd = fd;
773 }
774 }
775
776#ifdef WITH_SYSLOG
777 if( syslog_level < state.settings.syslog ) {
778 /* map debug levels to syslog() priorities
779 * note that not all DEBUG(0, ...) calls are
780 * necessarily errors */
781 static const int priority_map[4] = {
782 LOG_ERR, /* 0 */
783 LOG_WARNING, /* 1 */
784 LOG_NOTICE, /* 2 */
785 LOG_INFO, /* 3 */
786 };
787 int priority;
788 char *msgbuf = NULL;
789 int ret;
790
791 if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
792 priority = LOG_DEBUG;
793 else
794 priority = priority_map[syslog_level];
795
796 /*
797 * Specify the facility to interoperate with other syslog
798 * callers (vfs_full_audit for example).
799 */
800 priority |= SYSLOG_FACILITY;
801
802 va_start(ap, format_str);
803 ret = vasprintf(&msgbuf, format_str, ap);
804 va_end(ap);
805
806 if (ret != -1) {
807 syslog(priority, "%s", msgbuf);
808 }
809 SAFE_FREE(msgbuf);
810 }
811#endif
812
813 check_log_size();
814
815#ifdef WITH_SYSLOG
816 if( !state.settings.syslog_only)
817#endif
818 {
819 va_start( ap, format_str );
820 if (state.fd > 0)
821 (void)vdprintf( state.fd, format_str, ap );
822 va_end( ap );
823 }
824
825 done:
826 errno = old_errno;
827
828 return( 0 );
829}
830
831
832/**************************************************************************
833 Print the buffer content via Debug1(), then reset the buffer.
834 Input: none
835 Output: none
836****************************************************************************/
837
838static void bufr_print( void )
839{
840 format_bufr[format_pos] = '\0';
841 (void)Debug1( "%s", format_bufr );
842 format_pos = 0;
843}
844
845/***************************************************************************
846 Format the debug message text.
847
848 Input: msg - Text to be added to the "current" debug message text.
849
850 Output: none.
851
852 Notes: The purpose of this is two-fold. First, each call to syslog()
853 (used by Debug1(), see above) generates a new line of syslog
854 output. This is fixed by storing the partial lines until the
855 newline character is encountered. Second, printing the debug
856 message lines when a newline is encountered allows us to add
857 spaces, thus indenting the body of the message and making it
858 more readable.
859**************************************************************************/
860
861static void format_debug_text( const char *msg )
862{
863 size_t i;
864 bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
865
866 if (!format_bufr) {
867 debug_init();
868 }
869
870 for( i = 0; msg[i]; i++ ) {
871 /* Indent two spaces at each new line. */
872 if(timestamp && 0 == format_pos) {
873 format_bufr[0] = format_bufr[1] = ' ';
874 format_pos = 2;
875 }
876
877 /* If there's room, copy the character to the format buffer. */
878 if( format_pos < FORMAT_BUFR_MAX )
879 format_bufr[format_pos++] = msg[i];
880
881 /* If a newline is encountered, print & restart. */
882 if( '\n' == msg[i] )
883 bufr_print();
884
885 /* If the buffer is full dump it out, reset it, and put out a line
886 * continuation indicator.
887 */
888 if( format_pos >= FORMAT_BUFR_MAX ) {
889 bufr_print();
890 (void)Debug1( " +>\n" );
891 }
892 }
893
894 /* Just to be safe... */
895 format_bufr[format_pos] = '\0';
896}
897
898/***************************************************************************
899 Flush debug output, including the format buffer content.
900
901 Input: none
902 Output: none
903***************************************************************************/
904
905void dbgflush( void )
906{
907 bufr_print();
908}
909
910/***************************************************************************
911 Print a Debug Header.
912
913 Input: level - Debug level of the message (not the system-wide debug
914 level. )
915 cls - Debuglevel class of the calling module.
916 file - Pointer to a string containing the name of the file
917 from which this function was called, or an empty string
918 if the __FILE__ macro is not implemented.
919 func - Pointer to a string containing the name of the function
920 from which this function was called, or an empty string
921 if the __FUNCTION__ macro is not implemented.
922 line - line number of the call to dbghdr, assuming __LINE__
923 works.
924
925 Output: Always true. This makes it easy to fudge a call to dbghdr()
926 in a macro, since the function can be called as part of a test.
927 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
928
929 Notes: This function takes care of setting syslog_level.
930
931****************************************************************************/
932
933bool dbghdrclass(int level, int cls, const char *location, const char *func)
934{
935 /* Ensure we don't lose any real errno value. */
936 int old_errno = errno;
937
938 if( format_pos ) {
939 /* This is a fudge. If there is stuff sitting in the format_bufr, then
940 * the *right* thing to do is to call
941 * format_debug_text( "\n" );
942 * to write the remainder, and then proceed with the new header.
943 * Unfortunately, there are several places in the code at which
944 * the DEBUG() macro is used to build partial lines. That in mind,
945 * we'll work under the assumption that an incomplete line indicates
946 * that a new header is *not* desired.
947 */
948 return( true );
949 }
950
951#ifdef WITH_SYSLOG
952 /* Set syslog_level. */
953 syslog_level = level;
954#endif
955
956 /* Don't print a header if we're logging to stdout. */
957 if ( state.logtype != DEBUG_FILE ) {
958 return( true );
959 }
960
961 /* Print the header if timestamps are turned on. If parameters are
962 * not yet loaded, then default to timestamps on.
963 */
964 if( state.settings.timestamp_logs || state.settings.debug_prefix_timestamp) {
965 char header_str[200];
966
967 header_str[0] = '\0';
968
969 if( state.settings.debug_pid)
970 slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)getpid());
971
972 if( state.settings.debug_uid) {
973 size_t hs_len = strlen(header_str);
974 slprintf(header_str + hs_len,
975 sizeof(header_str) - 1 - hs_len,
976 ", effective(%u, %u), real(%u, %u)",
977 (unsigned int)geteuid(), (unsigned int)getegid(),
978 (unsigned int)getuid(), (unsigned int)getgid());
979 }
980
981 if (state.settings.debug_class && (cls != DBGC_ALL)) {
982 size_t hs_len = strlen(header_str);
983 slprintf(header_str + hs_len,
984 sizeof(header_str) -1 - hs_len,
985 ", class=%s",
986 classname_table[cls]);
987 }
988
989 /* Print it all out at once to prevent split syslog output. */
990 if( state.settings.debug_prefix_timestamp ) {
991 char *time_str = current_timestring(NULL,
992 state.settings.debug_hires_timestamp);
993 (void)Debug1( "[%s, %2d%s] ",
994 time_str,
995 level, header_str);
996 talloc_free(time_str);
997 } else {
998 char *time_str = current_timestring(NULL,
999 state.settings.debug_hires_timestamp);
1000 (void)Debug1( "[%s, %2d%s] %s(%s)\n",
1001 time_str,
1002 level, header_str, location, func );
1003 talloc_free(time_str);
1004 }
1005 }
1006
1007 errno = old_errno;
1008 return( true );
1009}
1010
1011/***************************************************************************
1012 Add text to the body of the "current" debug message via the format buffer.
1013
1014 Input: format_str - Format string, as used in printf(), et. al.
1015 ... - Variable argument list.
1016
1017 ..or.. va_alist - Old style variable parameter list starting point.
1018
1019 Output: Always true. See dbghdr() for more info, though this is not
1020 likely to be used in the same way.
1021
1022***************************************************************************/
1023
1024 bool dbgtext( const char *format_str, ... )
1025{
1026 va_list ap;
1027 char *msgbuf = NULL;
1028 bool ret = true;
1029 int res;
1030
1031 va_start(ap, format_str);
1032 res = vasprintf(&msgbuf, format_str, ap);
1033 va_end(ap);
1034
1035 if (res != -1) {
1036 format_debug_text(msgbuf);
1037 } else {
1038 ret = false;
1039 }
1040 SAFE_FREE(msgbuf);
1041 return ret;
1042}
1043
1044
1045/* the registered mutex handlers */
1046static struct {
1047 const char *name;
1048 struct debug_ops ops;
1049} debug_handlers;
1050
1051/**
1052 log suspicious usage - print comments and backtrace
1053*/
1054_PUBLIC_ void log_suspicious_usage(const char *from, const char *info)
1055{
1056 if (!debug_handlers.ops.log_suspicious_usage) return;
1057
1058 debug_handlers.ops.log_suspicious_usage(from, info);
1059}
1060
1061
1062/**
1063 print suspicious usage - print comments and backtrace
1064*/
1065_PUBLIC_ void print_suspicious_usage(const char* from, const char* info)
1066{
1067 if (!debug_handlers.ops.print_suspicious_usage) return;
1068
1069 debug_handlers.ops.print_suspicious_usage(from, info);
1070}
1071
1072_PUBLIC_ uint32_t get_task_id(void)
1073{
1074 if (debug_handlers.ops.get_task_id) {
1075 return debug_handlers.ops.get_task_id();
1076 }
1077 return getpid();
1078}
1079
1080_PUBLIC_ void log_task_id(void)
1081{
1082 if (!debug_handlers.ops.log_task_id) return;
1083
1084 if (!reopen_logs_internal()) return;
1085
1086 debug_handlers.ops.log_task_id(state.fd);
1087}
1088
1089/**
1090 register a set of debug handlers.
1091*/
1092_PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops)
1093{
1094 debug_handlers.name = name;
1095 debug_handlers.ops = *ops;
1096}
Note: See TracBrowser for help on using the repository browser.