4 Copyright (C) Andrew Tridgell 2004
5 Copyright (C) Stefan Metzmacher 2004
6 Copyright (C) Simo Sorce 2006
9 ** NOTE! The following LGPL license applies to the ldb
10 ** library. This does NOT imply that all of Samba is released
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 2 of the License, or (at your option) any later version.
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.
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 * Component: ldb tdb backend
33 * Description: core functions for tdb backend
35 * Author: Andrew Tridgell
36 * Author: Stefan Metzmacher
40 * - description: make the module use asyncronous calls
46 #include "ldb/include/includes.h"
48 #include "ldb/ldb_tdb/ldb_tdb.h"
52 map a tdb error code to a ldb error code
54 static int ltdb_err_map(enum TDB_ERROR tdb_code
)
62 return LDB_ERR_OPERATIONS_ERROR
;
64 return LDB_ERR_PROTOCOL_ERROR
;
68 case TDB_ERR_LOCK_TIMEOUT
:
69 return LDB_ERR_TIME_LIMIT_EXCEEDED
;
71 return LDB_ERR_ENTRY_ALREADY_EXISTS
;
73 return LDB_ERR_NO_SUCH_OBJECT
;
75 return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS
;
81 struct ldb_handle
*init_ltdb_handle(struct ltdb_private
*ltdb
, struct ldb_module
*module
,
83 int (*callback
)(struct ldb_context
*, void *, struct ldb_reply
*))
85 struct ltdb_context
*ac
;
88 h
= talloc_zero(ltdb
, struct ldb_handle
);
90 ldb_set_errstring(module
->ldb
, "Out of Memory");
96 ac
= talloc_zero(h
, struct ltdb_context
);
98 ldb_set_errstring(module
->ldb
, "Out of Memory");
103 h
->private_data
= (void *)ac
;
105 h
->state
= LDB_ASYNC_INIT
;
106 h
->status
= LDB_SUCCESS
;
109 ac
->context
= context
;
110 ac
->callback
= callback
;
116 form a TDB_DATA for a record key
119 note that the key for a record can depend on whether the
120 dn refers to a case sensitive index record or not
122 struct TDB_DATA
ltdb_key(struct ldb_module
*module
, const struct ldb_dn
*dn
)
124 struct ldb_context
*ldb
= module
->ldb
;
126 char *key_str
= NULL
;
127 char *dn_folded
= NULL
;
130 most DNs are case insensitive. The exception is index DNs for
131 case sensitive attributes
133 there are 3 cases dealt with in this code:
135 1) if the dn doesn't start with @ then uppercase the attribute
136 names and the attributes values of case insensitive attributes
137 2) if the dn starts with @ then leave it alone - the indexing code handles
141 dn_folded
= ldb_dn_linearize_casefold(ldb
, dn
);
146 key_str
= talloc_asprintf(ldb
, "DN=%s", dn_folded
);
148 talloc_free(dn_folded
);
154 key
.dptr
= (uint8_t *)key_str
;
155 key
.dsize
= strlen(key_str
) + 1;
167 check special dn's have valid attributes
168 currently only @ATTRIBUTES is checked
170 int ltdb_check_special_dn(struct ldb_module
*module
, const struct ldb_message
*msg
)
174 if (! ldb_dn_is_special(msg
->dn
) ||
175 ! ldb_dn_check_special(msg
->dn
, LTDB_ATTRIBUTES
)) {
179 /* we have @ATTRIBUTES, let's check attributes are fine */
180 /* should we check that we deny multivalued attributes ? */
181 for (i
= 0; i
< msg
->num_elements
; i
++) {
182 for (j
= 0; j
< msg
->elements
[i
].num_values
; j
++) {
183 if (ltdb_check_at_attributes_values(&msg
->elements
[i
].values
[j
]) != 0) {
184 ldb_set_errstring(module
->ldb
, "Invalid attribute value in an @ATTRIBUTES entry");
185 return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX
;
195 we've made a modification to a dn - possibly reindex and
196 update sequence number
198 static int ltdb_modified(struct ldb_module
*module
, const struct ldb_dn
*dn
)
202 if (ldb_dn_is_special(dn
) &&
203 (ldb_dn_check_special(dn
, LTDB_INDEXLIST
) ||
204 ldb_dn_check_special(dn
, LTDB_ATTRIBUTES
)) ) {
205 ret
= ltdb_reindex(module
);
209 !(ldb_dn_is_special(dn
) &&
210 ldb_dn_check_special(dn
, LTDB_BASEINFO
)) ) {
211 ret
= ltdb_increase_sequence_number(module
);
218 store a record into the db
220 int ltdb_store(struct ldb_module
*module
, const struct ldb_message
*msg
, int flgs
)
222 struct ltdb_private
*ltdb
=
223 talloc_get_type(module
->private_data
, struct ltdb_private
);
224 TDB_DATA tdb_key
, tdb_data
;
227 tdb_key
= ltdb_key(module
, msg
->dn
);
229 return LDB_ERR_OTHER
;
232 ret
= ltdb_pack_data(module
, msg
, &tdb_data
);
234 talloc_free(tdb_key
.dptr
);
235 return LDB_ERR_OTHER
;
238 ret
= tdb_store(ltdb
->tdb
, tdb_key
, tdb_data
, flgs
);
240 ret
= ltdb_err_map(tdb_error(ltdb
->tdb
));
244 ret
= ltdb_index_add(module
, msg
);
246 tdb_delete(ltdb
->tdb
, tdb_key
);
250 talloc_free(tdb_key
.dptr
);
251 talloc_free(tdb_data
.dptr
);
257 static int ltdb_add_internal(struct ldb_module
*module
, const struct ldb_message
*msg
)
261 ret
= ltdb_check_special_dn(module
, msg
);
262 if (ret
!= LDB_SUCCESS
) {
266 if (ltdb_cache_load(module
) != 0) {
267 return LDB_ERR_OPERATIONS_ERROR
;
270 ret
= ltdb_store(module
, msg
, TDB_INSERT
);
272 if (ret
== LDB_ERR_ENTRY_ALREADY_EXISTS
) {
275 dn
= ldb_dn_linearize(module
, msg
->dn
);
279 ldb_asprintf_errstring(module
->ldb
, "Entry %s already exists", dn
);
284 if (ret
== LDB_SUCCESS
) {
285 ret
= ltdb_modified(module
, msg
->dn
);
286 if (ret
!= LDB_SUCCESS
) {
287 return LDB_ERR_OPERATIONS_ERROR
;
295 add a record to the database
297 static int ltdb_add(struct ldb_module
*module
, struct ldb_request
*req
)
299 struct ltdb_private
*ltdb
= talloc_get_type(module
->private_data
, struct ltdb_private
);
300 struct ltdb_context
*ltdb_ac
;
301 int tret
, ret
= LDB_SUCCESS
;
303 if (req
->controls
!= NULL
) {
304 ldb_debug(module
->ldb
, LDB_DEBUG_WARNING
, "Controls should not reach the ldb_tdb backend!\n");
305 if (check_critical_controls(req
->controls
)) {
306 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION
;
310 req
->handle
= init_ltdb_handle(ltdb
, module
, req
->context
, req
->callback
);
311 if (req
->handle
== NULL
) {
312 return LDB_ERR_OPERATIONS_ERROR
;
314 ltdb_ac
= talloc_get_type(req
->handle
->private_data
, struct ltdb_context
);
316 tret
= ltdb_add_internal(module
, req
->op
.add
.message
);
317 if (tret
!= LDB_SUCCESS
) {
318 req
->handle
->status
= tret
;
322 if (ltdb_ac
->callback
) {
323 ret
= ltdb_ac
->callback(module
->ldb
, ltdb_ac
->context
, NULL
);
326 req
->handle
->state
= LDB_ASYNC_DONE
;
331 delete a record from the database, not updating indexes (used for deleting
334 int ltdb_delete_noindex(struct ldb_module
*module
, const struct ldb_dn
*dn
)
336 struct ltdb_private
*ltdb
=
337 talloc_get_type(module
->private_data
, struct ltdb_private
);
341 tdb_key
= ltdb_key(module
, dn
);
343 return LDB_ERR_OTHER
;
346 ret
= tdb_delete(ltdb
->tdb
, tdb_key
);
347 talloc_free(tdb_key
.dptr
);
350 ret
= ltdb_err_map(tdb_error(ltdb
->tdb
));
356 static int ltdb_delete_internal(struct ldb_module
*module
, const struct ldb_dn
*dn
)
358 struct ldb_message
*msg
;
361 msg
= talloc(module
, struct ldb_message
);
363 return LDB_ERR_OPERATIONS_ERROR
;
366 /* in case any attribute of the message was indexed, we need
367 to fetch the old record */
368 ret
= ltdb_search_dn1(module
, dn
, msg
);
370 /* not finding the old record is an error */
372 return LDB_ERR_NO_SUCH_OBJECT
;
375 ret
= ltdb_delete_noindex(module
, dn
);
376 if (ret
!= LDB_SUCCESS
) {
378 return LDB_ERR_NO_SUCH_OBJECT
;
381 /* remove any indexed attributes */
382 ret
= ltdb_index_del(module
, msg
);
383 if (ret
!= LDB_SUCCESS
) {
385 return LDB_ERR_OPERATIONS_ERROR
;
388 ret
= ltdb_modified(module
, dn
);
389 if (ret
!= LDB_SUCCESS
) {
390 return LDB_ERR_OPERATIONS_ERROR
;
398 delete a record from the database
400 static int ltdb_delete(struct ldb_module
*module
, struct ldb_request
*req
)
402 struct ltdb_private
*ltdb
= talloc_get_type(module
->private_data
, struct ltdb_private
);
403 struct ltdb_context
*ltdb_ac
;
404 int tret
, ret
= LDB_SUCCESS
;
406 if (req
->controls
!= NULL
) {
407 ldb_debug(module
->ldb
, LDB_DEBUG_WARNING
, "Controls should not reach the ldb_tdb backend!\n");
408 if (check_critical_controls(req
->controls
)) {
409 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION
;
415 if (ltdb_cache_load(module
) != 0) {
416 return LDB_ERR_OPERATIONS_ERROR
;
419 req
->handle
= init_ltdb_handle(ltdb
, module
, req
->context
, req
->callback
);
420 if (req
->handle
== NULL
) {
421 return LDB_ERR_OPERATIONS_ERROR
;
423 ltdb_ac
= talloc_get_type(req
->handle
->private_data
, struct ltdb_context
);
425 tret
= ltdb_delete_internal(module
, req
->op
.del
.dn
);
426 if (tret
!= LDB_SUCCESS
) {
427 req
->handle
->status
= tret
;
431 if (ltdb_ac
->callback
) {
432 ret
= ltdb_ac
->callback(module
->ldb
, ltdb_ac
->context
, NULL
);
435 req
->handle
->state
= LDB_ASYNC_DONE
;
440 find an element by attribute name. At the moment this does a linear search, it should
441 be re-coded to use a binary search once all places that modify records guarantee
444 return the index of the first matching element if found, otherwise -1
446 static int find_element(const struct ldb_message
*msg
, const char *name
)
449 for (i
=0;i
<msg
->num_elements
;i
++) {
450 if (ldb_attr_cmp(msg
->elements
[i
].name
, name
) == 0) {
459 add an element to an existing record. Assumes a elements array that we
460 can call re-alloc on, and assumed that we can re-use the data pointers from the
461 passed in additional values. Use with care!
463 returns 0 on success, -1 on failure (and sets errno)
465 static int msg_add_element(struct ldb_context
*ldb
,
466 struct ldb_message
*msg
, struct ldb_message_element
*el
)
468 struct ldb_message_element
*e2
;
471 e2
= talloc_realloc(msg
, msg
->elements
, struct ldb_message_element
,
472 msg
->num_elements
+1);
480 e2
= &msg
->elements
[msg
->num_elements
];
483 e2
->flags
= el
->flags
;
485 if (el
->num_values
!= 0) {
486 e2
->values
= talloc_array(msg
->elements
, struct ldb_val
, el
->num_values
);
492 for (i
=0;i
<el
->num_values
;i
++) {
493 e2
->values
[i
] = el
->values
[i
];
495 e2
->num_values
= el
->num_values
;
503 delete all elements having a specified attribute name
505 static int msg_delete_attribute(struct ldb_module
*module
,
506 struct ldb_context
*ldb
,
507 struct ldb_message
*msg
, const char *name
)
512 dn
= ldb_dn_linearize(ldb
, msg
->dn
);
517 for (i
=0;i
<msg
->num_elements
;i
++) {
518 if (ldb_attr_cmp(msg
->elements
[i
].name
, name
) == 0) {
519 for (j
=0;j
<msg
->elements
[i
].num_values
;j
++) {
520 ltdb_index_del_value(module
, dn
, &msg
->elements
[i
], j
);
522 talloc_free(msg
->elements
[i
].values
);
523 if (msg
->num_elements
> (i
+1)) {
524 memmove(&msg
->elements
[i
],
526 sizeof(struct ldb_message_element
)*
527 (msg
->num_elements
- (i
+1)));
531 msg
->elements
= talloc_realloc(msg
, msg
->elements
,
532 struct ldb_message_element
,
542 delete all elements matching an attribute name/value
544 return 0 on success, -1 on failure
546 static int msg_delete_element(struct ldb_module
*module
,
547 struct ldb_message
*msg
,
549 const struct ldb_val
*val
)
551 struct ldb_context
*ldb
= module
->ldb
;
554 struct ldb_message_element
*el
;
555 const struct ldb_attrib_handler
*h
;
557 found
= find_element(msg
, name
);
562 el
= &msg
->elements
[found
];
564 h
= ldb_attrib_handler(ldb
, el
->name
);
566 for (i
=0;i
<el
->num_values
;i
++) {
567 if (h
->comparison_fn(ldb
, ldb
, &el
->values
[i
], val
) == 0) {
568 if (i
<el
->num_values
-1) {
569 memmove(&el
->values
[i
], &el
->values
[i
+1],
570 sizeof(el
->values
[i
])*(el
->num_values
-(i
+1)));
573 if (el
->num_values
== 0) {
574 return msg_delete_attribute(module
, ldb
, msg
, name
);
585 modify a record - internal interface
587 yuck - this is O(n^2). Luckily n is usually small so we probably
588 get away with it, but if we ever have really large attribute lists
589 then we'll need to look at this again
591 int ltdb_modify_internal(struct ldb_module
*module
, const struct ldb_message
*msg
)
593 struct ldb_context
*ldb
= module
->ldb
;
594 struct ltdb_private
*ltdb
=
595 talloc_get_type(module
->private_data
, struct ltdb_private
);
596 TDB_DATA tdb_key
, tdb_data
;
597 struct ldb_message
*msg2
;
601 tdb_key
= ltdb_key(module
, msg
->dn
);
603 return LDB_ERR_OTHER
;
606 tdb_data
= tdb_fetch(ltdb
->tdb
, tdb_key
);
607 if (!tdb_data
.dptr
) {
608 talloc_free(tdb_key
.dptr
);
609 return ltdb_err_map(tdb_error(ltdb
->tdb
));
612 msg2
= talloc(tdb_key
.dptr
, struct ldb_message
);
614 talloc_free(tdb_key
.dptr
);
615 return LDB_ERR_OTHER
;
618 ret
= ltdb_unpack_data(module
, &tdb_data
, msg2
);
628 for (i
=0;i
<msg
->num_elements
;i
++) {
629 struct ldb_message_element
*el
= &msg
->elements
[i
];
630 struct ldb_message_element
*el2
;
631 struct ldb_val
*vals
;
634 switch (msg
->elements
[i
].flags
& LDB_FLAG_MOD_MASK
) {
636 case LDB_FLAG_MOD_ADD
:
637 /* add this element to the message. fail if it
639 ret
= find_element(msg2
, el
->name
);
642 if (msg_add_element(ldb
, msg2
, el
) != 0) {
649 el2
= &msg2
->elements
[ret
];
651 /* An attribute with this name already exists, add all
652 * values if they don't already exist. */
654 for (j
=0;j
<el
->num_values
;j
++) {
655 if (ldb_msg_find_val(el2
, &el
->values
[j
])) {
656 ldb_set_errstring(module
->ldb
, "Type or value exists");
657 ret
= LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS
;
662 vals
= talloc_realloc(msg2
->elements
, el2
->values
, struct ldb_val
,
663 el2
->num_values
+ el
->num_values
);
670 for (j
=0;j
<el
->num_values
;j
++) {
671 vals
[el2
->num_values
+ j
] =
672 ldb_val_dup(vals
, &el
->values
[j
]);
676 el2
->num_values
+= el
->num_values
;
680 case LDB_FLAG_MOD_REPLACE
:
681 /* replace all elements of this attribute name with the elements
682 listed. The attribute not existing is not an error */
683 msg_delete_attribute(module
, ldb
, msg2
, msg
->elements
[i
].name
);
685 /* add the replacement element, if not empty */
686 if (msg
->elements
[i
].num_values
!= 0 &&
687 msg_add_element(ldb
, msg2
, &msg
->elements
[i
]) != 0) {
693 case LDB_FLAG_MOD_DELETE
:
695 dn
= ldb_dn_linearize(msg2
, msg
->dn
);
701 /* we could be being asked to delete all
702 values or just some values */
703 if (msg
->elements
[i
].num_values
== 0) {
704 if (msg_delete_attribute(module
, ldb
, msg2
,
705 msg
->elements
[i
].name
) != 0) {
706 ldb_asprintf_errstring(module
->ldb
, "No such attribute: %s for delete on %s", msg
->elements
[i
].name
, dn
);
707 ret
= LDB_ERR_NO_SUCH_ATTRIBUTE
;
712 for (j
=0;j
<msg
->elements
[i
].num_values
;j
++) {
713 if (msg_delete_element(module
,
715 msg
->elements
[i
].name
,
716 &msg
->elements
[i
].values
[j
]) != 0) {
717 ldb_asprintf_errstring(module
->ldb
, "No matching attribute value when deleting attribute: %s on %s", msg
->elements
[i
].name
, dn
);
718 ret
= LDB_ERR_NO_SUCH_ATTRIBUTE
;
721 if (ltdb_index_del_value(module
, dn
, &msg
->elements
[i
], j
) != 0) {
728 ldb_asprintf_errstring(module
->ldb
, "Invalid ldb_modify flags on %s: 0x%x",
729 msg
->elements
[i
].name
,
730 msg
->elements
[i
].flags
& LDB_FLAG_MOD_MASK
);
731 ret
= LDB_ERR_PROTOCOL_ERROR
;
736 /* we've made all the mods - save the modified record back into the database */
737 ret
= ltdb_store(module
, msg2
, TDB_MODIFY
);
738 if (ret
!= LDB_SUCCESS
) {
742 if (ltdb_modified(module
, msg
->dn
) != LDB_SUCCESS
) {
743 ret
= LDB_ERR_OPERATIONS_ERROR
;
747 talloc_free(tdb_key
.dptr
);
752 talloc_free(tdb_key
.dptr
);
760 static int ltdb_modify(struct ldb_module
*module
, struct ldb_request
*req
)
762 struct ltdb_private
*ltdb
= talloc_get_type(module
->private_data
, struct ltdb_private
);
763 struct ltdb_context
*ltdb_ac
;
764 int tret
, ret
= LDB_SUCCESS
;
766 if (req
->controls
!= NULL
) {
767 ldb_debug(module
->ldb
, LDB_DEBUG_WARNING
, "Controls should not reach the ldb_tdb backend!\n");
768 if (check_critical_controls(req
->controls
)) {
769 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION
;
775 req
->handle
= init_ltdb_handle(ltdb
, module
, req
->context
, req
->callback
);
776 if (req
->handle
== NULL
) {
777 return LDB_ERR_OPERATIONS_ERROR
;
779 ltdb_ac
= talloc_get_type(req
->handle
->private_data
, struct ltdb_context
);
781 tret
= ltdb_check_special_dn(module
, req
->op
.mod
.message
);
782 if (tret
!= LDB_SUCCESS
) {
783 req
->handle
->status
= tret
;
787 if (ltdb_cache_load(module
) != 0) {
788 ret
= LDB_ERR_OPERATIONS_ERROR
;
792 tret
= ltdb_modify_internal(module
, req
->op
.mod
.message
);
793 if (tret
!= LDB_SUCCESS
) {
794 req
->handle
->status
= tret
;
798 if (ltdb_ac
->callback
) {
799 ret
= ltdb_ac
->callback(module
->ldb
, ltdb_ac
->context
, NULL
);
802 req
->handle
->state
= LDB_ASYNC_DONE
;
809 static int ltdb_rename(struct ldb_module
*module
, struct ldb_request
*req
)
811 struct ltdb_private
*ltdb
= talloc_get_type(module
->private_data
, struct ltdb_private
);
812 struct ltdb_context
*ltdb_ac
;
813 struct ldb_message
*msg
;
814 int tret
, ret
= LDB_SUCCESS
;
816 if (req
->controls
!= NULL
) {
817 ldb_debug(module
->ldb
, LDB_DEBUG_WARNING
, "Controls should not reach the ldb_tdb backend!\n");
818 if (check_critical_controls(req
->controls
)) {
819 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION
;
825 if (ltdb_cache_load(module
) != 0) {
826 return LDB_ERR_OPERATIONS_ERROR
;
829 req
->handle
= init_ltdb_handle(ltdb
, module
, req
->context
, req
->callback
);
830 if (req
->handle
== NULL
) {
831 return LDB_ERR_OPERATIONS_ERROR
;
833 ltdb_ac
= talloc_get_type(req
->handle
->private_data
, struct ltdb_context
);
835 msg
= talloc(ltdb_ac
, struct ldb_message
);
837 ret
= LDB_ERR_OPERATIONS_ERROR
;
841 /* in case any attribute of the message was indexed, we need
842 to fetch the old record */
843 tret
= ltdb_search_dn1(module
, req
->op
.rename
.olddn
, msg
);
845 /* not finding the old record is an error */
846 req
->handle
->status
= LDB_ERR_NO_SUCH_OBJECT
;
850 msg
->dn
= ldb_dn_copy(msg
, req
->op
.rename
.newdn
);
852 ret
= LDB_ERR_OPERATIONS_ERROR
;
856 tret
= ltdb_add_internal(module
, msg
);
857 if (tret
!= LDB_SUCCESS
) {
858 ret
= LDB_ERR_OPERATIONS_ERROR
;
862 tret
= ltdb_delete_internal(module
, req
->op
.rename
.olddn
);
863 if (tret
!= LDB_SUCCESS
) {
864 ltdb_delete_internal(module
, req
->op
.rename
.newdn
);
865 ret
= LDB_ERR_OPERATIONS_ERROR
;
869 if (ltdb_ac
->callback
) {
870 ret
= ltdb_ac
->callback(module
->ldb
, ltdb_ac
->context
, NULL
);
873 req
->handle
->state
= LDB_ASYNC_DONE
;
877 static int ltdb_start_trans(struct ldb_module
*module
)
879 struct ltdb_private
*ltdb
=
880 talloc_get_type(module
->private_data
, struct ltdb_private
);
882 if (tdb_transaction_start(ltdb
->tdb
) != 0) {
883 return ltdb_err_map(tdb_error(ltdb
->tdb
));
889 static int ltdb_end_trans(struct ldb_module
*module
)
891 struct ltdb_private
*ltdb
=
892 talloc_get_type(module
->private_data
, struct ltdb_private
);
894 if (tdb_transaction_commit(ltdb
->tdb
) != 0) {
895 return ltdb_err_map(tdb_error(ltdb
->tdb
));
901 static int ltdb_del_trans(struct ldb_module
*module
)
903 struct ltdb_private
*ltdb
=
904 talloc_get_type(module
->private_data
, struct ltdb_private
);
906 if (tdb_transaction_cancel(ltdb
->tdb
) != 0) {
907 return ltdb_err_map(tdb_error(ltdb
->tdb
));
913 static int ltdb_wait(struct ldb_handle
*handle
, enum ldb_wait_type type
)
915 return handle
->status
;
918 static int ltdb_request(struct ldb_module
*module
, struct ldb_request
*req
)
920 /* check for oustanding critical controls and return an error if found */
921 if (req
->controls
!= NULL
) {
922 ldb_debug(module
->ldb
, LDB_DEBUG_WARNING
, "Controls should not reach the ldb_tdb backend!\n");
923 if (check_critical_controls(req
->controls
)) {
924 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION
;
928 /* search, add, modify, delete, rename are handled by their own, no other op supported */
929 return LDB_ERR_OPERATIONS_ERROR
;
933 return sequenceNumber from @BASEINFO
935 static int ltdb_sequence_number(struct ldb_module
*module
, struct ldb_request
*req
)
937 TALLOC_CTX
*tmp_ctx
= talloc_new(req
);
938 struct ldb_message
*msg
= NULL
;
939 struct ldb_dn
*dn
= ldb_dn_explode(tmp_ctx
, LTDB_BASEINFO
);
942 if (tmp_ctx
== NULL
) {
943 talloc_free(tmp_ctx
);
944 return LDB_ERR_OPERATIONS_ERROR
;
947 msg
= talloc(tmp_ctx
, struct ldb_message
);
949 talloc_free(tmp_ctx
);
950 return LDB_ERR_OPERATIONS_ERROR
;
953 req
->op
.seq_num
.flags
= 0;
955 tret
= ltdb_search_dn1(module
, dn
, msg
);
957 talloc_free(tmp_ctx
);
958 req
->op
.seq_num
.seq_num
= 0;
959 /* zero is as good as anything when we don't know */
963 switch (req
->op
.seq_num
.type
) {
964 case LDB_SEQ_HIGHEST_SEQ
:
965 req
->op
.seq_num
.seq_num
= ldb_msg_find_attr_as_uint64(msg
, LTDB_SEQUENCE_NUMBER
, 0);
968 req
->op
.seq_num
.seq_num
= ldb_msg_find_attr_as_uint64(msg
, LTDB_SEQUENCE_NUMBER
, 0);
969 req
->op
.seq_num
.seq_num
++;
971 case LDB_SEQ_HIGHEST_TIMESTAMP
:
973 const char *date
= ldb_msg_find_attr_as_string(msg
, LTDB_MOD_TIMESTAMP
, NULL
);
975 req
->op
.seq_num
.seq_num
= ldb_string_to_time(date
);
977 req
->op
.seq_num
.seq_num
= 0;
978 /* zero is as good as anything when we don't know */
983 talloc_free(tmp_ctx
);
987 static const struct ldb_module_ops ltdb_ops
= {
989 .search
= ltdb_search
,
991 .modify
= ltdb_modify
,
993 .rename
= ltdb_rename
,
994 .request
= ltdb_request
,
995 .start_transaction
= ltdb_start_trans
,
996 .end_transaction
= ltdb_end_trans
,
997 .del_transaction
= ltdb_del_trans
,
999 .sequence_number
= ltdb_sequence_number
1003 connect to the database
1005 static int ltdb_connect(struct ldb_context
*ldb
, const char *url
,
1006 unsigned int flags
, const char *options
[],
1007 struct ldb_module
**module
)
1010 int tdb_flags
, open_flags
;
1011 struct ltdb_private
*ltdb
;
1014 if (strchr(url
, ':')) {
1015 if (strncmp(url
, "tdb://", 6) != 0) {
1016 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "Invalid tdb URL '%s'", url
);
1024 tdb_flags
= TDB_DEFAULT
;
1026 /* check for the 'nosync' option */
1027 if (flags
& LDB_FLG_NOSYNC
) {
1028 tdb_flags
|= TDB_NOSYNC
;
1031 if (flags
& LDB_FLG_RDONLY
) {
1032 open_flags
= O_RDONLY
;
1034 open_flags
= O_CREAT
| O_RDWR
;
1037 ltdb
= talloc_zero(ldb
, struct ltdb_private
);
1043 /* note that we use quite a large default hash size */
1044 ltdb
->tdb
= ltdb_wrap_open(ltdb
, path
, 10000,
1045 tdb_flags
, open_flags
,
1046 ldb
->create_perms
, ldb
);
1048 ldb_debug(ldb
, LDB_DEBUG_ERROR
, "Unable to open tdb '%s'\n", path
);
1053 ltdb
->sequence_number
= 0;
1055 *module
= talloc(ldb
, struct ldb_module
);
1061 (*module
)->ldb
= ldb
;
1062 (*module
)->prev
= (*module
)->next
= NULL
;
1063 (*module
)->private_data
= ltdb
;
1064 (*module
)->ops
= <db_ops
;
1069 int ldb_tdb_init(void)
1071 return ldb_register_backend("tdb", ltdb_connect
);