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

   1 /* tools.c - tools for slap tools */
   2 /*
   3  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6
   7 #include "portable.h"
   8
   9 #include <stdio.h>
  10
  11 #include <ac/socket.h>
  12
  13 #include "slap.h"
  14 #include "back-ldbm.h"
  15
  16 static LDBMCursor *cursorp = NULL;
  17 static DBCache *id2entry = NULL;
  18
  19 int ldbm_tool_entry_open(
  20         BackendDB *be, int mode )
  21 {
  22         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  23         int flags;
  24
  25         assert( slapMode & SLAP_TOOL_MODE );
  26         assert( id2entry == NULL );
  27
  28         switch( mode ) {
  29         case 1:
  30                 flags = LDBM_WRCREAT;
  31                 break;
  32         case 2:
  33 #ifdef TRUNCATE_MODE
  34                 flags = LDBM_NEWDB;
  35 #else
  36                 flags = LDBM_WRCREAT;
  37 #endif
  38                 break;
  39         default:
  40                 flags = LDBM_READER;
  41         }
  42
  43         li->li_dbcachewsync = 0;
  44
  45         if ( (id2entry = ldbm_cache_open( be, "id2entry", LDBM_SUFFIX, flags ))
  46             == NULL ) {
  47                 Debug( LDAP_DEBUG_ANY, "Could not open/create id2entry" LDBM_SUFFIX "\n",
  48                     0, 0, 0 );
  49                 return( -1 );
  50         }
  51
  52         return 0;
  53 }
  54
  55 int ldbm_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         ldbm_cache_close( be, id2entry );
  64         li->li_dbcachewsync = 1;
  65         id2entry = NULL;
  66
  67         return 0;
  68 }
  69
  70 ID ldbm_tool_entry_first(
  71         BackendDB *be )
  72 {
  73         Datum key;
  74         ID id;
  75
  76         assert( slapMode & SLAP_TOOL_MODE );
  77         assert( id2entry != NULL );
  78
  79         key = ldbm_firstkey( id2entry->dbc_db, &cursorp );
  80
  81         if( key.dptr == NULL ) {
  82                 return NOID;
  83         }
  84
  85         memcpy( &id, key.dptr, key.dsize );
  86
  87         ldbm_datum_free( id2entry->dbc_db, key );
  88
  89         return id;
  90 }
  91
  92 ID ldbm_tool_entry_next(
  93         BackendDB *be )
  94 {
  95         Datum key;
  96         ID id;
  97         int count;
  98
  99         assert( slapMode & SLAP_TOOL_MODE );
 100         assert( id2entry != NULL );
 101
 102         /* allow for NEXTID */
 103         ldbm_datum_init( key );
 104
 105         key = ldbm_nextkey( id2entry->dbc_db, key, cursorp );
 106
 107         if( key.dptr == NULL ) {
 108                 return NOID;
 109         }
 110
 111         memcpy( &id, key.dptr, key.dsize );
 112
 113         ldbm_datum_free( id2entry->dbc_db, key );
 114
 115         return id;
 116 }
 117
 118 Entry* ldbm_tool_entry_get( BackendDB *be, ID id )
 119 {
 120         Entry *e;
 121         Datum key, data;
 122         assert( slapMode & SLAP_TOOL_MODE );
 123         assert( id2entry != NULL );
 124
 125         ldbm_datum_init( key );
 126
 127         key.dptr = (char *) &id;
 128         key.dsize = sizeof(ID);
 129
 130         data = ldbm_cache_fetch( id2entry, key );
 131
 132         if ( data.dptr == NULL ) {
 133                 return NULL;
 134         }
 135
 136         e = str2entry( data.dptr );
 137         ldbm_datum_free( id2entry->dbc_db, data );
 138
 139         return e;
 140 }
 141
 142 ID ldbm_tool_entry_put(
 143         BackendDB *be,
 144         Entry *e )
 145 {
 146         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 147         Datum key, data;
 148         int rc, len;
 149
 150         assert( slapMode & SLAP_TOOL_MODE );
 151         assert( id2entry != NULL );
 152
 153         if( next_id_get( be ) == NOID ) {
 154                 return NOID;
 155         }
 156
 157         e->e_id = li->li_nextid++;
 158
 159         Debug( LDAP_DEBUG_TRACE, "=> ldbm_tool_entry_put( %ld, \"%s\" )\n",
 160                 e->e_id, e->e_dn, 0 );
 161
 162         rc = index_add_entry( be, e );
 163
 164         if( rc != 0 ) {
 165                 return NOID;
 166         }
 167
 168         rc = dn2id_add( be, e->e_ndn, e->e_id );
 169
 170         if( rc != 0 ) {
 171                 return NOID;
 172         }
 173
 174         ldbm_datum_init( key );
 175         ldbm_datum_init( data );
 176
 177         key.dptr = (char *) &e->e_id;
 178         key.dsize = sizeof(ID);
 179
 180         data.dptr = entry2str( e, &len );
 181         data.dsize = len + 1;
 182
 183         /* store it */
 184         rc = ldbm_cache_store( id2entry, key, data, LDBM_REPLACE );
 185
 186         if( rc != 0 ) {
 187                 (void) dn2id_delete( be, e->e_ndn );
 188                 return NOID;
 189         }
 190
 191         return e->e_id;
 192 }
 193
 194 int ldbm_tool_index_attr(
 195         BackendDB *be,
 196         char* type )
 197 {
 198         static DBCache *db = NULL;
 199         int indexmask, syntaxmask;
 200         char * at_cn;
 201
 202         assert( slapMode & SLAP_TOOL_MODE );
 203
 204         attr_masks( be->be_private, type, &indexmask, &syntaxmask );
 205
 206         attr_normalize( type );
 207         at_cn = at_canonical_name( type );
 208
 209         if ( (db = ldbm_cache_open( be, at_cn, LDBM_SUFFIX, LDBM_NEWDB ))
 210             == NULL ) {
 211                 Debug( LDAP_DEBUG_ANY,
 212                     "<= index_read NULL (could not open %s%s)\n", at_cn,
 213                     LDBM_SUFFIX, 0 );
 214                 return( NULL );
 215         }
 216
 217         ldbm_cache_close( be, db );
 218
 219         return indexmask != 0;
 220 }
 221
 222 int ldbm_tool_index_change(
 223         BackendDB *be,
 224         char* type,
 225         struct berval **bv,
 226         ID id,
 227         int op )
 228 {
 229         assert( slapMode & SLAP_TOOL_MODE );
 230
 231         index_change_values( be,
 232                 type, bv, id, op );
 233
 234         return 0;
 235 }
 236
 237 int ldbm_tool_sync( BackendDB *be )
 238 {
 239         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 240
 241         assert( slapMode & SLAP_TOOL_MODE );
 242
 243         if ( li->li_nextid != NOID ) {
 244                 next_id_write( be, li->li_nextid );
 245         }
 246
 247         return 0;
 248 }