git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb2/dn2id.c

   1 /* dn2id.c - routines to deal with the dn2id index */
   2 /* $OpenLDAP$ */
   3
   4 #include "portable.h"
   5
   6 #include <stdio.h>
   7
   8 #include <ac/string.h>
   9 #include <ac/socket.h>
  10
  11 #include "slap.h"
  12 #include "back-bdb2.h"
  13 #include "proto-back-bdb2.h"
  14
  15 int
  16 bdb2i_dn2id_add(
  17     BackendDB   *be,
  18     const char  *dn,
  19     ID          id
  20 )
  21 {
  22         int             rc, flags;
  23         struct dbcache  *db;
  24         Datum           key, data;
  25         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  26
  27         Debug( LDAP_DEBUG_TRACE, "=> bdb2i_dn2id_add( \"%s\", %ld )\n", dn, id, 0 );
  28
  29         if ( (db = bdb2i_cache_open( be, "dn2id", BDB2_SUFFIX, LDBM_WRCREAT ))
  30             == NULL ) {
  31                 Debug( LDAP_DEBUG_ANY, "Could not open/create dn2id%s\n",
  32                     BDB2_SUFFIX, 0, 0 );
  33                 return( -1 );
  34         }
  35
  36         ldbm_datum_init( key );
  37         key.dsize = strlen( dn ) + 2;
  38         key.dptr = ch_malloc( key.dsize );
  39         sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
  40
  41         ldbm_datum_init( data );
  42         data.dptr = (char *) &id;
  43         data.dsize = sizeof(ID);
  44
  45         flags = LDBM_INSERT;
  46         rc = bdb2i_cache_store( db, key, data, flags );
  47
  48         free( key.dptr );
  49
  50         if ( rc != -1 ) {
  51                 char *pdn = dn_parent( NULL, dn );
  52
  53                 if( pdn != NULL ) {
  54                         ldbm_datum_init( key );
  55                         key.dsize = strlen( pdn ) + 2;
  56                         key.dptr = ch_malloc( key.dsize );
  57                         sprintf( key.dptr, "%c%s", DN_ONE_PREFIX, pdn );
  58                         rc = bdb2i_idl_insert_key( be, db, key, id );
  59                         free( key.dptr );
  60                         free( pdn );
  61                 }
  62         }
  63
  64         if ( rc != -1 ) {
  65                 char **subtree = dn_subtree( NULL, dn );
  66
  67                 if( subtree != NULL ) {
  68                         int i;
  69                         for( i=0; subtree[i] != NULL; i++ ) {
  70                                 ldbm_datum_init( key );
  71                                 key.dsize = strlen( subtree[i] ) + 2;
  72                                 key.dptr = ch_malloc( key.dsize );
  73                                 sprintf( key.dptr, "%c%s", DN_SUBTREE_PREFIX, subtree[i] );
  74
  75                                 rc = bdb2i_idl_insert_key( be, db, key, id );
  76
  77                                 free( key.dptr );
  78                         }
  79
  80                         charray_free( subtree );
  81                 }
  82         }
  83
  84         bdb2i_cache_close( be, db );
  85
  86         Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id_add %d\n", rc, 0, 0 );
  87         return( rc );
  88 }
  89
  90 ID
  91 bdb2i_dn2id(
  92     BackendDB   *be,
  93     const char  *dn
  94 )
  95 {
  96         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  97         struct dbcache  *db;
  98         ID              id;
  99         Datum           key, data;
 100
 101         Debug( LDAP_DEBUG_TRACE, "=> bdb2i_dn2id( \"%s\" )\n", dn, 0, 0 );
 102
 103         /* first check the cache */
 104         if ( (id = bdb2i_cache_find_entry_dn2id( be, &li->li_cache, dn )) != NOID ) {
 105                 Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id %ld (in cache)\n", id,
 106                         0, 0 );
 107                 return( id );
 108         }
 109
 110         if ( (db = bdb2i_cache_open( be, "dn2id", BDB2_SUFFIX, LDBM_WRCREAT ))
 111                 == NULL ) {
 112                 Debug( LDAP_DEBUG_ANY, "<= bdb2i_dn2id could not open dn2id%s\n",
 113                         BDB2_SUFFIX, 0, 0 );
 114                 return( NOID );
 115         }
 116
 117         ldbm_datum_init( key );
 118
 119         key.dsize = strlen( dn ) + 2;
 120         key.dptr = ch_malloc( key.dsize );
 121         sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
 122
 123         data = bdb2i_cache_fetch( db, key );
 124
 125         bdb2i_cache_close( be, db );
 126
 127         free( key.dptr );
 128
 129         if ( data.dptr == NULL ) {
 130                 Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id NOID\n", 0, 0, 0 );
 131                 return( NOID );
 132         }
 133
 134         (void) memcpy( (char *) &id, data.dptr, sizeof(ID) );
 135
 136         ldbm_datum_free( db->dbc_db, data );
 137
 138         Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id %ld\n", id, 0, 0 );
 139         return( id );
 140 }
 141
 142 ID_BLOCK *
 143 bdb2i_dn2idl(
 144     BackendDB   *be,
 145     const char  *dn,
 146         int     prefix )
 147 {
 148         struct dbcache  *db;
 149         Datum key;
 150         ID_BLOCK *idl;
 151
 152         Debug( LDAP_DEBUG_TRACE, "=> bdb2i_dn2idl( \"%c%s\" )\n", prefix, dn, 0 );
 153
 154         if ( (db = bdb2i_cache_open( be, "dn2id", BDB2_SUFFIX, LDBM_WRCREAT ))
 155             == NULL ) {
 156                 Debug( LDAP_DEBUG_ANY,
 157                     "<= bdb2i_dn2idl could not open dn2id%s\n", BDB2_SUFFIX,
 158                     0, 0 );
 159                 return( NULL );
 160         }
 161
 162         ldbm_datum_init( key );
 163
 164         key.dsize = strlen( dn ) + 2;
 165         key.dptr = ch_malloc( key.dsize );
 166         sprintf( key.dptr, "%c%s", prefix, dn );
 167
 168         idl = bdb2i_idl_fetch( be, db, key );
 169
 170         free( key.dptr );
 171
 172         bdb2i_cache_close( be, db );
 173
 174         return( idl );
 175 }
 176
 177 int
 178 bdb2i_dn2id_delete(
 179     BackendDB   *be,
 180     const char  *dn,
 181         ID id
 182 )
 183 {
 184         struct dbcache  *db;
 185         Datum           key;
 186         int             rc;
 187
 188         Debug( LDAP_DEBUG_TRACE, "=> bdb2i_dn2id_delete( \"%s\", %ld )\n",
 189                 dn, id, 0 );
 190
 191         if ( (db = bdb2i_cache_open( be, "dn2id", BDB2_SUFFIX, LDBM_WRCREAT ))
 192             == NULL ) {
 193                 Debug( LDAP_DEBUG_ANY,
 194                     "<= bdb2i_dn2id_delete could not open dn2id%s\n", BDB2_SUFFIX,
 195                     0, 0 );
 196                 return( -1 );
 197         }
 198
 199         {
 200                 char *pdn = dn_parent( NULL, dn );
 201
 202                 if( pdn != NULL ) {
 203                         ldbm_datum_init( key );
 204                         key.dsize = strlen( pdn ) + 2;
 205                         key.dptr = ch_malloc( key.dsize );
 206                         sprintf( key.dptr, "%c%s", DN_ONE_PREFIX, pdn );
 207                         (void) bdb2i_idl_delete_key( be, db, key, id );
 208                         free( key.dptr );
 209                         free( pdn );
 210                 }
 211         }
 212
 213         {
 214                 char **subtree = dn_subtree( NULL, dn );
 215
 216                 if( subtree != NULL ) {
 217                         int i;
 218                         for( i=0; subtree[i] != NULL; i++ ) {
 219                                 ldbm_datum_init( key );
 220                                 key.dsize = strlen( subtree[i] ) + 2;
 221                                 key.dptr = ch_malloc( key.dsize );
 222                                 sprintf( key.dptr, "%c%s", DN_SUBTREE_PREFIX, subtree[i] );
 223
 224                                 (void) bdb2i_idl_delete_key( be, db, key, id );
 225
 226                                 free( key.dptr );
 227                         }
 228
 229                         charray_free( subtree );
 230                 }
 231         }
 232
 233         ldbm_datum_init( key );
 234
 235         key.dsize = strlen( dn ) + 2;
 236         key.dptr = ch_malloc( key.dsize );
 237         sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
 238
 239         rc = bdb2i_cache_delete( db, key );
 240
 241         free( key.dptr );
 242
 243         bdb2i_cache_close( be, db );
 244
 245         Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id_delete %d\n", rc, 0, 0 );
 246         return( rc );
 247 }
 248
 249 /*
 250  * dn2entry - look up dn in the cache/indexes and return the corresponding
 251  * entry.
 252  */
 253
 254 Entry *
 255 bdb2i_dn2entry_rw(
 256     BackendDB   *be,
 257     const char  *dn,
 258     Entry       **matched,
 259     int         rw
 260 )
 261 {
 262         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 263         ID              id;
 264         Entry           *e = NULL;
 265         char            *pdn;
 266
 267         Debug(LDAP_DEBUG_TRACE, "dn2entry_%s: dn: \"%s\"\n",
 268                 rw ? "w" : "r", dn, 0);
 269
 270         if( matched != NULL ) {
 271                 /* caller cares about match */
 272                 *matched = NULL;
 273         }
 274
 275         if ( (id = bdb2i_dn2id( be, dn )) != NOID &&
 276                 (e = bdb2i_id2entry_rw( be, id, rw )) != NULL )
 277         {
 278                 return( e );
 279         }
 280
 281         if ( id != NOID ) {
 282                 Debug(LDAP_DEBUG_ANY,
 283                         "dn2entry_%s: no entry for valid id (%ld), dn \"%s\"\n",
 284                         rw ? "w" : "r", id, dn);
 285                 /* must have been deleted from underneath us */
 286                 /* treat as if NOID was found */
 287         }
 288
 289         /* caller doesn't care about match */
 290         if( matched == NULL ) return NULL;
 291
 292         /* entry does not exist - see how much of the dn does exist */
 293         /* dn_parent checks returns NULL if dn is suffix */
 294         if ( (pdn = dn_parent( be, dn )) != NULL ) {
 295                 /* get entry with reader lock */
 296                 if ( (e = bdb2i_dn2entry_r( be, pdn, matched )) != NULL ) {
 297                         *matched = e;
 298                 }
 299                 free( pdn );
 300         }
 301
 302         return( NULL );
 303 }
 304
 305