upstream/openldap
1
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2025-12-20 22:59:34 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

ITS#9715 consolidate logging functionality into logging.c

Browse source
This commit is contained in:
Howard Chu 2021-10-16 17:22:10 +01:00
parent 90fc349654
commit d76b8cbbef
8 changed files with 626 additions and 791 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

211
servers/lloadd/config.c
View file

@ -46,6 +46,7 @@
#include "lutil.h" #include "lutil.h"
#include "lutil_ldap.h" #include "lutil_ldap.h"
#include "lload-config.h" #include "lload-config.h"
#include "../slapd/slap-cfglog.h"
#ifdef _WIN32 #ifdef _WIN32
#define LUTIL_ATOULX lutil_atoullx #define LUTIL_ATOULX lutil_atoullx
@ -121,7 +122,6 @@ static ConfigDriver config_restrict_oid;
static ConfigDriver config_tcp_buffer; static ConfigDriver config_tcp_buffer;
#endif /* LDAP_TCP_BUFFER */ #endif /* LDAP_TCP_BUFFER */
static ConfigDriver config_restrict; static ConfigDriver config_restrict;
static ConfigDriver config_loglevel;
static ConfigDriver config_include; static ConfigDriver config_include;
static ConfigDriver config_feature; static ConfigDriver config_feature;
#ifdef HAVE_TLS #ifdef HAVE_TLS
@ -156,9 +156,6 @@ enum {
CFG_TLS_SHARE_CTX, CFG_TLS_SHARE_CTX,
CFG_CONCUR, CFG_CONCUR,
CFG_THREADS, CFG_THREADS,
CFG_LOGFILE,
CFG_LOGFILE_ONLY,
CFG_LOGFILE_ROTATE,
CFG_MIRRORMODE, CFG_MIRRORMODE,
CFG_IOTHREADS, CFG_IOTHREADS,
CFG_MAXBUF_CLIENT, CFG_MAXBUF_CLIENT,
@ -291,22 +288,22 @@ static ConfigTable config_back_cf_table[] = {
#endif /* BALANCER_MODULE */ #endif /* BALANCER_MODULE */
{ "logfile", "file", 2, 2, 0, { "logfile", "file", 2, 2, 0,
ARG_STRING|ARG_MAGIC|CFG_LOGFILE, ARG_STRING|ARG_MAGIC|CFG_LOGFILE,
&config_generic, &config_logging,
NULL, NULL, NULL NULL, NULL, NULL
}, },
{ "logfile-only", "on|off", 2, 2, 0, { "logfile-only", "on|off", 2, 2, 0,
ARG_ON_OFF|ARG_MAGIC|CFG_LOGFILE_ONLY, ARG_ON_OFF|ARG_MAGIC|CFG_LOGFILE_ONLY,
&config_generic, &config_logging,
NULL, NULL, NULL NULL, NULL, NULL
}, },
{ "logfile-rotate", "max> <Mbyte> <hours", 4, 4, 0, { "logfile-rotate", "max> <Mbyte> <hours", 4, 4, 0,
ARG_MAGIC|CFG_LOGFILE_ROTATE, ARG_MAGIC|CFG_LOGFILE_ROTATE,
&config_generic, &config_logging,
NULL, NULL, NULL NULL, NULL, NULL
}, },
{ "loglevel", "level", 2, 0, 0, { "loglevel", "level", 2, 0, 0,
ARG_MAGIC, ARG_MAGIC|CFG_LOGLEVEL,
&config_loglevel, &config_logging,
NULL, NULL, NULL NULL, NULL, NULL
}, },
{ "pidfile", "file", 2, 2, 0, { "pidfile", "file", 2, 2, 0,
@ -1039,60 +1036,6 @@ config_generic( ConfigArgs *c )
} }
} break; } break;
case CFG_LOGFILE: {
int rc = logfile_open( c->value_string );
ch_free( c->value_string );
return rc;
} break;
case CFG_LOGFILE_ONLY:
slap_debug = slap_debug_orig;
if ( c->value_int ) {
slap_debug |= config_syslog;
ldap_syslog = 0;
} else {
ldap_syslog = config_syslog;
}
logfile_only = c->value_int;
break;
case CFG_LOGFILE_ROTATE: {
unsigned lf_max, lf_mbyte, lf_hour;
if ( lutil_atoux( &lf_max, c->argv[1], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid max value \"%s\"",
c->argv[0], c->argv[1] );
goto fail;
}
if ( !lf_max || lf_max > 99 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid max value \"%s\" must be 1-99",
c->argv[0], c->argv[1] );
goto fail;
}
if ( lutil_atoux( &lf_mbyte, c->argv[2], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid Mbyte value \"%s\"",
c->argv[0], c->argv[2] );
goto fail;
}
if ( lutil_atoux( &lf_hour, c->argv[3], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid hours value \"%s\"",
c->argv[0], c->argv[3] );
goto fail;
}
if ( !lf_mbyte && !lf_hour ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"Mbyte and hours cannot both be zero",
c->argv[0] );
goto fail;
}
logfile_max = lf_max;
logfile_fslimit = lf_mbyte * 1048576; /* Megabytes to bytes */
logfile_age = lf_hour * 3600; /* hours to seconds */
} break;
case CFG_RESCOUNT: case CFG_RESCOUNT:
lload_conn_max_pdus_per_cycle = c->value_uint; lload_conn_max_pdus_per_cycle = c->value_uint;
break; break;
@ -2033,146 +1976,6 @@ config_restrict( ConfigArgs *c )
return 0; return 0;
} }
static slap_verbmasks *loglevel_ops;
static int
loglevel_init( void )
{
slap_verbmasks lo[] = {
{ BER_BVC("Any"), (slap_mask_t)LDAP_DEBUG_ANY },
{ BER_BVC("Trace"), LDAP_DEBUG_TRACE },
{ BER_BVC("Packets"), LDAP_DEBUG_PACKETS },
{ BER_BVC("Args"), LDAP_DEBUG_ARGS },
{ BER_BVC("Conns"), LDAP_DEBUG_CONNS },
{ BER_BVC("BER"), LDAP_DEBUG_BER },
{ BER_BVC("Filter"), LDAP_DEBUG_FILTER },
{ BER_BVC("Config"), LDAP_DEBUG_CONFIG },
{ BER_BVC("ACL"), LDAP_DEBUG_ACL },
{ BER_BVC("Stats"), LDAP_DEBUG_STATS },
{ BER_BVC("Stats2"), LDAP_DEBUG_STATS2 },
{ BER_BVC("Shell"), LDAP_DEBUG_SHELL },
{ BER_BVC("Parse"), LDAP_DEBUG_PARSE },
{ BER_BVC("Sync"), LDAP_DEBUG_SYNC },
{ BER_BVC("None"), LDAP_DEBUG_NONE },
{ BER_BVNULL, 0 }
};
return slap_verbmasks_init( &loglevel_ops, lo );
}
static void
loglevel_destroy( void )
{
if ( loglevel_ops ) {
(void)slap_verbmasks_destroy( loglevel_ops );
}
loglevel_ops = NULL;
}
int
str2loglevel( const char *s, int *l )
{
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
i = verb_to_mask( s, loglevel_ops );
if ( BER_BVISNULL( &loglevel_ops[i].word ) ) {
return -1;
}
*l = loglevel_ops[i].mask;
return 0;
}
int
loglevel2bvarray( int l, BerVarray *bva )
{
if ( loglevel_ops == NULL ) {
loglevel_init();
}
if ( l == 0 ) {
struct berval bv = BER_BVC("0");
return value_add_one( bva, &bv );
}
return mask_to_verbs( loglevel_ops, l, bva );
}
int
loglevel_print( FILE *out )
{
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
fprintf( out, "Installed log subsystems:\n\n" );
for ( i = 0; !BER_BVISNULL( &loglevel_ops[i].word ); i++ ) {
unsigned mask = loglevel_ops[i].mask & 0xffffffffUL;
fprintf( out,
( mask == ( (slap_mask_t)-1 & 0xffffffffUL ) ?
"\t%-30s (-1, 0xffffffff)\n" :
"\t%-30s (%u, 0x%x)\n" ),
loglevel_ops[i].word.bv_val, mask, mask );
}
return 0;
}
static int
config_loglevel( ConfigArgs *c )
{
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
for ( i = 1; i < c->argc; i++ ) {
int level;
if ( isdigit( (unsigned char)c->argv[i][0] ) || c->argv[i][0] == '-' ) {
if ( lutil_atoix( &level, c->argv[i], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof(c->cr_msg),
"<%s> unable to parse level",
c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s \"%s\"\n",
c->log, c->cr_msg, c->argv[i] );
return 1;
}
} else {
if ( str2loglevel( c->argv[i], &level ) ) {
snprintf( c->cr_msg, sizeof(c->cr_msg), "<%s> unknown level",
c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s \"%s\"\n",
c->log, c->cr_msg, c->argv[i] );
return 1;
}
}
/* Explicitly setting a zero clears all the levels */
if ( level )
config_syslog |= level;
else
config_syslog = 0;
}
if ( slapMode & SLAP_SERVER_MODE ) {
if ( logfile_only ) {
slap_debug = slap_debug_orig | config_syslog;
ldap_syslog = 0;
} else {
ldap_syslog = config_syslog;
}
}
return 0;
}
static int static int
config_include( ConfigArgs *c ) config_include( ConfigArgs *c )
{ {
@ -3784,7 +3587,7 @@ lload_config_destroy( void )
free( line ); free( line );
if ( slapd_args_file ) free( slapd_args_file ); if ( slapd_args_file ) free( slapd_args_file );
if ( slapd_pid_file ) free( slapd_pid_file ); if ( slapd_pid_file ) free( slapd_pid_file );
loglevel_destroy(); slap_loglevel_destroy();
} }
/* See if the given URL (in plain and parsed form) matches /* See if the given URL (in plain and parsed form) matches

6
servers/slapd/back-monitor/log.c
View file

@ -77,7 +77,7 @@ monitor_subsys_log_open(
{ {
BerVarray bva = NULL; BerVarray bva = NULL;
if ( loglevel2bvarray( ldap_syslog, &bva ) == 0 && bva != NULL ) { if ( loglevel2bvarray( slap_syslog_get(), &bva ) == 0 && bva != NULL ) {
monitor_info_t *mi; monitor_info_t *mi;
Entry *e; Entry *e;
@ -109,7 +109,7 @@ monitor_subsys_log_modify(
{ {
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private; monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
int rc = LDAP_OTHER; int rc = LDAP_OTHER;
int newlevel = ldap_syslog; int newlevel = slap_syslog_get();
Attribute *save_attrs; Attribute *save_attrs;
Modifications *modlist = op->orm_modlist; Modifications *modlist = op->orm_modlist;
Modifications *ml; Modifications *ml;
@ -191,7 +191,7 @@ monitor_subsys_log_modify(
/* /*
* Do we need to protect this with a mutex? * Do we need to protect this with a mutex?
*/ */
ldap_syslog = newlevel; slap_syslog_set( newlevel );
#if 0 /* debug rather than log */ #if 0 /* debug rather than log */
slap_debug = newlevel; slap_debug = newlevel;

