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