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
  98         assert( slapMode & SLAP_TOOL_MODE );
  99         assert( id2entry != NULL );
 100
 101         /* allow for NEXTID */
 102         ldbm_datum_init( key );
 103
 104         key = ldbm_nextkey( id2entry->dbc_db, key, cursorp );
 105
 106         if( key.dptr == NULL ) {
 107                 return NOID;
 108         }
 109
 110         memcpy( &id, key.dptr, key.dsize );
 111
 112         ldbm_datum_free( id2entry->dbc_db, key );
 113
 114         return id;
 115 }
 116
 117 Entry* ldbm_tool_entry_get( BackendDB *be, ID id )
 118 {
 119         Entry *e;
 120         Datum key, data;
 121         assert( slapMode & SLAP_TOOL_MODE );
 122         assert( id2entry != NULL );
 123
 124         ldbm_datum_init( key );
 125
 126         key.dptr = (char *) &id;
 127         key.dsize = sizeof(ID);
 128
 129         data = ldbm_cache_fetch( id2entry, key );
 130
 131         if ( data.dptr == NULL ) {
 132                 return NULL;
 133         }
 134
 135         e = str2entry( data.dptr );
 136         ldbm_datum_free( id2entry->dbc_db, data );
 137
 138         return e;
 139 }
 140
 141 ID ldbm_tool_entry_put(
 142         BackendDB *be,
 143         Entry *e )
 144 {
 145         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 146         Datum key, data;
 147         int rc, len;
 148
 149         assert( slapMode & SLAP_TOOL_MODE );
 150         assert( id2entry != NULL );
 151
 152         if( next_id_get( be ) == NOID ) {
 153                 return NOID;
 154         }
 155
 156         e->e_id = li->li_nextid++;
 157
 158         Debug( LDAP_DEBUG_TRACE, "=> ldbm_tool_entry_put( %ld, \"%s\" )\n",
 159                 e->e_id, e->e_dn, 0 );
 160
 161         rc = index_add_entry( be, e );
 162
 163         if( rc != 0 ) {
 164                 return NOID;
 165         }
 166
 167         rc = dn2id_add( be, e->e_ndn, e->e_id );
 168
 169         if( rc != 0 ) {
 170                 return NOID;
 171         }
 172
 173         ldbm_datum_init( key );
 174         ldbm_datum_init( data );
 175
 176         key.dptr = (char *) &e->e_id;
 177         key.dsize = sizeof(ID);
 178
 179         data.dptr = entry2str( e, &len );
 180         data.dsize = len + 1;
 181
 182         /* store it */
 183         rc = ldbm_cache_store( id2entry, key, data, LDBM_REPLACE );
 184
 185         if( rc != 0 ) {
 186                 (void) dn2id_delete( be, e->e_ndn );
 187                 return NOID;
 188         }
 189
 190         return e->e_id;
 191 }
 192
 193 int ldbm_tool_index_attr(
 194         BackendDB *be,
 195         char* type )
 196 {
 197         static DBCache *db = NULL;
 198         int indexmask, syntaxmask;
 199         char * at_cn;
 200
 201         assert( slapMode & SLAP_TOOL_MODE );
 202
 203         attr_masks( be->be_private, type, &indexmask, &syntaxmask );
 204
 205         attr_normalize( type );
 206         at_cn = at_canonical_name( type );
 207
 208         if ( (db = ldbm_cache_open( be, at_cn, LDBM_SUFFIX, LDBM_NEWDB ))
 209             == NULL ) {
 210                 Debug( LDAP_DEBUG_ANY,
 211                     "<= index_read NULL (could not open %s%s)\n", at_cn,
 212                     LDBM_SUFFIX, 0 );
 213                 return 0;
 214         }
 215
 216         ldbm_cache_close( be, db );
 217
 218         return indexmask != 0;
 219 }
 220
 221 int ldbm_tool_index_change(
 222         BackendDB *be,
 223         char* type,
 224         struct berval **bv,
 225         ID id,
 226         int op )
 227 {
 228         assert( slapMode & SLAP_TOOL_MODE );
 229
 230         index_change_values( be,
 231                 type, bv, id, op );
 232
 233         return 0;
 234 }
 235
 236 int ldbm_tool_sync( BackendDB *be )
 237 {
 238         struct ldbminfo *li = (struct ldbminfo *) be->be_private;
 239
 240         assert( slapMode & SLAP_TOOL_MODE );
 241
 242         if ( li->li_nextid != NOID ) {
 243                 next_id_write( be, li->li_nextid );
 244         }
 245
 246         return 0;
 247 }