/*
start an ldb request
autostarts a transacion if none active and the operation is not a search
- returns -1 on errors.
+ returns LDB_ERR_* on errors.
*/
-
int ldb_request(struct ldb_context *ldb, struct ldb_request *request)
{
- int status;
+ int status, started_transaction=0;
+ struct ldb_request *r;
ldb_reset_err_string(ldb);
+ /* to allow ldb modules to assume they can use the request ptr
+ as a talloc context for the request, we have to copy the
+ structure here */
+ r = talloc(ldb, struct ldb_request);
+ if (r == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ *r = *request;
+
+ if (r->operation == LDB_REQ_SEARCH) {
+ r->op.search.res = NULL;
+ }
+
+ /* start a transaction if needed */
if ((!ldb->transaction_active) &&
(request->operation == LDB_REQ_ADD ||
request->operation == LDB_REQ_MODIFY ||
request->operation == LDB_REQ_DELETE ||
request->operation == LDB_REQ_RENAME)) {
-
status = ldb_transaction_start(ldb);
- if (status != LDB_SUCCESS) return status;
+ if (status != LDB_SUCCESS) {
+ talloc_free(r);
+ return status;
+ }
+ started_transaction = 1;
+ }
- status = ldb->modules->ops->request(ldb->modules, request);
+ /* call the first module in the chain */
+ status = ldb->modules->ops->request(ldb->modules, r);
+
+ /* the search call is the only one that returns something
+ other than a status code. We steal the results into
+ the context of the ldb before freeing the request */
+ if (request->operation == LDB_REQ_SEARCH) {
+ request->op.search.res = talloc_steal(ldb, r->op.search.res);
+ }
+ talloc_free(r);
+
+ if (started_transaction) {
return ldb_op_finish(ldb, status);
}
- return ldb->modules->ops->request(ldb->modules, request);
+ return status;
}
/*
const struct ldb_dn *base,
enum ldb_scope scope,
const char *expression,
- const char * const *attrs, struct ldb_result **res)
+ const char * const *attrs,
+ struct ldb_result **res)
{
- struct ldb_request *request;
+ struct ldb_request request;
struct ldb_parse_tree *tree;
int ret;
(*res) = NULL;
- request = talloc(ldb, struct ldb_request);
- if (request == NULL) {
- ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
- return -1;
- }
-
tree = ldb_parse_tree(ldb, expression);
if (tree == NULL) {
ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Unable to parse search expression"));
return -1;
}
- request->operation = LDB_REQ_SEARCH;
- request->op.search.base = base;
- request->op.search.scope = scope;
- request->op.search.tree = tree;
- request->op.search.attrs = attrs;
- request->op.search.res = res;
+ request.operation = LDB_REQ_SEARCH;
+ request.op.search.base = base;
+ request.op.search.scope = scope;
+ request.op.search.tree = tree;
+ request.op.search.attrs = attrs;
+
+ ret = ldb_request(ldb, &request);
- ret = ldb_request(ldb, request);
+ (*res) = request.op.search.res;
talloc_free(tree);
int ldb_add(struct ldb_context *ldb,
const struct ldb_message *message)
{
- struct ldb_request *request;
+ struct ldb_request request;
int status;
status = ldb_msg_sanity_check(message);
if (status != LDB_SUCCESS) return status;
- request = talloc(ldb, struct ldb_request);
- if (request == NULL) {
- ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
- return -1;
- }
+ request.operation = LDB_REQ_ADD;
+ request.op.add.message = message;
- request->operation = LDB_REQ_ADD;
- request->op.add.message = message;
-
- return ldb_request(ldb, request);
+ return ldb_request(ldb, &request);
}
/*
int ldb_modify(struct ldb_context *ldb,
const struct ldb_message *message)
{
- struct ldb_request *request;
+ struct ldb_request request;
int status;
status = ldb_msg_sanity_check(message);
if (status != LDB_SUCCESS) return status;
- request = talloc(ldb, struct ldb_request);
- if (request == NULL) {
- ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
- return -1;
- }
-
- request->operation = LDB_REQ_MODIFY;
- request->op.mod.message = message;
+ request.operation = LDB_REQ_MODIFY;
+ request.op.mod.message = message;
- return ldb_request(ldb, request);
+ return ldb_request(ldb, &request);
}
*/
int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
{
- struct ldb_request *request;
-
- request = talloc(ldb, struct ldb_request);
- if (request == NULL) {
- ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
- return -1;
- }
+ struct ldb_request request;
- request->operation = LDB_REQ_DELETE;
- request->op.del.dn = dn;
+ request.operation = LDB_REQ_DELETE;
+ request.op.del.dn = dn;
- return ldb_request(ldb, request);
+ return ldb_request(ldb, &request);
}
/*
*/
int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
{
- struct ldb_request *request;
-
- request = talloc(ldb, struct ldb_request);
- if (request == NULL) {
- ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
- return -1;
- }
+ struct ldb_request request;
- request->operation = LDB_REQ_RENAME;
- request->op.rename.olddn = olddn;
- request->op.rename.newdn = newdn;
+ request.operation = LDB_REQ_RENAME;
+ request.op.rename.olddn = olddn;
+ request.op.rename.newdn = newdn;
- return ldb_request(ldb, request);
+ return ldb_request(ldb, &request);
}
enum ldb_scope scope = req->op.search.scope;
struct ldb_parse_tree *tree = req->op.search.tree;
const char * const *attrs = req->op.search.attrs;
- struct ldb_result **res = req->op.search.res;
+ struct ldb_result *res;
struct ldb_request new_req;
struct ldb_parse_tree *new_tree;
struct ldb_dn *new_base;
new_req.op.search.scope = scope;
new_req.op.search.tree = new_tree;
new_req.op.search.attrs = newattrs;
- new_req.op.search.res = &newres;
+
mpret = ldb_request(privdat->mapped_ldb, req);
+ newres = new_req.op.search.res;
+
talloc_free(new_base);
talloc_free(new_tree);
talloc_free(newattrs);
- test if (full expression) is now true
*/
- *res = talloc(module, struct ldb_result);
- (*res)->msgs = talloc_array(module, struct ldb_message *, newres->count);
- (*res)->count = newres->count;
+ res = talloc(module, struct ldb_result);
+ req->op.search.res = res;
+ res->msgs = talloc_array(module, struct ldb_message *, newres->count);
+ res->count = newres->count;
ret = 0;
mergereq.op.search.scope = LDB_SCOPE_BASE;
mergereq.op.search.tree = ldb_parse_tree(module, "");
mergereq.op.search.attrs = NULL;
- mergereq.op.search.res = &extrares;
extraret = ldb_next_request(module, &mergereq);
+ extrares = mergereq.op.search.res;
+
if (extraret == -1) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Error searching for extra data!\n");
} else if (extraret > 1) {
}
if (ldb_match_msg(module->ldb, merged, tree, base, scope) != 0) {
- (*res)->msgs[ret] = merged;
+ res->msgs[ret] = merged;
ret++;
} else {
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Discarded merged message because it did not match");
talloc_free(newres);
- (*res)->count = ret;
+ res->count = ret;
return LDB_SUCCESS;
}
static int map_search_bytree(struct ldb_module *module, struct ldb_request *req)
{
const struct ldb_dn *base = req->op.search.base;
- struct ldb_result **res = req->op.search.res;
- struct ldb_result *fbres, *mpres = NULL;
+ struct ldb_result *fbres, *mpres, *res;
int i, ret;
- req->op.search.res = &fbres;
ret = map_search_fb(module, req);
- req->op.search.res = res;
if (ret != LDB_SUCCESS)
return ret;
/* special dn's are never mapped.. */
if (ldb_dn_is_special(base)) {
- *res = fbres;
return ret;
}
- req->op.search.res = &mpres;
+ fbres = req->op.search.res;
+
ret = map_search_mp(module, req);
- req->op.search.res = res;
if (ret != LDB_SUCCESS) {
return ret;
}
+ mpres = req->op.search.res;
+
/* Merge results */
- *res = talloc(module, struct ldb_result);
- (*res)->msgs = talloc_array(*res, struct ldb_message *, fbres->count + mpres->count);
+ res = talloc(module, struct ldb_result);
+ res->msgs = talloc_array(res, struct ldb_message *, fbres->count + mpres->count);
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Merging %d mapped and %d fallback messages", mpres->count, fbres->count);
- for (i = 0; i < fbres->count; i++) (*res)->msgs[i] = fbres->msgs[i];
- for (i = 0; i < mpres->count; i++) (*res)->msgs[fbres->count + i] = mpres->msgs[i];
+ for (i = 0; i < fbres->count; i++) {
+ res->msgs[i] = talloc_steal(res->msgs, fbres->msgs[i]);
+ }
+ for (i = 0; i < mpres->count; i++) {
+ res->msgs[fbres->count + i] = talloc_steal(res->msgs, mpres->msgs[i]);
+ }
- (*res)->count = fbres->count + mpres->count;
+ res->count = fbres->count + mpres->count;
return LDB_SUCCESS;
}