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

   1 /* dn2id.c - routines to deal with the dn2id index */
   2
   3 #include "portable.h"
   4
   5 #include <stdio.h>
   6
   7 #include <ac/string.h>
   8 #include <ac/socket.h>
   9
  10 #include "slap.h"
  11 #include "back-ldbm.h"
  12 #include "proto-back-ldbm.h"
  13
  14 extern struct dbcache   *ldbm_cache_open();
  15 extern char             *dn_parent();
  16 extern Datum            ldbm_cache_fetch();
  17
  18 int
  19 dn2id_add(
  20     Backend     *be,
  21     char        *dn,
  22     ID          id
  23 )
  24 {
  25         int             rc, flags;
  26         struct dbcache  *db;
  27         Datum           key, data;
  28         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  29
  30 #ifdef HAVE_BERKELEY_DB2
  31         memset( &key, 0, sizeof( key ) );
  32         memset( &data, 0, sizeof( data ) );
  33 #endif
  34
  35         Debug( LDAP_DEBUG_TRACE, "=> dn2id_add( \"%s\", %ld )\n", dn, id, 0 );
  36
  37         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
  38             == NULL ) {
  39                 Debug( LDAP_DEBUG_ANY, "Could not open/create dn2id%s\n",
  40                     LDBM_SUFFIX, 0, 0 );
  41                 return( -1 );
  42         }
  43
  44         dn = strdup( dn );
  45         dn_normalize_case( dn );
  46
  47         key.dptr = dn;
  48         key.dsize = strlen( dn ) + 1;
  49         data.dptr = (char *) &id;
  50         data.dsize = sizeof(ID);
  51
  52         flags = LDBM_INSERT;
  53         if ( li->li_dbcachewsync ) flags |= LDBM_SYNC;
  54
  55         rc = ldbm_cache_store( db, key, data, flags );
  56
  57         free( dn );
  58         ldbm_cache_close( be, db );
  59
  60         Debug( LDAP_DEBUG_TRACE, "<= dn2id_add %d\n", rc, 0, 0 );
  61         return( rc );
  62 }
  63
  64 ID
  65 dn2id(
  66     Backend     *be,
  67     char        *dn
  68 )
  69 {
  70         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  71         struct dbcache  *db;
  72         ID              id;
  73         Datum           key, data;
  74
  75 #ifdef HAVE_BERKELEY_DB2
  76         memset( &key, 0, sizeof( key ) );
  77         memset( &data, 0, sizeof( data ) );
  78 #endif
  79
  80         dn = strdup( dn );
  81         Debug( LDAP_DEBUG_TRACE, "=> dn2id( \"%s\" )\n", dn, 0, 0 );
  82         dn_normalize_case( dn );
  83
  84         /* first check the cache */
  85         if ( (id = cache_find_entry_dn2id( be, &li->li_cache, dn )) != NOID ) {
  86                 free( dn );
  87                 Debug( LDAP_DEBUG_TRACE, "<= dn2id %d (in cache)\n", id,
  88                         0, 0 );
  89                 return( id );
  90         }
  91
  92         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
  93                 == NULL ) {
  94                 free( dn );
  95                 Debug( LDAP_DEBUG_ANY, "<= dn2id could not open dn2id%s\n",
  96                         LDBM_SUFFIX, 0, 0 );
  97                 return( NOID );
  98         }
  99
 100         key.dptr = dn;
 101         key.dsize = strlen( dn ) + 1;
 102
 103         data = ldbm_cache_fetch( db, key );
 104
 105         ldbm_cache_close( be, db );
 106         free( dn );
 107
 108         if ( data.dptr == NULL ) {
 109                 Debug( LDAP_DEBUG_TRACE, "<= dn2id NOID\n", 0, 0, 0 );
 110                 return( NOID );
 111         }
 112
 113         (void) memcpy( (char *) &id, data.dptr, sizeof(ID) );
 114
 115         ldbm_datum_free( db->dbc_db, data );
 116
 117         Debug( LDAP_DEBUG_TRACE, "<= dn2id %d\n", id, 0, 0 );
 118         return( id );
 119 }
 120
 121 int
 122 dn2id_delete(
 123     Backend     *be,
 124     char        *dn
 125 )
 126 {
 127         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 128         struct dbcache  *db;
 129         Datum           key;
 130         int             rc;
 131
 132 #ifdef HAVE_BERKELEY_DB2
 133         memset( &key, 0, sizeof( key ) );
 134 #endif
 135
 136         Debug( LDAP_DEBUG_TRACE, "=> dn2id_delete( \"%s\" )\n", dn, 0, 0 );
 137
 138         if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
 139             == NULL ) {
 140                 Debug( LDAP_DEBUG_ANY,
 141                     "<= dn2id_delete could not open dn2id%s\n", LDBM_SUFFIX,
 142                     0, 0 );
 143                 return( -1 );
 144         }
 145
 146         dn_normalize_case( dn );
 147         key.dptr = dn;
 148         key.dsize = strlen( dn ) + 1;
 149
 150         rc = ldbm_cache_delete( db, key );
 151
 152         ldbm_cache_close( be, db );
 153
 154         Debug( LDAP_DEBUG_TRACE, "<= dn2id_delete %d\n", rc, 0, 0 );
 155         return( rc );
 156 }
 157
 158 /*
 159  * dn2entry - look up dn in the cache/indexes and return the corresponding
 160  * entry.
 161  */
 162
 163 static Entry *
 164 dn2entry(
 165     Backend     *be,
 166     char        *dn,
 167     char        **matched,
 168     int         rw
 169 )
 170 {
 171         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 172         ID              id;
 173         Entry           *e;
 174         char            *pdn;
 175
 176         Debug(LDAP_DEBUG_TRACE, "dn2entry_%s: dn: %s\n",
 177                 rw ? "w" : "r", dn, 0);
 178
 179         if ( (id = dn2id( be, dn )) != NOID &&
 180                 (e = id2entry( be, id, rw )) != NULL )
 181         {
 182                 return( e );
 183         }
 184         *matched = NULL;
 185
 186         /* stop when we get to the suffix */
 187         if ( be_issuffix( be, dn ) ) {
 188                 return( NULL );
 189         }
 190
 191         /* entry does not exist - see how much of the dn does exist */
 192         if ( (pdn = dn_parent( be, dn )) != NULL ) {
 193                 /* get entry with reader lock */
 194                 if ( (e = dn2entry_r( be, pdn, matched )) != NULL ) {
 195                         *matched = pdn;
 196                         /* free entry with reader lock */
 197                         cache_return_entry_r( &li->li_cache, e );
 198                 } else {
 199                         free( pdn );
 200                 }
 201         }
 202
 203         return( NULL );
 204 }
 205
 206 #if 0
 207                 if (e->e_state == ENTRY_STATE_DELETED)
 208                         continue;
 209
 210                 if (strcmp(dn, e->e_dn) != 0)
 211                         continue;
 212
 213                 /* return locked entry entry */
 214                 return(e);
 215         }
 216 }
 217 #endif
 218
 219 Entry *
 220 dn2entry_r(
 221         Backend *be,
 222         char    *dn,
 223         char    **matched
 224 )
 225 {
 226         return( dn2entry( be, dn, matched, 0 ) );
 227 }
 228
 229 Entry *
 230 dn2entry_w(
 231         Backend *be,
 232         char    *dn,
 233         char    **matched
 234 )
 235 {
 236         return( dn2entry( be, dn, matched, 1 ) );
 237 }
 238
 239
 240