← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source3/lib/debug.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

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