4 Copyright (C) Andrew Tridgell 2004
6 ** NOTE! The following LGPL license applies to the ldb
7 ** library. This does NOT imply that all of Samba is released
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 3 of the License, or (at your option) any later version.
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 * Component: ldb search functions
29 * Description: functions to search ldb+tdb databases
31 * Author: Andrew Tridgell
34 #include "ldb_includes.h"
39 add one element to a message
41 static int msg_add_element(struct ldb_message
*ret
,
42 const struct ldb_message_element
*el
,
46 struct ldb_message_element
*e2
, *elnew
;
48 if (check_duplicates
&& ldb_msg_find_element(ret
, el
->name
)) {
49 /* its already there */
53 e2
= talloc_realloc(ret
, ret
->elements
, struct ldb_message_element
, ret
->num_elements
+1);
59 elnew
= &e2
[ret
->num_elements
];
61 elnew
->name
= talloc_strdup(ret
->elements
, el
->name
);
67 elnew
->values
= talloc_array(ret
->elements
, struct ldb_val
, el
->num_values
);
75 for (i
=0;i
<el
->num_values
;i
++) {
76 elnew
->values
[i
] = ldb_val_dup(elnew
->values
, &el
->values
[i
]);
77 if (elnew
->values
[i
].length
!= el
->values
[i
].length
) {
82 elnew
->num_values
= el
->num_values
;
90 add the special distinguishedName element
92 static int msg_add_distinguished_name(struct ldb_message
*msg
)
94 struct ldb_message_element el
;
99 el
.name
= "distinguishedName";
102 val
.data
= (uint8_t *)ldb_dn_alloc_linearized(msg
, msg
->dn
);
103 val
.length
= strlen((char *)val
.data
);
105 ret
= msg_add_element(msg
, &el
, 1);
110 add all elements from one message into another
112 static int msg_add_all_elements(struct ldb_module
*module
, struct ldb_message
*ret
,
113 const struct ldb_message
*msg
)
115 struct ldb_context
*ldb
= module
->ldb
;
117 int check_duplicates
= (ret
->num_elements
!= 0);
119 if (msg_add_distinguished_name(ret
) != 0) {
123 for (i
=0;i
<msg
->num_elements
;i
++) {
124 const struct ldb_schema_attribute
*a
;
125 a
= ldb_schema_attribute_by_name(ldb
, msg
->elements
[i
].name
);
126 if (a
->flags
& LDB_ATTR_FLAG_HIDDEN
) {
129 if (msg_add_element(ret
, &msg
->elements
[i
],
130 check_duplicates
) != 0) {
140 pull the specified list of attributes from a message
142 static struct ldb_message
*ltdb_pull_attrs(struct ldb_module
*module
,
144 const struct ldb_message
*msg
,
145 const char * const *attrs
)
147 struct ldb_message
*ret
;
150 ret
= talloc(mem_ctx
, struct ldb_message
);
155 ret
->dn
= ldb_dn_copy(ret
, msg
->dn
);
161 ret
->num_elements
= 0;
162 ret
->elements
= NULL
;
165 if (msg_add_all_elements(module
, ret
, msg
) != 0) {
172 for (i
=0;attrs
[i
];i
++) {
173 struct ldb_message_element
*el
;
175 if (strcmp(attrs
[i
], "*") == 0) {
176 if (msg_add_all_elements(module
, ret
, msg
) != 0) {
183 if (ldb_attr_cmp(attrs
[i
], "distinguishedName") == 0) {
184 if (msg_add_distinguished_name(ret
) != 0) {
190 el
= ldb_msg_find_element(msg
, attrs
[i
]);
194 if (msg_add_element(ret
, el
, 1) != 0) {
204 search the database for a single simple dn.
205 return LDB_ERR_NO_SUCH_OBJECT on record-not-found
206 and LDB_SUCCESS on success
208 int ltdb_search_base(struct ldb_module
*module
, struct ldb_dn
*dn
)
210 struct ltdb_private
*ltdb
= (struct ltdb_private
*)module
->private_data
;
211 TDB_DATA tdb_key
, tdb_data
;
213 if (ldb_dn_is_null(dn
)) {
214 return LDB_ERR_NO_SUCH_OBJECT
;
218 tdb_key
= ltdb_key(module
, dn
);
220 return LDB_ERR_OPERATIONS_ERROR
;
223 tdb_data
= tdb_fetch(ltdb
->tdb
, tdb_key
);
224 talloc_free(tdb_key
.dptr
);
225 if (!tdb_data
.dptr
) {
226 return LDB_ERR_NO_SUCH_OBJECT
;
234 search the database for a single simple dn, returning all attributes
237 return LDB_ERR_NO_SUCH_OBJECT on record-not-found
238 and LDB_SUCCESS on success
240 int ltdb_search_dn1(struct ldb_module
*module
, struct ldb_dn
*dn
, struct ldb_message
*msg
)
242 struct ltdb_private
*ltdb
= (struct ltdb_private
*)module
->private_data
;
244 TDB_DATA tdb_key
, tdb_data
;
246 memset(msg
, 0, sizeof(*msg
));
249 tdb_key
= ltdb_key(module
, dn
);
251 return LDB_ERR_OPERATIONS_ERROR
;
254 tdb_data
= tdb_fetch(ltdb
->tdb
, tdb_key
);
255 talloc_free(tdb_key
.dptr
);
256 if (!tdb_data
.dptr
) {
257 return LDB_ERR_NO_SUCH_OBJECT
;
260 msg
->num_elements
= 0;
261 msg
->elements
= NULL
;
263 ret
= ltdb_unpack_data(module
, &tdb_data
, msg
);
266 return LDB_ERR_OPERATIONS_ERROR
;
270 msg
->dn
= ldb_dn_copy(msg
, dn
);
273 return LDB_ERR_OPERATIONS_ERROR
;
280 add a set of attributes from a record to a set of results
281 return 0 on success, -1 on failure
283 int ltdb_add_attr_results(struct ldb_module
*module
,
285 struct ldb_message
*msg
,
286 const char * const attrs
[],
288 struct ldb_message
***res
)
290 struct ldb_message
*msg2
;
291 struct ldb_message
**res2
;
293 /* pull the attributes that the user wants */
294 msg2
= ltdb_pull_attrs(module
, mem_ctx
, msg
, attrs
);
299 /* add to the results list */
300 res2
= talloc_realloc(mem_ctx
, *res
, struct ldb_message
*, (*count
)+2);
308 (*res
)[*count
] = talloc_move(*res
, &msg2
);
309 (*res
)[(*count
)+1] = NULL
;
318 filter the specified list of attributes from a message
319 removing not requested attrs.
321 int ltdb_filter_attrs(struct ldb_message
*msg
, const char * const *attrs
)
326 /* check for special attrs */
327 for (i
= 0; attrs
[i
]; i
++) {
328 if (strcmp(attrs
[i
], "*") == 0) {
333 if (ldb_attr_cmp(attrs
[i
], "distinguishedName") == 0) {
334 if (msg_add_distinguished_name(msg
) != 0) {
344 if (msg_add_distinguished_name(msg
) != 0) {
350 for (i
= 0; i
< msg
->num_elements
; i
++) {
353 for (j
= 0, found
= 0; attrs
[j
]; j
++) {
354 if (ldb_attr_cmp(msg
->elements
[i
].name
, attrs
[j
]) == 0) {
361 ldb_msg_remove_attr(msg
, msg
->elements
[i
].name
);
370 search function for a non-indexed search
372 static int search_func(struct tdb_context
*tdb
, TDB_DATA key
, TDB_DATA data
, void *state
)
374 struct ltdb_context
*ac
;
375 struct ldb_message
*msg
;
378 ac
= talloc_get_type(state
, struct ltdb_context
);
381 strncmp((char *)key
.dptr
, "DN=", 3) != 0) {
385 msg
= ldb_msg_new(ac
);
390 /* unpack the record */
391 ret
= ltdb_unpack_data(ac
->module
, &data
, msg
);
398 msg
->dn
= ldb_dn_new(msg
, ac
->module
->ldb
,
399 (char *)key
.dptr
+ 3);
400 if (msg
->dn
== NULL
) {
406 /* see if it matches the given expression */
407 if (!ldb_match_msg(ac
->module
->ldb
, msg
,
408 ac
->tree
, ac
->base
, ac
->scope
)) {
413 /* filter the attributes that the user wants */
414 ret
= ltdb_filter_attrs(msg
, ac
->attrs
);
421 ret
= ldb_module_send_entry(ac
->req
, msg
);
422 if (ret
!= LDB_SUCCESS
) {
423 ac
->callback_failed
= true;
424 /* the callback failed, abort the operation */
433 search the database with a LDAP-like expression.
434 this is the "full search" non-indexed variant
436 static int ltdb_search_full(struct ltdb_context
*ctx
)
438 struct ltdb_private
*ltdb
= talloc_get_type(ctx
->module
->private_data
, struct ltdb_private
);
441 if (ltdb
->in_transaction
!= 0) {
442 ret
= tdb_traverse(ltdb
->tdb
, search_func
, ctx
);
444 ret
= tdb_traverse_read(ltdb
->tdb
, search_func
, ctx
);
448 return LDB_ERR_OPERATIONS_ERROR
;
455 search the database with a LDAP-like expression.
456 choses a search method
458 int ltdb_search(struct ltdb_context
*ctx
)
460 struct ldb_module
*module
= ctx
->module
;
461 struct ldb_request
*req
= ctx
->req
;
462 struct ltdb_private
*ltdb
= talloc_get_type(module
->private_data
, struct ltdb_private
);
465 req
->handle
->state
= LDB_ASYNC_PENDING
;
467 if (ltdb_lock_read(module
) != 0) {
468 return LDB_ERR_OPERATIONS_ERROR
;
471 if (ltdb_cache_load(module
) != 0) {
472 ltdb_unlock_read(module
);
473 return LDB_ERR_OPERATIONS_ERROR
;
476 if (req
->op
.search
.tree
== NULL
) {
477 ltdb_unlock_read(module
);
478 return LDB_ERR_OPERATIONS_ERROR
;
481 if ((req
->op
.search
.base
== NULL
) || (ldb_dn_is_null(req
->op
.search
.base
) == true)) {
483 /* Check what we should do with a NULL dn */
484 switch (req
->op
.search
.scope
) {
486 ldb_asprintf_errstring(module
->ldb
,
487 "NULL Base DN invalid for a base search");
488 ret
= LDB_ERR_INVALID_DN_SYNTAX
;
490 case LDB_SCOPE_ONELEVEL
:
491 ldb_asprintf_errstring(module
->ldb
,
492 "NULL Base DN invalid for a one-level search");
493 ret
= LDB_ERR_INVALID_DN_SYNTAX
;
495 case LDB_SCOPE_SUBTREE
:
497 /* We accept subtree searches from a NULL base DN, ie over the whole DB */
500 } else if (ldb_dn_is_valid(req
->op
.search
.base
) == false) {
502 /* We don't want invalid base DNs here */
503 ldb_asprintf_errstring(module
->ldb
,
504 "Invalid Base DN: %s",
505 ldb_dn_get_linearized(req
->op
.search
.base
));
506 ret
= LDB_ERR_INVALID_DN_SYNTAX
;
508 } else if (ltdb
->check_base
) {
509 /* This database has been marked as 'checkBaseOnSearch', so do a spot check of the base dn */
510 ret
= ltdb_search_base(module
, req
->op
.search
.base
);
512 if (ret
== LDB_ERR_NO_SUCH_OBJECT
) {
513 ldb_asprintf_errstring(module
->ldb
,
514 "No such Base DN: %s",
515 ldb_dn_get_linearized(req
->op
.search
.base
));
519 /* If we are not checking the base DN life is easy */
523 ctx
->tree
= req
->op
.search
.tree
;
524 ctx
->scope
= req
->op
.search
.scope
;
525 ctx
->base
= req
->op
.search
.base
;
526 ctx
->attrs
= req
->op
.search
.attrs
;
528 if (ret
== LDB_SUCCESS
) {
529 ret
= ltdb_search_indexed(ctx
);
530 if (ret
== LDB_ERR_NO_SUCH_OBJECT
) {
531 /* Not in the index, therefore OK! */
535 /* Check if we got just a normal error.
536 * In that case proceed to a full search unless we got a
538 if ( ! ctx
->callback_failed
&& ret
!= LDB_SUCCESS
) {
539 /* Not indexed, so we need to do a full scan */
540 ret
= ltdb_search_full(ctx
);
541 if (ret
!= LDB_SUCCESS
) {
542 ldb_set_errstring(module
->ldb
, "Indexed and full searches both failed!\n");
547 ltdb_unlock_read(module
);