X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fbackend.c;h=9aa6568a60b74c7114b5b6d75a4c268c1b55b687;hb=51190984eefbdbedd47185e41ece37f72773744d;hp=e88797c6d8c185ea82e6809886b570b35eea713d;hpb=b7beec16639919fa80f76f0e72db9afde77d32be;p=openldap diff --git a/servers/slapd/backend.c b/servers/slapd/backend.c index e88797c6d8..9aa6568a60 100644 --- a/servers/slapd/backend.c +++ b/servers/slapd/backend.c @@ -1,3 +1,8 @@ +/* $OpenLDAP$ */ +/* + * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ /* backend.c - routines for dealing with back-end databases */ @@ -11,183 +16,432 @@ #include #include "slap.h" +#include "lutil.h" +#ifdef SLAPD_LDAP +#include "back-ldap/external.h" +#endif +#ifdef SLAPD_LDBM +#include "back-ldbm/external.h" +#endif +#ifdef SLAPD_BDB2 +#include "back-bdb2/external.h" +#endif +#ifdef SLAPD_PASSWD +#include "back-passwd/external.h" +#endif +#ifdef SLAPD_PERL +#include "back-perl/external.h" +#endif +#ifdef SLAPD_SHELL +#include "back-shell/external.h" +#endif +#ifdef SLAPD_TCL +#include "back-tcl/external.h" +#endif +#ifdef SLAPD_NTDOMAIN +#include "back-domain/external.h" +#endif + +static BackendInfo binfo[] = { +#if defined(SLAPD_LDAP) && !defined(SLAPD_LDAP_DYNAMIC) + {"ldap", ldap_back_initialize}, +#endif +#if defined(SLAPD_LDBM) && !defined(SLAPD_LDBM_DYNAMIC) + {"ldbm", ldbm_back_initialize}, +#endif +#if defined(SLAPD_BDB2) && !defined(SLAPD_BDB2_DYNAMIC) + {"bdb2", bdb2_back_initialize}, +#endif +#if defined(SLAPD_PASSWD) && !defined(SLAPD_PASSWD_DYNAMIC) + {"passwd", passwd_back_initialize}, +#endif +#if defined(SLAPD_PERL) && !defined(SLAPD_PERL_DYNAMIC) + {"perl", perl_back_initialize}, +#endif +#if defined(SLAPD_SHELL) && !defined(SLAPD_SHELL_DYNAMIC) + {"shell", shell_back_initialize}, +#endif +#if defined(SLAPD_TCL) && !defined(SLAPD_TCL_DYNAMIC) + {"tcl", tcl_back_initialize}, +#endif +#if defined(SLAPD_NTDOMAIN) && !defined(SLAPD_NTDOMAIN_DYNAMIC) + {"ntdom", domain_back_initialize}, +#endif + {NULL} +}; -#define BACKEND_GRAB_SIZE 10 +int nBackendInfo = 0; +BackendInfo *backendInfo = NULL; -int nbackends; -Backend *backends; -static int maxbackends; +int nBackendDB = 0; +BackendDB *backendDB = NULL; -Backend * -new_backend( - char *type -) +int backend_init(void) { - Backend *be; - int foundit; + int rc = -1; - if ( nbackends == maxbackends ) { - maxbackends += BACKEND_GRAB_SIZE; - backends = (Backend *) ch_realloc( (char *) backends, - maxbackends * sizeof(Backend) ); - memset( &backends[nbackends], '\0', BACKEND_GRAB_SIZE * - sizeof(Backend) ); + if((nBackendInfo != 0) || (backendInfo != NULL)) { + /* already initialized */ + Debug( LDAP_DEBUG_ANY, + "backend_init: already initialized.\n", 0, 0, 0 ); + return -1; } - be = &backends[nbackends++]; - be->be_sizelimit = defsize; - be->be_timelimit = deftime; - foundit = 0; + for( ; + binfo[nBackendInfo].bi_type != NULL; + nBackendInfo++ ) + { + rc = binfo[nBackendInfo].bi_init( &binfo[nBackendInfo] ); + + if(rc != 0) { + Debug( LDAP_DEBUG_ANY, + "backend_init: initialized for type \"%s\"\n", + binfo[nBackendInfo].bi_type, 0, 0 ); + + /* destroy those we've already inited */ + for( nBackendInfo--; + nBackendInfo >= 0 ; + nBackendInfo-- ) + { + if ( binfo[nBackendInfo].bi_destroy ) { + binfo[nBackendInfo].bi_destroy( + &binfo[nBackendInfo] ); + } + } + return rc; + } + } -#ifdef SLAPD_LDBM - if ( strcasecmp( type, "ldbm" ) == 0 ) { - be->be_bind = ldbm_back_bind; - be->be_unbind = ldbm_back_unbind; - be->be_search = ldbm_back_search; - be->be_compare = ldbm_back_compare; - be->be_modify = ldbm_back_modify; - be->be_modrdn = ldbm_back_modrdn; - be->be_add = ldbm_back_add; - be->be_delete = ldbm_back_delete; - be->be_abandon = ldbm_back_abandon; - be->be_config = ldbm_back_config; - be->be_init = ldbm_back_init; - be->be_close = ldbm_back_close; -#ifdef SLAPD_ACLGROUPS - be->be_group = ldbm_back_group; -#endif - be->be_type = "ldbm"; - foundit = 1; + if ( nBackendInfo > 0) { + backendInfo = binfo; + return 0; } -#endif -#ifdef SLAPD_PASSWD - if ( strcasecmp( type, "passwd" ) == 0 ) { - be->be_bind = NULL; - be->be_unbind = NULL; - be->be_search = passwd_back_search; - be->be_compare = NULL; - be->be_modify = NULL; - be->be_modrdn = NULL; - be->be_add = NULL; - be->be_delete = NULL; - be->be_abandon = NULL; - be->be_config = passwd_back_config; - be->be_init = NULL; - be->be_close = NULL; -#ifdef SLAPD_ACLGROUPS - be->be_group = NULL; -#endif - be->be_type = "passwd"; - foundit = 1; +#ifdef SLAPD_MODULES + return 0; +#else + Debug( LDAP_DEBUG_ANY, + "backend_init: failed\n", + 0, 0, 0 ); + + return rc; +#endif /* SLAPD_MODULES */ +} + +int backend_add(BackendInfo *aBackendInfo) +{ + int rc = 0; + + if ((rc = aBackendInfo->bi_init(aBackendInfo)) != 0) { + Debug( LDAP_DEBUG_ANY, + "backend_add: initialization for type \"%s\" failed\n", + aBackendInfo->bi_type, 0, 0 ); + return rc; + } + + /* now add the backend type to the Backend Info List */ + { + BackendInfo *newBackendInfo = 0; + + /* if backendInfo == binfo no deallocation of old backendInfo */ + if (backendInfo == binfo) { + newBackendInfo = ch_calloc(nBackendInfo + 1, sizeof(BackendInfo)); + memcpy(newBackendInfo, backendInfo, sizeof(BackendInfo) * + nBackendInfo); + } else { + newBackendInfo = ch_realloc(backendInfo, sizeof(BackendInfo) * + (nBackendInfo + 1)); + } + memcpy(&newBackendInfo[nBackendInfo], aBackendInfo, + sizeof(BackendInfo)); + backendInfo = newBackendInfo; + nBackendInfo++; + + return 0; + } +} + +int backend_startup(Backend *be) +{ + int i; + int rc = 0; + + if( ! ( nBackendDB > 0 ) ) { + /* no databases */ + Debug( LDAP_DEBUG_ANY, + "backend_startup: %d databases to startup.\n", + nBackendDB, 0, 0 ); + return 1; } -#endif -#ifdef SLAPD_SHELL - if ( strcasecmp( type, "shell" ) == 0 ) { - be->be_bind = shell_back_bind; - be->be_unbind = shell_back_unbind; - be->be_search = shell_back_search; - be->be_compare = shell_back_compare; - be->be_modify = shell_back_modify; - be->be_modrdn = shell_back_modrdn; - be->be_add = shell_back_add; - be->be_delete = shell_back_delete; - be->be_abandon = shell_back_abandon; - be->be_config = shell_back_config; - be->be_init = shell_back_init; - be->be_close = NULL; -#ifdef SLAPD_ACLGROUPS - be->be_group = NULL; -#endif - be->be_type = "shell"; - foundit = 1; + if(be != NULL) { + /* startup a specific backend database */ + Debug( LDAP_DEBUG_TRACE, + "backend_startup: starting database\n", + 0, 0, 0 ); + + if ( be->bd_info->bi_open ) { + rc = be->bd_info->bi_open( be->bd_info ); + } + + if(rc != 0) { + Debug( LDAP_DEBUG_ANY, + "backend_startup: bi_open failed!\n", + 0, 0, 0 ); + return rc; + } + + if ( be->bd_info->bi_db_open ) { + rc = be->bd_info->bi_db_open( be ); + } + + if(rc != 0) { + Debug( LDAP_DEBUG_ANY, + "backend_startup: bi_db_open failed!\n", + 0, 0, 0 ); + return rc; + } + + return rc; } -#endif + /* open each backend type */ + for( i = 0; i < nBackendInfo; i++ ) { + if( backendInfo[i].bi_nDB == 0) { + /* no database of this type, don't open */ + continue; + } -#ifdef SLAPD_PERL - if ( strcasecmp( type, "perl" ) == 0 ) { -#ifdef notdef - be->be_abandon = perl_back_abandon; - be->be_bind = perl_back_bind; -#else - be->be_abandon = NULL; - be->be_bind = NULL; -#endif - be->be_unbind = perl_back_unbind; - be->be_search = perl_back_search; - be->be_compare = perl_back_compare; - be->be_modify = perl_back_modify; - be->be_modrdn = perl_back_modrdn; - be->be_add = perl_back_add; - be->be_delete = perl_back_delete; - be->be_config = perl_back_config; - be->be_init = perl_back_init; - be->be_close = perl_back_close; - be->be_type = "perl"; - foundit = 1; + if( backendInfo[i].bi_open ) { + rc = backendInfo[i].bi_open( + &backendInfo[i] ); + } + + if(rc != 0) { + Debug( LDAP_DEBUG_ANY, + "backend_startup: bi_open %d failed!\n", + i, 0, 0 ); + return rc; + } } -#endif + /* open each backend database */ + for( i = 0; i < nBackendDB; i++ ) { + /* append global access controls */ + acl_append( &backendDB[i].be_acl, global_acl ); + + if ( backendDB[i].bd_info->bi_db_open ) { + rc = backendDB[i].bd_info->bi_db_open( + &backendDB[i] ); + } + + if(rc != 0) { + Debug( LDAP_DEBUG_ANY, + "backend_startup: bi_db_open %d failed!\n", + i, 0, 0 ); + return rc; + } + } + + return rc; +} + +int backend_num( Backend *be ) +{ + int i; + + if( be == NULL ) return -1; + + for( i = 0; i < nBackendDB; i++ ) { + if( be == &backendDB[i] ) return i; + } + return -1; +} + +int backend_shutdown( Backend *be ) +{ + int i; + int rc = 0; + + if( be != NULL ) { + /* shutdown a specific backend database */ + + if ( be->bd_info->bi_nDB == 0 ) { + /* no database of this type, we never opened it */ + return 0; + } + + if ( be->bd_info->bi_db_close ) { + be->bd_info->bi_db_close( be ); + } + + if( be->bd_info->bi_close ) { + be->bd_info->bi_close( be->bd_info ); + } + + return 0; + } + + /* close each backend database */ + for( i = 0; i < nBackendDB; i++ ) { + if ( backendDB[i].bd_info->bi_db_close ) { + backendDB[i].bd_info->bi_db_close( + &backendDB[i] ); + } + + if(rc != 0) { + Debug( LDAP_DEBUG_ANY, + "backend_close: bi_close %s failed!\n", + backendDB[i].be_type, 0, 0 ); + } + } + + /* close each backend type */ + for( i = 0; i < nBackendInfo; i++ ) { + if( backendInfo[i].bi_nDB == 0 ) { + /* no database of this type */ + continue; + } + + if( backendInfo[i].bi_close ) { + backendInfo[i].bi_close( + &backendInfo[i] ); + } + } + + return 0; +} + +int backend_destroy(void) +{ + int i; + + /* 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] ); + } + } + + /* destroy each backend type */ + for( i = 0; i < nBackendInfo; i++ ) { + if( backendInfo[i].bi_destroy ) { + backendInfo[i].bi_destroy( + &backendInfo[i] ); + } + } + +#ifdef SLAPD_MODULES + if (backendInfo != binfo) { + free(backendInfo); + } +#endif /* SLAPD_MODULES */ + + nBackendInfo = 0; + backendInfo = NULL; + + return 0; +} +BackendInfo* backend_info(const char *type) +{ + int i; - if ( be->be_init != NULL ) { - (*be->be_init)( be ); + /* search for the backend type */ + for( i = 0; i < nBackendInfo; i++ ) { + if( strcasecmp(backendInfo[i].bi_type, type) == 0 ) { + return &backendInfo[i]; + } } - if ( foundit == 0 ) { + return NULL; +} + + +BackendDB * +backend_db_init( + const char *type +) +{ + Backend *be; + BackendInfo *bi = backend_info(type); + int rc = 0; + + if( bi == NULL ) { fprintf( stderr, "Unrecognized database type (%s)\n", type ); - exit( 1 ); + return NULL; } + backendDB = (BackendDB *) ch_realloc( + (char *) backendDB, + (nBackendDB + 1) * sizeof(Backend) ); + + memset( &backendDB[nbackends], '\0', sizeof(Backend) ); + + be = &backends[nbackends++]; + + be->bd_info = bi; + be->be_sizelimit = defsize; + be->be_timelimit = deftime; + be->be_dfltaccess = global_default_access; + + /* assign a default depth limit for alias deref */ + be->be_max_deref_depth = SLAPD_DEFAULT_MAXDEREFDEPTH; + + be->be_realm = global_realm != NULL + ? ch_strdup( global_realm ) : NULL; + + if(bi->bi_db_init) { + rc = bi->bi_db_init( be ); + } + + if(rc != 0) { + fprintf( stderr, "database init failed (%s)\n", type ); + nbackends--; + return NULL; + } + + bi->bi_nDB++; return( be ); } +void +be_db_close( void ) +{ + int i; + + for ( i = 0; i < nbackends; i++ ) { + if ( backends[i].bd_info->bi_db_close ) { + (*backends[i].bd_info->bi_db_close)( &backends[i] ); + } + } +} + Backend * -select_backend( char * dn ) +select_backend( const char * dn ) { int i, j, len, dnlen; dnlen = strlen( dn ); for ( i = 0; i < nbackends; i++ ) { - for ( j = 0; backends[i].be_suffix != NULL && - backends[i].be_suffix[j] != NULL; j++ ) + for ( j = 0; backends[i].be_nsuffix != NULL && + backends[i].be_nsuffix[j] != NULL; j++ ) { - len = strlen( backends[i].be_suffix[j] ); + len = strlen( backends[i].be_nsuffix[j] ); if ( len > dnlen ) { continue; } - if ( strcasecmp( backends[i].be_suffix[j], + if ( strcmp( backends[i].be_nsuffix[j], dn + (dnlen - len) ) == 0 ) { return( &backends[i] ); } } } - /* if no proper suffix could be found then check for aliases */ - for ( i = 0; i < nbackends; i++ ) { - for ( j = 0; - backends[i].be_suffixAlias != NULL && - backends[i].be_suffixAlias[j] != NULL; - j += 2 ) - { - len = strlen( backends[i].be_suffixAlias[j] ); - - if ( len > dnlen ) { - continue; - } - - if ( strcasecmp( backends[i].be_suffixAlias[j], - dn + (dnlen - len) ) == 0 ) { - return( &backends[i] ); - } - } - } - #ifdef LDAP_ALLOW_NULL_SEARCH_BASE /* Add greg@greg.rim.or.jp * It's quick hack for cheap client @@ -208,13 +462,13 @@ select_backend( char * dn ) int be_issuffix( Backend *be, - char *suffix + const char *suffix ) { int i; - for ( i = 0; be->be_suffix != NULL && be->be_suffix[i] != NULL; i++ ) { - if ( strcasecmp( be->be_suffix[i], suffix ) == 0 ) { + for ( i = 0; be->be_nsuffix != NULL && be->be_nsuffix[i] != NULL; i++ ) { + if ( strcmp( be->be_nsuffix[i], suffix ) == 0 ) { return( 1 ); } } @@ -223,82 +477,178 @@ be_issuffix( } int -be_isroot( Backend *be, char *dn ) +be_isroot( Backend *be, const char *ndn ) { - if ( dn == NULL ) { + int rc; + + if ( ndn == NULL || be->be_root_ndn == NULL ) { return( 0 ); } - return( be->be_rootdn != NULL - ? strcasecmp( be->be_rootdn, dn ) == 0 - : 0 ); + rc = strcmp( be->be_root_ndn, ndn ) ? 0 : 1; + + return(rc); +} + +char * +be_root_dn( Backend *be ) +{ + if ( be->be_root_dn == NULL ) { + return( "" ); + } + + return be->be_root_dn; } int -be_isroot_pw( Backend *be, char *dn, struct berval *cred ) +be_isroot_pw( Backend *be, const char *ndn, struct berval *cred ) { int result; - if ( ! be_isroot( be, dn ) ) { - return( 0 ); + if ( ! be_isroot( be, ndn ) ) { + return 0; + } + + if( be->be_root_pw.bv_len == 0 ) { + return 0; } #ifdef SLAPD_CRYPT - pthread_mutex_lock( &crypt_mutex ); + ldap_pvt_thread_mutex_lock( &crypt_mutex ); #endif - result = lutil_passwd( cred->bv_val, be->be_rootpw ); + result = lutil_passwd( &be->be_root_pw, cred, NULL ); #ifdef SLAPD_CRYPT - pthread_mutex_unlock( &crypt_mutex ); + ldap_pvt_thread_mutex_unlock( &crypt_mutex ); #endif return result == 0; } -void -be_close( void ) +int +be_entry_release_rw( Backend *be, Entry *e, int rw ) +{ + if ( be->be_release ) { + /* free and release entry from backend */ + return be->be_release( be, e, rw ); + } else { + /* free entry */ + entry_free( e ); + return 0; + } +} + +int +backend_unbind( + Connection *conn, + Operation *op +) { int i; for ( i = 0; i < nbackends; i++ ) { - if ( backends[i].be_close != NULL ) { - (*backends[i].be_close)( &backends[i] ); + if ( backends[i].be_unbind ) { + (*backends[i].be_unbind)( &backends[i], conn, op ); } } + + return 0; } +int +backend_connection_init( + Connection *conn +) +{ + int i; -void -be_unbind( - Connection *conn, - Operation *op + for ( i = 0; i < nbackends; i++ ) { + if ( backends[i].be_connection_init ) { + (*backends[i].be_connection_init)( &backends[i], conn); + } + } + + return 0; +} + +int +backend_connection_destroy( + Connection *conn ) { int i; for ( i = 0; i < nbackends; i++ ) { - if ( backends[i].be_unbind != NULL ) { - (*backends[i].be_unbind)( &backends[i], conn, op ); + if ( backends[i].be_connection_destroy ) { + (*backends[i].be_connection_destroy)( &backends[i], conn); } } + + return 0; +} + +int +backend_check_controls( + Backend *be, + Connection *conn, + Operation *op ) +{ + LDAPControl **ctrls; + ctrls = op->o_ctrls; + if( ctrls == NULL ) { + return LDAP_SUCCESS; + } + + for( ; *ctrls != NULL ; ctrls++ ) { + if( (*ctrls)->ldctl_iscritical && + !charray_inlist( be->be_controls, (*ctrls)->ldctl_oid ) ) + { + return LDAP_UNAVAILABLE_CRITICAL_EXTENSION; + } + } + + return LDAP_SUCCESS; } -#ifdef SLAPD_ACLGROUPS int -be_group( +backend_group( Backend *be, - Entry *e, - char *bdn, - char *edn, - char *objectclassValue, - char *groupattrName + Entry *target, + const char *gr_ndn, + const char *op_ndn, + const char *objectclassValue, + const char *groupattrName ) { - if (be->be_group) - return(be->be_group(be, e, bdn, edn, - objectclassValue, groupattrName)); - else - return(1); + if (be->be_group) + return( be->be_group(be, target, gr_ndn, op_ndn, + objectclassValue, groupattrName) ); + else + return(1); +} + +#ifdef SLAPD_SCHEMA_DN +Attribute *backend_subschemasubentry( Backend *be ) +{ + /* + * This routine returns points to STATIC data!!! + */ + /* should be backend specific */ + + static struct berval ss_val = { + sizeof(SLAPD_SCHEMA_DN)-1, + SLAPD_SCHEMA_DN }; + static struct berval *ss_vals[2] = { &ss_val, NULL }; + static Attribute ss_attr = { + "subschemasubentry", + ss_vals, +#ifdef SLAPD_SCHEMA_COMPAT + SYNTAX_DN | SYNTAX_CIS, +#endif + NULL + }; + + return &ss_attr; } #endif