X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fback-monitor%2Finit.c;h=6a68be5401009ac6a438dc61857ac1ad1d8e9f4c;hb=49bd9befa4c721b4b65c153be2b4bc7a2467df65;hp=81daaf29d820af8c6f8870fe5ee3bc79e4c0fad5;hpb=f757db004cca62a1cd29f4e4959bad9c5577fcc3;p=openldap diff --git a/servers/slapd/back-monitor/init.c b/servers/slapd/back-monitor/init.c index 81daaf29d8..6a68be5401 100644 --- a/servers/slapd/back-monitor/init.c +++ b/servers/slapd/back-monitor/init.c @@ -1,34 +1,22 @@ /* init.c - initialize monitor backend */ -/* - * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* $OpenLDAP$ */ +/* This work is part of OpenLDAP Software . + * + * Copyright 2001-2004 The OpenLDAP Foundation. + * Portions Copyright 2001-2003 Pierangelo Masarati. + * 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 file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . */ -/* - * Copyright 2001, Pierangelo Masarati, All rights reserved. - * - * This work has beed deveolped for the OpenLDAP Foundation - * in the hope that it may be useful to the Open Source community, - * but WITHOUT ANY WARRANTY. - * - * Permission is granted to anyone to use this software for any purpose - * on any computer system, and to alter it and redistribute it, subject - * to the following restrictions: - * - * 1. The author and SysNet s.n.c. are not responsible for the consequences - * of use of this software, no matter how awful, even if they arise from - * flaws in it. - * - * 2. The origin of this software must not be misrepresented, either by - * explicit claim or by omission. Since few users ever read sources, - * credits should appear in the documentation. - * - * 3. Altered versions must be plainly marked as such, and must not be - * misrepresented as being the original software. Since few users - * ever read sources, credits should appear in the documentation. - * SysNet s.n.c. cannot be responsible for the consequences of the - * alterations. - * - * 4. This notice may not be removed or altered. +/* ACKNOWLEDGEMENTS: + * This work was initially developed by Pierangelo Masarati for inclusion + * in OpenLDAP Software. */ #include "portable.h" @@ -36,13 +24,16 @@ #include #include +#include #include "slap.h" +#include "lber_pvt.h" #include "back-monitor.h" +#undef INTEGRATE_CORE_SCHEMA + /* * used by many functions to add description to entries */ -AttributeDescription *monitor_ad_desc = NULL; BackendDB *be_monitor = NULL; /* @@ -51,23 +42,23 @@ BackendDB *be_monitor = NULL; struct monitorsubsys monitor_subsys[] = { { SLAPD_MONITOR_LISTENER, SLAPD_MONITOR_LISTENER_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, - MONITOR_F_NONE, - NULL, /* init */ + BER_BVNULL, BER_BVNULL, BER_BVNULL, + MONITOR_F_PERSISTENT_CH, + monitor_subsys_listener_init, NULL, /* update */ NULL, /* create */ NULL /* modify */ }, { SLAPD_MONITOR_DATABASE, SLAPD_MONITOR_DATABASE_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, + BER_BVNULL, BER_BVNULL, BER_BVNULL, MONITOR_F_PERSISTENT_CH, monitor_subsys_database_init, NULL, /* update */ NULL, /* create */ - NULL /* modify */ + monitor_subsys_database_modify }, { SLAPD_MONITOR_BACKEND, SLAPD_MONITOR_BACKEND_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, + BER_BVNULL, BER_BVNULL, BER_BVNULL, MONITOR_F_PERSISTENT_CH, monitor_subsys_backend_init, NULL, /* update */ @@ -75,7 +66,7 @@ struct monitorsubsys monitor_subsys[] = { NULL /* modify */ }, { SLAPD_MONITOR_THREAD, SLAPD_MONITOR_THREAD_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, + BER_BVNULL, BER_BVNULL, BER_BVNULL, MONITOR_F_NONE, monitor_subsys_thread_init, monitor_subsys_thread_update, @@ -83,7 +74,7 @@ struct monitorsubsys monitor_subsys[] = { NULL /* modify */ }, { SLAPD_MONITOR_SASL, SLAPD_MONITOR_SASL_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, + BER_BVNULL, BER_BVNULL, BER_BVNULL, MONITOR_F_NONE, NULL, /* init */ NULL, /* update */ @@ -91,7 +82,7 @@ struct monitorsubsys monitor_subsys[] = { NULL /* modify */ }, { SLAPD_MONITOR_TLS, SLAPD_MONITOR_TLS_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, + BER_BVNULL, BER_BVNULL, BER_BVNULL, MONITOR_F_NONE, NULL, /* init */ NULL, /* update */ @@ -99,31 +90,23 @@ struct monitorsubsys monitor_subsys[] = { NULL /* modify */ }, { SLAPD_MONITOR_CONN, SLAPD_MONITOR_CONN_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, + BER_BVNULL, BER_BVNULL, BER_BVNULL, MONITOR_F_VOLATILE_CH, monitor_subsys_conn_init, monitor_subsys_conn_update, monitor_subsys_conn_create, NULL /* modify */ }, { - SLAPD_MONITOR_READW, SLAPD_MONITOR_READW_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, - MONITOR_F_NONE, - NULL, /* init */ - monitor_subsys_readw_update, + SLAPD_MONITOR_RWW, SLAPD_MONITOR_RWW_NAME, + BER_BVNULL, BER_BVNULL, BER_BVNULL, + MONITOR_F_PERSISTENT_CH, + monitor_subsys_rww_init, + monitor_subsys_rww_update, NULL, /* create */ NULL /* modify */ - }, { - SLAPD_MONITOR_WRITEW, SLAPD_MONITOR_WRITEW_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, - MONITOR_F_NONE, - NULL, /* init */ - monitor_subsys_writew_update, - NULL, /* create */ - NULL /* modify */ }, { SLAPD_MONITOR_LOG, SLAPD_MONITOR_LOG_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, + BER_BVNULL, BER_BVNULL, BER_BVNULL, MONITOR_F_NONE, monitor_subsys_log_init, NULL, /* update */ @@ -131,23 +114,55 @@ struct monitorsubsys monitor_subsys[] = { monitor_subsys_log_modify }, { SLAPD_MONITOR_OPS, SLAPD_MONITOR_OPS_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, - MONITOR_F_NONE, + BER_BVNULL, BER_BVNULL, BER_BVNULL, + MONITOR_F_PERSISTENT_CH, monitor_subsys_ops_init, monitor_subsys_ops_update, NULL, /* create */ NULL, /* modify */ }, { SLAPD_MONITOR_SENT, SLAPD_MONITOR_SENT_NAME, - { 0L, NULL }, { 0L, NULL }, { 0L, NULL }, - MONITOR_F_NONE, + BER_BVNULL, BER_BVNULL, BER_BVNULL, + MONITOR_F_PERSISTENT_CH, monitor_subsys_sent_init, monitor_subsys_sent_update, NULL, /* create */ NULL, /* modify */ + }, { + SLAPD_MONITOR_TIME, SLAPD_MONITOR_TIME_NAME, + BER_BVNULL, BER_BVNULL, BER_BVNULL, + MONITOR_F_PERSISTENT_CH, + monitor_subsys_time_init, + monitor_subsys_time_update, + NULL, /* create */ + NULL, /* modify */ + }, { + SLAPD_MONITOR_OVERLAY, SLAPD_MONITOR_OVERLAY_NAME, + BER_BVNULL, BER_BVNULL, BER_BVNULL, + MONITOR_F_PERSISTENT_CH, + monitor_subsys_overlay_init, + NULL, /* update */ + NULL, /* create */ + NULL, /* modify */ }, { -1, NULL } }; +#if SLAPD_MONITOR == SLAPD_MOD_DYNAMIC + +int +init_module( int argc, char *argv[] ) +{ + BackendInfo bi; + + memset( &bi, '\0', sizeof(bi) ); + bi.bi_type = "monitor"; + bi.bi_init = monitor_back_initialize; + backend_add( &bi ); + return 0; +} + +#endif /* SLAPD_MONITOR */ + int monitor_back_initialize( BackendInfo *bi @@ -155,20 +170,21 @@ monitor_back_initialize( { static char *controls[] = { LDAP_CONTROL_MANAGEDSAIT, + LDAP_CONTROL_VALUESRETURNFILTER, NULL }; bi->bi_controls = controls; bi->bi_init = 0; - bi->bi_open = monitor_back_open; + bi->bi_open = 0; bi->bi_config = monitor_back_config; bi->bi_close = 0; bi->bi_destroy = 0; bi->bi_db_init = monitor_back_db_init; bi->bi_db_config = monitor_back_db_config; - bi->bi_db_open = 0; + bi->bi_db_open = monitor_back_db_open; bi->bi_db_close = 0; bi->bi_db_destroy = monitor_back_db_destroy; @@ -185,8 +201,6 @@ monitor_back_initialize( bi->bi_extended = 0; bi->bi_entry_release_rw = 0; - bi->bi_acl_group = 0; - bi->bi_acl_attribute = 0; bi->bi_chk_referrals = 0; bi->bi_operational = monitor_back_operational; @@ -201,6 +215,9 @@ monitor_back_initialize( bi->bi_tool_entry_put = 0; bi->bi_tool_entry_reindex = 0; bi->bi_tool_sync = 0; + bi->bi_tool_dn2id_get = 0; + bi->bi_tool_id2entry_get = 0; + bi->bi_tool_entry_modify = 0; bi->bi_connection_init = 0; bi->bi_connection_destroy = 0; @@ -214,63 +231,491 @@ monitor_back_db_init( ) { struct monitorinfo *mi; - Entry *e, *e_tmp; - struct monitorentrypriv *mp; int i, rc; - char buf[1024], *end_of_line; - struct berval dn, *ndn; - const char *text; - struct berval bv[2]; - + struct berval dn, ndn; + struct berval bv; + const char *text; + + struct m_s { + char *name; + char *schema; + slap_mask_t flags; + int offset; + } moc[] = { + { "monitor", "( 1.3.6.1.4.1.4203.666.3.2 " + "NAME 'monitor' " + "DESC 'OpenLDAP system monitoring' " + "SUP top STRUCTURAL " + "MUST cn " + "MAY ( " + "description " + "$ l " +#if 0 /* temporarily disabled */ + "$ st " + "$ street " + "$ postalAddress " + "$ postalCode " +#endif + "$ seeAlso " + "$ labeledURI " + "$ monitoredInfo " + "$ managedInfo " + "$ monitorOverlay " + ") )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_monitor) }, + { "monitorServer", "( 1.3.6.1.4.1.4203.666.3.7 " + "NAME 'monitorServer' " + "DESC 'Server monitoring root entry' " + "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_monitorServer) }, + { "monitorContainer", "( 1.3.6.1.4.1.4203.666.3.8 " + "NAME 'monitorContainer' " + "DESC 'monitor container class' " + "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_monitorContainer) }, + { "monitorCounterObject", "( 1.3.6.1.4.1.4203.666.3.9 " + "NAME 'monitorCounterObject' " + "DESC 'monitor counter class' " + "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_monitorCounterObject) }, + { "monitorOperation", "( 1.3.6.1.4.1.4203.666.3.10 " + "NAME 'monitorOperation' " + "DESC 'monitor operation class' " + "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_monitorOperation) }, + { "monitorConnection", "( 1.3.6.1.4.1.4203.666.3.11 " + "NAME 'monitorConnection' " + "DESC 'monitor connection class' " + "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_monitorConnection) }, + { "managedObject", "( 1.3.6.1.4.1.4203.666.3.12 " + "NAME 'managedObject' " + "DESC 'monitor managed entity class' " + "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_managedObject) }, + { "monitoredObject", "( 1.3.6.1.4.1.4203.666.3.13 " + "NAME 'monitoredObject' " + "DESC 'monitor monitored entity class' " + "SUP monitor STRUCTURAL )", SLAP_OC_OPERATIONAL|SLAP_OC_HIDE, + offsetof(struct monitorinfo, mi_oc_monitoredObject) }, + { NULL, NULL, 0, -1 } + }, mat[] = { + { "monitoredInfo", "( 1.3.6.1.4.1.4203.666.1.14 " + "NAME 'monitoredInfo' " + "DESC 'monitored info' " + /* "SUP name " */ + "EQUALITY caseIgnoreMatch " + "SUBSTR caseIgnoreSubstringsMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{32768} " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitoredInfo) }, + { "managedInfo", "( 1.3.6.1.4.1.4203.666.1.15 " + "NAME 'managedInfo' " + "DESC 'monitor managed info' " + "SUP name )", SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_managedInfo) }, + { "monitorCounter", "( 1.3.6.1.4.1.4203.666.1.16 " + "NAME 'monitorCounter' " + "DESC 'monitor counter' " + "EQUALITY integerMatch " + "ORDERING integerOrderingMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorCounter) }, + { "monitorOpCompleted", "( 1.3.6.1.4.1.4203.666.1.17 " + "NAME 'monitorOpCompleted' " + "DESC 'monitor completed operations' " + "SUP monitorCounter " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorOpCompleted) }, + { "monitorOpInitiated", "( 1.3.6.1.4.1.4203.666.1.18 " + "NAME 'monitorOpInitiated' " + "DESC 'monitor initiated operations' " + "SUP monitorCounter " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorOpInitiated) }, + { "monitorConnectionNumber", "( 1.3.6.1.4.1.4203.666.1.19 " + "NAME 'monitorConnectionNumber' " + "DESC 'monitor connection number' " + "SUP monitorCounter " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorConnectionNumber) }, + { "monitorConnectionAuthzDN", "( 1.3.6.1.4.1.4203.666.1.20 " + "NAME 'monitorConnectionAuthzDN' " + "DESC 'monitor connection authorization DN' " + /* "SUP distinguishedName " */ + "EQUALITY distinguishedNameMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorConnectionAuthzDN) }, + { "monitorConnectionLocalAddress", "( 1.3.6.1.4.1.4203.666.1.21 " + "NAME 'monitorConnectionLocalAddress' " + "DESC 'monitor connection local address' " + "SUP monitoredInfo " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorConnectionLocalAddress) }, + { "monitorConnectionPeerAddress", "( 1.3.6.1.4.1.4203.666.1.22 " + "NAME 'monitorConnectionPeerAddress' " + "DESC 'monitor connection peer address' " + "SUP monitoredInfo " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorConnectionPeerAddress) }, + { "monitorTimestamp", "( 1.3.6.1.4.1.4203.666.1.24 " + "NAME 'monitorTimestamp' " + "DESC 'monitor timestamp' " + "EQUALITY generalizedTimeMatch " + "ORDERING generalizedTimeOrderingMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 " + "SINGLE-VALUE " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_FINAL|SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorTimestamp) }, + { "monitorOverlay", "( 1.3.6.1.4.1.4203.666.1.27 " + "NAME 'monitorOverlay' " + "DESC 'name of overlays defined for a give database' " + "SUP monitoredInfo " + "NO-USER-MODIFICATION " + "USAGE directoryOperation )", SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_monitorOverlay) }, + { "readOnly", "( 1.3.6.1.4.1.4203.666.1.31 " + "NAME 'readOnly' " + "DESC 'read/write status of a given database' " + "EQUALITY booleanMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 " + "SINGLE-VALUE " + "USAGE directoryOperation )", SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_readOnly) }, + { "restrictedOperation", "( 1.3.6.1.4.1.4203.666.1.32 " + "NAME 'restrictedOperation' " + "DESC 'name of restricted operation for a given database' " + "SUP managedInfo )", SLAP_AT_HIDE, + offsetof(struct monitorinfo, mi_ad_restrictedOperation ) }, +#ifdef INTEGRATE_CORE_SCHEMA + { NULL, NULL, 0, -1 }, /* description */ + { NULL, NULL, 0, -1 }, /* seeAlso */ + { NULL, NULL, 0, -1 }, /* l */ + { NULL, NULL, 0, -1 }, /* labeledURI */ +#endif /* INTEGRATE_CORE_SCHEMA */ + { NULL, NULL, 0, -1 } + }, mat_core[] = { + { "description", "( 2.5.4.13 " + "NAME 'description' " + "DESC 'RFC2256: descriptive information' " + "EQUALITY caseIgnoreMatch " + "SUBSTR caseIgnoreSubstringsMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{1024} )", 0, + offsetof(struct monitorinfo, mi_ad_description) }, + { "seeAlso", "( 2.5.4.34 " + "NAME 'seeAlso' " + "DESC 'RFC2256: DN of related object' " + "SUP distinguishedName )", 0, + offsetof(struct monitorinfo, mi_ad_seeAlso) }, + { "l", "( 2.5.4.7 " + "NAME ( 'l' 'localityName' ) " + "DESC 'RFC2256: locality which this object resides in' " + "SUP name )", 0, + offsetof(struct monitorinfo, mi_ad_l) }, + { "labeledURI", "( 1.3.6.1.4.1.250.1.57 " + "NAME 'labeledURI' " + "DESC 'RFC2079: Uniform Resource Identifier with optional label' " + "EQUALITY caseExactMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )", 0, + offsetof(struct monitorinfo, mi_ad_labeledURI) }, + { NULL, NULL, 0, -1 } + }; + /* * database monitor can be defined once only */ if ( be_monitor ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, - "only one monitor backend is allowed\n" )); + LDAP_LOG( OPERATION, CRIT, + "only one monitor backend is allowed\n", 0, 0, 0); #else Debug( LDAP_DEBUG_ANY, - "only one monitor backend is allowed\n%s%s%s", - "", "", "" ); + "only one monitor backend is allowed\n", 0, 0, 0 ); #endif return( -1 ); } be_monitor = be; - ndn = NULL; + /* indicate system schema supported */ + SLAP_BFLAGS(be) |= SLAP_BFLAG_MONITOR; + dn.bv_val = SLAPD_MONITOR_DN; dn.bv_len = sizeof( SLAPD_MONITOR_DN ) - 1; - rc = dnNormalize( NULL, &dn, &ndn ); + rc = dnNormalize( 0, NULL, NULL, &dn, &ndn, NULL ); if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, - "monitor DN \"" SLAPD_MONITOR_DN "\" backend is allowed\n" )); + LDAP_LOG( OPERATION, CRIT, + "unable to normalize monitor DN \"%s\"\n", + SLAPD_MONITOR_DN, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, - "monitor DN \"" SLAPD_MONITOR_DN "\" backend is allowed\n", - 0, 0, 0 ); + "unable to normalize monitor DN \"%s\"\n", + SLAPD_MONITOR_DN, 0, 0 ); #endif return -1; } - ber_bvecadd( &be->be_suffix, ber_dupbv( NULL, &dn ) ); - ber_bvecadd( &be->be_nsuffix, ndn ); + ber_dupbv( &bv, &dn ); + ber_bvarray_add( &be->be_suffix, &bv ); + ber_bvarray_add( &be->be_nsuffix, &ndn ); mi = ( struct monitorinfo * )ch_calloc( sizeof( struct monitorinfo ), 1 ); + if ( mi == NULL ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, + "unable to initialize monitor backend\n", 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, + "unable to initialize monitor backend\n", 0, 0, 0 ); +#endif + return -1; + } + + memset( mi, 0, sizeof( struct monitorinfo ) ); + ldap_pvt_thread_mutex_init( &mi->mi_cache_mutex ); - if ( slap_str2ad( "description", &monitor_ad_desc, &text ) ) { + be->be_private = mi; + +#ifdef INTEGRATE_CORE_SCHEMA + /* prepare for schema integration */ + for ( k = 0; mat[k].name != NULL; k++ ); +#endif /* INTEGRATE_CORE_SCHEMA */ + + for ( i = 0; mat_core[i].name != NULL; i++ ) { + AttributeDescription **ad; + const char *text; + + ad = ((AttributeDescription **)&(((char *)mi)[mat_core[i].offset])); + ad[0] = NULL; + + switch (slap_str2ad( mat_core[i].name, ad, &text ) ) { + case LDAP_SUCCESS: + break; + +#ifdef INTEGRATE_CORE_SCHEMA + case LDAP_UNDEFINED_TYPE: + mat[k] = mat_core[i]; + k++; + break; +#endif /* INTEGRATE_CORE_SCHEMA */ + + default: #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, - "monitor_back_db_init: %s\n", text )); + LDAP_LOG( OPERATION, CRIT, + "monitor_back_db_init: %s: %s\n", + mat_core[i].name, text, 0 ); #else - Debug( LDAP_DEBUG_ANY, - "monitor_subsys_backend_init: %s\n%s%s", - text, "", "" ); + Debug( LDAP_DEBUG_ANY, + "monitor_back_db_init: %s: %s\n", + mat_core[i].name, text, 0 ); #endif - return( -1 ); + return( -1 ); + } + } + + /* schema integration */ + for ( i = 0; mat[i].name; i++ ) { + LDAPAttributeType *at; + int code; + const char *err; + AttributeDescription **ad; + + at = ldap_str2attributetype( mat[i].schema, &code, + &err, LDAP_SCHEMA_ALLOW_ALL ); + if ( !at ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, "monitor_back_db_init: " + "in AttributeType '%s' %s before %s\n", + mat[i].name, ldap_scherr2str(code), err ); +#else + Debug( LDAP_DEBUG_ANY, "monitor_back_db_init: " + "in AttributeType '%s' %s before %s\n", + mat[i].name, ldap_scherr2str(code), err ); +#endif + return -1; + } + + if ( at->at_oid == NULL ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, "monitor_back_db_init: " + "null OID for attributeType '%s'\n", + mat[i].name, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, "monitor_back_db_init: " + "null OID for attributeType '%s'\n", + mat[i].name, 0, 0 ); +#endif + return -1; + } + + code = at_add(at, &err); + if ( code ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, "monitor_back_db_init: " + "%s in attributeType '%s'\n", + scherr2str(code), mat[i].name, 0 ); +#else + Debug( LDAP_DEBUG_ANY, "monitor_back_db_init: " + "%s in attributeType '%s'\n", + scherr2str(code), mat[i].name, 0 ); +#endif + return -1; + } + ldap_memfree(at); + + ad = ((AttributeDescription **)&(((char *)mi)[mat[i].offset])); + ad[0] = NULL; + if ( slap_str2ad( mat[i].name, ad, &text ) ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, + "monitor_back_db_init: %s\n", text, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, + "monitor_back_db_init: %s\n", text, 0, 0 ); +#endif + return -1; + } + + (*ad)->ad_type->sat_flags |= mat[i].flags; + } + + for ( i = 0; moc[i].name; i++ ) { + LDAPObjectClass *oc; + int code; + const char *err; + ObjectClass *Oc; + + oc = ldap_str2objectclass(moc[i].schema, &code, &err, + LDAP_SCHEMA_ALLOW_ALL ); + if ( !oc ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, + "unable to parse monitor objectclass '%s': " + "%s before %s\n" , moc[i].name, + ldap_scherr2str(code), err ); +#else + Debug( LDAP_DEBUG_ANY, + "unable to parse monitor objectclass '%s': " + "%s before %s\n" , moc[i].name, + ldap_scherr2str(code), err ); +#endif + return -1; + } + + if ( oc->oc_oid == NULL ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, + "objectclass '%s' has no OID\n" , + moc[i].name, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, + "objectclass '%s' has no OID\n" , + moc[i].name, 0, 0 ); +#endif + return -1; + } + + code = oc_add(oc, 0, &err); + if ( code ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, + "objectclass '%s': %s \"%s\"\n" , + moc[i].name, scherr2str(code), err ); +#else + Debug( LDAP_DEBUG_ANY, + "objectclass '%s': %s \"%s\"\n" , + moc[i].name, scherr2str(code), err ); +#endif + return -1; + } + + ldap_memfree(oc); + + Oc = oc_find( moc[i].name ); + if ( Oc == NULL ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, "monitor_back_db_init: " + "unable to find objectClass %s " + "(just added)\n", moc[i].name, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, "monitor_back_db_init: " + "unable to find objectClass %s " + "(just added)\n", moc[i].name, 0, 0 ); +#endif + return -1; + } + + Oc->soc_flags |= moc[i].flags; + + ((ObjectClass **)&(((char *)mi)[moc[i].offset]))[0] = Oc; + } + + return 0; +} + +int +monitor_back_db_open( + BackendDB *be +) +{ + struct monitorinfo *mi = (struct monitorinfo *)be->be_private; + struct monitorsubsys *ms; + Entry *e, *e_tmp; + struct monitorentrypriv *mp; + int i; + char buf[ BACKMONITOR_BUFSIZE ], *end_of_line; + struct berval bv; + struct tm *tms; +#ifdef HAVE_GMTIME_R + struct tm tm_buf; +#endif + static char tmbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ]; + + /* + * Start + */ +#ifndef HAVE_GMTIME_R + ldap_pvt_thread_mutex_lock( &gmtime_mutex ); +#endif +#ifdef HACK_LOCAL_TIME +# ifdef HAVE_LOCALTIME_R + tms = localtime_r( &starttime, &tm_buf ); +# else + tms = localtime( &starttime ); +# endif /* HAVE_LOCALTIME_R */ + lutil_localtime( tmbuf, sizeof(tmbuf), tms, -timezone ); +#else /* !HACK_LOCAL_TIME */ +# ifdef HAVE_GMTIME_R + tms = gmtime_r( &starttime, &tm_buf ); +# else + tms = gmtime( &starttime ); +# endif /* HAVE_GMTIME_R */ + lutil_gentime( tmbuf, sizeof(tmbuf), tms ); +#endif /* !HACK_LOCAL_TIME */ +#ifndef HAVE_GMTIME_R + ldap_pvt_thread_mutex_unlock( &gmtime_mutex ); +#endif + + mi->mi_startTime.bv_val = tmbuf; + mi->mi_startTime.bv_len = strlen( tmbuf ); + + if ( BER_BVISEMPTY( &be->be_rootdn ) ) { + BER_BVSTR( &mi->mi_creatorsName, SLAPD_ANONYMOUS ); + } else { + mi->mi_creatorsName = be->be_rootdn; } /* @@ -286,13 +731,13 @@ monitor_back_db_init( dn.bv_val = ch_calloc( sizeof( char ), dn.bv_len + 1 ); strcpy( dn.bv_val, "cn=" ); strcat( dn.bv_val, monitor_subsys[ i ].mss_name ); - rc = dnPretty2( NULL, &dn, &monitor_subsys[ i ].mss_rdn ); + rc = dnPretty( NULL, &dn, &monitor_subsys[ i ].mss_rdn, NULL ); free( dn.bv_val ); if ( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, + LDAP_LOG( OPERATION, CRIT, "monitor RDN \"%s\" is invalid\n", - dn.bv_val )); + dn.bv_val, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "monitor RDN \"%s\" is invalid\n", @@ -306,13 +751,13 @@ monitor_back_db_init( strcpy( dn.bv_val , monitor_subsys[ i ].mss_rdn.bv_val ); strcat( dn.bv_val, "," SLAPD_MONITOR_DN ); rc = dnPrettyNormal( NULL, &dn, &monitor_subsys[ i ].mss_dn, - &monitor_subsys[ i ].mss_ndn ); + &monitor_subsys[ i ].mss_ndn, NULL ); free( dn.bv_val ); if ( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, + LDAP_LOG( OPERATION, CRIT, "monitor DN \"%s\" is invalid\n", - dn.bv_val )); + dn.bv_val, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "monitor DN \"%s\" is invalid\n", @@ -323,24 +768,29 @@ monitor_back_db_init( snprintf( buf, sizeof( buf ), "dn: %s\n" - "objectClass: top\n" - "objectClass: LDAPsubEntry\n" -#ifdef SLAPD_MONITORSUBENTRY - "objectClass: monitorSubEntry\n" -#else /* !SLAPD_MONITORSUBENTRY */ - "objectClass: extensibleObject\n" -#endif /* !SLAPD_MONITORSUBENTRY */ - "cn: %s\n", + "objectClass: %s\n" + "structuralObjectClass: %s\n" + "cn: %s\n" + "creatorsName: %s\n" + "modifiersName: %s\n" + "createTimestamp: %s\n" + "modifyTimestamp: %s\n", monitor_subsys[ i ].mss_dn.bv_val, - monitor_subsys[ i ].mss_name ); + mi->mi_oc_monitorContainer->soc_cname.bv_val, + mi->mi_oc_monitorContainer->soc_cname.bv_val, + monitor_subsys[ i ].mss_name, + mi->mi_creatorsName.bv_val, + mi->mi_creatorsName.bv_val, + mi->mi_startTime.bv_val, + mi->mi_startTime.bv_val ); e = str2entry( buf ); if ( e == NULL) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, + LDAP_LOG( OPERATION, CRIT, "unable to create '%s' entry\n", - monitor_subsys[ i ].mss_dn.bv_val )); + monitor_subsys[ i ].mss_dn.bv_val, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "unable to create '%s' entry\n", @@ -358,9 +808,9 @@ monitor_back_db_init( if ( monitor_cache_add( mi, e ) ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, + LDAP_LOG( OPERATION, CRIT, "unable to add entry '%s' to cache\n", - monitor_subsys[ i ].mss_dn.bv_val )); + monitor_subsys[ i ].mss_dn.bv_val, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "unable to add entry '%s' to cache\n", @@ -376,50 +826,85 @@ monitor_back_db_init( * creates the "cn=Monitor" entry */ snprintf( buf, sizeof( buf ), - "dn: " SLAPD_MONITOR_DN "\n" - "objectClass: top\n" - "objectClass: LDAPsubEntry\n" -#ifdef SLAPD_MONITORSUBENTRY - "objectClass: monitorSubEntry\n" -#else /* !SLAPD_MONITORSUBENTRY */ - "objectClass: extensibleObject\n" -#endif /* !SLAPD_MONITORSUBENTRY */ - "cn: Monitor" ); + "dn: %s\n" + "objectClass: %s\n" + "structuralObjectClass: %s\n" + "cn: Monitor\n" + "%s: This subtree contains monitoring/managing objects.\n" + "%s: This object contains information about this server.\n" +#if 0 + "%s: createTimestamp reflects the time this server instance was created.\n" + "%s: modifyTimestamp reflects the time this server instance was last accessed.\n" +#endif + "creatorsName: %s\n" + "modifiersName: %s\n" + "createTimestamp: %s\n" + "modifyTimestamp: %s\n", + SLAPD_MONITOR_DN, + mi->mi_oc_monitorServer->soc_cname.bv_val, + mi->mi_oc_monitorServer->soc_cname.bv_val, + mi->mi_ad_description->ad_cname.bv_val, + mi->mi_ad_description->ad_cname.bv_val, +#if 0 + mi->mi_ad_description->ad_cname.bv_val, + mi->mi_ad_description->ad_cname.bv_val, +#endif + mi->mi_creatorsName.bv_val, + mi->mi_creatorsName.bv_val, + mi->mi_startTime.bv_val, + mi->mi_startTime.bv_val ); e = str2entry( buf ); if ( e == NULL) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, + LDAP_LOG( OPERATION, CRIT, "unable to create '%s' entry\n", - SLAPD_MONITOR_DN )); + SLAPD_MONITOR_DN, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, - "unable to create '%s' entry\n%s%s", - SLAPD_MONITOR_DN, "", "" ); + "unable to create '%s' entry\n", + SLAPD_MONITOR_DN, 0, 0 ); #endif return( -1 ); } - bv[1].bv_val = NULL; - bv[0].bv_val = (char *) Versionstr; + + bv.bv_val = (char *) Versionstr; end_of_line = strchr( Versionstr, '\n' ); if ( end_of_line ) { - bv[0].bv_len = end_of_line - Versionstr; + bv.bv_len = end_of_line - Versionstr; } else { - bv[0].bv_len = strlen( Versionstr ); + bv.bv_len = strlen( Versionstr ); } - if ( attr_merge( e, monitor_ad_desc, bv ) ) { + + if ( attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo, + &bv, NULL ) ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, - "unable to add description to '%s' entry\n", - SLAPD_MONITOR_DN )); + LDAP_LOG( OPERATION, CRIT, + "unable to add monitoredInfo to '%s' entry\n", + SLAPD_MONITOR_DN, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, - "unable to add description to '%s' entry\n%s%s", - SLAPD_MONITOR_DN, "", "" ); + "unable to add monitoredInfo to '%s' entry\n", + SLAPD_MONITOR_DN, 0, 0 ); #endif return( -1 ); } + if ( mi->mi_l.bv_len ) { + if ( attr_merge_normalize_one( e, mi->mi_ad_l, &mi->mi_l, NULL ) ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, CRIT, + "unable to add locality to '%s' entry\n", + SLAPD_MONITOR_DN, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, + "unable to add locality to '%s' entry\n", + SLAPD_MONITOR_DN, 0, 0 ); +#endif + return( -1 ); + } + } + mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 ); e->e_private = ( void * )mp; @@ -429,63 +914,24 @@ monitor_back_db_init( if ( monitor_cache_add( mi, e ) ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, + LDAP_LOG( OPERATION, CRIT, "unable to add entry '%s' to cache\n", - SLAPD_MONITOR_DN )); + SLAPD_MONITOR_DN, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, - "unable to add entry '%s' to cache\n%s%s", - SLAPD_MONITOR_DN, "", "" ); + "unable to add entry '%s' to cache\n", + SLAPD_MONITOR_DN, 0, 0 ); #endif return -1; } be->be_private = mi; - return 0; -} - -int -monitor_back_open( - BackendInfo *bi -) -{ - BackendDB *be; - struct monitorsubsys *ms; - struct berval dn = { sizeof(SLAPD_MONITOR_DN)-1, SLAPD_MONITOR_DN }; - struct berval ndn; - int rc; + assert( be ); /* - * adds the monitor backend + * opens the monitor backend */ - rc = dnNormalize2( NULL, &dn, &ndn ); - if( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, - "monitor DN \"" SLAPD_MONITOR_DN "\" is invalid\n" )); -#else - Debug( LDAP_DEBUG_ANY, - "monitor DN \"" SLAPD_MONITOR_DN "\" is invalid\n", - 0, 0, 0 ); -#endif - return( -1 ); - } - - be = select_backend( &ndn , 0, 0 ); - free( ndn.bv_val ); - - if ( be == NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_CRIT, - "unable to get monitor backend\n" )); -#else - Debug( LDAP_DEBUG_ANY, - "unable to get monitor backend\n", 0, 0, 0 ); -#endif - return( -1 ); - } - for ( ms = monitor_subsys; ms->mss_name != NULL; ms++ ) { if ( ms->mss_init && ( *ms->mss_init )( be ) ) { return( -1 ); @@ -507,7 +953,7 @@ monitor_back_config( /* * eventually, will hold backend specific configuration parameters */ - return 0; + return SLAP_CONF_UNKNOWN; } int @@ -519,13 +965,22 @@ monitor_back_db_config( char **argv ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "config", LDAP_DEBUG_NOTICE, - "line %d of file '%s' will be ignored\n", lineno, fname )); -#else - Debug( LDAP_DEBUG_CONFIG, - "line %d of file '%s' will be ignored\n%s", lineno, fname, "" ); -#endif + struct monitorinfo *mi = (struct monitorinfo *)be->be_private; + + /* + * eventually, will hold database specific configuration parameters + */ + if ( strcasecmp( argv[ 0 ], "l" ) == 0 ) { + if ( argc != 2 ) { + return 1; + } + + ber_str2bv( argv[ 1 ], 0, 1, &mi->mi_l ); + + } else { + return SLAP_CONF_UNKNOWN; + } + return( 0 ); }