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