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