]> git.sur5r.net Git - openldap/blob - servers/slapd/back-ldbm/tools.c
New dn2id format with base/one/subtree indices (ldbm/bdb2)
[openldap] / 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 }