return structuralObjectClass errors

[openldap] / servers / slapd / back-bdb / idl.c

diff --git a/servers/slapd/back-bdb/idl.c b/servers/slapd/back-bdb/idl.c
index 2ec368c24422ccfb2eb5ea1312b7eeaa8417c4c5..9e55ef3ca3b44a6f6a595e5d070f51e82f4bc6f0 100644 (file)
--- a/servers/slapd/back-bdb/idl.c
+++ b/servers/slapd/back-bdb/idl.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 2000-2005 The OpenLDAP Foundation.
+ * Copyright 2000-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -224,10 +224,9 @@ int bdb_idl_insert( ID *ids, ID id )
        return 0;
 }
 
-#if 0  /* unused */
-static int idl_delete( ID *ids, ID id )
+static int bdb_idl_delete( ID *ids, ID id )
 {
-       unsigned x = bdb_idl_search( ids, id );
+       unsigned x;
 
 #if IDL_DEBUG > 1
        Debug( LDAP_DEBUG_ANY, "delete: %04lx at %d\n", (long) id, x, 0 );
@@ -236,6 +235,23 @@ static int idl_delete( ID *ids, ID id )
        idl_check( ids );
 #endif
 
+       if (BDB_IDL_IS_RANGE( ids )) {
+               /* If deleting a range boundary, adjust */
+               if ( ids[1] == id )
+                       ids[1]++;
+               else if ( ids[2] == id )
+                       ids[2]--;
+               /* deleting from inside a range is a no-op */
+
+               /* If the range has collapsed, re-adjust */
+               if ( ids[1] > ids[2] )
+                       ids[0] = 0;
+               else if ( ids[1] == ids[2] )
+                       ids[1] = 1;
+               return 0;
+       }
+
+       x = bdb_idl_search( ids, id );
        assert( x > 0 );
 
        if( x <= 0 ) {
@@ -264,7 +280,6 @@ static int idl_delete( ID *ids, ID id )
 
        return 0;
 }
-#endif /* unused */
 
 static char *
 bdb_show_key(
@@ -327,17 +342,17 @@ bdb_idl_cache_put(
        bdb_idl_cache_entry_t idl_tmp;
        bdb_idl_cache_entry_t *ee;
 
+       if ( rc == DB_NOTFOUND || BDB_IDL_IS_ZERO( ids ))
+               return;
+
        DBT2bv( key, &idl_tmp.kstr );
 
        ee = (bdb_idl_cache_entry_t *) ch_malloc(
                sizeof( bdb_idl_cache_entry_t ) );
        ee->db = db;
-       if ( rc == DB_NOTFOUND || BDB_IDL_IS_ZERO( ids )) {
-               ee->idl = NULL;
-       } else {
-               ee->idl = (ID*) ch_malloc( BDB_IDL_SIZEOF ( ids ) );
-               BDB_IDL_CPY( ee->idl, ids );
-       }
+       ee->idl = (ID*) ch_malloc( BDB_IDL_SIZEOF ( ids ) );
+       BDB_IDL_CPY( ee->idl, ids );
+
        ee->idl_lru_prev = NULL;
        ee->idl_lru_next = NULL;
        ber_dupbv( &ee->kstr, &idl_tmp.kstr );
@@ -407,6 +422,64 @@ bdb_idl_cache_del(
        ldap_pvt_thread_rdwr_wunlock( &bdb->bi_idl_tree_rwlock );
 }
 
+void
+bdb_idl_cache_add_id(
+       struct bdb_info *bdb,
+       DB                      *db,
+       DBT                     *key,
+       ID                      id )
+{
+       bdb_idl_cache_entry_t *cache_entry, idl_tmp;
+       DBT2bv( key, &idl_tmp.kstr );
+       idl_tmp.db = db;
+       ldap_pvt_thread_rdwr_wlock( &bdb->bi_idl_tree_rwlock );
+       cache_entry = avl_find( bdb->bi_idl_tree, &idl_tmp,
+                                     bdb_idl_entry_cmp );
+       if ( cache_entry != NULL ) {
+               if ( !BDB_IDL_IS_RANGE( cache_entry->idl ) &&
+                       cache_entry->idl[0] < BDB_IDL_DB_MAX ) {
+                       size_t s = BDB_IDL_SIZEOF( cache_entry->idl ) + sizeof(ID);
+                       cache_entry->idl = ch_realloc( cache_entry->idl, s );
+               }
+               bdb_idl_insert( cache_entry->idl, id );
+       }
+       ldap_pvt_thread_rdwr_wunlock( &bdb->bi_idl_tree_rwlock );
+}
+
+void
+bdb_idl_cache_del_id(
+       struct bdb_info *bdb,
+       DB                      *db,
+       DBT                     *key,
+       ID                      id )
+{
+       bdb_idl_cache_entry_t *cache_entry, idl_tmp;
+       DBT2bv( key, &idl_tmp.kstr );
+       idl_tmp.db = db;
+       ldap_pvt_thread_rdwr_wlock( &bdb->bi_idl_tree_rwlock );
+       cache_entry = avl_find( bdb->bi_idl_tree, &idl_tmp,
+                                     bdb_idl_entry_cmp );
+       if ( cache_entry != NULL ) {
+               bdb_idl_delete( cache_entry->idl, id );
+               if ( cache_entry->idl[0] == 0 ) {
+                       if ( avl_delete( &bdb->bi_idl_tree, (caddr_t) cache_entry,
+                                               bdb_idl_entry_cmp ) == NULL ) {
+                               Debug( LDAP_DEBUG_ANY, "=> bdb_idl_cache_del: "
+                                       "AVL delete failed\n",
+                                       0, 0, 0 );
+                       }
+                       --bdb->bi_idl_cache_size;
+                       ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
+                       IDL_LRU_DELETE( bdb, cache_entry );
+                       ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
+                       free( cache_entry->kstr.bv_val );
+                       free( cache_entry->idl );
+                       free( cache_entry );
+               }
+       }
+       ldap_pvt_thread_rdwr_wunlock( &bdb->bi_idl_tree_rwlock );
+}
+
 int
 bdb_idl_fetch_key(
        BackendDB       *be,
@@ -1254,7 +1327,7 @@ int bdb_idl_append_one( ID *ids, ID id )
  */
 int bdb_idl_append( ID *a, ID *b )
 {
-       ID ida, idb, tmp;
+       ID ida, idb, tmp, swap = 0;
 
        if ( BDB_IDL_IS_ZERO( b ) ) {
                return 0;
@@ -1276,6 +1349,7 @@ int bdb_idl_append( ID *a, ID *b )
        }
 
        if ( b[0] > 1 && ida > idb ) {
+               swap = idb;
                a[a[0]] = idb;
                b[b[0]] = ida;
        }
@@ -1294,10 +1368,13 @@ int bdb_idl_append( ID *a, ID *b )
                AC_MEMCPY(a+a[0]+1, b+2, i * sizeof(ID));
                a[0] += i;
        }
+       if ( swap ) {
+               b[b[0]] = swap;
+       }
        return 0;
 }
 
-#if 0
+#if 1
 
 /* Quicksort + Insertion sort for small arrays */
 
@@ -1387,7 +1464,8 @@ void
 bdb_idl_sort( ID *ids, ID *tmp )
 {
        int count, soft_limit, phase = 0, size = ids[0];
-       ID *idls[2], mask, maxval = ids[size];
+       ID *idls[2];
+       unsigned char *maxv = (unsigned char *)&ids[size];
 
        if ( BDB_IDL_IS_RANGE( ids ))
                return;
@@ -1412,17 +1490,15 @@ bdb_idl_sort( ID *ids, ID *tmp )
        idls[0] = ids;
        idls[1] = tmp;
 
-       soft_limit = sizeof(ID) - 1;
-       mask = (ID)0xff << (sizeof(ID) - 1) * 8;
-
-       while (!(maxval & mask)) {
-               soft_limit--;
-               mask >>= 8;
-       }
+#if BYTE_ORDER == BIG_ENDIAN
+    for (soft_limit = 0; !maxv[soft_limit]; soft_limit++);
+#else
+    for (soft_limit = sizeof(ID)-1; !maxv[soft_limit]; soft_limit--);
+#endif
 
        for (
 #if BYTE_ORDER == BIG_ENDIAN
-       count = soft_limit; count >= 0; --count
+       count = sizeof(ID)-1; count >= soft_limit; --count
 #else
        count = 0; count <= soft_limit; ++count
 #endif