debug: new debug class for kerberos
[kai/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 "replace.h"
23 #include <talloc.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 "util_strlist.h" /* LIST_SEP */
31 #include "blocking.h"
32 #include "debug.h"
33
34 /* define what facility to use for syslog */
35 #ifndef SYSLOG_FACILITY
36 #define SYSLOG_FACILITY LOG_DAEMON
37 #endif
38
39 /* -------------------------------------------------------------------------- **
40  * Defines...
41  */
42
43 /*
44  * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
45  * for a terminating null byte.
46  */
47 #define FORMAT_BUFR_SIZE 1024
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 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
107 static int debug_level_to_priority(int level)
108 {
109         /*
110          * map debug levels to syslog() priorities
111          */
112         static const int priority_map[] = {
113                 LOG_ERR,     /* 0 */
114                 LOG_WARNING, /* 1 */
115                 LOG_NOTICE,  /* 2 */
116                 LOG_NOTICE,  /* 3 */
117                 LOG_NOTICE,  /* 4 */
118                 LOG_NOTICE,  /* 5 */
119                 LOG_INFO,    /* 6 */
120                 LOG_INFO,    /* 7 */
121                 LOG_INFO,    /* 8 */
122                 LOG_INFO,    /* 9 */
123         };
124         int priority;
125
126         if( level >= ARRAY_SIZE(priority_map) || level < 0)
127                 priority = LOG_DEBUG;
128         else
129                 priority = priority_map[level];
130
131         return priority;
132 }
133 #endif
134
135 /* -------------------------------------------------------------------------- **
136  * Debug backends. When logging to DEBUG_FILE, send the log entries to
137  * all active backends.
138  */
139
140 static void debug_file_log(int msg_level,
141                            const char *msg, const char *msg_no_nl)
142 {
143         ssize_t ret;
144
145         check_log_size();
146         do {
147                 ret = write(state.fd, msg, strlen(msg));
148         } while (ret == -1 && errno == EINTR);
149 }
150
151 #ifdef WITH_SYSLOG
152 static void debug_syslog_reload(bool enabled, bool previously_enabled,
153                                 const char *prog_name, char *option)
154 {
155         if (enabled && !previously_enabled) {
156 #ifdef LOG_DAEMON
157                 openlog(prog_name, LOG_PID, SYSLOG_FACILITY);
158 #else
159                 /* for old systems that have no facility codes. */
160                 openlog(prog_name, LOG_PID );
161 #endif
162                 return;
163         }
164
165         if (!enabled && previously_enabled) {
166                 closelog();
167         }
168 }
169
170 static void debug_syslog_log(int msg_level,
171                              const char *msg, const char *msg_no_nl)
172 {
173         int priority;
174
175         priority = debug_level_to_priority(msg_level);
176
177         /*
178          * Specify the facility to interoperate with other syslog
179          * callers (vfs_full_audit for example).
180          */
181         priority |= SYSLOG_FACILITY;
182
183         syslog(priority, "%s", msg);
184 }
185 #endif /* WITH_SYSLOG */
186
187 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
188 #include <systemd/sd-journal.h>
189 static void debug_systemd_log(int msg_level,
190                               const char *msg, const char *msg_no_nl)
191 {
192         sd_journal_send("MESSAGE=%s", msg_no_nl,
193                         "PRIORITY=%d", debug_level_to_priority(msg_level),
194                         "LEVEL=%d", msg_level,
195                         NULL);
196 }
197 #endif
198
199 #ifdef HAVE_LTTNG_TRACEF
200 #include <lttng/tracef.h>
201 static void debug_lttng_log(int msg_level,
202                             const char *msg, const char *msg_no_nl)
203 {
204         tracef(msg_no_nl);
205 }
206 #endif /* WITH_LTTNG_TRACEF */
207
208 #ifdef HAVE_GPFS
209 #include "gpfswrap.h"
210 static void debug_gpfs_reload(bool enabled, bool previously_enabled,
211                               const char *prog_name, char *option)
212 {
213         gpfswrap_init();
214
215         if (enabled && !previously_enabled) {
216                 gpfswrap_init_trace();
217                 return;
218         }
219
220         if (!enabled && previously_enabled) {
221                 gpfswrap_fini_trace();
222                 return;
223         }
224
225         if (enabled) {
226                 /*
227                  * Trigger GPFS library to adjust state if necessary.
228                  */
229                 gpfswrap_query_trace();
230         }
231 }
232
233 static void debug_gpfs_log(int msg_level,
234                            const char *msg, const char *msg_no_nl)
235 {
236         gpfswrap_add_trace(msg_level, msg_no_nl);
237 }
238 #endif /* HAVE_GPFS */
239
240 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
241 #define DEBUG_RINGBUF_SIZE_OPT "size="
242
243 static char *debug_ringbuf;
244 static size_t debug_ringbuf_size;
245 static size_t debug_ringbuf_ofs;
246
247 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
248 char *debug_get_ringbuf(void)
249 {
250         return debug_ringbuf;
251 }
252
253 /* Return the size of the ringbuf (including a \0 terminator) */
254 size_t debug_get_ringbuf_size(void)
255 {
256         return debug_ringbuf_size;
257 }
258
259 static void debug_ringbuf_reload(bool enabled, bool previously_enabled,
260                                  const char *prog_name, char *option)
261 {
262         bool cmp;
263         size_t optlen = strlen(DEBUG_RINGBUF_SIZE_OPT);
264
265         debug_ringbuf_size = DEBUG_RINGBUF_SIZE;
266         debug_ringbuf_ofs = 0;
267
268         SAFE_FREE(debug_ringbuf);
269
270         if (!enabled) {
271                 return;
272         }
273
274         if (option != NULL) {
275                 cmp = strncmp(option, DEBUG_RINGBUF_SIZE_OPT, optlen);
276                 if (cmp == 0) {
277                         debug_ringbuf_size = (size_t)strtoull(
278                                 option + optlen, NULL, 10);
279                 }
280         }
281
282         debug_ringbuf = calloc(debug_ringbuf_size, sizeof(char));
283         if (debug_ringbuf == NULL) {
284                 return;
285         }
286 }
287
288 static void debug_ringbuf_log(int msg_level,
289                               const char *msg,
290                               const char *msg_no_nl)
291 {
292         size_t msglen = strlen(msg);
293         size_t allowed_size;
294
295         if (debug_ringbuf == NULL) {
296                 return;
297         }
298
299         /* Ensure the buffer is always \0 terminated */
300         allowed_size = debug_ringbuf_size - 1;
301
302         if (msglen > allowed_size) {
303                 return;
304         }
305
306         if ((debug_ringbuf_ofs + msglen) < debug_ringbuf_ofs) {
307                 return;
308         }
309
310         if ((debug_ringbuf_ofs + msglen) > allowed_size) {
311                 debug_ringbuf_ofs = 0;
312         }
313
314         memcpy(debug_ringbuf + debug_ringbuf_ofs, msg, msglen);
315         debug_ringbuf_ofs += msglen;
316 }
317
318 static struct debug_backend {
319         const char *name;
320         int log_level;
321         int new_log_level;
322         void (*reload)(bool enabled, bool prev_enabled,
323                        const char *prog_name, char *option);
324         void (*log)(int msg_level, const char *msg, const char *msg_no_nl);
325         char *option;
326 } debug_backends[] = {
327         {
328                 .name = "file",
329                 .log = debug_file_log,
330         },
331 #ifdef WITH_SYSLOG
332         {
333                 .name = "syslog",
334                 .reload = debug_syslog_reload,
335                 .log = debug_syslog_log,
336         },
337 #endif
338
339 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
340         {
341                 .name = "systemd",
342                 .log = debug_systemd_log,
343         },
344 #endif
345
346 #ifdef HAVE_LTTNG_TRACEF
347         {
348                 .name = "lttng",
349                 .log = debug_lttng_log,
350         },
351 #endif
352
353 #ifdef HAVE_GPFS
354         {
355                 .name = "gpfs",
356                 .reload = debug_gpfs_reload,
357                 .log = debug_gpfs_log,
358         },
359 #endif
360         {
361                 .name = "ringbuf",
362                 .log = debug_ringbuf_log,
363                 .reload = debug_ringbuf_reload,
364         },
365 };
366
367 static struct debug_backend *debug_find_backend(const char *name)
368 {
369         unsigned i;
370
371         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
372                 if (strcmp(name, debug_backends[i].name) == 0) {
373                         return &debug_backends[i];
374                 }
375         }
376
377         return NULL;
378 }
379
380 /*
381  * parse "backend[:option][@loglevel]
382  */
383 static void debug_backend_parse_token(char *tok)
384 {
385         char *backend_name_option, *backend_name,*backend_level, *saveptr;
386         char *backend_option;
387         struct debug_backend *b;
388
389         /*
390          * First parse into backend[:option] and loglevel
391          */
392         backend_name_option = strtok_r(tok, "@\0", &saveptr);
393         if (backend_name_option == NULL) {
394                 return;
395         }
396
397         backend_level = strtok_r(NULL, "\0", &saveptr);
398
399         /*
400          * Now parse backend[:option]
401          */
402         backend_name = strtok_r(backend_name_option, ":\0", &saveptr);
403         if (backend_name == NULL) {
404                 return;
405         }
406
407         backend_option = strtok_r(NULL, "\0", &saveptr);
408
409         /*
410          * Find and update backend
411          */
412         b = debug_find_backend(backend_name);
413         if (b == NULL) {
414                 return;
415         }
416
417         if (backend_level == NULL) {
418                 b->new_log_level = MAX_DEBUG_LEVEL;
419         } else {
420                 b->new_log_level = atoi(backend_level);
421         }
422
423         if (backend_option != NULL) {
424                 b->option = strdup(backend_option);
425                 if (b->option == NULL) {
426                         return;
427                 }
428         }
429 }
430
431 /*
432  * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
433  * and enable/disable backends accordingly
434  */
435 static void debug_set_backends(const char *param)
436 {
437         size_t str_len = strlen(param);
438         char str[str_len+1];
439         char *tok, *saveptr;
440         unsigned i;
441
442         /*
443          * initialize new_log_level to detect backends that have been
444          * disabled
445          */
446         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
447                 SAFE_FREE(debug_backends[i].option);
448                 debug_backends[i].new_log_level = -1;
449         }
450
451         memcpy(str, param, str_len + 1);
452
453         tok = strtok_r(str, LIST_SEP, &saveptr);
454         if (tok == NULL) {
455                 return;
456         }
457
458         while (tok != NULL) {
459                 debug_backend_parse_token(tok);
460                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
461         }
462
463         /*
464          * Let backends react to config changes
465          */
466         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
467                 struct debug_backend *b = &debug_backends[i];
468
469                 if (b->reload) {
470                         bool enabled = b->new_log_level > -1;
471                         bool previously_enabled = b->log_level > -1;
472
473                         b->reload(enabled, previously_enabled, state.prog_name,
474                                   b->option);
475                 }
476                 b->log_level = b->new_log_level;
477         }
478 }
479
480 static void debug_backends_log(const char *msg, int msg_level)
481 {
482         char msg_no_nl[FORMAT_BUFR_SIZE];
483         unsigned i;
484         int len;
485
486         /*
487          * Some backends already add an extra newline, so also provide
488          * a buffer without the newline character.
489          */
490         len = MIN(strlen(msg), FORMAT_BUFR_SIZE - 1);
491         if ((len > 0) && (msg[len - 1] == '\n')) {
492                 len--;
493         }
494
495         memcpy(msg_no_nl, msg, len);
496         msg_no_nl[len] = '\0';
497
498         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
499                 if (msg_level <= debug_backends[i].log_level) {
500                         debug_backends[i].log(msg_level, msg, msg_no_nl);
501                 }
502         }
503 }
504
505 /* -------------------------------------------------------------------------- **
506  * External variables.
507  */
508
509 /*
510    used to check if the user specified a
511    logfile on the command line
512 */
513 bool    override_logfile;
514
515 static const char *default_classname_table[] = {
516         [DBGC_ALL] =            "all",
517         [DBGC_TDB] =            "tdb",
518         [DBGC_PRINTDRIVERS] =   "printdrivers",
519         [DBGC_LANMAN] =         "lanman",
520         [DBGC_SMB] =            "smb",
521         [DBGC_RPC_PARSE] =      "rpc_parse",
522         [DBGC_RPC_SRV] =        "rpc_srv",
523         [DBGC_RPC_CLI] =        "rpc_cli",
524         [DBGC_PASSDB] =         "passdb",
525         [DBGC_SAM] =            "sam",
526         [DBGC_AUTH] =           "auth",
527         [DBGC_WINBIND] =        "winbind",
528         [DBGC_VFS] =            "vfs",
529         [DBGC_IDMAP] =          "idmap",
530         [DBGC_QUOTA] =          "quota",
531         [DBGC_ACLS] =           "acls",
532         [DBGC_LOCKING] =        "locking",
533         [DBGC_MSDFS] =          "msdfs",
534         [DBGC_DMAPI] =          "dmapi",
535         [DBGC_REGISTRY] =       "registry",
536         [DBGC_SCAVENGER] =      "scavenger",
537         [DBGC_DNS] =            "dns",
538         [DBGC_LDB] =            "ldb",
539         [DBGC_TEVENT] =         "tevent",
540         [DBGC_AUTH_AUDIT] =     "auth_audit",
541         [DBGC_AUTH_AUDIT_JSON] = "auth_json_audit",
542         [DBGC_KERBEROS] =       "kerberos",
543 };
544
545 /*
546  * This is to allow reading of DEBUGLEVEL_CLASS before the debug
547  * system has been initialized.
548  */
549 static const int debug_class_list_initial[ARRAY_SIZE(default_classname_table)];
550
551 static int debug_num_classes = 0;
552 int     *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
553
554
555 /* -------------------------------------------------------------------------- **
556  * Internal variables.
557  *
558  *  debug_count     - Number of debug messages that have been output.
559  *                    Used to check log size.
560  *
561  *  current_msg_level    - Internal copy of the message debug level.  Written by
562  *                    dbghdr() and read by Debug1().
563  *
564  *  format_bufr     - Used to format debug messages.  The dbgtext() function
565  *                    prints debug messages to a string, and then passes the
566  *                    string to format_debug_text(), which uses format_bufr
567  *                    to build the formatted output.
568  *
569  *  format_pos      - Marks the first free byte of the format_bufr.
570  *
571  *
572  *  log_overflow    - When this variable is true, never attempt to check the
573  *                    size of the log. This is a hack, so that we can write
574  *                    a message using DEBUG, from open_logs() when we
575  *                    are unable to open a new log file for some reason.
576  */
577
578 static int     debug_count    = 0;
579 static int     current_msg_level   = 0;
580 static char format_bufr[FORMAT_BUFR_SIZE];
581 static size_t     format_pos     = 0;
582 static bool    log_overflow   = false;
583
584 /*
585  * Define all the debug class selection names here. Names *MUST NOT* contain
586  * white space. There must be one name for each DBGC_<class name>, and they
587  * must be in the table in the order of DBGC_<class name>..
588  */
589
590 static char **classname_table = NULL;
591
592
593 /* -------------------------------------------------------------------------- **
594  * Functions...
595  */
596
597 static void debug_init(void);
598
599 /***************************************************************************
600  Free memory pointed to by global pointers.
601 ****************************************************************************/
602
603 void gfree_debugsyms(void)
604 {
605         unsigned i;
606
607         TALLOC_FREE(classname_table);
608
609         if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
610                 TALLOC_FREE( DEBUGLEVEL_CLASS );
611                 DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
612         }
613
614         debug_num_classes = 0;
615
616         state.initialized = false;
617
618         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
619                 SAFE_FREE(debug_backends[i].option);
620         }
621 }
622
623 /****************************************************************************
624 utility lists registered debug class names's
625 ****************************************************************************/
626
627 char *debug_list_class_names_and_levels(void)
628 {
629         char *buf = NULL;
630         unsigned int i;
631         /* prepare strings */
632         for (i = 0; i < debug_num_classes; i++) {
633                 buf = talloc_asprintf_append(buf,
634                                              "%s:%d%s",
635                                              classname_table[i],
636                                              DEBUGLEVEL_CLASS[i],
637                                              i == (debug_num_classes - 1) ? "\n" : " ");
638                 if (buf == NULL) {
639                         return NULL;
640                 }
641         }
642         return buf;
643 }
644
645 /****************************************************************************
646  Utility to translate names to debug class index's (internal version).
647 ****************************************************************************/
648
649 static int debug_lookup_classname_int(const char* classname)
650 {
651         int i;
652
653         if (!classname) return -1;
654
655         for (i=0; i < debug_num_classes; i++) {
656                 if (strcmp(classname, classname_table[i])==0)
657                         return i;
658         }
659         return -1;
660 }
661
662 /****************************************************************************
663  Add a new debug class to the system.
664 ****************************************************************************/
665
666 int debug_add_class(const char *classname)
667 {
668         int ndx;
669         int *new_class_list;
670         char **new_name_list;
671         int default_level;
672
673         if (!classname)
674                 return -1;
675
676         /* check the init has yet been called */
677         debug_init();
678
679         ndx = debug_lookup_classname_int(classname);
680         if (ndx >= 0)
681                 return ndx;
682         ndx = debug_num_classes;
683
684         if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
685                 /* Initial loading... */
686                 new_class_list = NULL;
687         } else {
688                 new_class_list = DEBUGLEVEL_CLASS;
689         }
690
691         default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
692
693         new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
694         if (!new_class_list)
695                 return -1;
696         DEBUGLEVEL_CLASS = new_class_list;
697
698         DEBUGLEVEL_CLASS[ndx] = default_level;
699
700         new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
701         if (!new_name_list)
702                 return -1;
703         classname_table = new_name_list;
704
705         classname_table[ndx] = talloc_strdup(classname_table, classname);
706         if (! classname_table[ndx])
707                 return -1;
708
709         debug_num_classes = ndx + 1;
710
711         return ndx;
712 }
713
714 /****************************************************************************
715  Utility to translate names to debug class index's (public version).
716 ****************************************************************************/
717
718 static int debug_lookup_classname(const char *classname)
719 {
720         int ndx;
721
722         if (!classname || !*classname)
723                 return -1;
724
725         ndx = debug_lookup_classname_int(classname);
726
727         if (ndx != -1)
728                 return ndx;
729
730         DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
731                   classname));
732         return debug_add_class(classname);
733 }
734
735 /****************************************************************************
736  Dump the current registered debug levels.
737 ****************************************************************************/
738
739 static void debug_dump_status(int level)
740 {
741         int q;
742
743         DEBUG(level, ("INFO: Current debug levels:\n"));
744         for (q = 0; q < debug_num_classes; q++) {
745                 const char *classname = classname_table[q];
746                 DEBUGADD(level, ("  %s: %d\n",
747                                  classname,
748                                  DEBUGLEVEL_CLASS[q]));
749         }
750 }
751
752 static bool debug_parse_param(char *param)
753 {
754         char *class_name;
755         char *class_level;
756         char *saveptr = NULL;
757         int ndx;
758
759         class_name = strtok_r(param, ":", &saveptr);
760         if (class_name == NULL) {
761                 return false;
762         }
763
764         class_level = strtok_r(NULL, "\0", &saveptr);
765         if (class_level == NULL) {
766                 return false;
767         }
768
769         ndx = debug_lookup_classname(class_name);
770         if (ndx == -1) {
771                 return false;
772         }
773
774         DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
775
776         return true;
777 }
778
779 /****************************************************************************
780  Parse the debug levels from smb.conf. Example debug level string:
781   3 tdb:5 printdrivers:7
782  Note: the 1st param has no "name:" preceeding it.
783 ****************************************************************************/
784
785 bool debug_parse_levels(const char *params_str)
786 {
787         size_t str_len = strlen(params_str);
788         char str[str_len+1];
789         char *tok, *saveptr;
790         int i;
791
792         /* Just in case */
793         debug_init();
794
795         memcpy(str, params_str, str_len+1);
796
797         tok = strtok_r(str, LIST_SEP, &saveptr);
798         if (tok == NULL) {
799                 return true;
800         }
801
802         /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
803          * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
804          */
805         if (isdigit(tok[0])) {
806                 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(tok);
807                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
808         } else {
809                 DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
810         }
811
812         /* Array is debug_num_classes long */
813         for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
814                 DEBUGLEVEL_CLASS[i] = DEBUGLEVEL_CLASS[DBGC_ALL];
815         }
816
817         while (tok != NULL) {
818                 bool ok;
819
820                 ok = debug_parse_param(tok);
821                 if (!ok) {
822                         DEBUG(0,("debug_parse_params: unrecognized debug "
823                                  "class name or format [%s]\n", tok));
824                         return false;
825                 }
826
827                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
828         }
829
830         debug_dump_status(5);
831
832         return true;
833 }
834
835 /* setup for logging of talloc warnings */
836 static void talloc_log_fn(const char *msg)
837 {
838         DEBUG(0,("%s", msg));
839 }
840
841 void debug_setup_talloc_log(void)
842 {
843         talloc_set_log_fn(talloc_log_fn);
844 }
845
846
847 /****************************************************************************
848 Init debugging (one time stuff)
849 ****************************************************************************/
850
851 static void debug_init(void)
852 {
853         size_t i;
854
855         if (state.initialized)
856                 return;
857
858         state.initialized = true;
859
860         debug_setup_talloc_log();
861
862         for (i = 0; i < ARRAY_SIZE(default_classname_table); i++) {
863                 debug_add_class(default_classname_table[i]);
864         }
865
866         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
867                 debug_backends[i].log_level = -1;
868                 debug_backends[i].new_log_level = -1;
869         }
870 }
871
872 void debug_set_settings(struct debug_settings *settings,
873                         const char *logging_param,
874                         int syslog_level, bool syslog_only)
875 {
876         char fake_param[256];
877         size_t len = 0;
878
879         /*
880          * This forces in some smb.conf derived values into the debug
881          * system. There are no pointers in this structure, so we can
882          * just structure-assign it in
883          */
884         state.settings = *settings;
885
886         /*
887          * If 'logging' is not set, create backend settings from
888          * deprecated 'syslog' and 'syslog only' parameters
889          */
890         if (logging_param != NULL) {
891                 len = strlen(logging_param);
892         }
893         if (len == 0) {
894                 if (syslog_only) {
895                         snprintf(fake_param, sizeof(fake_param),
896                                  "syslog@%d", syslog_level - 1);
897                 } else {
898                         snprintf(fake_param, sizeof(fake_param),
899                                  "syslog@%d file@%d", syslog_level -1,
900                                  MAX_DEBUG_LEVEL);
901                 }
902
903                 logging_param = fake_param;
904         }
905
906         debug_set_backends(logging_param);
907 }
908
909 /**
910   control the name of the logfile and whether logging will be to stdout, stderr
911   or a file, and set up syslog
912
913   new_log indicates the destination for the debug log (an enum in
914   order of precedence - once set to DEBUG_FILE, it is not possible to
915   reset to DEBUG_STDOUT for example.  This makes it easy to override
916   for debug to stderr on the command line, as the smb.conf cannot
917   reset it back to file-based logging
918 */
919 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
920 {
921         debug_init();
922         if (state.logtype < new_logtype) {
923                 state.logtype = new_logtype;
924         }
925         if (prog_name) {
926                 const char *p = strrchr(prog_name, '/');
927
928                 if (p) {
929                         prog_name = p + 1;
930                 }
931
932                 state.prog_name = prog_name;
933         }
934         reopen_logs_internal();
935 }
936
937 /***************************************************************************
938  Set the logfile name.
939 **************************************************************************/
940
941 void debug_set_logfile(const char *name)
942 {
943         if (name == NULL || *name == 0) {
944                 /* this copes with calls when smb.conf is not loaded yet */
945                 return;
946         }
947         TALLOC_FREE(state.debugf);
948         state.debugf = talloc_strdup(NULL, name);
949 }
950
951 static void debug_close_fd(int fd)
952 {
953         if (fd > 2) {
954                 close(fd);
955         }
956 }
957
958 bool debug_get_output_is_stderr(void)
959 {
960         return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
961 }
962
963 bool debug_get_output_is_stdout(void)
964 {
965         return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
966 }
967
968 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
969 {
970         debug_init();
971         if (fn) {
972                 state.logtype = DEBUG_CALLBACK;
973                 state.callback_private = private_ptr;
974                 state.callback = fn;
975         } else {
976                 state.logtype = DEBUG_DEFAULT_STDERR;
977                 state.callback_private = NULL;
978                 state.callback = NULL;
979         }
980 }
981
982 static void debug_callback_log(const char *msg, int msg_level)
983 {
984         size_t msg_len = strlen(msg);
985         char msg_copy[msg_len];
986
987         if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
988                 memcpy(msg_copy, msg, msg_len-1);
989                 msg_copy[msg_len-1] = '\0';
990                 msg = msg_copy;
991         }
992
993         state.callback(state.callback_private, msg_level, msg);
994 }
995
996 /**************************************************************************
997  reopen the log files
998  note that we now do this unconditionally
999  We attempt to open the new debug fp before closing the old. This means
1000  if we run out of fd's we just keep using the old fd rather than aborting.
1001  Fix from dgibson@linuxcare.com.
1002 **************************************************************************/
1003
1004 /**
1005   reopen the log file (usually called because the log file name might have changed)
1006 */
1007 bool reopen_logs_internal(void)
1008 {
1009         mode_t oldumask;
1010         int new_fd = 0;
1011         int old_fd = 0;
1012         bool ret = true;
1013
1014         if (state.reopening_logs) {
1015                 return true;
1016         }
1017
1018         /* Now clear the SIGHUP induced flag */
1019         state.schedule_reopen_logs = false;
1020
1021         switch (state.logtype) {
1022         case DEBUG_CALLBACK:
1023                 return true;
1024         case DEBUG_STDOUT:
1025         case DEBUG_DEFAULT_STDOUT:
1026                 debug_close_fd(state.fd);
1027                 state.fd = 1;
1028                 return true;
1029
1030         case DEBUG_DEFAULT_STDERR:
1031         case DEBUG_STDERR:
1032                 debug_close_fd(state.fd);
1033                 state.fd = 2;
1034                 return true;
1035
1036         case DEBUG_FILE:
1037                 break;
1038         }
1039
1040         oldumask = umask( 022 );
1041
1042         if (!state.debugf) {
1043                 return false;
1044         }
1045
1046         state.reopening_logs = true;
1047
1048         new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
1049
1050         if (new_fd == -1) {
1051                 log_overflow = true;
1052                 DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
1053                 log_overflow = false;
1054                 ret = false;
1055         } else {
1056                 smb_set_close_on_exec(new_fd);
1057                 old_fd = state.fd;
1058                 state.fd = new_fd;
1059                 debug_close_fd(old_fd);
1060         }
1061
1062         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1063          * to fix problem where smbd's that generate less
1064          * than 100 messages keep growing the log.
1065          */
1066         force_check_log_size();
1067         (void)umask(oldumask);
1068
1069         /* Take over stderr to catch output into logs */
1070         if (state.fd > 0) {
1071                 if (dup2(state.fd, 2) == -1) {
1072                         /* Close stderr too, if dup2 can't point it -
1073                            at the logfile.  There really isn't much
1074                            that can be done on such a fundamental
1075                            failure... */
1076                         close_low_fd(2);
1077                 }
1078         }
1079
1080         state.reopening_logs = false;
1081
1082         return ret;
1083 }
1084
1085 /**************************************************************************
1086  Force a check of the log size.
1087  ***************************************************************************/
1088
1089 void force_check_log_size( void )
1090 {
1091         debug_count = 100;
1092 }
1093
1094 _PUBLIC_ void debug_schedule_reopen_logs(void)
1095 {
1096         state.schedule_reopen_logs = true;
1097 }
1098
1099
1100 /***************************************************************************
1101  Check to see if there is any need to check if the logfile has grown too big.
1102 **************************************************************************/
1103
1104 bool need_to_check_log_size( void )
1105 {
1106         int maxlog;
1107
1108         if( debug_count < 100)
1109                 return( false );
1110
1111         maxlog = state.settings.max_log_size * 1024;
1112         if ( state.fd <=2 || maxlog <= 0 ) {
1113                 debug_count = 0;
1114                 return(false);
1115         }
1116         return( true );
1117 }
1118
1119 /**************************************************************************
1120  Check to see if the log has grown to be too big.
1121  **************************************************************************/
1122
1123 void check_log_size( void )
1124 {
1125         int         maxlog;
1126         struct stat st;
1127
1128         /*
1129          *  We need to be root to check/change log-file, skip this and let the main
1130          *  loop check do a new check as root.
1131          */
1132
1133 #if _SAMBA_BUILD_ == 3
1134         if (geteuid() != sec_initial_uid())
1135 #else
1136         if( geteuid() != 0)
1137 #endif
1138         {
1139                 /* We don't check sec_initial_uid() here as it isn't
1140                  * available in common code and we don't generally
1141                  * want to rotate and the possibly lose logs in
1142                  * make test or the build farm */
1143                 return;
1144         }
1145
1146         if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
1147                 return;
1148         }
1149
1150         maxlog = state.settings.max_log_size * 1024;
1151
1152         if (state.schedule_reopen_logs) {
1153             (void)reopen_logs_internal();
1154         }
1155
1156         if (maxlog && (fstat(state.fd, &st) == 0
1157             && st.st_size > maxlog )) {
1158                 (void)reopen_logs_internal();
1159                 if (state.fd > 2 && (fstat(state.fd, &st) == 0
1160                                      && st.st_size > maxlog)) {
1161                         char name[strlen(state.debugf) + 5];
1162
1163                         snprintf(name, sizeof(name), "%s.old", state.debugf);
1164
1165                         (void)rename(state.debugf, name);
1166
1167                         if (!reopen_logs_internal()) {
1168                                 /* We failed to reopen a log - continue using the old name. */
1169                                 (void)rename(name, state.debugf);
1170                         }
1171                 }
1172         }
1173
1174         /*
1175          * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
1176          */
1177
1178         if (state.fd <= 0) {
1179                 /* This code should only be reached in very strange
1180                  * circumstances. If we merely fail to open the new log we
1181                  * should stick with the old one. ergo this should only be
1182                  * reached when opening the logs for the first time: at
1183                  * startup or when the log level is increased from zero.
1184                  * -dwg 6 June 2000
1185                  */
1186                 int fd = open( "/dev/console", O_WRONLY, 0);
1187                 if (fd != -1) {
1188                         smb_set_close_on_exec(fd);
1189                         state.fd = fd;
1190                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
1191                                         state.debugf ));
1192                 } else {
1193                         /*
1194                          * We cannot continue without a debug file handle.
1195                          */
1196                         abort();
1197                 }
1198         }
1199         debug_count = 0;
1200 }
1201
1202 /*************************************************************************
1203  Write an debug message on the debugfile.
1204  This is called by dbghdr() and format_debug_text().
1205 ************************************************************************/
1206
1207 static void Debug1(const char *msg)
1208 {
1209         int old_errno = errno;
1210
1211         debug_count++;
1212
1213         switch(state.logtype) {
1214         case DEBUG_CALLBACK:
1215                 debug_callback_log(msg, current_msg_level);
1216                 break;
1217         case DEBUG_STDOUT:
1218         case DEBUG_STDERR:
1219         case DEBUG_DEFAULT_STDOUT:
1220         case DEBUG_DEFAULT_STDERR:
1221                 if (state.fd > 0) {
1222                         ssize_t ret;
1223                         do {
1224                                 ret = write(state.fd, msg, strlen(msg));
1225                         } while (ret == -1 && errno == EINTR);
1226                 }
1227                 break;
1228         case DEBUG_FILE:
1229                 debug_backends_log(msg, current_msg_level);
1230                 break;
1231         };
1232
1233         errno = old_errno;
1234 }
1235
1236 /**************************************************************************
1237  Print the buffer content via Debug1(), then reset the buffer.
1238  Input:  none
1239  Output: none
1240 ****************************************************************************/
1241
1242 static void bufr_print( void )
1243 {
1244         format_bufr[format_pos] = '\0';
1245         (void)Debug1(format_bufr);
1246         format_pos = 0;
1247 }
1248
1249 /***************************************************************************
1250  Format the debug message text.
1251
1252  Input:  msg - Text to be added to the "current" debug message text.
1253
1254  Output: none.
1255
1256  Notes:  The purpose of this is two-fold.  First, each call to syslog()
1257          (used by Debug1(), see above) generates a new line of syslog
1258          output.  This is fixed by storing the partial lines until the
1259          newline character is encountered.  Second, printing the debug
1260          message lines when a newline is encountered allows us to add
1261          spaces, thus indenting the body of the message and making it
1262          more readable.
1263 **************************************************************************/
1264
1265 static void format_debug_text( const char *msg )
1266 {
1267         size_t i;
1268         bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
1269
1270         debug_init();
1271
1272         for( i = 0; msg[i]; i++ ) {
1273                 /* Indent two spaces at each new line. */
1274                 if(timestamp && 0 == format_pos) {
1275                         format_bufr[0] = format_bufr[1] = ' ';
1276                         format_pos = 2;
1277                 }
1278
1279                 /* If there's room, copy the character to the format buffer. */
1280                 if (format_pos < FORMAT_BUFR_SIZE - 1)
1281                         format_bufr[format_pos++] = msg[i];
1282
1283                 /* If a newline is encountered, print & restart. */
1284                 if( '\n' == msg[i] )
1285                         bufr_print();
1286
1287                 /* If the buffer is full dump it out, reset it, and put out a line
1288                  * continuation indicator.
1289                  */
1290                 if (format_pos >= FORMAT_BUFR_SIZE - 1) {
1291                         bufr_print();
1292                         (void)Debug1( " +>\n" );
1293                 }
1294         }
1295
1296         /* Just to be safe... */
1297         format_bufr[format_pos] = '\0';
1298 }
1299
1300 /***************************************************************************
1301  Flush debug output, including the format buffer content.
1302
1303  Input:  none
1304  Output: none
1305 ***************************************************************************/
1306
1307 void dbgflush( void )
1308 {
1309         bufr_print();
1310 }
1311
1312 /***************************************************************************
1313  Print a Debug Header.
1314
1315  Input:  level    - Debug level of the message (not the system-wide debug
1316                     level. )
1317          cls      - Debuglevel class of the calling module.
1318          location - Pointer to a string containing the name of the file
1319                     from which this function was called, or an empty string
1320                     if the __FILE__ macro is not implemented.
1321          func     - Pointer to a string containing the name of the function
1322                     from which this function was called, or an empty string
1323                     if the __FUNCTION__ macro is not implemented.
1324
1325  Output: Always true.  This makes it easy to fudge a call to dbghdr()
1326          in a macro, since the function can be called as part of a test.
1327          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1328
1329  Notes:  This function takes care of setting current_msg_level.
1330
1331 ****************************************************************************/
1332
1333 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1334 {
1335         /* Ensure we don't lose any real errno value. */
1336         int old_errno = errno;
1337         bool verbose = false;
1338         char header_str[300];
1339         size_t hs_len;
1340         struct timeval tv;
1341         struct timeval_buf tvbuf;
1342
1343         if( format_pos ) {
1344                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
1345                  * the *right* thing to do is to call
1346                  *   format_debug_text( "\n" );
1347                  * to write the remainder, and then proceed with the new header.
1348                  * Unfortunately, there are several places in the code at which
1349                  * the DEBUG() macro is used to build partial lines.  That in mind,
1350                  * we'll work under the assumption that an incomplete line indicates
1351                  * that a new header is *not* desired.
1352                  */
1353                 return( true );
1354         }
1355
1356         /* Set current_msg_level. */
1357         current_msg_level = level;
1358
1359         /* Don't print a header if we're logging to stdout. */
1360         if ( state.logtype != DEBUG_FILE ) {
1361                 return( true );
1362         }
1363
1364         /* Print the header if timestamps are turned on.  If parameters are
1365          * not yet loaded, then default to timestamps on.
1366          */
1367         if (!(state.settings.timestamp_logs ||
1368               state.settings.debug_prefix_timestamp)) {
1369                 return true;
1370         }
1371
1372         GetTimeOfDay(&tv);
1373         timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
1374                         &tvbuf);
1375
1376         hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
1377                           tvbuf.buf, level);
1378         if (hs_len >= sizeof(header_str)) {
1379                 goto full;
1380         }
1381
1382         if (unlikely(DEBUGLEVEL_CLASS[ cls ] >= 10)) {
1383                 verbose = true;
1384         }
1385
1386         if (verbose || state.settings.debug_pid) {
1387                 hs_len += snprintf(
1388                         header_str + hs_len, sizeof(header_str) - hs_len,
1389                         ", pid=%u", (unsigned int)getpid());
1390                 if (hs_len >= sizeof(header_str)) {
1391                         goto full;
1392                 }
1393         }
1394
1395         if (verbose || state.settings.debug_uid) {
1396                 hs_len += snprintf(
1397                         header_str + hs_len, sizeof(header_str) - hs_len,
1398                         ", effective(%u, %u), real(%u, %u)",
1399                         (unsigned int)geteuid(), (unsigned int)getegid(),
1400                         (unsigned int)getuid(), (unsigned int)getgid());
1401                 if (hs_len >= sizeof(header_str)) {
1402                         goto full;
1403                 }
1404         }
1405
1406         if ((verbose || state.settings.debug_class)
1407             && (cls != DBGC_ALL)) {
1408                 hs_len += snprintf(
1409                         header_str + hs_len, sizeof(header_str) - hs_len,
1410                         ", class=%s", classname_table[cls]);
1411                 if (hs_len >= sizeof(header_str)) {
1412                         goto full;
1413                 }
1414         }
1415
1416         /*
1417          * No +=, see man man strlcat
1418          */
1419         hs_len = strlcat(header_str, "] ", sizeof(header_str));
1420         if (hs_len >= sizeof(header_str)) {
1421                 goto full;
1422         }
1423
1424         if (!state.settings.debug_prefix_timestamp) {
1425                 hs_len += snprintf(
1426                         header_str + hs_len, sizeof(header_str) - hs_len,
1427                         "%s(%s)\n", location, func);
1428                 if (hs_len >= sizeof(header_str)) {
1429                         goto full;
1430                 }
1431         }
1432
1433 full:
1434         (void)Debug1(header_str);
1435
1436         errno = old_errno;
1437         return( true );
1438 }
1439
1440 /***************************************************************************
1441  Add text to the body of the "current" debug message via the format buffer.
1442
1443   Input:  format_str  - Format string, as used in printf(), et. al.
1444           ...         - Variable argument list.
1445
1446   ..or..  va_alist    - Old style variable parameter list starting point.
1447
1448   Output: Always true.  See dbghdr() for more info, though this is not
1449           likely to be used in the same way.
1450
1451 ***************************************************************************/
1452
1453 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1454 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1455 {
1456         char *msgbuf = NULL;
1457         bool ret = true;
1458         int res;
1459
1460         res = vasprintf(&msgbuf, format_str, ap);
1461         if (res != -1) {
1462                 format_debug_text(msgbuf);
1463         } else {
1464                 ret = false;
1465         }
1466         SAFE_FREE(msgbuf);
1467         return ret;
1468 }
1469
1470 bool dbgtext_va(const char *format_str, va_list ap)
1471 {
1472         return __dbgtext_va(format_str, ap);
1473 }
1474
1475 bool dbgtext(const char *format_str, ... )
1476 {
1477         va_list ap;
1478         bool ret;
1479
1480         va_start(ap, format_str);
1481         ret = __dbgtext_va(format_str, ap);
1482         va_end(ap);
1483
1484         return ret;
1485 }