/* $OpenLDAP$ */
/*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/
/* backend.c - routines for dealing with back-end databases */
#include "slap.h"
#include "lutil.h"
-#ifdef SLAPD_BDB
+/*
+ * If a module is configured as dynamic, its header should not
+ * get included into slapd. While this is a general rule and does
+ * not have much of an effect in UNIX, this rule should be adhered
+ * to for Windows, where dynamic object code should not be implicitly
+ * imported into slapd without appropriate __declspec(dllimport) directives.
+ */
+
+#if defined(SLAPD_BDB) && !defined(SLAPD_BDB_DYNAMIC)
#include "back-bdb/external.h"
#endif
-#ifdef SLAPD_DNSSRV
+#if defined(SLAPD_DNSSRV) && !defined(SLAPD_DNSSRV_DYNAMIC)
#include "back-dnssrv/external.h"
#endif
-#ifdef SLAPD_LDAP
+#if defined(SLAPD_LDAP) && !defined(SLAPD_LDAP_DYNAMIC)
#include "back-ldap/external.h"
#endif
-#ifdef SLAPD_LDBM
+#if defined(SLAPD_LDBM) && !defined(SLAPD_LDBM_DYNAMIC)
#include "back-ldbm/external.h"
#endif
-#ifdef SLAPD_META
+#if defined(SLAPD_META) && !defined(SLAPD_META_DYNAMIC)
#include "back-meta/external.h"
#endif
-#ifdef SLAPD_PASSWD
+#if defined(SLAPD_MONITOR) && !defined(SLAPD_MONITOR_DYNAMIC)
+#include "back-monitor/external.h"
+#endif
+#if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC)
#include "back-passwd/external.h"
#endif
-#ifdef SLAPD_PERL
+#if defined(SLAPD_PERL) && !defined(SLAPD_PERL_DYNAMIC)
#include "back-perl/external.h"
#endif
-#ifdef SLAPD_SHELL
+#if defined(SLAPD_SHELL) && !defined(SLAPD_SHELL_DYNAMIC)
#include "back-shell/external.h"
#endif
-#ifdef SLAPD_TCL
+#if defined(SLAPD_TCL) && !defined(SLAPD_TCL_DYNAMIC)
#include "back-tcl/external.h"
#endif
-#ifdef SLAPD_SQL
+#if defined(SLAPD_SQL) && !defined(SLAPD_SQL_DYNAMIC)
#include "back-sql/external.h"
#endif
-#ifdef SLAPD_PRIVATE
+#if defined(SLAPD_PRIVATE) && !defined(SLAPD_PRIVATE_DYNAMIC)
#include "private/external.h"
#endif
#if defined(SLAPD_META) && !defined(SLAPD_META_DYNAMIC)
{"meta", meta_back_initialize},
#endif
+#if defined(SLAPD_MONITOR) && !defined(SLAPD_MONITOR_DYNAMIC)
+ {"monitor", monitor_back_initialize},
+#endif
#if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC)
{"passwd", passwd_back_initialize},
#endif
if(rc != 0) {
#ifdef NEW_LOGGING
LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
- "backend_init: initialized for type \"%s\"\n",
- binfo[nBackendInfo].bi_type ));
+ "backend_init: initialized for type \"%s\"\n",
+ binfo[nBackendInfo].bi_type ));
#else
Debug( LDAP_DEBUG_ANY,
"backend_init: initialized for type \"%s\"\n",
- binfo[nBackendInfo].bi_type, 0, 0 );
+ binfo[nBackendInfo].bi_type, 0, 0 );
#endif
/* destroy those we've already inited */
for( nBackendInfo--;
#else
#ifdef NEW_LOGGING
- LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
- "backend_init: failed\n" ));
+ LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
+ "backend_init: failed\n" ));
#else
- Debug( LDAP_DEBUG_ANY,
+ Debug( LDAP_DEBUG_ANY,
"backend_init: failed\n",
0, 0, 0 );
#endif
#ifdef NEW_LOGGING
LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
"backend_startup: starting \"%s\"\n",
- be->be_suffix[0] ));
+ be->be_suffix[0]->bv_val ));
#else
Debug( LDAP_DEBUG_TRACE,
"backend_startup: starting \"%s\"\n",
- be->be_suffix[0], 0, 0 );
+ be->be_suffix[0]->bv_val, 0, 0 );
#endif
if ( be->bd_info->bi_open ) {
int backend_destroy(void)
{
int i;
+ BackendDB *bd;
/* destroy each backend database */
- for( i = 0; i < nBackendDB; i++ ) {
- if ( backendDB[i].bd_info->bi_db_destroy ) {
- backendDB[i].bd_info->bi_db_destroy(
- &backendDB[i] );
+ for( i = 0, bd = backendDB; i < nBackendDB; i++, bd++ ) {
+ if ( bd->bd_info->bi_db_destroy ) {
+ bd->bd_info->bi_db_destroy( bd );
}
+ ber_bvecfree( bd->be_suffix );
+ ber_bvecfree( bd->be_nsuffix );
+ if ( bd->be_rootdn.bv_val ) free( bd->be_rootdn.bv_val );
+ if ( bd->be_rootndn.bv_val ) free( bd->be_rootndn.bv_val );
+ if ( bd->be_rootpw.bv_val ) free( bd->be_rootpw.bv_val );
+ acl_destroy( bd->be_acl, global_acl );
}
+ free( backendDB );
/* destroy each backend type */
for( i = 0; i < nBackendInfo; i++ ) {
be = &backends[nbackends++];
be->bd_info = bi;
- be->be_sizelimit = defsize;
- be->be_timelimit = deftime;
+ be->be_def_limit = deflimit;
be->be_dfltaccess = global_default_access;
be->be_restrictops = global_restrictops;
Backend *
select_backend(
- const char * dn,
- int manageDSAit )
+ struct berval * dn,
+ int manageDSAit,
+ int noSubs )
{
- int i, j, len, dnlen;
+ int i, j;
+ ber_len_t len, dnlen = dn->bv_len;
Backend *be = NULL;
- dnlen = strlen( dn );
for ( i = 0; i < nbackends; i++ ) {
for ( j = 0; backends[i].be_nsuffix != NULL &&
backends[i].be_nsuffix[j] != NULL; j++ )
{
- len = strlen( backends[i].be_nsuffix[j] );
+ if ((backends[i].be_glueflags&SLAP_GLUE_SUBORDINATE)&&
+ noSubs)
+ continue;
+
+ len = backends[i].be_nsuffix[j]->bv_len;
if ( len > dnlen ) {
/* suffix is longer than DN */
continue;
}
-
- if ( (len < dnlen) && !(DN_SEPARATOR( dn[(dnlen-len)-1] )) ) {
+ if ( len && len < dnlen &&
+ ( !DN_SEPARATOR( dn->bv_val[(dnlen-len)-1] ) ||
+ DN_ESCAPE( dn->bv_val[(dnlen-len)-2] ) ) )
+ {
/* make sure we have a separator */
continue;
}
-
- if ( strcmp( backends[i].be_nsuffix[j], &dn[dnlen-len] ) == 0 ) {
+ if ( strcmp( backends[i].be_nsuffix[j]->bv_val,
+ &dn->bv_val[dnlen-len] ) == 0 )
+ {
if( be == NULL ) {
be = &backends[i];
)
{
int i;
+ size_t len = strlen(suffix);
for ( i = 0; be->be_nsuffix != NULL && be->be_nsuffix[i] != NULL; i++ ) {
- if ( strcmp( be->be_nsuffix[i], suffix ) == 0 ) {
+ if ( len != be->be_nsuffix[i]->bv_len ) {
+ continue;
+ }
+ if ( strcmp( be->be_nsuffix[i]->bv_val, suffix ) == 0 ) {
return( 1 );
}
}
}
int
-be_isroot( Backend *be, const char *ndn )
+be_isroot( Backend *be, struct berval *ndn )
{
- int rc;
+ if ( !ndn->bv_len ) {
+ return( 0 );
+ }
- if ( ndn == NULL || *ndn == '\0' ) {
+ if ( !be->be_rootndn.bv_len ) {
return( 0 );
}
- if ( be->be_root_ndn == NULL || *be->be_root_ndn == '\0' ) {
+ return strcmp( be->be_rootndn.bv_val, ndn->bv_val ) ? 0 : 1;
+}
+
+int
+be_isupdate( Backend *be, struct berval *ndn )
+{
+ if ( !ndn->bv_len ) {
return( 0 );
}
- rc = strcmp( be->be_root_ndn, ndn ) ? 0 : 1;
+ if ( !be->be_update_ndn.bv_len ) {
+ return( 0 );
+ }
- return(rc);
+ return strcmp( be->be_update_ndn.bv_val, ndn->bv_val ) ? 0 : 1;
}
-char *
+struct berval *
be_root_dn( Backend *be )
{
- if ( be->be_root_dn == NULL ) {
- return( "" );
- }
-
- return be->be_root_dn;
+ return &be->be_rootdn;
}
int
be_isroot_pw( Backend *be,
Connection *conn,
- const char *ndn,
+ struct berval *ndn,
struct berval *cred )
{
int result;
return 0;
}
- if( be->be_root_pw.bv_len == 0 ) {
+ if( be->be_rootpw.bv_len == 0 ) {
return 0;
}
#endif
#endif
- result = lutil_passwd( &be->be_root_pw, cred, NULL );
+ result = lutil_passwd( &be->be_rootpw, cred, NULL );
#if defined( SLAPD_CRYPT ) || defined( SLAPD_SPASSWD )
#ifdef SLAPD_SPASSWD
return LDAP_CONFIDENTIALITY_REQUIRED;
}
- if( op->o_ndn == NULL ) {
+ if( op->o_ndn.bv_len == 0 ) {
*text = "modifications require authentication";
return LDAP_OPERATIONS_ERROR;
}
if( requires & SLAP_REQUIRE_STRONG ) {
/* should check mechanism */
- if( op->o_authmech == NULL ||
- op->o_dn == NULL || *op->o_dn == '\0' )
+ if( op->o_authmech == NULL || op->o_dn.bv_len == 0 )
{
*text = "strong authentication required";
return LDAP_STRONG_AUTH_REQUIRED;
}
if( requires & SLAP_REQUIRE_SASL ) {
- if( op->o_authmech == NULL ||
- op->o_dn == NULL || *op->o_dn == '\0' )
+ if( op->o_authmech == NULL || op->o_dn.bv_len == 0 )
{
*text = "SASL authentication required";
return LDAP_STRONG_AUTH_REQUIRED;
}
if( requires & SLAP_REQUIRE_AUTHC ) {
- if( op->o_dn == NULL || *op->o_dn == '\0' ) {
+ if( op->o_dn.bv_len == 0 ) {
*text = "authentication required";
return LDAP_UNWILLING_TO_PERFORM;
}
Backend *be,
Connection *conn,
Operation *op,
- const char *dn,
- const char *ndn )
+ struct berval *dn,
+ struct berval *ndn )
{
int rc = LDAP_SUCCESS;
Connection *conn,
Operation *op,
Entry *target,
- const char *gr_ndn,
- const char *op_ndn,
+ struct berval *gr_ndn,
+ struct berval *op_ndn,
ObjectClass *group_oc,
AttributeDescription *group_at
)
{
- if( strcmp( target->e_ndn, gr_ndn ) != 0 ) {
+ GroupAssertion *g;
+ int i;
+
+ ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
+ i = op->o_abandon;
+ ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
+ if (i) return SLAPD_ABANDON;
+
+ if( target->e_nname.bv_len != gr_ndn->bv_len ||
+ strcmp( target->e_nname.bv_val, gr_ndn->bv_val ) != 0 ) {
/* we won't attempt to send it to a different backend */
- be = select_backend(gr_ndn, 0);
+ be = select_backend( gr_ndn, 0,
+ (be->be_glueflags & SLAP_GLUE_INSTANCE));
if (be == NULL) {
return LDAP_NO_SUCH_OBJECT;
}
}
+ ldap_pvt_thread_mutex_lock( &conn->c_mutex );
+ for (g = conn->c_groups; g; g=g->next) {
+ if (g->be != be || g->oc != group_oc || g->at != group_at ||
+ g->len != gr_ndn->bv_len)
+ continue;
+ if (strcmp( g->ndn, gr_ndn->bv_val ) == 0)
+ break;
+ }
+ ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
+ if (g)
+ return g->res;
+
if( be->be_group ) {
- return be->be_group( be, conn, op,
+ int res = be->be_group( be, conn, op,
target, gr_ndn, op_ndn,
group_oc, group_at );
+
+ if (op->o_tag != LDAP_REQ_BIND) {
+ g = ch_malloc(sizeof(GroupAssertion) + gr_ndn->bv_len);
+ g->be = be;
+ g->oc = group_oc;
+ g->at = group_at;
+ g->res = res;
+ g->len = gr_ndn->bv_len;
+ strcpy(g->ndn, gr_ndn->bv_val);
+ ldap_pvt_thread_mutex_lock( &conn->c_mutex );
+ g->next = conn->c_groups;
+ conn->c_groups = g;
+ ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
+ }
+
+ return res;
}
return LDAP_UNWILLING_TO_PERFORM;
Connection *conn,
Operation *op,
Entry *target,
- const char *e_ndn,
+ struct berval *edn,
AttributeDescription *entry_at,
- struct berval ***vals
+ BVarray *vals
)
{
- if( target == NULL || strcmp( target->e_ndn, e_ndn ) != 0 ) {
+ if( target == NULL || target->e_nname.bv_len != edn->bv_len ||
+ strcmp( target->e_ndn, edn->bv_val ) != 0 )
+ {
/* we won't attempt to send it to a different backend */
- be = select_backend(e_ndn, 0);
+ be = select_backend( edn, 0,
+ (be->be_glueflags & SLAP_GLUE_INSTANCE));
if (be == NULL) {
return LDAP_NO_SUCH_OBJECT;
}
if( be->be_attribute ) {
- return be->be_attribute( be, conn, op, target, e_ndn,
+ return be->be_attribute( be, conn, op, target, edn,
entry_at, vals );
}
Backend *be,
Connection *conn,
Operation *op,
- Entry *e )
+ Entry *e,
+ AttributeName *attrs,
+ int opattrs )
{
- Attribute *a = NULL;
+ Attribute *a = NULL, **ap = &a;
#ifdef SLAPD_SCHEMA_DN
- a = ch_malloc( sizeof( Attribute ) );
- a->a_desc = ad_dup( slap_schema.si_ad_subschemaSubentry );
-
- /* Should be backend specific */
- a->a_vals = ch_malloc( 2 * sizeof( struct berval * ) );
- a->a_vals[0] = ber_bvstrdup( SLAPD_SCHEMA_DN );
- a->a_vals[1] = NULL;
-
- a->a_next = NULL;
+ *ap = slap_operational_subschemaSubentry();
+ ap = &(*ap)->a_next;
#endif
+ /*
+ * If operational attributes (allegedly) are required,
+ * and the backend supports specific operational attributes,
+ * add them to the attribute list
+ */
+ if ( ( opattrs || attrs ) && be && be->be_operational != NULL ) {
+ ( void )be->be_operational( be, conn, op, e, attrs, opattrs, ap );
+ }
+
return a;
}
+