int
monitor_back_modify( Operation *op, SlapReply *rs )
{
int rc = 0;
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
Entry *matched;
Entry *e;
Debug(LDAP_DEBUG_ARGS, "monitor_back_modify:\n", 0, 0, 0);
/* acquire and lock entry */
monitor_cache_dn2entry( op, rs, &op->o_req_ndn, &e, &matched );
if ( e == NULL ) {
rs->sr_err = LDAP_NO_SUCH_OBJECT;
if ( matched ) {
if ( !access_allowed_mask( op, matched,
slap_schema.si_ad_entry,
NULL, ACL_DISCLOSE, NULL, NULL ) )
{
/* do nothing */ ;
} else {
rs->sr_matched = matched->e_dn;
}
}
send_ldap_result( op, rs );
if ( matched != NULL ) {
rs->sr_matched = NULL;
monitor_cache_release( mi, matched );
}
return rs->sr_err;
}
if ( !acl_check_modlist( op, e, op->orm_modlist )) {
rc = LDAP_INSUFFICIENT_ACCESS;
} else {
assert( !SLAP_SHADOW( op->o_bd ) );
slap_mods_opattrs( op, &op->orm_modlist, 0 );
rc = monitor_entry_modify( op, rs, e );
}
if ( rc != LDAP_SUCCESS ) {
if ( !access_allowed_mask( op, e, slap_schema.si_ad_entry,
NULL, ACL_DISCLOSE, NULL, NULL ) )
{
rc = LDAP_NO_SUCH_OBJECT;
}
}
rs->sr_err = rc;
send_ldap_result( op, rs );
monitor_cache_release( mi, e );
return rs->sr_err;
}
/*
* If the entry exists in cache, it is returned in locked status;
* otherwise, if the parent exists, if it may generate volatile
* descendants an attempt to generate the required entry is
* performed and, if successful, the entry is returned
*/
int
monitor_cache_dn2entry(
Operation *op,
SlapReply *rs,
struct berval *ndn,
Entry **ep,
Entry **matched )
{
monitor_info_t *mi = (monitor_info_t *)op->o_bd->be_private;
int rc;
struct berval p_ndn = BER_BVNULL;
Entry *e_parent;
monitor_entry_t *mp;
assert( mi != NULL );
assert( ndn != NULL );
assert( ep != NULL );
assert( matched != NULL );
*matched = NULL;
if ( !dnIsSuffix( ndn, &op->o_bd->be_nsuffix[ 0 ] ) ) {
return( -1 );
}
rc = monitor_cache_get( mi, ndn, ep );
if ( !rc && *ep != NULL ) {
return( 0 );
}
/* try with parent/ancestors */
if ( BER_BVISNULL( ndn ) ) {
BER_BVSTR( &p_ndn, "" );
} else {
dnParent( ndn, &p_ndn );
}
rc = monitor_cache_dn2entry( op, rs, &p_ndn, &e_parent, matched );
if ( rc || e_parent == NULL ) {
return( -1 );
}
mp = ( monitor_entry_t * )e_parent->e_private;
rc = -1;
if ( mp->mp_flags & MONITOR_F_VOLATILE_CH ) {
/* parent entry generates volatile children */
rc = monitor_entry_create( op, rs, ndn, e_parent, ep );
}
if ( !rc ) {
monitor_cache_lock( *ep );
monitor_cache_release( mi, e_parent );
} else {
*matched = e_parent;
}
return( rc );
}
/*
* opens log subentry
*/
int
monitor_subsys_log_open(
BackendDB *be,
monitor_subsys_t *ms )
{
BerVarray bva = NULL;
if ( loglevel2bvarray( ldap_syslog, &bva ) == 0 && bva != NULL ) {
monitor_info_t *mi;
Entry *e;
mi = ( monitor_info_t * )be->be_private;
if ( monitor_cache_get( mi, &ms->mss_ndn, &e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_log_init: "
"unable to get entry \"%s\"\n",
ms->mss_ndn.bv_val, 0, 0 );
ber_bvarray_free( bva );
return( -1 );
}
attr_merge_normalize( e, mi->mi_ad_managedInfo, bva, NULL );
ber_bvarray_free( bva );
monitor_cache_release( mi, e );
}
return( 0 );
}
int
monitor_back_compare( Operation *op, SlapReply *rs )
{
monitor_info_t *mi = ( monitor_info_t * ) op->o_bd->be_private;
Entry *e, *matched = NULL;
int rc;
/* get entry with reader lock */
monitor_cache_dn2entry( op, rs, &op->o_req_ndn, &e, &matched );
if ( e == NULL ) {
rs->sr_err = LDAP_NO_SUCH_OBJECT;
if ( matched ) {
if ( !access_allowed_mask( op, matched,
slap_schema.si_ad_entry,
NULL, ACL_DISCLOSE, NULL, NULL ) )
{
/* do nothing */ ;
} else {
rs->sr_matched = matched->e_dn;
}
}
send_ldap_result( op, rs );
if ( matched ) {
monitor_cache_release( mi, matched );
rs->sr_matched = NULL;
}
return rs->sr_err;
}
monitor_entry_update( op, rs, e );
rs->sr_err = slap_compare_entry( op, e, op->orc_ava );
rc = rs->sr_err;
switch ( rc ) {
case LDAP_COMPARE_FALSE:
case LDAP_COMPARE_TRUE:
rc = LDAP_SUCCESS;
break;
}
send_ldap_result( op, rs );
rs->sr_err = rc;
monitor_cache_release( mi, e );
return rs->sr_err;
}
int monitor_back_release(
Operation *op,
Entry *e,
int rw )
{
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
return monitor_cache_release( mi, e );
}
int
monitor_back_modify(
Backend *be,
Connection *conn,
Operation *op,
struct berval *dn,
struct berval *ndn,
Modifications *modlist
)
{
int rc = 0;
struct monitorinfo *mi = (struct monitorinfo *) be->be_private;
Entry *matched;
Entry *e;
#ifdef NEW_LOGGING
LDAP_LOG( BACK_MON, ENTRY,
"monitor_back_modify: enter\n", 0, 0, 0 );
#else
Debug(LDAP_DEBUG_ARGS, "monitor_back_modify:\n", 0, 0, 0);
#endif
/* acquire and lock entry */
monitor_cache_dn2entry( mi, ndn, &e, &matched );
if ( e == NULL ) {
send_ldap_result( conn, op, LDAP_NO_SUCH_OBJECT,
matched ? matched->e_dn : NULL,
NULL, NULL, NULL );
if ( matched != NULL ) {
monitor_cache_release( mi, matched );
return( 0 );
}
}
if ( !acl_check_modlist( be, conn, op, e, modlist )) {
rc = LDAP_INSUFFICIENT_ACCESS;
} else {
rc = monitor_entry_modify( mi, e, modlist );
}
send_ldap_result( conn, op, rc, NULL, NULL, NULL, NULL );
monitor_cache_release( mi, e );
return( 0 );
}
/*
* * initializes log subentry
* */
int
monitor_subsys_thread_init(
BackendDB *be
)
{
struct monitorinfo *mi;
Entry *e;
struct berval bv[2];
static char buf[1024];
mi = ( struct monitorinfo * )be->be_private;
if ( monitor_cache_get( mi,
&monitor_subsys[SLAPD_MONITOR_THREAD].mss_ndn, &e ) )
{
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_thread_init: unable to get entry '%s'\n",
monitor_subsys[SLAPD_MONITOR_THREAD].mss_ndn.bv_val, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_thread_init: unable to get entry '%s'\n",
monitor_subsys[SLAPD_MONITOR_THREAD].mss_ndn.bv_val,
0, 0 );
#endif
return( -1 );
}
/* initialize the thread number */
snprintf( buf, sizeof( buf ), "max=%d", connection_pool_max );
bv[1].bv_val = NULL;
bv[0].bv_val = buf;
bv[0].bv_len = strlen( bv[0].bv_val );
attr_merge( e, monitor_ad_desc, bv );
monitor_cache_release( mi, e );
return( 0 );
}
int
monitor_subsys_conn_init(
BackendDB *be,
monitor_subsys_t *ms )
{
monitor_info_t *mi;
Entry *e, **ep, *e_conn = NULL;
monitor_entry_t *mp;
char buf[ BACKMONITOR_BUFSIZE ];
struct berval bv;
assert( be != NULL );
ms->mss_update = monitor_subsys_conn_update;
ms->mss_create = monitor_subsys_conn_create;
mi = ( monitor_info_t * )be->be_private;
if ( monitor_cache_get( mi, &ms->mss_ndn, &e_conn ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_conn_init: "
"unable to get entry \"%s\"\n",
ms->mss_ndn.bv_val );
return( -1 );
}
mp = ( monitor_entry_t * )e_conn->e_private;
mp->mp_children = NULL;
ep = &mp->mp_children;
int rc = -1;
/*
* Max file descriptors
*/
BER_BVSTR( &bv, "cn=Max File Descriptors" );
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv,
mi->mi_oc_monitorCounterObject, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_conn_init: "
"unable to create entry \"%s,%s\"\n",
bv.bv_val, ms->mss_ndn.bv_val );
goto bailout;
}
if ( dtblsize ) {
bv.bv_val = buf;
bv.bv_len = snprintf( buf, sizeof( buf ), "%d", dtblsize );
} else {
BER_BVSTR( &bv, "0" );
}
attr_merge_one( e, mi->mi_ad_monitorCounter, &bv, NULL );
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
return -1;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
mp->mp_flags &= ~MONITOR_F_VOLATILE_CH;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_conn_init: "
"unable to add entry \"cn=Total,%s\"\n",
ms->mss_ndn.bv_val );
goto bailout;
}
*ep = e;
ep = &mp->mp_next;
/*
* Total conns
*/
BER_BVSTR( &bv, "cn=Total" );
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv,
mi->mi_oc_monitorCounterObject, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_conn_init: "
"unable to create entry \"cn=Total,%s\"\n",
ms->mss_ndn.bv_val );
goto bailout;
}
BER_BVSTR( &bv, "-1" );
attr_merge_one( e, mi->mi_ad_monitorCounter, &bv, NULL );
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
goto bailout;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
mp->mp_flags &= ~MONITOR_F_VOLATILE_CH;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_conn_init: "
"unable to add entry \"cn=Total,%s\"\n",
ms->mss_ndn.bv_val );
goto bailout;
}
*ep = e;
ep = &mp->mp_next;
/*
* Current conns
*/
BER_BVSTR( &bv, "cn=Current" );
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv,
mi->mi_oc_monitorCounterObject, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_conn_init: "
"unable to create entry \"cn=Current,%s\"\n",
ms->mss_ndn.bv_val );
goto bailout;
}
BER_BVSTR( &bv, "0" );
attr_merge_one( e, mi->mi_ad_monitorCounter, &bv, NULL );
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
goto bailout;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
mp->mp_flags &= ~MONITOR_F_VOLATILE_CH;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_conn_init: "
"unable to add entry \"cn=Current,%s\"\n",
ms->mss_ndn.bv_val );
goto bailout;
}
*ep = e;
ep = &mp->mp_next;
rc = 0;
bailout:
monitor_cache_release( mi, e_conn );
return rc;
}
int
monitor_subsys_listener_init(
BackendDB *be
)
{
struct monitorinfo *mi;
Entry *e, *e_listener, *e_tmp;
int i;
struct monitorentrypriv *mp;
Listener **l;
assert( be != NULL );
assert( monitor_ad_desc != NULL );
mi = ( struct monitorinfo * )be->be_private;
if ( monitor_cache_get( mi,
&monitor_subsys[SLAPD_MONITOR_LISTENER].mss_ndn,
&e_listener ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_listener_init: "
"unable to get entry '%s'\n",
monitor_subsys[SLAPD_MONITOR_LISTENER].mss_ndn.bv_val, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to get entry '%s'\n%s%s",
monitor_subsys[SLAPD_MONITOR_LISTENER].mss_ndn.bv_val,
"", "" );
#endif
return( -1 );
}
if ( ( l = slapd_get_listeners() ) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_listener_init: "
"unable to get listeners\n", 0, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to get listeners\n", 0, 0, 0 );
#endif
return( -1 );
}
e_tmp = NULL;
for ( i = 0; l[i]; i++ );
for ( ; i--; ) {
char buf[1024];
snprintf( buf, sizeof( buf ),
"dn: cn=Listener %d,%s\n"
SLAPD_MONITOR_OBJECTCLASSES
"cn: Listener %d\n"
"description: %s\n"
"labeledURI: %s",
i,
monitor_subsys[SLAPD_MONITOR_LISTENER].mss_dn.bv_val,
i,
l[i]->sl_name.bv_val,
l[i]->sl_url.bv_val );
e = str2entry( buf );
if ( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_listener_init: "
"unable to create entry 'cn=Listener, %d,%s'\n",
i, monitor_subsys[SLAPD_MONITOR_LISTENER].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to create entry 'cn=Listener %d,%s'\n%s",
i,
monitor_subsys[SLAPD_MONITOR_LISTENER].mss_ndn.bv_val,
"" );
#endif
return( -1 );
}
#ifdef HAVE_TLS
if ( l[i]->sl_is_tls ) {
struct berval bv[2];
bv[1].bv_val = NULL;
bv[0].bv_val = "TLS";
bv[0].bv_len = sizeof("TLS")-1;
attr_merge( e, monitor_ad_desc, bv );
}
#endif /* HAVE_TLS */
#ifdef LDAP_CONNECTIONLESS
if ( l[i]->sl_is_udp ) {
struct berval bv[2];
bv[1].bv_val = NULL;
bv[0].bv_val = "UDP";
bv[0].bv_len = sizeof("UDP")-1;
attr_merge( e, monitor_ad_desc, bv );
}
#endif /* HAVE_TLS */
mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
e->e_private = ( void * )mp;
mp->mp_next = e_tmp;
mp->mp_children = NULL;
mp->mp_info = &monitor_subsys[SLAPD_MONITOR_LISTENER];
mp->mp_flags = monitor_subsys[SLAPD_MONITOR_LISTENER].mss_flags
| MONITOR_F_SUB;
if ( monitor_cache_add( mi, e ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_listener_init: "
"unable to add entry 'cn=Listener %d,%s'\n",
i, monitor_subsys[SLAPD_MONITOR_LISTENER].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to add entry 'cn=Listener %d,%s'\n",
i,
monitor_subsys[SLAPD_MONITOR_LISTENER].mss_ndn.bv_val,
0 );
#endif
return( -1 );
}
e_tmp = e;
}
mp = ( struct monitorentrypriv * )e_listener->e_private;
mp->mp_children = e_tmp;
monitor_cache_release( mi, e_listener );
return( 0 );
}
int
monitor_subsys_listener_init(
BackendDB *be,
monitor_subsys_t *ms
)
{
monitor_info_t *mi;
Entry *e_listener, **ep;
int i;
monitor_entry_t *mp;
Listener **l;
assert( be != NULL );
if ( ( l = slapd_get_listeners() ) == NULL ) {
if ( slapMode & SLAP_TOOL_MODE ) {
return 0;
}
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to get listeners\n", 0, 0, 0 );
return( -1 );
}
mi = ( monitor_info_t * )be->be_private;
if ( monitor_cache_get( mi, &ms->mss_ndn, &e_listener ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to get entry \"%s\"\n",
ms->mss_ndn.bv_val, 0, 0 );
return( -1 );
}
mp = ( monitor_entry_t * )e_listener->e_private;
mp->mp_children = NULL;
ep = &mp->mp_children;
for ( i = 0; l[ i ]; i++ ) {
char buf[ BACKMONITOR_BUFSIZE ];
Entry *e;
struct berval bv;
bv.bv_len = snprintf( buf, sizeof( buf ),
"cn=Listener %d", i );
bv.bv_val = buf;
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv,
mi->mi_oc_monitoredObject, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to create entry \"cn=Listener %d,%s\"\n",
i, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
attr_merge_normalize_one( e, mi->mi_ad_monitorConnectionLocalAddress,
&l[ i ]->sl_name, NULL );
attr_merge_normalize_one( e, slap_schema.si_ad_labeledURI,
&l[ i ]->sl_url, NULL );
#ifdef HAVE_TLS
if ( l[ i ]->sl_is_tls ) {
struct berval bv;
BER_BVSTR( &bv, "TLS" );
attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo,
&bv, NULL );
}
#endif /* HAVE_TLS */
#ifdef LDAP_CONNECTIONLESS
if ( l[ i ]->sl_is_udp ) {
struct berval bv;
BER_BVSTR( &bv, "UDP" );
attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo,
&bv, NULL );
}
#endif /* HAVE_TLS */
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
return -1;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags
| MONITOR_F_SUB;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_listener_init: "
"unable to add entry \"cn=Listener %d,%s\"\n",
i, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
*ep = e;
ep = &mp->mp_next;
}
monitor_cache_release( mi, e_listener );
return( 0 );
}
int
monitor_subsys_rww_init(
BackendDB *be,
monitor_subsys_t *ms )
{
monitor_info_t *mi;
Entry **ep, *e_conn;
monitor_entry_t *mp;
int i;
assert( be != NULL );
ms->mss_destroy = monitor_subsys_rww_destroy;
ms->mss_update = monitor_subsys_rww_update;
mi = ( monitor_info_t * )be->be_private;
if ( monitor_cache_get( mi, &ms->mss_ndn, &e_conn ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_rww_init: "
"unable to get entry \"%s\"\n",
ms->mss_ndn.bv_val, 0, 0 );
return( -1 );
}
mp = ( monitor_entry_t * )e_conn->e_private;
mp->mp_children = NULL;
ep = &mp->mp_children;
for ( i = 0; i < MONITOR_RWW_LAST; i++ ) {
struct berval nrdn, bv;
Entry *e;
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &monitor_rww[i].rdn,
mi->mi_oc_monitorCounterObject, mi, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_rww_init: "
"unable to create entry \"cn=Read,%s\"\n",
ms->mss_ndn.bv_val, 0, 0 );
return( -1 );
}
/* steal normalized RDN */
dnRdn( &e->e_nname, &nrdn );
ber_dupbv( &monitor_rww[ i ].nrdn, &nrdn );
BER_BVSTR( &bv, "0" );
attr_merge_one( e, mi->mi_ad_monitorCounter, &bv, NULL );
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
return -1;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_rww_init: "
"unable to add entry \"%s,%s\"\n",
monitor_rww[ i ].rdn.bv_val,
ms->mss_ndn.bv_val, 0 );
return( -1 );
}
*ep = e;
ep = &mp->mp_next;
}
monitor_cache_release( mi, e_conn );
return( 0 );
}
static int
monitor_send_children(
Operation *op,
SlapReply *rs,
Entry *e_parent,
int sub )
{
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
Entry *e,
*e_tmp,
*e_ch = NULL,
*e_nonvolatile = NULL;
monitor_entry_t *mp;
int rc,
nonvolatile = 0;
mp = ( monitor_entry_t * )e_parent->e_private;
e_nonvolatile = e = mp->mp_children;
if ( MONITOR_HAS_VOLATILE_CH( mp ) ) {
monitor_entry_create( op, rs, NULL, e_parent, &e_ch );
}
monitor_cache_release( mi, e_parent );
/* no volatile entries? */
if ( e_ch == NULL ) {
/* no persistent entries? return */
if ( e == NULL ) {
return LDAP_SUCCESS;
}
/* volatile entries */
} else {
/* if no persistent, return only volatile */
if ( e == NULL ) {
e = e_ch;
/* else append persistent to volatile */
} else {
e_tmp = e_ch;
do {
mp = ( monitor_entry_t * )e_tmp->e_private;
e_tmp = mp->mp_next;
if ( e_tmp == NULL ) {
mp->mp_next = e;
break;
}
} while ( e_tmp );
e = e_ch;
}
}
/* return entries */
for ( monitor_cache_lock( e ); e != NULL; ) {
monitor_entry_update( op, rs, e );
if ( op->o_abandon ) {
/* FIXME: may leak generated children */
if ( nonvolatile == 0 ) {
for ( e_tmp = e; e_tmp != NULL; ) {
mp = ( monitor_entry_t * )e_tmp->e_private;
e = e_tmp;
e_tmp = mp->mp_next;
monitor_cache_release( mi, e );
if ( e_tmp == e_nonvolatile ) {
break;
}
}
} else {
monitor_cache_release( mi, e );
}
return SLAPD_ABANDON;
}
rc = test_filter( op, e, op->oq_search.rs_filter );
if ( rc == LDAP_COMPARE_TRUE ) {
rs->sr_entry = e;
rs->sr_flags = 0;
rc = send_search_entry( op, rs );
rs->sr_entry = NULL;
}
mp = ( monitor_entry_t * )e->e_private;
e_tmp = mp->mp_next;
if ( sub ) {
rc = monitor_send_children( op, rs, e, sub );
if ( rc ) {
/* FIXME: may leak generated children */
if ( nonvolatile == 0 ) {
for ( ; e_tmp != NULL; ) {
mp = ( monitor_entry_t * )e_tmp->e_private;
e = e_tmp;
e_tmp = mp->mp_next;
monitor_cache_release( mi, e );
if ( e_tmp == e_nonvolatile ) {
break;
}
}
}
return( rc );
}
}
if ( e_tmp != NULL ) {
monitor_cache_lock( e_tmp );
}
if ( !sub ) {
/* otherwise the recursive call already released */
monitor_cache_release( mi, e );
}
e = e_tmp;
if ( e == e_nonvolatile ) {
nonvolatile = 1;
}
}
return LDAP_SUCCESS;
}
int
monitor_back_search( Operation *op, SlapReply *rs )
{
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
int rc = LDAP_SUCCESS;
Entry *e = NULL, *matched = NULL;
slap_mask_t mask;
Debug( LDAP_DEBUG_TRACE, "=> monitor_back_search\n", 0, 0, 0 );
/* get entry with reader lock */
monitor_cache_dn2entry( op, rs, &op->o_req_ndn, &e, &matched );
if ( e == NULL ) {
rs->sr_err = LDAP_NO_SUCH_OBJECT;
if ( matched ) {
if ( !access_allowed_mask( op, matched,
slap_schema.si_ad_entry,
NULL, ACL_DISCLOSE, NULL, NULL ) )
{
/* do nothing */ ;
} else {
rs->sr_matched = matched->e_dn;
}
}
send_ldap_result( op, rs );
if ( matched ) {
monitor_cache_release( mi, matched );
rs->sr_matched = NULL;
}
return rs->sr_err;
}
/* NOTE: __NEW__ "search" access is required
* on searchBase object */
if ( !access_allowed_mask( op, e, slap_schema.si_ad_entry,
NULL, ACL_SEARCH, NULL, &mask ) )
{
monitor_cache_release( mi, e );
if ( !ACL_GRANT( mask, ACL_DISCLOSE ) ) {
rs->sr_err = LDAP_NO_SUCH_OBJECT;
} else {
rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
}
send_ldap_result( op, rs );
return rs->sr_err;
}
rs->sr_attrs = op->oq_search.rs_attrs;
switch ( op->oq_search.rs_scope ) {
case LDAP_SCOPE_BASE:
monitor_entry_update( op, rs, e );
rc = test_filter( op, e, op->oq_search.rs_filter );
if ( rc == LDAP_COMPARE_TRUE ) {
rs->sr_entry = e;
rs->sr_flags = 0;
send_search_entry( op, rs );
rs->sr_entry = NULL;
}
rc = LDAP_SUCCESS;
monitor_cache_release( mi, e );
break;
case LDAP_SCOPE_ONELEVEL:
case LDAP_SCOPE_SUBORDINATE:
rc = monitor_send_children( op, rs, e,
op->oq_search.rs_scope == LDAP_SCOPE_SUBORDINATE );
break;
case LDAP_SCOPE_SUBTREE:
monitor_entry_update( op, rs, e );
rc = test_filter( op, e, op->oq_search.rs_filter );
if ( rc == LDAP_COMPARE_TRUE ) {
rs->sr_entry = e;
rs->sr_flags = 0;
send_search_entry( op, rs );
rs->sr_entry = NULL;
}
rc = monitor_send_children( op, rs, e, 1 );
break;
default:
rc = LDAP_UNWILLING_TO_PERFORM;
monitor_cache_release( mi, e );
}
rs->sr_attrs = NULL;
rs->sr_err = rc;
if ( rs->sr_err != SLAPD_ABANDON ) {
send_ldap_result( op, rs );
}
return rs->sr_err;
}
/*
* gets an entry from the cache based on the normalized dn
* with mutex locked
*/
int
monitor_cache_remove(
monitor_info_t *mi,
struct berval *ndn,
Entry **ep )
{
monitor_cache_t tmp_mc, *mc;
struct berval pndn;
assert( mi != NULL );
assert( ndn != NULL );
assert( ep != NULL );
*ep = NULL;
dnParent( ndn, &pndn );
retry:;
ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex );
tmp_mc.mc_ndn = *ndn;
mc = ( monitor_cache_t * )avl_find( mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp );
if ( mc != NULL ) {
monitor_cache_t *pmc;
if ( monitor_cache_trylock( mc->mc_e ) ) {
ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex );
goto retry;
}
tmp_mc.mc_ndn = pndn;
pmc = ( monitor_cache_t * )avl_find( mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp );
if ( pmc != NULL ) {
monitor_entry_t *mp = (monitor_entry_t *)mc->mc_e->e_private,
*pmp = (monitor_entry_t *)pmc->mc_e->e_private;
Entry **entryp;
if ( monitor_cache_trylock( pmc->mc_e ) ) {
monitor_cache_release( mi, mc->mc_e );
ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex );
goto retry;
}
for ( entryp = &pmp->mp_children; *entryp != NULL; ) {
monitor_entry_t *next = (monitor_entry_t *)(*entryp)->e_private;
if ( next == mp ) {
*entryp = next->mp_next;
entryp = NULL;
break;
}
entryp = &next->mp_next;
}
if ( entryp != NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_cache_remove(\"%s\"): "
"not in parent's list\n",
ndn->bv_val, 0, 0 );
}
/* either succeeded, and the entry is no longer
* in its parent's list, or failed, and the
* entry is neither mucked with nor returned */
monitor_cache_release( mi, pmc->mc_e );
if ( entryp == NULL ) {
monitor_cache_t *tmpmc;
tmp_mc.mc_ndn = *ndn;
tmpmc = avl_delete( &mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp );
assert( tmpmc == mc );
*ep = mc->mc_e;
ch_free( mc );
mc = NULL;
/* NOTE: we destroy the mutex, but otherwise
* leave the private data around; specifically,
* callbacks need be freed by someone else */
ldap_pvt_thread_mutex_destroy( &mp->mp_mutex );
mp->mp_next = NULL;
mp->mp_children = NULL;
}
}
if ( mc ) {
monitor_cache_release( mi, mc->mc_e );
}
}
ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex );
return ( *ep == NULL ? -1 : 0 );
}
int
monitor_subsys_time_init(
BackendDB *be,
monitor_subsys_t *ms )
{
monitor_info_t *mi;
Entry *e, **ep, *e_time;
monitor_entry_t *mp;
struct berval bv, value;
assert( be != NULL );
ms->mss_update = monitor_subsys_time_update;
mi = ( monitor_info_t * )be->be_private;
if ( monitor_cache_get( mi,
&ms->mss_ndn, &e_time ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_time_init: "
"unable to get entry \"%s\"\n",
ms->mss_ndn.bv_val, 0, 0 );
return( -1 );
}
mp = ( monitor_entry_t * )e_time->e_private;
mp->mp_children = NULL;
ep = &mp->mp_children;
BER_BVSTR( &bv, "cn=Start" );
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv,
mi->mi_oc_monitoredObject, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_time_init: "
"unable to create entry \"%s,%s\"\n",
bv.bv_val, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
attr_merge_normalize_one( e, mi->mi_ad_monitorTimestamp,
&mi->mi_startTime, NULL );
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
return -1;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_time_init: "
"unable to add entry \"%s,%s\"\n",
bv.bv_val, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
*ep = e;
ep = &mp->mp_next;
/*
* Current
*/
BER_BVSTR( &bv, "cn=Current" );
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv,
mi->mi_oc_monitoredObject, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_time_init: "
"unable to create entry \"%s,%s\"\n",
bv.bv_val, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
attr_merge_normalize_one( e, mi->mi_ad_monitorTimestamp,
&mi->mi_startTime, NULL );
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
return -1;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_time_init: "
"unable to add entry \"%s,%s\"\n",
bv.bv_val, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
*ep = e;
ep = &mp->mp_next;
/*
* Uptime
*/
BER_BVSTR( &bv, "cn=Uptime" );
e = monitor_entry_stub( &ms->mss_dn, &ms->mss_ndn, &bv,
mi->mi_oc_monitoredObject, NULL, NULL );
if ( e == NULL ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_time_init: "
"unable to create entry \"%s,%s\"\n",
bv.bv_val, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
BER_BVSTR( &value, "0" );
attr_merge_normalize_one( e, mi->mi_ad_monitoredInfo,
&value, NULL );
mp = monitor_entrypriv_create();
if ( mp == NULL ) {
return -1;
}
e->e_private = ( void * )mp;
mp->mp_info = ms;
mp->mp_flags = ms->mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_time_init: "
"unable to add entry \"%s,%s\"\n",
bv.bv_val, ms->mss_ndn.bv_val, 0 );
return( -1 );
}
*ep = e;
ep = &mp->mp_next;
monitor_cache_release( mi, e_time );
return( 0 );
}
static int
monitor_send_children(
Operation *op,
SlapReply *rs,
Entry *e_nonvolatile,
Entry *e_ch,
int sub )
{
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
Entry *e,
*e_tmp;
monitor_entry_t *mp;
int rc,
nonvolatile = 0;
e = e_nonvolatile;
/* no volatile entries? */
if ( e_ch == NULL ) {
/* no persistent entries? return */
if ( e == NULL ) {
return LDAP_SUCCESS;
}
/* volatile entries */
} else {
/* if no persistent, return only volatile */
if ( e == NULL ) {
e = e_ch;
/* else append persistent to volatile */
} else {
e_tmp = e_ch;
do {
mp = ( monitor_entry_t * )e_tmp->e_private;
e_tmp = mp->mp_next;
if ( e_tmp == NULL ) {
mp->mp_next = e;
break;
}
} while ( e_tmp );
e = e_ch;
}
}
/* return entries */
for ( ; e != NULL; e = e_tmp ) {
Entry *sub_nv = NULL, *sub_ch = NULL;
monitor_cache_lock( e );
monitor_entry_update( op, rs, e );
if ( e == e_nonvolatile )
nonvolatile = 1;
mp = ( monitor_entry_t * )e->e_private;
e_tmp = mp->mp_next;
if ( op->o_abandon ) {
monitor_cache_release( mi, e );
rc = SLAPD_ABANDON;
goto freeout;
}
if ( sub )
monitor_find_children( op, rs, e, &sub_nv, &sub_ch );
rc = test_filter( op, e, op->oq_search.rs_filter );
if ( rc == LDAP_COMPARE_TRUE ) {
rs->sr_entry = e;
rs->sr_flags = REP_ENTRY_MUSTRELEASE;
rc = send_search_entry( op, rs );
if ( rc ) {
for ( e = sub_ch; e != NULL; e = sub_nv ) {
mp = ( monitor_entry_t * )e->e_private;
sub_nv = mp->mp_next;
monitor_cache_lock( e );
monitor_cache_release( mi, e );
}
goto freeout;
}
} else {
monitor_cache_release( mi, e );
}
if ( sub ) {
rc = monitor_send_children( op, rs, sub_nv, sub_ch, sub );
if ( rc ) {
freeout:
if ( nonvolatile == 0 ) {
for ( ; e_tmp != NULL; ) {
mp = ( monitor_entry_t * )e_tmp->e_private;
e = e_tmp;
e_tmp = mp->mp_next;
monitor_cache_lock( e );
monitor_cache_release( mi, e );
if ( e_tmp == e_nonvolatile ) {
break;
}
}
}
return( rc );
}
}
}
return LDAP_SUCCESS;
}
int
monitor_subsys_database_init(
BackendDB *be
)
{
struct monitorinfo *mi;
Entry *e, *e_database, *e_tmp;
int i;
struct monitorentrypriv *mp;
AttributeDescription *ad_nc = slap_schema.si_ad_namingContexts;
AttributeDescription *ad_mc = slap_schema.si_ad_monitorContext;
AttributeDescription *ad_seeAlso = NULL;
const char *text = NULL;
assert( be != NULL );
assert( monitor_ad_desc != NULL );
mi = ( struct monitorinfo * )be->be_private;
if ( monitor_cache_get( mi,
&monitor_subsys[SLAPD_MONITOR_DATABASE].mss_ndn,
&e_database ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_database_init: "
"unable to get entry '%s'\n",
monitor_subsys[SLAPD_MONITOR_DATABASE].mss_ndn.bv_val, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_database_init: "
"unable to get entry '%s'\n%s%s",
monitor_subsys[SLAPD_MONITOR_DATABASE].mss_ndn.bv_val,
"", "" );
#endif
return( -1 );
}
if ( slap_str2ad( "seeAlso", &ad_seeAlso, &text ) != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_database_init: "
"unable to find 'seeAlso' attribute description\n",
0, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_database_init: "
"unable to find 'seeAlso' attribute description\n",
0, 0, 0 );
#endif
return( -1 );
}
e_tmp = NULL;
for ( i = nBackendDB; i--; ) {
char buf[1024];
int j;
be = &backendDB[i];
/* Subordinates are not exposed as their own naming context */
if ( SLAP_GLUE_SUBORDINATE( be ) ) {
continue;
}
snprintf( buf, sizeof( buf ),
"dn: cn=Database %d,%s\n"
SLAPD_MONITOR_OBJECTCLASSES
"cn: Database %d\n"
"description: %s",
i,
monitor_subsys[SLAPD_MONITOR_DATABASE].mss_dn.bv_val,
i,
be->bd_info->bi_type );
e = str2entry( buf );
if ( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_database_init: "
"unable to create entry 'cn=Database %d,%s'\n",
i, monitor_subsys[SLAPD_MONITOR_DATABASE].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_database_init: "
"unable to create entry 'cn=Database %d,%s'\n%s",
i,
monitor_subsys[SLAPD_MONITOR_DATABASE].mss_ndn.bv_val,
"" );
#endif
return( -1 );
}
if ( be->be_flags & SLAP_BFLAG_MONITOR ) {
attr_merge( e, ad_mc, be->be_suffix );
attr_merge( e_database, ad_mc, be->be_suffix );
} else {
attr_merge( e, ad_nc, be->be_suffix );
attr_merge( e_database, ad_nc, be->be_suffix );
}
for ( j = nBackendInfo; j--; ) {
if ( backendInfo[ j ].bi_type == be->bd_info->bi_type ) {
struct berval bv;
snprintf( buf, sizeof( buf ),
"cn=Backend %d,%s",
j, monitor_subsys[SLAPD_MONITOR_BACKEND].mss_dn.bv_val );
bv.bv_val = buf;
bv.bv_len = strlen( buf );
attr_merge_one( e, ad_seeAlso, &bv );
break;
}
}
/* we must find it! */
assert( j >= 0 );
mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
e->e_private = ( void * )mp;
mp->mp_next = e_tmp;
mp->mp_children = NULL;
mp->mp_info = &monitor_subsys[SLAPD_MONITOR_DATABASE];
mp->mp_flags = monitor_subsys[SLAPD_MONITOR_DATABASE].mss_flags
| MONITOR_F_SUB;
if ( monitor_cache_add( mi, e ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_database_init: "
"unable to add entry 'cn=Database %d,%s'\n",
i, monitor_subsys[SLAPD_MONITOR_DATABASE].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_database_init: "
"unable to add entry 'cn=Database %d,%s'\n",
i,
monitor_subsys[SLAPD_MONITOR_DATABASE].mss_ndn.bv_val,
0 );
#endif
return( -1 );
}
#if defined(LDAP_SLAPI)
monitor_back_add_plugin( be, e );
#endif /* defined(LDAP_SLAPI) */
e_tmp = e;
}
mp = ( struct monitorentrypriv * )e_database->e_private;
mp->mp_children = e_tmp;
monitor_cache_release( mi, e_database );
return( 0 );
}
int
monitor_subsys_ops_init(
BackendDB *be
)
{
struct monitorinfo *mi;
Entry *e, *e_tmp, *e_op, *e_children;
struct monitorentrypriv *mp;
char buf[1024];
struct berval bv[2];
int i;
assert( be != NULL );
mi = ( struct monitorinfo * )be->be_private;
if ( monitor_cache_get( mi,
&monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn, &e_op ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to get entry '%s'\n",
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to get entry '%s'\n%s%s",
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val,
"", "" );
#endif
return( -1 );
}
e_tmp = NULL;
/*
* Initiated ops
*/
snprintf( buf, sizeof( buf ),
"dn: cn=%s,%s\n"
SLAPD_MONITOR_OBJECTCLASSES
"cn: %s\n",
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_dn.bv_val,
bv_initiated.bv_val );
e = str2entry( buf );
if ( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,%s'\n",
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,%s'\n%s",
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val,
"" );
#endif
return( -1 );
}
bv[1].bv_val = NULL;
bv[0].bv_val = "0";
bv[0].bv_len = 1;
attr_merge( e, monitor_ad_desc, bv );
mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
e->e_private = ( void * )mp;
mp->mp_next = e_tmp;
mp->mp_children = NULL;
mp->mp_info = &monitor_subsys[SLAPD_MONITOR_OPS];
mp->mp_flags = monitor_subsys[SLAPD_MONITOR_OPS].mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,%s'\n",
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,%s'\n%s",
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val,
"" );
#endif
return( -1 );
}
e_tmp = e;
e_children = NULL;
for ( i = SLAP_OP_LAST; i-- > 0; ) {
/*
* Initiated ops
*/
snprintf( buf, sizeof( buf ),
"dn: cn=%s,cn=%s,%s\n"
SLAPD_MONITOR_OBJECTCLASSES
"cn: %s\n",
bv_op[ i ].bv_val,
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_dn.bv_val,
bv_op[ i ].bv_val );
e = str2entry( buf );
if ( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#endif
return( -1 );
}
bv[1].bv_val = NULL;
bv[0].bv_val = "0";
bv[0].bv_len = 1;
attr_merge( e, monitor_ad_desc, bv );
mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
e->e_private = ( void * )mp;
mp->mp_next = e_children;
mp->mp_children = NULL;
mp->mp_info = &monitor_subsys[SLAPD_MONITOR_OPS];
mp->mp_flags = monitor_subsys[SLAPD_MONITOR_OPS].mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_initiated.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#endif
return( -1 );
}
e_children = e;
}
mp = ( struct monitorentrypriv * )e_tmp->e_private;
mp->mp_children = e_children;
/*
* Completed ops
*/
snprintf( buf, sizeof( buf ),
"dn: cn=%s,%s\n"
SLAPD_MONITOR_OBJECTCLASSES
"cn: %s\n",
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_dn.bv_val,
bv_completed.bv_val );
e = str2entry( buf );
if ( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,%s'\n",
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,%s'\n%s",
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val,
"" );
#endif
return( -1 );
}
bv[0].bv_val = "0";
bv[0].bv_len = 1;
attr_merge( e, monitor_ad_desc, bv );
mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
e->e_private = ( void * )mp;
mp->mp_next = e_tmp;
mp->mp_children = NULL;
mp->mp_info = &monitor_subsys[SLAPD_MONITOR_OPS];
mp->mp_flags = monitor_subsys[SLAPD_MONITOR_OPS].mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,%s'\n",
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val, 0 );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,%s'\n%s",
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val,
"" );
#endif
return( -1 );
}
e_tmp = e;
e_children = NULL;
for ( i = SLAP_OP_LAST; i-- > 0; ) {
/*
* Completed ops
*/
snprintf( buf, sizeof( buf ),
"dn: cn=%s,cn=%s,%s\n"
SLAPD_MONITOR_OBJECTCLASSES
"cn: %s\n",
bv_op[ i ].bv_val,
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_dn.bv_val,
bv_op[ i ].bv_val );
e = str2entry( buf );
if ( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to create entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#endif
return( -1 );
}
bv[0].bv_val = "0";
bv[0].bv_len = 1;
attr_merge( e, monitor_ad_desc, bv );
mp = ( struct monitorentrypriv * )ch_calloc( sizeof( struct monitorentrypriv ), 1 );
e->e_private = ( void * )mp;
mp->mp_next = e_children;
mp->mp_children = NULL;
mp->mp_info = &monitor_subsys[SLAPD_MONITOR_OPS];
mp->mp_flags = monitor_subsys[SLAPD_MONITOR_OPS].mss_flags \
| MONITOR_F_SUB | MONITOR_F_PERSISTENT;
if ( monitor_cache_add( mi, e ) ) {
#ifdef NEW_LOGGING
LDAP_LOG( OPERATION, CRIT,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#else
Debug( LDAP_DEBUG_ANY,
"monitor_subsys_ops_init: "
"unable to add entry 'cn=%s,cn=%s,%s'\n",
bv_op[ i ].bv_val,
bv_completed.bv_val,
monitor_subsys[SLAPD_MONITOR_OPS].mss_ndn.bv_val );
#endif
return( -1 );
}
e_children = e;
}
mp = ( struct monitorentrypriv * )e_tmp->e_private;
mp->mp_children = e_children;
mp = ( struct monitorentrypriv * )e_op->e_private;
mp->mp_children = e_tmp;
monitor_cache_release( mi, e_op );
return( 0 );
}
int
monitor_back_compare( Operation *op, SlapReply *rs )
{
monitor_info_t *mi = ( monitor_info_t * ) op->o_bd->be_private;
Entry *e, *matched = NULL;
Attribute *a;
int rc;
/* get entry with reader lock */
monitor_cache_dn2entry( op, rs, &op->o_req_ndn, &e, &matched );
if ( e == NULL ) {
rs->sr_err = LDAP_NO_SUCH_OBJECT;
if ( matched ) {
if ( !access_allowed_mask( op, matched,
slap_schema.si_ad_entry,
NULL, ACL_DISCLOSE, NULL, NULL ) )
{
/* do nothing */ ;
} else {
rs->sr_matched = matched->e_dn;
}
}
send_ldap_result( op, rs );
if ( matched ) {
monitor_cache_release( mi, matched );
rs->sr_matched = NULL;
}
return rs->sr_err;
}
rs->sr_err = access_allowed( op, e, op->oq_compare.rs_ava->aa_desc,
&op->oq_compare.rs_ava->aa_value, ACL_COMPARE, NULL );
if ( !rs->sr_err ) {
rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
goto return_results;
}
rs->sr_err = LDAP_NO_SUCH_ATTRIBUTE;
for ( a = attrs_find( e->e_attrs, op->oq_compare.rs_ava->aa_desc );
a != NULL;
a = attrs_find( a->a_next, op->oq_compare.rs_ava->aa_desc )) {
rs->sr_err = LDAP_COMPARE_FALSE;
if ( attr_valfind( a,
SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
&op->oq_compare.rs_ava->aa_value, NULL,
op->o_tmpmemctx ) == 0 )
{
rs->sr_err = LDAP_COMPARE_TRUE;
break;
}
}
return_results:;
rc = rs->sr_err;
switch ( rc ) {
case LDAP_COMPARE_FALSE:
case LDAP_COMPARE_TRUE:
rc = LDAP_SUCCESS;
break;
case LDAP_NO_SUCH_ATTRIBUTE:
break;
default:
if ( !access_allowed_mask( op, e, slap_schema.si_ad_entry,
NULL, ACL_DISCLOSE, NULL, NULL ) )
{
rs->sr_err = LDAP_NO_SUCH_OBJECT;
}
break;
}
send_ldap_result( op, rs );
rs->sr_err = rc;
monitor_cache_release( mi, e );
return rs->sr_err;
}