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