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