Fix ndrdump to use a common setup_logging() API
[ira/wip.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_v3(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    Just run logging to stdout for this program 
610 */
611 _PUBLIC_ void setup_logging_stdout(void)
612 {
613         setup_logging(NULL, True);
614 }
615
616
617 /***************************************************************************
618  Set the logfile name.
619 **************************************************************************/
620
621 void debug_set_logfile(const char *name)
622 {
623         SAFE_FREE(debugf);
624         debugf = SMB_STRDUP(name);
625 }
626
627 /**************************************************************************
628  reopen the log files
629  note that we now do this unconditionally
630  We attempt to open the new debug fp before closing the old. This means
631  if we run out of fd's we just keep using the old fd rather than aborting.
632  Fix from dgibson@linuxcare.com.
633 **************************************************************************/
634
635 bool reopen_logs( void )
636 {
637         char *fname = NULL;
638         mode_t oldumask;
639         XFILE *new_dbf = NULL;
640         XFILE *old_dbf = NULL;
641         bool ret = True;
642
643         if (stdout_logging)
644                 return True;
645
646         oldumask = umask( 022 );
647
648         fname = debugf;
649         if (!fname) {
650                 return false;
651         }
652         debugf = NULL;
653
654         if (lp_loaded()) {
655                 char *logfname;
656
657                 logfname = lp_logfile();
658                 if (*logfname) {
659                         SAFE_FREE(fname);
660                         fname = SMB_STRDUP(logfname);
661                         if (!fname) {
662                                 return false;
663                         }
664                 }
665         }
666
667         debugf = fname;
668         new_dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
669
670         if (!new_dbf) {
671                 log_overflow = True;
672                 DEBUG(0, ("Unable to open new log file %s: %s\n", debugf, strerror(errno)));
673                 log_overflow = False;
674                 if (dbf)
675                         x_fflush(dbf);
676                 ret = False;
677         } else {
678                 x_setbuf(new_dbf, NULL);
679                 old_dbf = dbf;
680                 dbf = new_dbf;
681                 if (old_dbf)
682                         (void) x_fclose(old_dbf);
683         }
684
685         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
686          * to fix problem where smbd's that generate less
687          * than 100 messages keep growing the log.
688          */
689         force_check_log_size();
690         (void)umask(oldumask);
691
692         /* Take over stderr to catch output into logs */
693         if (dbf && dup2(x_fileno(dbf), 2) == -1) {
694                 close_low_fds(True); /* Close stderr too, if dup2 can't point it
695                                         at the logfile */
696         }
697
698         return ret;
699 }
700
701 /**************************************************************************
702  Force a check of the log size.
703  ***************************************************************************/
704
705 void force_check_log_size( void )
706 {
707         debug_count = 100;
708 }
709
710 /***************************************************************************
711  Check to see if there is any need to check if the logfile has grown too big.
712 **************************************************************************/
713
714 bool need_to_check_log_size( void )
715 {
716         int maxlog;
717
718         if( debug_count < 100 )
719                 return( False );
720
721         maxlog = lp_max_log_size() * 1024;
722         if( !dbf || maxlog <= 0 ) {
723                 debug_count = 0;
724                 return(False);
725         }
726         return( True );
727 }
728
729 /**************************************************************************
730  Check to see if the log has grown to be too big.
731  **************************************************************************/
732
733 void check_log_size( void )
734 {
735         int         maxlog;
736         SMB_STRUCT_STAT st;
737
738         /*
739          *  We need to be root to check/change log-file, skip this and let the main
740          *  loop check do a new check as root.
741          */
742
743         if( geteuid() != 0 )
744                 return;
745
746         if(log_overflow || !need_to_check_log_size() )
747                 return;
748
749         maxlog = lp_max_log_size() * 1024;
750
751         if( sys_fstat( x_fileno( dbf ), &st ) == 0 && st.st_ex_size > maxlog ) {
752                 (void)reopen_logs();
753                 if( dbf && get_file_size( debugf ) > maxlog ) {
754                         char *name = NULL;
755
756                         if (asprintf(&name, "%s.old", debugf ) < 0) {
757                                 return;
758                         }
759                         (void)rename(debugf, name);
760
761                         if (!reopen_logs()) {
762                                 /* We failed to reopen a log - continue using the old name. */
763                                 (void)rename(name, debugf);
764                         }
765                         SAFE_FREE(name);
766                 }
767         }
768
769         /*
770          * Here's where we need to panic if dbf == NULL..
771          */
772
773         if(dbf == NULL) {
774                 /* This code should only be reached in very strange
775                  * circumstances. If we merely fail to open the new log we
776                  * should stick with the old one. ergo this should only be
777                  * reached when opening the logs for the first time: at
778                  * startup or when the log level is increased from zero.
779                  * -dwg 6 June 2000
780                  */
781                 dbf = x_fopen( "/dev/console", O_WRONLY, 0);
782                 if(dbf) {
783                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
784                                         debugf ));
785                 } else {
786                         /*
787                          * We cannot continue without a debug file handle.
788                          */
789                         abort();
790                 }
791         }
792         debug_count = 0;
793 }
794
795 /*************************************************************************
796  Write an debug message on the debugfile.
797  This is called by dbghdr() and format_debug_text().
798 ************************************************************************/
799
800  int Debug1( const char *format_str, ... )
801 {
802         va_list ap;
803         int old_errno = errno;
804
805         debug_count++;
806
807         if( stdout_logging ) {
808                 va_start( ap, format_str );
809                 if(dbf)
810                         (void)x_vfprintf( dbf, format_str, ap );
811                 va_end( ap );
812                 errno = old_errno;
813                 goto done;
814         }
815
816         /* prevent recursion by checking if reopen_logs() has temporaily
817            set the debugf string to NULL */
818         if( debugf == NULL)
819                 goto done;
820
821 #ifdef WITH_SYSLOG
822         if( !lp_syslog_only() )
823 #endif
824         {
825                 if( !dbf ) {
826                         mode_t oldumask = umask( 022 );
827
828                         dbf = x_fopen( debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
829                         (void)umask( oldumask );
830                         if( dbf ) {
831                                 x_setbuf( dbf, NULL );
832                         } else {
833                                 errno = old_errno;
834                                 goto done;
835                         }
836                 }
837         }
838
839 #ifdef WITH_SYSLOG
840         if( syslog_level < lp_syslog() ) {
841                 /* map debug levels to syslog() priorities
842                  * note that not all DEBUG(0, ...) calls are
843                  * necessarily errors */
844                 static const int priority_map[4] = {
845                         LOG_ERR,     /* 0 */
846                         LOG_WARNING, /* 1 */
847                         LOG_NOTICE,  /* 2 */
848                         LOG_INFO,    /* 3 */
849                 };
850                 int     priority;
851                 char *msgbuf = NULL;
852                 int ret;
853
854                 if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
855                         priority = LOG_DEBUG;
856                 else
857                         priority = priority_map[syslog_level];
858
859                 va_start(ap, format_str);
860                 ret = vasprintf(&msgbuf, format_str, ap);
861                 va_end(ap);
862
863                 if (ret != -1) {
864                         syslog(priority, "%s", msgbuf);
865                 }
866                 SAFE_FREE(msgbuf);
867         }
868 #endif
869
870         check_log_size();
871
872 #ifdef WITH_SYSLOG
873         if( !lp_syslog_only() )
874 #endif
875         {
876                 va_start( ap, format_str );
877                 if(dbf)
878                         (void)x_vfprintf( dbf, format_str, ap );
879                 va_end( ap );
880                 if(dbf)
881                         (void)x_fflush( dbf );
882         }
883
884  done:
885         TALLOC_FREE(tmp_debug_ctx);
886
887         errno = old_errno;
888
889         return( 0 );
890 }
891
892
893 /**************************************************************************
894  Print the buffer content via Debug1(), then reset the buffer.
895  Input:  none
896  Output: none
897 ****************************************************************************/
898
899 static void bufr_print( void )
900 {
901         format_bufr[format_pos] = '\0';
902         (void)Debug1( "%s", format_bufr );
903         format_pos = 0;
904 }
905
906 /***************************************************************************
907  Format the debug message text.
908
909  Input:  msg - Text to be added to the "current" debug message text.
910
911  Output: none.
912
913  Notes:  The purpose of this is two-fold.  First, each call to syslog()
914          (used by Debug1(), see above) generates a new line of syslog
915          output.  This is fixed by storing the partial lines until the
916          newline character is encountered.  Second, printing the debug
917          message lines when a newline is encountered allows us to add
918          spaces, thus indenting the body of the message and making it
919          more readable.
920 **************************************************************************/
921
922 static void format_debug_text( const char *msg )
923 {
924         size_t i;
925         bool timestamp = (!stdout_logging && (lp_timestamp_logs() || !(lp_loaded())));
926
927         if (!format_bufr) {
928                 debug_init();
929         }
930
931         for( i = 0; msg[i]; i++ ) {
932                 /* Indent two spaces at each new line. */
933                 if(timestamp && 0 == format_pos) {
934                         format_bufr[0] = format_bufr[1] = ' ';
935                         format_pos = 2;
936                 }
937
938                 /* If there's room, copy the character to the format buffer. */
939                 if( format_pos < FORMAT_BUFR_MAX )
940                         format_bufr[format_pos++] = msg[i];
941
942                 /* If a newline is encountered, print & restart. */
943                 if( '\n' == msg[i] )
944                         bufr_print();
945
946                 /* If the buffer is full dump it out, reset it, and put out a line
947                  * continuation indicator.
948                  */
949                 if( format_pos >= FORMAT_BUFR_MAX ) {
950                         bufr_print();
951                         (void)Debug1( " +>\n" );
952                 }
953         }
954
955         /* Just to be safe... */
956         format_bufr[format_pos] = '\0';
957 }
958
959 /***************************************************************************
960  Flush debug output, including the format buffer content.
961
962  Input:  none
963  Output: none
964 ***************************************************************************/
965
966 void dbgflush( void )
967 {
968         bufr_print();
969         if(dbf)
970                 (void)x_fflush( dbf );
971 }
972
973 /***************************************************************************
974  Print a Debug Header.
975
976  Input:  level - Debug level of the message (not the system-wide debug
977                   level. )
978           cls   - Debuglevel class of the calling module.
979           file  - Pointer to a string containing the name of the file
980                   from which this function was called, or an empty string
981                   if the __FILE__ macro is not implemented.
982           func  - Pointer to a string containing the name of the function
983                   from which this function was called, or an empty string
984                   if the __FUNCTION__ macro is not implemented.
985          line  - line number of the call to dbghdr, assuming __LINE__
986                  works.
987
988   Output: Always True.  This makes it easy to fudge a call to dbghdr()
989           in a macro, since the function can be called as part of a test.
990           Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
991
992   Notes:  This function takes care of setting syslog_level.
993
994 ****************************************************************************/
995
996 bool dbghdrclass(int level, int cls, const char *location, const char *func)
997 {
998         /* Ensure we don't lose any real errno value. */
999         int old_errno = errno;
1000
1001         if( format_pos ) {
1002                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
1003                  * the *right* thing to do is to call
1004                  *   format_debug_text( "\n" );
1005                  * to write the remainder, and then proceed with the new header.
1006                  * Unfortunately, there are several places in the code at which
1007                  * the DEBUG() macro is used to build partial lines.  That in mind,
1008                  * we'll work under the assumption that an incomplete line indicates
1009                  * that a new header is *not* desired.
1010                  */
1011                 return( True );
1012         }
1013
1014 #ifdef WITH_SYSLOG
1015         /* Set syslog_level. */
1016         syslog_level = level;
1017 #endif
1018
1019         /* Don't print a header if we're logging to stdout. */
1020         if( stdout_logging )
1021                 return( True );
1022
1023         /* Print the header if timestamps are turned on.  If parameters are
1024          * not yet loaded, then default to timestamps on.
1025          */
1026         if( lp_timestamp_logs() || lp_debug_prefix_timestamp() || !(lp_loaded()) ) {
1027                 char header_str[200];
1028
1029                 header_str[0] = '\0';
1030
1031                 if( lp_debug_pid())
1032                         slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)sys_getpid());
1033
1034                 if( lp_debug_uid()) {
1035                         size_t hs_len = strlen(header_str);
1036                         slprintf(header_str + hs_len,
1037                         sizeof(header_str) - 1 - hs_len,
1038                                 ", effective(%u, %u), real(%u, %u)",
1039                                 (unsigned int)geteuid(), (unsigned int)getegid(),
1040                                 (unsigned int)getuid(), (unsigned int)getgid()); 
1041                 }
1042
1043                 if (lp_debug_class() && (cls != DBGC_ALL)) {
1044                         size_t hs_len = strlen(header_str);
1045                         slprintf(header_str + hs_len,
1046                                  sizeof(header_str) -1 - hs_len,
1047                                  ", class=%s",
1048                                  default_classname_table[cls]);
1049                 }
1050   
1051                 /* Print it all out at once to prevent split syslog output. */
1052                 if( lp_debug_prefix_timestamp() ) {
1053                     (void)Debug1( "[%s, %2d%s] ",
1054                         current_timestring(debug_ctx(),
1055                                            lp_debug_hires_timestamp()),
1056                         level, header_str);
1057                 } else {
1058                     (void)Debug1( "[%s, %2d%s] %s(%s)\n",
1059                         current_timestring(debug_ctx(),
1060                                            lp_debug_hires_timestamp()),
1061                         level, header_str, location, func );
1062                 }
1063         }
1064
1065         errno = old_errno;
1066         return( True );
1067 }
1068
1069 bool dbghdr(int level, const char *location, const char *func)
1070 {
1071         /* For compatibility with Samba 4, which doesn't have debug classes */
1072         return dbghdrclass(level, 0, location, func);
1073 }
1074
1075 /***************************************************************************
1076  Add text to the body of the "current" debug message via the format buffer.
1077
1078   Input:  format_str  - Format string, as used in printf(), et. al.
1079           ...         - Variable argument list.
1080
1081   ..or..  va_alist    - Old style variable parameter list starting point.
1082
1083   Output: Always True.  See dbghdr() for more info, though this is not
1084           likely to be used in the same way.
1085
1086 ***************************************************************************/
1087
1088  bool dbgtext( const char *format_str, ... )
1089 {
1090         va_list ap;
1091         char *msgbuf = NULL;
1092         bool ret = true;
1093         int res;
1094
1095         va_start(ap, format_str);
1096         res = vasprintf(&msgbuf, format_str, ap);
1097         va_end(ap);
1098
1099         if (res != -1) {
1100                 format_debug_text(msgbuf);
1101         } else {
1102                 ret = false;
1103         }
1104         SAFE_FREE(msgbuf);
1105         return ret;
1106 }
1107
1108 /*
1109  * Get us a temporary talloc context usable just for DEBUG arguments
1110  */
1111 TALLOC_CTX *debug_ctx(void)
1112 {
1113         if (tmp_debug_ctx == NULL) {
1114                 tmp_debug_ctx = talloc_named_const(NULL, 0, "debug_ctx");
1115         }
1116         return tmp_debug_ctx;
1117 }