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

   1 /* dn2id.c - routines to deal with the dn2id index */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/string.h>
  13 #include <ac/socket.h>
  14
  15 #include "slap.h"
  16 #include "back-ldbm.h"
  17 #include "proto-back-ldbm.h"
  18
  19 int
  20 dn2id_add(
  21     Backend     *be,
  22     const char  *dn,
  23     ID          id
  24 )
  25 {
  26         int             rc, flags;
  27         DBCache *db;
  28         Datum           key, data;
  29
  30 #ifdef NEW_LOGGING
  31         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
  32                    "dn2id_add: (%s):%ld\n", dn, id ));
  33 #else
  34         Debug( LDAP_DEBUG_TRACE, "=> dn2id_add( \"%s\", %ld )\n", dn, id, 0 );
  35 #endif
  36
  37         assert( id != NOID );
  38
  39         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
  40             == NULL ) {
  41 #ifdef NEW_LOGGING
  42                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
  43                            "dn2id_add: couldn't open/create dn2id%s\n", LDBM_SUFFIX ));
  44 #else
  45                 Debug( LDAP_DEBUG_ANY, "Could not open/create dn2id%s\n",
  46                     LDBM_SUFFIX, 0, 0 );
  47 #endif
  48
  49                 return( -1 );
  50         }
  51
  52         ldbm_datum_init( key );
  53         key.dsize = strlen( dn ) + 2;
  54         key.dptr = ch_malloc( key.dsize );
  55         sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
  56
  57         ldbm_datum_init( data );
  58         data.dptr = (char *) &id;
  59         data.dsize = sizeof(ID);
  60
  61         flags = LDBM_INSERT;
  62         rc = ldbm_cache_store( db, key, data, flags );
  63
  64         free( key.dptr );
  65
  66         if ( rc != -1 ) {
  67                 char *pdn = dn_parent( NULL, dn );
  68
  69                 if( pdn != NULL ) {
  70                         ldbm_datum_init( key );
  71                         key.dsize = strlen( pdn ) + 2;
  72                         key.dptr = ch_malloc( key.dsize );
  73                         sprintf( key.dptr, "%c%s", DN_ONE_PREFIX, pdn );
  74                         ldap_pvt_thread_mutex_lock( &db->dbc_write_mutex );
  75                         rc = idl_insert_key( be, db, key, id );
  76                         ldap_pvt_thread_mutex_unlock( &db->dbc_write_mutex );
  77                         free( key.dptr );
  78                         free( pdn );
  79                 }
  80         }
  81
  82         if ( rc != -1 ) {
  83                 char **subtree = dn_subtree( be, dn );
  84
  85                 if( subtree != NULL ) {
  86                         int i;
  87                         for( i=0; subtree[i] != NULL; i++ ) {
  88                                 ldbm_datum_init( key );
  89                                 key.dsize = strlen( subtree[i] ) + 2;
  90                                 key.dptr = ch_malloc( key.dsize );
  91                                 sprintf( key.dptr, "%c%s",
  92                                         DN_SUBTREE_PREFIX, subtree[i] );
  93                                 ldap_pvt_thread_mutex_lock( &db->dbc_write_mutex );
  94                                 rc = idl_insert_key( be, db, key, id );
  95                                 ldap_pvt_thread_mutex_unlock( &db->dbc_write_mutex );
  96                                 free( key.dptr );
  97
  98                                 if(rc == -1) break;
  99                         }
 100
 101                         charray_free( subtree );
 102                 }
 103         }
 104
 105         ldbm_cache_close( be, db );
 106
 107 #ifdef NEW_LOGGING
 108         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 109                    "dn2id_add: return %d\n", rc ));
 110 #else
 111         Debug( LDAP_DEBUG_TRACE, "<= dn2id_add %d\n", rc, 0, 0 );
 112 #endif
 113
 114         return( rc );
 115 }
 116
 117 int
 118 dn2id(
 119     Backend     *be,
 120     const char  *dn,
 121     ID          *idp
 122 )
 123 {
 124         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 125         DBCache *db;
 126         Datum           key, data;
 127
 128 #ifdef NEW_LOGGING
 129         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 130                    "dn2id: (%s)\n", dn ));
 131 #else
 132         Debug( LDAP_DEBUG_TRACE, "=> dn2id( \"%s\" )\n", dn, 0, 0 );
 133 #endif
 134
 135         assert( idp );
 136
 137         /* first check the cache */
 138         if ( (*idp = cache_find_entry_ndn2id( be, &li->li_cache, dn )) != NOID ) {
 139 #ifdef NEW_LOGGING
 140                 LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
 141                            "dn2id: (%s)%ld in cache.\n", dn, *idp ));
 142 #else
 143                 Debug( LDAP_DEBUG_TRACE, "<= dn2id %ld (in cache)\n", *idp,
 144                         0, 0 );
 145 #endif
 146
 147                 return( 0 );
 148         }
 149
 150         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
 151                 == NULL ) {
 152 #ifdef NEW_LOGGING
 153                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
 154                            "dn2id: couldn't open dn2id%s\n", LDBM_SUFFIX ));
 155 #else
 156                 Debug( LDAP_DEBUG_ANY, "<= dn2id could not open dn2id%s\n",
 157                         LDBM_SUFFIX, 0, 0 );
 158 #endif
 159                 /*
 160                  * return code !0 if ldbm cache open failed;
 161                  * callers should handle this
 162                  */
 163                 *idp = NOID;
 164                 return( -1 );
 165         }
 166
 167         ldbm_datum_init( key );
 168
 169         key.dsize = strlen( dn ) + 2;
 170         key.dptr = ch_malloc( key.dsize );
 171         sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
 172
 173         data = ldbm_cache_fetch( db, key );
 174
 175         ldbm_cache_close( be, db );
 176
 177         free( key.dptr );
 178
 179         if ( data.dptr == NULL ) {
 180 #ifdef NEW_LOGGING
 181                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
 182                            "dn2id: (%s) NOID\n", dn ));
 183 #else
 184                 Debug( LDAP_DEBUG_TRACE, "<= dn2id NOID\n", 0, 0, 0 );
 185 #endif
 186
 187                 *idp = NOID;
 188                 return( 0 );
 189         }
 190
 191         AC_MEMCPY( (char *) idp, data.dptr, sizeof(ID) );
 192
 193         assert( *idp != NOID );
 194
 195         ldbm_datum_free( db->dbc_db, data );
 196
 197 #ifdef NEW_LOGGING
 198         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 199                    "dn2id: %ld\n", *idp ));
 200 #else
 201         Debug( LDAP_DEBUG_TRACE, "<= dn2id %ld\n", *idp, 0, 0 );
 202 #endif
 203
 204         return( 0 );
 205 }
 206
 207 int
 208 dn2idl(
 209     Backend     *be,
 210     const char  *dn,
 211     int         prefix,
 212     ID_BLOCK    **idlp
 213 )
 214 {
 215         DBCache *db;
 216         Datum           key;
 217
 218 #ifdef NEW_LOGGING
 219         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 220                    "dn2idl: \"%c%s\"\n", prefix, dn ));
 221 #else
 222         Debug( LDAP_DEBUG_TRACE, "=> dn2idl( \"%c%s\" )\n", prefix, dn, 0 );
 223 #endif
 224
 225         assert( idlp != NULL );
 226         *idlp = NULL;
 227
 228         if ( prefix == DN_SUBTREE_PREFIX && be_issuffix(be, dn) ) {
 229                 *idlp = ch_malloc( sizeof(ID) );
 230                 **idlp = ID_BLOCK_ALLIDS_VALUE;
 231                 return 0;
 232         }
 233
 234         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
 235                 == NULL ) {
 236 #ifdef NEW_LOGGING
 237                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
 238                            "dn2idl: could not open dn2id%s\n", LDBM_SUFFIX ));
 239 #else
 240                 Debug( LDAP_DEBUG_ANY, "<= dn2idl could not open dn2id%s\n",
 241                         LDBM_SUFFIX, 0, 0 );
 242 #endif
 243
 244                 return -1;
 245         }
 246
 247         ldbm_datum_init( key );
 248
 249         key.dsize = strlen( dn ) + 2;
 250         key.dptr = ch_malloc( key.dsize );
 251         sprintf( key.dptr, "%c%s", prefix, dn );
 252
 253         *idlp = idl_fetch( be, db, key );
 254
 255         ldbm_cache_close( be, db );
 256
 257         free( key.dptr );
 258
 259         return( 0 );
 260 }
 261
 262
 263 int
 264 dn2id_delete(
 265     Backend     *be,
 266     const char  *dn,
 267         ID id
 268 )
 269 {
 270         DBCache *db;
 271         Datum           key;
 272         int             rc;
 273
 274 #ifdef NEW_LOGGING
 275         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 276                    "dn2id_delete: (%s)%ld\n", dn, id ));
 277 #else
 278         Debug( LDAP_DEBUG_TRACE, "=> dn2id_delete( \"%s\", %ld )\n", dn, id, 0 );
 279 #endif
 280
 281
 282         assert( id != NOID );
 283
 284         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
 285             == NULL ) {
 286 #ifdef NEW_LOGGING
 287                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
 288                            "dn2id_delete: couldn't open db2id%s\n", LDBM_SUFFIX ));
 289 #else
 290                 Debug( LDAP_DEBUG_ANY,
 291                     "<= dn2id_delete could not open dn2id%s\n", LDBM_SUFFIX,
 292                     0, 0 );
 293 #endif
 294
 295                 return( -1 );
 296         }
 297
 298
 299         {
 300                 char *pdn = dn_parent( NULL, dn );
 301
 302                 if( pdn != NULL ) {
 303                         ldbm_datum_init( key );
 304                         key.dsize = strlen( pdn ) + 2;
 305                         key.dptr = ch_malloc( key.dsize );
 306                         sprintf( key.dptr, "%c%s", DN_ONE_PREFIX, pdn );
 307
 308                         ldap_pvt_thread_mutex_lock( &db->dbc_write_mutex );
 309                         (void) idl_delete_key( be, db, key, id );
 310                         ldap_pvt_thread_mutex_unlock( &db->dbc_write_mutex );
 311
 312                         free( key.dptr );
 313                         free( pdn );
 314                 }
 315         }
 316
 317         {
 318                 char **subtree = dn_subtree( be, dn );
 319
 320                 if( subtree != NULL ) {
 321                         int i;
 322                         for( i=0; subtree[i] != NULL; i++ ) {
 323                                 ldbm_datum_init( key );
 324                                 key.dsize = strlen( subtree[i] ) + 2;
 325                                 key.dptr = ch_malloc( key.dsize );
 326                                 sprintf( key.dptr, "%c%s",
 327                                         DN_SUBTREE_PREFIX, subtree[i] );
 328
 329                                 ldap_pvt_thread_mutex_lock( &db->dbc_write_mutex );
 330                                 (void) idl_delete_key( be, db, key, id );
 331                                 ldap_pvt_thread_mutex_unlock( &db->dbc_write_mutex );
 332
 333                                 free( key.dptr );
 334                         }
 335
 336                         charray_free( subtree );
 337                 }
 338         }
 339
 340         ldbm_datum_init( key );
 341
 342         key.dsize = strlen( dn ) + 2;
 343         key.dptr = ch_malloc( key.dsize );
 344         sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
 345
 346         rc = ldbm_cache_delete( db, key );
 347
 348         free( key.dptr );
 349
 350         ldbm_cache_close( be, db );
 351
 352 #ifdef NEW_LOGGING
 353         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 354                    "dn2id_delete: return %d\n", rc ));
 355 #else
 356         Debug( LDAP_DEBUG_TRACE, "<= dn2id_delete %d\n", rc, 0, 0 );
 357 #endif
 358
 359         return( rc );
 360 }
 361
 362 /*
 363  * dn2entry - look up dn in the cache/indexes and return the corresponding
 364  * entry.
 365  */
 366
 367 Entry *
 368 dn2entry_rw(
 369     Backend     *be,
 370     const char  *dn,
 371     Entry       **matched,
 372     int         rw
 373 )
 374 {
 375         ID              id;
 376         Entry           *e = NULL;
 377         char            *pdn;
 378
 379 #ifdef NEW_LOGGING
 380         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 381                    "dn2entry_rw: %s entry %s\n", rw ? "w" : "r",
 382                    dn ));
 383 #else
 384         Debug(LDAP_DEBUG_TRACE, "dn2entry_%s: dn: \"%s\"\n",
 385                 rw ? "w" : "r", dn, 0);
 386 #endif
 387
 388
 389         if( matched != NULL ) {
 390                 /* caller cares about match */
 391                 *matched = NULL;
 392         }
 393
 394         if ( dn2id( be, dn, &id ) ) {
 395                 /* something bad happened to ldbm cache */
 396                 return( NULL );
 397
 398         } else if ( id != NOID ) {
 399                 /* try to return the entry */
 400                 if ((e = id2entry_rw( be, id, rw )) != NULL ) {
 401                         return( e );
 402                 }
 403
 404 #ifdef NEW_LOGGING
 405                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
 406                            "dn2entry_rw: no entry for valid id (%ld), dn (%s)\n",
 407                            id, dn ));
 408 #else
 409                 Debug(LDAP_DEBUG_ANY,
 410                         "dn2entry_%s: no entry for valid id (%ld), dn \"%s\"\n",
 411                         rw ? "w" : "r", id, dn);
 412 #endif
 413
 414                 /* must have been deleted from underneath us */
 415                 /* treat as if NOID was found */
 416         }
 417
 418         /* caller doesn't care about match */
 419         if( matched == NULL ) return NULL;
 420
 421         /* entry does not exist - see how much of the dn does exist */
 422         /* dn_parent checks returns NULL if dn is suffix */
 423         if ( (pdn = dn_parent( be, dn )) != NULL ) {
 424                 /* get entry with reader lock */
 425                 if ( (e = dn2entry_r( be, pdn, matched )) != NULL ) {
 426                         *matched = e;
 427                 }
 428                 free( pdn );
 429         }
 430
 431         return NULL;
 432 }
 433