Line data Source code
1 : /*
2 : ldb database library
3 :
4 : Copyright (C) Andrew Tridgell 2004
5 : Copyright (C) Stefan Metzmacher 2004
6 : Copyright (C) Simo Sorce 2006-2008
7 : Copyright (C) Matthias Dieter Wallnöfer 2009-2010
8 :
9 : ** NOTE! The following LGPL license applies to the ldb
10 : ** library. This does NOT imply that all of Samba is released
11 : ** under the LGPL
12 :
13 : This library is free software; you can redistribute it and/or
14 : modify it under the terms of the GNU Lesser General Public
15 : License as published by the Free Software Foundation; either
16 : version 3 of the License, or (at your option) any later version.
17 :
18 : This library is distributed in the hope that it will be useful,
19 : but WITHOUT ANY WARRANTY; without even the implied warranty of
20 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 : Lesser General Public License for more details.
22 :
23 : You should have received a copy of the GNU Lesser General Public
24 : License along with this library; if not, see <http://www.gnu.org/licenses/>.
25 : */
26 :
27 : /*
28 : * Name: ldb_tdb
29 : *
30 : * Component: ldb tdb backend
31 : *
32 : * Description: core functions for tdb backend
33 : *
34 : * Author: Andrew Tridgell
35 : * Author: Stefan Metzmacher
36 : *
37 : * Modifications:
38 : *
39 : * - description: make the module use asynchronous calls
40 : * date: Feb 2006
41 : * Author: Simo Sorce
42 : *
43 : * - description: make it possible to use event contexts
44 : * date: Jan 2008
45 : * Author: Simo Sorce
46 : *
47 : * - description: fix up memory leaks and small bugs
48 : * date: Oct 2009
49 : * Author: Matthias Dieter Wallnöfer
50 : */
51 :
52 : #include "ldb_tdb.h"
53 : #include "ldb_private.h"
54 : #include "../ldb_key_value/ldb_kv.h"
55 : #include <tdb.h>
56 :
57 : /*
58 : lock the database for read - use by ltdb_search and ltdb_sequence_number
59 : */
60 170746810 : static int ltdb_lock_read(struct ldb_module *module)
61 : {
62 170746810 : void *data = ldb_module_get_private(module);
63 7961687 : struct ldb_kv_private *ldb_kv =
64 170746810 : talloc_get_type(data, struct ldb_kv_private);
65 170746810 : int tdb_ret = 0;
66 7961687 : int ret;
67 170746810 : pid_t pid = getpid();
68 :
69 170746810 : if (ldb_kv->pid != pid) {
70 2 : ldb_asprintf_errstring(ldb_module_get_ctx(module),
71 : __location__
72 : ": Reusing ldb opened by pid %d in "
73 : "process %d\n",
74 : ldb_kv->pid,
75 : pid);
76 2 : return LDB_ERR_PROTOCOL_ERROR;
77 : }
78 :
79 170746808 : if (tdb_transaction_active(ldb_kv->tdb) == false &&
80 99780996 : ldb_kv->read_lock_count == 0) {
81 47869416 : tdb_ret = tdb_lockall_read(ldb_kv->tdb);
82 : }
83 164764717 : if (tdb_ret == 0) {
84 170746808 : ldb_kv->read_lock_count++;
85 170746808 : return LDB_SUCCESS;
86 : }
87 0 : ret = ltdb_err_map(tdb_error(ldb_kv->tdb));
88 0 : if (ret == LDB_SUCCESS) {
89 0 : ret = LDB_ERR_OPERATIONS_ERROR;
90 : }
91 0 : ldb_debug_set(ldb_module_get_ctx(module),
92 : LDB_DEBUG_FATAL,
93 : "Failure during ltdb_lock_read(): %s -> %s",
94 0 : tdb_errorstr(ldb_kv->tdb),
95 : ldb_strerror(ret));
96 0 : return ret;
97 : }
98 :
99 : /*
100 : unlock the database after a ltdb_lock_read()
101 : */
102 170746810 : static int ltdb_unlock_read(struct ldb_module *module)
103 : {
104 170746810 : void *data = ldb_module_get_private(module);
105 7961687 : struct ldb_kv_private *ldb_kv =
106 170746810 : talloc_get_type(data, struct ldb_kv_private);
107 170746810 : pid_t pid = getpid();
108 :
109 170746810 : if (ldb_kv->pid != pid) {
110 2 : ldb_asprintf_errstring(ldb_module_get_ctx(module),
111 : __location__
112 : ": Reusing ldb opened by pid %d in "
113 : "process %d\n",
114 : ldb_kv->pid,
115 : pid);
116 2 : return LDB_ERR_PROTOCOL_ERROR;
117 : }
118 170746808 : if (!tdb_transaction_active(ldb_kv->tdb) &&
119 99780996 : ldb_kv->read_lock_count == 1) {
120 47869416 : tdb_unlockall_read(ldb_kv->tdb);
121 47869416 : ldb_kv->read_lock_count--;
122 47869416 : return 0;
123 : }
124 122877392 : ldb_kv->read_lock_count--;
125 122877392 : return 0;
126 : }
127 :
128 12988400 : static int ltdb_store(struct ldb_kv_private *ldb_kv,
129 : struct ldb_val ldb_key,
130 : struct ldb_val ldb_data,
131 : int flags)
132 : {
133 12988400 : TDB_DATA key = {
134 12988400 : .dptr = ldb_key.data,
135 12988400 : .dsize = ldb_key.length
136 : };
137 12988400 : TDB_DATA data = {
138 12988400 : .dptr = ldb_data.data,
139 12988400 : .dsize = ldb_data.length
140 : };
141 12988400 : bool transaction_active = tdb_transaction_active(ldb_kv->tdb);
142 12988400 : if (transaction_active == false){
143 0 : return LDB_ERR_PROTOCOL_ERROR;
144 : }
145 12988399 : return tdb_store(ldb_kv->tdb, key, data, flags);
146 : }
147 :
148 64964 : static int ltdb_error(struct ldb_kv_private *ldb_kv)
149 : {
150 64964 : return ltdb_err_map(tdb_error(ldb_kv->tdb));
151 : }
152 :
153 0 : static const char *ltdb_errorstr(struct ldb_kv_private *ldb_kv)
154 : {
155 0 : return tdb_errorstr(ldb_kv->tdb);
156 : }
157 :
158 641937 : static int ltdb_delete(struct ldb_kv_private *ldb_kv, struct ldb_val ldb_key)
159 : {
160 641937 : TDB_DATA tdb_key = {
161 641937 : .dptr = ldb_key.data,
162 641937 : .dsize = ldb_key.length
163 : };
164 641937 : bool transaction_active = tdb_transaction_active(ldb_kv->tdb);
165 641937 : if (transaction_active == false){
166 0 : return LDB_ERR_PROTOCOL_ERROR;
167 : }
168 641936 : return tdb_delete(ldb_kv->tdb, tdb_key);
169 : }
170 :
171 1432293 : static int ltdb_transaction_start(struct ldb_kv_private *ldb_kv)
172 : {
173 1432293 : pid_t pid = getpid();
174 :
175 1432293 : if (ldb_kv->pid != pid) {
176 0 : ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
177 : __location__
178 : ": Reusing ldb opened by pid %d in "
179 : "process %d\n",
180 : ldb_kv->pid,
181 : pid);
182 0 : return LDB_ERR_PROTOCOL_ERROR;
183 : }
184 :
185 1432293 : return tdb_transaction_start(ldb_kv->tdb);
186 : }
187 :
188 194705 : static int ltdb_transaction_cancel(struct ldb_kv_private *ldb_kv)
189 : {
190 194705 : pid_t pid = getpid();
191 :
192 194705 : if (ldb_kv->pid != pid) {
193 2 : ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
194 : __location__
195 : ": Reusing ldb opened by pid %d in "
196 : "process %d\n",
197 : ldb_kv->pid,
198 : pid);
199 2 : return LDB_ERR_PROTOCOL_ERROR;
200 : }
201 :
202 194703 : return tdb_transaction_cancel(ldb_kv->tdb);
203 : }
204 :
205 1232942 : static int ltdb_transaction_prepare_commit(struct ldb_kv_private *ldb_kv)
206 : {
207 1232942 : pid_t pid = getpid();
208 :
209 1232942 : if (ldb_kv->pid != pid) {
210 0 : ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
211 : __location__
212 : ": Reusing ldb opened by pid %d in "
213 : "process %d\n",
214 : ldb_kv->pid,
215 : pid);
216 0 : return LDB_ERR_PROTOCOL_ERROR;
217 : }
218 :
219 1232942 : return tdb_transaction_prepare_commit(ldb_kv->tdb);
220 : }
221 :
222 1237577 : static int ltdb_transaction_commit(struct ldb_kv_private *ldb_kv)
223 : {
224 1237577 : pid_t pid = getpid();
225 :
226 1237577 : if (ldb_kv->pid != pid) {
227 0 : ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
228 : __location__
229 : ": Reusing ldb opened by pid %d in "
230 : "process %d\n",
231 : ldb_kv->pid,
232 : pid);
233 0 : return LDB_ERR_PROTOCOL_ERROR;
234 : }
235 :
236 1237577 : return tdb_transaction_commit(ldb_kv->tdb);
237 : }
238 : struct kv_ctx {
239 : ldb_kv_traverse_fn kv_traverse_fn;
240 : void *ctx;
241 : struct ldb_kv_private *ldb_kv;
242 : int (*parser)(struct ldb_val key,
243 : struct ldb_val data,
244 : void *private_data);
245 : int parser_ret;
246 : };
247 :
248 528524684 : static int ltdb_traverse_fn_wrapper(struct tdb_context *tdb,
249 : TDB_DATA tdb_key,
250 : TDB_DATA tdb_data,
251 : void *ctx)
252 : {
253 528524684 : struct kv_ctx *kv_ctx = ctx;
254 528524684 : struct ldb_val key = {
255 528524684 : .length = tdb_key.dsize,
256 528524684 : .data = tdb_key.dptr,
257 : };
258 528524684 : struct ldb_val data = {
259 528524684 : .length = tdb_data.dsize,
260 528524684 : .data = tdb_data.dptr,
261 : };
262 528524684 : return kv_ctx->kv_traverse_fn(kv_ctx->ldb_kv, key, data, kv_ctx->ctx);
263 : }
264 :
265 76125 : static int ltdb_traverse_fn(struct ldb_kv_private *ldb_kv,
266 : ldb_kv_traverse_fn fn,
267 : void *ctx)
268 : {
269 76125 : struct kv_ctx kv_ctx = {
270 : .kv_traverse_fn = fn, .ctx = ctx, .ldb_kv = ldb_kv};
271 76125 : if (tdb_transaction_active(ldb_kv->tdb)) {
272 39340 : return tdb_traverse(
273 39340 : ldb_kv->tdb, ltdb_traverse_fn_wrapper, &kv_ctx);
274 : } else {
275 36785 : return tdb_traverse_read(
276 36785 : ldb_kv->tdb, ltdb_traverse_fn_wrapper, &kv_ctx);
277 : }
278 : }
279 :
280 73424 : static int ltdb_update_in_iterate(struct ldb_kv_private *ldb_kv,
281 : struct ldb_val ldb_key,
282 : struct ldb_val ldb_key2,
283 : struct ldb_val ldb_data,
284 : void *state)
285 : {
286 35826 : int tdb_ret;
287 35826 : struct ldb_context *ldb;
288 73424 : struct ldb_kv_reindex_context *ctx =
289 : (struct ldb_kv_reindex_context *)state;
290 73424 : struct ldb_module *module = ldb_kv->module;
291 73424 : TDB_DATA key = {
292 73424 : .dptr = ldb_key.data,
293 73424 : .dsize = ldb_key.length
294 : };
295 73424 : TDB_DATA key2 = {
296 73424 : .dptr = ldb_key2.data,
297 73424 : .dsize = ldb_key2.length
298 : };
299 73424 : TDB_DATA data = {
300 73424 : .dptr = ldb_data.data,
301 73424 : .dsize = ldb_data.length
302 : };
303 :
304 73424 : ldb = ldb_module_get_ctx(module);
305 :
306 73424 : tdb_ret = tdb_delete(ldb_kv->tdb, key);
307 73424 : if (tdb_ret != 0) {
308 0 : ldb_debug(ldb,
309 : LDB_DEBUG_ERROR,
310 : "Failed to delete %*.*s "
311 : "for rekey as %*.*s: %s",
312 0 : (int)key.dsize,
313 0 : (int)key.dsize,
314 0 : (const char *)key.dptr,
315 0 : (int)key2.dsize,
316 0 : (int)key2.dsize,
317 0 : (const char *)key.dptr,
318 0 : tdb_errorstr(ldb_kv->tdb));
319 0 : ctx->error = ltdb_err_map(tdb_error(ldb_kv->tdb));
320 0 : return -1;
321 : }
322 73424 : tdb_ret = tdb_store(ldb_kv->tdb, key2, data, 0);
323 73424 : if (tdb_ret != 0) {
324 0 : ldb_debug(ldb,
325 : LDB_DEBUG_ERROR,
326 : "Failed to rekey %*.*s as %*.*s: %s",
327 0 : (int)key.dsize,
328 0 : (int)key.dsize,
329 0 : (const char *)key.dptr,
330 0 : (int)key2.dsize,
331 0 : (int)key2.dsize,
332 0 : (const char *)key.dptr,
333 0 : tdb_errorstr(ldb_kv->tdb));
334 0 : ctx->error = ltdb_err_map(tdb_error(ldb_kv->tdb));
335 0 : return -1;
336 : }
337 37598 : return tdb_ret;
338 : }
339 :
340 213531631 : static int ltdb_parse_record_wrapper(TDB_DATA tdb_key,
341 : TDB_DATA tdb_data,
342 : void *ctx)
343 : {
344 213531631 : struct kv_ctx *kv_ctx = ctx;
345 213531631 : struct ldb_val key = {
346 213531631 : .length = tdb_key.dsize,
347 213531631 : .data = tdb_key.dptr,
348 : };
349 213531631 : struct ldb_val data = {
350 213531631 : .length = tdb_data.dsize,
351 213531631 : .data = tdb_data.dptr,
352 : };
353 :
354 213531631 : kv_ctx->parser_ret = kv_ctx->parser(key, data, kv_ctx->ctx);
355 213531631 : return kv_ctx->parser_ret;
356 : }
357 :
358 265712278 : static int ltdb_parse_record(struct ldb_kv_private *ldb_kv,
359 : struct ldb_val ldb_key,
360 : int (*parser)(struct ldb_val key,
361 : struct ldb_val data,
362 : void *private_data),
363 : void *ctx)
364 : {
365 265712278 : struct kv_ctx kv_ctx = {.parser = parser, .ctx = ctx, .ldb_kv = ldb_kv};
366 265712278 : TDB_DATA key = {
367 265712278 : .dptr = ldb_key.data,
368 265712278 : .dsize = ldb_key.length
369 : };
370 7623449 : int ret;
371 :
372 265712278 : if (tdb_transaction_active(ldb_kv->tdb) == false &&
373 158231822 : ldb_kv->read_lock_count == 0) {
374 0 : return LDB_ERR_PROTOCOL_ERROR;
375 : }
376 :
377 273335725 : ret = tdb_parse_record(
378 265712277 : ldb_kv->tdb, key, ltdb_parse_record_wrapper, &kv_ctx);
379 265712277 : if (kv_ctx.parser_ret != LDB_SUCCESS) {
380 0 : return kv_ctx.parser_ret;
381 265712228 : } else if (ret == 0) {
382 207671426 : return LDB_SUCCESS;
383 : }
384 52180646 : return ltdb_err_map(tdb_error(ldb_kv->tdb));
385 : }
386 :
387 49213 : static int ltdb_iterate_range(struct ldb_kv_private *ldb_kv,
388 : struct ldb_val start_key,
389 : struct ldb_val end_key,
390 : ldb_kv_traverse_fn fn,
391 : void *ctx)
392 : {
393 : /*
394 : * We do not implement this operation because we do not know how to
395 : * iterate from one key to the next (in a sorted fashion).
396 : *
397 : * We could mimic it potentially, but it would violate boundaries of
398 : * knowledge (data type representation).
399 : */
400 49213 : return LDB_ERR_OPERATIONS_ERROR;
401 : }
402 :
403 0 : static const char *ltdb_name(struct ldb_kv_private *ldb_kv)
404 : {
405 0 : return tdb_name(ldb_kv->tdb);
406 : }
407 :
408 85679296 : static bool ltdb_changed(struct ldb_kv_private *ldb_kv)
409 : {
410 85679296 : int seq = tdb_get_seqnum(ldb_kv->tdb);
411 85679296 : bool has_changed = (seq != ldb_kv->tdb_seqnum);
412 :
413 85679296 : ldb_kv->tdb_seqnum = seq;
414 :
415 85679296 : return has_changed;
416 : }
417 :
418 4588118 : static bool ltdb_transaction_active(struct ldb_kv_private *ldb_kv)
419 : {
420 4588118 : return tdb_transaction_active(ldb_kv->tdb);
421 : }
422 :
423 : /*
424 : * Get an estimate of the number of records in a tdb database.
425 : *
426 : * This implementation will overestimate the number of records in a sparsely
427 : * populated database. The size estimate is only used for allocating
428 : * an in memory tdb to cache index records during a reindex, overestimating
429 : * the contents is acceptable, and preferable to underestimating
430 : */
431 : #define RECORD_SIZE 500
432 2 : static size_t ltdb_get_size(struct ldb_kv_private *ldb_kv)
433 : {
434 2 : size_t map_size = tdb_map_size(ldb_kv->tdb);
435 2 : size_t size = map_size / RECORD_SIZE;
436 :
437 2 : return size;
438 : }
439 :
440 : /*
441 : * Start a sub transaction
442 : * As TDB does not currently support nested transactions, we do nothing and
443 : * return LDB_SUCCESS
444 : */
445 1374348 : static int ltdb_nested_transaction_start(struct ldb_kv_private *ldb_kv)
446 : {
447 1374348 : return LDB_SUCCESS;
448 : }
449 :
450 : /*
451 : * Commit a sub transaction
452 : * As TDB does not currently support nested transactions, we do nothing and
453 : * return LDB_SUCCESS
454 : */
455 1363446 : static int ltdb_nested_transaction_commit(struct ldb_kv_private *ldb_kv)
456 : {
457 1363446 : return LDB_SUCCESS;
458 : }
459 :
460 : /*
461 : * Cancel a sub transaction
462 : * As TDB does not currently support nested transactions, we do nothing and
463 : * return LDB_SUCCESS
464 : */
465 10902 : static int ltdb_nested_transaction_cancel(struct ldb_kv_private *ldb_kv)
466 : {
467 10902 : return LDB_SUCCESS;
468 : }
469 :
470 : static const struct kv_db_ops key_value_ops = {
471 : /* No support for any additional features */
472 : .options = 0,
473 :
474 : .store = ltdb_store,
475 : .delete = ltdb_delete,
476 : .iterate = ltdb_traverse_fn,
477 : .update_in_iterate = ltdb_update_in_iterate,
478 : .fetch_and_parse = ltdb_parse_record,
479 : .iterate_range = ltdb_iterate_range,
480 : .lock_read = ltdb_lock_read,
481 : .unlock_read = ltdb_unlock_read,
482 : .begin_write = ltdb_transaction_start,
483 : .prepare_write = ltdb_transaction_prepare_commit,
484 : .finish_write = ltdb_transaction_commit,
485 : .abort_write = ltdb_transaction_cancel,
486 : .error = ltdb_error,
487 : .errorstr = ltdb_errorstr,
488 : .name = ltdb_name,
489 : .has_changed = ltdb_changed,
490 : .transaction_active = ltdb_transaction_active,
491 : .get_size = ltdb_get_size,
492 : .begin_nested_write = ltdb_nested_transaction_start,
493 : .finish_nested_write = ltdb_nested_transaction_commit,
494 : .abort_nested_write = ltdb_nested_transaction_cancel,
495 : };
496 :
497 : /*
498 : connect to the database
499 : */
500 724449 : int ltdb_connect(struct ldb_context *ldb, const char *url,
501 : unsigned int flags, const char *options[],
502 : struct ldb_module **_module)
503 : {
504 12197 : const char *path;
505 12197 : int tdb_flags, open_flags;
506 12197 : struct ldb_kv_private *ldb_kv;
507 :
508 : /*
509 : * We hold locks, so we must use a private event context
510 : * on each returned handle
511 : */
512 724449 : ldb_set_require_private_event_context(ldb);
513 :
514 : /* parse the url */
515 724449 : if (strchr(url, ':')) {
516 417671 : if (strncmp(url, "tdb://", 6) != 0) {
517 0 : ldb_debug(ldb, LDB_DEBUG_ERROR,
518 : "Invalid tdb URL '%s'", url);
519 0 : return LDB_ERR_OPERATIONS_ERROR;
520 : }
521 417671 : path = url+6;
522 : } else {
523 295861 : path = url;
524 : }
525 :
526 724449 : tdb_flags = TDB_DEFAULT | TDB_SEQNUM | TDB_DISALLOW_NESTING;
527 :
528 : /* check for the 'nosync' option */
529 724449 : if (flags & LDB_FLG_NOSYNC) {
530 718378 : tdb_flags |= TDB_NOSYNC;
531 : }
532 :
533 : /* and nommap option */
534 724449 : if (flags & LDB_FLG_NOMMAP) {
535 0 : tdb_flags |= TDB_NOMMAP;
536 : }
537 :
538 724449 : ldb_kv = talloc_zero(ldb, struct ldb_kv_private);
539 724449 : if (!ldb_kv) {
540 0 : ldb_oom(ldb);
541 0 : return LDB_ERR_OPERATIONS_ERROR;
542 : }
543 :
544 724449 : if (flags & LDB_FLG_RDONLY) {
545 : /*
546 : * This is weird, but because we can only have one tdb
547 : * in this process, and the other one could be
548 : * read-write, we can't use the tdb readonly. Plus a
549 : * read only tdb prohibits the all-record lock.
550 : */
551 16 : open_flags = O_RDWR;
552 :
553 16 : ldb_kv->read_only = true;
554 :
555 724433 : } else if (flags & LDB_FLG_DONT_CREATE_DB) {
556 : /*
557 : * This is used by ldbsearch to prevent creation of the database
558 : * if the name is wrong
559 : */
560 647831 : open_flags = O_RDWR;
561 : } else {
562 : /*
563 : * This is the normal case
564 : */
565 67272 : open_flags = O_CREAT | O_RDWR;
566 : }
567 :
568 724449 : ldb_kv->kv_ops = &key_value_ops;
569 :
570 724449 : errno = 0;
571 : /* note that we use quite a large default hash size */
572 724449 : ldb_kv->tdb = ltdb_wrap_open(ldb_kv,
573 : path,
574 : 10000,
575 : tdb_flags,
576 : open_flags,
577 : ldb_get_create_perms(ldb),
578 : ldb);
579 724449 : if (!ldb_kv->tdb) {
580 1012 : ldb_asprintf_errstring(ldb,
581 1007 : "Unable to open tdb '%s': %s", path, strerror(errno));
582 1012 : ldb_debug(ldb, LDB_DEBUG_ERROR,
583 1007 : "Unable to open tdb '%s': %s", path, strerror(errno));
584 1012 : talloc_free(ldb_kv);
585 1012 : if (errno == EACCES || errno == EPERM) {
586 0 : return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
587 : }
588 1012 : return LDB_ERR_OPERATIONS_ERROR;
589 : }
590 :
591 723437 : return ldb_kv_init_store(
592 : ldb_kv, "ldb_tdb backend", ldb, options, _module);
593 : }
|
