01aedb47740ec5fa1987ecb6a31a7fbe6aff5d02
[tprouty/samba.git] / source / lib / debug.c
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
81 XFILE   *dbf        = NULL;
82 pstring debugf     = "";
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 /*
95  * This is to allow assignment to DEBUGLEVEL before the debug
96  * system has been initialised.
97  */
98 static int debug_all_class_hack = 1;
99 static BOOL debug_all_class_isset_hack = True;
100
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;
104
105 /* DEBUGLEVEL is #defined to *debug_level */
106 int     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
136 static BOOL    stdout_logging = False;
137 static int     debug_count    = 0;
138 #ifdef WITH_SYSLOG
139 static int     syslog_level   = 0;
140 #endif
141 static pstring format_bufr    = { '\0' };
142 static size_t     format_pos     = 0;
143 static 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  */
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        */
166         "acls",              /* DBGC_ACLS         */
167         NULL
168 };
169
170 static char **classname_table = NULL;
171
172
173 /* -------------------------------------------------------------------------- **
174  * Functions...
175  */
176
177
178 /****************************************************************************
179 utility lists registered debug class names's
180 ****************************************************************************/
181
182 #define MAX_CLASS_NAME_SIZE 1024
183
184 static char *debug_list_class_names_and_levels(void)
185 {
186         int i, dim;
187         char **list;
188         char *buf = NULL;
189         char *b;
190         BOOL err = False;
191
192         if (DEBUGLEVEL_CLASS == &debug_all_class_hack)
193                 return NULL;
194
195         list = calloc(debug_num_classes + 1, sizeof(char *));
196         if (!list)
197                 return NULL;
198
199         /* prepare strings */
200         for (i = 0, dim = 0; i < debug_num_classes; i++) {
201                 int l = asprintf(&list[i],
202                                 "%s:%d ",
203                                 classname_table[i],
204                                 DEBUGLEVEL_CLASS_ISSET[i]?DEBUGLEVEL_CLASS[i]:DEBUGLEVEL);
205                 if (l < 0 || l > MAX_CLASS_NAME_SIZE) {
206                         err = True;
207                         goto done;
208                 }
209                 dim += l;
210         }
211
212         /* create single string list - add space for newline */
213         b = buf = malloc(dim+1);
214         if (!buf) {
215                 err = True;
216                 goto done;
217         }
218         for (i = 0; i < debug_num_classes; i++) {
219                 int l = strlen(list[i]);
220                 strncpy(b, list[i], l);
221                 b = b + l;
222         }
223         b[-1] = '\n'; /* replace last space with newline */
224         b[0] = '\0';  /* null terminate string */
225
226 done:
227         /* free strings list */
228         for (i = 0; i < debug_num_classes; i++)
229                 if (list[i]) free(list[i]);
230         free(list);
231
232         if (err) {
233                 if (buf)
234                         free(buf);
235                 return NULL;
236         } else {
237                 return buf;
238         }
239 }
240
241 /****************************************************************************
242  Utility access to debug class names's.
243 ****************************************************************************/
244
245 const char *debug_classname_from_index(int ndx)
246 {
247         if (ndx < 0 || ndx >= debug_num_classes)
248                 return NULL;
249         else
250                 return classname_table[ndx];
251 }
252
253 /****************************************************************************
254  Utility to translate names to debug class index's (internal version).
255 ****************************************************************************/
256
257 static int debug_lookup_classname_int(const char* classname)
258 {
259         int i;
260
261         if (!classname) return -1;
262
263         for (i=0; i < debug_num_classes; i++) {
264                 if (strcmp(classname, classname_table[i])==0)
265                         return i;
266         }
267         return -1;
268 }
269
270 /****************************************************************************
271  Add a new debug class to the system.
272 ****************************************************************************/
273
274 int debug_add_class(const char *classname)
275 {
276         int ndx;
277         void *new_ptr;
278
279         if (!classname)
280                 return -1;
281
282         /* check the init has yet been called */
283         debug_init();
284
285         ndx = debug_lookup_classname_int(classname);
286         if (ndx >= 0)
287                 return ndx;
288         ndx = debug_num_classes;
289
290         new_ptr = DEBUGLEVEL_CLASS;
291         if (DEBUGLEVEL_CLASS == &debug_all_class_hack) {
292                 /* Initial loading... */
293                 new_ptr = NULL;
294         }
295         new_ptr = Realloc(new_ptr, sizeof(int) * (debug_num_classes + 1));
296         if (!new_ptr)
297                 return -1;
298         DEBUGLEVEL_CLASS = new_ptr;
299         DEBUGLEVEL_CLASS[ndx] = 0;
300
301         /* debug_level is the pointer used for the DEBUGLEVEL-thingy */
302         if (ndx==0) {
303                 /* Transfer the initial level from debug_all_class_hack */
304                 DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL;
305         }
306         debug_level = DEBUGLEVEL_CLASS;
307
308         new_ptr = DEBUGLEVEL_CLASS_ISSET;
309         if (new_ptr == &debug_all_class_isset_hack) {
310                 new_ptr = NULL;
311         }
312         new_ptr = Realloc(new_ptr, sizeof(BOOL) * (debug_num_classes + 1));
313         if (!new_ptr)
314                 return -1;
315         DEBUGLEVEL_CLASS_ISSET = new_ptr;
316         DEBUGLEVEL_CLASS_ISSET[ndx] = False;
317
318         new_ptr = Realloc(classname_table,
319                           sizeof(char *) * (debug_num_classes + 1));
320         if (!new_ptr)
321                 return -1;
322         classname_table = new_ptr;
323
324         classname_table[ndx] = strdup(classname);
325         if (! classname_table[ndx])
326                 return -1;
327         
328         debug_num_classes++;
329
330         return ndx;
331 }
332
333 /****************************************************************************
334  Utility to translate names to debug class index's (public version).
335 ****************************************************************************/
336
337 int debug_lookup_classname(const char *classname)
338 {
339         int ndx;
340        
341         if (!classname || !*classname)
342                 return -1;
343
344         ndx = debug_lookup_classname_int(classname);
345
346         if (ndx != -1)
347                 return ndx;
348
349         if (debug_warn_unknown_class) {
350                 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
351                           classname));
352         }
353         if (debug_auto_add_unknown_class) {
354                 return debug_add_class(classname);
355         }
356         return -1;
357 }
358
359 /****************************************************************************
360  Dump the current registered debug levels.
361 ****************************************************************************/
362
363 static void debug_dump_status(int level)
364 {
365         int q;
366
367         DEBUG(level, ("INFO: Current debug levels:\n"));
368         for (q = 0; q < debug_num_classes; q++) {
369                 DEBUGADD(level, ("  %s: %s/%d\n",
370                                  classname_table[q],
371                                  (DEBUGLEVEL_CLASS_ISSET[q]
372                                   ? "True" : "False"),
373                                  DEBUGLEVEL_CLASS[q]));
374         }
375 }
376
377 /****************************************************************************
378  parse the debug levels from smbcontrol. Example debug level parameter:
379  printdrivers:7
380 ****************************************************************************/
381
382 static BOOL debug_parse_params(char **params)
383 {
384         int   i, ndx;
385         char *class_name;
386         char *class_level;
387
388         if (!params)
389                 return False;
390
391         /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"  
392          * v.s. "all:10", this is the traditional way to set DEBUGLEVEL 
393          */
394         if (isdigit((int)params[0][0])) {
395                 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
396                 DEBUGLEVEL_CLASS_ISSET[DBGC_ALL] = True;
397                 i = 1; /* start processing at the next params */
398         } else {
399                 i = 0; /* DBGC_ALL not specified OR class name was included */
400         }
401
402         /* Fill in new debug class levels */
403         for (; i < debug_num_classes && params[i]; i++) {
404                 if ((class_name=strtok(params[i],":")) &&
405                         (class_level=strtok(NULL, "\0")) &&
406             ((ndx = debug_lookup_classname(class_name)) != -1)) {
407                                 DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
408                                 DEBUGLEVEL_CLASS_ISSET[ndx] = True;
409                 } else {
410                         DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
411                         return False;
412                 }
413         }
414
415         return True;
416 }
417
418 /****************************************************************************
419  Parse the debug levels from smb.conf. Example debug level string:
420   3 tdb:5 printdrivers:7
421  Note: the 1st param has no "name:" preceeding it.
422 ****************************************************************************/
423
424 BOOL debug_parse_levels(const char *params_str)
425 {
426         char **params;
427
428         /* Just in case */
429         debug_init();
430
431         if (AllowDebugChange == False)
432                 return True;
433
434         params = str_list_make(params_str, NULL);
435
436         if (debug_parse_params(params)) {
437                 debug_dump_status(5);
438                 str_list_free(&params);
439                 return True;
440         } else {
441                 str_list_free(&params);
442                 return False;
443         }
444 }
445
446 /****************************************************************************
447  Receive a "set debug level" message.
448 ****************************************************************************/
449
450 static void debug_message(int msg_type, pid_t src, void *buf, size_t len)
451 {
452         const char *params_str = buf;
453
454         /* Check, it's a proper string! */
455         if (params_str[len-1] != '\0') {
456                 DEBUG(1, ("Invalid debug message from pid %u to pid %u\n",
457                           (unsigned int)src, (unsigned int)getpid()));
458                 return;
459         }
460
461         DEBUG(3, ("INFO: Remote set of debug to `%s'  (pid %u from pid %u)\n",
462                   params_str, (unsigned int)getpid(), (unsigned int)src));
463
464         debug_parse_levels(params_str);
465 }
466
467 /****************************************************************************
468  Send a "set debug level" message.
469 ****************************************************************************/
470
471 void debug_message_send(pid_t pid, const char *params_str)
472 {
473         if (!params_str)
474                 return;
475         message_send_pid(pid, MSG_DEBUG, params_str, strlen(params_str) + 1,
476                          False);
477 }
478
479 /****************************************************************************
480  Return current debug level.
481 ****************************************************************************/
482
483 static void debuglevel_message(int msg_type, pid_t src, void *buf, size_t len)
484 {
485         char *message = debug_list_class_names_and_levels();
486
487         DEBUG(1,("INFO: Received REQ_DEBUGLEVEL message from PID %u\n",(unsigned int)src));
488         message_send_pid(src, MSG_DEBUGLEVEL, message, strlen(message) + 1, True);
489
490         SAFE_FREE(message);
491 }
492
493 /****************************************************************************
494 Init debugging (one time stuff)
495 ****************************************************************************/
496
497 void debug_init(void)
498 {
499         static BOOL initialised = False;
500         const char **p;
501
502         if (initialised)
503                 return;
504         
505         initialised = True;
506
507         message_register(MSG_DEBUG, debug_message);
508         message_register(MSG_REQ_DEBUGLEVEL, debuglevel_message);
509
510         for(p = default_classname_table; *p; p++) {
511                 debug_add_class(*p);
512         }
513 }
514
515 /***************************************************************************
516  Get ready for syslog stuff
517 **************************************************************************/
518
519 void setup_logging(const char *pname, BOOL interactive)
520 {
521         debug_init();
522
523         /* reset to allow multiple setup calls, going from interactive to
524            non-interactive */
525         stdout_logging = False;
526         if (dbf) {
527                 x_fflush(dbf);
528                 (void) x_fclose(dbf);
529         }
530
531         dbf = NULL;
532
533         if (interactive) {
534                 stdout_logging = True;
535                 dbf = x_stdout;
536                 x_setbuf( x_stdout, NULL );
537         }
538 #ifdef WITH_SYSLOG
539         else {
540                 const char *p = strrchr_m( pname,'/' );
541                 if (p)
542                         pname = p + 1;
543 #ifdef LOG_DAEMON
544                 openlog( pname, LOG_PID, SYSLOG_FACILITY );
545 #else
546                 /* for old systems that have no facility codes. */
547                 openlog( pname, LOG_PID );
548 #endif
549         }
550 #endif
551 }
552
553 /**************************************************************************
554  reopen the log files
555  note that we now do this unconditionally
556  We attempt to open the new debug fp before closing the old. This means
557  if we run out of fd's we just keep using the old fd rather than aborting.
558  Fix from dgibson@linuxcare.com.
559 **************************************************************************/
560
561 BOOL reopen_logs( void )
562 {
563         pstring fname;
564         mode_t oldumask;
565         XFILE *new_dbf = NULL;
566         XFILE *old_dbf = NULL;
567         BOOL ret = True;
568
569         if (stdout_logging)
570                 return True;
571
572         oldumask = umask( 022 );
573   
574         pstrcpy(fname, debugf );
575         debugf[0] = '\0';
576
577         if (lp_loaded()) {
578                 char *logfname;
579
580                 logfname = lp_logfile();
581                 if (*logfname)
582                         pstrcpy(fname, logfname);
583         }
584
585         pstrcpy( debugf, fname );
586         new_dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
587
588         if (!new_dbf) {
589                 log_overflow = True;
590                 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
591                 log_overflow = False;
592                 if (dbf)
593                         x_fflush(dbf);
594                 ret = False;
595         } else {
596                 x_setbuf(new_dbf, NULL);
597                 old_dbf = dbf;
598                 dbf = new_dbf;
599                 if (old_dbf)
600                         (void) x_fclose(old_dbf);
601         }
602
603         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
604          * to fix problem where smbd's that generate less
605          * than 100 messages keep growing the log.
606          */
607         force_check_log_size();
608         (void)umask(oldumask);
609
610         /* Take over stderr to catch ouput into logs */
611         if (dbf && sys_dup2(x_fileno(dbf), 2) == -1) {
612                 close_low_fds(True); /* Close stderr too, if dup2 can't point it
613                                         at the logfile */
614         }
615
616         return ret;
617 }
618
619 /**************************************************************************
620  Force a check of the log size.
621  ***************************************************************************/
622
623 void force_check_log_size( void )
624 {
625         debug_count = 100;
626 }
627
628 /***************************************************************************
629  Check to see if there is any need to check if the logfile has grown too big.
630 **************************************************************************/
631
632 BOOL need_to_check_log_size( void )
633 {
634         int maxlog;
635
636         if( debug_count < 100 )
637                 return( False );
638
639         maxlog = lp_max_log_size() * 1024;
640         if( !dbf || maxlog <= 0 ) {
641                 debug_count = 0;
642                 return(False);
643         }
644         return( True );
645 }
646
647 /**************************************************************************
648  Check to see if the log has grown to be too big.
649  **************************************************************************/
650
651 void check_log_size( void )
652 {
653         int         maxlog;
654         SMB_STRUCT_STAT st;
655
656         /*
657          *  We need to be root to check/change log-file, skip this and let the main
658          *  loop check do a new check as root.
659          */
660
661         if( geteuid() != 0 )
662                 return;
663
664         if(log_overflow || !need_to_check_log_size() )
665                 return;
666
667         maxlog = lp_max_log_size() * 1024;
668
669         if( sys_fstat( x_fileno( dbf ), &st ) == 0 && st.st_size > maxlog ) {
670                 (void)reopen_logs();
671                 if( dbf && get_file_size( debugf ) > maxlog ) {
672                         pstring name;
673
674                         slprintf( name, sizeof(name)-1, "%s.old", debugf );
675                         (void)rename( debugf, name );
676       
677                         if (!reopen_logs()) {
678                                 /* We failed to reopen a log - continue using the old name. */
679                                 (void)rename(name, debugf);
680                         }
681                 }
682         }
683
684         /*
685          * Here's where we need to panic if dbf == NULL..
686          */
687
688         if(dbf == NULL) {
689                 /* This code should only be reached in very strange
690                  * circumstances. If we merely fail to open the new log we
691                  * should stick with the old one. ergo this should only be
692                  * reached when opening the logs for the first time: at
693                  * startup or when the log level is increased from zero.
694                  * -dwg 6 June 2000
695                  */
696                 dbf = x_fopen( "/dev/console", O_WRONLY, 0);
697                 if(dbf) {
698                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
699                                         debugf ));
700                 } else {
701                         /*
702                          * We cannot continue without a debug file handle.
703                          */
704                         abort();
705                 }
706         }
707         debug_count = 0;
708 }
709
710 /*************************************************************************
711  Write an debug message on the debugfile.
712  This is called by dbghdr() and format_debug_text().
713 ************************************************************************/
714
715  int Debug1( const char *format_str, ... )
716 {
717         va_list ap;  
718         int old_errno = errno;
719
720         debug_count++;
721
722         if( stdout_logging ) {
723                 va_start( ap, format_str );
724                 if(dbf)
725                         (void)x_vfprintf( dbf, format_str, ap );
726                 va_end( ap );
727                 errno = old_errno;
728                 return( 0 );
729         }
730
731         /* prevent recursion by checking if reopen_logs() has temporaily
732            set the debugf string to "" */
733         if( debugf[0] == '\0')
734                 return( 0 );
735
736 #ifdef WITH_SYSLOG
737         if( !lp_syslog_only() )
738 #endif
739         {
740                 if( !dbf ) {
741                         mode_t oldumask = umask( 022 );
742
743                         dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
744                         (void)umask( oldumask );
745                         if( dbf ) {
746                                 x_setbuf( dbf, NULL );
747                         } else {
748                                 errno = old_errno;
749                                 return(0);
750                         }
751                 }
752         }
753
754 #ifdef WITH_SYSLOG
755         if( syslog_level < lp_syslog() ) {
756                 /* map debug levels to syslog() priorities
757                  * note that not all DEBUG(0, ...) calls are
758                  * necessarily errors */
759                 static int priority_map[] = { 
760                         LOG_ERR,     /* 0 */
761                         LOG_WARNING, /* 1 */
762                         LOG_NOTICE,  /* 2 */
763                         LOG_INFO,    /* 3 */
764                 };
765                 int     priority;
766                 pstring msgbuf;
767
768                 if( syslog_level >= ( sizeof(priority_map) / sizeof(priority_map[0]) ) || syslog_level < 0)
769                         priority = LOG_DEBUG;
770                 else
771                         priority = priority_map[syslog_level];
772
773                 va_start( ap, format_str );
774                 vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
775                 va_end( ap );
776
777                 msgbuf[255] = '\0';
778                 syslog( priority, "%s", msgbuf );
779         }
780 #endif
781   
782         check_log_size();
783
784 #ifdef WITH_SYSLOG
785         if( !lp_syslog_only() )
786 #endif
787         {
788                 va_start( ap, format_str );
789                 if(dbf)
790                         (void)x_vfprintf( dbf, format_str, ap );
791                 va_end( ap );
792                 if(dbf)
793                         (void)x_fflush( dbf );
794         }
795
796         errno = old_errno;
797
798         return( 0 );
799 }
800
801
802 /**************************************************************************
803  Print the buffer content via Debug1(), then reset the buffer.
804  Input:  none
805  Output: none
806 ****************************************************************************/
807
808 static void bufr_print( void )
809 {
810         format_bufr[format_pos] = '\0';
811         (void)Debug1( "%s", format_bufr );
812         format_pos = 0;
813 }
814
815 /***************************************************************************
816  Format the debug message text.
817
818  Input:  msg - Text to be added to the "current" debug message text.
819
820  Output: none.
821
822  Notes:  The purpose of this is two-fold.  First, each call to syslog()
823          (used by Debug1(), see above) generates a new line of syslog
824          output.  This is fixed by storing the partial lines until the
825          newline character is encountered.  Second, printing the debug
826          message lines when a newline is encountered allows us to add
827          spaces, thus indenting the body of the message and making it
828          more readable.
829 **************************************************************************/
830
831 static void format_debug_text( const char *msg )
832 {
833         size_t i;
834         BOOL timestamp = (!stdout_logging && (lp_timestamp_logs() || !(lp_loaded())));
835
836         for( i = 0; msg[i]; i++ ) {
837                 /* Indent two spaces at each new line. */
838                 if(timestamp && 0 == format_pos) {
839                         format_bufr[0] = format_bufr[1] = ' ';
840                         format_pos = 2;
841                 }
842
843                 /* If there's room, copy the character to the format buffer. */
844                 if( format_pos < FORMAT_BUFR_MAX )
845                         format_bufr[format_pos++] = msg[i];
846
847                 /* If a newline is encountered, print & restart. */
848                 if( '\n' == msg[i] )
849                         bufr_print();
850
851                 /* If the buffer is full dump it out, reset it, and put out a line
852                  * continuation indicator.
853                  */
854                 if( format_pos >= FORMAT_BUFR_MAX ) {
855                         bufr_print();
856                         (void)Debug1( " +>\n" );
857                 }
858         }
859
860         /* Just to be safe... */
861         format_bufr[format_pos] = '\0';
862 }
863
864 /***************************************************************************
865  Flush debug output, including the format buffer content.
866
867  Input:  none
868  Output: none
869 ***************************************************************************/
870
871 void dbgflush( void )
872 {
873         bufr_print();
874         if(dbf)
875                 (void)x_fflush( dbf );
876 }
877
878 /***************************************************************************
879  Print a Debug Header.
880
881  Input:  level - Debug level of the message (not the system-wide debug
882                   level. )
883           file  - Pointer to a string containing the name of the file
884                   from which this function was called, or an empty string
885                   if the __FILE__ macro is not implemented.
886           func  - Pointer to a string containing the name of the function
887                   from which this function was called, or an empty string
888                   if the __FUNCTION__ macro is not implemented.
889          line  - line number of the call to dbghdr, assuming __LINE__
890                  works.
891
892   Output: Always True.  This makes it easy to fudge a call to dbghdr()
893           in a macro, since the function can be called as part of a test.
894           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
895
896   Notes:  This function takes care of setting syslog_level.
897
898 ****************************************************************************/
899
900 BOOL dbghdr( int level, const char *file, const char *func, int line )
901 {
902         /* Ensure we don't lose any real errno value. */
903         int old_errno = errno;
904
905         if( format_pos ) {
906                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
907                  * the *right* thing to do is to call
908                  *   format_debug_text( "\n" );
909                  * to write the remainder, and then proceed with the new header.
910                  * Unfortunately, there are several places in the code at which
911                  * the DEBUG() macro is used to build partial lines.  That in mind,
912                  * we'll work under the assumption that an incomplete line indicates
913                  * that a new header is *not* desired.
914                  */
915                 return( True );
916         }
917
918 #ifdef WITH_SYSLOG
919         /* Set syslog_level. */
920         syslog_level = level;
921 #endif
922
923         /* Don't print a header if we're logging to stdout. */
924         if( stdout_logging )
925                 return( True );
926
927         /* Print the header if timestamps are turned on.  If parameters are
928          * not yet loaded, then default to timestamps on.
929          */
930         if( lp_timestamp_logs() || !(lp_loaded()) ) {
931                 char header_str[200];
932
933                 header_str[0] = '\0';
934
935                 if( lp_debug_pid())
936                         slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
937
938                 if( lp_debug_uid()) {
939                         size_t hs_len = strlen(header_str);
940                         slprintf(header_str + hs_len,
941                         sizeof(header_str) - 1 - hs_len,
942                                 ", effective(%u, %u), real(%u, %u)",
943                                 (unsigned int)geteuid(), (unsigned int)getegid(),
944                                 (unsigned int)getuid(), (unsigned int)getgid()); 
945                 }
946   
947                 /* Print it all out at once to prevent split syslog output. */
948                 (void)Debug1( "[%s, %d%s] %s:%s(%d)\n",
949                         timestring(lp_debug_hires_timestamp()), level,
950                         header_str, file, func, line );
951         }
952
953         errno = old_errno;
954         return( True );
955 }
956
957 /***************************************************************************
958  Add text to the body of the "current" debug message via the format buffer.
959
960   Input:  format_str  - Format string, as used in printf(), et. al.
961           ...         - Variable argument list.
962
963   ..or..  va_alist    - Old style variable parameter list starting point.
964
965   Output: Always True.  See dbghdr() for more info, though this is not
966           likely to be used in the same way.
967
968 ***************************************************************************/
969
970  BOOL dbgtext( const char *format_str, ... )
971 {
972         va_list ap;
973         pstring msgbuf;
974
975         va_start( ap, format_str ); 
976         vslprintf( msgbuf, sizeof(msgbuf)-1, format_str, ap );
977         va_end( ap );
978
979         format_debug_text( msgbuf );
980
981   return( True );
982 }