The branch, master has been updated
via cd9f993ec45c6d95e83f759ffd6bccffd90250b6 (commit)
via b2901da479f5e711986de48df4910910460fe7db (commit)
via f14a2b3386e9f44111cee010f6864602e5b833cd (commit)
via 51baa8deec00244cc0a6e3d29c53932427800610 (commit)
via 4f40ee2b86007f7dc631e93e59f24f970bc25ea2 (commit)
via 9f7c2548d9da848397b4730f02c7c47f23e259dc (commit)
via 0aeade2007ef789f5970efe2b69ff7fb83a12b83 (commit)
via 82153740911b16871cae043b6842810499b5cb55 (commit)
from eb935e08d388aab7e02f8ec0ce58b0a62808de5c (commit)
http://gitweb.samba.org/?p=samba.git;a=shortlog;h=master
- Log -----------------------------------------------------------------
commit cd9f993ec45c6d95e83f759ffd6bccffd90250b6
Author: Stefan Metzmacher <[EMAIL PROTECTED]>
Date: Sat Sep 27 21:36:18 2008 +0200
s4:lib/ldb: disable sqlite3 backend always as it doesn't compile anymore
metze
commit b2901da479f5e711986de48df4910910460fe7db
Author: Simo Sorce <[EMAIL PROTECTED]>
Date: Thu Sep 11 18:38:40 2008 -0400
LDB ASYNC: misc changes
commit f14a2b3386e9f44111cee010f6864602e5b833cd
Author: Simo Sorce <[EMAIL PROTECTED]>
Date: Fri Sep 12 13:27:15 2008 -0400
LDB ASYNC: ldb misc changes
commit 51baa8deec00244cc0a6e3d29c53932427800610
Author: Simo Sorce <[EMAIL PROTECTED]>
Date: Thu Sep 11 18:36:28 2008 -0400
LDB ASYNC: samba4 modules
commit 4f40ee2b86007f7dc631e93e59f24f970bc25ea2
Author: Simo Sorce <[EMAIL PROTECTED]>
Date: Thu Sep 11 18:35:38 2008 -0400
LDB ASYNC: core modules
commit 9f7c2548d9da848397b4730f02c7c47f23e259dc
Author: Simo Sorce <[EMAIL PROTECTED]>
Date: Thu Sep 11 18:34:56 2008 -0400
LDB ASYNC: other backends
commit 0aeade2007ef789f5970efe2b69ff7fb83a12b83
Author: Simo Sorce <[EMAIL PROTECTED]>
Date: Thu Sep 11 18:34:11 2008 -0400
LDB ASYNC: ldb_tdb backend
commit 82153740911b16871cae043b6842810499b5cb55
Author: Simo Sorce <[EMAIL PROTECTED]>
Date: Thu Sep 11 18:33:16 2008 -0400
LDB ASYNC: Core files
-----------------------------------------------------------------------
Summary of changes:
source4/cldap_server/rootdse.c | 21 +-
source4/dsdb/samdb/cracknames.c | 5 +-
source4/dsdb/samdb/ldb_modules/anr.c | 176 ++-
source4/dsdb/samdb/ldb_modules/extended_dn.c | 143 +-
source4/dsdb/samdb/ldb_modules/instancetype.c | 66 +-
source4/dsdb/samdb/ldb_modules/kludge_acl.c | 206 ++--
source4/dsdb/samdb/ldb_modules/linked_attributes.c | 1315 ++++++++--------
source4/dsdb/samdb/ldb_modules/local_password.c | 1124 ++++++++------
source4/dsdb/samdb/ldb_modules/normalise.c | 150 ++-
source4/dsdb/samdb/ldb_modules/objectclass.c | 752 ++++------
source4/dsdb/samdb/ldb_modules/objectguid.c | 101 +-
source4/dsdb/samdb/ldb_modules/partition.c | 595 ++++----
source4/dsdb/samdb/ldb_modules/password_hash.c | 731 ++++------
source4/dsdb/samdb/ldb_modules/proxy.c | 136 ++-
source4/dsdb/samdb/ldb_modules/ranged_results.c | 165 ++-
source4/dsdb/samdb/ldb_modules/repl_meta_data.c | 736 ++++------
source4/dsdb/samdb/ldb_modules/rootdse.c | 122 +-
source4/dsdb/samdb/ldb_modules/samldb.c | 1633 +++++++++++++-------
source4/dsdb/samdb/ldb_modules/schema_fsmo.c | 100 +-
source4/dsdb/samdb/ldb_modules/show_deleted.c | 166 +--
source4/dsdb/samdb/ldb_modules/simple_ldap_map.c | 53 +-
source4/dsdb/samdb/ldb_modules/subtree_delete.c | 232 +--
source4/dsdb/samdb/ldb_modules/subtree_rename.c | 332 ++---
source4/dsdb/samdb/ldb_modules/update_keytab.c | 245 +++-
source4/ldap_server/ldap_backend.c | 35 +-
source4/lib/ldb/common/ldb.c | 304 +++--
source4/lib/ldb/common/ldb_modules.c | 141 ++-
source4/lib/ldb/include/ldb.h | 105 +-
source4/lib/ldb/include/ldb_private.h | 98 +-
source4/lib/ldb/ldb.i | 5 +-
source4/lib/ldb/ldb_ildap/ldb_ildap.c | 483 +++---
source4/lib/ldb/ldb_ldap/ldb_ldap.c | 588 ++++----
source4/lib/ldb/ldb_map/ldb_map.c | 355 +----
source4/lib/ldb/ldb_map/ldb_map.h | 4 +-
source4/lib/ldb/ldb_map/ldb_map_inbound.c | 754 +++++----
source4/lib/ldb/ldb_map/ldb_map_outbound.c | 443 ++++---
source4/lib/ldb/ldb_map/ldb_map_private.h | 88 +-
source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c | 130 +-
source4/lib/ldb/ldb_tdb/ldb_index.c | 61 +-
source4/lib/ldb/ldb_tdb/ldb_search.c | 129 +-
source4/lib/ldb/ldb_tdb/ldb_tdb.c | 353 ++---
source4/lib/ldb/ldb_tdb/ldb_tdb.h | 14 +-
source4/lib/ldb/ldb_wrap.c | 22 +-
source4/lib/ldb/libldb.m4 | 6 +-
source4/lib/ldb/modules/asq.c | 419 ++---
source4/lib/ldb/modules/operational.c | 102 +-
source4/lib/ldb/modules/paged_results.c | 493 +++----
source4/lib/ldb/modules/paged_searches.c | 359 ++---
source4/lib/ldb/modules/rdn_name.c | 300 ++--
source4/lib/ldb/modules/sort.c | 369 ++---
source4/lib/ldb/tools/ldbsearch.c | 76 +-
source4/lib/ldb_wrap.c | 13 +-
source4/libcli/ldap/ldap_client.c | 2 +-
source4/torture/ldap/schema.c | 64 +-
54 files changed, 7944 insertions(+), 7676 deletions(-)
Changeset truncated at 500 lines:
diff --git a/source4/cldap_server/rootdse.c b/source4/cldap_server/rootdse.c
index 4ff71c0..65786e6 100644
--- a/source4/cldap_server/rootdse.c
+++ b/source4/cldap_server/rootdse.c
@@ -66,22 +66,19 @@ static void cldapd_rootdse_fill(struct cldapd_server
*cldapd,
attrs[i] = NULL;
}
- lreq = talloc(mem_ctx, struct ldb_request);
- if (lreq == NULL) goto nomem;
-
res = talloc_zero(mem_ctx, struct ldb_result);
if (res == NULL) goto nomem;
- lreq->operation = LDB_SEARCH;
- lreq->op.search.base = basedn;
- lreq->op.search.scope = scope;
- lreq->op.search.tree = search->tree;
- lreq->op.search.attrs = attrs;
-
- lreq->controls = NULL;
+ ldb_ret = ldb_build_search_req_ex(&lreq, cldapd->samctx, mem_ctx,
+ basedn, scope,
+ search->tree, attrs,
+ NULL,
+ res, ldb_search_default_callback,
+ NULL);
- lreq->context = res;
- lreq->callback = ldb_search_default_callback;
+ if (ldb_ret != LDB_SUCCESS) {
+ goto reply;
+ }
/* Copy the timeout from the incoming call */
ldb_set_timeout(cldapd->samctx, lreq, search->timelimit);
diff --git a/source4/dsdb/samdb/cracknames.c b/source4/dsdb/samdb/cracknames.c
index 7324d89..e02e8d8 100644
--- a/source4/dsdb/samdb/cracknames.c
+++ b/source4/dsdb/samdb/cracknames.c
@@ -797,7 +797,8 @@ static WERROR DsCrackNameOneFilter(struct ldb_context
*sam_ctx, TALLOC_CTX *mem_
result_attrs,
NULL,
res,
- ldb_search_default_callback);
+ ldb_search_default_callback,
+ NULL);
if (ret == LDB_SUCCESS) {
struct ldb_search_options_control
*search_options;
search_options = talloc(req, struct
ldb_search_options_control);
@@ -812,8 +813,6 @@ static WERROR DsCrackNameOneFilter(struct ldb_context
*sam_ctx, TALLOC_CTX *mem_
return WERR_OK;
}
- ldb_set_timeout(sam_ctx, req, 0); /* use default
timeout */
-
ret = ldb_request(sam_ctx, req);
if (ret == LDB_SUCCESS) {
diff --git a/source4/dsdb/samdb/ldb_modules/anr.c
b/source4/dsdb/samdb/ldb_modules/anr.c
index 4e2c527..028df58 100644
--- a/source4/dsdb/samdb/ldb_modules/anr.c
+++ b/source4/dsdb/samdb/ldb_modules/anr.c
@@ -1,7 +1,8 @@
/*
ldb database library
- Copyright (C) Amdrew Bartlett <[EMAIL PROTECTED]> 2007
+ Copyright (C) Andrew Bartlett <[EMAIL PROTECTED]> 2007
+ Copyright (C) Simo Sorce <[EMAIL PROTECTED]> 2008
Copyright (C) Andrew Tridgell 2004
This program is free software; you can redistribute it and/or modify
@@ -99,6 +100,7 @@ struct ldb_parse_tree *make_match_tree(struct ldb_module
*module,
struct anr_context {
bool found_anr;
struct ldb_module *module;
+ struct ldb_request *req;
};
/**
@@ -106,39 +108,35 @@ struct anr_context {
* parse tree with an 'or' of all the anr attributes in the schema.
*/
-typedef struct ldb_parse_tree *(*anr_parse_tree_callback_t)(TALLOC_CTX
*mem_ctx,
- const struct ldb_val
*match,
- void *context);
-
-
/**
- * Callback function to do the heavy lifting for the for the parse tree walker
+ * Callback function to do the heavy lifting for the parse tree walker
*/
-struct ldb_parse_tree *anr_replace_callback(TALLOC_CTX *mem_ctx,
- const struct ldb_val *match,
- void *context)
+static int anr_replace_value(struct anr_context *ac,
+ TALLOC_CTX *mem_ctx,
+ const struct ldb_val *match,
+ struct ldb_parse_tree **ntree)
{
struct ldb_parse_tree *tree = NULL;
- struct anr_context *anr_context = talloc_get_type(context, struct
anr_context);
- struct ldb_module *module = anr_context->module;
+ struct ldb_module *module = ac->module;
struct ldb_parse_tree *match_tree;
- uint8_t *p;
- enum ldb_parse_op op;
struct dsdb_attribute *cur;
const struct dsdb_schema *schema = dsdb_get_schema(module->ldb);
+ uint8_t *p;
+ enum ldb_parse_op op;
+
if (!schema) {
ldb_asprintf_errstring(module->ldb, "no schema with which to
construct anr filter");
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- anr_context->found_anr = true;
+ ac->found_anr = true;
if (match->length > 1 && match->data[0] == '=') {
- DATA_BLOB *match2 = talloc(tree, DATA_BLOB);
+ DATA_BLOB *match2 = talloc(mem_ctx, DATA_BLOB);
*match2 = data_blob_const(match->data+1, match->length - 1);
if (match2 == NULL){
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
match = match2;
op = LDB_OP_EQUALITY;
@@ -154,7 +152,7 @@ struct ldb_parse_tree *anr_replace_callback(TALLOC_CTX
*mem_ctx,
tree = make_parse_list(module, mem_ctx, LDB_OP_OR,
tree, match_tree);
if (tree == NULL) {
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
} else {
tree = match_tree;
@@ -173,7 +171,7 @@ struct ldb_parse_tree *anr_replace_callback(TALLOC_CTX
*mem_ctx,
DATA_BLOB *second_match = talloc(tree, DATA_BLOB);
if (!first_match || !second_match) {
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
*first_match = data_blob_const(match->data, p-match->data);
*second_match = data_blob_const(p+1, match->length -
(p-match->data) - 1);
@@ -183,26 +181,26 @@ struct ldb_parse_tree *anr_replace_callback(TALLOC_CTX
*mem_ctx,
match_tree_1 = make_match_tree(module, mem_ctx, op,
"givenName", first_match);
match_tree_2 = make_match_tree(module, mem_ctx, op, "sn",
second_match);
- first_split_filter = make_parse_list(module, context,
LDB_OP_AND, match_tree_1, match_tree_2);
+ first_split_filter = make_parse_list(module, ac, LDB_OP_AND,
match_tree_1, match_tree_2);
if (first_split_filter == NULL){
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
match_tree_1 = make_match_tree(module, mem_ctx, op, "sn",
first_match);
match_tree_2 = make_match_tree(module, mem_ctx, op,
"givenName", second_match);
- second_split_filter = make_parse_list(module, context,
LDB_OP_AND, match_tree_1, match_tree_2);
+ second_split_filter = make_parse_list(module, ac, LDB_OP_AND,
match_tree_1, match_tree_2);
if (second_split_filter == NULL){
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
split_filters = make_parse_list(module, mem_ctx, LDB_OP_OR,
first_split_filter,
second_split_filter);
if (split_filters == NULL) {
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (tree) {
@@ -212,38 +210,46 @@ struct ldb_parse_tree *anr_replace_callback(TALLOC_CTX
*mem_ctx,
tree = split_filters;
}
}
- return tree;
+ *ntree = tree;
+ return LDB_SUCCESS;
}
/*
replace any occurances of an attribute with a new, generated attribute tree
*/
-struct ldb_parse_tree *anr_replace_subtrees(struct ldb_parse_tree *tree,
- const char *attr,
- anr_parse_tree_callback_t callback,
- void *context)
+static int anr_replace_subtrees(struct anr_context *ac,
+ struct ldb_parse_tree *tree,
+ const char *attr,
+ struct ldb_parse_tree **ntree)
{
+ int ret;
int i;
- struct ldb_parse_tree *tmp;
switch (tree->operation) {
case LDB_OP_AND:
case LDB_OP_OR:
for (i=0;i<tree->u.list.num_elements;i++) {
- tmp = anr_replace_subtrees(tree->u.list.elements[i],
- attr, callback, context);
- if (tmp) tree->u.list.elements[i] = tmp;
+ ret = anr_replace_subtrees(ac, tree->u.list.elements[i],
+ attr,
&tree->u.list.elements[i]);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ *ntree = tree;
}
break;
case LDB_OP_NOT:
- tmp = anr_replace_subtrees(tree->u.isnot.child, attr, callback,
context);
- if (tmp) tree->u.isnot.child = tmp;
+ ret = anr_replace_subtrees(ac, tree->u.isnot.child, attr,
&tree->u.isnot.child);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ *ntree = tree;
break;
case LDB_OP_EQUALITY:
if (ldb_attr_cmp(tree->u.equality.attr, attr) == 0) {
- tmp = callback(tree, &tree->u.equality.value,
- context);
- if (tmp) tree = tmp;
+ ret = anr_replace_value(ac, tree,
&tree->u.equality.value, ntree);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
break;
case LDB_OP_SUBSTRING:
@@ -252,53 +258,97 @@ struct ldb_parse_tree *anr_replace_subtrees(struct
ldb_parse_tree *tree,
tree->u.substring.end_with_wildcard == 1 &&
tree->u.substring.chunks[0] != NULL &&
tree->u.substring.chunks[1] == NULL) {
- tmp = callback(tree,
tree->u.substring.chunks[0], context);
- if (tmp) tree = tmp;
+ ret = anr_replace_value(ac, tree,
tree->u.substring.chunks[0], ntree);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
}
break;
+ default:
+ break;
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int anr_search_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct anr_context *ac;
+
+ ac = talloc_get_type(req->context, struct anr_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ return ldb_module_send_entry(ac->req, ares->message);
+
+ case LDB_REPLY_REFERRAL:
+ return ldb_module_send_referral(ac->req, ares->referral);
+
+ case LDB_REPLY_DONE:
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+
}
- return tree;
+ return LDB_SUCCESS;
}
/* search */
static int anr_search(struct ldb_module *module, struct ldb_request *req)
{
struct ldb_parse_tree *anr_tree;
- struct anr_context *context = talloc(req, struct anr_context);
- if (!context) {
+ struct ldb_request *down_req;
+ struct anr_context *ac;
+ int ret;
+
+ ac = talloc(req, struct anr_context);
+ if (!ac) {
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- context->module = module;
- context->found_anr = false;
+ ac->module = module;
+ ac->req = req;
+ ac->found_anr = false;
#if 0
printf("oldanr : %s\n", ldb_filter_from_tree (0, req->op.search.tree));
#endif
- /* Yes, this is a problem with req->op.search.tree being const... */
- anr_tree = anr_replace_subtrees(req->op.search.tree, "anr",
anr_replace_callback, context);
- if (!anr_tree) {
- talloc_free(context);
+ ret = anr_replace_subtrees(ac, req->op.search.tree, "anr", &anr_tree);
+ if (ret != LDB_SUCCESS) {
return LDB_ERR_OPERATIONS_ERROR;
}
- if (context->found_anr) {
- /* The above function modifies the tree if it finds "anr", so no
- * point just setting this on the down_req */
-#if 0
- printf("newtree: %s\n", ldb_filter_from_tree (0, anr_tree));
-#endif
- req->op.search.tree = talloc_steal(req, anr_tree);
- } else {
- if (anr_tree != req->op.search.tree) {
- talloc_free(anr_tree);
- }
- talloc_free(context);
+ if (!ac->found_anr) {
+ talloc_free(ac);
+ return ldb_next_request(module, req);
}
- return ldb_next_request(module, req);
+
+ ret = ldb_build_search_req_ex(&down_req,
+ module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ anr_tree,
+ req->op.search.attrs,
+ req->controls,
+ ac, anr_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ talloc_steal(down_req, anr_tree);
+
+ return ldb_next_request(module, down_req);
}
_PUBLIC_ const struct ldb_module_ops ldb_anr_module_ops = {
diff --git a/source4/dsdb/samdb/ldb_modules/extended_dn.c
b/source4/dsdb/samdb/ldb_modules/extended_dn.c
index 84bf5e4..e40190e 100644
--- a/source4/dsdb/samdb/ldb_modules/extended_dn.c
+++ b/source4/dsdb/samdb/ldb_modules/extended_dn.c
@@ -1,7 +1,7 @@
/*
ldb database library
- Copyright (C) Simo Sorce 2005
+ Copyright (C) Simo Sorce 2005-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
@@ -95,7 +95,7 @@ static bool add_attrs(void *mem_ctx, char ***attrs, const
char *attr)
return true;
}
-static bool inject_extended_dn(struct ldb_message *msg,
+static int inject_extended_dn(struct ldb_message *msg,
struct ldb_context *ldb,
int type,
bool remove_guid,
@@ -113,8 +113,9 @@ static bool inject_extended_dn(struct ldb_message *msg,
guid_blob = ldb_msg_find_ldb_val(msg, "objectGUID");
sid_blob = ldb_msg_find_ldb_val(msg, "objectSID");
- if (!guid_blob)
- return false;
+ if (!guid_blob) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
switch (type) {
case 0:
@@ -123,7 +124,7 @@ static bool inject_extended_dn(struct ldb_message *msg,
const char *lower_guid_hex =
strlower_talloc(msg, data_blob_hex_string(msg, guid_blob));
const char *lower_sid_hex =
strlower_talloc(msg, data_blob_hex_string(msg, sid_blob));
if (!lower_guid_hex || !lower_sid_hex) {
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
new_dn = talloc_asprintf(msg,
"<GUID=%s>;<SID=%s>;%s",
lower_guid_hex,
@@ -132,7 +133,7 @@ static bool inject_extended_dn(struct ldb_message *msg,
} else {
const char *lower_guid_hex =
strlower_talloc(msg, data_blob_hex_string(msg, guid_blob));
if (!lower_guid_hex) {
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
new_dn = talloc_asprintf(msg, "<GUID=%s>;%s",
lower_guid_hex,
@@ -151,8 +152,8 @@ static bool inject_extended_dn(struct ldb_message *msg,
if (sid) {
object_sid = dom_sid_string(msg, sid);
if (!object_sid)
- return false;
-
+ return LDB_ERR_OPERATIONS_ERROR;
+
}
/* Normal, sane format */
@@ -167,11 +168,11 @@ static bool inject_extended_dn(struct ldb_message *msg,
}
break;
default:
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (!new_dn) {
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (remove_guid) {
@@ -184,52 +185,70 @@ static bool inject_extended_dn(struct ldb_message *msg,
msg->dn = ldb_dn_new(msg, ldb, new_dn);
if (! ldb_dn_validate(msg->dn))
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
val = ldb_msg_find_ldb_val(msg, "distinguishedName");
if (val) {
ldb_msg_remove_attr(msg, "distinguishedName");
if (ldb_msg_add_steal_string(msg, "distinguishedName", new_dn))
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return true;
+ return LDB_SUCCESS;
}
/* search */
struct extended_context {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
+ struct ldb_request *req;
- const char * const *attrs;
bool remove_guid;
bool remove_sid;
int extended_type;
};
-static int extended_callback(struct ldb_context *ldb, void *context, struct
ldb_reply *ares)
+static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct extended_context *ac;
+ int ret;
- ac = talloc_get_type(context, struct extended_context);
+ ac = talloc_get_type(req->context, struct extended_context);
- if (ares->type == LDB_REPLY_ENTRY) {
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
/* for each record returned post-process to add any derived
attributes that have been asked for */
--
Samba Shared Repository