356
servers/slapd/bconfig.c
View file

@ -38,6 +38,7 @@
#include <lutil.h> #include <lutil.h>
#include "slap-config.h" #include "slap-config.h"
#include "slap-cfglog.h"
#define CONFIG_RDN "cn=config" #define CONFIG_RDN "cn=config"
#define SCHEMA_RDN "cn=schema" #define SCHEMA_RDN "cn=schema"
@ -129,7 +130,6 @@ static ConfigDriver config_disallows;
static ConfigDriver config_requires; static ConfigDriver config_requires;
static ConfigDriver config_security; static ConfigDriver config_security;
static ConfigDriver config_referral; static ConfigDriver config_referral;
static ConfigDriver config_loglevel;
static ConfigDriver config_updatedn; static ConfigDriver config_updatedn;
static ConfigDriver config_updateref; static ConfigDriver config_updateref;
static ConfigDriver config_extra_attrs; static ConfigDriver config_extra_attrs;
@ -169,7 +169,6 @@ enum {
CFG_ATTR, CFG_ATTR,
CFG_ATOPT, CFG_ATOPT,
CFG_ROOTDSE, CFG_ROOTDSE,
CFG_LOGFILE,
CFG_PLUGIN, CFG_PLUGIN,
CFG_MODLOAD, CFG_MODLOAD,
CFG_MODPATH, CFG_MODPATH,
@ -201,8 +200,6 @@ enum {
CFG_TLS_CACERT, CFG_TLS_CACERT,
CFG_TLS_CERT, CFG_TLS_CERT,
CFG_TLS_KEY, CFG_TLS_KEY,
CFG_LOGFILE_ROTATE,
CFG_LOGFILE_ONLY,
CFG_LAST CFG_LAST
}; };
@ -483,19 +480,19 @@ static ConfigTable config_back_cf_table[] = {
"SYNTAX OMsInteger SINGLE-VALUE )", NULL, "SYNTAX OMsInteger SINGLE-VALUE )", NULL,
{ .v_int = LDAP_PVT_SASL_LOCAL_SSF } }, { .v_int = LDAP_PVT_SASL_LOCAL_SSF } },
{ "logfile", "file", 2, 2, 0, ARG_STRING|ARG_MAGIC|CFG_LOGFILE, { "logfile", "file", 2, 2, 0, ARG_STRING|ARG_MAGIC|CFG_LOGFILE,
&config_generic, "( OLcfgGlAt:27 NAME 'olcLogFile' " &config_logging, "( OLcfgGlAt:27 NAME 'olcLogFile' "
"EQUALITY caseExactMatch " "EQUALITY caseExactMatch "
"SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL }, "SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
{ "logfile-only", "on|off", 2, 2, 0, ARG_ON_OFF|ARG_MAGIC|CFG_LOGFILE_ONLY, { "logfile-only", "on|off", 2, 2, 0, ARG_ON_OFF|ARG_MAGIC|CFG_LOGFILE_ONLY,
&config_generic, "( OLcfgGlAt:102 NAME 'olcLogFileOnly' " &config_logging, "( OLcfgGlAt:102 NAME 'olcLogFileOnly' "
"EQUALITY booleanMatch " "EQUALITY booleanMatch "
"SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL }, "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL },
{ "logfile-rotate", "max> <Mbyte> <hours", 4, 4, 0, ARG_MAGIC|CFG_LOGFILE_ROTATE, { "logfile-rotate", "max> <Mbyte> <hours", 4, 4, 0, ARG_MAGIC|CFG_LOGFILE_ROTATE,
&config_generic, "( OLcfgGlAt:103 NAME 'olcLogFileRotate' " &config_logging, "( OLcfgGlAt:103 NAME 'olcLogFileRotate' "
"EQUALITY caseIgnoreMatch " "EQUALITY caseIgnoreMatch "
"SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL }, "SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
{ "loglevel", "level", 2, 0, 0, ARG_MAGIC, { "loglevel", "level", 2, 0, 0, ARG_MAGIC|CFG_LOGLEVEL,
&config_loglevel, "( OLcfgGlAt:28 NAME 'olcLogLevel' " &config_logging, "( OLcfgGlAt:28 NAME 'olcLogLevel' "
"EQUALITY caseIgnoreMatch " "EQUALITY caseIgnoreMatch "
"SYNTAX OMsDirectoryString )", NULL, NULL }, "SYNTAX OMsDirectoryString )", NULL, NULL },
{ "maxDerefDepth", "depth", 2, 2, 0, ARG_DB|ARG_INT|ARG_MAGIC|CFG_DEPTH, { "maxDerefDepth", "depth", 2, 2, 0, ARG_DB|ARG_INT|ARG_MAGIC|CFG_DEPTH,
@ -1089,8 +1086,6 @@ static ADlist *sortVals;
static int new_daemon_threads; static int new_daemon_threads;
static int config_syslog;
static int static int
config_resize_lthreads(ConfigArgs *c) config_resize_lthreads(ConfigArgs *c)
{ {
@ -1383,31 +1378,6 @@ config_generic(ConfigArgs *c) {
rc = 1; rc = 1;
} }
break; break;
case CFG_LOGFILE: {
const char *logfileName = logfile_name();
if ( logfileName && *logfileName )
c->value_string = ch_strdup( logfileName );
else
rc = 1;
}
break;
case CFG_LOGFILE_ONLY:
c->value_int = logfile_only;
break;
case CFG_LOGFILE_ROTATE:
rc = 1;
if ( logfile_max ) {
char buf[64];
struct berval bv;
bv.bv_len = snprintf( buf, sizeof(buf), "%d %ld %ld", logfile_max,
(long) logfile_fslimit / 1048576, (long) logfile_age / 3600 );
if ( bv.bv_len > 0 && bv.bv_len < sizeof(buf) ) {
bv.bv_val = buf;
value_add_one( &c->rvalue_vals, &bv );
rc = 0;
}
}
break;
case CFG_LASTMOD: case CFG_LASTMOD:
c->value_int = (SLAP_NOLASTMOD(c->be) == 0); c->value_int = (SLAP_NOLASTMOD(c->be) == 0);
break; break;
@ -1638,20 +1608,6 @@ config_generic(ConfigArgs *c) {
passwd_salt = NULL; passwd_salt = NULL;
break; break;
case CFG_LOGFILE:
logfile_close();
break;
case CFG_LOGFILE_ONLY:
/* remove loglevel from debuglevel */
slap_debug = slap_debug_orig;
ldap_syslog = config_syslog;
break;
case CFG_LOGFILE_ROTATE:
logfile_max = logfile_fslimit = logfile_age = 0;
break;
case CFG_SERVERID: { case CFG_SERVERID: {
ServerID *si, **sip; ServerID *si, **sip;
@ -2425,66 +2381,6 @@ sortval_reject:
ldap_free_urldesc( lud ); ldap_free_urldesc( lud );
} }
break; break;
case CFG_LOGFILE: {
int rc = logfile_open( c->value_string );
ch_free( c->value_string );
return rc;
}
break;
case CFG_LOGFILE_ONLY:
slap_debug = slap_debug_orig;
if ( c->value_int ) {
slap_debug |= config_syslog;
ldap_syslog = 0;
} else {
ldap_syslog = config_syslog;
}
logfile_only = c->value_int;
break;
case CFG_LOGFILE_ROTATE: {
unsigned lf_max, lf_mbyte, lf_hour;
if ( lutil_atoux( &lf_max, c->argv[1], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid max value \"%s\"", c->argv[0], c->argv[1] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( !lf_max || lf_max > 99 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid max value \"%s\" must be 1-99", c->argv[0], c->argv[1] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( lutil_atoux( &lf_mbyte, c->argv[2], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid Mbyte value \"%s\"", c->argv[0], c->argv[2] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( lutil_atoux( &lf_hour, c->argv[3], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid hours value \"%s\"", c->argv[0], c->argv[3] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( !lf_mbyte && !lf_hour ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"Mbyte and hours cannot both be zero", c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
logfile_max = lf_max;
logfile_fslimit = lf_mbyte * 1048576; /* Megabytes to bytes */
logfile_age = lf_hour * 3600; /* hours to seconds */
}
break;
case CFG_LASTMOD: case CFG_LASTMOD:
if(SLAP_NOLASTMODCMD(c->be)) { if(SLAP_NOLASTMODCMD(c->be)) {
@ -3821,244 +3717,6 @@ config_extra_attrs(ConfigArgs *c)
return 0; return 0;
} }
static slap_verbmasks *loglevel_ops;
static int
loglevel_init( void )
{
slap_verbmasks lo[] = {
{ BER_BVC("Any"), (slap_mask_t) LDAP_DEBUG_ANY },
{ BER_BVC("Trace"), LDAP_DEBUG_TRACE },
{ BER_BVC("Packets"), LDAP_DEBUG_PACKETS },
{ BER_BVC("Args"), LDAP_DEBUG_ARGS },
{ BER_BVC("Conns"), LDAP_DEBUG_CONNS },
{ BER_BVC("BER"), LDAP_DEBUG_BER },
{ BER_BVC("Filter"), LDAP_DEBUG_FILTER },
{ BER_BVC("Config"), LDAP_DEBUG_CONFIG },
{ BER_BVC("ACL"), LDAP_DEBUG_ACL },
{ BER_BVC("Stats"), LDAP_DEBUG_STATS },
{ BER_BVC("Stats2"), LDAP_DEBUG_STATS2 },
{ BER_BVC("Shell"), LDAP_DEBUG_SHELL },
{ BER_BVC("Parse"), LDAP_DEBUG_PARSE },
#if 0 /* no longer used (nor supported) */
{ BER_BVC("Cache"), LDAP_DEBUG_CACHE },
{ BER_BVC("Index"), LDAP_DEBUG_INDEX },
#endif
{ BER_BVC("Sync"), LDAP_DEBUG_SYNC },
{ BER_BVC("None"), LDAP_DEBUG_NONE },
{ BER_BVNULL, 0 }
};
return slap_verbmasks_init( &loglevel_ops, lo );
}
static void
loglevel_destroy( void )
{
if ( loglevel_ops ) {
(void)slap_verbmasks_destroy( loglevel_ops );
}
loglevel_ops = NULL;
}
static slap_mask_t loglevel_ignore[] = { -1, 0 };
int
slap_loglevel_register( slap_mask_t m, struct berval *s )
{
int rc;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
rc = slap_verbmasks_append( &loglevel_ops, m, s, loglevel_ignore );
if ( rc != 0 ) {
Debug( LDAP_DEBUG_ANY, "slap_loglevel_register(%lu, \"%s\") failed\n",
m, s->bv_val );
}
return rc;
}
int
slap_loglevel_get( struct berval *s, int *l )
{
int rc;
slap_mask_t m, i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
for ( m = 0, i = 1; !BER_BVISNULL( &loglevel_ops[ i ].word ); i++ ) {
m |= loglevel_ops[ i ].mask;
}
for ( i = 1; m & i; i <<= 1 )
;
if ( i == 0 ) {
return -1;
}
rc = slap_verbmasks_append( &loglevel_ops, i, s, loglevel_ignore );
if ( rc != 0 ) {
Debug( LDAP_DEBUG_ANY, "slap_loglevel_get(%lu, \"%s\") failed\n",
i, s->bv_val );
} else {
*l = i;
slap_check_unknown_level( s->bv_val, i );
}
return rc;
}
int
str2loglevel( const char *s, int *l )
{
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
i = verb_to_mask( s, loglevel_ops );
if ( BER_BVISNULL( &loglevel_ops[ i ].word ) ) {
return -1;
}
*l = loglevel_ops[ i ].mask;
return 0;
}
const char *
loglevel2str( int l )
{
struct berval bv = BER_BVNULL;
loglevel2bv( l, &bv );
return bv.bv_val;
}
int
loglevel2bv( int l, struct berval *bv )
{
if ( loglevel_ops == NULL ) {
loglevel_init();
}
BER_BVZERO( bv );
return enum_to_verb( loglevel_ops, l, bv ) == -1;
}
int
loglevel2bvarray( int l, BerVarray *bva )
{
if ( loglevel_ops == NULL ) {
loglevel_init();
}
if ( l == 0 ) {
struct berval bv = BER_BVC("0");
return value_add_one( bva, &bv );
}
return mask_to_verbs( loglevel_ops, l, bva );
}
int
loglevel_print( FILE *out )
{
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
fprintf( out, "Installed log subsystems:\n\n" );
for ( i = 0; !BER_BVISNULL( &loglevel_ops[ i ].word ); i++ ) {
unsigned mask = loglevel_ops[ i ].mask & 0xffffffffUL;
fprintf( out,
(mask == ((slap_mask_t) -1 & 0xffffffffUL)
? "\t%-30s (-1, 0xffffffff)\n" : "\t%-30s (%u, 0x%x)\n"),
loglevel_ops[ i ].word.bv_val, mask, mask );
}
fprintf( out, "\nNOTE: custom log subsystems may be later installed "
"by specific code\n\n" );
return 0;
}
static int
config_loglevel(ConfigArgs *c) {
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
if (c->op == SLAP_CONFIG_EMIT) {
/* Get default or commandline slapd setting */
if ( ldap_syslog && !config_syslog )
config_syslog = ldap_syslog;
return loglevel2bvarray( config_syslog, &c->rvalue_vals );
} else if ( c->op == LDAP_MOD_DELETE ) {
if ( !c->line ) {
config_syslog = 0;
} else {
i = verb_to_mask( c->line, loglevel_ops );
config_syslog &= ~loglevel_ops[i].mask;
}
goto reset;
}
for( i=1; i < c->argc; i++ ) {
int level;
if ( isdigit((unsigned char)c->argv[i][0]) || c->argv[i][0] == '-' ) {
if( lutil_atoix( &level, c->argv[i], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> unable to parse level", c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s \"%s\"\n",
c->log, c->cr_msg, c->argv[i]);
return( 1 );
}
} else {
if ( str2loglevel( c->argv[i], &level ) ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> unknown level", c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s \"%s\"\n",
c->log, c->cr_msg, c->argv[i]);
return( 1 );
}
}
/* Explicitly setting a zero clears all the levels */
if ( level )
config_syslog |= level;
else
config_syslog = 0;
}
reset:
if ( slapMode & SLAP_SERVER_MODE ) {
if ( logfile_only ) {
slap_debug = slap_debug_orig | config_syslog;
ldap_syslog = 0;
} else {
ldap_syslog = config_syslog;
}
}
return(0);
}
static int static int
config_referral(ConfigArgs *c) { config_referral(ConfigArgs *c) {
struct berval val; struct berval val;
@ -7877,7 +7535,7 @@ config_back_db_destroy( BackendDB *be, ConfigReply *cr )
backend_destroy_one( &cfb->cb_db, 0 ); backend_destroy_one( &cfb->cb_db, 0 );
} }
loglevel_destroy(); slap_loglevel_destroy();
return 0; return 0;
} }

551
servers/slapd/logging.c
View file

@ -22,6 +22,7 @@
#include <ac/string.h> #include <ac/string.h>
#include <ac/time.h> #include <ac/time.h>
#include <ac/unistd.h> #include <ac/unistd.h>
#include <ac/ctype.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/uio.h> #include <sys/uio.h>
@ -29,11 +30,16 @@
#include "slap.h" #include "slap.h"
#include "slap-config.h"
#include "slap-cfglog.h"
static int config_syslog, active_syslog;
static char logfile_suffix[sizeof(".xx.gz")]; static char logfile_suffix[sizeof(".xx.gz")];
char logfile_path[MAXPATHLEN - sizeof(logfile_suffix) -1]; static char logfile_path[MAXPATHLEN - sizeof(logfile_suffix) -1];
long logfile_fslimit; static long logfile_fslimit;
int logfile_age, logfile_only, logfile_max; static int logfile_age, logfile_only, logfile_max;
int slap_debug_orig; int slap_debug_orig;
ldap_pvt_thread_mutex_t logfile_mutex; ldap_pvt_thread_mutex_t logfile_mutex;
@ -69,7 +75,7 @@ slap_debug_print( const char *data )
iov[1].iov_base = (void *)data; iov[1].iov_base = (void *)data;
iov[1].iov_len = strlen( data ); iov[1].iov_len = strlen( data );
if ( !logfile_only ) if ( !logfile_only )
writev( 2, iov, 2 ); (void)!writev( 2, iov, 2 );
if ( logfile_fd >= 0 ) { if ( logfile_fd >= 0 ) {
int len = iov[0].iov_len + iov[1].iov_len; int len = iov[0].iov_len + iov[1].iov_len;
if ( logfile_fslimit || logfile_age ) { if ( logfile_fslimit || logfile_age ) {
@ -158,3 +164,540 @@ logfile_name()
{ {
return logfile_path[0] ? logfile_path : NULL; return logfile_path[0] ? logfile_path : NULL;
} }
#if defined(LDAP_DEBUG) && defined(LDAP_SYSLOG)
#ifdef LOG_LOCAL4
int
slap_parse_syslog_user( const char *arg, int *syslogUser )
{
static slap_verbmasks syslogUsers[] = {
{ BER_BVC( "LOCAL0" ), LOG_LOCAL0 },
{ BER_BVC( "LOCAL1" ), LOG_LOCAL1 },
{ BER_BVC( "LOCAL2" ), LOG_LOCAL2 },
{ BER_BVC( "LOCAL3" ), LOG_LOCAL3 },
{ BER_BVC( "LOCAL4" ), LOG_LOCAL4 },
{ BER_BVC( "LOCAL5" ), LOG_LOCAL5 },
{ BER_BVC( "LOCAL6" ), LOG_LOCAL6 },
{ BER_BVC( "LOCAL7" ), LOG_LOCAL7 },
#ifdef LOG_USER
{ BER_BVC( "USER" ), LOG_USER },
#endif /* LOG_USER */
#ifdef LOG_DAEMON
{ BER_BVC( "DAEMON" ), LOG_DAEMON },
#endif /* LOG_DAEMON */
{ BER_BVNULL, 0 }
};
int i = verb_to_mask( arg, syslogUsers );
if ( BER_BVISNULL( &syslogUsers[ i ].word ) ) {
Debug( LDAP_DEBUG_ANY,
"unrecognized syslog user \"%s\".\n",
arg );
return 1;
}
*syslogUser = syslogUsers[ i ].mask;
return 0;
}
#endif /* LOG_LOCAL4 */
int
slap_parse_syslog_level( const char *arg, int *levelp )
{
static slap_verbmasks str2syslog_level[] = {
{ BER_BVC( "EMERG" ), LOG_EMERG },
{ BER_BVC( "ALERT" ), LOG_ALERT },
{ BER_BVC( "CRIT" ), LOG_CRIT },
{ BER_BVC( "ERR" ), LOG_ERR },
{ BER_BVC( "WARNING" ), LOG_WARNING },
{ BER_BVC( "NOTICE" ), LOG_NOTICE },
{ BER_BVC( "INFO" ), LOG_INFO },
{ BER_BVC( "DEBUG" ), LOG_DEBUG },
{ BER_BVNULL, 0 }
};
int i = verb_to_mask( arg, str2syslog_level );
if ( BER_BVISNULL( &str2syslog_level[ i ].word ) ) {
Debug( LDAP_DEBUG_ANY,
"unknown syslog level \"%s\".\n",
arg );
return 1;
}
*levelp = str2syslog_level[ i ].mask;
return 0;
}
#endif /* LDAP_DEBUG && LDAP_SYSLOG */
static char **debug_unknowns;
static char **syslog_unknowns;
static int
parse_debug_unknowns( char **unknowns, int *levelp )
{
int i, level, rc = 0;
for ( i = 0; unknowns[ i ] != NULL; i++ ) {
level = 0;
if ( str2loglevel( unknowns[ i ], &level )) {
fprintf( stderr,
"unrecognized log level \"%s\"\n", unknowns[ i ] );
rc = 1;
} else {
*levelp |= level;
}
}
return rc;
}
int
slap_parse_debug_level( const char *arg, int *levelp, int which )
{
int level;
if ( arg && arg[ 0 ] != '-' && !isdigit( (unsigned char) arg[ 0 ] ) )
{
int i;
char **levels;
char ***unknowns = which ? &syslog_unknowns : &debug_unknowns;
levels = ldap_str2charray( arg, "," );
for ( i = 0; levels[ i ] != NULL; i++ ) {
level = 0;
if ( str2loglevel( levels[ i ], &level ) ) {
/* remember this for later */
ldap_charray_add( unknowns, levels[ i ] );
fprintf( stderr,
"unrecognized log level \"%s\" (deferred)\n",
levels[ i ] );
} else {
*levelp |= level;
}
}
ldap_charray_free( levels );
} else {
int rc;
if ( arg[0] == '-' ) {
rc = lutil_atoix( &level, arg, 0 );
} else {
unsigned ulevel;
rc = lutil_atoux( &ulevel, arg, 0 );
level = (int)ulevel;
}
if ( rc ) {
fprintf( stderr,
"unrecognized log level "
"\"%s\"\n", arg );
return 1;
}
if ( level == 0 ) {
*levelp = 0;
} else {
*levelp |= level;
}
}
return 0;
}
int
slap_parse_debug_unknowns() {
int rc = 0;
if ( debug_unknowns ) {
rc = parse_debug_unknowns( debug_unknowns, &slap_debug );
ldap_charray_free( debug_unknowns );
debug_unknowns = NULL;
if ( rc )
goto leave;
ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &slap_debug );
ldap_set_option( NULL, LDAP_OPT_DEBUG_LEVEL, &slap_debug );
}
if ( syslog_unknowns ) {
rc = parse_debug_unknowns( syslog_unknowns, &ldap_syslog );
ldap_charray_free( syslog_unknowns );
syslog_unknowns = NULL;
}
leave:
return rc;
}
void slap_check_unknown_level( char *levelstr, int level )
{
int i;
if ( debug_unknowns ) {
for ( i = 0; debug_unknowns[ i ]; i++ ) {
if ( !strcasecmp( debug_unknowns[ i ], levelstr )) {
slap_debug |= level;
break;
}
}
}
if ( syslog_unknowns ) {
for ( i = 0; syslog_unknowns[ i ]; i++ ) {
if ( !strcasecmp( syslog_unknowns[ i ], levelstr )) {
ldap_syslog |= level;
break;
}
}
}
}
static slap_verbmasks *loglevel_ops;
static int
loglevel_init( void )
{
slap_verbmasks lo[] = {
{ BER_BVC("Any"), (slap_mask_t) LDAP_DEBUG_ANY },
{ BER_BVC("Trace"), LDAP_DEBUG_TRACE },
{ BER_BVC("Packets"), LDAP_DEBUG_PACKETS },
{ BER_BVC("Args"), LDAP_DEBUG_ARGS },
{ BER_BVC("Conns"), LDAP_DEBUG_CONNS },
{ BER_BVC("BER"), LDAP_DEBUG_BER },
{ BER_BVC("Filter"), LDAP_DEBUG_FILTER },
{ BER_BVC("Config"), LDAP_DEBUG_CONFIG },
{ BER_BVC("ACL"), LDAP_DEBUG_ACL },
{ BER_BVC("Stats"), LDAP_DEBUG_STATS },
{ BER_BVC("Stats2"), LDAP_DEBUG_STATS2 },
{ BER_BVC("Shell"), LDAP_DEBUG_SHELL },
{ BER_BVC("Parse"), LDAP_DEBUG_PARSE },
#if 0 /* no longer used (nor supported) */
{ BER_BVC("Cache"), LDAP_DEBUG_CACHE },
{ BER_BVC("Index"), LDAP_DEBUG_INDEX },
#endif
{ BER_BVC("Sync"), LDAP_DEBUG_SYNC },
{ BER_BVC("None"), LDAP_DEBUG_NONE },
{ BER_BVNULL, 0 }
};
return slap_verbmasks_init( &loglevel_ops, lo );
}
void
slap_loglevel_destroy( void )
{
if ( loglevel_ops ) {
(void)slap_verbmasks_destroy( loglevel_ops );
}
loglevel_ops = NULL;
}
static slap_mask_t loglevel_ignore[] = { -1, 0 };
int
slap_loglevel_get( struct berval *s, int *l )
{
int rc;
slap_mask_t m, i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
for ( m = 0, i = 1; !BER_BVISNULL( &loglevel_ops[ i ].word ); i++ ) {
m |= loglevel_ops[ i ].mask;
}
for ( i = 1; m & i; i <<= 1 )
;
if ( i == 0 ) {
return -1;
}
rc = slap_verbmasks_append( &loglevel_ops, i, s, loglevel_ignore );
if ( rc != 0 ) {
Debug( LDAP_DEBUG_ANY, "slap_loglevel_get(%lu, \"%s\") failed\n",
i, s->bv_val );
} else {
*l = i;
slap_check_unknown_level( s->bv_val, i );
}
return rc;
}
int
slap_syslog_get()
{
return active_syslog;
}
void
slap_syslog_set( int l )
{
active_syslog = l;
if ( logfile_only ) {
slap_debug |= active_syslog;
ldap_syslog = 0;
} else {
ldap_syslog = active_syslog;
}
}
int
str2loglevel( const char *s, int *l )
{
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
i = verb_to_mask( s, loglevel_ops );
if ( BER_BVISNULL( &loglevel_ops[ i ].word ) ) {
return -1;
}
*l = loglevel_ops[ i ].mask;
return 0;
}
const char *
loglevel2str( int l )
{
struct berval bv = BER_BVNULL;
loglevel2bv( l, &bv );
return bv.bv_val;
}
int
loglevel2bv( int l, struct berval *bv )
{
if ( loglevel_ops == NULL ) {
loglevel_init();
}
BER_BVZERO( bv );
return enum_to_verb( loglevel_ops, l, bv ) == -1;
}
int
loglevel2bvarray( int l, BerVarray *bva )
{
if ( loglevel_ops == NULL ) {
loglevel_init();
}
if ( l == 0 ) {
struct berval bv = BER_BVC("0");
return value_add_one( bva, &bv );
}
return mask_to_verbs( loglevel_ops, l, bva );
}
int
loglevel_print( FILE *out )
{
int i;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
fprintf( out, "Installed log subsystems:\n\n" );
for ( i = 0; !BER_BVISNULL( &loglevel_ops[ i ].word ); i++ ) {
unsigned mask = loglevel_ops[ i ].mask & 0xffffffffUL;
fprintf( out,
(mask == ((slap_mask_t) -1 & 0xffffffffUL)
? "\t%-30s (-1, 0xffffffff)\n" : "\t%-30s (%u, 0x%x)\n"),
loglevel_ops[ i ].word.bv_val, mask, mask );
}
fprintf( out, "\nNOTE: custom log subsystems may be later installed "
"by specific code\n\n" );
return 0;
}
int
config_logging(ConfigArgs *c) {
int i, rc;
if ( loglevel_ops == NULL ) {
loglevel_init();
}
if (c->op == SLAP_CONFIG_EMIT) {
switch(c->type) {
case CFG_LOGLEVEL:
/* Get default or commandline slapd setting */
if ( ldap_syslog && !config_syslog )
config_syslog = ldap_syslog;
rc = loglevel2bvarray( config_syslog, &c->rvalue_vals );
break;
case CFG_LOGFILE: {
const char *logfileName = logfile_name();
if ( logfileName && *logfileName )
c->value_string = ch_strdup( logfileName );
else
rc = 1;
}
break;
case CFG_LOGFILE_ONLY:
c->value_int = logfile_only;
break;
case CFG_LOGFILE_ROTATE:
rc = 1;
if ( logfile_max ) {
char buf[64];
struct berval bv;
bv.bv_len = snprintf( buf, sizeof(buf), "%d %ld %ld", logfile_max,
(long) logfile_fslimit / 1048576, (long) logfile_age / 3600 );
if ( bv.bv_len > 0 && bv.bv_len < sizeof(buf) ) {
bv.bv_val = buf;
value_add_one( &c->rvalue_vals, &bv );
rc = 0;
}
}
break;
default:
rc = 1;
}
return rc;
} else if ( c->op == LDAP_MOD_DELETE ) {
switch(c->type) {
case CFG_LOGLEVEL:
if ( !c->line ) {
config_syslog = 0;
} else {
i = verb_to_mask( c->line, loglevel_ops );
config_syslog &= ~loglevel_ops[i].mask;
}
goto reset;
case CFG_LOGFILE:
logfile_close();
break;
case CFG_LOGFILE_ONLY:
/* remove loglevel from debuglevel */
slap_debug = slap_debug_orig;
ldap_syslog = config_syslog;
break;
case CFG_LOGFILE_ROTATE:
logfile_max = logfile_fslimit = logfile_age = 0;
break;
default:
rc = 1;
}
return rc;
}
switch(c->type) {
case CFG_LOGLEVEL:
for( i=1; i < c->argc; i++ ) {
int level;
if ( isdigit((unsigned char)c->argv[i][0]) || c->argv[i][0] == '-' ) {
if( lutil_atoix( &level, c->argv[i], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> unable to parse level", c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s \"%s\"\n",
c->log, c->cr_msg, c->argv[i]);
return( 1 );
}
} else {
if ( str2loglevel( c->argv[i], &level ) ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> unknown level", c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s \"%s\"\n",
c->log, c->cr_msg, c->argv[i]);
return( 1 );
}
}
/* Explicitly setting a zero clears all the levels */
if ( level )
config_syslog |= level;
else
config_syslog = 0;
}
reset:
slap_debug = slap_debug_orig;
active_syslog = config_syslog;
if ( logfile_only ) {
slap_debug |= config_syslog;
ldap_syslog = 0;
} else {
ldap_syslog = config_syslog;
}
rc = 0;
break;
case CFG_LOGFILE:
rc = logfile_open( c->value_string );
ch_free( c->value_string );
break;
case CFG_LOGFILE_ONLY:
logfile_only = c->value_int;
goto reset;
case CFG_LOGFILE_ROTATE: {
unsigned lf_max, lf_mbyte, lf_hour;
if ( lutil_atoux( &lf_max, c->argv[1], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid max value \"%s\"", c->argv[0], c->argv[1] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( !lf_max || lf_max > 99 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid max value \"%s\" must be 1-99", c->argv[0], c->argv[1] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( lutil_atoux( &lf_mbyte, c->argv[2], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid Mbyte value \"%s\"", c->argv[0], c->argv[2] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( lutil_atoux( &lf_hour, c->argv[3], 0 ) != 0 ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"invalid hours value \"%s\"", c->argv[0], c->argv[3] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
if ( !lf_mbyte && !lf_hour ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> "
"Mbyte and hours cannot both be zero", c->argv[0] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg );
return 1;
}
logfile_max = lf_max;
logfile_fslimit = lf_mbyte * 1048576; /* Megabytes to bytes */
logfile_age = lf_hour * 3600; /* hours to seconds */
}
break;
default:
rc = 1;
}
return rc;
}

190
servers/slapd/main.c
View file

@ -162,173 +162,6 @@ struct option_helper {
{ BER_BVNULL, 0, NULL, NULL } { BER_BVNULL, 0, NULL, NULL }
}; };
#if defined(LDAP_DEBUG) && defined(LDAP_SYSLOG)
#ifdef LOG_LOCAL4
int
parse_syslog_user( const char *arg, int *syslogUser )
{
static slap_verbmasks syslogUsers[] = {
{ BER_BVC( "LOCAL0" ), LOG_LOCAL0 },
{ BER_BVC( "LOCAL1" ), LOG_LOCAL1 },
{ BER_BVC( "LOCAL2" ), LOG_LOCAL2 },
{ BER_BVC( "LOCAL3" ), LOG_LOCAL3 },
{ BER_BVC( "LOCAL4" ), LOG_LOCAL4 },
{ BER_BVC( "LOCAL5" ), LOG_LOCAL5 },
{ BER_BVC( "LOCAL6" ), LOG_LOCAL6 },
{ BER_BVC( "LOCAL7" ), LOG_LOCAL7 },
#ifdef LOG_USER
{ BER_BVC( "USER" ), LOG_USER },
#endif /* LOG_USER */
#ifdef LOG_DAEMON
{ BER_BVC( "DAEMON" ), LOG_DAEMON },
#endif /* LOG_DAEMON */
{ BER_BVNULL, 0 }
};
int i = verb_to_mask( arg, syslogUsers );
if ( BER_BVISNULL( &syslogUsers[ i ].word ) ) {
Debug( LDAP_DEBUG_ANY,
"unrecognized syslog user \"%s\".\n",
arg );
return 1;
}
*syslogUser = syslogUsers[ i ].mask;
return 0;
}
#endif /* LOG_LOCAL4 */
int
parse_syslog_level( const char *arg, int *levelp )
{
static slap_verbmasks str2syslog_level[] = {
{ BER_BVC( "EMERG" ), LOG_EMERG },
{ BER_BVC( "ALERT" ), LOG_ALERT },
{ BER_BVC( "CRIT" ), LOG_CRIT },
{ BER_BVC( "ERR" ), LOG_ERR },
{ BER_BVC( "WARNING" ), LOG_WARNING },
{ BER_BVC( "NOTICE" ), LOG_NOTICE },
{ BER_BVC( "INFO" ), LOG_INFO },
{ BER_BVC( "DEBUG" ), LOG_DEBUG },
{ BER_BVNULL, 0 }
};
int i = verb_to_mask( arg, str2syslog_level );
if ( BER_BVISNULL( &str2syslog_level[ i ].word ) ) {
Debug( LDAP_DEBUG_ANY,
"unknown syslog level \"%s\".\n",
arg );
return 1;
}
*levelp = str2syslog_level[ i ].mask;
return 0;
}
#endif /* LDAP_DEBUG && LDAP_SYSLOG */
static char **debug_unknowns;
static char **syslog_unknowns;
int
parse_debug_unknowns( char **unknowns, int *levelp )
{
int i, level, rc = 0;
for ( i = 0; unknowns[ i ] != NULL; i++ ) {
level = 0;
if ( str2loglevel( unknowns[ i ], &level )) {
fprintf( stderr,
"unrecognized log level \"%s\"\n", unknowns[ i ] );
rc = 1;
} else {
*levelp |= level;
}
}
return rc;
}
int
parse_debug_level( const char *arg, int *levelp, char ***unknowns )
{
int level;
if ( arg && arg[ 0 ] != '-' && !isdigit( (unsigned char) arg[ 0 ] ) )
{
int i;
char **levels;
levels = ldap_str2charray( arg, "," );
for ( i = 0; levels[ i ] != NULL; i++ ) {
level = 0;
if ( str2loglevel( levels[ i ], &level ) ) {
/* remember this for later */
ldap_charray_add( unknowns, levels[ i ] );
fprintf( stderr,
"unrecognized log level \"%s\" (deferred)\n",
levels[ i ] );
} else {
*levelp |= level;
}
}
ldap_charray_free( levels );
} else {
int rc;
if ( arg[0] == '-' ) {
rc = lutil_atoix( &level, arg, 0 );
} else {
unsigned ulevel;
rc = lutil_atoux( &ulevel, arg, 0 );
level = (int)ulevel;
}
if ( rc ) {
fprintf( stderr,
"unrecognized log level "
"\"%s\"\n", arg );
return 1;
}
if ( level == 0 ) {
*levelp = 0;
} else {
*levelp |= level;
}
}
return 0;
}
void slap_check_unknown_level( char *levelstr, int level )
{
int i;
if ( debug_unknowns ) {
for ( i = 0; debug_unknowns[ i ]; i++ ) {
if ( !strcasecmp( debug_unknowns[ i ], levelstr )) {
slap_debug |= level;
break;
}
}
}
if ( syslog_unknowns ) {
for ( i = 0; syslog_unknowns[ i ]; i++ ) {
if ( !strcasecmp( syslog_unknowns[ i ], levelstr )) {
ldap_syslog |= level;
break;
}
}
}
}
static void static void
usage( char *name ) usage( char *name )
{ {
@ -572,7 +405,7 @@ int main( int argc, char **argv )
} }
no_detach = 1; no_detach = 1;
if ( parse_debug_level( optarg, &level, &debug_unknowns ) ) { if ( slap_parse_debug_level( optarg, &level, 0 ) ) {
goto destroy; goto destroy;
} }
#ifdef LDAP_DEBUG #ifdef LDAP_DEBUG
@ -631,21 +464,21 @@ int main( int argc, char **argv )
break; break;
} }
if ( parse_debug_level( optarg, &ldap_syslog, &syslog_unknowns ) ) { if ( slap_parse_debug_level( optarg, &ldap_syslog, 1 ) ) {
goto destroy; goto destroy;
} }
break; break;
#if defined(LDAP_DEBUG) && defined(LDAP_SYSLOG) #if defined(LDAP_DEBUG) && defined(LDAP_SYSLOG)
case 'S': case 'S':
if ( parse_syslog_level( optarg, &ldap_syslog_level ) ) { if ( slap_parse_syslog_level( optarg, &ldap_syslog_level ) ) {
goto destroy; goto destroy;
} }
break; break;
#ifdef LOG_LOCAL4 #ifdef LOG_LOCAL4
case 'l': /* set syslog local user */ case 'l': /* set syslog local user */
if ( parse_syslog_user( optarg, &syslogUser ) ) { if ( slap_parse_syslog_user( optarg, &syslogUser ) ) {
goto destroy; goto destroy;
} }
break; break;
@ -837,22 +670,9 @@ unhandled_option:;
goto destroy; goto destroy;
} }
if ( debug_unknowns ) { rc = slap_parse_debug_unknowns();
rc = parse_debug_unknowns( debug_unknowns, &slap_debug );
ldap_charray_free( debug_unknowns );
debug_unknowns = NULL;
if ( rc ) if ( rc )
goto destroy; goto destroy;
ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &slap_debug );
ldap_set_option( NULL, LDAP_OPT_DEBUG_LEVEL, &slap_debug );
}
if ( syslog_unknowns ) {
rc = parse_debug_unknowns( syslog_unknowns, &ldap_syslog );
ldap_charray_free( syslog_unknowns );
syslog_unknowns = NULL;
if ( rc )
goto destroy;
}
if ( check & CHECK_LOGLEVEL ) { if ( check & CHECK_LOGLEVEL ) {
rc = 0; rc = 0;

40
servers/slapd/proto-slap.h
View file

@ -504,13 +504,6 @@ LDAP_SLAPD_F (int) overlay_callback_after_backover LDAP_P((
/* /*
* bconfig.c * bconfig.c
*/ */
LDAP_SLAPD_F (int) slap_loglevel_register LDAP_P (( slap_mask_t m, struct berval *s ));
LDAP_SLAPD_F (int) slap_loglevel_get LDAP_P(( struct berval *s, int *l ));
LDAP_SLAPD_F (int) str2loglevel LDAP_P(( const char *s, int *l ));
LDAP_SLAPD_F (int) loglevel2bvarray LDAP_P(( int l, BerVarray *bva ));
LDAP_SLAPD_F (const char *) loglevel2str LDAP_P(( int l ));
LDAP_SLAPD_F (int) loglevel2bv LDAP_P(( int l, struct berval *bv ));
LDAP_SLAPD_F (int) loglevel_print LDAP_P(( FILE *out ));
LDAP_SLAPD_F (int) slap_cf_aux_table_parse LDAP_P(( const char *word, void *bc, slap_cf_aux_table *tab0, LDAP_CONST char *tabmsg )); LDAP_SLAPD_F (int) slap_cf_aux_table_parse LDAP_P(( const char *word, void *bc, slap_cf_aux_table *tab0, LDAP_CONST char *tabmsg ));
LDAP_SLAPD_F (int) slap_cf_aux_table_unparse LDAP_P(( void *bc, struct berval *bv, slap_cf_aux_table *tab0 )); LDAP_SLAPD_F (int) slap_cf_aux_table_unparse LDAP_P(( void *bc, struct berval *bv, slap_cf_aux_table *tab0 ));
@ -1226,30 +1219,35 @@ LDAP_SLAPD_F (int) lock_fclose LDAP_P(( FILE *fp, FILE *lfp ));
/* /*
* logging.c * logging.c
*/ */
LDAP_SLAPD_F (int) slap_loglevel_get LDAP_P(( struct berval *s, int *l ));
LDAP_SLAPD_F (void) slap_loglevel_destroy LDAP_P(( void ));
LDAP_SLAPD_F (int) str2loglevel LDAP_P(( const char *s, int *l ));
LDAP_SLAPD_F (int) loglevel2bvarray LDAP_P(( int l, BerVarray *bva ));
LDAP_SLAPD_F (const char *) loglevel2str LDAP_P(( int l ));
LDAP_SLAPD_F (int) loglevel2bv LDAP_P(( int l, struct berval *bv ));
LDAP_SLAPD_F (int) loglevel_print LDAP_P(( FILE *out ));
LDAP_SLAPD_F (void) slap_debug_print LDAP_P(( const char *data )); LDAP_SLAPD_F (void) slap_debug_print LDAP_P(( const char *data ));
LDAP_SLAPD_F (int) logfile_open LDAP_P(( const char *path )); LDAP_SLAPD_F (int) logfile_open LDAP_P(( const char *path ));
LDAP_SLAPD_F (void) logfile_close LDAP_P(( void )); LDAP_SLAPD_F (void) logfile_close LDAP_P(( void ));
LDAP_SLAPD_F (void) slap_syslog_set LDAP_P(( int l ));
LDAP_SLAPD_F (int) slap_syslog_get LDAP_P(( void ));
LDAP_SLAPD_F (const char *) logfile_name LDAP_P(( void )); LDAP_SLAPD_F (const char *) logfile_name LDAP_P(( void ));
LDAP_SLAPD_F (int)
slap_parse_syslog_level LDAP_P(( const char *arg, int *levelp ));
LDAP_SLAPD_F (int)
slap_parse_syslog_user LDAP_P(( const char *arg, int *syslogUser ));
LDAP_SLAPD_F (int)
slap_parse_debug_level LDAP_P(( const char *arg, int *levelp, int which ));
LDAP_SLAPD_F (int)
slap_parse_debug_unknowns LDAP_P(( void ));
LDAP_SLAPD_F (void)
slap_check_unknown_level LDAP_P(( char *levelstr, int level ));
LDAP_SLAPD_V(ldap_pvt_thread_mutex_t) logfile_mutex; LDAP_SLAPD_V(ldap_pvt_thread_mutex_t) logfile_mutex;
LDAP_SLAPD_V(int) logfile_age;
LDAP_SLAPD_V(int) logfile_only;
LDAP_SLAPD_V(int) logfile_max;
LDAP_SLAPD_V(long) logfile_fslimit;
LDAP_SLAPD_V(int) slap_debug_orig; LDAP_SLAPD_V(int) slap_debug_orig;
/* /*
* main.c * main.c
*/ */
LDAP_SLAPD_F (int)
parse_debug_level LDAP_P(( const char *arg, int *levelp, char ***unknowns ));
LDAP_SLAPD_F (int)
parse_syslog_level LDAP_P(( const char *arg, int *levelp ));
LDAP_SLAPD_F (int)
parse_syslog_user LDAP_P(( const char *arg, int *syslogUser ));
LDAP_SLAPD_F (int)
parse_debug_unknowns LDAP_P(( char **unknowns, int *levelp ));
LDAP_SLAPD_F (void)
slap_check_unknown_level LDAP_P(( char *levelstr, int level ));
/* /*
* matchedValues.c * matchedValues.c

29
servers/slapd/slap-cfglog.h Normal file
View file

@ -0,0 +1,29 @@
/* slap-cfglog.h - logging configuration */
/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
* Copyright 1998-2021 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted only as authorized by the OpenLDAP
* Public License.
*
* A copy of this license is available in the file LICENSE in the
* top-level directory of the distribution or, alternatively, at
* <http://www.OpenLDAP.org/license.html>.
*/
#ifndef CFGLOG_H
#define CFGLOG_H
enum {
CFG_LOGLEVEL = 1,
CFG_LOGFILE,
CFG_LOGFILE_ROTATE,
CFG_LOGFILE_ONLY
};
extern ConfigDriver config_logging;
#endif /* CFGLOG_H */

26
servers/slapd/slapcommon.c
View file

@ -50,7 +50,6 @@ static LDIFFP dummy;
#if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG) #if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG)
int start_syslog; int start_syslog;
static char **syslog_unknowns;
#ifdef LOG_LOCAL4 #ifdef LOG_LOCAL4
static int syslogUser = SLAP_DEFAULT_SYSLOG_USER; static int syslogUser = SLAP_DEFAULT_SYSLOG_USER;
#endif /* LOG_LOCAL4 */ #endif /* LOG_LOCAL4 */
@ -178,20 +177,20 @@ parse_slapopt( int tool, int *mode )
#if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG) #if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG)
} else if ( strncasecmp( optarg, "syslog", len ) == 0 ) { } else if ( strncasecmp( optarg, "syslog", len ) == 0 ) {
if ( parse_debug_level( p, &ldap_syslog, &syslog_unknowns ) ) { if ( slap_parse_debug_level( p, &ldap_syslog, 1 ) ) {
return -1; return -1;
} }
start_syslog = 1; start_syslog = 1;
} else if ( strncasecmp( optarg, "syslog-level", len ) == 0 ) { } else if ( strncasecmp( optarg, "syslog-level", len ) == 0 ) {
if ( parse_syslog_level( p, &ldap_syslog_level ) ) { if ( slap_parse_syslog_level( p, &ldap_syslog_level ) ) {
return -1; return -1;
} }
start_syslog = 1; start_syslog = 1;
#ifdef LOG_LOCAL4 #ifdef LOG_LOCAL4
} else if ( strncasecmp( optarg, "syslog-user", len ) == 0 ) { } else if ( strncasecmp( optarg, "syslog-user", len ) == 0 ) {
if ( parse_syslog_user( p, &syslogUser ) ) { if ( slap_parse_syslog_user( p, &syslogUser ) ) {
return -1; return -1;
} }
start_syslog = 1; start_syslog = 1;
@ -286,7 +285,6 @@ slap_tool_init(
char *filterstr = NULL; char *filterstr = NULL;
char *subtree = NULL; char *subtree = NULL;
char *ldiffile = NULL; char *ldiffile = NULL;
char **debug_unknowns = NULL;
int rc, i; int rc, i;
int mode = SLAP_TOOL_MODE; int mode = SLAP_TOOL_MODE;
int truncatemode = 0; int truncatemode = 0;
@ -384,7 +382,7 @@ slap_tool_init(
case 'd': { /* turn on debugging */ case 'd': { /* turn on debugging */
int level = 0; int level = 0;
if ( parse_debug_level( optarg, &level, &debug_unknowns ) ) { if ( slap_parse_debug_level( optarg, &level, 0 ) ) {
usage( tool, progname ); usage( tool, progname );
} }
#ifdef LDAP_DEBUG #ifdef LDAP_DEBUG
@ -689,23 +687,9 @@ slap_tool_init(
exit( EXIT_FAILURE ); exit( EXIT_FAILURE );
} }
if ( debug_unknowns ) { rc = slap_parse_debug_unknowns();
rc = parse_debug_unknowns( debug_unknowns, &slap_debug );
ldap_charray_free( debug_unknowns );
debug_unknowns = NULL;
if ( rc ) if ( rc )
exit( EXIT_FAILURE ); exit( EXIT_FAILURE );
}
#if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG)
if ( syslog_unknowns ) {
rc = parse_debug_unknowns( syslog_unknowns, &ldap_syslog );
ldap_charray_free( syslog_unknowns );
syslog_unknowns = NULL;
if ( rc )
exit( EXIT_FAILURE );
}
#endif
at_oc_cache = 1; at_oc_cache = 1;