git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb2/tools.c

   1 /* tools.c - tools for slap tools */
   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-bdb2.h"
  17
  18 static LDBMCursor *cursorp = NULL;
  19 static DBCache *id2entry = NULL;
  20
  21 int bdb2_tool_entry_open(
  22         BackendDB *be, int mode )
  23 {
  24         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  25         int flags;
  26
  27         assert( slapMode & SLAP_TOOL_MODE );
  28         assert( id2entry == NULL );
  29
  30         switch( mode ) {
  31         case 1:
  32                 flags = LDBM_WRCREAT;
  33                 break;
  34         case 2:
  35 #ifdef TRUNCATE_MODE
  36                 flags = LDBM_NEWDB;
  37 #else
  38                 flags = LDBM_WRCREAT;
  39 #endif
  40                 break;
  41         default:
  42                 flags = LDBM_READER;
  43         }
  44
  45         if ( (id2entry = bdb2i_cache_open( be, "id2entry", BDB2_SUFFIX, flags ))
  46             == NULL ) {
  47                 Debug( LDAP_DEBUG_ANY, "Could not open/create id2entry" BDB2_SUFFIX "\n",
  48                     0, 0, 0 );
  49                 return( -1 );
  50         }
  51
  52         return 0;
  53 }
  54
  55 int bdb2_tool_entry_close(
  56         BackendDB *be )
  57 {
  58         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  59
  60         assert( slapMode & SLAP_TOOL_MODE );
  61         assert( id2entry != NULL );
  62
  63         bdb2i_cache_close( be, id2entry );
  64         id2entry = NULL;
  65
  66         return 0;
  67 }
  68
  69 ID bdb2_tool_entry_first(
  70         BackendDB *be )
  71 {
  72         Datum key;
  73         ID id;
  74
  75         assert( slapMode & SLAP_TOOL_MODE );
  76         assert( id2entry != NULL );
  77
  78         key = ldbm_firstkey( id2entry->dbc_db, &cursorp );
  79
  80         if( key.dptr == NULL ) {
  81                 return NOID;
  82         }
  83
  84         memcpy( &id, key.dptr, key.dsize );
  85
  86         ldbm_datum_free( id2entry->dbc_db, key );
  87
  88         return id;
  89 }
  90
  91 ID bdb2_tool_entry_next(
  92         BackendDB *be )
  93 {
  94         Datum key;
  95         ID id;
  96
  97         assert( slapMode & SLAP_TOOL_MODE );
  98         assert( id2entry != NULL );
  99
 100         /* allow for NEXTID */
 101         ldbm_datum_init( key );
 102
 103         key = ldbm_nextkey( id2entry->dbc_db, key, cursorp );
 104
 105         if( key.dptr == NULL ) {
 106                 return NOID;
 107         }
 108
 109         memcpy( &id, key.dptr, key.dsize );
 110
 111         ldbm_datum_free( id2entry->dbc_db, key );
 112
 113         return id;
 114 }
 115
 116 Entry* bdb2_tool_entry_get( BackendDB *be, ID id )
 117 {
 118         Entry *e;
 119         Datum key, data;
 120         assert( slapMode & SLAP_TOOL_MODE );
 121         assert( id2entry != NULL );
 122
 123         ldbm_datum_init( key );
 124
 125         key.dptr = (char *) &id;
 126         key.dsize = sizeof(ID);
 127
 128         data = bdb2i_cache_fetch( id2entry, key );
 129
 130         if ( data.dptr == NULL ) {
 131                 return NULL;
 132         }
 133
 134         e = str2entry( data.dptr );
 135         ldbm_datum_free( id2entry->dbc_db, data );
 136
 137         return e;
 138 }
 139
 140 ID bdb2_tool_entry_put(
 141         BackendDB *be,
 142         Entry *e )
 143 {
 144         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 145         Datum key, data;
 146         int rc, len;
 147
 148         assert( slapMode & SLAP_TOOL_MODE );
 149         assert( id2entry != NULL );
 150
 151         if( bdb2i_next_id_get( be ) == NOID ) {
 152                 return NOID;
 153         }
 154
 155         e->e_id = li->li_nextid++;
 156
 157         Debug( LDAP_DEBUG_TRACE, "=> bdb2_tool_entry_put( %ld, \"%s\" )\n",
 158                 e->e_id, e->e_dn, 0 );
 159
 160         rc = bdb2i_index_add_entry( be, e );
 161
 162         if( rc != 0 ) {
 163                 return NOID;
 164         }
 165
 166         rc = bdb2i_dn2id_add( be, e->e_ndn, e->e_id );
 167
 168         if( rc != 0 ) {
 169                 return NOID;
 170         }
 171
 172         ldbm_datum_init( key );
 173         ldbm_datum_init( data );
 174
 175         key.dptr = (char *) &e->e_id;
 176         key.dsize = sizeof(ID);
 177
 178         data.dptr = entry2str( e, &len );
 179         data.dsize = len + 1;
 180
 181         /* store it */
 182         rc = bdb2i_cache_store( id2entry, key, data, LDBM_REPLACE );
 183
 184         if( rc != 0 ) {
 185                 (void) bdb2i_dn2id_delete( be, e->e_ndn, e->e_id );
 186                 return NOID;
 187         }
 188
 189         return e->e_id;
 190 }
 191
 192 int bdb2_tool_index_attr(
 193         BackendDB *be,
 194         char* type )
 195 {
 196         static DBCache *db = NULL;
 197         int indexmask, syntaxmask;
 198         char * at_cn;
 199
 200         assert( slapMode & SLAP_TOOL_MODE );
 201
 202         bdb2i_attr_masks( be->be_private, type, &indexmask, &syntaxmask );
 203
 204         attr_normalize( type );
 205         at_cn = at_canonical_name( type );
 206
 207         if ( (db = bdb2i_cache_open( be, at_cn, LDBM_SUFFIX, LDBM_NEWDB ))
 208             == NULL ) {
 209                 Debug( LDAP_DEBUG_ANY,
 210                     "<= index_read NULL (could not open %s%s)\n", at_cn,
 211                     BDB2_SUFFIX, 0 );
 212                 return 0;
 213         }
 214
 215         bdb2i_cache_close( be, db );
 216
 217         return indexmask != 0;
 218 }
 219
 220 int bdb2_tool_index_change(
 221         BackendDB *be,
 222         char* type,
 223         struct berval **bv,
 224         ID id,
 225         int op )
 226 {
 227         assert( slapMode & SLAP_TOOL_MODE );
 228
 229         bdb2i_index_add_values( be,
 230                 type, bv, id );
 231
 232         return 0;
 233 }
 234
 235 int bdb2_tool_sync( BackendDB *be )
 236 {
 237         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 238
 239         assert( slapMode & SLAP_TOOL_MODE );
 240
 241         if ( li->li_nextid != NOID ) {
 242                 bdb2i_next_id_save( be );
 243         }
 244
 245         return 0;
 246 }