Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed
  • vendor/current/lib/util/debug.c

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