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( NULL, 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 ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
 229                 == NULL ) {
 230 #ifdef NEW_LOGGING
 231                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
 232                            "dn2idl: could not open dn2id%s\n", LDBM_SUFFIX ));
 233 #else
 234                 Debug( LDAP_DEBUG_ANY, "<= dn2idl could not open dn2id%s\n",
 235                         LDBM_SUFFIX, 0, 0 );
 236 #endif
 237
 238                 return -1;
 239         }
 240
 241         ldbm_datum_init( key );
 242
 243         key.dsize = strlen( dn ) + 2;
 244         key.dptr = ch_malloc( key.dsize );
 245         sprintf( key.dptr, "%c%s", prefix, dn );
 246
 247         *idlp = idl_fetch( be, db, key );
 248
 249         ldbm_cache_close( be, db );
 250
 251         free( key.dptr );
 252
 253         return( 0 );
 254 }
 255
 256
 257 int
 258 dn2id_delete(
 259     Backend     *be,
 260     const char  *dn,
 261         ID id
 262 )
 263 {
 264         DBCache *db;
 265         Datum           key;
 266         int             rc;
 267
 268 #ifdef NEW_LOGGING
 269         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 270                    "dn2id_delete: (%s)%ld\n", dn, id ));
 271 #else
 272         Debug( LDAP_DEBUG_TRACE, "=> dn2id_delete( \"%s\", %ld )\n", dn, id, 0 );
 273 #endif
 274
 275
 276         assert( id != NOID );
 277
 278         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
 279             == NULL ) {
 280 #ifdef NEW_LOGGING
 281                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
 282                            "dn2id_delete: couldn't open db2id%s\n", LDBM_SUFFIX ));
 283 #else
 284                 Debug( LDAP_DEBUG_ANY,
 285                     "<= dn2id_delete could not open dn2id%s\n", LDBM_SUFFIX,
 286                     0, 0 );
 287 #endif
 288
 289                 return( -1 );
 290         }
 291
 292
 293         {
 294                 char *pdn = dn_parent( NULL, dn );
 295
 296                 if( pdn != NULL ) {
 297                         ldbm_datum_init( key );
 298                         key.dsize = strlen( pdn ) + 2;
 299                         key.dptr = ch_malloc( key.dsize );
 300                         sprintf( key.dptr, "%c%s", DN_ONE_PREFIX, pdn );
 301
 302                         ldap_pvt_thread_mutex_lock( &db->dbc_write_mutex );
 303                         (void) idl_delete_key( be, db, key, id );
 304                         ldap_pvt_thread_mutex_unlock( &db->dbc_write_mutex );
 305
 306                         free( key.dptr );
 307                         free( pdn );
 308                 }
 309         }
 310
 311         {
 312                 char **subtree = dn_subtree( NULL, dn );
 313
 314                 if( subtree != NULL ) {
 315                         int i;
 316                         for( i=0; subtree[i] != NULL; i++ ) {
 317                                 ldbm_datum_init( key );
 318                                 key.dsize = strlen( subtree[i] ) + 2;
 319                                 key.dptr = ch_malloc( key.dsize );
 320                                 sprintf( key.dptr, "%c%s",
 321                                         DN_SUBTREE_PREFIX, subtree[i] );
 322
 323                                 ldap_pvt_thread_mutex_lock( &db->dbc_write_mutex );
 324                                 (void) idl_delete_key( be, db, key, id );
 325                                 ldap_pvt_thread_mutex_unlock( &db->dbc_write_mutex );
 326
 327                                 free( key.dptr );
 328                         }
 329
 330                         charray_free( subtree );
 331                 }
 332         }
 333
 334         ldbm_datum_init( key );
 335
 336         key.dsize = strlen( dn ) + 2;
 337         key.dptr = ch_malloc( key.dsize );
 338         sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
 339
 340         rc = ldbm_cache_delete( db, key );
 341
 342         free( key.dptr );
 343
 344         ldbm_cache_close( be, db );
 345
 346 #ifdef NEW_LOGGING
 347         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 348                    "dn2id_delete: return %d\n", rc ));
 349 #else
 350         Debug( LDAP_DEBUG_TRACE, "<= dn2id_delete %d\n", rc, 0, 0 );
 351 #endif
 352
 353         return( rc );
 354 }
 355
 356 /*
 357  * dn2entry - look up dn in the cache/indexes and return the corresponding
 358  * entry.
 359  */
 360
 361 Entry *
 362 dn2entry_rw(
 363     Backend     *be,
 364     const char  *dn,
 365     Entry       **matched,
 366     int         rw
 367 )
 368 {
 369         ID              id;
 370         Entry           *e = NULL;
 371         char            *pdn;
 372
 373 #ifdef NEW_LOGGING
 374         LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
 375                    "dn2entry_rw: %s entry %s\n", rw ? "w" : "r",
 376                    dn ));
 377 #else
 378         Debug(LDAP_DEBUG_TRACE, "dn2entry_%s: dn: \"%s\"\n",
 379                 rw ? "w" : "r", dn, 0);
 380 #endif
 381
 382
 383         if( matched != NULL ) {
 384                 /* caller cares about match */
 385                 *matched = NULL;
 386         }
 387
 388         if ( dn2id( be, dn, &id ) ) {
 389                 /* something bad happened to ldbm cache */
 390                 return( NULL );
 391
 392         } else if ( id != NOID ) {
 393                 /* try to return the entry */
 394                 if ((e = id2entry_rw( be, id, rw )) != NULL ) {
 395                         return( e );
 396                 }
 397
 398 #ifdef NEW_LOGGING
 399                 LDAP_LOG(( "backend", LDAP_LEVEL_ERR,
 400                            "dn2entry_rw: no entry for valid id (%ld), dn (%s)\n",
 401                            id, dn ));
 402 #else
 403                 Debug(LDAP_DEBUG_ANY,
 404                         "dn2entry_%s: no entry for valid id (%ld), dn \"%s\"\n",
 405                         rw ? "w" : "r", id, dn);
 406 #endif
 407
 408                 /* must have been deleted from underneath us */
 409                 /* treat as if NOID was found */
 410         }
 411
 412         /* caller doesn't care about match */
 413         if( matched == NULL ) return NULL;
 414
 415         /* entry does not exist - see how much of the dn does exist */
 416         /* dn_parent checks returns NULL if dn is suffix */
 417         if ( (pdn = dn_parent( be, dn )) != NULL ) {
 418                 /* get entry with reader lock */
 419                 if ( (e = dn2entry_r( be, pdn, matched )) != NULL ) {
 420                         *matched = e;
 421                 }
 422                 free( pdn );
 423         }
 424
 425         return NULL;
 426 }
 427