dbwrap: dbwrap_fetch_locked_timeout().
[kai/samba-autobuild/.git] / lib / dbwrap / dbwrap.c
1 /*
2    Unix SMB/CIFS implementation.
3    Database interface wrapper
4    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006
5
6    Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com)
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "dbwrap/dbwrap.h"
24 #include "dbwrap/dbwrap_private.h"
25 #include "lib/util/util_tdb.h"
26
27 /*
28  * Fall back using fetch if no genuine exists operation is provided
29  */
30
31 static int dbwrap_fallback_exists(struct db_context *db, TDB_DATA key)
32 {
33         NTSTATUS status = dbwrap_parse_record(db, key, NULL, NULL);
34         return NT_STATUS_IS_OK(status) ? 1 : 0;
35 }
36
37 static int delete_record(struct db_record *rec, void *data)
38 {
39         NTSTATUS status = dbwrap_record_delete(rec);
40         return NT_STATUS_IS_OK(status) ? 0 : -1;
41 }
42
43 /*
44  * Fallback wipe implementation using traverse and delete if no genuine
45  * wipe operation is provided
46  */
47 static int dbwrap_fallback_wipe(struct db_context *db)
48 {
49         NTSTATUS status = dbwrap_trans_traverse(db, delete_record, NULL);
50         return NT_STATUS_IS_OK(status) ? 0 : -1;
51 }
52
53 static int do_nothing(struct db_record *rec, void *unused)
54 {
55         return 0;
56 }
57
58 /*
59  * Fallback check operation: just traverse.
60  */
61 static int dbwrap_fallback_check(struct db_context *db)
62 {
63         NTSTATUS status = dbwrap_traverse_read(db, do_nothing, NULL, NULL);
64         return NT_STATUS_IS_OK(status) ? 0 : -1;
65 }
66
67 /*
68  * Wrapper functions for the backend methods
69  */
70
71 TDB_DATA dbwrap_record_get_key(const struct db_record *rec)
72 {
73         return rec->key;
74 }
75
76 TDB_DATA dbwrap_record_get_value(const struct db_record *rec)
77 {
78         return rec->value;
79 }
80
81 NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags)
82 {
83         NTSTATUS status;
84         struct db_context *db;
85
86         status = rec->store(rec, data, flags);
87         if (!NT_STATUS_IS_OK(status)) {
88                 return status;
89         }
90         db = rec->db;
91         if (db->stored_callback != NULL) {
92                 db->stored_callback(db, rec,
93                                     db->stored_callback_private_data);
94         }
95         return NT_STATUS_OK;
96 }
97
98 void dbwrap_set_stored_callback(
99         struct db_context *db,
100         void (*cb)(struct db_context *db, struct db_record *rec,
101                    void *private_data),
102         void *private_data)
103 {
104         db->stored_callback = cb;
105         db->stored_callback_private_data = private_data;
106 }
107
108 NTSTATUS dbwrap_record_delete(struct db_record *rec)
109 {
110         NTSTATUS status;
111         struct db_context *db;
112
113         status = rec->delete_rec(rec);
114         if (!NT_STATUS_IS_OK(status)) {
115                 return status;
116         }
117         db = rec->db;
118         if (db->stored_callback != NULL) {
119                 db->stored_callback(db, rec,
120                                     db->stored_callback_private_data);
121         }
122         return NT_STATUS_OK;
123 }
124
125 struct dbwrap_lock_order_state {
126         uint8_t *plock_order_mask;
127         uint8_t bitmask;
128 };
129
130 static int dbwrap_lock_order_state_destructor(
131         struct dbwrap_lock_order_state *s)
132 {
133         *s->plock_order_mask &= ~s->bitmask;
134         return 0;
135 }
136
137 static struct dbwrap_lock_order_state *dbwrap_check_lock_order(
138         struct db_context *db, TALLOC_CTX *mem_ctx)
139 {
140         /*
141          * Store the lock_order of currently locked records as bits in
142          * "lock_order_mask". We only use levels 1,2,3 right now, so a
143          * single uint8_t is enough.
144          */
145         static uint8_t lock_order_mask;
146
147         struct dbwrap_lock_order_state *state;
148         uint8_t idx;
149         int used;
150
151         if (db->lock_order == 0) {
152                 /*
153                  * lock order 0 is for example for dbwrap_rbt without
154                  * real locking. Return state nevertheless to avoid
155                  * special cases.
156                  */
157                 return talloc(mem_ctx, struct dbwrap_lock_order_state);
158         }
159
160         /*
161          * We fill bits from the high bits, to be able to use
162          * "ffs(lock_order_mask)"
163          */
164         idx = sizeof(lock_order_mask)*8 - db->lock_order;
165
166         used = ffs(lock_order_mask);
167
168         DEBUG(5, ("used=%d, lock_order=%d, idx=%d\n", used,
169                   (int)db->lock_order, (int)idx));
170
171         if ((used != 0) && (used-1 <= idx)) {
172                 DEBUG(0, ("Lock order violation: Trying %d, order_mask=%x\n",
173                           (int)db->lock_order, (int)lock_order_mask));
174                 return NULL;
175         }
176
177         state = talloc(mem_ctx, struct dbwrap_lock_order_state);
178         if (state == NULL) {
179                 DEBUG(1, ("talloc failed\n"));
180                 return NULL;
181         }
182         state->bitmask = 1 << idx;
183         state->plock_order_mask = &lock_order_mask;
184
185         talloc_set_destructor(state, dbwrap_lock_order_state_destructor);
186         lock_order_mask |= state->bitmask;
187
188         return state;
189 }
190
191 static struct db_record *dbwrap_fetch_locked_internal(
192         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key,
193         struct db_record *(*db_fn)(struct db_context *db, TALLOC_CTX *mem_ctx,
194                                    TDB_DATA key))
195 {
196         struct db_record *rec;
197         struct dbwrap_lock_order_state *lock_order;
198         TALLOC_CTX *frame = talloc_stackframe();
199
200         lock_order = dbwrap_check_lock_order(db, frame);
201         if (lock_order == NULL) {
202                 TALLOC_FREE(frame);
203                 return NULL;
204         }
205         rec = db_fn(db, mem_ctx, key);
206         if (rec == NULL) {
207                 TALLOC_FREE(frame);
208                 return NULL;
209         }
210         (void)talloc_steal(rec, lock_order);
211         rec->db = db;
212         TALLOC_FREE(frame);
213         return rec;
214 }
215
216 struct db_record *dbwrap_fetch_locked(struct db_context *db,
217                                       TALLOC_CTX *mem_ctx,
218                                       TDB_DATA key)
219 {
220         return dbwrap_fetch_locked_internal(db, mem_ctx, key,
221                                             db->fetch_locked);
222 }
223
224 struct db_record *dbwrap_try_fetch_locked(struct db_context *db,
225                                       TALLOC_CTX *mem_ctx,
226                                       TDB_DATA key)
227 {
228         return dbwrap_fetch_locked_internal(
229                 db, mem_ctx, key,
230                 db->try_fetch_locked
231                 ? db->try_fetch_locked : db->fetch_locked);
232 }
233
234 struct db_record *dbwrap_fetch_locked_timeout(struct db_context *db,
235                                               TALLOC_CTX *mem_ctx,
236                                               TDB_DATA key,
237                                               unsigned int timeout)
238 {
239         struct db_record *rec;
240         struct dbwrap_lock_order_state *lock_order;
241         TALLOC_CTX *frame = talloc_stackframe();
242
243         lock_order = dbwrap_check_lock_order(db, frame);
244         if (lock_order == NULL) {
245                 TALLOC_FREE(frame);
246                 return NULL;
247         }
248         rec = db->fetch_locked_timeout
249                 ? db->fetch_locked_timeout(db, mem_ctx, key, timeout)
250                 : db->fetch_locked(db, mem_ctx, key);
251         if (rec == NULL) {
252                 TALLOC_FREE(frame);
253                 return NULL;
254         }
255         (void)talloc_steal(rec, lock_order);
256         rec->db = db;
257         TALLOC_FREE(frame);
258         return rec;
259 }
260
261 struct db_context *dbwrap_record_get_db(struct db_record *rec)
262 {
263         return rec->db;
264 }
265
266 struct dbwrap_fetch_state {
267         TALLOC_CTX *mem_ctx;
268         TDB_DATA data;
269 };
270
271 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
272                                 void *private_data)
273 {
274         struct dbwrap_fetch_state *state =
275                 (struct dbwrap_fetch_state *)private_data;
276
277         state->data.dsize = data.dsize;
278         state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
279                                                     data.dsize);
280 }
281
282 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
283                       TDB_DATA key, TDB_DATA *value)
284 {
285         struct dbwrap_fetch_state state;
286         NTSTATUS status;
287
288         if (value == NULL) {
289                 return NT_STATUS_INVALID_PARAMETER;
290         }
291
292         state.mem_ctx = mem_ctx;
293
294         status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
295         if (!NT_STATUS_IS_OK(status)) {
296                 return status;
297         }
298         if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
299                 return NT_STATUS_NO_MEMORY;
300         }
301         *value = state.data;
302         return NT_STATUS_OK;
303 }
304
305 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
306 {
307         int result;
308         if (db->exists != NULL) {
309                 result = db->exists(db, key);
310         } else {
311                 result = dbwrap_fallback_exists(db,key);
312         }
313         return (result == 1);
314 }
315
316 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
317                       TDB_DATA data, int flags)
318 {
319         struct db_record *rec;
320         NTSTATUS status;
321         TALLOC_CTX *frame = talloc_stackframe();
322
323         rec = dbwrap_fetch_locked(db, frame, key);
324         if (rec == NULL) {
325                 TALLOC_FREE(frame);
326                 return NT_STATUS_NO_MEMORY;
327         }
328
329         status = dbwrap_record_store(rec, data, flags);
330         TALLOC_FREE(frame);
331         return status;
332 }
333
334 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
335 {
336         struct db_record *rec;
337         NTSTATUS status;
338         TALLOC_CTX *frame = talloc_stackframe();
339
340         rec = dbwrap_fetch_locked(db, frame, key);
341         if (rec == NULL) {
342                 TALLOC_FREE(frame);
343                 return NT_STATUS_NO_MEMORY;
344         }
345         status = dbwrap_record_delete(rec);
346         TALLOC_FREE(frame);
347         return status;
348 }
349
350 NTSTATUS dbwrap_traverse(struct db_context *db,
351                          int (*f)(struct db_record*, void*),
352                          void *private_data,
353                          int *count)
354 {
355         int ret = db->traverse(db, f, private_data);
356
357         if (ret < 0) {
358                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
359         }
360
361         if (count != NULL) {
362                 *count = ret;
363         }
364
365         return NT_STATUS_OK;
366 }
367
368 NTSTATUS dbwrap_traverse_read(struct db_context *db,
369                               int (*f)(struct db_record*, void*),
370                               void *private_data,
371                               int *count)
372 {
373         int ret = db->traverse_read(db, f, private_data);
374
375         if (ret < 0) {
376                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
377         }
378
379         if (count != NULL) {
380                 *count = ret;
381         }
382
383         return NT_STATUS_OK;
384 }
385
386 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
387 {
388         return;
389 }
390
391 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
392                              void (*parser)(TDB_DATA key, TDB_DATA data,
393                                             void *private_data),
394                              void *private_data)
395 {
396         if (parser == NULL) {
397                 parser = dbwrap_null_parser;
398         }
399         return db->parse_record(db, key, parser, private_data);
400 }
401
402 int dbwrap_wipe(struct db_context *db)
403 {
404         if (db->wipe == NULL) {
405                 return dbwrap_fallback_wipe(db);
406         }
407         return db->wipe(db);
408 }
409
410 int dbwrap_check(struct db_context *db)
411 {
412         if (db->check == NULL) {
413                 return dbwrap_fallback_check(db);
414         }
415         return db->check(db);
416 }
417
418 int dbwrap_get_seqnum(struct db_context *db)
419 {
420         return db->get_seqnum(db);
421 }
422
423 int dbwrap_transaction_start(struct db_context *db)
424 {
425         return db->transaction_start(db);
426 }
427
428 int dbwrap_transaction_commit(struct db_context *db)
429 {
430         return db->transaction_commit(db);
431 }
432
433 int dbwrap_transaction_cancel(struct db_context *db)
434 {
435         return db->transaction_cancel(db);
436 }
437
438 void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen)
439 {
440         db->id(db, id, idlen);
441 }