From 58d50a614f1b4a3fc6b60ad5f777d987263fe54f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 31 Mar 2004 06:45:39 +0000
Subject: make a more recent snapshot of ldb available to interested people.
 Note that I decided to make it LGPL.

ldb is not finished yet, but enough of it is there for people to get
an idea of what it does, and quite a few simple tests work
(This used to be commit dc6f41f9e777d37f883303ddef0d96840d80f78e)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 524 ++++++++++++++++++++++++++++++++++++
 1 file changed, 524 insertions(+)
 create mode 100644 source4/lib/ldb/ldb_ldap/ldb_ldap.c

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
new file mode 100644
index 0000000000..b2f7688497
--- /dev/null
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -0,0 +1,524 @@
+/* 
+   ldb database library
+
+   Copyright (C) Andrew Tridgell  2004
+
+     ** NOTE! The following LGPL license applies to the ldb
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
+   
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/*
+ *  Name: ldb
+ *
+ *  Component: ldb ldap backend
+ *
+ *  Description: core files for LDAP backend
+ *
+ *  Author: Andrew Tridgell
+ */
+
+#include "includes.h"
+#include "ldb_ldap/ldb_ldap.h"
+
+#if 0
+/*
+  we don't need this right now, but will once we add more backend 
+  options
+*/
+
+/*
+  find an option in an option list (a null terminated list of strings)
+
+  this assumes the list is short. If it ever gets long then we really
+  should do this in some smarter way
+ */
+static const char *lldb_option_find(const struct lldb_private *lldb, const char *name)
+{
+	int i;
+	size_t len = strlen(name);
+
+	if (!lldb->options) return NULL;
+
+	for (i=0;lldb->options[i];i++) {		
+		if (strncmp(lldb->options[i], name, len) == 0 &&
+		    lldb->options[i][len] == '=') {
+			return &lldb->options[i][len+1];
+		}
+	}
+
+	return NULL;
+}
+#endif
+
+/*
+  close/free the connection
+*/
+static int lldb_close(struct ldb_context *ldb)
+{
+	int i, ret = 0;
+	struct lldb_private *lldb = ldb->private;
+
+	if (ldap_unbind(lldb->ldap) != LDAP_SUCCESS) {
+		ret = -1;
+	}
+
+	if (lldb->options) {
+		for (i=0;lldb->options[i];i++) {
+			free(lldb->options[i]);
+		}
+		free(lldb->options);
+	}
+	free(lldb);
+	free(ldb);
+
+	return ret;
+}
+
+/*
+  delete a record
+*/
+static int lldb_delete(struct ldb_context *ldb, const char *dn)
+{
+	struct lldb_private *lldb = ldb->private;
+	int ret = 0;
+	
+	lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
+	if (lldb->last_rc != LDAP_SUCCESS) {
+		ret = -1;
+	}
+
+	return ret;
+}
+
+/*
+  free a search message
+*/
+static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
+{
+	int i;
+	free(msg->dn);
+	for (i=0;i<msg->num_elements;i++) {
+		free(msg->elements[i].name);
+		if (msg->elements[i].value.data) {
+			free(msg->elements[i].value.data);
+		}
+	}
+	if (msg->elements) free(msg->elements);
+	free(msg);
+	return 0;
+}
+
+/*
+  free a search result
+*/
+static int lldb_search_free(struct ldb_context *ldb, struct ldb_message **res)
+{
+	int i;
+	for (i=0;res[i];i++) {
+		if (lldb_msg_free(ldb, res[i]) != 0) {
+			return -1;
+		}
+	}
+	free(res);
+	return 0;
+}
+
+
+/*
+  add a single set of ldap message values to a ldb_message
+*/
+static int lldb_add_msg_attr(struct ldb_message *msg, 
+			     const char *attr, struct berval **bval)
+{
+	int count, i;
+	struct ldb_message_element *el;
+
+	count = ldap_count_values_len(bval);
+
+	if (count <= 0) {
+		return -1;
+	}
+
+	el = realloc_p(msg->elements, struct ldb_message_element, 
+		       msg->num_elements + count);
+	if (!el) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	msg->elements = el;
+
+	for (i=0;i<count;i++) {
+		msg->elements[msg->num_elements].name = strdup(attr);
+		if (!msg->elements[msg->num_elements].name) {
+			return -1;
+		}
+		msg->elements[msg->num_elements].value.data = malloc(bval[i]->bv_len);
+		if (!msg->elements[msg->num_elements].value.data) {
+			free(msg->elements[msg->num_elements].name);
+			return -1;
+		}
+		memcpy(msg->elements[msg->num_elements].value.data, 
+		       bval[i]->bv_val, bval[i]->bv_len);
+		msg->elements[msg->num_elements].value.length = bval[i]->bv_len;
+		msg->num_elements++;
+	}
+
+	return 0;
+}
+
+/*
+  search for matching records
+*/
+static int lldb_search(struct ldb_context *ldb, const char *base,
+		       enum ldb_scope scope, const char *expression,
+		       const char **attrs, struct ldb_message ***res)
+{
+	struct lldb_private *lldb = ldb->private;
+	int count, msg_count;
+	LDAPMessage *ldapres, *msg;
+
+	lldb->last_rc = ldap_search_s(lldb->ldap, base, (int)scope, 
+				      expression, attrs, 0, &ldapres);
+	if (lldb->last_rc != LDAP_SUCCESS) {
+		return -1;
+	}
+
+	count = ldap_count_entries(lldb->ldap, ldapres);
+	if (count == -1 || count == 0) {
+		ldap_msgfree(ldapres);
+		return count;
+	}
+
+	(*res) = malloc_array_p(struct ldb_message *, count+1);
+	if (! *res) {
+		ldap_msgfree(ldapres);
+		errno = ENOMEM;
+		return -1;
+	}
+
+	(*res)[0] = NULL;
+
+	msg_count = 0;
+
+	/* loop over all messages */
+	for (msg=ldap_first_entry(lldb->ldap, ldapres); 
+	     msg; 
+	     msg=ldap_next_entry(lldb->ldap, msg)) {
+		BerElement *berptr = NULL;
+		char *attr, *dn;
+
+		if (msg_count == count) {
+			/* hmm, got too many? */
+			fprintf(stderr,"Too many messages?!\n");
+			break;
+		}
+
+		(*res)[msg_count] = malloc_p(struct ldb_message);
+		if (!(*res)[msg_count]) {
+			goto failed;
+		}
+		(*res)[msg_count+1] = NULL;
+
+		dn = ldap_get_dn(lldb->ldap, msg);
+		if (!dn) {
+			goto failed;
+		}
+
+		(*res)[msg_count]->dn = strdup(dn);
+		ldap_memfree(dn);
+		if (!(*res)[msg_count]->dn) {
+			goto failed;
+		}
+
+
+		(*res)[msg_count]->num_elements = 0;
+		(*res)[msg_count]->elements = NULL;
+		(*res)[msg_count]->private = NULL;
+
+		/* loop over all attributes */
+		for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
+		     attr;
+		     attr=ldap_next_attribute(lldb->ldap, msg, berptr)) {
+			struct berval **bval;
+			bval = ldap_get_values_len(lldb->ldap, msg, attr);
+
+			if (bval) {
+				lldb_add_msg_attr((*res)[msg_count], attr, bval);
+				ldap_value_free_len(bval);
+			}					  
+			
+			ldap_memfree(attr);
+		}
+		if (berptr) ber_free(berptr, 0);
+
+		msg_count++;
+	}
+
+	ldap_msgfree(ldapres);
+
+	return msg_count;
+
+failed:
+	if (*res) lldb_search_free(ldb, *res);
+	return -1;
+}
+
+
+/*
+  free a set of mods from lldb_msg_to_mods()
+*/
+static void lldb_mods_free(LDAPMod **mods)
+{
+	int i, j;
+
+	if (!mods) return;
+
+	for (i=0;mods[i];i++) {
+		if (mods[i]->mod_vals.modv_bvals) {
+			for (j=0;mods[i]->mod_vals.modv_bvals[j];j++) {
+				free(mods[i]->mod_vals.modv_bvals[j]);
+			}
+			free(mods[i]->mod_vals.modv_bvals);
+		}
+		free(mods[i]);
+	}
+	free(mods);
+}
+
+
+/*
+  convert a ldb_message structure to a list of LDAPMod structures
+  ready for ldap_add() or ldap_modify()
+*/
+static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
+{
+	LDAPMod **mods;
+	int i, num_vals, num_mods = 0;
+
+	/* allocate maximum number of elements needed */
+	mods = malloc_array_p(LDAPMod *, msg->num_elements+1);
+	if (!mods) {
+		errno = ENOMEM;
+		return NULL;
+	}
+	mods[0] = NULL;
+
+	for (i=0;i<msg->num_elements;i++) {
+
+		if (i > 0 && 
+		    (!use_flags || 
+		     (msg->elements[i].flags == msg->elements[i-1].flags)) &&
+		    strcmp(msg->elements[i].name, msg->elements[i-1].name) == 0) {
+			struct berval **b;
+			/* when attributes are repeated we need to extend the
+			   existing bvals array */
+			b = realloc_p(mods[num_mods-1]->mod_vals.modv_bvals, 
+				      struct berval *, num_vals+2);
+			if (!b) {
+				goto failed;
+			}
+			mods[num_mods-1]->mod_vals.modv_bvals = b;
+			b[num_vals+1] = NULL;
+			b[num_vals] = malloc_p(struct berval);
+			if (!b[num_vals]) goto failed;
+			b[num_vals]->bv_val = msg->elements[i].value.data;
+			b[num_vals]->bv_len = msg->elements[i].value.length;
+			num_vals++;
+			continue;
+		}
+
+		num_vals = 1;
+
+		mods[num_mods] = malloc_p(LDAPMod);
+		if (!mods[num_mods]) {
+			goto failed;
+		}
+		mods[num_mods+1] = NULL;
+		mods[num_mods]->mod_op = LDAP_MOD_BVALUES;
+		if (use_flags) {
+			switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
+			case LDB_FLAG_MOD_ADD:
+				mods[num_mods]->mod_op |= LDAP_MOD_ADD;
+				break;
+			case LDB_FLAG_MOD_DELETE:
+				mods[num_mods]->mod_op |= LDAP_MOD_DELETE;
+				break;
+			case LDB_FLAG_MOD_REPLACE:
+				mods[num_mods]->mod_op |= LDAP_MOD_REPLACE;
+				break;
+			}
+		}
+		mods[num_mods]->mod_type = msg->elements[i].name;
+		mods[num_mods]->mod_vals.modv_bvals = malloc_array_p(struct berval *, 2);
+		if (!mods[num_mods]->mod_vals.modv_bvals) {
+			goto failed;
+		}
+		mods[num_mods]->mod_vals.modv_bvals[0] = malloc_p(struct berval);
+		if (!mods[num_mods]->mod_vals.modv_bvals[0]) {
+			goto failed;
+		}
+		mods[num_mods]->mod_vals.modv_bvals[0]->bv_val = msg->elements[i].value.data;
+		mods[num_mods]->mod_vals.modv_bvals[0]->bv_len = msg->elements[i].value.length;
+		mods[num_mods]->mod_vals.modv_bvals[1] = NULL;
+		num_mods++;
+	}
+
+	return mods;
+
+failed:
+	lldb_mods_free(mods);
+	return NULL;
+}
+
+
+/*
+  add a record
+*/
+static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
+{
+	struct lldb_private *lldb = ldb->private;
+	LDAPMod **mods;
+	int ret = 0;
+
+	mods = lldb_msg_to_mods(msg, 0);
+
+	lldb->last_rc = ldap_add_s(lldb->ldap, msg->dn, mods);
+	if (lldb->last_rc != LDAP_SUCCESS) {
+		ret = -1;
+	}
+
+	lldb_mods_free(mods);
+
+	return ret;
+}
+
+
+/*
+  modify a record
+*/
+static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
+{
+	struct lldb_private *lldb = ldb->private;
+	LDAPMod **mods;
+	int ret = 0;
+
+	mods = lldb_msg_to_mods(msg, 1);
+
+	lldb->last_rc = ldap_modify_s(lldb->ldap, msg->dn, mods);
+	if (lldb->last_rc != LDAP_SUCCESS) {
+		ret = -1;
+	}
+
+	lldb_mods_free(mods);
+
+	return ret;
+}
+
+
+/*
+  return extended error information
+*/
+static const char *lldb_errstring(struct ldb_context *ldb)
+{
+	struct lldb_private *lldb = ldb->private;
+	return ldap_err2string(lldb->last_rc);
+}
+
+
+static const struct ldb_backend_ops lldb_ops = {
+	lldb_close, 
+	lldb_search,
+	lldb_search_free,
+	lldb_add,
+	lldb_modify,
+	lldb_delete,
+	lldb_errstring
+};
+
+
+/*
+  connect to the database
+*/
+struct ldb_context *lldb_connect(const char *url, 
+				 unsigned int flags, 
+				 const char *options[])
+{
+	struct ldb_context *ldb = NULL;
+	struct lldb_private *lldb = NULL;
+	int i;
+
+	ldb = malloc_p(struct ldb_context);
+	if (!ldb) {
+		errno = ENOMEM;
+		goto failed;
+	}
+
+	lldb = malloc_p(struct lldb_private);
+	if (!lldb) {
+		free(ldb);
+		errno = ENOMEM;
+		goto failed;
+	}
+
+	lldb->ldap = NULL;
+	lldb->options = NULL;
+
+	lldb->last_rc = ldap_initialize(&lldb->ldap, url);
+	if (lldb->last_rc != LDAP_SUCCESS) {
+		goto failed;
+	}
+
+	ldb->ops = &lldb_ops;
+	ldb->private = lldb;
+
+	if (options) {
+		/* take a copy of the options array, so we don't have to rely
+		   on the caller keeping it around (it might be dynamic) */
+		for (i=0;options[i];i++) ;
+
+		lldb->options = malloc_array_p(char *, i+1);
+		if (!lldb->options) {
+			goto failed;
+		}
+		
+		for (i=0;options[i];i++) {
+			lldb->options[i+1] = NULL;
+			lldb->options[i] = strdup(options[i]);
+			if (!lldb->options[i]) {
+				goto failed;
+			}
+		}
+	}
+
+	return ldb;
+
+failed:
+	if (lldb && lldb->options) {
+		for (i=0;lldb->options[i];i++) {
+			free(lldb->options[i]);
+		}
+		free(lldb->options);
+	}
+	if (lldb && lldb->ldap) {
+		ldap_unbind(lldb->ldap);
+	}
+	if (lldb) free(lldb);
+	if (ldb) free(ldb);
+	return NULL;
+}
-- 
cgit 


From ee44733f94864fb0a1ae15d48e3335c0705a82ae Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 3 Apr 2004 12:29:21 +0000
Subject: added the rest of the ldb_modify() code, which required a fairly
 large change in the ldb API. The API is now much closer to LDAP. (This used
 to be commit e9e85c464411c561c5073d262a2e3533fec175ca)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 96 ++++++++++++++++++-------------------
 1 file changed, 46 insertions(+), 50 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index b2f7688497..e6cbb52cad 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -37,7 +37,7 @@
 
 #if 0
 /*
-  we don't need this right now, but will once we add more backend 
+  we don't need this right now, but will once we add some backend 
   options
 */
 
