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