r13998: From now on ldb_request() will require an alloced request

By freeing the request you will be sure everything down the path get freed.

this also means you have to steal the results if you want to keep them :)

simo.
(This used to be commit e8075e6a062ce5edb84485e45d0b841c2ee2af7d)

1 files changed, 95 insertions, 74 deletions

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ed3351dc5e..9acf74535b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -257,57 +257,35 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 /*
   start an ldb request
   autostarts a transacion if none active and the operation is not a search
+  NOTE: the request must be a talloc context.
   returns LDB_ERR_* on errors.
 */
-int ldb_request(struct ldb_context *ldb, struct ldb_request *request)
+int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 {
 	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;
+	if (req->operation == LDB_REQ_SEARCH) {
+		req->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)) {
+	    (req->operation == LDB_REQ_ADD ||
+	     req->operation == LDB_REQ_MODIFY ||
+	     req->operation == LDB_REQ_DELETE ||
+	     req->operation == LDB_REQ_RENAME)) {
 		status = ldb_transaction_start(ldb);
 		if (status != LDB_SUCCESS) {
-			talloc_free(r);
+			talloc_free(req);
 			return status;
 		}
 		started_transaction = 1;
 	}
 
 	/* 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 (status == LDB_SUCCESS && request->operation == LDB_REQ_SEARCH) {
-		request->op.search.res = talloc_steal(ldb, r->op.search.res);
-	}
-	if (status == LDB_SUCCESS && request->operation == LDB_ASYNC_SEARCH) {
-		request->async.handle = r->async.handle;
-	}
-	talloc_free(r);
+	status = ldb->modules->ops->request(ldb->modules, req);
 
 	if (started_transaction) {
 		return ldb_op_finish(ldb, status);
@@ -331,31 +309,36 @@ int ldb_search(struct ldb_context *ldb,
 	       const char * const *attrs, 
 	       struct ldb_result **res)
 {
-	struct ldb_request request;
-	struct ldb_parse_tree *tree;
+	struct ldb_request *req;
 	int ret;
 
 	(*res) = NULL;
 
-	tree = ldb_parse_tree(ldb, expression);
-	if (tree == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Unable to parse search expression"));
-		return -1;
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	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.controls = NULL;
+	req->operation = LDB_REQ_SEARCH;
+	req->op.search.base = base;
+	req->op.search.scope = scope;
 
-	ret = ldb_request(ldb, &request);
+	req->op.search.tree = ldb_parse_tree(req, expression);
+	if (req->op.search.tree == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Unable to parse search expression"));
+		talloc_free(req);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	(*res) = request.op.search.res;
+	req->op.search.attrs = attrs;
+	req->controls = NULL;
 
-	talloc_free(tree);
+	ret = ldb_request(ldb, req);
 
+	(*res) = talloc_steal(ldb, req->op.search.res);
+
+	talloc_free(req);
 	return ret;
 }
 
@@ -366,17 +349,26 @@ int ldb_search(struct ldb_context *ldb,
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	struct ldb_request request;
-	int status;
+	struct ldb_request *req;
+	int ret;
+
+	ret = ldb_msg_sanity_check(message);
+	if (ret != LDB_SUCCESS) return ret;
+
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	status = ldb_msg_sanity_check(message);
-	if (status != LDB_SUCCESS) return status;
+	req->operation = LDB_REQ_ADD;
+	req->op.add.message = message;
+	req->controls = NULL;
 
-	request.operation = LDB_REQ_ADD;
-	request.op.add.message = message;
-	request.controls = NULL;
+	ret = ldb_request(ldb, req);
 
-	return ldb_request(ldb, &request);
+	talloc_free(req);
+	return ret;
 }
 
 /*
@@ -385,17 +377,26 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	struct ldb_request request;
-	int status;
+	struct ldb_request *req;
+	int ret;
+
+	ret = ldb_msg_sanity_check(message);
+	if (ret != LDB_SUCCESS) return ret;
+
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	status = ldb_msg_sanity_check(message);
-	if (status != LDB_SUCCESS) return status;
+	req->operation = LDB_REQ_MODIFY;
+	req->op.add.message = message;
+	req->controls = NULL;
 
-	request.operation = LDB_REQ_MODIFY;
-	request.op.mod.message = message;
-	request.controls = NULL;
+	ret = ldb_request(ldb, req);
 
-	return ldb_request(ldb, &request);
+	talloc_free(req);
+	return ret;
 }
 
 
@@ -404,13 +405,23 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
-	struct ldb_request request;
+	struct ldb_request *req;
+	int ret;
+
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_REQ_DELETE;
+	req->op.del.dn = dn;
+	req->controls = NULL;
 
-	request.operation = LDB_REQ_DELETE;
-	request.op.del.dn = dn;
-	request.controls = NULL;
+	ret = ldb_request(ldb, req);
 
-	return ldb_request(ldb, &request);
+	talloc_free(req);
+	return ret;
 }
 
 /*
@@ -418,14 +429,24 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
-	struct ldb_request request;
+	struct ldb_request *req;
+	int ret;
 
-	request.operation = LDB_REQ_RENAME;
-	request.op.rename.olddn = olddn;
-	request.op.rename.newdn = newdn;
-	request.controls = NULL;
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_REQ_RENAME;
+	req->op.rename.olddn = olddn;
+	req->op.rename.newdn = newdn;
+	req->controls = NULL;
 
-	return ldb_request(ldb, &request);
+	ret = ldb_request(ldb, req);
+
+	talloc_free(req);
+	return ret;
 }