@@ -110,13 +110,16 @@ static int lldb_delete(struct ldb_context *ldb, const char *dn)
 */
 static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
 {
-	int i;
+	int i, j;
 	free(msg->dn);
 	for (i=0;i<msg->num_elements;i++) {
 		free(msg->elements[i].name);
-		if (msg->elements[i].value.data) {
-			free(msg->elements[i].value.data);
+		for (j=0;j<msg->elements[i].num_values;j++) {
+			if (msg->elements[i].values[j].data) {
+				free(msg->elements[i].values[j].data);
+			}
 		}
+		free(msg->elements[i].values);
 	}
 	if (msg->elements) free(msg->elements);
 	free(msg);
@@ -155,7 +158,7 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 	}
 
 	el = realloc_p(msg->elements, struct ldb_message_element, 
-		       msg->num_elements + count);
+		       msg->num_elements + 1);
 	if (!el) {
 		errno = ENOMEM;
 		return -1;
@@ -163,22 +166,34 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 
 	msg->elements = el;
 
+	el = &msg->elements[msg->num_elements];
+
+	el->name = strdup(attr);
+	if (!el->name) {
+		errno = ENOMEM;
+		return -1;
+	}
+	el->flags = 0;
+
+	el->num_values = 0;
+	el->values = malloc_array_p(struct ldb_val, count);
+	if (!el->values) {
+		errno = ENOMEM;
+		return -1;
+	}
+
 	for (i=0;i<count;i++) {
-		msg->elements[msg->num_elements].name = strdup(attr);
-		if (!msg->elements[msg->num_elements].name) {
+		el->values[i].data = malloc(bval[i]->bv_len);
+		if (!el->values[i].data) {
 			return -1;
 		}
-		msg->elements[msg->num_elements].value.data = malloc(bval[i]->bv_len);
-		if (!msg->elements[msg->num_elements].value.data) {
-			free(msg->elements[msg->num_elements].name);
-			return -1;
-		}
-		memcpy(msg->elements[msg->num_elements].value.data, 
-		       bval[i]->bv_val, bval[i]->bv_len);
-		msg->elements[msg->num_elements].value.length = bval[i]->bv_len;
-		msg->num_elements++;
+		memcpy(el->values[i].data, bval[i]->bv_val, bval[i]->bv_len);
+		el->values[i].length = bval[i]->bv_len;
+		el->num_values++;
 	}
 
+	msg->num_elements++;
+
 	return 0;
 }
 
@@ -309,7 +324,7 @@ static void lldb_mods_free(LDAPMod **mods)
 static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 {
 	LDAPMod **mods;
-	int i, num_vals, num_mods = 0;
+	int i, j, num_mods = 0;
 
 	/* allocate maximum number of elements needed */
 	mods = malloc_array_p(LDAPMod *, msg->num_elements+1);
@@ -320,30 +335,7 @@ static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 	mods[0] = NULL;
 
 	for (i=0;i<msg->num_elements;i++) {
-
-		if (i > 0 && 
-		    (!use_flags || 
-		     (msg->elements[i].flags == msg->elements[i-1].flags)) &&
-		    strcmp(msg->elements[i].name, msg->elements[i-1].name) == 0) {
-			struct berval **b;
-			/* when attributes are repeated we need to extend the
-			   existing bvals array */
-			b = realloc_p(mods[num_mods-1]->mod_vals.modv_bvals, 
-				      struct berval *, num_vals+2);
-			if (!b) {
-				goto failed;
-			}
-			mods[num_mods-1]->mod_vals.modv_bvals = b;
-			b[num_vals+1] = NULL;
-			b[num_vals] = malloc_p(struct berval);
-			if (!b[num_vals]) goto failed;
-			b[num_vals]->bv_val = msg->elements[i].value.data;
-			b[num_vals]->bv_len = msg->elements[i].value.length;
-			num_vals++;
-			continue;
-		}
-
-		num_vals = 1;
+		const struct ldb_message_element *el = &msg->elements[i];
 
 		mods[num_mods] = malloc_p(LDAPMod);
 		if (!mods[num_mods]) {
@@ -352,7 +344,7 @@ static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 		mods[num_mods+1] = NULL;
 		mods[num_mods]->mod_op = LDAP_MOD_BVALUES;
 		if (use_flags) {
-			switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
+			switch (el->flags & LDB_FLAG_MOD_MASK) {
 			case LDB_FLAG_MOD_ADD:
 				mods[num_mods]->mod_op |= LDAP_MOD_ADD;
 				break;
@@ -364,18 +356,22 @@ static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 				break;
 			}
 		}
-		mods[num_mods]->mod_type = msg->elements[i].name;
-		mods[num_mods]->mod_vals.modv_bvals = malloc_array_p(struct berval *, 2);
+		mods[num_mods]->mod_type = el->name;
+		mods[num_mods]->mod_vals.modv_bvals = malloc_array_p(struct berval *, 
+								     1+el->num_values);
 		if (!mods[num_mods]->mod_vals.modv_bvals) {
 			goto failed;
 		}
-		mods[num_mods]->mod_vals.modv_bvals[0] = malloc_p(struct berval);
-		if (!mods[num_mods]->mod_vals.modv_bvals[0]) {
-			goto failed;
+
+		for (j=0;j<el->num_values;j++) {
+			mods[num_mods]->mod_vals.modv_bvals[j] = malloc_p(struct berval);
+			if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
+				goto failed;
+			}
+			mods[num_mods]->mod_vals.modv_bvals[j]->bv_val = el->values[j].data;
+			mods[num_mods]->mod_vals.modv_bvals[j]->bv_len = el->values[j].length;
 		}
-		mods[num_mods]->mod_vals.modv_bvals[0]->bv_val = msg->elements[i].value.data;
-		mods[num_mods]->mod_vals.modv_bvals[0]->bv_len = msg->elements[i].value.length;
-		mods[num_mods]->mod_vals.modv_bvals[1] = NULL;
+		mods[num_mods]->mod_vals.modv_bvals[j] = NULL;
 		num_mods++;
 	}
 
-- 
cgit 


From 177777b05534c86514f5ee79b67532537bfd99dd Mon Sep 17 00:00:00 2001
From: Richard Sharpe <sharpe@samba.org>
Date: Sat, 10 Apr 2004 06:10:26 +0000
Subject: r141: A number of changes to get things working on FreeBSD and reduce
 the breakage caused by someone recently ...

1. Add configure check HAVE_COMPARISON_FN_T to see if this is defined. I
have not checked this on Linux yet, but will do so soon.

2. Add the definitions of malloc_p, realloc_p etc.

3. Check for LDAP and don't build stuff that depends on LDAP if we don't\
have it.

It currently builds on FreeBSD but there is one warning printed out at the end.
(This used to be commit 7b34fbe0f2ef175e5504e34e4f3cdf9a0563970f)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index e6cbb52cad..25dad914da 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -33,7 +33,8 @@
  */
 
 #include "includes.h"
-#include "ldb_ldap/ldb_ldap.h"
+#if HAVE_LDAP
+#include "ldb_ldap.h"
 
 #if 0
 /*
@@ -518,3 +519,4 @@ failed:
 	if (ldb) free(ldb);
 	return NULL;
 }
+#endif /*HAVE_LDAP*/
-- 
cgit 


From ac193579e7db00c7a2ea0aadaaf0d34c10dcf1a5 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 10 Apr 2004 20:18:22 +0000
Subject: r152: a quick airport commit ....

added ldbedit, a _really_ useful command

added ldbadd, ldbdel, ldbsearch and ldbmodify to build

solved lots of timezone issues, we now pass the torture tests with
client and server in different zones

fixed several build issues

I know this breaks the no-LDAP build. Wait till I arrive in San Jose for that
fix.
(This used to be commit af34710d4da1841653624fe304b1c8d812c0fdd9)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 25dad914da..25af43c569 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -33,8 +33,7 @@
  */
 
 #include "includes.h"
-#if HAVE_LDAP
-#include "ldb_ldap.h"
+#include "ldb/ldb_ldap/ldb_ldap.h"
 
 #if 0
 /*
@@ -519,4 +518,4 @@ failed:
 	if (ldb) free(ldb);
 	return NULL;
 }
-#endif /*HAVE_LDAP*/
+
-- 
cgit 


From 6411aa483f9233af098b4893ad67ebd2fd9d5868 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 28 Apr 2004 07:05:28 +0000
Subject: r381: make the code more C++ friendly (This used to be commit
 8acecc7f27e25ab876fffffe43ae75b5f77aff77)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 25af43c569..510f28a45e 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -71,7 +71,7 @@ static const char *lldb_option_find(const struct lldb_private *lldb, const char
 static int lldb_close(struct ldb_context *ldb)
 {
 	int i, ret = 0;
-	struct lldb_private *lldb = ldb->private;
+	struct lldb_private *lldb = ldb->private_data;
 
 	if (ldap_unbind(lldb->ldap) != LDAP_SUCCESS) {
 		ret = -1;
@@ -94,7 +94,7 @@ static int lldb_close(struct ldb_context *ldb)
 */
 static int lldb_delete(struct ldb_context *ldb, const char *dn)
 {
-	struct lldb_private *lldb = ldb->private;
+	struct lldb_private *lldb = ldb->private_data;
 	int ret = 0;
 	
 	lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
@@ -204,7 +204,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 		       enum ldb_scope scope, const char *expression,
 		       const char **attrs, struct ldb_message ***res)
 {
-	struct lldb_private *lldb = ldb->private;
+	struct lldb_private *lldb = ldb->private_data;
 	int count, msg_count;
 	LDAPMessage *ldapres, *msg;
 
@@ -388,7 +388,7 @@ failed:
 */
 static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
 {
-	struct lldb_private *lldb = ldb->private;
+	struct lldb_private *lldb = ldb->private_data;
 	LDAPMod **mods;
 	int ret = 0;
 
@@ -410,7 +410,7 @@ static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
 */
 static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
 {
-	struct lldb_private *lldb = ldb->private;
+	struct lldb_private *lldb = ldb->private_data;
 	LDAPMod **mods;
 	int ret = 0;
 
@@ -432,7 +432,7 @@ static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
 */
 static const char *lldb_errstring(struct ldb_context *ldb)
 {
-	struct lldb_private *lldb = ldb->private;
+	struct lldb_private *lldb = ldb->private_data;
 	return ldap_err2string(lldb->last_rc);
 }
 
@@ -481,7 +481,7 @@ struct ldb_context *lldb_connect(const char *url,
 	}
 
 	ldb->ops = &lldb_ops;
-	ldb->private = lldb;
+	ldb->private_data = lldb;
 
 	if (options) {
 		/* take a copy of the options array, so we don't have to rely
-- 
cgit 


From b0b97592be312b3553ac31cc3f3cb994de06e506 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Wed, 28 Apr 2004 07:32:37 +0000
Subject: r382: More C++ friendliness fixes. (This used to be commit
 e96f3a2005cf6f4da2ecd4670a35eab1b4f250d0)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 510f28a45e..55c083b44c 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -264,7 +264,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 
 		(*res)[msg_count]->num_elements = 0;
 		(*res)[msg_count]->elements = NULL;
-		(*res)[msg_count]->private = NULL;
+		(*res)[msg_count]->private_data = NULL;
 
 		/* loop over all attributes */
 		for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
-- 
cgit 


From 0dad5a34273bf5cadcfd4a36d69bdffbf69eb073 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 1 May 2004 09:45:56 +0000
Subject: r435: a major upgrade for ldb

 - added the ability to mark record attributes as being CASE_INSENSITIVE, WILDCARD or INTEGER.

 - added the ability to support objectclass subclasses, and to search by a parent class

 - added internal support for case insensitive versus case sensitive
   indexing (not UTF8 compliant yet)

 - cleaned up a number of const warnings

 - added a number of helper functions for fetching integers, strings and doubles

 - added a in-memory cache for important database properties, supported by a
   database sequence number

 - changed some variable names to avoid conflicts with C++
(This used to be commit f2bf06f25c2e6c744817711c7bedbd1d3b52f994)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 55c083b44c..8723beeadc 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -96,6 +96,11 @@ static int lldb_delete(struct ldb_context *ldb, const char *dn)
 {
 	struct lldb_private *lldb = ldb->private_data;
 	int ret = 0;
+
+	/* ignore ltdb specials */
+	if (dn[0] == '@') {
+		return 0;
+	}
 	
 	lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
 	if (lldb->last_rc != LDAP_SUCCESS) {
@@ -202,7 +207,7 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 */
 static int lldb_search(struct ldb_context *ldb, const char *base,
 		       enum ldb_scope scope, const char *expression,
-		       const char **attrs, struct ldb_message ***res)
+		       char * const *attrs, struct ldb_message ***res)
 {
 	struct lldb_private *lldb = ldb->private_data;
 	int count, msg_count;
@@ -392,6 +397,11 @@ static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
 	LDAPMod **mods;
 	int ret = 0;
 
+	/* ignore ltdb specials */
+	if (msg->dn[0] == '@') {
+		return 0;
+	}
+
 	mods = lldb_msg_to_mods(msg, 0);
 
 	lldb->last_rc = ldap_add_s(lldb->ldap, msg->dn, mods);
@@ -414,6 +424,11 @@ static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
 	LDAPMod **mods;
 	int ret = 0;
 
+	/* ignore ltdb specials */
+	if (msg->dn[0] == '@') {
+		return 0;
+	}
+
 	mods = lldb_msg_to_mods(msg, 1);
 
 	lldb->last_rc = ldap_modify_s(lldb->ldap, msg->dn, mods);
-- 
cgit 


From 208e09747c242ab5bd59a658033db49efa8d8696 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 3 May 2004 14:51:26 +0000
Subject: r456:  - added -i option to ldbsearch

 - fixed sorting bug in ldb index handing
(This used to be commit cdd48e2b9b3ca6be5503eec401e09db162408ac8)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 8723beeadc..26c29122ad 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -207,7 +207,7 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 */
 static int lldb_search(struct ldb_context *ldb, const char *base,
 		       enum ldb_scope scope, const char *expression,
-		       char * const *attrs, struct ldb_message ***res)
+		       const char * const *attrs, struct ldb_message ***res)
 {
 	struct lldb_private *lldb = ldb->private_data;
 	int count, msg_count;
-- 
cgit 


From 232bc1503fc0e3f85b4711f077d2566dc0f0c823 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 5 May 2004 04:27:29 +0000
Subject: r490: - expanded the test suite to test modify and delete operations

- made yet another attempt to make ldb const clean.

- "make test" now runs both the tdb and ldap backend tests, and run the ldbtest utility
  with and without indexing

- added prototypes in ldb.h for ldb_msg_*() public functions
(This used to be commit 01e87406768cb5a98ac8530a2f361a4987a36cd3)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 26c29122ad..8723beeadc 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -207,7 +207,7 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 */
 static int lldb_search(struct ldb_context *ldb, const char *base,
 		       enum ldb_scope scope, const char *expression,
-		       const char * const *attrs, struct ldb_message ***res)
+		       char * const *attrs, struct ldb_message ***res)
 {
 	struct lldb_private *lldb = ldb->private_data;
 	int count, msg_count;
-- 
cgit 


From d8ce7c6a2acbf371509a23775470e7614bcb6027 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 May 2004 04:40:15 +0000
Subject: r502: modified ldb to allow the use of an external pool memory
 allocator. The way to use this is to call ldb_set_alloc() with a function
 pointer to whatever memory allocator you like. It includes a context pointer
 to allow for pool based allocators. (This used to be commit
 3955c482e6c2c9e975a4bb809ec8cb6068e48e34)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 93 +++++++++++++++++++------------------
 1 file changed, 49 insertions(+), 44 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 8723beeadc..7e7d047f25 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -77,13 +77,15 @@ static int lldb_close(struct ldb_context *ldb)
 		ret = -1;
 	}
 
+	ldb_set_alloc(ldb, NULL, NULL);
+
 	if (lldb->options) {
 		for (i=0;lldb->options[i];i++) {
-			free(lldb->options[i]);
+			ldb_free(ldb, lldb->options[i]);
 		}
-		free(lldb->options);
+		ldb_free(ldb, lldb->options);
 	}
-	free(lldb);
+	ldb_free(ldb, lldb);
 	free(ldb);
 
 	return ret;
@@ -116,18 +118,18 @@ static int lldb_delete(struct ldb_context *ldb, const char *dn)
 static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
 {
 	int i, j;
-	free(msg->dn);
+	ldb_free(ldb, msg->dn);
 	for (i=0;i<msg->num_elements;i++) {
-		free(msg->elements[i].name);
+		ldb_free(ldb, msg->elements[i].name);
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			if (msg->elements[i].values[j].data) {
-				free(msg->elements[i].values[j].data);
+				ldb_free(ldb, msg->elements[i].values[j].data);
 			}
 		}
-		free(msg->elements[i].values);
+		ldb_free(ldb, msg->elements[i].values);
 	}
-	if (msg->elements) free(msg->elements);
-	free(msg);
+	if (msg->elements) ldb_free(ldb, msg->elements);
+	ldb_free(ldb, msg);
 	return 0;
 }
 
@@ -142,7 +144,7 @@ static int lldb_search_free(struct ldb_context *ldb, struct ldb_message **res)
 			return -1;
 		}
 	}
-	free(res);
+	ldb_free(ldb, res);
 	return 0;
 }
 
@@ -150,7 +152,8 @@ static int lldb_search_free(struct ldb_context *ldb, struct ldb_message **res)
 /*
   add a single set of ldap message values to a ldb_message
 */
-static int lldb_add_msg_attr(struct ldb_message *msg, 
+static int lldb_add_msg_attr(struct ldb_context *ldb,
+			     struct ldb_message *msg, 
 			     const char *attr, struct berval **bval)
 {
 	int count, i;
@@ -162,8 +165,8 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 		return -1;
 	}
 
-	el = realloc_p(msg->elements, struct ldb_message_element, 
-		       msg->num_elements + 1);
+	el = ldb_realloc_p(ldb, msg->elements, struct ldb_message_element, 
+			   msg->num_elements + 1);
 	if (!el) {
 		errno = ENOMEM;
 		return -1;
@@ -173,7 +176,7 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 
 	el = &msg->elements[msg->num_elements];
 
-	el->name = strdup(attr);
+	el->name = ldb_strdup(ldb, attr);
 	if (!el->name) {
 		errno = ENOMEM;
 		return -1;
@@ -181,14 +184,14 @@ static int lldb_add_msg_attr(struct ldb_message *msg,
 	el->flags = 0;
 
 	el->num_values = 0;
-	el->values = malloc_array_p(struct ldb_val, count);
+	el->values = ldb_malloc_array_p(ldb, struct ldb_val, count);
 	if (!el->values) {
 		errno = ENOMEM;
 		return -1;
 	}
 
 	for (i=0;i<count;i++) {
-		el->values[i].data = malloc(bval[i]->bv_len);
+		el->values[i].data = ldb_malloc(ldb, bval[i]->bv_len);
 		if (!el->values[i].data) {
 			return -1;
 		}
@@ -225,7 +228,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 		return count;
 	}
 
-	(*res) = malloc_array_p(struct ldb_message *, count+1);
+	(*res) = ldb_malloc_array_p(ldb, struct ldb_message *, count+1);
 	if (! *res) {
 		ldap_msgfree(ldapres);
 		errno = ENOMEM;
@@ -249,7 +252,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 			break;
 		}
 
-		(*res)[msg_count] = malloc_p(struct ldb_message);
+		(*res)[msg_count] = ldb_malloc_p(ldb, struct ldb_message);
 		if (!(*res)[msg_count]) {
 			goto failed;
 		}
@@ -260,7 +263,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 			goto failed;
 		}
 
-		(*res)[msg_count]->dn = strdup(dn);
+		(*res)[msg_count]->dn = ldb_strdup(ldb, dn);
 		ldap_memfree(dn);
 		if (!(*res)[msg_count]->dn) {
 			goto failed;
@@ -279,7 +282,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 			bval = ldap_get_values_len(lldb->ldap, msg, attr);
 
 			if (bval) {
-				lldb_add_msg_attr((*res)[msg_count], attr, bval);
+				lldb_add_msg_attr(ldb, (*res)[msg_count], attr, bval);
 				ldap_value_free_len(bval);
 			}					  
 			
@@ -303,7 +306,7 @@ failed:
 /*
   free a set of mods from lldb_msg_to_mods()
 */
-static void lldb_mods_free(LDAPMod **mods)
+static void lldb_mods_free(struct ldb_context *ldb, LDAPMod **mods)
 {
 	int i, j;
 
@@ -312,13 +315,13 @@ static void lldb_mods_free(LDAPMod **mods)
 	for (i=0;mods[i];i++) {
 		if (mods[i]->mod_vals.modv_bvals) {
 			for (j=0;mods[i]->mod_vals.modv_bvals[j];j++) {
-				free(mods[i]->mod_vals.modv_bvals[j]);
+				ldb_free(ldb, mods[i]->mod_vals.modv_bvals[j]);
 			}
-			free(mods[i]->mod_vals.modv_bvals);
+			ldb_free(ldb, mods[i]->mod_vals.modv_bvals);
 		}
-		free(mods[i]);
+		ldb_free(ldb, mods[i]);
 	}
-	free(mods);
+	ldb_free(ldb, mods);
 }
 
 
@@ -326,13 +329,14 @@ static void lldb_mods_free(LDAPMod **mods)
   convert a ldb_message structure to a list of LDAPMod structures
   ready for ldap_add() or ldap_modify()
 */
-static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
+static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
+				  const struct ldb_message *msg, int use_flags)
 {
 	LDAPMod **mods;
 	int i, j, num_mods = 0;
 
 	/* allocate maximum number of elements needed */
-	mods = malloc_array_p(LDAPMod *, msg->num_elements+1);
+	mods = ldb_malloc_array_p(ldb, LDAPMod *, msg->num_elements+1);
 	if (!mods) {
 		errno = ENOMEM;
 		return NULL;
@@ -342,7 +346,7 @@ static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 	for (i=0;i<msg->num_elements;i++) {
 		const struct ldb_message_element *el = &msg->elements[i];
 
-		mods[num_mods] = malloc_p(LDAPMod);
+		mods[num_mods] = ldb_malloc_p(ldb, LDAPMod);
 		if (!mods[num_mods]) {
 			goto failed;
 		}
@@ -362,14 +366,15 @@ static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 			}
 		}
 		mods[num_mods]->mod_type = el->name;
-		mods[num_mods]->mod_vals.modv_bvals = malloc_array_p(struct berval *, 
-								     1+el->num_values);
+		mods[num_mods]->mod_vals.modv_bvals = ldb_malloc_array_p(ldb, 
+									 struct berval *,
+									 1+el->num_values);
 		if (!mods[num_mods]->mod_vals.modv_bvals) {
 			goto failed;
 		}
 
 		for (j=0;j<el->num_values;j++) {
-			mods[num_mods]->mod_vals.modv_bvals[j] = malloc_p(struct berval);
+			mods[num_mods]->mod_vals.modv_bvals[j] = ldb_malloc_p(ldb, struct berval);
 			if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
 				goto failed;
 			}
@@ -383,7 +388,7 @@ static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 	return mods;
 
 failed:
-	lldb_mods_free(mods);
+	lldb_mods_free(ldb, mods);
 	return NULL;
 }
 
@@ -402,14 +407,14 @@ static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
 		return 0;
 	}
 
-	mods = lldb_msg_to_mods(msg, 0);
+	mods = lldb_msg_to_mods(ldb, msg, 0);
 
 	lldb->last_rc = ldap_add_s(lldb->ldap, msg->dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ret = -1;
 	}
 
-	lldb_mods_free(mods);
+	lldb_mods_free(ldb, mods);
 
 	return ret;
 }
@@ -429,14 +434,14 @@ static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
 		return 0;
 	}
 
-	mods = lldb_msg_to_mods(msg, 1);
+	mods = lldb_msg_to_mods(ldb, msg, 1);
 
 	lldb->last_rc = ldap_modify_s(lldb->ldap, msg->dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ret = -1;
 	}
 
-	lldb_mods_free(mods);
+	lldb_mods_free(ldb, mods);
 
 	return ret;
 }
@@ -474,15 +479,15 @@ struct ldb_context *lldb_connect(const char *url,
 	struct lldb_private *lldb = NULL;
 	int i;
 
-	ldb = malloc_p(struct ldb_context);
+	ldb = calloc(1, sizeof(struct ldb_context));
 	if (!ldb) {
 		errno = ENOMEM;
 		goto failed;
 	}
 
-	lldb = malloc_p(struct lldb_private);
+	lldb = ldb_malloc_p(ldb, struct lldb_private);
 	if (!lldb) {
-		free(ldb);
+		ldb_free(ldb, ldb);
 		errno = ENOMEM;
 		goto failed;
 	}
@@ -503,14 +508,14 @@ struct ldb_context *lldb_connect(const char *url,
 		   on the caller keeping it around (it might be dynamic) */
 		for (i=0;options[i];i++) ;
 
-		lldb->options = malloc_array_p(char *, i+1);
+		lldb->options = ldb_malloc_array_p(ldb, char *, i+1);
 		if (!lldb->options) {
 			goto failed;
 		}
 		
 		for (i=0;options[i];i++) {
 			lldb->options[i+1] = NULL;
-			lldb->options[i] = strdup(options[i]);
+			lldb->options[i] = ldb_strdup(ldb, options[i]);
 			if (!lldb->options[i]) {
 				goto failed;
 			}
@@ -522,14 +527,14 @@ struct ldb_context *lldb_connect(const char *url,
 failed:
 	if (lldb && lldb->options) {
 		for (i=0;lldb->options[i];i++) {
-			free(lldb->options[i]);
+			ldb_free(ldb, lldb->options[i]);
 		}
-		free(lldb->options);
+		ldb_free(ldb, lldb->options);
 	}
 	if (lldb && lldb->ldap) {
 		ldap_unbind(lldb->ldap);
 	}
-	if (lldb) free(lldb);
+	ldb_free(ldb, lldb);
 	if (ldb) free(ldb);
 	return NULL;
 }
-- 
cgit 


From 68293565de0b799dcc51e001dabf53adf88ee7ad Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 May 2004 09:55:05 +0000
Subject: r513: added a generic ldb debug system to allow the Samba debug
 functions to be cleanly interfaced to ldb (This used to be commit
 74b89d5f960d6b936751e3f057b4540eb80b79cd)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 7e7d047f25..7e959e7854 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -248,7 +248,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 
 		if (msg_count == count) {
 			/* hmm, got too many? */
-			fprintf(stderr,"Too many messages?!\n");
+			ldb_debug(ldb, LDB_DEBUG_FATAL, "Fatal: ldap message count inconsistent\n");
 			break;
 		}
 
-- 
cgit 


From 265023fafa463c742f89510879acb2a830de8ab9 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 7 May 2004 23:54:41 +0000
Subject: r574:  - another attempt at const cleanliness in ldb

 - fixed a problem with searching for values containing an '=' sign

 - fixed the semantics of attempting an attribute deletion on an attribute that doesn't exist.

 - added some more ldb_msg_*() utilities
(This used to be commit 62b4ec367d170330d837b0f1fe5cd13205a53b59)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 7e959e7854..d96bfd62d3 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -210,7 +210,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 */
 static int lldb_search(struct ldb_context *ldb, const char *base,
 		       enum ldb_scope scope, const char *expression,
-		       char * const *attrs, struct ldb_message ***res)
+		       const char * const *attrs, struct ldb_message ***res)
 {
 	struct lldb_private *lldb = ldb->private_data;
 	int count, msg_count;
-- 
cgit 


From 34ca729f733d9d22fc789a5fce6c448b03c96545 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Wed, 7 Jul 2004 01:02:54 +0000
Subject: r1374: Fix signed/unsigned warnings (actually found by g++) after
 unsigned int changes in r1018. (This used to be commit
 45b4016530fc0bfa13146f73a503866b5dbed517)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index d96bfd62d3..06d3884c16 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -117,7 +117,7 @@ static int lldb_delete(struct ldb_context *ldb, const char *dn)
 */
 static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
 {
-	int i, j;
+	unsigned int i, j;
 	ldb_free(ldb, msg->dn);
 	for (i=0;i<msg->num_elements;i++) {
 		ldb_free(ldb, msg->elements[i].name);
@@ -333,7 +333,8 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 				  const struct ldb_message *msg, int use_flags)
 {
 	LDAPMod **mods;
-	int i, j, num_mods = 0;
+	unsigned int i, j;
+	int num_mods = 0;
 
 	/* allocate maximum number of elements needed */
 	mods = ldb_malloc_array_p(ldb, LDAPMod *, msg->num_elements+1);
-- 
cgit 


From a9bd40549767c19207f3ec520a3e4346beeabef4 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 20 Oct 2004 19:28:02 +0000
Subject: r3093: - implment ldb_rename() and ldbrename

- add tests for ldbrename

- disable all tests which regenerate the index
  (this is broken for me...the process hangs,
   tridge we need to discuss that)

- link only the needed stuff to the ldb tools

- build ldbtest inside samba

metze
(This used to be commit 18552f4786c24e0019cc87726ef4c05365fe586e)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 43 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 06d3884c16..5b682a493a 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -91,6 +91,41 @@ static int lldb_close(struct ldb_context *ldb)
 	return ret;
 }
 
+/*
+  rename a record
+*/
+static int lldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
+{
+	struct lldb_private *lldb = ldb->private_data;
+	int ret = 0;
+	char *newrdn, *p;
+	const char *parentdn = "";
+
+	/* ignore ltdb specials */
+	if (olddn[0] == '@' ||newdn[0] == '@') {
+		return 0;
+	}
+
+	newrdn = ldb_strdup(ldb, newdn);
+	if (!newrdn) {
+		return -1;
+	}
+
+	p = strchr(newrdn, ',');
+	if (p) {
+		*p++ = '\0';
+		parentdn = p;
+	}
+
+	lldb->last_rc = ldap_rename_s(lldb->ldap, olddn, newrdn, parentdn, 1, NULL, NULL);
+	ldb_free(ldb, newrdn);
+	if (lldb->last_rc != LDAP_SUCCESS) {
+		ret = -1;
+	}
+
+	return ret;
+}
+
 /*
   delete a record
 */
@@ -465,6 +500,7 @@ static const struct ldb_backend_ops lldb_ops = {
 	lldb_add,
 	lldb_modify,
 	lldb_delete,
+	lldb_rename,
 	lldb_errstring
 };
 
@@ -478,7 +514,7 @@ struct ldb_context *lldb_connect(const char *url,
 {
 	struct ldb_context *ldb = NULL;
 	struct lldb_private *lldb = NULL;
-	int i;
+	int i, version = 3;
 
 	ldb = calloc(1, sizeof(struct ldb_context));
 	if (!ldb) {
@@ -501,6 +537,11 @@ struct ldb_context *lldb_connect(const char *url,
 		goto failed;
 	}
 
+	lldb->last_rc = ldap_set_option(lldb->ldap, LDAP_OPT_PROTOCOL_VERSION, &version);
+	if (lldb->last_rc != LDAP_SUCCESS) {
+		goto failed;
+	}
+
 	ldb->ops = &lldb_ops;
 	ldb->private_data = lldb;
 
-- 
cgit 


From a6ae640313a47ac2950c0948e4385fa934a5ef09 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 28 Oct 2004 13:19:39 +0000
Subject: r3323: more warning reductions (This used to be commit
 5921587ec26e4892efc678421277e4969417d7f5)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 5b682a493a..9ac51b26fe 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -252,7 +252,9 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 	LDAPMessage *ldapres, *msg;
 
 	lldb->last_rc = ldap_search_s(lldb->ldap, base, (int)scope, 
-				      expression, attrs, 0, &ldapres);
+				      expression, 
+				      discard_const_p(char *, attrs), 
+				      0, &ldapres);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		return -1;
 	}
-- 
cgit 


From 679e95db033fd11d17c1f1ac5e44f6cc4df2220e Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 15 Nov 2004 11:40:27 +0000
Subject: r3754: merge in ldb modules support from the tmp branch ldbPlugins
 (This used to be commit 71323f424b4561af1fdddd2358629049be3dad8c)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 53 ++++++++++++++++++++++++-------------
 1 file changed, 34 insertions(+), 19 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 9ac51b26fe..96aee088a7 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -68,10 +68,11 @@ static const char *lldb_option_find(const struct lldb_private *lldb, const char
 /*
   close/free the connection
 */
-static int lldb_close(struct ldb_context *ldb)
+static int lldb_close(struct ldb_module *module)
 {
 	int i, ret = 0;
-	struct lldb_private *lldb = ldb->private_data;
+	struct ldb_context *ldb = module->ldb;
+	struct lldb_private *lldb = module->private_data;
 
 	if (ldap_unbind(lldb->ldap) != LDAP_SUCCESS) {
 		ret = -1;
@@ -94,9 +95,10 @@ static int lldb_close(struct ldb_context *ldb)
 /*
   rename a record
 */
-static int lldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
+static int lldb_rename(struct ldb_module *module, const char *olddn, const char *newdn)
 {
-	struct lldb_private *lldb = ldb->private_data;
+	struct ldb_context *ldb = module->ldb;
+	struct lldb_private *lldb = module->private_data;
 	int ret = 0;
 	char *newrdn, *p;
 	const char *parentdn = "";
@@ -129,9 +131,9 @@ static int lldb_rename(struct ldb_context *ldb, const char *olddn, const char *n
 /*
   delete a record
 */
-static int lldb_delete(struct ldb_context *ldb, const char *dn)
+static int lldb_delete(struct ldb_module *module, const char *dn)
 {
-	struct lldb_private *lldb = ldb->private_data;
+	struct lldb_private *lldb = module->private_data;
 	int ret = 0;
 
 	/* ignore ltdb specials */
@@ -171,8 +173,9 @@ static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
 /*
   free a search result
 */
-static int lldb_search_free(struct ldb_context *ldb, struct ldb_message **res)
+static int lldb_search_free(struct ldb_module *module, struct ldb_message **res)
 {
+	struct ldb_context *ldb = module->ldb;
 	int i;
 	for (i=0;res[i];i++) {
 		if (lldb_msg_free(ldb, res[i]) != 0) {
@@ -243,11 +246,12 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 /*
   search for matching records
 */
-static int lldb_search(struct ldb_context *ldb, const char *base,
+static int lldb_search(struct ldb_module *module, const char *base,
 		       enum ldb_scope scope, const char *expression,
 		       const char * const *attrs, struct ldb_message ***res)
 {
-	struct lldb_private *lldb = ldb->private_data;
+	struct ldb_context *ldb = module->ldb;
+	struct lldb_private *lldb = module->private_data;
 	int count, msg_count;
 	LDAPMessage *ldapres, *msg;
 
@@ -335,7 +339,7 @@ static int lldb_search(struct ldb_context *ldb, const char *base,
 	return msg_count;
 
 failed:
-	if (*res) lldb_search_free(ldb, *res);
+	if (*res) lldb_search_free(module, *res);
 	return -1;
 }
 
@@ -434,9 +438,10 @@ failed:
 /*
   add a record
 */
-static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
+static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 {
-	struct lldb_private *lldb = ldb->private_data;
+	struct ldb_context *ldb = module->ldb;
+	struct lldb_private *lldb = module->private_data;
 	LDAPMod **mods;
 	int ret = 0;
 
@@ -461,9 +466,10 @@ static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
 /*
   modify a record
 */
-static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
+static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 {
-	struct lldb_private *lldb = ldb->private_data;
+	struct ldb_context *ldb = module->ldb;
+	struct lldb_private *lldb = module->private_data;
 	LDAPMod **mods;
 	int ret = 0;
 
@@ -488,14 +494,15 @@ static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
 /*
   return extended error information
 */
-static const char *lldb_errstring(struct ldb_context *ldb)
+static const char *lldb_errstring(struct ldb_module *module)
 {
-	struct lldb_private *lldb = ldb->private_data;
+	struct lldb_private *lldb = module->private_data;
 	return ldap_err2string(lldb->last_rc);
 }
 
 
-static const struct ldb_backend_ops lldb_ops = {
+static const struct ldb_module_ops lldb_ops = {
+	"ldap",
 	lldb_close, 
 	lldb_search,
 	lldb_search_free,
@@ -544,8 +551,16 @@ struct ldb_context *lldb_connect(const char *url,
 		goto failed;
 	}
 
-	ldb->ops = &lldb_ops;
-	ldb->private_data = lldb;
+	ldb->modules = ldb_malloc_p(ldb, struct ldb_module);
+	if (!ldb->modules) {
+		ldb_free(ldb, ldb);
+		errno = ENOMEM;
+		goto failed;
+	}
+	ldb->modules->ldb = ldb;
+	ldb->modules->prev = ldb->modules->next = NULL;
+	ldb->modules->private_data = lldb;
+	ldb->modules->ops = &lldb_ops;
 
 	if (options) {
 		/* take a copy of the options array, so we don't have to rely
-- 
cgit 


From 950f3eb508a70f2304f76a8307582690d4715670 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 15 Nov 2004 12:30:28 +0000
Subject: r3757: Some fixes for ldb_ldap Now we pass also the test-ldap tests
 :-) (This used to be commit 0d58b1dc5aa0b00a924c1c5506f0c500c0b37b3e)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 96aee088a7..7fb6a0b3f7 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -255,6 +255,10 @@ static int lldb_search(struct ldb_module *module, const char *base,
 	int count, msg_count;
 	LDAPMessage *ldapres, *msg;
 
+	if (base == NULL) {
+		base = "";
+	}
+
 	lldb->last_rc = ldap_search_s(lldb->ldap, base, (int)scope, 
 				      expression, 
 				      discard_const_p(char *, attrs), 
-- 
cgit 


From 8a18778286a16423d7d6e483fdb308a91e294efe Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 16 Nov 2004 09:00:52 +0000
Subject: r3783: - don't use make proto for ldb anymore

- split ldh.h out of samba's includes.h

- make ldb_context and ldb_module private to the subsystem

- use ltdb_ prefix for all ldb_tdb functions

metze
(This used to be commit f5ee40d6ce8224e280070975efc9911558fe675c)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 7fb6a0b3f7..85604dfe76 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -33,6 +33,8 @@
  */
 
 #include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
 #include "ldb/ldb_ldap/ldb_ldap.h"
 
 #if 0
-- 
cgit 


From a4de8cd6a5a882a8d49fdb4b0e625ffdc6b401bb Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 21 Nov 2004 15:51:54 +0000
Subject: r3897: add a locking infrastructure (This used to be commit
 a99c0adb09e2bc77b876d23cb2d0711ccffd83ca)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 85604dfe76..d9640f247a 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -496,6 +496,35 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 	return ret;
 }
 
+static int lldb_lock(struct ldb_module *module, const char *lockname)
+{
+	struct ldb_context *ldb = module->ldb;
+	struct lldb_private *lldb = module->private_data;
+	int ret = 0;
+
+	if (lockname == NULL) {
+		return -1;
+	}
+
+	/* TODO implement a local locking mechanism here */
+
+	return ret;
+}
+
+static int lldb_unlock(struct ldb_module *module, const char *lockname)
+{
+	struct ldb_context *ldb = module->ldb;
+	struct lldb_private *lldb = module->private_data;
+	int ret = 0;
+
+	if (lockname == NULL) {
+		return -1;
+	}
+
+	/* TODO implement a local unlocking mechanism here */
+
+	return ret;
+}
 
 /*
   return extended error information
@@ -516,6 +545,8 @@ static const struct ldb_module_ops lldb_ops = {
 	lldb_modify,
 	lldb_delete,
 	lldb_rename,
+	lldb_lock,
+	lldb_unlock,
 	lldb_errstring
 };
 
-- 
cgit 


From 90b06b4ea8d8d06e9cd9f6678b4086eda49204bd Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 23 Nov 2004 17:35:37 +0000
Subject: r3926: fix compiler warnings

metze
(This used to be commit a9cbaa3cff470f58031972d53ecb6f5856b187e0)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index d9640f247a..b9c3865acc 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -498,8 +498,6 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 
 static int lldb_lock(struct ldb_module *module, const char *lockname)
 {
-	struct ldb_context *ldb = module->ldb;
-	struct lldb_private *lldb = module->private_data;
 	int ret = 0;
 
 	if (lockname == NULL) {
@@ -513,8 +511,6 @@ static int lldb_lock(struct ldb_module *module, const char *lockname)
 
 static int lldb_unlock(struct ldb_module *module, const char *lockname)
 {
-	struct ldb_context *ldb = module->ldb;
-	struct lldb_private *lldb = module->private_data;
 	int ret = 0;
 
 	if (lockname == NULL) {
-- 
cgit 


From 1a988ec9af7960616fb4661b20d86ff05146d836 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 2 Jan 2005 07:49:29 +0000
Subject: r4474: - converted ldb to use talloc internally

- added gcov flags to Makefile.ldb

- expanded ldb test suite to get more coverage
(This used to be commit 0ab98f50a7e0fe15347a99e5c29a6590a87729a0)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 149 ++++++++++--------------------------
 1 file changed, 40 insertions(+), 109 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index b9c3865acc..fee02da32f 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -72,26 +72,9 @@ static const char *lldb_option_find(const struct lldb_private *lldb, const char
 */
 static int lldb_close(struct ldb_module *module)
 {
-	int i, ret = 0;
 	struct ldb_context *ldb = module->ldb;
-	struct lldb_private *lldb = module->private_data;
-
-	if (ldap_unbind(lldb->ldap) != LDAP_SUCCESS) {
-		ret = -1;
-	}
-
-	ldb_set_alloc(ldb, NULL, NULL);
-
-	if (lldb->options) {
-		for (i=0;lldb->options[i];i++) {
-			ldb_free(ldb, lldb->options[i]);
-		}
-		ldb_free(ldb, lldb->options);
-	}
-	ldb_free(ldb, lldb);
-	free(ldb);
-
-	return ret;
+	talloc_free(ldb);
+	return 0;
 }
 
 /*
@@ -99,18 +82,18 @@ static int lldb_close(struct ldb_module *module)
 */
 static int lldb_rename(struct ldb_module *module, const char *olddn, const char *newdn)
 {
-	struct ldb_context *ldb = module->ldb;
 	struct lldb_private *lldb = module->private_data;
 	int ret = 0;
 	char *newrdn, *p;
 	const char *parentdn = "";
+	TALLOC_CTX *mem_ctx = talloc(lldb, 0);
 
 	/* ignore ltdb specials */
 	if (olddn[0] == '@' ||newdn[0] == '@') {
 		return 0;
 	}
 
-	newrdn = ldb_strdup(ldb, newdn);
+	newrdn = talloc_strdup(mem_ctx, newdn);
 	if (!newrdn) {
 		return -1;
 	}
@@ -122,11 +105,12 @@ static int lldb_rename(struct ldb_module *module, const char *olddn, const char
 	}
 
 	lldb->last_rc = ldap_rename_s(lldb->ldap, olddn, newrdn, parentdn, 1, NULL, NULL);
-	ldb_free(ldb, newrdn);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ret = -1;
 	}
 
+	talloc_free(mem_ctx);
+
 	return ret;
 }
 
@@ -151,40 +135,12 @@ static int lldb_delete(struct ldb_module *module, const char *dn)
 	return ret;
 }
 
-/*
-  free a search message
-*/
-static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
-{
-	unsigned int i, j;
-	ldb_free(ldb, msg->dn);
-	for (i=0;i<msg->num_elements;i++) {
-		ldb_free(ldb, msg->elements[i].name);
-		for (j=0;j<msg->elements[i].num_values;j++) {
-			if (msg->elements[i].values[j].data) {
-				ldb_free(ldb, msg->elements[i].values[j].data);
-			}
-		}
-		ldb_free(ldb, msg->elements[i].values);
-	}
-	if (msg->elements) ldb_free(ldb, msg->elements);
-	ldb_free(ldb, msg);
-	return 0;
-}
-
 /*
   free a search result
 */
 static int lldb_search_free(struct ldb_module *module, struct ldb_message **res)
 {
-	struct ldb_context *ldb = module->ldb;
-	int i;
-	for (i=0;res[i];i++) {
-		if (lldb_msg_free(ldb, res[i]) != 0) {
-			return -1;
-		}
-	}
-	ldb_free(ldb, res);
+	talloc_free(res);
 	return 0;
 }
 
@@ -205,8 +161,8 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 		return -1;
 	}
 
-	el = ldb_realloc_p(ldb, msg->elements, struct ldb_message_element, 
-			   msg->num_elements + 1);
+	el = talloc_realloc_p(msg, msg->elements, struct ldb_message_element, 
+			      msg->num_elements + 1);
 	if (!el) {
 		errno = ENOMEM;
 		return -1;
@@ -216,7 +172,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 
 	el = &msg->elements[msg->num_elements];
 
-	el->name = ldb_strdup(ldb, attr);
+	el->name = talloc_strdup(msg->elements, attr);
 	if (!el->name) {
 		errno = ENOMEM;
 		return -1;
@@ -224,18 +180,17 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 	el->flags = 0;
 
 	el->num_values = 0;
-	el->values = ldb_malloc_array_p(ldb, struct ldb_val, count);
+	el->values = talloc_array_p(msg->elements, struct ldb_val, count);
 	if (!el->values) {
 		errno = ENOMEM;
 		return -1;
 	}
 
 	for (i=0;i<count;i++) {
-		el->values[i].data = ldb_malloc(ldb, bval[i]->bv_len);
+		el->values[i].data = talloc_memdup(el->values, bval[i]->bv_val, bval[i]->bv_len);
 		if (!el->values[i].data) {
 			return -1;
 		}
-		memcpy(el->values[i].data, bval[i]->bv_val, bval[i]->bv_len);
 		el->values[i].length = bval[i]->bv_len;
 		el->num_values++;
 	}
@@ -275,7 +230,7 @@ static int lldb_search(struct ldb_module *module, const char *base,
 		return count;
 	}
 
-	(*res) = ldb_malloc_array_p(ldb, struct ldb_message *, count+1);
+	(*res) = talloc_array_p(lldb, struct ldb_message *, count+1);
 	if (! *res) {
 		ldap_msgfree(ldapres);
 		errno = ENOMEM;
@@ -299,7 +254,7 @@ static int lldb_search(struct ldb_module *module, const char *base,
 			break;
 		}
 
-		(*res)[msg_count] = ldb_malloc_p(ldb, struct ldb_message);
+		(*res)[msg_count] = talloc_p(*res, struct ldb_message);
 		if (!(*res)[msg_count]) {
 			goto failed;
 		}
@@ -310,7 +265,7 @@ static int lldb_search(struct ldb_module *module, const char *base,
 			goto failed;
 		}
 
-		(*res)[msg_count]->dn = ldb_strdup(ldb, dn);
+		(*res)[msg_count]->dn = talloc_strdup((*res)[msg_count], dn);
 		ldap_memfree(dn);
 		if (!(*res)[msg_count]->dn) {
 			goto failed;
@@ -350,28 +305,6 @@ failed:
 }
 
 
-/*
-  free a set of mods from lldb_msg_to_mods()
-*/
-static void lldb_mods_free(struct ldb_context *ldb, LDAPMod **mods)
-{
-	int i, j;
-
-	if (!mods) return;
-
-	for (i=0;mods[i];i++) {
-		if (mods[i]->mod_vals.modv_bvals) {
-			for (j=0;mods[i]->mod_vals.modv_bvals[j];j++) {
-				ldb_free(ldb, mods[i]->mod_vals.modv_bvals[j]);
-			}
-			ldb_free(ldb, mods[i]->mod_vals.modv_bvals);
-		}
-		ldb_free(ldb, mods[i]);
-	}
-	ldb_free(ldb, mods);
-}
-
-
 /*
   convert a ldb_message structure to a list of LDAPMod structures
   ready for ldap_add() or ldap_modify()
@@ -384,7 +317,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 	int num_mods = 0;
 
 	/* allocate maximum number of elements needed */
-	mods = ldb_malloc_array_p(ldb, LDAPMod *, msg->num_elements+1);
+	mods = talloc_array_p(ldb, LDAPMod *, msg->num_elements+1);
 	if (!mods) {
 		errno = ENOMEM;
 		return NULL;
@@ -394,7 +327,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 	for (i=0;i<msg->num_elements;i++) {
 		const struct ldb_message_element *el = &msg->elements[i];
 
-		mods[num_mods] = ldb_malloc_p(ldb, LDAPMod);
+		mods[num_mods] = talloc_p(ldb, LDAPMod);
 		if (!mods[num_mods]) {
 			goto failed;
 		}
@@ -414,15 +347,16 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 			}
 		}
 		mods[num_mods]->mod_type = el->name;
-		mods[num_mods]->mod_vals.modv_bvals = ldb_malloc_array_p(ldb, 
-									 struct berval *,
-									 1+el->num_values);
+		mods[num_mods]->mod_vals.modv_bvals = talloc_array_p(mods[num_mods], 
+								     struct berval *,
+								     1+el->num_values);
 		if (!mods[num_mods]->mod_vals.modv_bvals) {
 			goto failed;
 		}
 
 		for (j=0;j<el->num_values;j++) {
-			mods[num_mods]->mod_vals.modv_bvals[j] = ldb_malloc_p(ldb, struct berval);
+			mods[num_mods]->mod_vals.modv_bvals[j] = talloc_p(mods[num_mods]->mod_vals.modv_bvals,
+									  struct berval);
 			if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
 				goto failed;
 			}
@@ -436,7 +370,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 	return mods;
 
 failed:
-	lldb_mods_free(ldb, mods);
+	talloc_free(mods);
 	return NULL;
 }
 
@@ -463,7 +397,7 @@ static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 		ret = -1;
 	}
 
-	lldb_mods_free(ldb, mods);
+	talloc_free(mods);
 
 	return ret;
 }
@@ -491,7 +425,7 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 		ret = -1;
 	}
 
-	lldb_mods_free(ldb, mods);
+	talloc_free(mods);
 
 	return ret;
 }
@@ -547,6 +481,13 @@ static const struct ldb_module_ops lldb_ops = {
 };
 
 
+static int lldb_destructor(void *p)
+{
+	struct lldb_private *lldb = p;
+	ldap_unbind(lldb->ldap);
+	return 0;
+}
+
 /*
   connect to the database
 */
@@ -558,15 +499,14 @@ struct ldb_context *lldb_connect(const char *url,
 	struct lldb_private *lldb = NULL;
 	int i, version = 3;
 
-	ldb = calloc(1, sizeof(struct ldb_context));
+	ldb = talloc_p(NULL, struct ldb_context);
 	if (!ldb) {
 		errno = ENOMEM;
 		goto failed;
 	}
 
-	lldb = ldb_malloc_p(ldb, struct lldb_private);
+	lldb = talloc_p(ldb, struct lldb_private);
 	if (!lldb) {
-		ldb_free(ldb, ldb);
 		errno = ENOMEM;
 		goto failed;
 	}
@@ -579,14 +519,15 @@ struct ldb_context *lldb_connect(const char *url,
 		goto failed;
 	}
 
+	talloc_set_destructor(lldb, lldb_destructor);
+
 	lldb->last_rc = ldap_set_option(lldb->ldap, LDAP_OPT_PROTOCOL_VERSION, &version);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		goto failed;
 	}
 
-	ldb->modules = ldb_malloc_p(ldb, struct ldb_module);
+	ldb->modules = talloc_p(ldb, struct ldb_module);
 	if (!ldb->modules) {
-		ldb_free(ldb, ldb);
 		errno = ENOMEM;
 		goto failed;
 	}
@@ -600,14 +541,14 @@ struct ldb_context *lldb_connect(const char *url,
 		   on the caller keeping it around (it might be dynamic) */
 		for (i=0;options[i];i++) ;
 
-		lldb->options = ldb_malloc_array_p(ldb, char *, i+1);
+		lldb->options = talloc_array_p(lldb, char *, i+1);
 		if (!lldb->options) {
 			goto failed;
 		}
 		
 		for (i=0;options[i];i++) {
 			lldb->options[i+1] = NULL;
-			lldb->options[i] = ldb_strdup(ldb, options[i]);
+			lldb->options[i] = talloc_strdup(lldb->options, options[i]);
 			if (!lldb->options[i]) {
 				goto failed;
 			}
@@ -617,17 +558,7 @@ struct ldb_context *lldb_connect(const char *url,
 	return ldb;
 
 failed:
-	if (lldb && lldb->options) {
-		for (i=0;lldb->options[i];i++) {
-			ldb_free(ldb, lldb->options[i]);
-		}
-		ldb_free(ldb, lldb->options);
-	}
-	if (lldb && lldb->ldap) {
-		ldap_unbind(lldb->ldap);
-	}
-	ldb_free(ldb, lldb);
-	if (ldb) free(ldb);
+	talloc_free(ldb);
 	return NULL;
 }
 
-- 
cgit 


From cc55aef7c116d03ba2817625b0ba9edb378525e3 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 Jan 2005 02:32:43 +0000
Subject: r4547: - added talloc_new(ctx) macro that is a neater form of the
 common talloc(ctx, 0) call.

- cleaned up some talloc usage in various files

I'd like to get to the point that we have no calls to talloc(), at
which point we will rename talloc_p() to talloc(), to encourage
everyone to use the typesafe functions.
(This used to be commit e6c81d7c9f8a6938947d3c1c8a971a0d6d50b67a)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index fee02da32f..bab3c86e16 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -86,7 +86,7 @@ static int lldb_rename(struct ldb_module *module, const char *olddn, const char
 	int ret = 0;
 	char *newrdn, *p;
 	const char *parentdn = "";
-	TALLOC_CTX *mem_ctx = talloc(lldb, 0);
+	TALLOC_CTX *mem_ctx = talloc_new(lldb);
 
 	/* ignore ltdb specials */
 	if (olddn[0] == '@' ||newdn[0] == '@') {
-- 
cgit 


From a2f77f979d7271a9708ed06f43b00ffb10ec7f4c Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 12 Jan 2005 16:00:01 +0000
Subject: r4714: move the ldb code to the new talloc interface (eg remove _p
 suffix) this helps standalone building of ldb

renew the schema module
split code into functions to improve readability and code reuse

add and modify works correctly but we need a proper testsuite

Simo
(This used to be commit a681ae365ff1b5a2771b42ebd90336651ce1e513)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index bab3c86e16..46ea1a9e33 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -161,7 +161,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 		return -1;
 	}
 
-	el = talloc_realloc_p(msg, msg->elements, struct ldb_message_element, 
+	el = talloc_realloc(msg, msg->elements, struct ldb_message_element, 
 			      msg->num_elements + 1);
 	if (!el) {
 		errno = ENOMEM;
@@ -180,7 +180,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 	el->flags = 0;
 
 	el->num_values = 0;
-	el->values = talloc_array_p(msg->elements, struct ldb_val, count);
+	el->values = talloc_array(msg->elements, struct ldb_val, count);
 	if (!el->values) {
 		errno = ENOMEM;
 		return -1;
@@ -230,7 +230,7 @@ static int lldb_search(struct ldb_module *module, const char *base,
 		return count;
 	}
 
-	(*res) = talloc_array_p(lldb, struct ldb_message *, count+1);
+	(*res) = talloc_array(lldb, struct ldb_message *, count+1);
 	if (! *res) {
 		ldap_msgfree(ldapres);
 		errno = ENOMEM;
@@ -254,7 +254,7 @@ static int lldb_search(struct ldb_module *module, const char *base,
 			break;
 		}
 
-		(*res)[msg_count] = talloc_p(*res, struct ldb_message);
+		(*res)[msg_count] = talloc(*res, struct ldb_message);
 		if (!(*res)[msg_count]) {
 			goto failed;
 		}
@@ -317,7 +317,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 	int num_mods = 0;
 
 	/* allocate maximum number of elements needed */
-	mods = talloc_array_p(ldb, LDAPMod *, msg->num_elements+1);
+	mods = talloc_array(ldb, LDAPMod *, msg->num_elements+1);
 	if (!mods) {
 		errno = ENOMEM;
 		return NULL;
@@ -327,7 +327,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 	for (i=0;i<msg->num_elements;i++) {
 		const struct ldb_message_element *el = &msg->elements[i];
 
-		mods[num_mods] = talloc_p(ldb, LDAPMod);
+		mods[num_mods] = talloc(ldb, LDAPMod);
 		if (!mods[num_mods]) {
 			goto failed;
 		}
@@ -347,7 +347,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 			}
 		}
 		mods[num_mods]->mod_type = el->name;
-		mods[num_mods]->mod_vals.modv_bvals = talloc_array_p(mods[num_mods], 
+		mods[num_mods]->mod_vals.modv_bvals = talloc_array(mods[num_mods], 
 								     struct berval *,
 								     1+el->num_values);
 		if (!mods[num_mods]->mod_vals.modv_bvals) {
@@ -355,7 +355,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 		}
 
 		for (j=0;j<el->num_values;j++) {
-			mods[num_mods]->mod_vals.modv_bvals[j] = talloc_p(mods[num_mods]->mod_vals.modv_bvals,
+			mods[num_mods]->mod_vals.modv_bvals[j] = talloc(mods[num_mods]->mod_vals.modv_bvals,
 									  struct berval);
 			if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
 				goto failed;
@@ -499,13 +499,13 @@ struct ldb_context *lldb_connect(const char *url,
 	struct lldb_private *lldb = NULL;
 	int i, version = 3;
 
-	ldb = talloc_p(NULL, struct ldb_context);
+	ldb = talloc(NULL, struct ldb_context);
 	if (!ldb) {
 		errno = ENOMEM;
 		goto failed;
 	}
 
-	lldb = talloc_p(ldb, struct lldb_private);
+	lldb = talloc(ldb, struct lldb_private);
 	if (!lldb) {
 		errno = ENOMEM;
 		goto failed;
@@ -526,7 +526,7 @@ struct ldb_context *lldb_connect(const char *url,
 		goto failed;
 	}
 
-	ldb->modules = talloc_p(ldb, struct ldb_module);
+	ldb->modules = talloc(ldb, struct ldb_module);
 	if (!ldb->modules) {
 		errno = ENOMEM;
 		goto failed;
@@ -541,7 +541,7 @@ struct ldb_context *lldb_connect(const char *url,
 		   on the caller keeping it around (it might be dynamic) */
 		for (i=0;options[i];i++) ;
 
-		lldb->options = talloc_array_p(lldb, char *, i+1);
+		lldb->options = talloc_array(lldb, char *, i+1);
 		if (!lldb->options) {
 			goto failed;
 		}
-- 
cgit 


From b1b14817eaa6e6579596d54166e17bc8d5605c01 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 27 Feb 2005 11:35:47 +0000
Subject: r5585: LDB interfaces change:

changes:
- ldb_wrap disappears from code and become a private structure of db_wrap.c
  thanks to our move to talloc in ldb code, we do not need to expose it anymore

- removal of ldb_close() function form the code
  thanks to our move to talloc in ldb code, we do not need it anymore
  use talloc_free() to close and free an ldb database

- some minor updates to ldb modules code to cope with the change and fix some
  bugs I found out during the process
(This used to be commit d58be9e74b786a11a57e89df36081d55730dfe0a)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 11 -----------
 1 file changed, 11 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 46ea1a9e33..dc392dd56b 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -67,16 +67,6 @@ static const char *lldb_option_find(const struct lldb_private *lldb, const char
 }
 #endif
 
-/*
-  close/free the connection
-*/
-static int lldb_close(struct ldb_module *module)
-{
-	struct ldb_context *ldb = module->ldb;
-	talloc_free(ldb);
-	return 0;
-}
-
 /*
   rename a record
 */
@@ -468,7 +458,6 @@ static const char *lldb_errstring(struct ldb_module *module)
 
 static const struct ldb_module_ops lldb_ops = {
 	"ldap",
-	lldb_close, 
 	lldb_search,
 	lldb_search_free,
 	lldb_add,
-- 
cgit 


From fe4d985b6f3d318d9b58a16677be3b4ae34fba15 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 25 Apr 2005 12:46:18 +0000
Subject: r6470: Remove ldb_search_free() it is not needed anymore. Just use
 talloc_free() to release the memory after an ldb_search(). (This used to be
 commit 4f0948dab0aa5e8b6a4ce486f3668ca8dfae23db)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index dc392dd56b..c62c1b9e56 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -125,16 +125,6 @@ static int lldb_delete(struct ldb_module *module, const char *dn)
 	return ret;
 }
 
-/*
-  free a search result
-*/
-static int lldb_search_free(struct ldb_module *module, struct ldb_message **res)
-{
-	talloc_free(res);
-	return 0;
-}
-
-
 /*
   add a single set of ldap message values to a ldb_message
 */
@@ -290,7 +280,7 @@ static int lldb_search(struct ldb_module *module, const char *base,
 	return msg_count;
 
 failed:
-	if (*res) lldb_search_free(module, *res);
+	if (*res) talloc_free(*res);
 	return -1;
 }
 
@@ -459,7 +449,6 @@ static const char *lldb_errstring(struct ldb_module *module)
 static const struct ldb_module_ops lldb_ops = {
 	"ldap",
 	lldb_search,
-	lldb_search_free,
 	lldb_add,
 	lldb_modify,
 	lldb_delete,
-- 
cgit 


From 490a5a5d595c021771fb6965829a3821d6dddb6a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 13 Jun 2005 06:02:55 +0000
Subject: r7518: don't use an uninitialised ldb debug function when failing to
 load modules in the ldap backend (This used to be commit
 52e4a5b3b0c4c96bf9686ce047ccfc1846dc2c89)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index c62c1b9e56..95b620f571 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -483,6 +483,8 @@ struct ldb_context *lldb_connect(const char *url,
 		goto failed;
 	}
 
+	ldb->debug_ops.debug = NULL;
+
 	lldb = talloc(ldb, struct lldb_private);
 	if (!lldb) {
 		errno = ENOMEM;
-- 
cgit 


From 4b0e5bd75373ffa2d847706a71fd0349dfa15e71 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 13 Jun 2005 09:10:17 +0000
Subject: r7527: - added a ldb_search_bytree() interface, which takes a
 ldb_parse_tree   instead of a search expression. This allows our ldap server
 to pass   its ASN.1 parsed search expressions straight to ldb, instead of
 going   via strings.

- updated all the ldb modules code to handle the new interface

- got rid of the separate ldb_parse.h now that the ldb_parse
  structures are exposed externally

- moved to C99 structure initialisation in ldb

- switched ldap server to using ldb_search_bytree()
(This used to be commit 96620ab2ee5d440bbbc51c1bc0cad9977770f897)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 40 ++++++++++++++++++++++++++++---------
 1 file changed, 31 insertions(+), 9 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 95b620f571..fceaf02196 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -285,6 +285,27 @@ failed:
 }
 
 
+/*
+  search for matching records using a ldb_parse_tree
+*/
+static int lldb_search_bytree(struct ldb_module *module, const char *base,
+			      enum ldb_scope scope, struct ldb_parse_tree *tree,
+			      const char * const *attrs, struct ldb_message ***res)
+{
+	struct lldb_private *lldb = module->private_data;
+	char *expression;
+	int ret;
+
+	expression = ldb_filter_from_tree(lldb, tree);
+	if (expression == NULL) {
+		return -1;
+	}
+	ret = lldb_search(module, base, scope, expression, attrs, res);
+	talloc_free(expression);
+	return ret;
+}
+
+
 /*
   convert a ldb_message structure to a list of LDAPMod structures
   ready for ldap_add() or ldap_modify()
@@ -447,15 +468,16 @@ static const char *lldb_errstring(struct ldb_module *module)
 
 
 static const struct ldb_module_ops lldb_ops = {
-	"ldap",
-	lldb_search,
-	lldb_add,
-	lldb_modify,
-	lldb_delete,
-	lldb_rename,
-	lldb_lock,
-	lldb_unlock,
-	lldb_errstring
+	.name          = "ldap",
+	.search        = lldb_search,
+	.search_bytree = lldb_search_bytree,
+	.add_record    = lldb_add,
+	.modify_record = lldb_modify,
+	.delete_record = lldb_delete,
+	.rename_record = lldb_rename,
+	.named_lock    = lldb_lock,
+	.named_unlock  = lldb_unlock,
+	.errstring     = lldb_errstring
 };
 
 
-- 
cgit 


From 9189833a8753a723a8b8d0af9c8b096571b06a84 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 14 Jun 2005 19:15:17 +0000
Subject: r7582: Better way to have a fast path searching for a specific DN.
 Old way was ugly and had a bug, you couldn't add an attribute named dn or
 distinguishedName and search for it, tdb would change that search in a dn
 search. This makes it also possible to search by dn against an ldap server as
 the old method was not supported by ldap syntaxes.

sss
(This used to be commit a614466dec2484a0d39bdfae53da822cfcf80926)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index fceaf02196..b3d8fcc1a5 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -196,6 +196,10 @@ static int lldb_search(struct ldb_module *module, const char *base,
 		base = "";
 	}
 
+	if (expression == NULL || expression[0] == '\0') {
+		expression = "objectClass=*";
+	}
+
 	lldb->last_rc = ldap_search_s(lldb->ldap, base, (int)scope, 
 				      expression, 
 				      discard_const_p(char *, attrs), 
-- 
cgit 


From 93e03bd27215a54d79ca996941468d1c33099ff3 Mon Sep 17 00:00:00 2001
From: Derrell Lipman <derrell@samba.org>
Date: Wed, 15 Jun 2005 02:45:11 +0000
Subject: r7602: fix some compiler warnings (This used to be commit
 ce9966e091d36f66d409ac6f7b5e462c9dc37325)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index b3d8fcc1a5..828bcc5d61 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -351,7 +351,7 @@ static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
 				break;
 			}
 		}
-		mods[num_mods]->mod_type = el->name;
+		mods[num_mods]->mod_type = discard_const_p(char, el->name);
 		mods[num_mods]->mod_vals.modv_bvals = talloc_array(mods[num_mods], 
 								     struct berval *,
 								     1+el->num_values);
-- 
cgit 


From 52400f0f7d26727a59797e21c09a1433daf094e4 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 17 Jun 2005 02:46:25 +0000
Subject: r7666: fixed a memory leak in the ldap ldb backend (This used to be
 commit ac3f33c61555a2afa30fe446676013564982e257)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 828bcc5d61..16beed58f8 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -76,14 +76,13 @@ static int lldb_rename(struct ldb_module *module, const char *olddn, const char
 	int ret = 0;
 	char *newrdn, *p;
 	const char *parentdn = "";
-	TALLOC_CTX *mem_ctx = talloc_new(lldb);
 
 	/* ignore ltdb specials */
 	if (olddn[0] == '@' ||newdn[0] == '@') {
 		return 0;
 	}
 
-	newrdn = talloc_strdup(mem_ctx, newdn);
+	newrdn = talloc_strdup(lldb, newdn);
 	if (!newrdn) {
 		return -1;
 	}
@@ -99,7 +98,7 @@ static int lldb_rename(struct ldb_module *module, const char *olddn, const char
 		ret = -1;
 	}
 
-	talloc_free(mem_ctx);
+	talloc_free(newrdn);
 
 	return ret;
 }
-- 
cgit 


From ed3d8091ce2b2014350a2f7f22202dde6846a130 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 18 Jun 2005 07:42:21 +0000
Subject: r7709: - convert ldb to use popt, so that it can interact with the
 samba   cmdline credentials code (which will be done soon)

- added a ldb_init() call, and changed ldb_connect() to take a ldb
  context. This allows for much better error handling in
  ldb_connect(), and also made the popt conversion easier

- fixed up all the existing backends with the new syntax

- improved error handling in *_connect()

- fixed a crash bug in the new case_fold_required() code

- ensured that ltdb_rename() and all ltdb_search() paths get the read lock

- added a ldb_oom() macro to make it easier to report out of memory
  situations in ldb code
(This used to be commit f648fdf187669d6d87d01dd4e786b03cd420f220)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 82 +++++++------------------------------
 1 file changed, 14 insertions(+), 68 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 16beed58f8..d7f589e2e5 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -37,36 +37,6 @@
 #include "ldb/include/ldb_private.h"
 #include "ldb/ldb_ldap/ldb_ldap.h"
 
-#if 0
-/*
-  we don't need this right now, but will once we add some backend 
-  options
-*/
-
-/*
-  find an option in an option list (a null terminated list of strings)
-
-  this assumes the list is short. If it ever gets long then we really
-  should do this in some smarter way
- */
-static const char *lldb_option_find(const struct lldb_private *lldb, const char *name)
-{
-	int i;
-	size_t len = strlen(name);
-
-	if (!lldb->options) return NULL;
-
-	for (i=0;lldb->options[i];i++) {		
-		if (strncmp(lldb->options[i], name, len) == 0 &&
-		    lldb->options[i][len] == '=') {
-			return &lldb->options[i][len+1];
-		}
-	}
-
-	return NULL;
-}
-#endif
-
 /*
   rename a record
 */
@@ -494,25 +464,17 @@ static int lldb_destructor(void *p)
 /*
   connect to the database
 */
-struct ldb_context *lldb_connect(const char *url, 
-				 unsigned int flags, 
-				 const char *options[])
+int lldb_connect(struct ldb_context *ldb,
+		 const char *url, 
+		 unsigned int flags, 
+		 const char *options[])
 {
-	struct ldb_context *ldb = NULL;
 	struct lldb_private *lldb = NULL;
-	int i, version = 3;
-
-	ldb = talloc(NULL, struct ldb_context);
-	if (!ldb) {
-		errno = ENOMEM;
-		goto failed;
-	}
-
-	ldb->debug_ops.debug = NULL;
+	int version = 3;
 
 	lldb = talloc(ldb, struct lldb_private);
 	if (!lldb) {
-		errno = ENOMEM;
+		ldb_oom(ldb);
 		goto failed;
 	}
 
@@ -521,6 +483,8 @@ struct ldb_context *lldb_connect(const char *url,
 
 	lldb->last_rc = ldap_initialize(&lldb->ldap, url);
 	if (lldb->last_rc != LDAP_SUCCESS) {
+		ldb_debug(ldb, LDB_DEBUG_FATAL, "ldap_initialize failed for URL '%s' - %s\n",
+			  url, ldap_err2string(lldb->last_rc));
 		goto failed;
 	}
 
@@ -528,12 +492,13 @@ struct ldb_context *lldb_connect(const char *url,
 
 	lldb->last_rc = ldap_set_option(lldb->ldap, LDAP_OPT_PROTOCOL_VERSION, &version);
 	if (lldb->last_rc != LDAP_SUCCESS) {
-		goto failed;
+		ldb_debug(ldb, LDB_DEBUG_FATAL, "ldap_set_option failed - %s\n",
+			  ldap_err2string(lldb->last_rc));
 	}
 
 	ldb->modules = talloc(ldb, struct ldb_module);
 	if (!ldb->modules) {
-		errno = ENOMEM;
+		ldb_oom(ldb);
 		goto failed;
 	}
 	ldb->modules->ldb = ldb;
@@ -541,29 +506,10 @@ struct ldb_context *lldb_connect(const char *url,
 	ldb->modules->private_data = lldb;
 	ldb->modules->ops = &lldb_ops;
 
-	if (options) {
-		/* take a copy of the options array, so we don't have to rely
-		   on the caller keeping it around (it might be dynamic) */
-		for (i=0;options[i];i++) ;
-
-		lldb->options = talloc_array(lldb, char *, i+1);
-		if (!lldb->options) {
-			goto failed;
-		}
-		
-		for (i=0;options[i];i++) {
-			lldb->options[i+1] = NULL;
-			lldb->options[i] = talloc_strdup(lldb->options, options[i]);
-			if (!lldb->options[i]) {
-				goto failed;
-			}
-		}
-	}
-
-	return ldb;
+	return 0;
 
 failed:
-	talloc_free(ldb);
-	return NULL;
+	talloc_free(lldb);
+	return -1;
 }
 
-- 
cgit 


From 3e4c4cff2177af33efdb15f03a1bbcb639505cee Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 18 Aug 2005 15:02:01 +0000
Subject: r9391: Convert all the code to use struct ldb_dn to ohandle ldap like
 distinguished names Provide more functions to handle DNs in this form (This
 used to be commit 692e35b7797e39533dd2a1c4b63d9da30f1eb5ba)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 94 +++++++++++++++++++++++++++----------
 1 file changed, 70 insertions(+), 24 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index d7f589e2e5..2da4f1af8e 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -40,57 +40,77 @@
 /*
   rename a record
 */
-static int lldb_rename(struct ldb_module *module, const char *olddn, const char *newdn)
+static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
+	TALLOC_CTX *local_ctx;
 	struct lldb_private *lldb = module->private_data;
 	int ret = 0;
-	char *newrdn, *p;
+	char *old_dn;
+	char *newrdn;
 	const char *parentdn = "";
 
 	/* ignore ltdb specials */
-	if (olddn[0] == '@' ||newdn[0] == '@') {
+	if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
 		return 0;
 	}
 
-	newrdn = talloc_strdup(lldb, newdn);
-	if (!newrdn) {
+	local_ctx = talloc_named(lldb, 0, "lldb_rename local context");
+	if (local_ctx == NULL) {
 		return -1;
 	}
 
-	p = strchr(newrdn, ',');
-	if (p) {
-		*p++ = '\0';
-		parentdn = p;
+	old_dn = ldb_dn_linearize(local_ctx, olddn);
+	if (old_dn == NULL) {
+		goto failed;
+	}
+
+	newrdn = talloc_asprintf(lldb, "%s=%s",
+				      newdn->components[0].name,
+				      ldb_dn_escape_value(lldb, newdn->components[0].value));
+	if (!newrdn) {
+		goto failed;
+	}
+
+	parentdn = ldb_dn_linearize(lldb, ldb_dn_get_parent(lldb, newdn));
+	if (!parentdn) {
+		goto failed;
 	}
 
-	lldb->last_rc = ldap_rename_s(lldb->ldap, olddn, newrdn, parentdn, 1, NULL, NULL);
+	lldb->last_rc = ldap_rename_s(lldb->ldap, old_dn, newrdn, parentdn, 1, NULL, NULL);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ret = -1;
 	}
 
-	talloc_free(newrdn);
-
+	talloc_free(local_ctx);
 	return ret;
+
+failed:
+	talloc_free(local_ctx);
+	return -1;
 }
 
 /*
   delete a record
 */
-static int lldb_delete(struct ldb_module *module, const char *dn)
+static int lldb_delete(struct ldb_module *module, const struct ldb_dn *edn)
 {
 	struct lldb_private *lldb = module->private_data;
+	char *dn;
 	int ret = 0;
 
 	/* ignore ltdb specials */
-	if (dn[0] == '@') {
+	if (ldb_dn_is_special(edn)) {
 		return 0;
 	}
-	
+
+	dn = ldb_dn_linearize(lldb, edn);
+
 	lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ret = -1;
 	}
 
+	talloc_free(dn);
 	return ret;
 }
 
@@ -152,27 +172,33 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 /*
   search for matching records
 */
-static int lldb_search(struct ldb_module *module, const char *base,
+static int lldb_search(struct ldb_module *module, const struct ldb_dn *base,
 		       enum ldb_scope scope, const char *expression,
 		       const char * const *attrs, struct ldb_message ***res)
 {
 	struct ldb_context *ldb = module->ldb;
 	struct lldb_private *lldb = module->private_data;
 	int count, msg_count;
+	char *search_base;
 	LDAPMessage *ldapres, *msg;
 
+	search_base = ldb_dn_linearize(ldb, base);
 	if (base == NULL) {
-		base = "";
+		search_base = talloc_strdup(ldb, "");
+	}
+	if (search_base == NULL) {
+		return -1;
 	}
 
 	if (expression == NULL || expression[0] == '\0') {
 		expression = "objectClass=*";
 	}
 
-	lldb->last_rc = ldap_search_s(lldb->ldap, base, (int)scope, 
+	lldb->last_rc = ldap_search_s(lldb->ldap, search_base, (int)scope, 
 				      expression, 
 				      discard_const_p(char *, attrs), 
 				      0, &ldapres);
+	talloc_free(search_base);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		return -1;
 	}
@@ -218,7 +244,7 @@ static int lldb_search(struct ldb_module *module, const char *base,
 			goto failed;
 		}
 
-		(*res)[msg_count]->dn = talloc_strdup((*res)[msg_count], dn);
+		(*res)[msg_count]->dn = ldb_dn_explode((*res)[msg_count], dn);
 		ldap_memfree(dn);
 		if (!(*res)[msg_count]->dn) {
 			goto failed;
@@ -261,7 +287,7 @@ failed:
 /*
   search for matching records using a ldb_parse_tree
 */
-static int lldb_search_bytree(struct ldb_module *module, const char *base,
+static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
 			      enum ldb_scope scope, struct ldb_parse_tree *tree,
 			      const char * const *attrs, struct ldb_message ***res)
 {
@@ -357,16 +383,26 @@ static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 	struct ldb_context *ldb = module->ldb;
 	struct lldb_private *lldb = module->private_data;
 	LDAPMod **mods;
+	char *dn;
 	int ret = 0;
 
 	/* ignore ltdb specials */
-	if (msg->dn[0] == '@') {
+	if (ldb_dn_is_special(msg->dn)) {
 		return 0;
 	}
 
 	mods = lldb_msg_to_mods(ldb, msg, 0);
+	if (mods == NULL) {
+		return -1;
+	}
 
-	lldb->last_rc = ldap_add_s(lldb->ldap, msg->dn, mods);
+	dn = ldb_dn_linearize(mods, msg->dn);
+	if (dn == NULL) {
+		talloc_free(mods);
+		return -1;
+	}
+
+	lldb->last_rc = ldap_add_s(lldb->ldap, dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ret = -1;
 	}
@@ -385,16 +421,26 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 	struct ldb_context *ldb = module->ldb;
 	struct lldb_private *lldb = module->private_data;
 	LDAPMod **mods;
+	char *dn;
 	int ret = 0;
 
 	/* ignore ltdb specials */
-	if (msg->dn[0] == '@') {
+	if (ldb_dn_is_special(msg->dn)) {
 		return 0;
 	}
 
 	mods = lldb_msg_to_mods(ldb, msg, 1);
+	if (mods == NULL) {
+		return -1;
+	}
+
+	dn = ldb_dn_linearize(mods, msg->dn);
+	if (dn == NULL) {
+		talloc_free(mods);
+		return -1;
+	}
 
-	lldb->last_rc = ldap_modify_s(lldb->ldap, msg->dn, mods);
+	lldb->last_rc = ldap_modify_s(lldb->ldap, dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ret = -1;
 	}
-- 
cgit 


From 8919d6bf9a88ce9ac43dae61989c33082c984b66 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 17 Sep 2005 19:25:50 +0000
Subject: r10299: remove the public (un)lock functions and introduce a
 transaction based private ldb API

ldb_sqlite3 is already working with this model and ldb_tdb will do
as soon as tridge finishes the tdb transaction code.

currently the transactions are always implicit and wrap any single
ldb API call except searching, the transaction functions are
currently not made public on purpose.

Simo.
(This used to be commit 1da4ac2cdcb7e54076f85242a93784260dced918)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 44 ++++++++++++++-----------------------
 1 file changed, 16 insertions(+), 28 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 2da4f1af8e..39f56dba0e 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -450,30 +450,18 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 	return ret;
 }
 
-static int lldb_lock(struct ldb_module *module, const char *lockname)
+static int lldb_start_trans(struct ldb_module *module)
 {
-	int ret = 0;
-
-	if (lockname == NULL) {
-		return -1;
-	}
+	/* TODO implement a local transaction mechanism here */
 
-	/* TODO implement a local locking mechanism here */
-
-	return ret;
+	return 0;
 }
 
-static int lldb_unlock(struct ldb_module *module, const char *lockname)
+static int lldb_end_trans(struct ldb_module *module, int status)
 {
-	int ret = 0;
-
-	if (lockname == NULL) {
-		return -1;
-	}
-
-	/* TODO implement a local unlocking mechanism here */
+	/* TODO implement a local transaction mechanism here */
 
-	return ret;
+	return status;
 }
 
 /*
@@ -487,16 +475,16 @@ static const char *lldb_errstring(struct ldb_module *module)
 
 
 static const struct ldb_module_ops lldb_ops = {
-	.name          = "ldap",
-	.search        = lldb_search,
-	.search_bytree = lldb_search_bytree,
-	.add_record    = lldb_add,
-	.modify_record = lldb_modify,
-	.delete_record = lldb_delete,
-	.rename_record = lldb_rename,
-	.named_lock    = lldb_lock,
-	.named_unlock  = lldb_unlock,
-	.errstring     = lldb_errstring
+	.name              = "ldap",
+	.search            = lldb_search,
+	.search_bytree     = lldb_search_bytree,
+	.add_record        = lldb_add,
+	.modify_record     = lldb_modify,
+	.delete_record     = lldb_delete,
+	.rename_record     = lldb_rename,
+	.start_transaction = lldb_start_trans,
+	.end_transaction   = lldb_end_trans,
+	.errstring         = lldb_errstring
 };
 
 
-- 
cgit 


From 16aff2a184f7fab64d718b356056070e305e99e9 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 18 Sep 2005 18:49:06 +0000
Subject: r10305: start implementing better error handling

changed the prioivate modules API
error string are now not spread over all
modules but are kept in  a single place.

This allows a better control of memory
and error reporting.
(This used to be commit 3fc676ac1d6f59d08bedbbd9377986154cf84ce4)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 39f56dba0e..2035913f2a 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -78,6 +78,7 @@ static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, co
 
 	lldb->last_rc = ldap_rename_s(lldb->ldap, old_dn, newrdn, parentdn, 1, NULL, NULL);
 	if (lldb->last_rc != LDAP_SUCCESS) {
+		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
@@ -107,6 +108,7 @@ static int lldb_delete(struct ldb_module *module, const struct ldb_dn *edn)
 
 	lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
 	if (lldb->last_rc != LDAP_SUCCESS) {
+		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
@@ -200,6 +202,7 @@ static int lldb_search(struct ldb_module *module, const struct ldb_dn *base,
 				      0, &ldapres);
 	talloc_free(search_base);
 	if (lldb->last_rc != LDAP_SUCCESS) {
+		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		return -1;
 	}
 
@@ -404,6 +407,7 @@ static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 
 	lldb->last_rc = ldap_add_s(lldb->ldap, dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
+		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
@@ -442,6 +446,7 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 
 	lldb->last_rc = ldap_modify_s(lldb->ldap, dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
+		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
@@ -464,16 +469,6 @@ static int lldb_end_trans(struct ldb_module *module, int status)
 	return status;
 }
 
-/*
-  return extended error information
-*/
-static const char *lldb_errstring(struct ldb_module *module)
-{
-	struct lldb_private *lldb = module->private_data;
-	return ldap_err2string(lldb->last_rc);
-}
-
-
 static const struct ldb_module_ops lldb_ops = {
 	.name              = "ldap",
 	.search            = lldb_search,
@@ -483,8 +478,7 @@ static const struct ldb_module_ops lldb_ops = {
 	.delete_record     = lldb_delete,
 	.rename_record     = lldb_rename,
 	.start_transaction = lldb_start_trans,
-	.end_transaction   = lldb_end_trans,
-	.errstring         = lldb_errstring
+	.end_transaction   = lldb_end_trans
 };
 
 
-- 
cgit 


From 63b43dd12fb579aaaccedd07aaa630cb1cd7aa88 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 24 Sep 2005 15:42:15 +0000
Subject: r10477: expose transactions outside ldb and change the API once more
 do not autostart transactions on ldb operations if a transaction is already
 in place test transactions on winsdb

all my tests passes so far
tridge please confirm this is ok for you
(This used to be commit c2bb2a36bdbe0ec7519697a9a9ba7526a0defac2)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 2035913f2a..1d1dd66e84 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -462,11 +462,18 @@ static int lldb_start_trans(struct ldb_module *module)
 	return 0;
 }
 
-static int lldb_end_trans(struct ldb_module *module, int status)
+static int lldb_end_trans(struct ldb_module *module)
 {
 	/* TODO implement a local transaction mechanism here */
 
-	return status;
+	return 0;
+}
+
+static int lldb_del_trans(struct ldb_module *module)
+{
+	/* TODO implement a local transaction mechanism here */
+
+	return 0;
 }
 
 static const struct ldb_module_ops lldb_ops = {
@@ -478,7 +485,8 @@ static const struct ldb_module_ops lldb_ops = {
 	.delete_record     = lldb_delete,
 	.rename_record     = lldb_rename,
 	.start_transaction = lldb_start_trans,
-	.end_transaction   = lldb_end_trans
+	.end_transaction   = lldb_end_trans,
+	.del_transaction   = lldb_del_trans
 };
 
 
-- 
cgit 


From 5fd031c97daaa1bf09a7ad80550753acd434075f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 Oct 2005 05:24:46 +0000
Subject: r10753: don't require every ldb module to implement both a
 search_bytree() and a search() function, instead each module now only
 implements the bytree method, and the expression based search is handled
 generically by the modules code. This makes for more consistency and less
 code duplication.

fixed the tdb backend to handle BASE searches much more
efficiently. They now always only lookup one record, regardless of the
search expression
(This used to be commit 7e44f9153c5578624e2fca04cdc0a00af0fd9eb4)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 51 ++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 29 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 1d1dd66e84..268e2b0291 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -174,15 +174,16 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 /*
   search for matching records
 */
-static int lldb_search(struct ldb_module *module, const struct ldb_dn *base,
-		       enum ldb_scope scope, const char *expression,
-		       const char * const *attrs, struct ldb_message ***res)
+static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
+			      enum ldb_scope scope, struct ldb_parse_tree *tree,
+			      const char * const *attrs, struct ldb_message ***res)
 {
 	struct ldb_context *ldb = module->ldb;
 	struct lldb_private *lldb = module->private_data;
-	int count, msg_count;
+	int count, msg_count, ldap_scope;
 	char *search_base;
 	LDAPMessage *ldapres, *msg;
+	char *expression;
 
 	search_base = ldb_dn_linearize(ldb, base);
 	if (base == NULL) {
@@ -192,11 +193,25 @@ static int lldb_search(struct ldb_module *module, const struct ldb_dn *base,
 		return -1;
 	}
 
-	if (expression == NULL || expression[0] == '\0') {
-		expression = "objectClass=*";
+	expression = ldb_filter_from_tree(search_base, tree);
+	if (expression == NULL) {
+		talloc_free(search_base);
+		return -1;
+	}
+
+	switch (scope) {
+	case LDB_SCOPE_BASE:
+		ldap_scope = LDAP_SCOPE_BASE;
+		break;
+	case LDB_SCOPE_ONELEVEL:
+		ldap_scope = LDAP_SCOPE_ONELEVEL;
+		break;
+	default:
+		ldap_scope = LDAP_SCOPE_SUBTREE;
+		break;
 	}
 
-	lldb->last_rc = ldap_search_s(lldb->ldap, search_base, (int)scope, 
+	lldb->last_rc = ldap_search_s(lldb->ldap, search_base, ldap_scope, 
 				      expression, 
 				      discard_const_p(char *, attrs), 
 				      0, &ldapres);
@@ -287,27 +302,6 @@ failed:
 }
 
 
-/*
-  search for matching records using a ldb_parse_tree
-*/
-static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
-			      enum ldb_scope scope, struct ldb_parse_tree *tree,
-			      const char * const *attrs, struct ldb_message ***res)
-{
-	struct lldb_private *lldb = module->private_data;
-	char *expression;
-	int ret;
-
-	expression = ldb_filter_from_tree(lldb, tree);
-	if (expression == NULL) {
-		return -1;
-	}
-	ret = lldb_search(module, base, scope, expression, attrs, res);
-	talloc_free(expression);
-	return ret;
-}
-
-
 /*
   convert a ldb_message structure to a list of LDAPMod structures
   ready for ldap_add() or ldap_modify()
@@ -478,7 +472,6 @@ static int lldb_del_trans(struct ldb_module *module)
 
 static const struct ldb_module_ops lldb_ops = {
 	.name              = "ldap",
-	.search            = lldb_search,
 	.search_bytree     = lldb_search_bytree,
 	.add_record        = lldb_add,
 	.modify_record     = lldb_modify,
-- 
cgit 


From 5c9590587197dcb95007fdc54318187d5716c7c6 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 8 Nov 2005 00:11:45 +0000
Subject: r11567: Ldb API change patch.

This patch changes the way lsb_search is called and the meaning of the returned integer.
The last argument of ldb_search is changed from struct ldb_message to struct ldb_result
which contains a pointer to a struct ldb_message list and a count of the number of messages.
The return is not the count of messages anymore but instead it is an ldb error value.

I tryed to keep the patch as tiny as possible bu as you can guess I had to change a good
amount of places. I also tried to double check all my changes being sure that the calling
functions would still behave as before. But this patch is big enough that I fear some bug
may have been introduced anyway even if it passes the test suite. So if you are currently
working on any file being touched please give it a deep look and blame me for any error.

Simo.
(This used to be commit 22c8c97e6fb466b41859e090e959d7f1134be780)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 85 +++++++++++++++++++++++++++----------
 1 file changed, 62 insertions(+), 23 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 268e2b0291..893ad0dd2a 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -34,6 +34,7 @@
 
 #include "includes.h"
 #include "ldb/include/ldb.h"
+#include "ldb/include/ldb_errors.h"
 #include "ldb/include/ldb_private.h"
 #include "ldb/ldb_ldap/ldb_ldap.h"
 
@@ -176,7 +177,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 */
 static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
 			      enum ldb_scope scope, struct ldb_parse_tree *tree,
-			      const char * const *attrs, struct ldb_message ***res)
+			      const char * const *attrs, struct ldb_result **res)
 {
 	struct ldb_context *ldb = module->ldb;
 	struct lldb_private *lldb = module->private_data;
@@ -211,6 +212,14 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 		break;
 	}
 
+	(*res) = talloc(lldb, struct ldb_result);
+	if (! *res) {
+		errno = ENOMEM;
+		return LDB_ERR_OTHER;
+	}
+	(*res)->count = 0;
+	(*res)->msgs = NULL;
+
 	lldb->last_rc = ldap_search_s(lldb->ldap, search_base, ldap_scope, 
 				      expression, 
 				      discard_const_p(char *, attrs), 
@@ -218,23 +227,24 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 	talloc_free(search_base);
 	if (lldb->last_rc != LDAP_SUCCESS) {
 		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
-		return -1;
+		return lldb->last_rc;
 	}
 
 	count = ldap_count_entries(lldb->ldap, ldapres);
 	if (count == -1 || count == 0) {
 		ldap_msgfree(ldapres);
-		return count;
+		return LDB_SUCCESS;
 	}
 
-	(*res) = talloc_array(lldb, struct ldb_message *, count+1);
-	if (! *res) {
+	(*res)->msgs = talloc_array(*res, struct ldb_message *, count+1);
+	if (! (*res)->msgs) {
 		ldap_msgfree(ldapres);
+		talloc_free(*res);
 		errno = ENOMEM;
-		return -1;
+		return LDB_ERR_OTHER;
 	}
 
-	(*res)[0] = NULL;
+	(*res)->msgs[0] = NULL;
 
 	msg_count = 0;
 
@@ -251,27 +261,27 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 			break;
 		}
 
-		(*res)[msg_count] = talloc(*res, struct ldb_message);
-		if (!(*res)[msg_count]) {
+		(*res)->msgs[msg_count] = talloc((*res)->msgs, struct ldb_message);
+		if (!(*res)->msgs[msg_count]) {
 			goto failed;
 		}
-		(*res)[msg_count+1] = NULL;
+		(*res)->msgs[msg_count+1] = NULL;
 
 		dn = ldap_get_dn(lldb->ldap, msg);
 		if (!dn) {
 			goto failed;
 		}
 
-		(*res)[msg_count]->dn = ldb_dn_explode((*res)[msg_count], dn);
+		(*res)->msgs[msg_count]->dn = ldb_dn_explode((*res)->msgs[msg_count], dn);
 		ldap_memfree(dn);
-		if (!(*res)[msg_count]->dn) {
+		if (!(*res)->msgs[msg_count]->dn) {
 			goto failed;
 		}
 
 
-		(*res)[msg_count]->num_elements = 0;
-		(*res)[msg_count]->elements = NULL;
-		(*res)[msg_count]->private_data = NULL;
+		(*res)->msgs[msg_count]->num_elements = 0;
+		(*res)->msgs[msg_count]->elements = NULL;
+		(*res)->msgs[msg_count]->private_data = NULL;
 
 		/* loop over all attributes */
 		for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
@@ -281,7 +291,7 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 			bval = ldap_get_values_len(lldb->ldap, msg, attr);
 
 			if (bval) {
-				lldb_add_msg_attr(ldb, (*res)[msg_count], attr, bval);
+				lldb_add_msg_attr(ldb, (*res)->msgs[msg_count], attr, bval);
 				ldap_value_free_len(bval);
 			}					  
 			
@@ -294,11 +304,12 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 
 	ldap_msgfree(ldapres);
 
-	return msg_count;
+	(*res)->count = msg_count;
+	return LDB_SUCCESS;
 
 failed:
 	if (*res) talloc_free(*res);
-	return -1;
+	return LDB_ERR_OTHER;
 }
 
 
@@ -470,13 +481,41 @@ static int lldb_del_trans(struct ldb_module *module)
 	return 0;
 }
 
+static int lldb_request(struct ldb_module *module, struct ldb_request *req)
+{
+	switch (req->operation) {
+
+	case LDB_REQ_SEARCH:
+		return lldb_search_bytree(module,
+					  req->op.search.base,
+					  req->op.search.scope, 
+					  req->op.search.tree, 
+					  req->op.search.attrs, 
+					  req->op.search.res);
+
+	case LDB_REQ_ADD:
+		return lldb_add(module, req->op.add.message);
+
+	case LDB_REQ_MODIFY:
+		return lldb_modify(module, req->op.mod.message);
+
+	case LDB_REQ_DELETE:
+		return lldb_delete(module, req->op.del.dn);
+
+	case LDB_REQ_RENAME:
+		return lldb_rename(module,
+					req->op.rename.olddn,
+					req->op.rename.newdn);
+
+	default:
+		return -1;
+
+	}
+}
+
 static const struct ldb_module_ops lldb_ops = {
 	.name              = "ldap",
-	.search_bytree     = lldb_search_bytree,
-	.add_record        = lldb_add,
-	.modify_record     = lldb_modify,
-	.delete_record     = lldb_delete,
-	.rename_record     = lldb_rename,
+	.request           = lldb_request,
 	.start_transaction = lldb_start_trans,
 	.end_transaction   = lldb_end_trans,
 	.del_transaction   = lldb_del_trans
-- 
cgit 


From c908d0b2aa111659e57a73efb8c33c413965c846 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 6 Jan 2006 04:01:23 +0000
Subject: r12733: Merge ldap/ldb controls into main tree There's still lot of
 work to do but the patch is stable enough to be pushed into the main samba4
 tree.

Simo.
(This used to be commit 77125feaff252cab44d26593093a9c211c846ce8)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 893ad0dd2a..8207b5f592 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -219,6 +219,7 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 	}
 	(*res)->count = 0;
 	(*res)->msgs = NULL;
+	(*res)->controls = NULL;
 
 	lldb->last_rc = ldap_search_s(lldb->ldap, search_base, ldap_scope, 
 				      expression, 
@@ -272,7 +273,7 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 			goto failed;
 		}
 
-		(*res)->msgs[msg_count]->dn = ldb_dn_explode((*res)->msgs[msg_count], dn);
+		(*res)->msgs[msg_count]->dn = ldb_dn_explode_or_special((*res)->msgs[msg_count], dn);
 		ldap_memfree(dn);
 		if (!(*res)->msgs[msg_count]->dn) {
 			goto failed;
-- 
cgit 


From dbef4d76de92c3388f4e1819a76d6febf90be290 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 6 Jan 2006 16:12:45 +0000
Subject: r12743: Remove the ugly way we had to make a second stage init and
 introduce a second_stage_init private function for modules that need a second
 stage init.

Simo.
(This used to be commit 5e8b365fa2d93801a5de1d9ea76ce9d5546bd248)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 8207b5f592..dffd0e969c 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -514,12 +514,18 @@ static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 	}
 }
 
+static int lldb_init_2(struct ldb_module *module)
+{
+	return LDB_SUCCESS;
+}
+
 static const struct ldb_module_ops lldb_ops = {
 	.name              = "ldap",
 	.request           = lldb_request,
 	.start_transaction = lldb_start_trans,
 	.end_transaction   = lldb_end_trans,
-	.del_transaction   = lldb_del_trans
+	.del_transaction   = lldb_del_trans,
+	.second_stage_init = lldb_init_2
 };
 
 
-- 
cgit 


From 4d1c5a023cf6680474bd8d8be73f576d155cfe81 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 10 Jan 2006 16:48:32 +0000
Subject: r12829: fix ldb headers, to not include '<...>' files in .c files

this helps in getting symbol -fvisibility=hidden (GCC 4 feature) working later.

metze
(This used to be commit 380938e97f31c7860aed1e73cc0110c6e17b472e)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index dffd0e969c..7233498eb3 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -33,9 +33,8 @@
  */
 
 #include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
+#include "ldb/include/includes.h"
+
 #include "ldb/ldb_ldap/ldb_ldap.h"
 
 /*
@@ -492,7 +491,7 @@ static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 					  req->op.search.scope, 
 					  req->op.search.tree, 
 					  req->op.search.attrs, 
-					  req->op.search.res);
+					  &req->op.search.res);
 
 	case LDB_REQ_ADD:
 		return lldb_add(module, req->op.add.message);
-- 
cgit 


From d590dea10b3abf93fcc8138189291e8b66bae7d7 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 22 Feb 2006 05:21:43 +0000
Subject: r13615: Make ldb_set_errstring get ldb instead of module as
 parameter. The module was just used to get to the ldb so it was meningless.

Also add LDB_WAIT_ONCE e relative code in ldb_ildap.c
(This used to be commit d5b467b7c132b0bd4d23918ba7bf3370b1afcce8)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 7233498eb3..c27ded7767 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -78,7 +78,7 @@ static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, co
 
 	lldb->last_rc = ldap_rename_s(lldb->ldap, old_dn, newrdn, parentdn, 1, NULL, NULL);
 	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
@@ -108,7 +108,7 @@ static int lldb_delete(struct ldb_module *module, const struct ldb_dn *edn)
 
 	lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
 	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
@@ -226,7 +226,7 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 				      0, &ldapres);
 	talloc_free(search_base);
 	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		return lldb->last_rc;
 	}
 
@@ -412,7 +412,7 @@ static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 
 	lldb->last_rc = ldap_add_s(lldb->ldap, dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
@@ -451,7 +451,7 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 
 	lldb->last_rc = ldap_modify_s(lldb->ldap, dn, mods);
 	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
 		ret = -1;
 	}
 
-- 
cgit 


From e1380d63a0d85120ebf25d228b1bf6f8c6604d99 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 28 Feb 2006 04:38:53 +0000
Subject: r13744: Make ldb_ldap async (This used to be commit
 ec833b409c1fff4ab908fe194579e701d2e950b0)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 995 +++++++++++++++++++++++++++---------
 1 file changed, 746 insertions(+), 249 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index c27ded7767..167bbfbd63 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -2,6 +2,7 @@
    ldb database library
 
    Copyright (C) Andrew Tridgell  2004
+   Copyright (C) Simo Sorce       2006
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -23,97 +24,141 @@
 */
 
 /*
- *  Name: ldb
+ *  Name: ldb_ldap
  *
  *  Component: ldb ldap backend
  *
  *  Description: core files for LDAP backend
  *
  *  Author: Andrew Tridgell
+ *
+ *  Modifications:
+ *
+ *  - description: make the module use asyncronous calls
+ *    date: Feb 2006
+ *    author: Simo Sorce
  */
 
 #include "includes.h"
 #include "ldb/include/includes.h"
 
-#include "ldb/ldb_ldap/ldb_ldap.h"
+#include <ldap.h>
 
-/*
-  rename a record
-*/
-static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
-{
-	TALLOC_CTX *local_ctx;
-	struct lldb_private *lldb = module->private_data;
-	int ret = 0;
-	char *old_dn;
-	char *newrdn;
-	const char *parentdn = "";
+struct lldb_private {
+	LDAP *ldap;
+	int timeout;
+};
 
-	/* ignore ltdb specials */
-	if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
-		return 0;
-	}
+struct lldb_async_context {
+	struct ldb_module *module;
+	int msgid;
+	uint32_t timeout;
+	void *context;
+	int (*callback)(struct ldb_context *, void *, struct ldb_async_result *);
+};
 
-	local_ctx = talloc_named(lldb, 0, "lldb_rename local context");
-	if (local_ctx == NULL) {
-		return -1;
-	}
+static int lldb_ldap_to_ldb(int err) {
+	/* Ldap errors and ldb errors are defined to the same values */
+	return err;
+}
 
-	old_dn = ldb_dn_linearize(local_ctx, olddn);
-	if (old_dn == NULL) {
-		goto failed;
-	}
+static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ldb_module *module,
+					    void *context,
+					    int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+					    int timeout)
+{
+	struct lldb_async_context *ac;
+	struct ldb_async_handle *h;
 
-	newrdn = talloc_asprintf(lldb, "%s=%s",
-				      newdn->components[0].name,
-				      ldb_dn_escape_value(lldb, newdn->components[0].value));
-	if (!newrdn) {
-		goto failed;
+	h = talloc_zero(lldb, struct ldb_async_handle);
+	if (h == NULL) {
+		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+		return NULL;
 	}
 
-	parentdn = ldb_dn_linearize(lldb, ldb_dn_get_parent(lldb, newdn));
-	if (!parentdn) {
-		goto failed;
+	ac = talloc(h, struct lldb_async_context);
+	if (ac == NULL) {
+		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+		talloc_free(h);
+		return NULL;
 	}
 
-	lldb->last_rc = ldap_rename_s(lldb->ldap, old_dn, newrdn, parentdn, 1, NULL, NULL);
-	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
-		ret = -1;
-	}
+	h->private_data = (void *)ac;
 
-	talloc_free(local_ctx);
-	return ret;
+	ac->module = module;
+	ac->context = context;
+	ac->callback = callback;
+	ac->timeout = timeout;
+	ac->msgid = 0;
 
-failed:
-	talloc_free(local_ctx);
-	return -1;
+	return h;
 }
-
 /*
-  delete a record
+  convert a ldb_message structure to a list of LDAPMod structures
+  ready for ldap_add() or ldap_modify()
 */
-static int lldb_delete(struct ldb_module *module, const struct ldb_dn *edn)
+static LDAPMod **lldb_msg_to_mods(void *mem_ctx, const struct ldb_message *msg, int use_flags)
 {
-	struct lldb_private *lldb = module->private_data;
-	char *dn;
-	int ret = 0;
+	LDAPMod **mods;
+	unsigned int i, j;
+	int num_mods = 0;
 
-	/* ignore ltdb specials */
-	if (ldb_dn_is_special(edn)) {
-		return 0;
+	/* allocate maximum number of elements needed */
+	mods = talloc_array(mem_ctx, LDAPMod *, msg->num_elements+1);
+	if (!mods) {
+		errno = ENOMEM;
+		return NULL;
 	}
+	mods[0] = NULL;
 
-	dn = ldb_dn_linearize(lldb, edn);
+	for (i=0;i<msg->num_elements;i++) {
+		const struct ldb_message_element *el = &msg->elements[i];
 
-	lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
-	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
-		ret = -1;
+		mods[num_mods] = talloc(mods, LDAPMod);
+		if (!mods[num_mods]) {
+			goto failed;
+		}
+		mods[num_mods+1] = NULL;
+		mods[num_mods]->mod_op = LDAP_MOD_BVALUES;
+		if (use_flags) {
+			switch (el->flags & LDB_FLAG_MOD_MASK) {
+			case LDB_FLAG_MOD_ADD:
+				mods[num_mods]->mod_op |= LDAP_MOD_ADD;
+				break;
+			case LDB_FLAG_MOD_DELETE:
+				mods[num_mods]->mod_op |= LDAP_MOD_DELETE;
+				break;
+			case LDB_FLAG_MOD_REPLACE:
+				mods[num_mods]->mod_op |= LDAP_MOD_REPLACE;
+				break;
+			}
+		}
+		mods[num_mods]->mod_type = discard_const_p(char, el->name);
+		mods[num_mods]->mod_vals.modv_bvals = talloc_array(mods[num_mods], 
+								   struct berval *,
+								   1+el->num_values);
+		if (!mods[num_mods]->mod_vals.modv_bvals) {
+			goto failed;
+		}
+
+		for (j=0;j<el->num_values;j++) {
+			mods[num_mods]->mod_vals.modv_bvals[j] = talloc(mods[num_mods]->mod_vals.modv_bvals,
+									struct berval);
+			if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
+				goto failed;
+			}
+			mods[num_mods]->mod_vals.modv_bvals[j]->bv_val = el->values[j].data;
+			mods[num_mods]->mod_vals.modv_bvals[j]->bv_len = el->values[j].length;
+		}
+		mods[num_mods]->mod_vals.modv_bvals[j] = NULL;
+		num_mods++;
 	}
 
-	talloc_free(dn);
-	return ret;
+	return mods;
+
+failed:
+	talloc_free(mods);
+	return NULL;
 }
 
 /*
@@ -174,29 +219,58 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 /*
   search for matching records
 */
-static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
+static int lldb_search_async(struct ldb_module *module, const struct ldb_dn *base,
 			      enum ldb_scope scope, struct ldb_parse_tree *tree,
-			      const char * const *attrs, struct ldb_result **res)
+			      const char * const *attrs,
+			      struct ldb_control **control_req,
+			      void *context,
+			      int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+			      int timeout,
+			      struct ldb_async_handle **handle)
 {
-	struct ldb_context *ldb = module->ldb;
-	struct lldb_private *lldb = module->private_data;
-	int count, msg_count, ldap_scope;
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct lldb_async_context *lldb_ac;
+	struct timeval tv;
+	int ldap_scope;
 	char *search_base;
-	LDAPMessage *ldapres, *msg;
 	char *expression;
+	int ret;
+
+	if (!callback || !context) {
+		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Async interface called with NULL callback function or NULL context"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	if (tree == NULL) {
+		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Invalid expression parse tree"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	if (control_req != NULL) {
+		ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
+	}
+
+	*handle = init_handle(lldb, module, context, callback, timeout);
+	if (*handle == NULL) {
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	search_base = ldb_dn_linearize(ldb, base);
+	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+
+	search_base = ldb_dn_linearize(lldb_ac, base);
 	if (base == NULL) {
-		search_base = talloc_strdup(ldb, "");
+		search_base = talloc_strdup(lldb_ac, "");
 	}
 	if (search_base == NULL) {
-		return -1;
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	expression = ldb_filter_from_tree(search_base, tree);
+	expression = ldb_filter_from_tree(lldb_ac, tree);
 	if (expression == NULL) {
-		talloc_free(search_base);
-		return -1;
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	switch (scope) {
@@ -211,251 +285,624 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 		break;
 	}
 
-	(*res) = talloc(lldb, struct ldb_result);
-	if (! *res) {
-		errno = ENOMEM;
-		return LDB_ERR_OTHER;
+	tv.tv_sec = timeout;
+	tv.tv_usec = 0;
+
+	ret = ldap_search_ext(lldb->ldap, search_base, ldap_scope, 
+			    expression, 
+			    discard_const_p(char *, attrs), 
+			    0,
+			    NULL,
+			    NULL,
+			    &tv,
+			    LDAP_NO_LIMIT,
+			    &lldb_ac->msgid);
+
+	if (ret != LDAP_SUCCESS) {
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		talloc_free(*handle);
+		*handle = NULL;
 	}
-	(*res)->count = 0;
-	(*res)->msgs = NULL;
-	(*res)->controls = NULL;
 
-	lldb->last_rc = ldap_search_s(lldb->ldap, search_base, ldap_scope, 
-				      expression, 
-				      discard_const_p(char *, attrs), 
-				      0, &ldapres);
-	talloc_free(search_base);
-	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
-		return lldb->last_rc;
-	}
+	return lldb_ldap_to_ldb(ret);
+}
 
-	count = ldap_count_entries(lldb->ldap, ldapres);
-	if (count == -1 || count == 0) {
-		ldap_msgfree(ldapres);
-		return LDB_SUCCESS;
+static int lldb_search_sync_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
+{
+	struct ldb_result *res;
+	int n;
+	
+ 	if (!context) {
+		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context in callback"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}	
+
+	res = *((struct ldb_result **)context);
+
+	if (!res || !ares) {
+		goto error;
 	}
 
-	(*res)->msgs = talloc_array(*res, struct ldb_message *, count+1);
-	if (! (*res)->msgs) {
-		ldap_msgfree(ldapres);
-		talloc_free(*res);
-		errno = ENOMEM;
-		return LDB_ERR_OTHER;
-	}
+	if (ares->type == LDB_REPLY_ENTRY) {
+		res->msgs = talloc_realloc(res, res->msgs, struct ldb_message *, res->count + 2);
+		if (! res->msgs) {
+			goto error;
+		}
 
-	(*res)->msgs[0] = NULL;
+		res->msgs[res->count + 1] = NULL;
 
-	msg_count = 0;
+		res->msgs[res->count] = talloc_steal(res->msgs, ares->message);
+		if (! res->msgs[res->count]) {
+			goto error;
+		}
 
-	/* loop over all messages */
-	for (msg=ldap_first_entry(lldb->ldap, ldapres); 
-	     msg; 
-	     msg=ldap_next_entry(lldb->ldap, msg)) {
-		BerElement *berptr = NULL;
-		char *attr, *dn;
+		res->count++;
+	}
 
-		if (msg_count == count) {
-			/* hmm, got too many? */
-			ldb_debug(ldb, LDB_DEBUG_FATAL, "Fatal: ldap message count inconsistent\n");
-			break;
+	if (ares->type == LDB_REPLY_REFERRAL) {
+		if (res->refs) {
+			for (n = 0; res->refs[n]; n++) /*noop*/ ;
+		} else {
+			n = 0;
 		}
 
-		(*res)->msgs[msg_count] = talloc((*res)->msgs, struct ldb_message);
-		if (!(*res)->msgs[msg_count]) {
-			goto failed;
+		res->refs = talloc_realloc(res, res->refs, char *, n + 2);
+		if (! res->refs) {
+			goto error;
 		}
-		(*res)->msgs[msg_count+1] = NULL;
 
-		dn = ldap_get_dn(lldb->ldap, msg);
-		if (!dn) {
-			goto failed;
-		}
+		res->refs[n] = talloc_steal(res->refs, ares->referral);
+		res->refs[n + 1] = NULL;
+	}
 
-		(*res)->msgs[msg_count]->dn = ldb_dn_explode_or_special((*res)->msgs[msg_count], dn);
-		ldap_memfree(dn);
-		if (!(*res)->msgs[msg_count]->dn) {
-			goto failed;
+	if (ares->type == LDB_REPLY_DONE) {
+		if (ares->controls) {
+			res->controls = talloc_steal(res, ares->controls);
+			if (! res->controls) {
+				goto error;
+			}
 		}
+	}
 
+	talloc_free(ares);
+	return LDB_SUCCESS;
 
-		(*res)->msgs[msg_count]->num_elements = 0;
-		(*res)->msgs[msg_count]->elements = NULL;
-		(*res)->msgs[msg_count]->private_data = NULL;
-
-		/* loop over all attributes */
-		for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
-		     attr;
-		     attr=ldap_next_attribute(lldb->ldap, msg, berptr)) {
-			struct berval **bval;
-			bval = ldap_get_values_len(lldb->ldap, msg, attr);
+error:
+	talloc_free(ares);
+	talloc_free(res);
+	*((struct ldb_result **)context) = NULL;
+	return LDB_ERR_OPERATIONS_ERROR;
+}
 
-			if (bval) {
-				lldb_add_msg_attr(ldb, (*res)->msgs[msg_count], attr, bval);
-				ldap_value_free_len(bval);
-			}					  
-			
-			ldap_memfree(attr);
-		}
-		if (berptr) ber_free(berptr, 0);
+/*
+  search for matching records using a synchronous function
+ */
+static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
+			      enum ldb_scope scope, struct ldb_parse_tree *tree,
+			      const char * const *attrs,
+			      struct ldb_control **control_req,
+			      struct ldb_result **res)
+{
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct ldb_async_handle *handle;
+	int ret;
 
-		msg_count++;
+	*res = talloc_zero(lldb, struct ldb_result);
+	if (! *res) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ldap_msgfree(ldapres);
+	ret = lldb_search_async(module, base, scope, tree, attrs, control_req,
+				res, &lldb_search_sync_callback, lldb->timeout, &handle);
 
-	(*res)->count = msg_count;
-	return LDB_SUCCESS;
+	if (ret != LDB_SUCCESS)
+		return ret;
 
-failed:
-	if (*res) talloc_free(*res);
-	return LDB_ERR_OTHER;
+	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
 }
 
-
 /*
-  convert a ldb_message structure to a list of LDAPMod structures
-  ready for ldap_add() or ldap_modify()
+  add a record
 */
-static LDAPMod **lldb_msg_to_mods(struct ldb_context *ldb,
-				  const struct ldb_message *msg, int use_flags)
+static int lldb_add_async(struct ldb_module *module, const struct ldb_message *msg,
+			  void *context,
+			  int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+			  int timeout,
+			  struct ldb_async_handle **handle)
 {
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct lldb_async_context *lldb_ac;
 	LDAPMod **mods;
-	unsigned int i, j;
-	int num_mods = 0;
+	char *dn;
+	int ret;
 
-	/* allocate maximum number of elements needed */
-	mods = talloc_array(ldb, LDAPMod *, msg->num_elements+1);
-	if (!mods) {
-		errno = ENOMEM;
-		return NULL;
+	/* ltdb specials should not reach this point */
+	if (ldb_dn_is_special(msg->dn)) {
+		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
-	mods[0] = NULL;
 
-	for (i=0;i<msg->num_elements;i++) {
-		const struct ldb_message_element *el = &msg->elements[i];
+	*handle = init_handle(lldb, module, context, callback, timeout);
+	if (*handle == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-		mods[num_mods] = talloc(ldb, LDAPMod);
-		if (!mods[num_mods]) {
-			goto failed;
-		}
-		mods[num_mods+1] = NULL;
-		mods[num_mods]->mod_op = LDAP_MOD_BVALUES;
-		if (use_flags) {
-			switch (el->flags & LDB_FLAG_MOD_MASK) {
-			case LDB_FLAG_MOD_ADD:
-				mods[num_mods]->mod_op |= LDAP_MOD_ADD;
-				break;
-			case LDB_FLAG_MOD_DELETE:
-				mods[num_mods]->mod_op |= LDAP_MOD_DELETE;
-				break;
-			case LDB_FLAG_MOD_REPLACE:
-				mods[num_mods]->mod_op |= LDAP_MOD_REPLACE;
-				break;
-			}
-		}
-		mods[num_mods]->mod_type = discard_const_p(char, el->name);
-		mods[num_mods]->mod_vals.modv_bvals = talloc_array(mods[num_mods], 
-								     struct berval *,
-								     1+el->num_values);
-		if (!mods[num_mods]->mod_vals.modv_bvals) {
-			goto failed;
-		}
+	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
 
-		for (j=0;j<el->num_values;j++) {
-			mods[num_mods]->mod_vals.modv_bvals[j] = talloc(mods[num_mods]->mod_vals.modv_bvals,
-									  struct berval);
-			if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
-				goto failed;
-			}
-			mods[num_mods]->mod_vals.modv_bvals[j]->bv_val = el->values[j].data;
-			mods[num_mods]->mod_vals.modv_bvals[j]->bv_len = el->values[j].length;
-		}
-		mods[num_mods]->mod_vals.modv_bvals[j] = NULL;
-		num_mods++;
+	mods = lldb_msg_to_mods(lldb_ac, msg, 0);
+	if (mods == NULL) {
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	return mods;
+	dn = ldb_dn_linearize(lldb_ac, msg->dn);
+	if (dn == NULL) {
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-failed:
-	talloc_free(mods);
-	return NULL;
+	ret = ldap_add_ext(lldb->ldap, dn, mods,
+			   NULL,
+			   NULL,
+			   &lldb_ac->msgid);
+
+	if (ret != LDAP_SUCCESS) {
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		talloc_free(*handle);
+	}
+
+	return lldb_ldap_to_ldb(ret);
+}
+
+static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
+{
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct ldb_async_handle *handle;
+	int ret;
+
+	/* ldap does not understand ltdb specials */
+	if (ldb_dn_is_special(msg->dn)) {
+		return LDB_SUCCESS;
+	}
+
+	ret = lldb_add_async(module, msg, NULL, NULL, lldb->timeout, &handle);
+
+	if (ret != LDB_SUCCESS)
+		return ret;
+
+	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
 }
 
 
 /*
-  add a record
+  modify a record
 */
-static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
+static int lldb_modify_async(struct ldb_module *module, const struct ldb_message *msg,
+			     void *context,
+			     int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+			     int timeout,
+			     struct ldb_async_handle **handle)
 {
-	struct ldb_context *ldb = module->ldb;
-	struct lldb_private *lldb = module->private_data;
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct lldb_async_context *lldb_ac;
 	LDAPMod **mods;
 	char *dn;
-	int ret = 0;
+	int ret;
 
-	/* ignore ltdb specials */
+	/* ltdb specials should not reach this point */
 	if (ldb_dn_is_special(msg->dn)) {
-		return 0;
+		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	mods = lldb_msg_to_mods(ldb, msg, 0);
+	*handle = init_handle(lldb, module, context, callback, timeout);
+	if (*handle == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+
+	mods = lldb_msg_to_mods(lldb_ac, msg, 1);
 	if (mods == NULL) {
-		return -1;
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	dn = ldb_dn_linearize(mods, msg->dn);
+	dn = ldb_dn_linearize(lldb_ac, msg->dn);
 	if (dn == NULL) {
-		talloc_free(mods);
-		return -1;
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb->last_rc = ldap_add_s(lldb->ldap, dn, mods);
-	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
-		ret = -1;
+	ret = ldap_modify_ext(lldb->ldap, dn, mods,
+			      NULL,
+			      NULL,
+			      &lldb_ac->msgid);
+
+	if (ret != LDAP_SUCCESS) {
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		talloc_free(*handle);
 	}
 
-	talloc_free(mods);
+	return lldb_ldap_to_ldb(ret);
+}
 
-	return ret;
+static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
+{
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct ldb_async_handle *handle;
+	int ret;
+
+	/* ldap does not understand ltdb specials */
+	if (ldb_dn_is_special(msg->dn)) {
+		return LDB_SUCCESS;
+	}
+
+	ret = lldb_modify_async(module, msg, NULL, NULL, lldb->timeout, &handle);
+
+	if (ret != LDB_SUCCESS)
+		return ret;
+
+	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
 }
 
+/*
+  delete a record
+*/
+static int lldb_delete_async(struct ldb_module *module, const struct ldb_dn *dn,
+			     void *context,
+			     int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+			     int timeout,
+			     struct ldb_async_handle **handle)
+{
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct lldb_async_context *lldb_ac;
+	char *dnstr;
+	int ret;
+	
+	/* ltdb specials should not reach this point */
+	if (ldb_dn_is_special(dn)) {
+		return LDB_ERR_INVALID_DN_SYNTAX;
+	}
+
+	*handle = init_handle(lldb, module, context, callback, timeout);
+	if (*handle == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+
+	dnstr = ldb_dn_linearize(lldb_ac, dn);
+
+	ret = ldap_delete_ext(lldb->ldap, dnstr,
+			      NULL,
+			      NULL,
+			      &lldb_ac->msgid);
+
+	if (ret != LDAP_SUCCESS) {
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		talloc_free(*handle);
+	}
+
+	return lldb_ldap_to_ldb(ret);
+}
+
+static int lldb_delete(struct ldb_module *module, const struct ldb_dn *dn)
+{
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct ldb_async_handle *handle;
+	int ret;
+
+	/* ignore ltdb specials */
+	if (ldb_dn_is_special(dn)) {
+		return LDB_SUCCESS;
+	}
+
+	ret = lldb_delete_async(module, dn, NULL, NULL, lldb->timeout, &handle);
+
+	if (ret != LDB_SUCCESS)
+		return ret;
+
+	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+}
 
 /*
-  modify a record
+  rename a record
 */
-static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
+static int lldb_rename_async(struct ldb_module *module,
+			     const struct ldb_dn *olddn, const struct ldb_dn *newdn,
+			     void *context,
+			     int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+			     int timeout,
+			     struct ldb_async_handle **handle)
 {
-	struct ldb_context *ldb = module->ldb;
-	struct lldb_private *lldb = module->private_data;
-	LDAPMod **mods;
-	char *dn;
-	int ret = 0;
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct lldb_async_context *lldb_ac;
+	char *old_dn;
+       	char *newrdn;
+	char *parentdn;
+	int ret;
+	
+	/* ltdb specials should not reach this point */
+	if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
+		return LDB_ERR_INVALID_DN_SYNTAX;
+	}
+
+	*handle = init_handle(lldb, module, context, callback, timeout);
+	if (*handle == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+
+	old_dn = ldb_dn_linearize(lldb_ac, olddn);
+	if (old_dn == NULL) {
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	newrdn = talloc_asprintf(lldb_ac, "%s=%s",
+				      newdn->components[0].name,
+				      ldb_dn_escape_value(lldb, newdn->components[0].value));
+	if (!newrdn) {
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	parentdn = ldb_dn_linearize(lldb_ac, ldb_dn_get_parent(lldb_ac, newdn));
+	if (!parentdn) {
+		talloc_free(*handle);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ret = ldap_rename(lldb->ldap, old_dn, newrdn, parentdn,
+			  1, NULL, NULL,
+			  &lldb_ac->msgid);
+
+	if (ret != LDAP_SUCCESS) {
+		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		talloc_free(*handle);
+	}
+
+	return lldb_ldap_to_ldb(ret);
+}
+
+static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
+{
+	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
+	struct ldb_async_handle *handle;
+	int ret;
 
 	/* ignore ltdb specials */
-	if (ldb_dn_is_special(msg->dn)) {
-		return 0;
+	if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
+		return LDB_SUCCESS;
 	}
 
-	mods = lldb_msg_to_mods(ldb, msg, 1);
-	if (mods == NULL) {
-		return -1;
+	ret = lldb_rename_async(module, olddn, newdn, NULL, NULL, lldb->timeout, &handle);
+
+	if (ret != LDB_SUCCESS)
+		return ret;
+
+	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+}
+
+static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *result)
+{
+	struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
+	struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
+	struct ldb_async_result *ares = NULL;
+	LDAPMessage *msg;
+	int type;
+	char *matcheddnp = NULL;
+	char *errmsgp = NULL;
+	char **referralsp = NULL;
+	LDAPControl **serverctrlsp = NULL;
+
+	type = ldap_msgtype(result);
+
+	switch (type) {
+
+	case LDAP_RES_SEARCH_ENTRY:
+		msg = ldap_first_entry(lldb->ldap, result);
+	       	if (msg != NULL) {
+			BerElement *berptr = NULL;
+			char *attr, *dn;
+
+			ares = talloc_zero(ac, struct ldb_async_result);
+			if (!ares) {
+				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				goto error;
+			}
+
+			ares->message = ldb_msg_new(ares);
+			if (!ares->message) {
+				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				goto error;
+			}
+
+			dn = ldap_get_dn(lldb->ldap, msg);
+			if (!dn) {
+				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				goto error;
+			}
+			ares->message->dn = ldb_dn_explode_or_special(ares->message, dn);
+			if (ares->message->dn == NULL) {
+				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				goto error;
+			}
+			ldap_memfree(dn);
+
+			ares->message->num_elements = 0;
+			ares->message->elements = NULL;
+			ares->message->private_data = NULL;
+
+			/* loop over all attributes */
+			for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
+			     attr;
+			     attr=ldap_next_attribute(lldb->ldap, msg, berptr)) {
+				struct berval **bval;
+				bval = ldap_get_values_len(lldb->ldap, msg, attr);
+
+				if (bval) {
+					lldb_add_msg_attr(ac->module->ldb, ares->message, attr, bval);
+					ldap_value_free_len(bval);
+				}					  
+				
+				ldap_memfree(attr);
+			}
+			if (berptr) ber_free(berptr, 0);
+
+
+			ares->type = LDB_REPLY_ENTRY;
+			handle->state = LDB_ASYNC_PENDING;
+			handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+
+			ldap_msgfree(result);
+		}
+		break;
+
+	case LDAP_RES_SEARCH_REFERENCE:
+		if (ldap_parse_result(lldb->ldap, result, &handle->status,
+					&matcheddnp, &errmsgp,
+					&referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			goto error;
+		}
+		if (referralsp == NULL) {
+			handle->status = LDB_ERR_PROTOCOL_ERROR;
+			goto error;
+		}
+
+		ares = talloc_zero(ac, struct ldb_async_result);
+		if (!ares) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			goto error;
+		}
+
+		ares->referral = talloc_strdup(ares, *referralsp);
+		ares->type = LDB_REPLY_REFERRAL;
+		handle->state = LDB_ASYNC_PENDING;
+		handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+
+		break;
+
+	case LDAP_RES_SEARCH_RESULT:
+		if (ldap_parse_result(lldb->ldap, result, &handle->status,
+					&matcheddnp, &errmsgp,
+					&referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			goto error;
+		}
+
+		ares = talloc_zero(ac, struct ldb_async_result);
+		if (!ares) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			goto error;
+		}
+
+		if (serverctrlsp != NULL) {
+			/* FIXME: transform the LDAPControl list into an ldb_control one */
+			ares->controls = NULL;
+		}
+		
+		ares->type = LDB_REPLY_DONE;
+		handle->state = LDB_ASYNC_DONE;
+		handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+
+		break;
+
+	case LDAP_RES_MODIFY:
+	case LDAP_RES_ADD:
+	case LDAP_RES_DELETE:
+	case LDAP_RES_MODDN:
+		if (ldap_parse_result(lldb->ldap, result, &handle->status,
+					&matcheddnp, &errmsgp,
+					&referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			goto error;
+		}
+		if (ac->callback && handle->status == LDB_SUCCESS) {
+			ares = NULL; /* FIXME: build a corresponding ares to pass on */
+			handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+		}
+		handle->state = LDB_ASYNC_DONE;
+		break;
+
+	default:
+		handle->state = LDB_ERR_PROTOCOL_ERROR;
 	}
 
-	dn = ldb_dn_linearize(mods, msg->dn);
-	if (dn == NULL) {
-		talloc_free(mods);
-		return -1;
+	if (matcheddnp) ldap_memfree(matcheddnp);
+	if (errmsgp) {
+		ldb_set_errstring(ac->module->ldb, talloc_strdup(ac->module, errmsgp));
+		ldap_memfree(errmsgp);
 	}
+	if (referralsp) ldap_value_free(referralsp);
+	if (serverctrlsp) ldap_controls_free(serverctrlsp);
+
+	return handle->status;
+
+error:
+	handle->state = LDB_ASYNC_DONE;
+	return handle->status;
+}
 
-	lldb->last_rc = ldap_modify_s(lldb->ldap, dn, mods);
-	if (lldb->last_rc != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(lldb->last_rc)));
-		ret = -1;
+static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+{
+	struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
+	struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
+	struct timeval timeout;
+	LDAPMessage *result;
+	int ret;
+
+	if (!ac->msgid) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	talloc_free(mods);
+	handle->status = LDB_SUCCESS;
+	handle->state = LDB_ASYNC_INIT;
+
+	switch(type) {
+	case LDB_WAIT_NONE:
+		timeout.tv_sec = 0;
+		timeout.tv_usec = 0;
+		ret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
+		if (ret == -1) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			return handle->status;
+		}
+		if (ret == 0) {
+			handle->status = LDB_SUCCESS;
+			return handle->status;
+		}
+		ret = lldb_parse_result(handle, result);
+		break;
+	case LDB_WAIT_ONCE:
+		timeout.tv_sec = ac->timeout;
+		timeout.tv_usec = 0;
+		ret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
+		if (ret == -1 || ret == 0) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			return handle->status;
+		}
+		ret = lldb_parse_result(handle, result);
+		break;
+	case LDB_WAIT_ALL:
+		timeout.tv_sec = ac->timeout;
+		timeout.tv_usec = 0;
+		while (handle->status == LDB_SUCCESS && handle->state != LDB_ASYNC_DONE) {
+			ret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
+			if (ret == -1 || ret == 0) {
+				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				return handle->status;
+			}
+			ret = lldb_parse_result(handle, result);
+			if (ret != LDB_SUCCESS) {
+				return ret;
+			}
+		}
+		break;
+	default:
+		ret = LDB_ERR_OPERATIONS_ERROR;
+	}
 
 	return ret;
 }
@@ -491,6 +938,7 @@ static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 					  req->op.search.scope, 
 					  req->op.search.tree, 
 					  req->op.search.attrs, 
+					  req->controls,
 					  &req->op.search.res);
 
 	case LDB_REQ_ADD:
@@ -507,6 +955,51 @@ static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 					req->op.rename.olddn,
 					req->op.rename.newdn);
 
+	case LDB_ASYNC_SEARCH:
+		return lldb_search_async(module,
+					req->op.search.base,
+					req->op.search.scope, 
+					req->op.search.tree, 
+					req->op.search.attrs,
+				 	req->controls,
+					req->async.context,
+					req->async.callback,
+					req->async.timeout,
+					&req->async.handle);
+
+	case LDB_ASYNC_ADD:
+		return lldb_add_async(module,
+					req->op.add.message,
+					req->async.context,
+					req->async.callback,
+					req->async.timeout,
+					&req->async.handle);
+
+	case LDB_ASYNC_MODIFY:
+		return lldb_modify_async(module,
+					req->op.mod.message,
+					req->async.context,
+					req->async.callback,
+					req->async.timeout,
+					&req->async.handle);
+
+	case LDB_ASYNC_DELETE:
+		return lldb_delete_async(module,
+					req->op.del.dn,
+					req->async.context,
+					req->async.callback,
+					req->async.timeout,
+					&req->async.handle);
+
+	case LDB_ASYNC_RENAME:
+		return lldb_rename_async(module,
+					req->op.rename.olddn,
+					req->op.rename.newdn,
+					req->async.context,
+					req->async.callback,
+					req->async.timeout,
+					&req->async.handle);
+
 	default:
 		return -1;
 
@@ -545,6 +1038,7 @@ int lldb_connect(struct ldb_context *ldb,
 {
 	struct lldb_private *lldb = NULL;
 	int version = 3;
+	int ret;
 
 	lldb = talloc(ldb, struct lldb_private);
 	if (!lldb) {
@@ -553,21 +1047,22 @@ int lldb_connect(struct ldb_context *ldb,
 	}
 
 	lldb->ldap = NULL;
-	lldb->options = NULL;
+	lldb->timeout = 120; /* TODO: get timeout from options ? */
 
-	lldb->last_rc = ldap_initialize(&lldb->ldap, url);
-	if (lldb->last_rc != LDAP_SUCCESS) {
+	ret = ldap_initialize(&lldb->ldap, url);
+	if (ret != LDAP_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "ldap_initialize failed for URL '%s' - %s\n",
-			  url, ldap_err2string(lldb->last_rc));
+			  url, ldap_err2string(ret));
 		goto failed;
 	}
 
 	talloc_set_destructor(lldb, lldb_destructor);
 
-	lldb->last_rc = ldap_set_option(lldb->ldap, LDAP_OPT_PROTOCOL_VERSION, &version);
-	if (lldb->last_rc != LDAP_SUCCESS) {
+	ret = ldap_set_option(lldb->ldap, LDAP_OPT_PROTOCOL_VERSION, &version);
+	if (ret != LDAP_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "ldap_set_option failed - %s\n",
-			  ldap_err2string(lldb->last_rc));
+			  ldap_err2string(ret));
+		goto failed;
 	}
 
 	ldb->modules = talloc(ldb, struct ldb_module);
@@ -580,6 +1075,8 @@ int lldb_connect(struct ldb_context *ldb,
 	ldb->modules->private_data = lldb;
 	ldb->modules->ops = &lldb_ops;
 
+	ldb->async_wait = &lldb_async_wait;
+
 	return 0;
 
 failed:
-- 
cgit 


From 26af14c39b88b0e7eb53657b89be65d865804688 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 2 Mar 2006 16:32:53 +0000
Subject: r13786: [merge] Add registration functions for LDB modules

Applications that use LDB modules will now have to run ldb_global_init()
before they can use LDB.

The next step will be adding support for loading LDB modules from .so
files. This will also allow us to use one LDB without difference between the
standalone and the Samba-specific build
(This used to be commit 52a235650514039bf8ffee99a784bbc1b6ae6b92)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 167bbfbd63..4f840868a1 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -1006,18 +1006,12 @@ static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 	}
 }
 
-static int lldb_init_2(struct ldb_module *module)
-{
-	return LDB_SUCCESS;
-}
-
 static const struct ldb_module_ops lldb_ops = {
 	.name              = "ldap",
 	.request           = lldb_request,
 	.start_transaction = lldb_start_trans,
 	.end_transaction   = lldb_end_trans,
 	.del_transaction   = lldb_del_trans,
-	.second_stage_init = lldb_init_2
 };
 
 
-- 
cgit 


From 6ef61825541131e16a03975cdbd344e2bbebf810 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 3 Mar 2006 17:44:03 +0000
Subject: r13818: Make ldb_tdb 'fake' async.

Simo.
(This used to be commit 0db616ef59ed51cac7e0bfaea8a799d5aa42ef16)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 4f840868a1..540dfc690b 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -52,7 +52,7 @@ struct lldb_private {
 struct lldb_async_context {
 	struct ldb_module *module;
 	int msgid;
-	uint32_t timeout;
+	int timeout;
 	void *context;
 	int (*callback)(struct ldb_context *, void *, struct ldb_async_result *);
 };
@@ -398,7 +398,10 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+
+	talloc_free(handle);
+	return ret;
 }
 
 /*
@@ -469,7 +472,10 @@ static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+
+	talloc_free(handle);
+	return ret;
 }
 
 
@@ -541,7 +547,10 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+
+	talloc_free(handle);
+	return ret;
 }
 
 /*
@@ -601,7 +610,10 @@ static int lldb_delete(struct ldb_module *module, const struct ldb_dn *dn)
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+
+	talloc_free(handle);
+	return ret;
 }
 
 /*
@@ -681,7 +693,10 @@ static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, co
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	return ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+
+	talloc_free(handle);
+	return ret;
 }
 
 static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *result)
-- 
cgit 


From 509814bd037a3c73fea4ab92b531c25964f34dfa Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 3 Mar 2006 20:01:19 +0000
Subject: r13823: make async_wait part of the modules ops (This used to be
 commit b4202cf030d5f154f0f94f5f501ecd648ba5c48f)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 540dfc690b..031fd847e3 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -860,7 +860,7 @@ error:
 	return handle->status;
 }
 
-static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+static int lldb_async_wait(struct ldb_module *module, struct ldb_async_handle *handle, enum ldb_async_wait_type type)
 {
 	struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
 	struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
@@ -1027,6 +1027,7 @@ static const struct ldb_module_ops lldb_ops = {
 	.start_transaction = lldb_start_trans,
 	.end_transaction   = lldb_end_trans,
 	.del_transaction   = lldb_del_trans,
+	.async_wait        = lldb_async_wait
 };
 
 
@@ -1084,8 +1085,6 @@ int lldb_connect(struct ldb_context *ldb,
 	ldb->modules->private_data = lldb;
 	ldb->modules->ops = &lldb_ops;
 
-	ldb->async_wait = &lldb_async_wait;
-
 	return 0;
 
 failed:
-- 
cgit 


From 8edf29e8ef4d886321a6e8ec3902065641d34f40 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 3 Mar 2006 22:52:57 +0000
Subject: r13827: Minor enhancements or cosmetic changes (This used to be
 commit 7ef63abae12f65835a82f9931ad1f5ea75e5f3f6)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 031fd847e3..d671afb953 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -395,12 +395,15 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 	ret = lldb_search_async(module, base, scope, tree, attrs, control_req,
 				res, &lldb_search_sync_callback, lldb->timeout, &handle);
 
-	if (ret != LDB_SUCCESS)
-		return ret;
+	if (ret == LDB_SUCCESS) {
+		ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+		talloc_free(handle);
+	}
 
-	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	if (ret != LDB_SUCCESS) {
+		talloc_free(*res);
+	}
 
-	talloc_free(handle);
 	return ret;
 }
 
@@ -866,7 +869,7 @@ static int lldb_async_wait(struct ldb_module *module, struct ldb_async_handle *h
 	struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
 	struct timeval timeout;
 	LDAPMessage *result;
-	int ret;
+	int ret = LDB_ERR_OPERATIONS_ERROR;
 
 	if (!ac->msgid) {
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -915,8 +918,6 @@ static int lldb_async_wait(struct ldb_module *module, struct ldb_async_handle *h
 			}
 		}
 		break;
-	default:
-		ret = LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	return ret;
-- 
cgit 


From 5d0aa16dfcf3047a52d3dd7e12ffb704a9725e83 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 5 Mar 2006 16:05:26 +0000
Subject: r13839: Use registration mechanism for backends as well (in the same
 sense my previous patch added it for modules). This is the next step towards
 LDB backends and modules as run-time loadable .so files. (This used to be
 commit fb2f70de4f6c4a9b13ad590cb4d3a9c858cede49)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index d671afb953..3a5039ddc0 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -1042,7 +1042,7 @@ static int lldb_destructor(void *p)
 /*
   connect to the database
 */
-int lldb_connect(struct ldb_context *ldb,
+static int lldb_connect(struct ldb_context *ldb,
 		 const char *url, 
 		 unsigned int flags, 
 		 const char *options[])
@@ -1093,3 +1093,7 @@ failed:
 	return -1;
 }
 
+int ldb_ldap_init(void)
+{
+	return ldb_register_backend("ldap", lldb_connect);
+}
-- 
cgit 


From 7ffc1b48a4ac5d8e2bfba5b5f5f6f4bea33f3964 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 7 Mar 2006 20:43:40 +0000
Subject: r13986: minor fixes (This used to be commit
 8375f030197d311515085ac6beeaf63af45d14b0)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 3a5039ddc0..307370ee12 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -713,6 +713,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 	char *errmsgp = NULL;
 	char **referralsp = NULL;
 	LDAPControl **serverctrlsp = NULL;
+	int ret;
 
 	type = ldap_msgtype(result);
 
@@ -763,17 +764,19 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 					lldb_add_msg_attr(ac->module->ldb, ares->message, attr, bval);
 					ldap_value_free_len(bval);
 				}					  
-				
-				ldap_memfree(attr);
 			}
 			if (berptr) ber_free(berptr, 0);
 
 
 			ares->type = LDB_REPLY_ENTRY;
 			handle->state = LDB_ASYNC_PENDING;
-			handle->status = ac->callback(ac->module->ldb, ac->context, ares);
-
-			ldap_msgfree(result);
+			ret = ac->callback(ac->module->ldb, ac->context, ares);
+			if (ret != LDB_SUCCESS) {
+				handle->status = ret;
+			}
+		} else {
+			handle->status = LDB_ERR_PROTOCOL_ERROR;
+			handle->state = LDB_ASYNC_DONE;
 		}
 		break;
 
@@ -798,7 +801,10 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 		ares->referral = talloc_strdup(ares, *referralsp);
 		ares->type = LDB_REPLY_REFERRAL;
 		handle->state = LDB_ASYNC_PENDING;
-		handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+		ret = ac->callback(ac->module->ldb, ac->context, ares);
+		if (ret != LDB_SUCCESS) {
+			handle->status = ret;
+		}
 
 		break;
 
@@ -823,7 +829,10 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 		
 		ares->type = LDB_REPLY_DONE;
 		handle->state = LDB_ASYNC_DONE;
-		handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+		ret = ac->callback(ac->module->ldb, ac->context, ares);
+		if (ret != LDB_SUCCESS) {
+			handle->status = ret;
+		}
 
 		break;
 
@@ -845,7 +854,8 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 		break;
 
 	default:
-		handle->state = LDB_ERR_PROTOCOL_ERROR;
+		handle->status = LDB_ERR_PROTOCOL_ERROR;
+		goto error;
 	}
 
 	if (matcheddnp) ldap_memfree(matcheddnp);
@@ -856,10 +866,12 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 	if (referralsp) ldap_value_free(referralsp);
 	if (serverctrlsp) ldap_controls_free(serverctrlsp);
 
+	ldap_msgfree(result);
 	return handle->status;
 
 error:
 	handle->state = LDB_ASYNC_DONE;
+	ldap_msgfree(result);
 	return handle->status;
 }
 
-- 
cgit 


From 7b82c4beb93375f79b6c06fc86bb31873baa187b Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 7 Mar 2006 21:08:09 +0000
Subject: r13992: change the way ldb_async_wait() works.

I think I should change the name of this function
to ldb_async_process(), any opinions ?
(This used to be commit 3347322d1327cfa975ee9dccd4f2774e6e14fbcb)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 307370ee12..8406ab384b 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -76,6 +76,8 @@ static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ld
 		return NULL;
 	}
 
+	h->module = module;
+
 	ac = talloc(h, struct lldb_async_context);
 	if (ac == NULL) {
 		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
@@ -875,10 +877,10 @@ error:
 	return handle->status;
 }
 
-static int lldb_async_wait(struct ldb_module *module, struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
 {
 	struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
-	struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
+	struct lldb_private *lldb = talloc_get_type(handle->module->private_data, struct lldb_private);
 	struct timeval timeout;
 	LDAPMessage *result;
 	int ret = LDB_ERR_OPERATIONS_ERROR;
-- 
cgit 


From 257598424e63c2cfa118b5ea84b7dc719d1dc5aa Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 7 Mar 2006 21:16:35 +0000
Subject: r13996: simplify ldb_async_wait() some more (This used to be commit
 ef1b3e6368179fe86ae07b8d00e4668090175551)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 8406ab384b..5a4d911218 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -398,7 +398,7 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 				res, &lldb_search_sync_callback, lldb->timeout, &handle);
 
 	if (ret == LDB_SUCCESS) {
-		ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+		ret = ldb_async_wait(handle, LDB_WAIT_ALL);
 		talloc_free(handle);
 	}
 
@@ -477,7 +477,7 @@ static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
 
 	talloc_free(handle);
 	return ret;
@@ -552,7 +552,7 @@ static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
 
 	talloc_free(handle);
 	return ret;
@@ -615,7 +615,7 @@ static int lldb_delete(struct ldb_module *module, const struct ldb_dn *dn)
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
 
 	talloc_free(handle);
 	return ret;
@@ -698,7 +698,7 @@ static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, co
 	if (ret != LDB_SUCCESS)
 		return ret;
 
-	ret = ldb_async_wait(module->ldb, handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
 
 	talloc_free(handle);
 	return ret;
-- 
cgit 


From 3baf0606040419988f1a08c0da7f546c5904d8ca Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 10 Mar 2006 15:27:16 +0000
Subject: r14161: return early if we know the job is already finished (This
 used to be commit 09f6f552d73f782dc8d62cefad9c5f584b7b07d2)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 5a4d911218..a2ca7a7cc8 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -87,6 +87,9 @@ static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ld
 
 	h->private_data = (void *)ac;
 
+	h->state = LDB_ASYNC_INIT;
+	h->status = LDB_SUCCESS;
+
 	ac->module = module;
 	ac->context = context;
 	ac->callback = callback;
@@ -885,12 +888,15 @@ static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_
 	LDAPMessage *result;
 	int ret = LDB_ERR_OPERATIONS_ERROR;
 
-	if (!ac->msgid) {
+	if (handle->state == LDB_ASYNC_DONE) {
+		return handle->status;
+	}
+
+	if (!ac || !ac->msgid) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	handle->status = LDB_SUCCESS;
-	handle->state = LDB_ASYNC_INIT;
 
 	switch(type) {
 	case LDB_WAIT_NONE:
-- 
cgit 


From 6e74d8356578c42c8081498094f2c834c6d439b4 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 10 Mar 2006 15:50:47 +0000
Subject: r14163: Remove LDB_WAIT_ONCE, we can hardly guarante we get anything
 if not waiting for all, keeping this value may just lead to false
 expectations.

You either make blocking call waiting for ALL results
transforming this in a sync call, or either you loop
expecting from 0 to all results being returned at any
time on any of these loops.

It should be clear also that when you may receive results
at any time as soon as you call ldb_request.
Your callback may have received all results even before
calling ldb_async_wait the first time.

Simo.
(This used to be commit 6f041068b50caf919cd971812bdb8e3e810565fb)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 10 ----------
 1 file changed, 10 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index a2ca7a7cc8..49de229a1e 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -913,16 +913,6 @@ static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_
 		}
 		ret = lldb_parse_result(handle, result);
 		break;
-	case LDB_WAIT_ONCE:
-		timeout.tv_sec = ac->timeout;
-		timeout.tv_usec = 0;
-		ret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
-		if (ret == -1 || ret == 0) {
-			handle->status = LDB_ERR_OPERATIONS_ERROR;
-			return handle->status;
-		}
-		ret = lldb_parse_result(handle, result);
-		break;
 	case LDB_WAIT_ALL:
 		timeout.tv_sec = ac->timeout;
 		timeout.tv_usec = 0;
-- 
cgit 


From bb1909e15e7a9f3cd79da2ce8b8ef90f1a557376 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 20 Mar 2006 21:44:59 +0000
Subject: r14592: Add support for loading shared modules to LDB. (This used to
 be commit f10fae23f0685b2d9c6174596e1c66d799f02c52)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 49de229a1e..8bfff117da 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -1105,5 +1105,7 @@ failed:
 
 int ldb_ldap_init(void)
 {
-	return ldb_register_backend("ldap", lldb_connect);
+	return ldb_register_backend("ldap", lldb_connect) +
+		   ldb_register_backend("ldapi", lldb_connect) + 
+		   ldb_register_backend("ldaps", lldb_connect);
 }
-- 
cgit 


From 971d30bb201f5c3faff5f575d26882eb79f7955a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 24 May 2006 07:34:11 +0000
Subject: r15854: more talloc_set_destructor() typesafe fixes (This used to be
 commit 61c6100617589ac6df4f527877241464cacbf8b3)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 8bfff117da..bbfb1de104 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -1042,9 +1042,8 @@ static const struct ldb_module_ops lldb_ops = {
 };
 
 
-static int lldb_destructor(void *p)
+static int lldb_destructor(struct lldb_private *lldb)
 {
-	struct lldb_private *lldb = p;
 	ldap_unbind(lldb->ldap);
 	return 0;
 }
-- 
cgit 


From 90a5e19e03842b77fd7811965fb2603e552261bc Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 28 May 2006 02:10:44 +0000
Subject: r15913: Error passing in the async code is not in agood shape Start
 enhancing it and fix some problems with incorrect evalutaion of the codes

Implement rdn rename (async only)
(This used to be commit 6af1d738b9668d4f0eb6194ac0f84af9e73f8c2e)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 77 +++++++++++++++++++------------------
 1 file changed, 40 insertions(+), 37 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index bbfb1de104..c53db1f90c 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -718,7 +718,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 	char *errmsgp = NULL;
 	char **referralsp = NULL;
 	LDAPControl **serverctrlsp = NULL;
-	int ret;
+	int ret = LDB_SUCCESS;
 
 	type = ldap_msgtype(result);
 
@@ -732,24 +732,24 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 
 			ares = talloc_zero(ac, struct ldb_async_result);
 			if (!ares) {
-				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
 			}
 
 			ares->message = ldb_msg_new(ares);
 			if (!ares->message) {
-				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
 			}
 
 			dn = ldap_get_dn(lldb->ldap, msg);
 			if (!dn) {
-				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
 			}
 			ares->message->dn = ldb_dn_explode_or_special(ares->message, dn);
 			if (ares->message->dn == NULL) {
-				handle->status = LDB_ERR_OPERATIONS_ERROR;
+				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
 			}
 			ldap_memfree(dn);
@@ -774,11 +774,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 
 
 			ares->type = LDB_REPLY_ENTRY;
-			handle->state = LDB_ASYNC_PENDING;
 			ret = ac->callback(ac->module->ldb, ac->context, ares);
-			if (ret != LDB_SUCCESS) {
-				handle->status = ret;
-			}
 		} else {
 			handle->status = LDB_ERR_PROTOCOL_ERROR;
 			handle->state = LDB_ASYNC_DONE;
@@ -789,7 +785,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 		if (ldap_parse_result(lldb->ldap, result, &handle->status,
 					&matcheddnp, &errmsgp,
 					&referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
-			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			ret = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
 		}
 		if (referralsp == NULL) {
@@ -799,17 +795,13 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 
 		ares = talloc_zero(ac, struct ldb_async_result);
 		if (!ares) {
-			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			ret = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
 		}
 
 		ares->referral = talloc_strdup(ares, *referralsp);
 		ares->type = LDB_REPLY_REFERRAL;
-		handle->state = LDB_ASYNC_PENDING;
 		ret = ac->callback(ac->module->ldb, ac->context, ares);
-		if (ret != LDB_SUCCESS) {
-			handle->status = ret;
-		}
 
 		break;
 
@@ -823,7 +815,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 
 		ares = talloc_zero(ac, struct ldb_async_result);
 		if (!ares) {
-			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			ret = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
 		}
 
@@ -835,9 +827,6 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 		ares->type = LDB_REPLY_DONE;
 		handle->state = LDB_ASYNC_DONE;
 		ret = ac->callback(ac->module->ldb, ac->context, ares);
-		if (ret != LDB_SUCCESS) {
-			handle->status = ret;
-		}
 
 		break;
 
@@ -853,13 +842,13 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 		}
 		if (ac->callback && handle->status == LDB_SUCCESS) {
 			ares = NULL; /* FIXME: build a corresponding ares to pass on */
-			handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+			ret = ac->callback(ac->module->ldb, ac->context, ares);
 		}
 		handle->state = LDB_ASYNC_DONE;
 		break;
 
 	default:
-		handle->status = LDB_ERR_PROTOCOL_ERROR;
+		ret = LDB_ERR_PROTOCOL_ERROR;
 		goto error;
 	}
 
@@ -872,12 +861,12 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 	if (serverctrlsp) ldap_controls_free(serverctrlsp);
 
 	ldap_msgfree(result);
-	return handle->status;
+	return ret;
 
 error:
 	handle->state = LDB_ASYNC_DONE;
 	ldap_msgfree(result);
-	return handle->status;
+	return ret;
 }
 
 static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
@@ -886,7 +875,7 @@ static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_
 	struct lldb_private *lldb = talloc_get_type(handle->module->private_data, struct lldb_private);
 	struct timeval timeout;
 	LDAPMessage *result;
-	int ret = LDB_ERR_OPERATIONS_ERROR;
+	int ret, lret;
 
 	if (handle->state == LDB_ASYNC_DONE) {
 		return handle->status;
@@ -896,40 +885,54 @@ static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	handle->state = LDB_ASYNC_PENDING;
 	handle->status = LDB_SUCCESS;
 
 	switch(type) {
 	case LDB_WAIT_NONE:
 		timeout.tv_sec = 0;
 		timeout.tv_usec = 0;
-		ret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
-		if (ret == -1) {
-			handle->status = LDB_ERR_OPERATIONS_ERROR;
-			return handle->status;
+
+		lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
+		if (lret == -1) {
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
-		if (ret == 0) {
-			handle->status = LDB_SUCCESS;
-			return handle->status;
+		if (lret == 0) {
+			ret = LDB_SUCCESS;
+			goto done;
 		}
-		ret = lldb_parse_result(handle, result);
-		break;
+
+		return lldb_parse_result(handle, result);
+
 	case LDB_WAIT_ALL:
 		timeout.tv_sec = ac->timeout;
 		timeout.tv_usec = 0;
+		ret = LDB_ERR_OPERATIONS_ERROR;
+
 		while (handle->status == LDB_SUCCESS && handle->state != LDB_ASYNC_DONE) {
-			ret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
-			if (ret == -1 || ret == 0) {
-				handle->status = LDB_ERR_OPERATIONS_ERROR;
-				return handle->status;
+
+			lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
+			if (lret == -1) {
+				return LDB_ERR_OPERATIONS_ERROR;
 			}
+			if (lret == 0) {
+				return LDB_ERR_TIME_LIMIT_EXCEEDED;
+			}
+
 			ret = lldb_parse_result(handle, result);
 			if (ret != LDB_SUCCESS) {
 				return ret;
 			}
 		}
+
 		break;
+		
+	default:
+		handle->state = LDB_ASYNC_DONE;
+		ret = LDB_ERR_OPERATIONS_ERROR;
 	}
 
+done:
 	return ret;
 }
 
-- 
cgit 


From 3a4d7eb2c08a06fac89c34d132f1c32751ce7ad5 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 29 May 2006 01:30:02 +0000
Subject: r15927: Optimize ldb module traverse while keeping the API intact. I
 was sick of jumping inot each module for each request, even the ones not
 handle by that module. (This used to be commit
 7d65105e885a28584e8555453b90232c43a92bf7)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 299 ++++++++++++++++--------------------
 1 file changed, 135 insertions(+), 164 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index c53db1f90c..f372e5fd04 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -224,14 +224,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 /*
   search for matching records
 */
-static int lldb_search_async(struct ldb_module *module, const struct ldb_dn *base,
-			      enum ldb_scope scope, struct ldb_parse_tree *tree,
-			      const char * const *attrs,
-			      struct ldb_control **control_req,
-			      void *context,
-			      int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
-			      int timeout,
-			      struct ldb_async_handle **handle)
+static int lldb_search_async(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -241,44 +234,41 @@ static int lldb_search_async(struct ldb_module *module, const struct ldb_dn *bas
 	char *expression;
 	int ret;
 
-	if (!callback || !context) {
+	if (!req->async.callback || !req->async.context) {
 		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Async interface called with NULL callback function or NULL context"));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	if (tree == NULL) {
+	if (req->op.search.tree == NULL) {
 		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Invalid expression parse tree"));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	if (control_req != NULL) {
+	if (req->controls != NULL) {
 		ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
 	}
 
-	*handle = init_handle(lldb, module, context, callback, timeout);
-	if (*handle == NULL) {
-		talloc_free(*handle);
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
 
-	search_base = ldb_dn_linearize(lldb_ac, base);
-	if (base == NULL) {
+	search_base = ldb_dn_linearize(lldb_ac, req->op.search.base);
+	if (req->op.search.base == NULL) {
 		search_base = talloc_strdup(lldb_ac, "");
 	}
 	if (search_base == NULL) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	expression = ldb_filter_from_tree(lldb_ac, tree);
+	expression = ldb_filter_from_tree(lldb_ac, req->op.search.tree);
 	if (expression == NULL) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	switch (scope) {
+	switch (req->op.search.scope) {
 	case LDB_SCOPE_BASE:
 		ldap_scope = LDAP_SCOPE_BASE;
 		break;
@@ -290,12 +280,12 @@ static int lldb_search_async(struct ldb_module *module, const struct ldb_dn *bas
 		break;
 	}
 
-	tv.tv_sec = timeout;
+	tv.tv_sec = req->async.timeout;
 	tv.tv_usec = 0;
 
 	ret = ldap_search_ext(lldb->ldap, search_base, ldap_scope, 
 			    expression, 
-			    discard_const_p(char *, attrs), 
+			    discard_const_p(char *, req->op.search.attrs), 
 			    0,
 			    NULL,
 			    NULL,
@@ -305,8 +295,6 @@ static int lldb_search_async(struct ldb_module *module, const struct ldb_dn *bas
 
 	if (ret != LDAP_SUCCESS) {
 		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
-		talloc_free(*handle);
-		*handle = NULL;
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -389,7 +377,7 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 			      struct ldb_result **res)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_async_handle *handle;
+	struct ldb_request *req;
 	int ret;
 
 	*res = talloc_zero(lldb, struct ldb_result);
@@ -397,12 +385,26 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = lldb_search_async(module, base, scope, tree, attrs, control_req,
-				res, &lldb_search_sync_callback, lldb->timeout, &handle);
+	req = talloc_zero(lldb, struct ldb_request);
+	if (! req) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_ASYNC_SEARCH;
+	req->op.search.base = base;
+	req->op.search.scope = scope;
+	req->op.search.tree = tree;
+	req->op.search.attrs = attrs;
+	req->controls = control_req;
+	req->async.context = (void *)res;
+	req->async.callback = lldb_search_sync_callback;
+	req->async.timeout = lldb->timeout;
+
+	ret = lldb_search_async(module, req);
 
 	if (ret == LDB_SUCCESS) {
-		ret = ldb_async_wait(handle, LDB_WAIT_ALL);
-		talloc_free(handle);
+		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
+		talloc_free(req);
 	}
 
 	if (ret != LDB_SUCCESS) {
@@ -415,11 +417,7 @@ static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *ba
 /*
   add a record
 */
-static int lldb_add_async(struct ldb_module *module, const struct ldb_message *msg,
-			  void *context,
-			  int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
-			  int timeout,
-			  struct ldb_async_handle **handle)
+static int lldb_add_async(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -428,26 +426,24 @@ static int lldb_add_async(struct ldb_module *module, const struct ldb_message *m
 	int ret;
 
 	/* ltdb specials should not reach this point */
-	if (ldb_dn_is_special(msg->dn)) {
+	if (ldb_dn_is_special(req->op.add.message->dn)) {
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	*handle = init_handle(lldb, module, context, callback, timeout);
-	if (*handle == NULL) {
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
 
-	mods = lldb_msg_to_mods(lldb_ac, msg, 0);
+	mods = lldb_msg_to_mods(lldb_ac, req->op.add.message, 0);
 	if (mods == NULL) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	dn = ldb_dn_linearize(lldb_ac, msg->dn);
+	dn = ldb_dn_linearize(lldb_ac, req->op.add.message->dn);
 	if (dn == NULL) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -458,7 +454,6 @@ static int lldb_add_async(struct ldb_module *module, const struct ldb_message *m
 
 	if (ret != LDAP_SUCCESS) {
 		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
-		talloc_free(*handle);
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -467,22 +462,31 @@ static int lldb_add_async(struct ldb_module *module, const struct ldb_message *m
 static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_async_handle *handle;
+	struct ldb_request *req;
 	int ret;
 
-	/* ldap does not understand ltdb specials */
-	if (ldb_dn_is_special(msg->dn)) {
-		return LDB_SUCCESS;
+	req = talloc_zero(lldb, struct ldb_request);
+	if (! req) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = lldb_add_async(module, msg, NULL, NULL, lldb->timeout, &handle);
+	req->operation = LDB_ASYNC_ADD;
+	req->op.add.message = msg;
+	req->controls = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = lldb->timeout;
+
+	ret = lldb_add_async(module, req);
 
-	if (ret != LDB_SUCCESS)
+	if (ret != LDB_SUCCESS) {
+		talloc_free(req);
 		return ret;
+	}
 
-	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
 
-	talloc_free(handle);
+	talloc_free(req);
 	return ret;
 }
 
@@ -490,11 +494,7 @@ static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
 /*
   modify a record
 */
-static int lldb_modify_async(struct ldb_module *module, const struct ldb_message *msg,
-			     void *context,
-			     int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
-			     int timeout,
-			     struct ldb_async_handle **handle)
+static int lldb_modify_async(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -503,26 +503,24 @@ static int lldb_modify_async(struct ldb_module *module, const struct ldb_message
 	int ret;
 
 	/* ltdb specials should not reach this point */
-	if (ldb_dn_is_special(msg->dn)) {
+	if (ldb_dn_is_special(req->op.mod.message->dn)) {
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	*handle = init_handle(lldb, module, context, callback, timeout);
-	if (*handle == NULL) {
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
 
-	mods = lldb_msg_to_mods(lldb_ac, msg, 1);
+	mods = lldb_msg_to_mods(lldb_ac, req->op.mod.message, 1);
 	if (mods == NULL) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	dn = ldb_dn_linearize(lldb_ac, msg->dn);
+	dn = ldb_dn_linearize(lldb_ac, req->op.mod.message->dn);
 	if (dn == NULL) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -533,7 +531,6 @@ static int lldb_modify_async(struct ldb_module *module, const struct ldb_message
 
 	if (ret != LDAP_SUCCESS) {
 		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
-		talloc_free(*handle);
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -542,33 +539,38 @@ static int lldb_modify_async(struct ldb_module *module, const struct ldb_message
 static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_async_handle *handle;
+	struct ldb_request *req;
 	int ret;
 
-	/* ldap does not understand ltdb specials */
-	if (ldb_dn_is_special(msg->dn)) {
-		return LDB_SUCCESS;
+	req = talloc_zero(lldb, struct ldb_request);
+	if (! req) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = lldb_modify_async(module, msg, NULL, NULL, lldb->timeout, &handle);
+	req->operation = LDB_ASYNC_MODIFY;
+	req->op.mod.message = msg;
+	req->controls = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = lldb->timeout;
+
+	ret = lldb_modify_async(module, req);
 
-	if (ret != LDB_SUCCESS)
+	if (ret != LDB_SUCCESS) {
+		talloc_free(req);
 		return ret;
+	}
 
-	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
 
-	talloc_free(handle);
+	talloc_free(req);
 	return ret;
 }
 
 /*
   delete a record
 */
-static int lldb_delete_async(struct ldb_module *module, const struct ldb_dn *dn,
-			     void *context,
-			     int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
-			     int timeout,
-			     struct ldb_async_handle **handle)
+static int lldb_delete_async(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -576,18 +578,18 @@ static int lldb_delete_async(struct ldb_module *module, const struct ldb_dn *dn,
 	int ret;
 	
 	/* ltdb specials should not reach this point */
-	if (ldb_dn_is_special(dn)) {
+	if (ldb_dn_is_special(req->op.del.dn)) {
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	*handle = init_handle(lldb, module, context, callback, timeout);
-	if (*handle == NULL) {
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
 
-	dnstr = ldb_dn_linearize(lldb_ac, dn);
+	dnstr = ldb_dn_linearize(lldb_ac, req->op.del.dn);
 
 	ret = ldap_delete_ext(lldb->ldap, dnstr,
 			      NULL,
@@ -596,7 +598,6 @@ static int lldb_delete_async(struct ldb_module *module, const struct ldb_dn *dn,
 
 	if (ret != LDAP_SUCCESS) {
 		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
-		talloc_free(*handle);
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -605,34 +606,38 @@ static int lldb_delete_async(struct ldb_module *module, const struct ldb_dn *dn,
 static int lldb_delete(struct ldb_module *module, const struct ldb_dn *dn)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_async_handle *handle;
+	struct ldb_request *req;
 	int ret;
 
-	/* ignore ltdb specials */
-	if (ldb_dn_is_special(dn)) {
-		return LDB_SUCCESS;
+	req = talloc_zero(lldb, struct ldb_request);
+	if (! req) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = lldb_delete_async(module, dn, NULL, NULL, lldb->timeout, &handle);
+	req->operation = LDB_ASYNC_DELETE;
+	req->op.del.dn = dn;
+	req->controls = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = lldb->timeout;
 
-	if (ret != LDB_SUCCESS)
+	ret = lldb_delete_async(module, req);
+
+	if (ret != LDB_SUCCESS) {
+		talloc_free(req);
 		return ret;
+	}
 
-	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
 
-	talloc_free(handle);
+	talloc_free(req);
 	return ret;
 }
 
 /*
   rename a record
 */
-static int lldb_rename_async(struct ldb_module *module,
-			     const struct ldb_dn *olddn, const struct ldb_dn *newdn,
-			     void *context,
-			     int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
-			     int timeout,
-			     struct ldb_async_handle **handle)
+static int lldb_rename_async(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -642,34 +647,31 @@ static int lldb_rename_async(struct ldb_module *module,
 	int ret;
 	
 	/* ltdb specials should not reach this point */
-	if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
+	if (ldb_dn_is_special(req->op.rename.olddn) || ldb_dn_is_special(req->op.rename.newdn)) {
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	*handle = init_handle(lldb, module, context, callback, timeout);
-	if (*handle == NULL) {
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type((*handle)->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
 
-	old_dn = ldb_dn_linearize(lldb_ac, olddn);
+	old_dn = ldb_dn_linearize(lldb_ac, req->op.rename.olddn);
 	if (old_dn == NULL) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	newrdn = talloc_asprintf(lldb_ac, "%s=%s",
-				      newdn->components[0].name,
-				      ldb_dn_escape_value(lldb, newdn->components[0].value));
+				 req->op.rename.newdn->components[0].name,
+				 ldb_dn_escape_value(lldb, req->op.rename.newdn->components[0].value));
 	if (!newrdn) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	parentdn = ldb_dn_linearize(lldb_ac, ldb_dn_get_parent(lldb_ac, newdn));
+	parentdn = ldb_dn_linearize(lldb_ac, ldb_dn_get_parent(lldb_ac, req->op.rename.newdn));
 	if (!parentdn) {
-		talloc_free(*handle);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -679,7 +681,6 @@ static int lldb_rename_async(struct ldb_module *module,
 
 	if (ret != LDAP_SUCCESS) {
 		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
-		talloc_free(*handle);
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -688,22 +689,32 @@ static int lldb_rename_async(struct ldb_module *module,
 static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_async_handle *handle;
+	struct ldb_request *req;
 	int ret;
 
-	/* ignore ltdb specials */
-	if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
-		return LDB_SUCCESS;
+	req = talloc_zero(lldb, struct ldb_request);
+	if (! req) {
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = lldb_rename_async(module, olddn, newdn, NULL, NULL, lldb->timeout, &handle);
+	req->operation = LDB_ASYNC_RENAME;
+	req->op.rename.olddn = olddn;
+	req->op.rename.newdn = newdn;
+	req->controls = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = lldb->timeout;
+
+	ret = lldb_rename_async(module, req);
 
-	if (ret != LDB_SUCCESS)
+	if (ret != LDB_SUCCESS) {
+		talloc_free(req);
 		return ret;
+	}
 
-	ret = ldb_async_wait(handle, LDB_WAIT_ALL);
+	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
 
-	talloc_free(handle);
+	talloc_free(req);
 	return ret;
 }
 
@@ -984,51 +995,6 @@ static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 					req->op.rename.olddn,
 					req->op.rename.newdn);
 
-	case LDB_ASYNC_SEARCH:
-		return lldb_search_async(module,
-					req->op.search.base,
-					req->op.search.scope, 
-					req->op.search.tree, 
-					req->op.search.attrs,
-				 	req->controls,
-					req->async.context,
-					req->async.callback,
-					req->async.timeout,
-					&req->async.handle);
-
-	case LDB_ASYNC_ADD:
-		return lldb_add_async(module,
-					req->op.add.message,
-					req->async.context,
-					req->async.callback,
-					req->async.timeout,
-					&req->async.handle);
-
-	case LDB_ASYNC_MODIFY:
-		return lldb_modify_async(module,
-					req->op.mod.message,
-					req->async.context,
-					req->async.callback,
-					req->async.timeout,
-					&req->async.handle);
-
-	case LDB_ASYNC_DELETE:
-		return lldb_delete_async(module,
-					req->op.del.dn,
-					req->async.context,
-					req->async.callback,
-					req->async.timeout,
-					&req->async.handle);
-
-	case LDB_ASYNC_RENAME:
-		return lldb_rename_async(module,
-					req->op.rename.olddn,
-					req->op.rename.newdn,
-					req->async.context,
-					req->async.callback,
-					req->async.timeout,
-					&req->async.handle);
-
 	default:
 		return -1;
 
@@ -1037,6 +1003,11 @@ static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 
 static const struct ldb_module_ops lldb_ops = {
 	.name              = "ldap",
+	.search            = lldb_search_async,
+	.add               = lldb_add_async,
+	.modify            = lldb_modify_async,
+	.del               = lldb_delete_async,
+	.rename            = lldb_rename_async,
 	.request           = lldb_request,
 	.start_transaction = lldb_start_trans,
 	.end_transaction   = lldb_end_trans,
-- 
cgit 


From 0c7b82e5f6063de4114de21cf854ac67346e31f6 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 29 May 2006 23:46:43 +0000
Subject: r15942: Remove the sync internal ldb calls altogether. This means
 that some modules have been disabled as well as they have not been ported to
 the async interface

One of them is the ugly objectclass module.
I hope that the change in samldb module will make the MMC happy
without the need of this crappy module, we need proper handling
in a decent schema module.

proxy and ldb_map have also been disabled
ldb_sqlite3 need to be ported as well (currenlty just broken).
(This used to be commit 51083de795bdcbf649de926e86969adc20239b6d)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 296 ++----------------------------------
 1 file changed, 14 insertions(+), 282 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index f372e5fd04..5748c2ecd7 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -224,7 +224,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 /*
   search for matching records
 */
-static int lldb_search_async(struct ldb_module *module, struct ldb_request *req)
+static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -300,124 +300,10 @@ static int lldb_search_async(struct ldb_module *module, struct ldb_request *req)
 	return lldb_ldap_to_ldb(ret);
 }
 
-static int lldb_search_sync_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
-{
-	struct ldb_result *res;
-	int n;
-	
- 	if (!context) {
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context in callback"));
-		return LDB_ERR_OPERATIONS_ERROR;
-	}	
-
-	res = *((struct ldb_result **)context);
-
-	if (!res || !ares) {
-		goto error;
-	}
-
-	if (ares->type == LDB_REPLY_ENTRY) {
-		res->msgs = talloc_realloc(res, res->msgs, struct ldb_message *, res->count + 2);
-		if (! res->msgs) {
-			goto error;
-		}
-
-		res->msgs[res->count + 1] = NULL;
-
-		res->msgs[res->count] = talloc_steal(res->msgs, ares->message);
-		if (! res->msgs[res->count]) {
-			goto error;
-		}
-
-		res->count++;
-	}
-
-	if (ares->type == LDB_REPLY_REFERRAL) {
-		if (res->refs) {
-			for (n = 0; res->refs[n]; n++) /*noop*/ ;
-		} else {
-			n = 0;
-		}
-
-		res->refs = talloc_realloc(res, res->refs, char *, n + 2);
-		if (! res->refs) {
-			goto error;
-		}
-
-		res->refs[n] = talloc_steal(res->refs, ares->referral);
-		res->refs[n + 1] = NULL;
-	}
-
-	if (ares->type == LDB_REPLY_DONE) {
-		if (ares->controls) {
-			res->controls = talloc_steal(res, ares->controls);
-			if (! res->controls) {
-				goto error;
-			}
-		}
-	}
-
-	talloc_free(ares);
-	return LDB_SUCCESS;
-
-error:
-	talloc_free(ares);
-	talloc_free(res);
-	*((struct ldb_result **)context) = NULL;
-	return LDB_ERR_OPERATIONS_ERROR;
-}
-
-/*
-  search for matching records using a synchronous function
- */
-static int lldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
-			      enum ldb_scope scope, struct ldb_parse_tree *tree,
-			      const char * const *attrs,
-			      struct ldb_control **control_req,
-			      struct ldb_result **res)
-{
-	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_request *req;
-	int ret;
-
-	*res = talloc_zero(lldb, struct ldb_result);
-	if (! *res) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	req = talloc_zero(lldb, struct ldb_request);
-	if (! req) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	req->operation = LDB_ASYNC_SEARCH;
-	req->op.search.base = base;
-	req->op.search.scope = scope;
-	req->op.search.tree = tree;
-	req->op.search.attrs = attrs;
-	req->controls = control_req;
-	req->async.context = (void *)res;
-	req->async.callback = lldb_search_sync_callback;
-	req->async.timeout = lldb->timeout;
-
-	ret = lldb_search_async(module, req);
-
-	if (ret == LDB_SUCCESS) {
-		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
-		talloc_free(req);
-	}
-
-	if (ret != LDB_SUCCESS) {
-		talloc_free(*res);
-	}
-
-	return ret;
-}
-
 /*
   add a record
 */
-static int lldb_add_async(struct ldb_module *module, struct ldb_request *req)
+static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -459,42 +345,10 @@ static int lldb_add_async(struct ldb_module *module, struct ldb_request *req)
 	return lldb_ldap_to_ldb(ret);
 }
 
-static int lldb_add(struct ldb_module *module, const struct ldb_message *msg)
-{
-	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_request *req;
-	int ret;
-
-	req = talloc_zero(lldb, struct ldb_request);
-	if (! req) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	req->operation = LDB_ASYNC_ADD;
-	req->op.add.message = msg;
-	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
-	req->async.timeout = lldb->timeout;
-
-	ret = lldb_add_async(module, req);
-
-	if (ret != LDB_SUCCESS) {
-		talloc_free(req);
-		return ret;
-	}
-
-	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
-
-	talloc_free(req);
-	return ret;
-}
-
-
 /*
   modify a record
 */
-static int lldb_modify_async(struct ldb_module *module, struct ldb_request *req)
+static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -536,41 +390,10 @@ static int lldb_modify_async(struct ldb_module *module, struct ldb_request *req)
 	return lldb_ldap_to_ldb(ret);
 }
 
-static int lldb_modify(struct ldb_module *module, const struct ldb_message *msg)
-{
-	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_request *req;
-	int ret;
-
-	req = talloc_zero(lldb, struct ldb_request);
-	if (! req) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	req->operation = LDB_ASYNC_MODIFY;
-	req->op.mod.message = msg;
-	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
-	req->async.timeout = lldb->timeout;
-
-	ret = lldb_modify_async(module, req);
-
-	if (ret != LDB_SUCCESS) {
-		talloc_free(req);
-		return ret;
-	}
-
-	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
-
-	talloc_free(req);
-	return ret;
-}
-
 /*
   delete a record
 */
-static int lldb_delete_async(struct ldb_module *module, struct ldb_request *req)
+static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -603,41 +426,10 @@ static int lldb_delete_async(struct ldb_module *module, struct ldb_request *req)
 	return lldb_ldap_to_ldb(ret);
 }
 
-static int lldb_delete(struct ldb_module *module, const struct ldb_dn *dn)
-{
-	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_request *req;
-	int ret;
-
-	req = talloc_zero(lldb, struct ldb_request);
-	if (! req) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	req->operation = LDB_ASYNC_DELETE;
-	req->op.del.dn = dn;
-	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
-	req->async.timeout = lldb->timeout;
-
-	ret = lldb_delete_async(module, req);
-
-	if (ret != LDB_SUCCESS) {
-		talloc_free(req);
-		return ret;
-	}
-
-	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
-
-	talloc_free(req);
-	return ret;
-}
-
 /*
   rename a record
 */
-static int lldb_rename_async(struct ldb_module *module, struct ldb_request *req)
+static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
 	struct lldb_async_context *lldb_ac;
@@ -686,38 +478,6 @@ static int lldb_rename_async(struct ldb_module *module, struct ldb_request *req)
 	return lldb_ldap_to_ldb(ret);
 }
 
-static int lldb_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
-{
-	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct ldb_request *req;
-	int ret;
-
-	req = talloc_zero(lldb, struct ldb_request);
-	if (! req) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	req->operation = LDB_ASYNC_RENAME;
-	req->op.rename.olddn = olddn;
-	req->op.rename.newdn = newdn;
-	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
-	req->async.timeout = lldb->timeout;
-
-	ret = lldb_rename_async(module, req);
-
-	if (ret != LDB_SUCCESS) {
-		talloc_free(req);
-		return ret;
-	}
-
-	ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
-
-	talloc_free(req);
-	return ret;
-}
-
 static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *result)
 {
 	struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
@@ -951,63 +711,35 @@ static int lldb_start_trans(struct ldb_module *module)
 {
 	/* TODO implement a local transaction mechanism here */
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 static int lldb_end_trans(struct ldb_module *module)
 {
 	/* TODO implement a local transaction mechanism here */
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 static int lldb_del_trans(struct ldb_module *module)
 {
 	/* TODO implement a local transaction mechanism here */
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 static int lldb_request(struct ldb_module *module, struct ldb_request *req)
 {
-	switch (req->operation) {
-
-	case LDB_REQ_SEARCH:
-		return lldb_search_bytree(module,
-					  req->op.search.base,
-					  req->op.search.scope, 
-					  req->op.search.tree, 
-					  req->op.search.attrs, 
-					  req->controls,
-					  &req->op.search.res);
-
-	case LDB_REQ_ADD:
-		return lldb_add(module, req->op.add.message);
-
-	case LDB_REQ_MODIFY:
-		return lldb_modify(module, req->op.mod.message);
-
-	case LDB_REQ_DELETE:
-		return lldb_delete(module, req->op.del.dn);
-
-	case LDB_REQ_RENAME:
-		return lldb_rename(module,
-					req->op.rename.olddn,
-					req->op.rename.newdn);
-
-	default:
-		return -1;
-
-	}
+	return LDB_ERR_OPERATIONS_ERROR;
 }
 
 static const struct ldb_module_ops lldb_ops = {
 	.name              = "ldap",
-	.search            = lldb_search_async,
-	.add               = lldb_add_async,
-	.modify            = lldb_modify_async,
-	.del               = lldb_delete_async,
-	.rename            = lldb_rename_async,
+	.search            = lldb_search,
+	.add               = lldb_add,
+	.modify            = lldb_modify,
+	.del               = lldb_delete,
+	.rename            = lldb_rename,
 	.request           = lldb_request,
 	.start_transaction = lldb_start_trans,
 	.end_transaction   = lldb_end_trans,
-- 
cgit 


From ca5accf224dc3ef998235603797b519866b57b1c Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 4 Jun 2006 05:28:13 +0000
Subject: r16036: Add a couple of new functions to corretly deal with timeouts.
 Check timeouts are correctly verified. Some minor fixed and removal of unused
 code. (This used to be commit b52e5d6a0cb1a32e62759eaa49ce3e4cc804cc92)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 5748c2ecd7..4132fa6c15 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -46,13 +46,13 @@
 
 struct lldb_private {
 	LDAP *ldap;
-	int timeout;
 };
 
 struct lldb_async_context {
 	struct ldb_module *module;
 	int msgid;
 	int timeout;
+	time_t starttime;
 	void *context;
 	int (*callback)(struct ldb_context *, void *, struct ldb_async_result *);
 };
@@ -65,7 +65,7 @@ static int lldb_ldap_to_ldb(int err) {
 static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ldb_module *module,
 					    void *context,
 					    int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
-					    int timeout)
+					    int timeout, time_t starttime)
 {
 	struct lldb_async_context *ac;
 	struct ldb_async_handle *h;
@@ -94,6 +94,7 @@ static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ld
 	ac->context = context;
 	ac->callback = callback;
 	ac->timeout = timeout;
+	ac->starttime = starttime;
 	ac->msgid = 0;
 
 	return h;
@@ -248,7 +249,7 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 		ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
 	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -316,7 +317,7 @@ static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
 	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -361,7 +362,7 @@ static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
 	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -405,7 +406,7 @@ static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
 	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -443,7 +444,7 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout);
+	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
 	if (req->async.handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -661,6 +662,12 @@ static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_
 
 	switch(type) {
 	case LDB_WAIT_NONE:
+
+		if ((ac->timeout != -1) &&
+		    ((ac->starttime + timeout) > time(NULL))) {
+			return LDB_ERR_TIME_LIMIT_EXCEEDED;
+		}
+
 		timeout.tv_sec = 0;
 		timeout.tv_usec = 0;
 
@@ -676,13 +683,19 @@ static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_
 		return lldb_parse_result(handle, result);
 
 	case LDB_WAIT_ALL:
-		timeout.tv_sec = ac->timeout;
 		timeout.tv_usec = 0;
 		ret = LDB_ERR_OPERATIONS_ERROR;
 
 		while (handle->status == LDB_SUCCESS && handle->state != LDB_ASYNC_DONE) {
 
-			lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
+			if (ac->timeout == -1) {
+				lret = ldap_result(lldb->ldap, ac->msgid, 0, NULL, &result);
+			} else {
+				timeout.tv_sec = ac->timeout - (time(NULL) - ac->starttime);
+				if (timeout.tv_sec <= 0)
+					return LDB_ERR_TIME_LIMIT_EXCEEDED;
+				lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
+			}
 			if (lret == -1) {
 				return LDB_ERR_OPERATIONS_ERROR;
 			}
@@ -773,7 +786,6 @@ static int lldb_connect(struct ldb_context *ldb,
 	}
 
 	lldb->ldap = NULL;
-	lldb->timeout = 120; /* TODO: get timeout from options ? */
 
 	ret = ldap_initialize(&lldb->ldap, url);
 	if (ret != LDAP_SUCCESS) {
-- 
cgit 


From 247af0d569594512a24e83156e257b8d4d356883 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 7 Jun 2006 21:03:38 +0000
Subject: r16083: Make it possible to initialise a backend module, without it
 setting up the whole ldb structure.

Because the sequence number was a fn pointer on the main ldb context,
turn it into a full request (currently sync).

Andrew Bartlett
(This used to be commit fbe7d0ca9031e292b2d2fae263233c973982980a)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 4132fa6c15..c74be37108 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -771,9 +771,10 @@ static int lldb_destructor(struct lldb_private *lldb)
   connect to the database
 */
 static int lldb_connect(struct ldb_context *ldb,
-		 const char *url, 
-		 unsigned int flags, 
-		 const char *options[])
+			const char *url, 
+			unsigned int flags, 
+			const char *options[],
+			struct ldb_module **module)
 {
 	struct lldb_private *lldb = NULL;
 	int version = 3;
@@ -803,15 +804,16 @@ static int lldb_connect(struct ldb_context *ldb,
 		goto failed;
 	}
 
-	ldb->modules = talloc(ldb, struct ldb_module);
-	if (!ldb->modules) {
+	*module = talloc(ldb, struct ldb_module);
+	if (!module) {
 		ldb_oom(ldb);
-		goto failed;
+		talloc_free(lldb);
+		return -1;
 	}
-	ldb->modules->ldb = ldb;
-	ldb->modules->prev = ldb->modules->next = NULL;
-	ldb->modules->private_data = lldb;
-	ldb->modules->ops = &lldb_ops;
+	(*module)->ldb = ldb;
+	(*module)->prev = ldb->modules->next = NULL;
+	(*module)->private_data = lldb;
+	(*module)->ops = &lldb_ops;
 
 	return 0;
 
-- 
cgit 


From d912d6fcef28fad1c6e1c04a3a2eb4ed9e1a4ca3 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 8 Jun 2006 01:02:14 +0000
Subject: r16087: Fix silly cut-and-paste typo that cost me much of my
 afternoon...

This only affects my new partitions module, which I will post soon,
but should be fixed anyway.

Andrew Bartlett
(This used to be commit 8912c4e057eb3962321245cf49b92999afcc64fc)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index c74be37108..13f891108a 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -811,7 +811,7 @@ static int lldb_connect(struct ldb_context *ldb,
 		return -1;
 	}
 	(*module)->ldb = ldb;
-	(*module)->prev = ldb->modules->next = NULL;
+	(*module)->prev = (*module)->next = NULL;
 	(*module)->private_data = lldb;
 	(*module)->ops = &lldb_ops;
 
-- 
cgit 


From 761450c66e92efb2570b5aaa038178d426323cce Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Jul 2006 12:11:02 +0000
Subject: r17112: - fix the build of the ldap ldb backend with newer openldap
 header files. - use the correct timeout variable (simo you should do a
 standalone build before commiting:-)

metze
(This used to be commit ac9d69d2574e8331b3ce9c3b97922ead9165fa79)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 13f891108a..3df137efaf 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -42,6 +42,7 @@
 #include "includes.h"
 #include "ldb/include/includes.h"
 
+#define LDAP_DEPRECATED 1
 #include <ldap.h>
 
 struct lldb_private {
@@ -664,7 +665,7 @@ static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_
 	case LDB_WAIT_NONE:
 
 		if ((ac->timeout != -1) &&
-		    ((ac->starttime + timeout) > time(NULL))) {
+		    ((ac->starttime + ac->timeout) > time(NULL))) {
 			return LDB_ERR_TIME_LIMIT_EXCEEDED;
 		}
 
-- 
cgit 


From c93817b36d3ff7f44cb7b3e1d1a29e37ec12affe Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 22 Jul 2006 16:56:33 +0000
Subject: r17185: Oh, I wanted to do this for sooo long time. Finally
 acknowledge that ldb is inherently async and does not have a dual personality
 anymore Rename all ldb_async_XXX functions to ldb_XXX except for
 ldb_async_result, it is now ldb_reply to reflect the real function of this
 structure.

Simo.
(This used to be commit 25fc7354049d62efeba17681ef1cdd326bc3f2ef)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 54 ++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 3df137efaf..f6d24411db 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -49,13 +49,13 @@ struct lldb_private {
 	LDAP *ldap;
 };
 
-struct lldb_async_context {
+struct lldb_context {
 	struct ldb_module *module;
 	int msgid;
 	int timeout;
 	time_t starttime;
 	void *context;
-	int (*callback)(struct ldb_context *, void *, struct ldb_async_result *);
+	int (*callback)(struct ldb_context *, void *, struct ldb_reply *);
 };
 
 static int lldb_ldap_to_ldb(int err) {
@@ -63,15 +63,15 @@ static int lldb_ldap_to_ldb(int err) {
 	return err;
 }
 
-static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ldb_module *module,
+static struct ldb_handle *init_handle(struct lldb_private *lldb, struct ldb_module *module,
 					    void *context,
-					    int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
+					    int (*callback)(struct ldb_context *, void *, struct ldb_reply *),
 					    int timeout, time_t starttime)
 {
-	struct lldb_async_context *ac;
-	struct ldb_async_handle *h;
+	struct lldb_context *ac;
+	struct ldb_handle *h;
 
-	h = talloc_zero(lldb, struct ldb_async_handle);
+	h = talloc_zero(lldb, struct ldb_handle);
 	if (h == NULL) {
 		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
 		return NULL;
@@ -79,7 +79,7 @@ static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ld
 
 	h->module = module;
 
-	ac = talloc(h, struct lldb_async_context);
+	ac = talloc(h, struct lldb_context);
 	if (ac == NULL) {
 		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
 		talloc_free(h);
@@ -229,7 +229,7 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct lldb_async_context *lldb_ac;
+	struct lldb_context *lldb_ac;
 	struct timeval tv;
 	int ldap_scope;
 	char *search_base;
@@ -255,7 +255,7 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
 
 	search_base = ldb_dn_linearize(lldb_ac, req->op.search.base);
 	if (req->op.search.base == NULL) {
@@ -308,7 +308,7 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct lldb_async_context *lldb_ac;
+	struct lldb_context *lldb_ac;
 	LDAPMod **mods;
 	char *dn;
 	int ret;
@@ -323,7 +323,7 @@ static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
 
 	mods = lldb_msg_to_mods(lldb_ac, req->op.add.message, 0);
 	if (mods == NULL) {
@@ -353,7 +353,7 @@ static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct lldb_async_context *lldb_ac;
+	struct lldb_context *lldb_ac;
 	LDAPMod **mods;
 	char *dn;
 	int ret;
@@ -368,7 +368,7 @@ static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
 
 	mods = lldb_msg_to_mods(lldb_ac, req->op.mod.message, 1);
 	if (mods == NULL) {
@@ -398,7 +398,7 @@ static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct lldb_async_context *lldb_ac;
+	struct lldb_context *lldb_ac;
 	char *dnstr;
 	int ret;
 	
@@ -412,7 +412,7 @@ static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
 
 	dnstr = ldb_dn_linearize(lldb_ac, req->op.del.dn);
 
@@ -434,7 +434,7 @@ static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 {
 	struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
-	struct lldb_async_context *lldb_ac;
+	struct lldb_context *lldb_ac;
 	char *old_dn;
        	char *newrdn;
 	char *parentdn;
@@ -450,7 +450,7 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
 
 	old_dn = ldb_dn_linearize(lldb_ac, req->op.rename.olddn);
 	if (old_dn == NULL) {
@@ -480,11 +480,11 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 	return lldb_ldap_to_ldb(ret);
 }
 
-static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *result)
+static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 {
-	struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
+	struct lldb_context *ac = talloc_get_type(handle->private_data, struct lldb_context);
 	struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
-	struct ldb_async_result *ares = NULL;
+	struct ldb_reply *ares = NULL;
 	LDAPMessage *msg;
 	int type;
 	char *matcheddnp = NULL;
@@ -503,7 +503,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 			BerElement *berptr = NULL;
 			char *attr, *dn;
 
-			ares = talloc_zero(ac, struct ldb_async_result);
+			ares = talloc_zero(ac, struct ldb_reply);
 			if (!ares) {
 				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
@@ -566,7 +566,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 			goto error;
 		}
 
-		ares = talloc_zero(ac, struct ldb_async_result);
+		ares = talloc_zero(ac, struct ldb_reply);
 		if (!ares) {
 			ret = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
@@ -586,7 +586,7 @@ static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *resul
 			goto error;
 		}
 
-		ares = talloc_zero(ac, struct ldb_async_result);
+		ares = talloc_zero(ac, struct ldb_reply);
 		if (!ares) {
 			ret = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
@@ -642,9 +642,9 @@ error:
 	return ret;
 }
 
-static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+static int lldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 {
-	struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
+	struct lldb_context *ac = talloc_get_type(handle->private_data, struct lldb_context);
 	struct lldb_private *lldb = talloc_get_type(handle->module->private_data, struct lldb_private);
 	struct timeval timeout;
 	LDAPMessage *result;
@@ -758,7 +758,7 @@ static const struct ldb_module_ops lldb_ops = {
 	.start_transaction = lldb_start_trans,
 	.end_transaction   = lldb_end_trans,
 	.del_transaction   = lldb_del_trans,
-	.async_wait        = lldb_async_wait
+	.wait              = lldb_wait
 };
 
 
-- 
cgit 


From 49f68caed20d2a7d1850e493005bdf85929d6365 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 22 Jul 2006 17:21:59 +0000
Subject: r17186: "async" word abuse clean-up part 2 (This used to be commit
 c6aa60c7e69abf1f83efc150b1c3ed02751c45fc)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index f6d24411db..1a20a28590 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -236,7 +236,7 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 	char *expression;
 	int ret;
 
-	if (!req->async.callback || !req->async.context) {
+	if (!req->callback || !req->context) {
 		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Async interface called with NULL callback function or NULL context"));
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -250,12 +250,12 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 		ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
-	if (req->async.handle == NULL) {
+	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
+	if (req->handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
+	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
 	search_base = ldb_dn_linearize(lldb_ac, req->op.search.base);
 	if (req->op.search.base == NULL) {
@@ -282,7 +282,7 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 		break;
 	}
 
-	tv.tv_sec = req->async.timeout;
+	tv.tv_sec = req->timeout;
 	tv.tv_usec = 0;
 
 	ret = ldap_search_ext(lldb->ldap, search_base, ldap_scope, 
@@ -318,12 +318,12 @@ static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
-	if (req->async.handle == NULL) {
+	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
+	if (req->handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
+	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
 	mods = lldb_msg_to_mods(lldb_ac, req->op.add.message, 0);
 	if (mods == NULL) {
@@ -363,12 +363,12 @@ static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
-	if (req->async.handle == NULL) {
+	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
+	if (req->handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
+	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
 	mods = lldb_msg_to_mods(lldb_ac, req->op.mod.message, 1);
 	if (mods == NULL) {
@@ -407,12 +407,12 @@ static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
-	if (req->async.handle == NULL) {
+	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
+	if (req->handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
+	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
 	dnstr = ldb_dn_linearize(lldb_ac, req->op.del.dn);
 
@@ -445,12 +445,12 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
-	if (req->async.handle == NULL) {
+	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
+	if (req->handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_context);
+	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
 	old_dn = ldb_dn_linearize(lldb_ac, req->op.rename.olddn);
 	if (old_dn == NULL) {
-- 
cgit 


From faed8175063b16df94d5332581baf1af0562bb09 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 13 Aug 2006 07:33:57 +0000
Subject: r17514: Simplify the way to set ldb errors and add another helper
 function to set them. (This used to be commit
 260868bae56194fcb98d55afc22fc66d96a303df)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 1a20a28590..74ef1fcb47 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -73,7 +73,7 @@ static struct ldb_handle *init_handle(struct lldb_private *lldb, struct ldb_modu
 
 	h = talloc_zero(lldb, struct ldb_handle);
 	if (h == NULL) {
-		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+		ldb_set_errstring(module->ldb, "Out of Memory");
 		return NULL;
 	}
 
@@ -81,7 +81,7 @@ static struct ldb_handle *init_handle(struct lldb_private *lldb, struct ldb_modu
 
 	ac = talloc(h, struct lldb_context);
 	if (ac == NULL) {
-		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
+		ldb_set_errstring(module->ldb, "Out of Memory");
 		talloc_free(h);
 		return NULL;
 	}
@@ -237,12 +237,12 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 	int ret;
 
 	if (!req->callback || !req->context) {
-		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Async interface called with NULL callback function or NULL context"));
+		ldb_set_errstring(module->ldb, "Async interface called with NULL callback function or NULL context");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	if (req->op.search.tree == NULL) {
-		ldb_set_errstring(module->ldb, talloc_asprintf(module, "Invalid expression parse tree"));
+		ldb_set_errstring(module->ldb, "Invalid expression parse tree");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -296,7 +296,7 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 			    &lldb_ac->msgid);
 
 	if (ret != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		ldb_set_errstring(module->ldb, ldap_err2string(ret));
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -341,7 +341,7 @@ static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 			   &lldb_ac->msgid);
 
 	if (ret != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		ldb_set_errstring(module->ldb, ldap_err2string(ret));
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -386,7 +386,7 @@ static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 			      &lldb_ac->msgid);
 
 	if (ret != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		ldb_set_errstring(module->ldb, ldap_err2string(ret));
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -422,7 +422,7 @@ static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 			      &lldb_ac->msgid);
 
 	if (ret != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		ldb_set_errstring(module->ldb, ldap_err2string(ret));
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -474,7 +474,7 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 			  &lldb_ac->msgid);
 
 	if (ret != LDAP_SUCCESS) {
-		ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+		ldb_set_errstring(module->ldb, ldap_err2string(ret));
 	}
 
 	return lldb_ldap_to_ldb(ret);
@@ -627,7 +627,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 
 	if (matcheddnp) ldap_memfree(matcheddnp);
 	if (errmsgp) {
-		ldb_set_errstring(ac->module->ldb, talloc_strdup(ac->module, errmsgp));
+		ldb_set_errstring(ac->module->ldb, errmsgp);
 		ldap_memfree(errmsgp);
 	}
 	if (referralsp) ldap_value_free(referralsp);
-- 
cgit 


From 862ba2617205832d4d5f0db07c54c4cc436a0f3d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 22 Aug 2006 01:13:45 +0000
Subject: r17678: don't free result message twice (This used to be commit
 e3908818198bf0f89c1140e659ab2140bdfbc323)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 74ef1fcb47..9de67e5ad7 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -557,7 +557,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 	case LDAP_RES_SEARCH_REFERENCE:
 		if (ldap_parse_result(lldb->ldap, result, &handle->status,
 					&matcheddnp, &errmsgp,
-					&referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
+					&referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
 			ret = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
 		}
@@ -581,7 +581,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 	case LDAP_RES_SEARCH_RESULT:
 		if (ldap_parse_result(lldb->ldap, result, &handle->status,
 					&matcheddnp, &errmsgp,
-					&referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
+					&referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
 			handle->status = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
 		}
@@ -609,7 +609,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 	case LDAP_RES_MODDN:
 		if (ldap_parse_result(lldb->ldap, result, &handle->status,
 					&matcheddnp, &errmsgp,
-					&referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
+					&referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
 			handle->status = LDB_ERR_OPERATIONS_ERROR;
 			goto error;
 		}
-- 
cgit 


From bf86ece6cb9ff38bd08fb39988d9dc7577ea3f99 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 30 Sep 2006 07:54:20 +0000
Subject: r19009: ensure that data values from ldap libs are null terminated,
 to allow ldb_msg_find_attr_as_string() to work correctly.

Thanks to Jim Myers for spotting this!
(This used to be commit b2076c1a7e4b70644b59689ce46952ef940be6b0)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 9de67e5ad7..10563816b9 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -210,10 +210,15 @@ static int lldb_add_msg_attr(struct ldb_context *ldb,
 	}
 
 	for (i=0;i<count;i++) {
-		el->values[i].data = talloc_memdup(el->values, bval[i]->bv_val, bval[i]->bv_len);
+		/* we have to ensure this is null terminated so that
+		   ldb_msg_find_attr_as_string() can work */
+		el->values[i].data = talloc_size(el->values, bval[i]->bv_len+1);
 		if (!el->values[i].data) {
+			errno = ENOMEM;
 			return -1;
 		}
+		memcpy(el->values[i].data, bval[i]->bv_val, bval[i]->bv_len);
+		el->values[i].data[bval[i]->bv_len] = 0;
 		el->values[i].length = bval[i]->bv_len;
 		el->num_values++;
 	}
-- 
cgit 


From 2ad8e1443de55a005cb9249ba317ab8541ec7c90 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 14 Oct 2006 04:43:51 +0000
Subject: r19273: - fixed error handling with the ldap backend

- propogate errors to the ldbadd command line tool

- use the rdn_name module when testing the tdb backend to allow the
  same test code to correctly test the ldap and non-ldap backends
(This used to be commit dd82c474a123d90329bda653a4cb73c93e087b15)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 10563816b9..a34e35c6db 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -497,9 +497,11 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 	char **referralsp = NULL;
 	LDAPControl **serverctrlsp = NULL;
 	int ret = LDB_SUCCESS;
-
+	
 	type = ldap_msgtype(result);
 
+	handle->status = 0;
+
 	switch (type) {
 
 	case LDAP_RES_SEARCH_ENTRY:
@@ -631,15 +633,19 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 	}
 
 	if (matcheddnp) ldap_memfree(matcheddnp);
-	if (errmsgp) {
+	if (errmsgp && *errmsgp) {
 		ldb_set_errstring(ac->module->ldb, errmsgp);
+	} else if (handle->status) {
+		ldb_set_errstring(ac->module->ldb, ldap_err2string(handle->status));
+	}
+	if (errmsgp) {
 		ldap_memfree(errmsgp);
 	}
 	if (referralsp) ldap_value_free(referralsp);
 	if (serverctrlsp) ldap_controls_free(serverctrlsp);
 
 	ldap_msgfree(result);
-	return ret;
+	return lldb_ldap_to_ldb(handle->status);
 
 error:
 	handle->state = LDB_ASYNC_DONE;
-- 
cgit 


From e36ea2e8ebe44079dd3989694f0235e77caf4fe2 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 17 Oct 2006 01:21:02 +0000
Subject: r19362: - don't need to store the baseinfo message after cache load

- set better names on talloc structures in ldb modules, making leaks
  easier to track down
(This used to be commit 3bf76db42dc6dde5d71083216dba819869b31c75)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index a34e35c6db..410ad64b4a 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -822,6 +822,7 @@ static int lldb_connect(struct ldb_context *ldb,
 		talloc_free(lldb);
 		return -1;
 	}
+	talloc_set_name_const(*module, "ldb_ldap backend");
 	(*module)->ldb = ldb;
 	(*module)->prev = (*module)->next = NULL;
 	(*module)->private_data = lldb;
-- 
cgit 


From 3cee746a3f23f1040daa60d1208145bff87b3d01 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Tue, 24 Oct 2006 20:15:13 +0000
Subject: r19485: Fix Coverity # 319 (This used to be commit
 d12bdb6133c1612b9d3e1a0c6692cbc4ab17fe32)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 410ad64b4a..a17e80cde0 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -817,7 +817,7 @@ static int lldb_connect(struct ldb_context *ldb,
 	}
 
 	*module = talloc(ldb, struct ldb_module);
-	if (!module) {
+	if (*module == NULL) {
 		ldb_oom(ldb);
 		talloc_free(lldb);
 		return -1;
-- 
cgit 


From 9ec6f0a3a17093f5c0fdf259ce36830eeccd215a Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 2 Nov 2006 00:32:42 +0000
Subject: r19532: oops forgot this (This used to be commit
 9af225e319838a33141daa450473c157ecd65cd3)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index a17e80cde0..cdc1a500f8 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -463,8 +463,8 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 	}
 
 	newrdn = talloc_asprintf(lldb_ac, "%s=%s",
-				 req->op.rename.newdn->components[0].name,
-				 ldb_dn_escape_value(lldb, req->op.rename.newdn->components[0].value));
+				 ldb_dn_get_rdn_name(req->op.rename.newdn),
+				 ldb_dn_escape_value(lldb, *(ldb_dn_get_rdn_val(req->op.rename.newdn))));
 	if (!newrdn) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-- 
cgit 


From 4889eb9f7aae9349e426d0f6d2217adff67eaebd Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 22 Nov 2006 00:59:34 +0000
Subject: r19831: Big ldb_dn optimization and interfaces enhancement patch

This patch changes a lot of the code in ldb_dn.c, and also
removes and add a number of manipulation functions around.

The aim is to avoid validating a dn if not necessary as the
validation code is necessarily slow. This is mainly to speed up
internal operations where input is not user generated and so we
can assume the DNs need no validation. The code is designed to
keep the data as a string if possible.

The code is not yet 100% perfect, but pass all the tests so far.
A memleak is certainly present, I'll work on that next.

Simo.
(This used to be commit a580c871d3784602a9cce32d33419e63c8236e63)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index cdc1a500f8..ee2d818935 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -527,8 +527,8 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
 			}
-			ares->message->dn = ldb_dn_explode_or_special(ares->message, dn);
-			if (ares->message->dn == NULL) {
+			ares->message->dn = ldb_dn_new(ares->message, ac->module->ldb, dn);
+			if ( ! ldb_dn_validate(ares->message->dn)) {
 				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
 			}
-- 
cgit 


From a9e31b33b55a873c2f01db5e348560176adf863d Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 22 Nov 2006 02:05:19 +0000
Subject: r19832: better prototypes for the linearization functions:

- ldb_dn_get_linearized
  returns a const string

- ldb_dn_alloc_linearized
  allocs astring with the linearized dn
(This used to be commit 3929c086d5d0b3f08b1c4f2f3f9602c3f4a9a4bd)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index ee2d818935..bfae566e3e 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -262,7 +262,7 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 
 	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
-	search_base = ldb_dn_linearize(lldb_ac, req->op.search.base);
+	search_base = ldb_dn_alloc_linearized(lldb_ac, req->op.search.base);
 	if (req->op.search.base == NULL) {
 		search_base = talloc_strdup(lldb_ac, "");
 	}
@@ -335,7 +335,7 @@ static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	dn = ldb_dn_linearize(lldb_ac, req->op.add.message->dn);
+	dn = ldb_dn_alloc_linearized(lldb_ac, req->op.add.message->dn);
 	if (dn == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -380,7 +380,7 @@ static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	dn = ldb_dn_linearize(lldb_ac, req->op.mod.message->dn);
+	dn = ldb_dn_alloc_linearized(lldb_ac, req->op.mod.message->dn);
 	if (dn == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -419,7 +419,7 @@ static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 
 	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
-	dnstr = ldb_dn_linearize(lldb_ac, req->op.del.dn);
+	dnstr = ldb_dn_alloc_linearized(lldb_ac, req->op.del.dn);
 
 	ret = ldap_delete_ext(lldb->ldap, dnstr,
 			      NULL,
@@ -457,7 +457,7 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 
 	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
 
-	old_dn = ldb_dn_linearize(lldb_ac, req->op.rename.olddn);
+	old_dn = ldb_dn_alloc_linearized(lldb_ac, req->op.rename.olddn);
 	if (old_dn == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -469,7 +469,7 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	parentdn = ldb_dn_linearize(lldb_ac, ldb_dn_get_parent(lldb_ac, req->op.rename.newdn));
+	parentdn = ldb_dn_alloc_linearized(lldb_ac, ldb_dn_get_parent(lldb_ac, req->op.rename.newdn));
 	if (!parentdn) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-- 
cgit 


From 43637dfb9dbf44403fc90d56cedbfbf7a5e54bc8 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 12 Dec 2006 18:25:19 +0000
Subject: r20126: fix talloc hierachy and make lldb a child of module

metze
(This used to be commit 1e3bb180261643900c7bdacef818add5349c7a30)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 40 ++++++++++++++++++++-----------------
 1 file changed, 22 insertions(+), 18 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index bfae566e3e..a96a73d02b 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -47,6 +47,7 @@
 
 struct lldb_private {
 	LDAP *ldap;
+	struct ldb_module *module;
 };
 
 struct lldb_context {
@@ -786,19 +787,33 @@ static int lldb_connect(struct ldb_context *ldb,
 			const char *url, 
 			unsigned int flags, 
 			const char *options[],
-			struct ldb_module **module)
+			struct ldb_module **_module)
 {
-	struct lldb_private *lldb = NULL;
+	struct ldb_module *module;
+	struct lldb_private *lldb;
 	int version = 3;
 	int ret;
 
-	lldb = talloc(ldb, struct lldb_private);
+	module = talloc(ldb, struct ldb_module);
+	if (module == NULL) {
+		ldb_oom(ldb);
+		talloc_free(lldb);
+		return -1;
+	}
+	talloc_set_name_const(module, "ldb_ldap backend");
+	module->ldb		= ldb;
+	module->prev		= module->next = NULL;
+	module->private_data	= NULL;
+	module->ops		= &lldb_ops;
+
+	lldb = talloc(module, struct lldb_private);
 	if (!lldb) {
 		ldb_oom(ldb);
 		goto failed;
 	}
-
-	lldb->ldap = NULL;
+	module->private_data	= lldb;
+	lldb->module		= module;
+	lldb->ldap		= NULL;
 
 	ret = ldap_initialize(&lldb->ldap, url);
 	if (ret != LDAP_SUCCESS) {
@@ -816,22 +831,11 @@ static int lldb_connect(struct ldb_context *ldb,
 		goto failed;
 	}
 
-	*module = talloc(ldb, struct ldb_module);
-	if (*module == NULL) {
-		ldb_oom(ldb);
-		talloc_free(lldb);
-		return -1;
-	}
-	talloc_set_name_const(*module, "ldb_ldap backend");
-	(*module)->ldb = ldb;
-	(*module)->prev = (*module)->next = NULL;
-	(*module)->private_data = lldb;
-	(*module)->ops = &lldb_ops;
-
+	*_module = module;
 	return 0;
 
 failed:
-	talloc_free(lldb);
+	talloc_free(module);
 	return -1;
 }
 
-- 
cgit 


From ecc8ef51cbca48fe1e9ccb2069c3aa7c12d1d2b9 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 12 Dec 2006 18:45:12 +0000
Subject: r20127: - allocate ldb_handle under ldb_request! fix a mem leak -
 pass ldb_request to init_lldb_handle() - remove some useless
 talloc_get_type() calls

metze
(This used to be commit a7397c4d2bed181c96863e985727c8dad0894df7)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 80 ++++++++++++++++---------------------
 1 file changed, 35 insertions(+), 45 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index a96a73d02b..bbc1e368a1 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -51,7 +51,8 @@ struct lldb_private {
 };
 
 struct lldb_context {
-	struct ldb_module *module;
+	struct lldb_private *lldb;
+	struct ldb_handle *handle;
 	int msgid;
 	int timeout;
 	time_t starttime;
@@ -64,42 +65,41 @@ static int lldb_ldap_to_ldb(int err) {
 	return err;
 }
 
-static struct ldb_handle *init_handle(struct lldb_private *lldb, struct ldb_module *module,
-					    void *context,
-					    int (*callback)(struct ldb_context *, void *, struct ldb_reply *),
-					    int timeout, time_t starttime)
+static struct lldb_context *init_lldb_handle(struct lldb_private *lldb, struct ldb_request *req)
 {
 	struct lldb_context *ac;
 	struct ldb_handle *h;
 
-	h = talloc_zero(lldb, struct ldb_handle);
+	h = talloc_zero(req, struct ldb_handle);
 	if (h == NULL) {
-		ldb_set_errstring(module->ldb, "Out of Memory");
+		ldb_set_errstring(lldb->module->ldb, "Out of Memory");
 		return NULL;
 	}
 
-	h->module = module;
+	h->module = lldb->module;
 
 	ac = talloc(h, struct lldb_context);
 	if (ac == NULL) {
-		ldb_set_errstring(module->ldb, "Out of Memory");
+		ldb_set_errstring(lldb->module->ldb, "Out of Memory");
 		talloc_free(h);
 		return NULL;
 	}
 
-	h->private_data = (void *)ac;
+	h->private_data = ac;
 
 	h->state = LDB_ASYNC_INIT;
 	h->status = LDB_SUCCESS;
 
-	ac->module = module;
-	ac->context = context;
-	ac->callback = callback;
-	ac->timeout = timeout;
-	ac->starttime = starttime;
+	ac->lldb = lldb;
+	ac->handle = h;
+	ac->context = req->context;
+	ac->callback = req->callback;
+	ac->timeout = req->timeout;
+	ac->starttime = req->starttime;
 	ac->msgid = 0;
 
-	return h;
+	req->handle = h;
+	return ac;
 }
 /*
   convert a ldb_message structure to a list of LDAPMod structures
@@ -256,13 +256,11 @@ static int lldb_search(struct ldb_module *module, struct ldb_request *req)
 		ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
 	}
 
-	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
-	if (req->handle == NULL) {
+	lldb_ac = init_lldb_handle(lldb, req);
+	if (lldb_ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
-
 	search_base = ldb_dn_alloc_linearized(lldb_ac, req->op.search.base);
 	if (req->op.search.base == NULL) {
 		search_base = talloc_strdup(lldb_ac, "");
@@ -324,13 +322,11 @@ static int lldb_add(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
-	if (req->handle == NULL) {
+	lldb_ac = init_lldb_handle(lldb, req);
+	if (lldb_ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
-
 	mods = lldb_msg_to_mods(lldb_ac, req->op.add.message, 0);
 	if (mods == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -369,13 +365,11 @@ static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
+	lldb_ac = init_lldb_handle(lldb, req);
 	if (req->handle == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
-
 	mods = lldb_msg_to_mods(lldb_ac, req->op.mod.message, 1);
 	if (mods == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -413,13 +407,11 @@ static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
-	if (req->handle == NULL) {
+	lldb_ac = init_lldb_handle(lldb, req);
+	if (lldb_ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
-
 	dnstr = ldb_dn_alloc_linearized(lldb_ac, req->op.del.dn);
 
 	ret = ldap_delete_ext(lldb->ldap, dnstr,
@@ -451,13 +443,11 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 
-	req->handle = init_handle(lldb, module, req->context, req->callback, req->timeout, req->starttime);
-	if (req->handle == NULL) {
+	lldb_ac = init_lldb_handle(lldb, req);
+	if (lldb_ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	lldb_ac = talloc_get_type(req->handle->private_data, struct lldb_context);
-
 	old_dn = ldb_dn_alloc_linearized(lldb_ac, req->op.rename.olddn);
 	if (old_dn == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -489,7 +479,7 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 {
 	struct lldb_context *ac = talloc_get_type(handle->private_data, struct lldb_context);
-	struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
+	struct lldb_private *lldb = ac->lldb;
 	struct ldb_reply *ares = NULL;
 	LDAPMessage *msg;
 	int type;
@@ -528,7 +518,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
 			}
-			ares->message->dn = ldb_dn_new(ares->message, ac->module->ldb, dn);
+			ares->message->dn = ldb_dn_new(ares->message, ac->lldb->module->ldb, dn);
 			if ( ! ldb_dn_validate(ares->message->dn)) {
 				ret = LDB_ERR_OPERATIONS_ERROR;
 				goto error;
@@ -547,7 +537,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 				bval = ldap_get_values_len(lldb->ldap, msg, attr);
 
 				if (bval) {
-					lldb_add_msg_attr(ac->module->ldb, ares->message, attr, bval);
+					lldb_add_msg_attr(ac->lldb->module->ldb, ares->message, attr, bval);
 					ldap_value_free_len(bval);
 				}					  
 			}
@@ -555,7 +545,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 
 
 			ares->type = LDB_REPLY_ENTRY;
-			ret = ac->callback(ac->module->ldb, ac->context, ares);
+			ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
 		} else {
 			handle->status = LDB_ERR_PROTOCOL_ERROR;
 			handle->state = LDB_ASYNC_DONE;
@@ -582,7 +572,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 
 		ares->referral = talloc_strdup(ares, *referralsp);
 		ares->type = LDB_REPLY_REFERRAL;
-		ret = ac->callback(ac->module->ldb, ac->context, ares);
+		ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
 
 		break;
 
@@ -607,7 +597,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 		
 		ares->type = LDB_REPLY_DONE;
 		handle->state = LDB_ASYNC_DONE;
-		ret = ac->callback(ac->module->ldb, ac->context, ares);
+		ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
 
 		break;
 
@@ -623,7 +613,7 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 		}
 		if (ac->callback && handle->status == LDB_SUCCESS) {
 			ares = NULL; /* FIXME: build a corresponding ares to pass on */
-			ret = ac->callback(ac->module->ldb, ac->context, ares);
+			ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
 		}
 		handle->state = LDB_ASYNC_DONE;
 		break;
@@ -635,9 +625,9 @@ static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
 
 	if (matcheddnp) ldap_memfree(matcheddnp);
 	if (errmsgp && *errmsgp) {
-		ldb_set_errstring(ac->module->ldb, errmsgp);
+		ldb_set_errstring(ac->lldb->module->ldb, errmsgp);
 	} else if (handle->status) {
-		ldb_set_errstring(ac->module->ldb, ldap_err2string(handle->status));
+		ldb_set_errstring(ac->lldb->module->ldb, ldap_err2string(handle->status));
 	}
 	if (errmsgp) {
 		ldap_memfree(errmsgp);
@@ -657,7 +647,7 @@ error:
 static int lldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 {
 	struct lldb_context *ac = talloc_get_type(handle->private_data, struct lldb_context);
-	struct lldb_private *lldb = talloc_get_type(handle->module->private_data, struct lldb_private);
+	struct lldb_private *lldb = ac->lldb;
 	struct timeval timeout;
 	LDAPMessage *result;
 	int ret, lret;
-- 
cgit 


From 4e93962ea544f2c32077a42071be3176c377b8e9 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 12 Dec 2006 19:02:14 +0000
Subject: r20130: remove one more talloc_get_type()

metze
(This used to be commit 024dacb3b0a32bcaaef0b7a7598070b9034a7648)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index bbc1e368a1..9847ec4273 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -476,9 +476,9 @@ static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
 	return lldb_ldap_to_ldb(ret);
 }
 
-static int lldb_parse_result(struct ldb_handle *handle, LDAPMessage *result)
+static int lldb_parse_result(struct lldb_context *ac, LDAPMessage *result)
 {
-	struct lldb_context *ac = talloc_get_type(handle->private_data, struct lldb_context);
+	struct ldb_handle *handle = ac->handle;
 	struct lldb_private *lldb = ac->lldb;
 	struct ldb_reply *ares = NULL;
 	LDAPMessage *msg;
@@ -683,7 +683,7 @@ static int lldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 			goto done;
 		}
 
-		return lldb_parse_result(handle, result);
+		return lldb_parse_result(ac, result);
 
 	case LDB_WAIT_ALL:
 		timeout.tv_usec = 0;
@@ -706,7 +706,7 @@ static int lldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 				return LDB_ERR_TIME_LIMIT_EXCEEDED;
 			}
 
-			ret = lldb_parse_result(handle, result);
+			ret = lldb_parse_result(ac, result);
 			if (ret != LDB_SUCCESS) {
 				return ret;
 			}
-- 
cgit 


From f4fa06ca00e35a4a6409b778905f951001ac4477 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 15 Dec 2006 21:04:01 +0000
Subject: r20190: fix the ldb_ldap backend

metze
(This used to be commit 6b7eb5d68e769fd5450c5d92c3ece4c471aaeae9)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 9847ec4273..20ad6c46c1 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -527,7 +527,6 @@ static int lldb_parse_result(struct lldb_context *ac, LDAPMessage *result)
 
 			ares->message->num_elements = 0;
 			ares->message->elements = NULL;
-			ares->message->private_data = NULL;
 
 			/* loop over all attributes */
 			for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
-- 
cgit 


From 52fb06edc25e8538c413df1aaabba18c859a00cf Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 5 May 2007 18:50:56 +0000
Subject: r22681: Fix standalone ldb build when parent directory name != ldb.
 (This used to be commit 1093875d59f1ea9b8bd82277d4f9d8366e584952)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 20ad6c46c1..44789b73f8 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -39,8 +39,7 @@
  *    author: Simo Sorce
  */
 
-#include "includes.h"
-#include "ldb/include/includes.h"
+#include "ldb_includes.h"
 
 #define LDAP_DEPRECATED 1
 #include <ldap.h>
-- 
cgit 


From b8d69a7ea2505b706ff7c74d7c97bc89d82dfa07 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 02:46:15 +0000
Subject: r23795: more v2->v3 conversion (This used to be commit
 84b468b2f8f2dffda89593f816e8bc6a8b6d42ac)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 44789b73f8..29655eaf65 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -11,7 +11,7 @@
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+   version 3 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
-- 
cgit 


From 6c973f4e8ccbcb6c9275f8a54e26abb19df7e15a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 03:42:26 +0000
Subject: r23798: updated old Temple Place FSF addresses to new URL (This used
 to be commit 40c0919aaa9c1b14bbaebb95ecce53eb0380fdbb)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 29655eaf65..d897350c2f 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -19,8 +19,7 @@
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
-   License along with this library; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
 /*
-- 
cgit 


From 39a817d310964f8e9a63cfb096b3ad24fa03bd5e Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 20 Feb 2008 04:33:43 +0100
Subject: Fix use of some modules (needed _PUBLIC_). (This used to be commit
 ce332130ea77159832da23bab760fa26921719e2)

---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index d897350c2f..3f6ff3fd5b 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -826,9 +826,17 @@ failed:
 	return -1;
 }
 
-int ldb_ldap_init(void)
-{
-	return ldb_register_backend("ldap", lldb_connect) +
-		   ldb_register_backend("ldapi", lldb_connect) + 
-		   ldb_register_backend("ldaps", lldb_connect);
-}
+_PUBLIC_ struct ldb_backend_ops ldb_ldap_backend_ops = {
+	.name = "ldap",
+	.connect_fn = lldb_connect
+};
+
+_PUBLIC_ struct ldb_backend_ops ldb_ldapi_backend_ops = {
+	.name = "ldapi",
+	.connect_fn = lldb_connect
+};
+
+_PUBLIC_ struct ldb_backend_ops ldb_ldaps_backend_ops = {
+	.name = "ldaps",
+	.connect_fn = lldb_connect
+};
-- 
cgit 


From 92f6333535a57c034e2ceb3305b420c921a48094 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Mar 2008 14:29:13 +0100
Subject: ldb: fix the standalone build

metze
(This used to be commit 91b49365abed6f67e2b3c18b0090b4e6ff1df935)
---
 source4/lib/ldb/ldb_ldap/ldb_ldap.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_ldap/ldb_ldap.c')

diff --git a/source4/lib/ldb/ldb_ldap/ldb_ldap.c b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
index 3f6ff3fd5b..a4534c549a 100644
--- a/source4/lib/ldb/ldb_ldap/ldb_ldap.c
+++ b/source4/lib/ldb/ldb_ldap/ldb_ldap.c
@@ -826,17 +826,17 @@ failed:
 	return -1;
 }
 
-_PUBLIC_ struct ldb_backend_ops ldb_ldap_backend_ops = {
+const struct ldb_backend_ops ldb_ldap_backend_ops = {
 	.name = "ldap",
 	.connect_fn = lldb_connect
 };
 
-_PUBLIC_ struct ldb_backend_ops ldb_ldapi_backend_ops = {
+const struct ldb_backend_ops ldb_ldapi_backend_ops = {
 	.name = "ldapi",
 	.connect_fn = lldb_connect
 };
 
-_PUBLIC_ struct ldb_backend_ops ldb_ldaps_backend_ops = {
+const struct ldb_backend_ops ldb_ldaps_backend_ops = {
 	.name = "ldaps",
 	.connect_fn = lldb_connect
 };
-- 
cgit