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/string.h>
  12 #include <ac/socket.h>
  13
  14 #include "slap.h"
  15 #include "back-ldbm.h"
  16
  17 static LDBMCursor *cursorp = NULL;
  18 static DBCache *id2entry = NULL;
  19
  20 int ldbm_tool_entry_open(
  21         BackendDB *be, int mode )
  22 {
  23         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  24         int flags;
  25
  26         assert( slapMode & SLAP_TOOL_MODE );
  27         assert( id2entry == NULL );
  28
  29         switch( mode ) {
  30         case 1:
  31                 flags = LDBM_WRCREAT;
  32                 break;
  33         case 2:
  34 #ifdef TRUNCATE_MODE
  35                 flags = LDBM_NEWDB;
  36 #else
  37                 flags = LDBM_WRCREAT;
  38 #endif
  39                 break;
  40         default:
  41                 flags = LDBM_READER;
  42         }
  43
  44         li->li_dbcachewsync = 0;
  45
  46         if ( (id2entry = ldbm_cache_open( be, "id2entry", LDBM_SUFFIX, flags ))
  47             == NULL ) {
  48                 Debug( LDAP_DEBUG_ANY, "Could not open/create id2entry" LDBM_SUFFIX "\n",
  49                     0, 0, 0 );
  50                 return( -1 );
  51         }
  52
  53         return 0;
  54 }
  55
  56 int ldbm_tool_entry_close(
  57         BackendDB *be )
  58 {
  59         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
  60
  61         assert( slapMode & SLAP_TOOL_MODE );
  62         assert( id2entry != NULL );
  63
  64         ldbm_cache_close( be, id2entry );
  65         li->li_dbcachewsync = 1;
  66         id2entry = NULL;
  67
  68         return 0;
  69 }
  70
  71 ID ldbm_tool_entry_first(
  72         BackendDB *be )
  73 {
  74         Datum key;
  75         ID id;
  76
  77         assert( slapMode & SLAP_TOOL_MODE );
  78         assert( id2entry != NULL );
  79
  80         key = ldbm_firstkey( id2entry->dbc_db, &cursorp );
  81
  82         if( key.dptr == NULL ) {
  83                 return NOID;
  84         }
  85
  86         memcpy( &id, key.dptr, key.dsize );
  87
  88         ldbm_datum_free( id2entry->dbc_db, key );
  89
  90         return id;
  91 }
  92
  93 ID ldbm_tool_entry_next(
  94         BackendDB *be )
  95 {
  96         Datum key;
  97         ID id;
  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 0;
 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 }