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