Add a default case with assert() just in case.

[openldap] / servers / slapd / backend.c

diff --git a/servers/slapd/backend.c b/servers/slapd/backend.c
index 12951245cdccb3ad4ef23664d23f7a7b03d3bd3b..530410362cc165631370bde305185b41f1baa2bd 100644 (file)
--- a/servers/slapd/backend.c
+++ b/servers/slapd/backend.c
@@ -1,6 +1,6 @@
 /* $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 */
@@ -410,19 +410,19 @@ int backend_shutdown( Backend *be )
 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( backendDB[i].be_suffix );
-               ber_bvecfree( backendDB[i].be_nsuffix );
-               free( backendDB[i].be_rootdn.bv_val );
-               free( backendDB[i].be_rootndn.bv_val );
-               free( backendDB[i].be_rootpw.bv_val );
-               acl_destroy( backendDB[i].be_acl, global_acl );
+               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 );
 
@@ -533,9 +533,11 @@ select_backend(
                for ( j = 0; backends[i].be_nsuffix != NULL &&
                    backends[i].be_nsuffix[j] != NULL; j++ )
                {
-                       if ((backends[i].be_glueflags&SLAP_GLUE_SUBORDINATE)&&
-                               noSubs)
+                       if (( backends[i].be_flags & SLAP_BFLAG_GLUE_SUBORDINATE )
+                               && noSubs )
+                       {
                                continue;
+                       }
 
                        len = backends[i].be_nsuffix[j]->bv_len;
 
@@ -604,7 +606,7 @@ be_isroot( Backend *be, struct berval *ndn )
                return( 0 );
        }
 
-       return strcmp( be->be_rootndn.bv_val, ndn->bv_val ) ? 0 : 1;
+       return dn_match( &be->be_rootndn, ndn );
 }
 
 int
@@ -618,32 +620,24 @@ be_isupdate( Backend *be, struct berval *ndn )
                return( 0 );
        }
 
-       return strcmp( be->be_update_ndn.bv_val, ndn->bv_val ) ? 0 : 1;
+       return dn_match( &be->be_update_ndn, ndn );
 }
 
-char *
+struct berval *
 be_root_dn( Backend *be )
 {
-       if ( !be->be_rootdn.bv_len ) {
-               return( "" );
-       }
-
-       return be->be_rootdn.bv_val;
+       return &be->be_rootdn;
 }
 
 int
 be_isroot_pw( Backend *be,
        Connection *conn,
-       const char *dn,
+       struct berval *ndn,
        struct berval *cred )
 {
        int result;
 
-       struct berval ndn;
-       ndn.bv_val = (char *) dn;
-       ndn.bv_len = dn ? strlen( dn ) : 0;
-
-       if ( ! be_isroot( be, &ndn ) ) {
+       if ( ! be_isroot( be, ndn ) ) {
                return 0;
        }
 
@@ -969,7 +963,7 @@ int backend_check_referrals(
                const char *text;
 
                rc = be->be_chk_referrals( be,
-                       conn, op, dn->bv_val, ndn->bv_val, &text );
+                       conn, op, dn, ndn, &text );
 
                if( rc != LDAP_SUCCESS && rc != LDAP_REFERRAL ) {
                        send_ldap_result( conn, op, rc,
@@ -986,29 +980,25 @@ backend_group(
        Connection *conn,
        Operation *op,
        Entry   *target,
-       const char      *gr_ndn,
+       struct berval *gr_ndn,
        struct berval *op_ndn,
        ObjectClass *group_oc,
        AttributeDescription *group_at
 )
 {
        GroupAssertion *g;
-       struct berval gr;
        int i;
 
-       gr.bv_val = (char *) gr_ndn;
-       gr.bv_len = strlen(gr_ndn);
-
        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( strcmp( target->e_ndn, gr_ndn ) != 0 ) {
+       if ( !dn_match( &target->e_nname, gr_ndn ) ) {
                /* we won't attempt to send it to a different backend */
                
-               be = select_backend( &gr, 0,
-                       (be->be_glueflags & SLAP_GLUE_INSTANCE));
+               be = select_backend( gr_ndn, 0,
+                       (be->be_flags & SLAP_BFLAG_GLUE_INSTANCE));
 
                if (be == NULL) {
                        return LDAP_NO_SUCH_OBJECT;
@@ -1018,9 +1008,9 @@ backend_group(
        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.bv_len)
+                   g->len != gr_ndn->bv_len)
                        continue;
-               if (strcmp( g->ndn, gr_ndn ) == 0)
+               if (strcmp( g->ndn, gr_ndn->bv_val ) == 0)
                        break;
        }
        ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
@@ -1029,17 +1019,17 @@ backend_group(
 
        if( be->be_group ) {
                int res = be->be_group( be, conn, op,
-                       target, gr_ndn, op_ndn->bv_val,
+                       target, gr_ndn, op_ndn,
                        group_oc, group_at );
                
                if (op->o_tag != LDAP_REQ_BIND) {
-                       g = ch_malloc(sizeof(GroupAssertion) + gr.bv_len);
+                       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.bv_len;
-                       strcpy(g->ndn, gr_ndn);
+                       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;
@@ -1058,22 +1048,16 @@ backend_attribute(
        Connection *conn,
        Operation *op,
        Entry   *target,
-       const char      *entry_ndn,
+       struct berval   *edn,
        AttributeDescription *entry_at,
-       struct berval ***vals
+       BerVarray *vals
 )
 {
-       struct berval edn;
-       edn.bv_val = (char *) entry_ndn;
-       edn.bv_len = strlen( entry_ndn );
-
-       if( target == NULL ||
-               strcmp( target->e_ndn, entry_ndn ) != 0 )
-       {
+       if ( target == NULL || !dn_match( &target->e_nname, edn ) ) {
                /* we won't attempt to send it to a different backend */
                
-               be = select_backend( &edn, 0,
-                       (be->be_glueflags & SLAP_GLUE_INSTANCE));
+               be = select_backend( edn, 0,
+                       (be->be_flags & SLAP_BFLAG_GLUE_INSTANCE));
 
                if (be == NULL) {
                        return LDAP_NO_SUCH_OBJECT;
@@ -1081,7 +1065,7 @@ backend_attribute(
        } 
 
        if( be->be_attribute ) {
-               return be->be_attribute( be, conn, op, target, entry_ndn,
+               return be->be_attribute( be, conn, op, target, edn,
                        entry_at, vals );
        }
 
@@ -1093,7 +1077,7 @@ Attribute *backend_operational(
        Connection *conn,
        Operation *op,
        Entry *e,
-       char **attrs,
+       AttributeName *attrs,
        int opattrs     )
 {
        Attribute *a = NULL, **ap = &a;