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/common/ldb.c | 129 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 source4/lib/ldb/common/ldb.c

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
new file mode 100644
index 0000000000..90b77e1e7f
--- /dev/null
+++ b/source4/lib/ldb/common/ldb.c
@@ -0,0 +1,129 @@
+/* 
+   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 core API
+ *
+ *  Description: core API routines interfacing to ldb backends
+ *
+ *  Author: Andrew Tridgell
+ */
+
+#include "includes.h"
+
+/* 
+ connect to a database. The URL can either be one of the following forms
+   ldb://path
+   ldapi://path
+
+   flags is made up of LDB_FLG_*
+
+   the options are passed uninterpreted to the backend, and are
+   backend specific
+*/
+struct ldb_context *ldb_connect(const char *url, unsigned int flags,
+				const char *options[])
+{
+
+	if (strncmp(url, "tdb:", 4) == 0) {
+		return ltdb_connect(url, flags, options);
+	}
+
+	if (strncmp(url, "ldap", 4) == 0) {
+		return lldb_connect(url, flags, options);
+	}
+
+	errno = EINVAL;
+	return NULL;
+}
+
+/*
+  close the connection to the database
+*/
+int ldb_close(struct ldb_context *ldb)
+{
+	return ldb->ops->close(ldb);
+}
+
+
+/*
+  search the database given a LDAP-like search expression
+
+  return the number of records found, or -1 on error
+*/
+int ldb_search(struct ldb_context *ldb, 
+	       const char *base,
+	       enum ldb_scope scope,
+	       const char *expression,
+	       const char *attrs[], struct ldb_message ***res)
+{
+	return ldb->ops->search(ldb, base, scope, expression, attrs, res);
+}
+
+/* 
+   free a set of messages returned by ldb_search
+*/
+int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
+{
+	return ldb->ops->search_free(ldb, msgs);
+}
+
+
+/*
+  add a record to the database. Will fail if a record with the given class and key
+  already exists
+*/
+int ldb_add(struct ldb_context *ldb, 
+	    const struct ldb_message *message)
+{
+	return ldb->ops->add(ldb, message);
+}
+
+/*
+  modify the specified attributes of a record
+*/
+int ldb_modify(struct ldb_context *ldb, 
+	       const struct ldb_message *message)
+{
+	return ldb->ops->modify(ldb, message);
+}
+
+
+/*
+  delete a record from the database
+*/
+int ldb_delete(struct ldb_context *ldb, const char *dn)
+{
+	return ldb->ops->delete(ldb, dn);
+}
+
+/*
+  return extended error information 
+*/
+const char *ldb_errstring(struct ldb_context *ldb)
+{
+	return ldb->ops->errstring(ldb);
+}
-- 
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/common/ldb.c | 2 ++
 1 file changed, 2 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 90b77e1e7f..3ba4434e07 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -52,9 +52,11 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 		return ltdb_connect(url, flags, options);
 	}
 
+#ifdef HAVE_LDAP
 	if (strncmp(url, "ldap", 4) == 0) {
 		return lldb_connect(url, flags, options);
 	}
+#endif /*HAVE_LDAP*/
 
 	errno = EINVAL;
 	return NULL;
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 3ba4434e07..146745043f 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -80,7 +80,7 @@ int ldb_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)
 {
 	return ldb->ops->search(ldb, base, scope, expression, attrs, res);
 }
-- 
cgit 


From 27db4c6d18b31c2e70211efe3c26816cd5d38b24 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 11 Apr 2004 01:26:53 +0000
Subject: r158: cope with or without LDAP in samba build of ldb (This used to
 be commit e776ce4f9e6fead235b3cec86d85eb95704f10ef)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 146745043f..e84473efab 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -52,11 +52,11 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 		return ltdb_connect(url, flags, options);
 	}
 
-#ifdef HAVE_LDAP
+#if HAVE_LDAP
 	if (strncmp(url, "ldap", 4) == 0) {
 		return lldb_connect(url, flags, options);
 	}
-#endif /*HAVE_LDAP*/
+#endif
 
 	errno = EINVAL;
 	return NULL;
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index e84473efab..66d3696786 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -119,7 +119,7 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const char *dn)
 {
-	return ldb->ops->delete(ldb, dn);
+	return ldb->ops->delete_record(ldb, dn);
 }
 
 /*
-- 
cgit 


From a00c266702ca81a3689996198590b5b69a967940 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 28 Apr 2004 13:06:25 +0000
Subject: r387: more C++ friendly changes (This used to be commit
 ac0c525a8b8a05cc275fb9f4c1dcfd749604c85f)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 66d3696786..f61ddecdc7 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -101,7 +101,7 @@ int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	return ldb->ops->add(ldb, message);
+	return ldb->ops->add_record(ldb, message);
 }
 
 /*
@@ -110,7 +110,7 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	return ldb->ops->modify(ldb, message);
+	return ldb->ops->modify_record(ldb, message);
 }
 
 
-- 
cgit 


From b96695ca23f8d1d95ed2e038ea66e6a0580356c3 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 3 May 2004 09:34:18 +0000
Subject: r454: allow a non-URL form of a filename to be used in ldb_connect().
 This makes it a little easier to work with the ldb tools (This used to be
 commit 03df31cef025b2087531579437d6bae1ec36e82f)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index f61ddecdc7..ac77f306e9 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -48,7 +48,8 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 				const char *options[])
 {
 
-	if (strncmp(url, "tdb:", 4) == 0) {
+	if (strncmp(url, "tdb:", 4) == 0 ||
+	    strchr(url, ':') == NULL) {
 		return ltdb_connect(url, flags, options);
 	}
 
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ac77f306e9..ce21d1d9e2 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -81,7 +81,7 @@ int ldb_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)
 {
 	return ldb->ops->search(ldb, base, scope, expression, attrs, res);
 }
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ce21d1d9e2..86d0dd9e9b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -81,7 +81,7 @@ int ldb_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)
 {
 	return ldb->ops->search(ldb, base, scope, expression, attrs, res);
 }
-- 
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/common/ldb.c | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 86d0dd9e9b..b8f61e017a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -68,6 +68,7 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 */
 int ldb_close(struct ldb_context *ldb)
 {
+	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_close");
 	return ldb->ops->close(ldb);
 }
 
@@ -83,7 +84,12 @@ int ldb_search(struct ldb_context *ldb,
 	       const char *expression,
 	       char * const *attrs, struct ldb_message ***res)
 {
-	return ldb->ops->search(ldb, base, scope, expression, attrs, res);
+	int ret;
+	ret = ldb->ops->search(ldb, base, scope, expression, attrs, res);
+
+	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_search(%s) -> %d records\n", 
+		  expression, ret);
+	return ret;
 }
 
 /* 
@@ -102,7 +108,10 @@ int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	return ldb->ops->add_record(ldb, message);
+	int ret;
+	ret = ldb->ops->add_record(ldb, message);
+	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_add(%s) -> %d\n", message->dn, ret);
+	return ret;
 }
 
 /*
@@ -111,7 +120,11 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	return ldb->ops->modify_record(ldb, message);
+	int ret;
+	ret = ldb->ops->modify_record(ldb, message);
+	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_modify(%s) -> %d\n", 
+		  message->dn, ret);
+	return ret;
 }
 
 
@@ -120,7 +133,10 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const char *dn)
 {
-	return ldb->ops->delete_record(ldb, dn);
+	int ret;
+	ret = ldb->ops->delete_record(ldb, dn);
+	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_delete(%s) -> %d\n", dn, ret);
+	return ret;
 }
 
 /*
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index b8f61e017a..c6e8d37671 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -82,7 +82,7 @@ int ldb_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)
 {
 	int ret;
 	ret = ldb->ops->search(ldb, base, scope, expression, attrs, res);
-- 
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/common/ldb.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index c6e8d37671..fa4a64c19d 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -139,6 +139,17 @@ int ldb_delete(struct ldb_context *ldb, const char *dn)
 	return ret;
 }
 
+/*
+  rename a record in the database
+*/
+int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
+{
+	int ret;
+	ret = ldb->ops->rename_record(ldb, olddn, newdn);
+	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_rename(%s,%s) -> %d\n", olddn, newdn);
+	return ret;
+}
+
 /*
   return extended error information 
 */
-- 
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/common/ldb.c | 56 ++++++++++++++++++++------------------------
 1 file changed, 25 insertions(+), 31 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index fa4a64c19d..4fe2088daf 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -47,20 +47,32 @@
 struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 				const char *options[])
 {
+	struct ldb_context *ldb_ctx = NULL;
 
 	if (strncmp(url, "tdb:", 4) == 0 ||
 	    strchr(url, ':') == NULL) {
-		return ltdb_connect(url, flags, options);
+		ldb_ctx = ltdb_connect(url, flags, options);
 	}
 
 #if HAVE_LDAP
 	if (strncmp(url, "ldap", 4) == 0) {
-		return lldb_connect(url, flags, options);
+		ldb_ctx = lldb_connect(url, flags, options);
 	}
 #endif
 
-	errno = EINVAL;
-	return NULL;
+
+	if (!ldb_ctx) {
+		errno = EINVAL;
+		return NULL;
+	}
+
+	if (ldb_load_modules(ldb_ctx, options) != 0) {
+		ldb_close(ldb_ctx);
+		errno = EINVAL;
+		return NULL;
+	}
+
+	return ldb_ctx;
 }
 
 /*
@@ -68,8 +80,7 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 */
 int ldb_close(struct ldb_context *ldb)
 {
-	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_close");
-	return ldb->ops->close(ldb);
+	return ldb->modules->ops->close(ldb->modules);
 }
 
 
@@ -84,12 +95,7 @@ int ldb_search(struct ldb_context *ldb,
 	       const char *expression,
 	       const char * const *attrs, struct ldb_message ***res)
 {
-	int ret;
-	ret = ldb->ops->search(ldb, base, scope, expression, attrs, res);
-
-	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_search(%s) -> %d records\n", 
-		  expression, ret);
-	return ret;
+	return ldb->modules->ops->search(ldb->modules, base, scope, expression, attrs, res);
 }
 
 /* 
@@ -97,7 +103,7 @@ int ldb_search(struct ldb_context *ldb,
 */
 int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
 {
-	return ldb->ops->search_free(ldb, msgs);
+	return ldb->modules->ops->search_free(ldb->modules, msgs);
 }
 
 
@@ -108,10 +114,7 @@ int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	int ret;
-	ret = ldb->ops->add_record(ldb, message);
-	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_add(%s) -> %d\n", message->dn, ret);
-	return ret;
+	return ldb->modules->ops->add_record(ldb->modules, message);
 }
 
 /*
@@ -120,11 +123,7 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	int ret;
-	ret = ldb->ops->modify_record(ldb, message);
-	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_modify(%s) -> %d\n", 
-		  message->dn, ret);
-	return ret;
+	return ldb->modules->ops->modify_record(ldb->modules, message);
 }
 
 
@@ -133,10 +132,7 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const char *dn)
 {
-	int ret;
-	ret = ldb->ops->delete_record(ldb, dn);
-	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_delete(%s) -> %d\n", dn, ret);
-	return ret;
+	return ldb->modules->ops->delete_record(ldb->modules, dn);
 }
 
 /*
@@ -144,10 +140,7 @@ int ldb_delete(struct ldb_context *ldb, const char *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
 {
-	int ret;
-	ret = ldb->ops->rename_record(ldb, olddn, newdn);
-	ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_rename(%s,%s) -> %d\n", olddn, newdn);
-	return ret;
+	return ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
 }
 
 /*
@@ -155,5 +148,6 @@ int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
 */
 const char *ldb_errstring(struct ldb_context *ldb)
 {
-	return ldb->ops->errstring(ldb);
+	return ldb->modules->ops->errstring(ldb->modules);
 }
+
-- 
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/common/ldb.c | 2 ++
 1 file changed, 2 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 4fe2088daf..0fb371011f 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -33,6 +33,8 @@
  */
 
 #include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
 
 /* 
  connect to a database. The URL can either be one of the following forms
-- 
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/common/ldb.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 0fb371011f..40616c5963 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -69,7 +69,7 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 	}
 
 	if (ldb_load_modules(ldb_ctx, options) != 0) {
-		ldb_close(ldb_ctx);
+		talloc_free(ldb_ctx);
 		errno = EINVAL;
 		return NULL;
 	}
@@ -77,15 +77,6 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 	return ldb_ctx;
 }
 
-/*
-  close the connection to the database
-*/
-int ldb_close(struct ldb_context *ldb)
-{
-	return ldb->modules->ops->close(ldb->modules);
-}
-
-
 /*
   search the database given a LDAP-like search expression
 
-- 
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/common/ldb.c | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 40616c5963..600c7063f0 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -81,6 +81,9 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
   search the database given a LDAP-like search expression
 
   return the number of records found, or -1 on error
+
+  Use talloc_free to free the ldb_message returned in 'res'
+
 */
 int ldb_search(struct ldb_context *ldb, 
 	       const char *base,
@@ -91,15 +94,6 @@ int ldb_search(struct ldb_context *ldb,
 	return ldb->modules->ops->search(ldb->modules, base, scope, expression, attrs, res);
 }
 
-/* 
-   free a set of messages returned by ldb_search
-*/
-int ldb_search_free(struct ldb_context *ldb, struct ldb_message **msgs)
-{
-	return ldb->modules->ops->search_free(ldb->modules, msgs);
-}
-
-
 /*
   add a record to the database. Will fail if a record with the given class and key
   already exists
-- 
cgit 


From a1ba224107fbcf6f8a9a3091f42cde2a0c47f85e Mon Sep 17 00:00:00 2001
From: Derrell Lipman <derrell@samba.org>
Date: Sat, 4 Jun 2005 17:13:43 +0000
Subject: r7276: - moved static tdb function ltdb_dn_fold() into common/ so
 that it can be   called from multiple backends.  (ldb_sqlite3 needs it too.) 
 Added parameter   for a callback function that determines whether an
 attribute needs case   folding. - begin to prepare for sqlite3 in build
 process - work-in-progress updates, on ldb_sqlite3 (This used to be commit
 a80bced0b96ffb655559a43cf7f4d7a34deb5a7d)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 600c7063f0..649b0a0f24 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -62,6 +62,12 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 	}
 #endif
 
+#if HAVE_SQLITE3
+	if (strncmp(url, "sqlite:", 7) == 0) {
+		ldb_ctx = lsqlite3_connect(url, flags, options);
+	}
+#endif
+
 
 	if (!ldb_ctx) {
 		errno = EINVAL;
-- 
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/common/ldb.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 649b0a0f24..f5c6d551ea 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -100,6 +100,23 @@ int ldb_search(struct ldb_context *ldb,
 	return ldb->modules->ops->search(ldb->modules, base, scope, expression, attrs, res);
 }
 
+/*
+  search the database given a LDAP-like search expression
+
+  return the number of records found, or -1 on error
+
+  Use talloc_free to free the ldb_message returned in 'res'
+
+*/
+int ldb_search_bytree(struct ldb_context *ldb, 
+		      const char *base,
+		      enum ldb_scope scope,
+		      struct ldb_parse_tree *tree,
+		      const char * const *attrs, struct ldb_message ***res)
+{
+	return ldb->modules->ops->search_bytree(ldb->modules, base, scope, tree, attrs, res);
+}
+
 /*
   add a record to the database. Will fail if a record with the given class and key
   already exists
-- 
cgit 


From 03b0f279ed7d1ed7083e0c2301af94ff39f0e8a4 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 17 Jun 2005 02:47:26 +0000
Subject: r7667: added a ldb ildap backend, using our internal ldap client
 library. Next step is to remove the check for the ldap libraries in configure
 (This used to be commit 74841dbb2a86bb1c584b5c26c4cd24a818a65a34)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index f5c6d551ea..2d0d09de3e 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -56,7 +56,11 @@ struct ldb_context *ldb_connect(const char *url, unsigned int flags,
 		ldb_ctx = ltdb_connect(url, flags, options);
 	}
 
-#if HAVE_LDAP
+#if HAVE_ILDAP
+	if (strncmp(url, "ldap", 4) == 0) {
+		ldb_ctx = ildb_connect(url, flags, options);
+	}
+#elif HAVE_LDAP
 	if (strncmp(url, "ldap", 4) == 0) {
 		ldb_ctx = lldb_connect(url, flags, options);
 	}
-- 
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/common/ldb.c | 48 ++++++++++++++++++++++++++------------------
 1 file changed, 29 insertions(+), 19 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 2d0d09de3e..d2dbac95ea 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -36,6 +36,16 @@
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_private.h"
 
+/* 
+   initialise a ldb context
+   The mem_ctx is optional
+*/
+struct ldb_context *ldb_init(void *mem_ctx)
+{
+	struct ldb_context *ldb = talloc_zero(mem_ctx, struct ldb_context);
+	return ldb;
+}
+
 /* 
  connect to a database. The URL can either be one of the following forms
    ldb://path
@@ -46,45 +56,45 @@
    the options are passed uninterpreted to the backend, and are
    backend specific
 */
-struct ldb_context *ldb_connect(const char *url, unsigned int flags,
-				const char *options[])
+int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[])
 {
-	struct ldb_context *ldb_ctx = NULL;
+	int ret;
 
 	if (strncmp(url, "tdb:", 4) == 0 ||
 	    strchr(url, ':') == NULL) {
-		ldb_ctx = ltdb_connect(url, flags, options);
+		ret = ltdb_connect(ldb, url, flags, options);
 	}
 
 #if HAVE_ILDAP
-	if (strncmp(url, "ldap", 4) == 0) {
-		ldb_ctx = ildb_connect(url, flags, options);
+	else if (strncmp(url, "ldap", 4) == 0) {
+		ret = ildb_connect(ldb, url, flags, options);
 	}
 #elif HAVE_LDAP
-	if (strncmp(url, "ldap", 4) == 0) {
-		ldb_ctx = lldb_connect(url, flags, options);
+	else if (strncmp(url, "ldap", 4) == 0) {
+		ret = lldb_connect(ldb, url, flags, options);
 	}
 #endif
-
 #if HAVE_SQLITE3
-	if (strncmp(url, "sqlite:", 7) == 0) {
+	else if (strncmp(url, "sqlite:", 7) == 0) {
 		ldb_ctx = lsqlite3_connect(url, flags, options);
 	}
 #endif
+	else {
+		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to find backend for '%s'", url);
+		return -1;
+	}
 
-
-	if (!ldb_ctx) {
-		errno = EINVAL;
-		return NULL;
+	if (ret != 0) {
+		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'", url);
+		return ret;
 	}
 
-	if (ldb_load_modules(ldb_ctx, options) != 0) {
-		talloc_free(ldb_ctx);
-		errno = EINVAL;
-		return NULL;
+	if (ldb_load_modules(ldb, options) != 0) {
+		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for '%s'", url);
+		return -1;
 	}
 
-	return ldb_ctx;
+	return 0;
 }
 
 /*
-- 
cgit 


From 1601b8e9f9eecd59f82a2a18cd87438be41c611b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 19 Jun 2005 13:29:07 +0000
Subject: r7759: allow ldb_errstring() to be used when not connected (This used
 to be commit 818ae965afad37216d804aa630359d875794612e)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index d2dbac95ea..450fa75d8e 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -172,6 +172,9 @@ int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
 */
 const char *ldb_errstring(struct ldb_context *ldb)
 {
+	if (ldb->modules == NULL) {
+		return "ldb not connected";
+	}
 	return ldb->modules->ops->errstring(ldb->modules);
 }
 
-- 
cgit 


From bd7a474b1967423711ff93c0080ce0f89270e3f9 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 20 Jun 2005 04:56:43 +0000
Subject: r7776: add a method for getting arbitrary opaque data into a ldb
 context, for use by backends. Currently only EventContext is used in this
 way. (This used to be commit 9fa21b245843371f7777682ee4e5b98e2925b4d0)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 450fa75d8e..e268a8d0d7 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -178,3 +178,34 @@ const char *ldb_errstring(struct ldb_context *ldb)
 	return ldb->modules->ops->errstring(ldb->modules);
 }
 
+
+/*
+  set backend specific opaque parameters
+*/
+int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value)
+{
+	struct ldb_opaque *o = talloc(ldb, struct ldb_opaque);
+	if (o == NULL) {
+		ldb_oom(ldb);
+		return -1;
+	}
+	o->next = ldb->opaque;
+	o->name = name;
+	o->value = value;
+	ldb->opaque = o;
+	return 0;
+}
+
+/*
+  get a previously set opaque value
+*/
+void *ldb_get_opaque(struct ldb_context *ldb, const char *name)
+{
+	struct ldb_opaque *o;
+	for (o=ldb->opaque;o;o=o->next) {
+		if (strcmp(o->name, name) == 0) {
+			return o->value;
+		}
+	}
+	return NULL;
+}
-- 
cgit 


From fdc0450db25021eddcc65d032fd3fd8ca5976928 Mon Sep 17 00:00:00 2001
From: Derrell Lipman <derrell@samba.org>
Date: Wed, 22 Jun 2005 02:39:07 +0000
Subject: r7828: Although there is still plenty to do, ldb_sqlite3 now passes
 the set of tests in tests/test-sqlite3.sh (tests/test-generic.sh).

There are lots of optimizations still TBD, and some things are REALLY slow
right now (e.g. each add() operation takes 1/3 - 1/2 second) but it's ready for
interested parties to poke it and prod it and see how (un)reasonable it is.
Play away.

Still to be implemented or improved:
 - tdb specials (@MODULES, @SUBCLASSES, etc.)
 - all DNs are case-folded in their entirty right now (since doing otherwise
   would require @ATTRIBUTES to be implemented)
 - speed improvements and optimizations.  I am quite confident that the
   excessively slow add() operation can be much improved, and other areas
   can be somewhat improved.
(This used to be commit 1dd865005594671e7effe06fb088fa97fa08de0b)
---
 source4/lib/ldb/common/ldb.c | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index e268a8d0d7..63526dfe2e 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -76,7 +76,7 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 #endif
 #if HAVE_SQLITE3
 	else if (strncmp(url, "sqlite:", 7) == 0) {
-		ldb_ctx = lsqlite3_connect(url, flags, options);
+                ret = lsqlite3_connect(ldb, url, flags, options);
 	}
 #endif
 	else {
@@ -167,6 +167,22 @@ int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
 	return ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
 }
 
+/*
+  create a named lock
+*/
+int ldb_lock(struct ldb_context *ldb, const char *lockname)
+{
+        return ldb->modules->ops->named_lock(ldb->modules, lockname);
+}
+
+/*
+  release a named lock
+*/
+int ldb_unlock(struct ldb_context *ldb, const char *lockname)
+{
+        return ldb->modules->ops->named_unlock(ldb->modules, lockname);
+}
+
 /*
   return extended error information 
 */
-- 
cgit 


From a06d66a3a669c3a0a0f816438e2b3e91e208f398 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 1 Jul 2005 06:21:26 +0000
Subject: r8037: a fairly major update to the internals of ldb. Changes are:

 - moved the knowledge of attribute types out of ldb_tdb and into the
   generic ldb code. This allows the ldb_match() message match logic
   to be generic, so it can be used by other backend

 - added the generic ability to load attribute handlers, for
   canonicalisation, compare, ldif read and ldif write. In the future
   this will be used by the schema module to allow us to correctly
   obey the attributetype schema elements

 - added attribute handlers for some of the core ldap attribute types,
   Integer, DirectoryString, DN, ObjectClass etc

 - added automatic registration of attribute handlers for well-known
   attribute names 'cn', 'dc', 'dn', 'ou' and 'objectClass'

 - converted the objectSid special handlers for Samba to the new system

 - added more correct handling of indexing in tdb backend based on the
   attribute canonicalisation function

 - added generic support for subclasses, moving it out of the tdb
   backend. This will be used in future by the schema module

 - fixed several bugs in the dn_explode code. It still needs more
   work, but doesn't corrupt ldb dbs any more.
(This used to be commit 944c5844ab441b96d8e5d7b2d151982139d1fab9)
---
 source4/lib/ldb/common/ldb.c | 8 ++++++++
 1 file changed, 8 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 63526dfe2e..aa5b58c252 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -43,6 +43,14 @@
 struct ldb_context *ldb_init(void *mem_ctx)
 {
 	struct ldb_context *ldb = talloc_zero(mem_ctx, struct ldb_context);
+	int ret;
+
+	ret = ldb_setup_wellknown_attributes(ldb);
+	if (ret != 0) {
+		talloc_free(ldb);
+		return NULL;
+	}
+
 	return ldb;
 }
 
-- 
cgit 


From 3c5675af9340cb66f9d9337d3dc7f82e6ff13e1b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 19 Jul 2005 11:53:25 +0000
Subject: r8600: fixed null termination on some error messages in ldb (This
 used to be commit 326f0ad6fba8d78f104b93b49995e6c24f9493ef)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index aa5b58c252..3a2eb13297 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -88,17 +88,17 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	}
 #endif
 	else {
-		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to find backend for '%s'", url);
+		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to find backend for '%s'\n", url);
 		return -1;
 	}
 
 	if (ret != 0) {
-		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'", url);
+		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'\n", url);
 		return ret;
 	}
 
 	if (ldb_load_modules(ldb, options) != 0) {
-		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for '%s'", url);
+		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for '%s'\n", url);
 		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/common/ldb.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 3a2eb13297..25e7bee66b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -114,7 +114,7 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 
 */
 int ldb_search(struct ldb_context *ldb, 
-	       const char *base,
+	       const struct ldb_dn *base,
 	       enum ldb_scope scope,
 	       const char *expression,
 	       const char * const *attrs, struct ldb_message ***res)
@@ -131,7 +131,7 @@ int ldb_search(struct ldb_context *ldb,
 
 */
 int ldb_search_bytree(struct ldb_context *ldb, 
-		      const char *base,
+		      const struct ldb_dn *base,
 		      enum ldb_scope scope,
 		      struct ldb_parse_tree *tree,
 		      const char * const *attrs, struct ldb_message ***res)
@@ -162,7 +162,7 @@ int ldb_modify(struct ldb_context *ldb,
 /*
   delete a record from the database
 */
-int ldb_delete(struct ldb_context *ldb, const char *dn)
+int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
 	return ldb->modules->ops->delete_record(ldb->modules, dn);
 }
@@ -170,7 +170,7 @@ int ldb_delete(struct ldb_context *ldb, const char *dn)
 /*
   rename a record in the database
 */
-int ldb_rename(struct ldb_context *ldb, const char *olddn, const char *newdn)
+int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
 	return ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
 }
-- 
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/common/ldb.c | 54 ++++++++++++++++++++++++++++----------------
 1 file changed, 35 insertions(+), 19 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 25e7bee66b..ae71f08713 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -105,6 +105,22 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	return 0;
 }
 
+/*
+  start a transaction
+*/
+static int ldb_start_trans(struct ldb_context *ldb)
+{
+        return ldb->modules->ops->start_transaction(ldb->modules);
+}
+
+/*
+  end a transaction
+*/
+static int ldb_end_trans(struct ldb_context *ldb, int status)
+{
+        return ldb->modules->ops->end_transaction(ldb->modules, status);
+}
+
 /*
   search the database given a LDAP-like search expression
 
@@ -146,7 +162,11 @@ int ldb_search_bytree(struct ldb_context *ldb,
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	return ldb->modules->ops->add_record(ldb->modules, message);
+	int status = ldb_start_trans(ldb);
+	if (status != 0) return status;
+
+	status = ldb->modules->ops->add_record(ldb->modules, message);
+	return ldb_end_trans(ldb, status);
 }
 
 /*
@@ -155,7 +175,11 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	return ldb->modules->ops->modify_record(ldb->modules, message);
+	int status = ldb_start_trans(ldb);
+	if (status != 0) return status;
+
+	status = ldb->modules->ops->modify_record(ldb->modules, message);
+	return ldb_end_trans(ldb, status);
 }
 
 
@@ -164,7 +188,11 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
-	return ldb->modules->ops->delete_record(ldb->modules, dn);
+	int status = ldb_start_trans(ldb);
+	if (status != 0) return status;
+
+	status = ldb->modules->ops->delete_record(ldb->modules, dn);
+	return ldb_end_trans(ldb, status);
 }
 
 /*
@@ -172,23 +200,11 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
-	return ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
-}
+	int status = ldb_start_trans(ldb);
+	if (status != 0) return status;
 
-/*
-  create a named lock
-*/
-int ldb_lock(struct ldb_context *ldb, const char *lockname)
-{
-        return ldb->modules->ops->named_lock(ldb->modules, lockname);
-}
-
-/*
-  release a named lock
-*/
-int ldb_unlock(struct ldb_context *ldb, const char *lockname)
-{
-        return ldb->modules->ops->named_unlock(ldb->modules, lockname);
+	status = ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
+	return ldb_end_trans(ldb, status);
 }
 
 /*
-- 
cgit 


From 46a8d809376cab59c579c654b0de5105727a9585 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 18 Sep 2005 10:47:03 +0000
Subject: r10304: check for basic ldb_message sanity and return appropriate
 LDB_ERR_ value (This used to be commit
 610f5646f0816820ac9342e81d46d139e26cc918)

---
 source4/lib/ldb/common/ldb.c | 38 +++++++++++++++++++++++++-------------
 1 file changed, 25 insertions(+), 13 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ae71f08713..57fb5a81da 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.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"
 
 /* 
@@ -89,20 +90,20 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 #endif
 	else {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to find backend for '%s'\n", url);
-		return -1;
+		return LDB_ERR_OTHER;
 	}
 
-	if (ret != 0) {
+	if (ret != LDB_ERR_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'\n", url);
 		return ret;
 	}
 
-	if (ldb_load_modules(ldb, options) != 0) {
+	if (ldb_load_modules(ldb, options) != LDB_ERR_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for '%s'\n", url);
-		return -1;
+		return LDB_ERR_OTHER;
 	}
 
-	return 0;
+	return LDB_ERR_SUCCESS;
 }
 
 /*
@@ -162,8 +163,14 @@ int ldb_search_bytree(struct ldb_context *ldb,
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	int status = ldb_start_trans(ldb);
-	if (status != 0) return status;
+	int status;
+
+
+	status = ldb_msg_sanity_check(message);
+	if (status != LDB_ERR_SUCCESS) return status;
+
+	status = ldb_start_trans(ldb);
+	if (status != LDB_ERR_SUCCESS) return status;
 
 	status = ldb->modules->ops->add_record(ldb->modules, message);
 	return ldb_end_trans(ldb, status);
@@ -175,8 +182,13 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	int status = ldb_start_trans(ldb);
-	if (status != 0) return status;
+	int status;
+
+	status = ldb_msg_sanity_check(message);
+	if (status != LDB_ERR_SUCCESS) return status;
+
+	status = ldb_start_trans(ldb);
+	if (status != LDB_ERR_SUCCESS) return status;
 
 	status = ldb->modules->ops->modify_record(ldb->modules, message);
 	return ldb_end_trans(ldb, status);
@@ -189,7 +201,7 @@ int ldb_modify(struct ldb_context *ldb,
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
 	int status = ldb_start_trans(ldb);
-	if (status != 0) return status;
+	if (status != LDB_ERR_SUCCESS) return status;
 
 	status = ldb->modules->ops->delete_record(ldb->modules, dn);
 	return ldb_end_trans(ldb, status);
@@ -201,7 +213,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
 	int status = ldb_start_trans(ldb);
-	if (status != 0) return status;
+	if (status != LDB_ERR_SUCCESS) return status;
 
 	status = ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
 	return ldb_end_trans(ldb, status);
@@ -227,13 +239,13 @@ int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value)
 	struct ldb_opaque *o = talloc(ldb, struct ldb_opaque);
 	if (o == NULL) {
 		ldb_oom(ldb);
-		return -1;
+		return LDB_ERR_OTHER;
 	}
 	o->next = ldb->opaque;
 	o->name = name;
 	o->value = value;
 	ldb->opaque = o;
-	return 0;
+	return LDB_ERR_SUCCESS;
 }
 
 /*
-- 
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/common/ldb.c | 34 +++++++++++++++++++++++++++++-----
 1 file changed, 29 insertions(+), 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 57fb5a81da..a00c2481d8 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -106,6 +106,14 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	return LDB_ERR_SUCCESS;
 }
 
+static void ldb_reset_err_string(struct ldb_context *ldb)
+{
+	if (ldb->err_string) {
+		talloc_free(ldb->err_string);
+		ldb->err_string = NULL;
+	}
+}
+
 /*
   start a transaction
 */
@@ -136,6 +144,8 @@ int ldb_search(struct ldb_context *ldb,
 	       const char *expression,
 	       const char * const *attrs, struct ldb_message ***res)
 {
+	ldb_reset_err_string(ldb);
+
 	return ldb->modules->ops->search(ldb->modules, base, scope, expression, attrs, res);
 }
 
@@ -153,6 +163,8 @@ int ldb_search_bytree(struct ldb_context *ldb,
 		      struct ldb_parse_tree *tree,
 		      const char * const *attrs, struct ldb_message ***res)
 {
+	ldb_reset_err_string(ldb);
+
 	return ldb->modules->ops->search_bytree(ldb->modules, base, scope, tree, attrs, res);
 }
 
@@ -165,6 +177,7 @@ int ldb_add(struct ldb_context *ldb,
 {
 	int status;
 
+	ldb_reset_err_string(ldb);
 
 	status = ldb_msg_sanity_check(message);
 	if (status != LDB_ERR_SUCCESS) return status;
@@ -184,6 +197,8 @@ int ldb_modify(struct ldb_context *ldb,
 {
 	int status;
 
+	ldb_reset_err_string(ldb);
+
 	status = ldb_msg_sanity_check(message);
 	if (status != LDB_ERR_SUCCESS) return status;
 
@@ -200,7 +215,11 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
-	int status = ldb_start_trans(ldb);
+	int status;
+
+	ldb_reset_err_string(ldb);
+
+	status = ldb_start_trans(ldb);
 	if (status != LDB_ERR_SUCCESS) return status;
 
 	status = ldb->modules->ops->delete_record(ldb->modules, dn);
@@ -212,7 +231,11 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
-	int status = ldb_start_trans(ldb);
+	int status;
+
+	ldb_reset_err_string(ldb);
+
+	status = ldb_start_trans(ldb);
 	if (status != LDB_ERR_SUCCESS) return status;
 
 	status = ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
@@ -224,10 +247,11 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 */
 const char *ldb_errstring(struct ldb_context *ldb)
 {
-	if (ldb->modules == NULL) {
-		return "ldb not connected";
+	if (ldb->err_string) {
+		return ldb->err_string;
 	}
-	return ldb->modules->ops->errstring(ldb->modules);
+
+	return NULL;
 }
 
 
-- 
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/common/ldb.c | 104 ++++++++++++++++++++++++++++++++-----------
 1 file changed, 77 insertions(+), 27 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index a00c2481d8..a743b2f584 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -93,17 +93,17 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 		return LDB_ERR_OTHER;
 	}
 
-	if (ret != LDB_ERR_SUCCESS) {
+	if (ret != LDB_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'\n", url);
 		return ret;
 	}
 
-	if (ldb_load_modules(ldb, options) != LDB_ERR_SUCCESS) {
+	if (ldb_load_modules(ldb, options) != LDB_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for '%s'\n", url);
 		return LDB_ERR_OTHER;
 	}
 
-	return LDB_ERR_SUCCESS;
+	return LDB_SUCCESS;
 }
 
 static void ldb_reset_err_string(struct ldb_context *ldb)
@@ -117,17 +117,45 @@ static void ldb_reset_err_string(struct ldb_context *ldb)
 /*
   start a transaction
 */
-static int ldb_start_trans(struct ldb_context *ldb)
+int ldb_transaction_start(struct ldb_context *ldb)
 {
-        return ldb->modules->ops->start_transaction(ldb->modules);
+	ldb->transaction_active++;
+
+	ldb_reset_err_string(ldb);
+
+	return ldb->modules->ops->start_transaction(ldb->modules);
 }
 
 /*
-  end a transaction
+  commit a transaction
 */
-static int ldb_end_trans(struct ldb_context *ldb, int status)
+int ldb_transaction_commit(struct ldb_context *ldb)
 {
-        return ldb->modules->ops->end_transaction(ldb->modules, status);
+	if (ldb->transaction_active > 0) {
+		ldb->transaction_active--;
+	} else {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ldb_reset_err_string(ldb);
+
+	return ldb->modules->ops->end_transaction(ldb->modules);
+}
+
+/*
+  cancel a transaction
+*/
+int ldb_transaction_cancel(struct ldb_context *ldb)
+{
+	if (ldb->transaction_active > 0) {
+		ldb->transaction_active--;
+	} else {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ldb_reset_err_string(ldb);
+
+	return ldb->modules->ops->del_transaction(ldb->modules);
 }
 
 /*
@@ -180,13 +208,18 @@ int ldb_add(struct ldb_context *ldb,
 	ldb_reset_err_string(ldb);
 
 	status = ldb_msg_sanity_check(message);
-	if (status != LDB_ERR_SUCCESS) return status;
+	if (status != LDB_SUCCESS) return status;
 
-	status = ldb_start_trans(ldb);
-	if (status != LDB_ERR_SUCCESS) return status;
+	if (! ldb->transaction_active) {
+		status = ldb_transaction_start(ldb);
+		if (status != LDB_SUCCESS) return status;
 
-	status = ldb->modules->ops->add_record(ldb->modules, message);
-	return ldb_end_trans(ldb, status);
+		status = ldb->modules->ops->add_record(ldb->modules, message);
+		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		return ldb_transaction_commit(ldb);
+	}
+
+	return ldb->modules->ops->add_record(ldb->modules, message);
 }
 
 /*
@@ -200,13 +233,18 @@ int ldb_modify(struct ldb_context *ldb,
 	ldb_reset_err_string(ldb);
 
 	status = ldb_msg_sanity_check(message);
-	if (status != LDB_ERR_SUCCESS) return status;
+	if (status != LDB_SUCCESS) return status;
+
+	if (! ldb->transaction_active) {
+		status = ldb_transaction_start(ldb);
+		if (status != LDB_SUCCESS) return status;
 
-	status = ldb_start_trans(ldb);
-	if (status != LDB_ERR_SUCCESS) return status;
+		status = ldb->modules->ops->modify_record(ldb->modules, message);
+		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		return ldb_transaction_commit(ldb);
+	}
 
-	status = ldb->modules->ops->modify_record(ldb->modules, message);
-	return ldb_end_trans(ldb, status);
+	return ldb->modules->ops->modify_record(ldb->modules, message);
 }
 
 
@@ -219,11 +257,16 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 
 	ldb_reset_err_string(ldb);
 
-	status = ldb_start_trans(ldb);
-	if (status != LDB_ERR_SUCCESS) return status;
+	if (! ldb->transaction_active) {
+		status = ldb_transaction_start(ldb);
+		if (status != LDB_SUCCESS) return status;
 
-	status = ldb->modules->ops->delete_record(ldb->modules, dn);
-	return ldb_end_trans(ldb, status);
+		status = ldb->modules->ops->delete_record(ldb->modules, dn);
+		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		return ldb_transaction_commit(ldb);
+	}
+
+	return ldb->modules->ops->delete_record(ldb->modules, dn);
 }
 
 /*
@@ -235,13 +278,20 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 
 	ldb_reset_err_string(ldb);
 
-	status = ldb_start_trans(ldb);
-	if (status != LDB_ERR_SUCCESS) return status;
+	if (! ldb->transaction_active) {
+		status = ldb_transaction_start(ldb);
+		if (status != LDB_SUCCESS) return status;
+
+		status = ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
+		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		return ldb_transaction_commit(ldb);
+	}
 
-	status = ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
-	return ldb_end_trans(ldb, status);
+	return ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
 }
 
+
+
 /*
   return extended error information 
 */
@@ -269,7 +319,7 @@ int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value)
 	o->name = name;
 	o->value = value;
 	ldb->opaque = o;
-	return LDB_ERR_SUCCESS;
+	return LDB_SUCCESS;
 }
 
 /*
-- 
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/common/ldb.c | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index a743b2f584..29ee323ad4 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -172,13 +172,23 @@ int ldb_search(struct ldb_context *ldb,
 	       const char *expression,
 	       const char * const *attrs, struct ldb_message ***res)
 {
-	ldb_reset_err_string(ldb);
+	struct ldb_parse_tree *tree;
+	int ret;
+
+	tree = ldb_parse_tree(ldb, expression);
+	if (tree == NULL) {
+		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Unable to parse search expression"));
+		return -1;
+	}
+
+	ret = ldb_search_bytree(ldb, base, scope, tree, attrs, res);
+	talloc_free(tree);
 
-	return ldb->modules->ops->search(ldb->modules, base, scope, expression, attrs, res);
+	return ret;
 }
 
 /*
-  search the database given a LDAP-like search expression
+  search the database given a search tree
 
   return the number of records found, or -1 on error
 
-- 
cgit 


From 78d0e79c9f9263e7f3798aa2e174a347ea1a3df1 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 Oct 2005 06:57:09 +0000
Subject: r10759: make modules easier to write by allowing modules to only
 implement the functions they care about, instead of all functions. This also
 makes it more likely that future changes to ldb will not break existing
 modules (This used to be commit 45f0c967b58e7c1b2e900a4d74cfde2a2c527dfa)

---
 source4/lib/ldb/common/ldb.c | 54 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 42 insertions(+), 12 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 29ee323ad4..725044d3f4 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -114,16 +114,25 @@ static void ldb_reset_err_string(struct ldb_context *ldb)
 	}
 }
 
+#define FIRST_OP(ldb, op) do { \
+	module = ldb->modules; \
+	while (module && module->ops->op == NULL) module = module->next; \
+	if (module == NULL) return -1; \
+} while (0)
+
 /*
   start a transaction
 */
 int ldb_transaction_start(struct ldb_context *ldb)
 {
+	struct ldb_module *module;
+	FIRST_OP(ldb, start_transaction);
+	
 	ldb->transaction_active++;
 
 	ldb_reset_err_string(ldb);
 
-	return ldb->modules->ops->start_transaction(ldb->modules);
+	return module->ops->start_transaction(module);
 }
 
 /*
@@ -131,6 +140,9 @@ int ldb_transaction_start(struct ldb_context *ldb)
 */
 int ldb_transaction_commit(struct ldb_context *ldb)
 {
+	struct ldb_module *module;
+	FIRST_OP(ldb, end_transaction);
+
 	if (ldb->transaction_active > 0) {
 		ldb->transaction_active--;
 	} else {
@@ -139,7 +151,7 @@ int ldb_transaction_commit(struct ldb_context *ldb)
 
 	ldb_reset_err_string(ldb);
 
-	return ldb->modules->ops->end_transaction(ldb->modules);
+	return module->ops->end_transaction(module);
 }
 
 /*
@@ -147,6 +159,9 @@ int ldb_transaction_commit(struct ldb_context *ldb)
 */
 int ldb_transaction_cancel(struct ldb_context *ldb)
 {
+	struct ldb_module *module;
+	FIRST_OP(ldb, del_transaction);
+
 	if (ldb->transaction_active > 0) {
 		ldb->transaction_active--;
 	} else {
@@ -155,7 +170,7 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 
 	ldb_reset_err_string(ldb);
 
-	return ldb->modules->ops->del_transaction(ldb->modules);
+	return module->ops->del_transaction(module);
 }
 
 /*
@@ -201,9 +216,12 @@ int ldb_search_bytree(struct ldb_context *ldb,
 		      struct ldb_parse_tree *tree,
 		      const char * const *attrs, struct ldb_message ***res)
 {
+	struct ldb_module *module;
+	FIRST_OP(ldb, search_bytree);
+
 	ldb_reset_err_string(ldb);
 
-	return ldb->modules->ops->search_bytree(ldb->modules, base, scope, tree, attrs, res);
+	return module->ops->search_bytree(module, base, scope, tree, attrs, res);
 }
 
 /*
@@ -213,8 +231,11 @@ int ldb_search_bytree(struct ldb_context *ldb,
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
+	struct ldb_module *module;
 	int status;
 
+	FIRST_OP(ldb, add_record);
+
 	ldb_reset_err_string(ldb);
 
 	status = ldb_msg_sanity_check(message);
@@ -224,12 +245,12 @@ int ldb_add(struct ldb_context *ldb,
 		status = ldb_transaction_start(ldb);
 		if (status != LDB_SUCCESS) return status;
 
-		status = ldb->modules->ops->add_record(ldb->modules, message);
+		status = module->ops->add_record(module, message);
 		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
 		return ldb_transaction_commit(ldb);
 	}
 
-	return ldb->modules->ops->add_record(ldb->modules, message);
+	return module->ops->add_record(module, message);
 }
 
 /*
@@ -238,8 +259,11 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
+	struct ldb_module *module;
 	int status;
 
+	FIRST_OP(ldb, modify_record);
+
 	ldb_reset_err_string(ldb);
 
 	status = ldb_msg_sanity_check(message);
@@ -249,12 +273,12 @@ int ldb_modify(struct ldb_context *ldb,
 		status = ldb_transaction_start(ldb);
 		if (status != LDB_SUCCESS) return status;
 
-		status = ldb->modules->ops->modify_record(ldb->modules, message);
+		status = module->ops->modify_record(module, message);
 		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
 		return ldb_transaction_commit(ldb);
 	}
 
-	return ldb->modules->ops->modify_record(ldb->modules, message);
+	return module->ops->modify_record(module, message);
 }
 
 
@@ -263,20 +287,23 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
+	struct ldb_module *module;
 	int status;
 
+	FIRST_OP(ldb, delete_record);
+
 	ldb_reset_err_string(ldb);
 
 	if (! ldb->transaction_active) {
 		status = ldb_transaction_start(ldb);
 		if (status != LDB_SUCCESS) return status;
 
-		status = ldb->modules->ops->delete_record(ldb->modules, dn);
+		status = module->ops->delete_record(module, dn);
 		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
 		return ldb_transaction_commit(ldb);
 	}
 
-	return ldb->modules->ops->delete_record(ldb->modules, dn);
+	return module->ops->delete_record(module, dn);
 }
 
 /*
@@ -284,20 +311,23 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
+	struct ldb_module *module;
 	int status;
 
+	FIRST_OP(ldb, rename_record);
+
 	ldb_reset_err_string(ldb);
 
 	if (! ldb->transaction_active) {
 		status = ldb_transaction_start(ldb);
 		if (status != LDB_SUCCESS) return status;
 
-		status = ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
+		status = module->ops->rename_record(module, olddn, newdn);
 		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
 		return ldb_transaction_commit(ldb);
 	}
 
-	return ldb->modules->ops->rename_record(ldb->modules, olddn, newdn);
+	return module->ops->rename_record(module, olddn, newdn);
 }
 
 
-- 
cgit 


From f6a09fb8f81048891da589337d5bdeb3fc9959c7 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 7 Oct 2005 00:40:29 +0000
Subject: r10790: allow updating of existing ldb opaque values (thanks to
 abartlet for spotting this) (This used to be commit
 ef13569ca94da00cc410318e61505e70f3606674)

---
 source4/lib/ldb/common/ldb.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 725044d3f4..d34ddb4c8a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -350,7 +350,17 @@ const char *ldb_errstring(struct ldb_context *ldb)
 */
 int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value)
 {
-	struct ldb_opaque *o = talloc(ldb, struct ldb_opaque);
+	struct ldb_opaque *o;
+
+	/* allow updating an existing value */
+	for (o=ldb->opaque;o;o=o->next) {
+		if (strcmp(o->name, name) == 0) {
+			o->value = value;
+			return LDB_SUCCESS;
+		}
+	}
+
+	o = talloc(ldb, struct ldb_opaque);
 	if (o == NULL) {
 		ldb_oom(ldb);
 		return LDB_ERR_OTHER;
-- 
cgit 


From 84ad5fc9f3d1a4caad749cea84756028f4a649d2 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 17 Oct 2005 11:26:23 +0000
Subject: r11109: fixed the error code return from most ldb functions (the
 change to use ldb_transaction_cancel() broke it) (This used to be commit
 dc41994ea72c7c7f571efa009930cf36d7a9897a)

---
 source4/lib/ldb/common/ldb.c | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index d34ddb4c8a..abd2c03aa3 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -168,8 +168,6 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ldb_reset_err_string(ldb);
-
 	return module->ops->del_transaction(module);
 }
 
@@ -246,7 +244,10 @@ int ldb_add(struct ldb_context *ldb,
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->add_record(module, message);
-		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		if (status != LDB_SUCCESS) {
+			ldb_transaction_cancel(ldb);
+			return status;
+		}
 		return ldb_transaction_commit(ldb);
 	}
 
@@ -274,7 +275,10 @@ int ldb_modify(struct ldb_context *ldb,
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->modify_record(module, message);
-		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		if (status != LDB_SUCCESS) {
+			ldb_transaction_cancel(ldb);
+			return status;
+		}
 		return ldb_transaction_commit(ldb);
 	}
 
@@ -299,7 +303,10 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->delete_record(module, dn);
-		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		if (status != LDB_SUCCESS) {
+			ldb_transaction_cancel(ldb);
+			return status;
+		}
 		return ldb_transaction_commit(ldb);
 	}
 
@@ -323,7 +330,10 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->rename_record(module, olddn, newdn);
-		if (status != LDB_SUCCESS) return ldb_transaction_cancel(ldb);
+		if (status != LDB_SUCCESS) {
+			ldb_transaction_cancel(ldb);
+			return status;
+		}
 		return ldb_transaction_commit(ldb);
 	}
 
-- 
cgit 


From d812957a3162d37ec355b2e2673f3e7297626da7 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 28 Oct 2005 03:43:39 +0000
Subject: r11353: a bit of an improvement to the ldb_tdb error handling (This
 used to be commit 896704f5c139c8bce30dfc898bb3a12be10035ed)

---
 source4/lib/ldb/common/ldb.c | 42 ++++++++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 20 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index abd2c03aa3..791e66ea51 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -222,6 +222,24 @@ int ldb_search_bytree(struct ldb_context *ldb,
 	return module->ops->search_bytree(module, base, scope, tree, attrs, res);
 }
 
+/*
+  check for an error return from an op 
+  if an op fails, but has not setup an error string, then setup one now
+*/
+static int ldb_op_finish(struct ldb_context *ldb, int status)
+{
+	if (status == LDB_SUCCESS) {
+		return ldb_transaction_commit(ldb);
+	}
+	if (ldb->err_string == NULL) {
+		/* no error string was setup by the backend */
+		ldb_set_errstring(ldb->modules, 
+				  talloc_asprintf(ldb, "ldb error %d", status));
+	}
+	ldb_transaction_cancel(ldb);
+	return status;
+}
+
 /*
   add a record to the database. Will fail if a record with the given class and key
   already exists
@@ -244,11 +262,7 @@ int ldb_add(struct ldb_context *ldb,
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->add_record(module, message);
-		if (status != LDB_SUCCESS) {
-			ldb_transaction_cancel(ldb);
-			return status;
-		}
-		return ldb_transaction_commit(ldb);
+		return ldb_op_finish(ldb, status);
 	}
 
 	return module->ops->add_record(module, message);
@@ -275,11 +289,7 @@ int ldb_modify(struct ldb_context *ldb,
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->modify_record(module, message);
-		if (status != LDB_SUCCESS) {
-			ldb_transaction_cancel(ldb);
-			return status;
-		}
-		return ldb_transaction_commit(ldb);
+		return ldb_op_finish(ldb, status);
 	}
 
 	return module->ops->modify_record(module, message);
@@ -303,11 +313,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->delete_record(module, dn);
-		if (status != LDB_SUCCESS) {
-			ldb_transaction_cancel(ldb);
-			return status;
-		}
-		return ldb_transaction_commit(ldb);
+		return ldb_op_finish(ldb, status);
 	}
 
 	return module->ops->delete_record(module, dn);
@@ -330,11 +336,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 		if (status != LDB_SUCCESS) return status;
 
 		status = module->ops->rename_record(module, olddn, newdn);
-		if (status != LDB_SUCCESS) {
-			ldb_transaction_cancel(ldb);
-			return status;
-		}
-		return ldb_transaction_commit(ldb);
+		return ldb_op_finish(ldb, status);
 	}
 
 	return module->ops->rename_record(module, olddn, newdn);
-- 
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/common/ldb.c | 192 ++++++++++++++++++++++---------------------
 1 file changed, 100 insertions(+), 92 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 791e66ea51..48911cad6b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -171,6 +171,52 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 	return module->ops->del_transaction(module);
 }
 
+/*
+  check for an error return from an op 
+  if an op fails, but has not setup an error string, then setup one now
+*/
+static int ldb_op_finish(struct ldb_context *ldb, int status)
+{
+	if (status == LDB_SUCCESS) {
+		return ldb_transaction_commit(ldb);
+	}
+	if (ldb->err_string == NULL) {
+		/* no error string was setup by the backend */
+		ldb_set_errstring(ldb->modules, 
+				  talloc_asprintf(ldb, "ldb error %d", status));
+	}
+	ldb_transaction_cancel(ldb);
+	return status;
+}
+
+/*
+  start an ldb request
+  autostarts a transacion if none active and the operation is not a search
+  returns -1 on errors.
+*/
+
+int ldb_request(struct ldb_context *ldb, struct ldb_request *request)
+{
+	int status;
+
+	ldb_reset_err_string(ldb);
+
+	if ((!ldb->transaction_active) &&
+	    (request->operation == LDB_REQ_ADD ||
+	     request->operation == LDB_REQ_MODIFY ||
+	     request->operation == LDB_REQ_DELETE ||
+	     request->operation == LDB_REQ_RENAME)) {
+
+		status = ldb_transaction_start(ldb);
+		if (status != LDB_SUCCESS) return status;
+
+		status = ldb->modules->ops->request(ldb->modules, request);
+		return ldb_op_finish(ldb, status);
+	}
+
+	return ldb->modules->ops->request(ldb->modules, request);
+}
+
 /*
   search the database given a LDAP-like search expression
 
@@ -183,61 +229,36 @@ int ldb_search(struct ldb_context *ldb,
 	       const struct ldb_dn *base,
 	       enum ldb_scope scope,
 	       const char *expression,
-	       const char * const *attrs, struct ldb_message ***res)
+	       const char * const *attrs, struct ldb_result **res)
 {
+	struct ldb_request *request;
 	struct ldb_parse_tree *tree;
 	int ret;
 
+	request = talloc(ldb, struct ldb_request);
+	if (request == NULL) {
+		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
+		return -1;
+	}
+
 	tree = ldb_parse_tree(ldb, expression);
 	if (tree == NULL) {
 		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Unable to parse search expression"));
 		return -1;
 	}
 
-	ret = ldb_search_bytree(ldb, base, scope, tree, attrs, res);
-	talloc_free(tree);
-
-	return ret;
-}
-
-/*
-  search the database given a search tree
-
-  return the number of records found, or -1 on error
-
-  Use talloc_free to free the ldb_message returned in 'res'
-
-*/
-int ldb_search_bytree(struct ldb_context *ldb, 
-		      const struct ldb_dn *base,
-		      enum ldb_scope scope,
-		      struct ldb_parse_tree *tree,
-		      const char * const *attrs, struct ldb_message ***res)
-{
-	struct ldb_module *module;
-	FIRST_OP(ldb, search_bytree);
+	request->operation = LDB_REQ_SEARCH;
+	request->op.search.base = base;
+	request->op.search.scope = scope;
+	request->op.search.tree = tree;
+	request->op.search.attrs = attrs;
+	request->op.search.res = res;
 
-	ldb_reset_err_string(ldb);
+	ret = ldb_request(ldb, request);
 
-	return module->ops->search_bytree(module, base, scope, tree, attrs, res);
-}
+	talloc_free(tree);
 
-/*
-  check for an error return from an op 
-  if an op fails, but has not setup an error string, then setup one now
-*/
-static int ldb_op_finish(struct ldb_context *ldb, int status)
-{
-	if (status == LDB_SUCCESS) {
-		return ldb_transaction_commit(ldb);
-	}
-	if (ldb->err_string == NULL) {
-		/* no error string was setup by the backend */
-		ldb_set_errstring(ldb->modules, 
-				  talloc_asprintf(ldb, "ldb error %d", status));
-	}
-	ldb_transaction_cancel(ldb);
-	return status;
+	return ret;
 }
 
 /*
@@ -247,25 +268,22 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	struct ldb_module *module;
+	struct ldb_request *request;
 	int status;
 
-	FIRST_OP(ldb, add_record);
-
-	ldb_reset_err_string(ldb);
-
 	status = ldb_msg_sanity_check(message);
 	if (status != LDB_SUCCESS) return status;
 
-	if (! ldb->transaction_active) {
-		status = ldb_transaction_start(ldb);
-		if (status != LDB_SUCCESS) return status;
-
-		status = module->ops->add_record(module, message);
-		return ldb_op_finish(ldb, status);
+	request = talloc(ldb, struct ldb_request);
+	if (request == NULL) {
+		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
+		return -1;
 	}
 
-	return module->ops->add_record(module, message);
+	request->operation = LDB_REQ_ADD;
+	request->op.add.message = message;
+
+	return ldb_request(ldb, request);
 }
 
 /*
@@ -274,25 +292,22 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	struct ldb_module *module;
+	struct ldb_request *request;
 	int status;
 
-	FIRST_OP(ldb, modify_record);
-
-	ldb_reset_err_string(ldb);
-
 	status = ldb_msg_sanity_check(message);
 	if (status != LDB_SUCCESS) return status;
 
-	if (! ldb->transaction_active) {
-		status = ldb_transaction_start(ldb);
-		if (status != LDB_SUCCESS) return status;
-
-		status = module->ops->modify_record(module, message);
-		return ldb_op_finish(ldb, status);
+	request = talloc(ldb, struct ldb_request);
+	if (request == NULL) {
+		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
+		return -1;
 	}
 
-	return module->ops->modify_record(module, message);
+	request->operation = LDB_REQ_MODIFY;
+	request->op.mod.message = message;
+
+	return ldb_request(ldb, request);
 }
 
 
@@ -301,22 +316,18 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
-	struct ldb_module *module;
-	int status;
-
-	FIRST_OP(ldb, delete_record);
-
-	ldb_reset_err_string(ldb);
-
-	if (! ldb->transaction_active) {
-		status = ldb_transaction_start(ldb);
-		if (status != LDB_SUCCESS) return status;
+	struct ldb_request *request;
 
-		status = module->ops->delete_record(module, dn);
-		return ldb_op_finish(ldb, status);
+	request = talloc(ldb, struct ldb_request);
+	if (request == NULL) {
+		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
+		return -1;
 	}
 
-	return module->ops->delete_record(module, dn);
+	request->operation = LDB_REQ_DELETE;
+	request->op.del.dn = dn;
+
+	return ldb_request(ldb, request);
 }
 
 /*
@@ -324,22 +335,19 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
-	struct ldb_module *module;
-	int status;
-
-	FIRST_OP(ldb, rename_record);
-
-	ldb_reset_err_string(ldb);
-
-	if (! ldb->transaction_active) {
-		status = ldb_transaction_start(ldb);
-		if (status != LDB_SUCCESS) return status;
+	struct ldb_request *request;
 
-		status = module->ops->rename_record(module, olddn, newdn);
-		return ldb_op_finish(ldb, status);
+	request = talloc(ldb, struct ldb_request);
+	if (request == NULL) {
+		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
+		return -1;
 	}
 
-	return module->ops->rename_record(module, olddn, newdn);
+	request->operation = LDB_REQ_RENAME;
+	request->op.rename.olddn = olddn;
+	request->op.rename.newdn = newdn;
+
+	return ldb_request(ldb, request);
 }
 
 
-- 
cgit 


From f613e18d1e587782e94ae614a88ee1df4aa0503e Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 9 Nov 2005 08:07:38 +0000
Subject: r11594: ensure ldb_search() sets *res to NULL on failure (some of the
 updated ldb_result code coud rely on that) (This used to be commit
 cd567bcb24125827c746c1c0902631b0e7c2cea5)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 48911cad6b..ea99bf3e8b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -235,6 +235,8 @@ int ldb_search(struct ldb_context *ldb,
 	struct ldb_parse_tree *tree;
 	int ret;
 
+	(*res) = NULL;
+
 	request = talloc(ldb, struct ldb_request);
 	if (request == NULL) {
 		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
-- 
cgit 


From 6eabad9c9d977c1c5c6ecf7494a0be42ad113d23 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 29 Nov 2005 12:34:03 +0000
Subject: r11958: - fixed memory leaks in the ldb_result handling in ldb
 operations

- removed an unnecessary level of pointer in ldb_search structure
(This used to be commit b8d4afb14a18dfd8bac79882a035e74d3ed312bd)
---
 source4/lib/ldb/common/ldb.c | 129 ++++++++++++++++++++++---------------------
 1 file changed, 66 insertions(+), 63 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ea99bf3e8b..3dc62fd4d6 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -192,29 +192,60 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 /*
   start an ldb request
   autostarts a transacion if none active and the operation is not a search
-  returns -1 on errors.
+  returns LDB_ERR_* on errors.
 */
-
 int ldb_request(struct ldb_context *ldb, struct ldb_request *request)
 {
-	int status;
+	int status, started_transaction=0;
+	struct ldb_request *r;
 
 	ldb_reset_err_string(ldb);
 
+	/* to allow ldb modules to assume they can use the request ptr
+	   as a talloc context for the request, we have to copy the 
+	   structure here */
+	r = talloc(ldb, struct ldb_request);
+	if (r == NULL) {
+		ldb_oom(ldb);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	*r = *request;
+
+	if (r->operation == LDB_REQ_SEARCH) {
+		r->op.search.res = NULL;
+	}
+
+	/* start a transaction if needed */
 	if ((!ldb->transaction_active) &&
 	    (request->operation == LDB_REQ_ADD ||
 	     request->operation == LDB_REQ_MODIFY ||
 	     request->operation == LDB_REQ_DELETE ||
 	     request->operation == LDB_REQ_RENAME)) {
-
 		status = ldb_transaction_start(ldb);
-		if (status != LDB_SUCCESS) return status;
+		if (status != LDB_SUCCESS) {
+			talloc_free(r);
+			return status;
+		}
+		started_transaction = 1;
+	}
 
-		status = ldb->modules->ops->request(ldb->modules, request);
+	/* call the first module in the chain */
+	status = ldb->modules->ops->request(ldb->modules, r);
+
+	/* the search call is the only one that returns something
+	   other than a status code. We steal the results into
+	   the context of the ldb before freeing the request */
+	if (request->operation == LDB_REQ_SEARCH) {
+		request->op.search.res = talloc_steal(ldb, r->op.search.res);
+	}
+	talloc_free(r);
+
+	if (started_transaction) {
 		return ldb_op_finish(ldb, status);
 	}
 
-	return ldb->modules->ops->request(ldb->modules, request);
+	return status;
 }
 
 /*
@@ -229,34 +260,30 @@ int ldb_search(struct ldb_context *ldb,
 	       const struct ldb_dn *base,
 	       enum ldb_scope scope,
 	       const char *expression,
-	       const char * const *attrs, struct ldb_result **res)
+	       const char * const *attrs, 
+	       struct ldb_result **res)
 {
-	struct ldb_request *request;
+	struct ldb_request request;
 	struct ldb_parse_tree *tree;
 	int ret;
 
 	(*res) = NULL;
 
-	request = talloc(ldb, struct ldb_request);
-	if (request == NULL) {
-		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
-		return -1;
-	}
-
 	tree = ldb_parse_tree(ldb, expression);
 	if (tree == NULL) {
 		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Unable to parse search expression"));
 		return -1;
 	}
 
-	request->operation = LDB_REQ_SEARCH;
-	request->op.search.base = base;
-	request->op.search.scope = scope;
-	request->op.search.tree = tree;
-	request->op.search.attrs = attrs;
-	request->op.search.res = res;
+	request.operation = LDB_REQ_SEARCH;
+	request.op.search.base = base;
+	request.op.search.scope = scope;
+	request.op.search.tree = tree;
+	request.op.search.attrs = attrs;
+
+	ret = ldb_request(ldb, &request);
 
-	ret = ldb_request(ldb, request);
+	(*res) = request.op.search.res;
 
 	talloc_free(tree);
 
@@ -270,22 +297,16 @@ int ldb_search(struct ldb_context *ldb,
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	struct ldb_request *request;
+	struct ldb_request request;
 	int status;
 
 	status = ldb_msg_sanity_check(message);
 	if (status != LDB_SUCCESS) return status;
 
-	request = talloc(ldb, struct ldb_request);
-	if (request == NULL) {
-		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
-		return -1;
-	}
+	request.operation = LDB_REQ_ADD;
+	request.op.add.message = message;
 
-	request->operation = LDB_REQ_ADD;
-	request->op.add.message = message;
-
-	return ldb_request(ldb, request);
+	return ldb_request(ldb, &request);
 }
 
 /*
@@ -294,22 +315,16 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	struct ldb_request *request;
+	struct ldb_request request;
 	int status;
 
 	status = ldb_msg_sanity_check(message);
 	if (status != LDB_SUCCESS) return status;
 
-	request = talloc(ldb, struct ldb_request);
-	if (request == NULL) {
-		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
-		return -1;
-	}
-
-	request->operation = LDB_REQ_MODIFY;
-	request->op.mod.message = message;
+	request.operation = LDB_REQ_MODIFY;
+	request.op.mod.message = message;
 
-	return ldb_request(ldb, request);
+	return ldb_request(ldb, &request);
 }
 
 
@@ -318,18 +333,12 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
-	struct ldb_request *request;
-
-	request = talloc(ldb, struct ldb_request);
-	if (request == NULL) {
-		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
-		return -1;
-	}
+	struct ldb_request request;
 
-	request->operation = LDB_REQ_DELETE;
-	request->op.del.dn = dn;
+	request.operation = LDB_REQ_DELETE;
+	request.op.del.dn = dn;
 
-	return ldb_request(ldb, request);
+	return ldb_request(ldb, &request);
 }
 
 /*
@@ -337,19 +346,13 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
-	struct ldb_request *request;
-
-	request = talloc(ldb, struct ldb_request);
-	if (request == NULL) {
-		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Not Enough memory"));
-		return -1;
-	}
+	struct ldb_request request;
 
-	request->operation = LDB_REQ_RENAME;
-	request->op.rename.olddn = olddn;
-	request->op.rename.newdn = newdn;
+	request.operation = LDB_REQ_RENAME;
+	request.op.rename.olddn = olddn;
+	request.op.rename.newdn = newdn;
 
-	return ldb_request(ldb, request);
+	return ldb_request(ldb, &request);
 }
 
 
-- 
cgit 


From b1c80c3cfab83bad414b30ca9a7e90a6073152df Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 28 Dec 2005 04:14:58 +0000
Subject: r12534: Make the transaction code fill the error string on failure.

Andrew Bartlett
(This used to be commit 2f54d7f774434f2a8b89ae01e993c4a1d16ce861)
---
 source4/lib/ldb/common/ldb.c | 33 ++++++++++++++++++++++++++++++---
 1 file changed, 30 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 3dc62fd4d6..6095f4fc04 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -126,13 +126,22 @@ static void ldb_reset_err_string(struct ldb_context *ldb)
 int ldb_transaction_start(struct ldb_context *ldb)
 {
 	struct ldb_module *module;
+	int status;
 	FIRST_OP(ldb, start_transaction);
 	
 	ldb->transaction_active++;
 
 	ldb_reset_err_string(ldb);
 
-	return module->ops->start_transaction(module);
+	status = module->ops->start_transaction(module);
+	if (status != LDB_SUCCESS) {
+		if (ldb->err_string == NULL) {
+			/* no error string was setup by the backend */
+			ldb_set_errstring(ldb->modules, 
+					  talloc_asprintf(ldb, "ldb transaction start error %d", status));
+		}
+	}
+	return status;
 }
 
 /*
@@ -141,6 +150,7 @@ int ldb_transaction_start(struct ldb_context *ldb)
 int ldb_transaction_commit(struct ldb_context *ldb)
 {
 	struct ldb_module *module;
+	int status;
 	FIRST_OP(ldb, end_transaction);
 
 	if (ldb->transaction_active > 0) {
@@ -151,7 +161,15 @@ int ldb_transaction_commit(struct ldb_context *ldb)
 
 	ldb_reset_err_string(ldb);
 
-	return module->ops->end_transaction(module);
+	status = module->ops->end_transaction(module);
+	if (status != LDB_SUCCESS) {
+		if (ldb->err_string == NULL) {
+			/* no error string was setup by the backend */
+			ldb_set_errstring(ldb->modules, 
+					  talloc_asprintf(ldb, "ldb transaction commit error %d", status));
+		}
+	}
+	return status;
 }
 
 /*
@@ -160,6 +178,7 @@ int ldb_transaction_commit(struct ldb_context *ldb)
 int ldb_transaction_cancel(struct ldb_context *ldb)
 {
 	struct ldb_module *module;
+	int status;
 	FIRST_OP(ldb, del_transaction);
 
 	if (ldb->transaction_active > 0) {
@@ -168,7 +187,15 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	return module->ops->del_transaction(module);
+	status = module->ops->del_transaction(module);
+	if (status != LDB_SUCCESS) {
+		if (ldb->err_string == NULL) {
+			/* no error string was setup by the backend */
+			ldb_set_errstring(ldb->modules, 
+					  talloc_asprintf(ldb, "ldb transaction cancel error %d", status));
+		}
+	}
+	return status;
 }
 
 /*
-- 
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/common/ldb.c | 5 +++++
 1 file changed, 5 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 6095f4fc04..604f02a1f7 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -307,6 +307,7 @@ int ldb_search(struct ldb_context *ldb,
 	request.op.search.scope = scope;
 	request.op.search.tree = tree;
 	request.op.search.attrs = attrs;
+	request.controls = NULL;
 
 	ret = ldb_request(ldb, &request);
 
@@ -332,6 +333,7 @@ int ldb_add(struct ldb_context *ldb,
 
 	request.operation = LDB_REQ_ADD;
 	request.op.add.message = message;
+	request.controls = NULL;
 
 	return ldb_request(ldb, &request);
 }
@@ -350,6 +352,7 @@ int ldb_modify(struct ldb_context *ldb,
 
 	request.operation = LDB_REQ_MODIFY;
 	request.op.mod.message = message;
+	request.controls = NULL;
 
 	return ldb_request(ldb, &request);
 }
@@ -364,6 +367,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 
 	request.operation = LDB_REQ_DELETE;
 	request.op.del.dn = dn;
+	request.controls = NULL;
 
 	return ldb_request(ldb, &request);
 }
@@ -378,6 +382,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 	request.operation = LDB_REQ_RENAME;
 	request.op.rename.olddn = olddn;
 	request.op.rename.newdn = newdn;
+	request.controls = NULL;
 
 	return ldb_request(ldb, &request);
 }
-- 
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/common/ldb.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 604f02a1f7..78e6a74425 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -120,6 +120,19 @@ static void ldb_reset_err_string(struct ldb_context *ldb)
 	if (module == NULL) return -1; \
 } while (0)
 
+/*
+ second stage init all modules loaded
+*/
+int ldb_second_stage_init(struct ldb_context *ldb)
+{
+	struct ldb_module *module;
+
+	FIRST_OP(ldb, second_stage_init);
+
+	return module->ops->second_stage_init(module);
+}
+
+
 /*
   start a transaction
 */
-- 
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/common/ldb.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 78e6a74425..41b1a3efb7 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -33,9 +33,7 @@
  */
 
 #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"
 
 /* 
    initialise a ldb context
-- 
cgit 


From f5ebc8e404f4397c0ef2c8b838984df1767c955c Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 4 Feb 2006 00:38:48 +0000
Subject: r13324: From now on check attribute names obey rfc2251 Also add a way
 to provide utf8 compliant functions by registering them with
 ldb_set_utf8_fns()

Next comes code to register samba internal utf8 functions.

Simo.
(This used to be commit ac9b8a41ffca8e06c5e849d544d3203a665b8e0d)
---
 source4/lib/ldb/common/ldb.c | 2 ++
 1 file changed, 2 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 41b1a3efb7..0857c07ad4 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -50,6 +50,8 @@ struct ldb_context *ldb_init(void *mem_ctx)
 		return NULL;
 	}
 
+	ldb_set_utf8_default(ldb);
+
 	return ldb;
 }
 
-- 
cgit 


From 00fe70e5b917769418f68eaa255d3a06a9a08ce7 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 22 Feb 2006 01:31:35 +0000
Subject: r13609: Get in the initial work on making ldb async Currently only
 ldb_ildap is async, the plan is to first make all backend support the async
 calls, and then remove the sync functions from backends and keep the only in
 the API.

Modules will need to be transformed along the way.

Simo
(This used to be commit 1e2c13b2d52de7c534493dd79a2c0596a3e8c1f5)
---
 source4/lib/ldb/common/ldb.c | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 0857c07ad4..68722cde96 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -106,7 +106,15 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	return LDB_SUCCESS;
 }
 
-static void ldb_reset_err_string(struct ldb_context *ldb)
+void ldb_set_errstring(struct ldb_module *module, char *err_string)
+{
+	if (module->ldb->err_string) {
+		talloc_free(module->ldb->err_string);
+	}
+	module->ldb->err_string = talloc_steal(module->ldb, err_string);
+}
+
+void ldb_reset_err_string(struct ldb_context *ldb)
 {
 	if (ldb->err_string) {
 		talloc_free(ldb->err_string);
@@ -211,6 +219,14 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 	return status;
 }
 
+int ldb_async_wait(struct ldb_context *ldb, struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+{
+	if (ldb->async_wait != NULL)
+		return ldb->async_wait(handle, type);
+
+	return LDB_ERR_OPERATIONS_ERROR;
+}
+
 /*
   check for an error return from an op 
   if an op fails, but has not setup an error string, then setup one now
@@ -279,6 +295,9 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *request)
 	if (request->operation == LDB_REQ_SEARCH) {
 		request->op.search.res = talloc_steal(ldb, r->op.search.res);
 	}
+	if (request->operation == LDB_ASYNC_SEARCH) {
+		request->async.handle = r->async.handle;
+	}
 	talloc_free(r);
 
 	if (started_transaction) {
-- 
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/common/ldb.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 68722cde96..87705a855a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -106,12 +106,12 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	return LDB_SUCCESS;
 }
 
-void ldb_set_errstring(struct ldb_module *module, char *err_string)
+void ldb_set_errstring(struct ldb_context *ldb, char *err_string)
 {
-	if (module->ldb->err_string) {
-		talloc_free(module->ldb->err_string);
+	if (ldb->err_string) {
+		talloc_free(ldb->err_string);
 	}
-	module->ldb->err_string = talloc_steal(module->ldb, err_string);
+	ldb->err_string = talloc_steal(ldb, err_string);
 }
 
 void ldb_reset_err_string(struct ldb_context *ldb)
@@ -158,7 +158,7 @@ int ldb_transaction_start(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_set_errstring(ldb->modules, 
+			ldb_set_errstring(ldb, 
 					  talloc_asprintf(ldb, "ldb transaction start error %d", status));
 		}
 	}
@@ -186,7 +186,7 @@ int ldb_transaction_commit(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_set_errstring(ldb->modules, 
+			ldb_set_errstring(ldb, 
 					  talloc_asprintf(ldb, "ldb transaction commit error %d", status));
 		}
 	}
@@ -212,7 +212,7 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_set_errstring(ldb->modules, 
+			ldb_set_errstring(ldb, 
 					  talloc_asprintf(ldb, "ldb transaction cancel error %d", status));
 		}
 	}
@@ -238,7 +238,7 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 	}
 	if (ldb->err_string == NULL) {
 		/* no error string was setup by the backend */
-		ldb_set_errstring(ldb->modules, 
+		ldb_set_errstring(ldb, 
 				  talloc_asprintf(ldb, "ldb error %d", status));
 	}
 	ldb_transaction_cancel(ldb);
@@ -330,7 +330,7 @@ int ldb_search(struct ldb_context *ldb,
 
 	tree = ldb_parse_tree(ldb, expression);
 	if (tree == NULL) {
-		ldb_set_errstring(ldb->modules, talloc_strdup(ldb, "Unable to parse search expression"));
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Unable to parse search expression"));
 		return -1;
 	}
 
-- 
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/common/ldb.c | 13 -------------
 1 file changed, 13 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 87705a855a..28bed0b0ea 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -128,19 +128,6 @@ void ldb_reset_err_string(struct ldb_context *ldb)
 	if (module == NULL) return -1; \
 } while (0)
 
-/*
- second stage init all modules loaded
-*/
-int ldb_second_stage_init(struct ldb_context *ldb)
-{
-	struct ldb_module *module;
-
-	FIRST_OP(ldb, second_stage_init);
-
-	return module->ops->second_stage_init(module);
-}
-
-
 /*
   start a transaction
 */
-- 
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/common/ldb.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 28bed0b0ea..9d8783324c 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -125,7 +125,7 @@ void ldb_reset_err_string(struct ldb_context *ldb)
 #define FIRST_OP(ldb, op) do { \
 	module = ldb->modules; \
 	while (module && module->ops->op == NULL) module = module->next; \
-	if (module == NULL) return -1; \
+	if (module == NULL) return LDB_ERR_OPERATIONS_ERROR; \
 } while (0)
 
 /*
@@ -208,10 +208,11 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 
 int ldb_async_wait(struct ldb_context *ldb, struct ldb_async_handle *handle, enum ldb_async_wait_type type)
 {
-	if (ldb->async_wait != NULL)
-		return ldb->async_wait(handle, type);
+	struct ldb_module *module;
+
+	FIRST_OP(ldb, async_wait);
 
-	return LDB_ERR_OPERATIONS_ERROR;
+	return module->ops->async_wait(module, handle, type);
 }
 
 /*
-- 
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/common/ldb.c | 61 +++++++++++++++++++++++++++++++-------------
 1 file changed, 43 insertions(+), 18 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 9d8783324c..b664ba680d 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -55,6 +55,40 @@ struct ldb_context *ldb_init(void *mem_ctx)
 	return ldb;
 }
 
+static struct ldb_backend {
+	const char *name;
+	ldb_connect_fn connect_fn;
+	struct ldb_backend *prev, *next;
+} *ldb_backends = NULL;
+/*
+ register a new ldb backend
+*/
+int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
+{
+	struct ldb_backend *backend = talloc(talloc_autofree_context(), struct ldb_backend);
+
+	/* Maybe check for duplicity here later on? */
+
+	backend->name = talloc_strdup(backend, url_prefix);
+	backend->connect_fn = connectfn;
+	DLIST_ADD(ldb_backends, backend);
+
+	return LDB_SUCCESS;
+}
+
+static ldb_connect_fn ldb_find_backend(const char *url)
+{
+	struct ldb_backend *backend;
+
+	for (backend = ldb_backends; backend; backend = backend->next) {
+		if (strncmp(backend->name, url, strlen(backend->name)) == 0) {
+			return backend->connect_fn;
+		}
+	}
+
+	return NULL;
+}
+
 /* 
  connect to a database. The URL can either be one of the following forms
    ldb://path
@@ -68,31 +102,22 @@ struct ldb_context *ldb_init(void *mem_ctx)
 int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[])
 {
 	int ret;
+	ldb_connect_fn fn;
 
-	if (strncmp(url, "tdb:", 4) == 0 ||
-	    strchr(url, ':') == NULL) {
-		ret = ltdb_connect(ldb, url, flags, options);
+	if (strchr(url, ':') != NULL) {
+		fn = ldb_find_backend(url);
+	} else {
+		/* Default to tdb */
+		fn = ldb_find_backend("tdb:");
 	}
 
-#if HAVE_ILDAP
-	else if (strncmp(url, "ldap", 4) == 0) {
-		ret = ildb_connect(ldb, url, flags, options);
-	}
-#elif HAVE_LDAP
-	else if (strncmp(url, "ldap", 4) == 0) {
-		ret = lldb_connect(ldb, url, flags, options);
-	}
-#endif
-#if HAVE_SQLITE3
-	else if (strncmp(url, "sqlite:", 7) == 0) {
-                ret = lsqlite3_connect(ldb, url, flags, options);
-	}
-#endif
-	else {
+	if (fn == NULL) {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to find backend for '%s'\n", url);
 		return LDB_ERR_OTHER;
 	}
 
+	ret = fn(ldb, url, flags, options);
+
 	if (ret != LDB_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'\n", url);
 		return ret;
-- 
cgit 


From eec236c1f295ff4e60b4d88db440771a18e0a6e3 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 6 Mar 2006 21:40:47 +0000
Subject: r13900: don't segfault on error (This used to be commit
 cf7ad707578ee4dbd5dbf3c83f1f4ede42de3835)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index b664ba680d..4b4cc30de8 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -305,10 +305,10 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *request)
 	/* the search call is the only one that returns something
 	   other than a status code. We steal the results into
 	   the context of the ldb before freeing the request */
-	if (request->operation == LDB_REQ_SEARCH) {
+	if (status == LDB_SUCCESS && request->operation == LDB_REQ_SEARCH) {
 		request->op.search.res = talloc_steal(ldb, r->op.search.res);
 	}
-	if (request->operation == LDB_ASYNC_SEARCH) {
+	if (status == LDB_SUCCESS && request->operation == LDB_ASYNC_SEARCH) {
 		request->async.handle = r->async.handle;
 	}
 	talloc_free(r);
-- 
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/common/ldb.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 4b4cc30de8..b304cf6afc 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -233,11 +233,7 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 
 int ldb_async_wait(struct ldb_context *ldb, struct ldb_async_handle *handle, enum ldb_async_wait_type type)
 {
-	struct ldb_module *module;
-
-	FIRST_OP(ldb, async_wait);
-
-	return module->ops->async_wait(module, handle, type);
+	return handle->module->ops->async_wait(handle, type);
 }
 
 /*
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index b304cf6afc..ed3351dc5e 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -231,7 +231,7 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 	return status;
 }
 
-int ldb_async_wait(struct ldb_context *ldb, struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+int ldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
 {
 	return handle->module->ops->async_wait(handle, type);
 }
-- 
cgit 


From 82da2d401e54d0b3124b727fab755d94dd5402d4 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 8 Mar 2006 01:01:14 +0000
Subject: r13998: From now on ldb_request() will require an alloced request By
 freeing the request you will be sure everything down the path get freed.

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

simo.
(This used to be commit e8075e6a062ce5edb84485e45d0b841c2ee2af7d)
---
 source4/lib/ldb/common/ldb.c | 169 ++++++++++++++++++++++++-------------------
 1 file changed, 95 insertions(+), 74 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ed3351dc5e..9acf74535b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -257,57 +257,35 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 /*
   start an ldb request
   autostarts a transacion if none active and the operation is not a search
+  NOTE: the request must be a talloc context.
   returns LDB_ERR_* on errors.
 */
-int ldb_request(struct ldb_context *ldb, struct ldb_request *request)
+int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 {
 	int status, started_transaction=0;
-	struct ldb_request *r;
 
 	ldb_reset_err_string(ldb);
 
-	/* to allow ldb modules to assume they can use the request ptr
-	   as a talloc context for the request, we have to copy the 
-	   structure here */
-	r = talloc(ldb, struct ldb_request);
-	if (r == NULL) {
-		ldb_oom(ldb);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	*r = *request;
-
-	if (r->operation == LDB_REQ_SEARCH) {
-		r->op.search.res = NULL;
+	if (req->operation == LDB_REQ_SEARCH) {
+		req->op.search.res = NULL;
 	}
 
 	/* start a transaction if needed */
 	if ((!ldb->transaction_active) &&
-	    (request->operation == LDB_REQ_ADD ||
-	     request->operation == LDB_REQ_MODIFY ||
-	     request->operation == LDB_REQ_DELETE ||
-	     request->operation == LDB_REQ_RENAME)) {
+	    (req->operation == LDB_REQ_ADD ||
+	     req->operation == LDB_REQ_MODIFY ||
+	     req->operation == LDB_REQ_DELETE ||
+	     req->operation == LDB_REQ_RENAME)) {
 		status = ldb_transaction_start(ldb);
 		if (status != LDB_SUCCESS) {
-			talloc_free(r);
+			talloc_free(req);
 			return status;
 		}
 		started_transaction = 1;
 	}
 
 	/* call the first module in the chain */
-	status = ldb->modules->ops->request(ldb->modules, r);
-
-	/* the search call is the only one that returns something
-	   other than a status code. We steal the results into
-	   the context of the ldb before freeing the request */
-	if (status == LDB_SUCCESS && request->operation == LDB_REQ_SEARCH) {
-		request->op.search.res = talloc_steal(ldb, r->op.search.res);
-	}
-	if (status == LDB_SUCCESS && request->operation == LDB_ASYNC_SEARCH) {
-		request->async.handle = r->async.handle;
-	}
-	talloc_free(r);
+	status = ldb->modules->ops->request(ldb->modules, req);
 
 	if (started_transaction) {
 		return ldb_op_finish(ldb, status);
@@ -331,31 +309,36 @@ int ldb_search(struct ldb_context *ldb,
 	       const char * const *attrs, 
 	       struct ldb_result **res)
 {
-	struct ldb_request request;
-	struct ldb_parse_tree *tree;
+	struct ldb_request *req;
 	int ret;
 
 	(*res) = NULL;
 
-	tree = ldb_parse_tree(ldb, expression);
-	if (tree == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Unable to parse search expression"));
-		return -1;
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	request.operation = LDB_REQ_SEARCH;
-	request.op.search.base = base;
-	request.op.search.scope = scope;
-	request.op.search.tree = tree;
-	request.op.search.attrs = attrs;
-	request.controls = NULL;
+	req->operation = LDB_REQ_SEARCH;
+	req->op.search.base = base;
+	req->op.search.scope = scope;
 
-	ret = ldb_request(ldb, &request);
+	req->op.search.tree = ldb_parse_tree(req, expression);
+	if (req->op.search.tree == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Unable to parse search expression"));
+		talloc_free(req);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	(*res) = request.op.search.res;
+	req->op.search.attrs = attrs;
+	req->controls = NULL;
 
-	talloc_free(tree);
+	ret = ldb_request(ldb, req);
 
+	(*res) = talloc_steal(ldb, req->op.search.res);
+
+	talloc_free(req);
 	return ret;
 }
 
@@ -366,17 +349,26 @@ int ldb_search(struct ldb_context *ldb,
 int ldb_add(struct ldb_context *ldb, 
 	    const struct ldb_message *message)
 {
-	struct ldb_request request;
-	int status;
+	struct ldb_request *req;
+	int ret;
+
+	ret = ldb_msg_sanity_check(message);
+	if (ret != LDB_SUCCESS) return ret;
+
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	status = ldb_msg_sanity_check(message);
-	if (status != LDB_SUCCESS) return status;
+	req->operation = LDB_REQ_ADD;
+	req->op.add.message = message;
+	req->controls = NULL;
 
-	request.operation = LDB_REQ_ADD;
-	request.op.add.message = message;
-	request.controls = NULL;
+	ret = ldb_request(ldb, req);
 
-	return ldb_request(ldb, &request);
+	talloc_free(req);
+	return ret;
 }
 
 /*
@@ -385,17 +377,26 @@ int ldb_add(struct ldb_context *ldb,
 int ldb_modify(struct ldb_context *ldb, 
 	       const struct ldb_message *message)
 {
-	struct ldb_request request;
-	int status;
+	struct ldb_request *req;
+	int ret;
+
+	ret = ldb_msg_sanity_check(message);
+	if (ret != LDB_SUCCESS) return ret;
+
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
-	status = ldb_msg_sanity_check(message);
-	if (status != LDB_SUCCESS) return status;
+	req->operation = LDB_REQ_MODIFY;
+	req->op.add.message = message;
+	req->controls = NULL;
 
-	request.operation = LDB_REQ_MODIFY;
-	request.op.mod.message = message;
-	request.controls = NULL;
+	ret = ldb_request(ldb, req);
 
-	return ldb_request(ldb, &request);
+	talloc_free(req);
+	return ret;
 }
 
 
@@ -404,13 +405,23 @@ int ldb_modify(struct ldb_context *ldb,
 */
 int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 {
-	struct ldb_request request;
+	struct ldb_request *req;
+	int ret;
+
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_REQ_DELETE;
+	req->op.del.dn = dn;
+	req->controls = NULL;
 
-	request.operation = LDB_REQ_DELETE;
-	request.op.del.dn = dn;
-	request.controls = NULL;
+	ret = ldb_request(ldb, req);
 
-	return ldb_request(ldb, &request);
+	talloc_free(req);
+	return ret;
 }
 
 /*
@@ -418,14 +429,24 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 */
 int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 {
-	struct ldb_request request;
+	struct ldb_request *req;
+	int ret;
 
-	request.operation = LDB_REQ_RENAME;
-	request.op.rename.olddn = olddn;
-	request.op.rename.newdn = newdn;
-	request.controls = NULL;
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_REQ_RENAME;
+	req->op.rename.olddn = olddn;
+	req->op.rename.newdn = newdn;
+	req->controls = NULL;
 
-	return ldb_request(ldb, &request);
+	ret = ldb_request(ldb, req);
+
+	talloc_free(req);
+	return ret;
 }
 
 
-- 
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/common/ldb.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 9acf74535b..0d424ad601 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -102,15 +102,26 @@ static ldb_connect_fn ldb_find_backend(const char *url)
 int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[])
 {
 	int ret;
+	char *backend;
 	ldb_connect_fn fn;
 
 	if (strchr(url, ':') != NULL) {
-		fn = ldb_find_backend(url);
+		backend = talloc_strndup(ldb, url, strchr(url, ':')-url);
 	} else {
 		/* Default to tdb */
-		fn = ldb_find_backend("tdb:");
+		backend = talloc_strdup(ldb, "tdb");
 	}
 
+	fn = ldb_find_backend(backend);
+
+	if (fn == NULL) {
+		if (ldb_try_load_dso(ldb, backend) == 0) {
+			fn = ldb_find_backend(backend);
+		}
+	}
+
+	talloc_free(backend);
+
 	if (fn == NULL) {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to find backend for '%s'\n", url);
 		return LDB_ERR_OTHER;
-- 
cgit 


From 508f2f5506a14814888718bf00f52b7788d0e9ea Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 20 Mar 2006 23:35:08 +0000
Subject: r14594: Fix some dependencies (required for shared library build)
 (This used to be commit 06f7a8c692a645830eb3dd9abad8556c66bba747)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 0d424ad601..6e1f6f5cde 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -106,7 +106,7 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	ldb_connect_fn fn;
 
 	if (strchr(url, ':') != NULL) {
-		backend = talloc_strndup(ldb, url, strchr(url, ':')-url);
+		backend = talloc_strndup(ldb, url, strchr(url, ':')-url-1);
 	} else {
 		/* Default to tdb */
 		backend = talloc_strdup(ldb, "tdb");
-- 
cgit 


From d64ccc01769ce274c74d8458f9ef81cdcc8986f6 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 21 Mar 2006 01:30:22 +0000
Subject: r14599: Pass ACLs down the registry layer. (This used to be commit
 6cdefd8945eee5513a6993350ea71f12d4dbd6fa)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 6e1f6f5cde..0d424ad601 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -106,7 +106,7 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	ldb_connect_fn fn;
 
 	if (strchr(url, ':') != NULL) {
-		backend = talloc_strndup(ldb, url, strchr(url, ':')-url-1);
+		backend = talloc_strndup(ldb, url, strchr(url, ':')-url);
 	} else {
 		/* Default to tdb */
 		backend = talloc_strdup(ldb, "tdb");
-- 
cgit 


From 859817e30ff809bda972e208e89191f53e097674 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Mon, 17 Apr 2006 23:25:25 +0000
Subject: r15113: Add a ldb_strerror() function. (This used to be commit
 456a1de2b9cd54337066c9ba24ad1c46aafcd072)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 0d424ad601..eef02bd760 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -474,6 +474,101 @@ const char *ldb_errstring(struct ldb_context *ldb)
 	return NULL;
 }
 
+/*
+  return a string explaining what a ldb error constant meancs
+*/
+const char *ldb_strerror(int ldb_err)
+{
+	switch (ldb_err) {
+	case LDB_SUCCESS:
+		return "Success";
+	case LDB_ERR_OPERATIONS_ERROR:
+		return "Operations error";
+	case LDB_ERR_PROTOCOL_ERROR:
+		return "Protocol error";
+	case LDB_ERR_TIME_LIMIT_EXCEEDED:
+		return "Time limit exceeded";
+	case LDB_ERR_SIZE_LIMIT_EXCEEDED:
+		return "Size limit exceeded";
+	case LDB_ERR_COMPARE_FALSE:
+		return "Compare false";
+	case LDB_ERR_COMPARE_TRUE:
+		return "Compare true";
+	case LDB_ERR_AUTH_METHOD_NOT_SUPPORTED:
+		return "Auth method not supported";
+	case LDB_ERR_STRONG_AUTH_REQUIRED:
+		return "Strong auth required";
+/* 9 RESERVED */
+	case LDB_ERR_REFERRAL:
+		return "Referral error";
+	case LDB_ERR_ADMIN_LIMIT_EXCEEDED:
+		return "Admin limit exceeded";
+	case LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION:
+		return "Unsupported critical extension";
+	case LDB_ERR_CONFIDENTIALITY_REQUIRED:
+		return "Confidentiality required";
+	case LDB_ERR_SASL_BIND_IN_PROGRESS:
+		return "SASL bind in progress";
+	case LDB_ERR_NO_SUCH_ATTRIBUTE:
+		return "No such attribute";
+	case LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE:
+		return "Undefined attribute type";
+	case LDB_ERR_INAPPROPRIATE_MATCHING:
+		return "Inappropriate matching";
+	case LDB_ERR_CONSTRAINT_VIOLATION:
+		return "Constraint violation";
+	case LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS:
+		return "Attribute or value exists";
+	case LDB_ERR_INVALID_ATTRIBUTE_SYNTAX:
+		return "Invalid attribute syntax";
+/* 22-31 unused */
+	case LDB_ERR_NO_SUCH_OBJECT:
+		return "No such object";
+	case LDB_ERR_ALIAS_PROBLEM:
+		return "Alias problem";
+	case LDB_ERR_INVALID_DN_SYNTAX:
+		return "Invalid DN syntax";
+/* 53 RESERVED */
+	case LDB_ERR_ALIAS_DEREFERENCING_PROBLEM:
+		return "Alias dereferencing problem";
+/* 37-47 unused */
+	case LDB_ERR_INAPPROPRIATE_AUTHENTICATION:
+		return "Inappropriate authentication";
+	case LDB_ERR_INVALID_CREDENTIALS:
+		return "Invalid credentials";
+	case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
+		return "insufficient access rights";
+	case LDB_ERR_BUSY:
+		return "Busy";
+	case LDB_ERR_UNAVAILABLE:
+		return "Unavailable";
+	case LDB_ERR_UNWILLING_TO_PERFORM:
+		return "Unwilling to perform";
+	case LDB_ERR_LOOP_DETECT:
+		return "Loop detect";
+/* 55-63 unused */
+	case LDB_ERR_NAMING_VIOLATION:
+		return "Naming violation";
+	case LDB_ERR_OBJECT_CLASS_VIOLATION:
+		return "Object class violation";
+	case LDB_ERR_NOT_ALLOWED_ON_NON_LEAF:
+		return "Not allowed on non-leaf";
+	case LDB_ERR_NOT_ALLOWED_ON_RDN:
+		return "Not allowed on RDN";
+	case LDB_ERR_ENTRY_ALREADY_EXISTS:
+		return "Entry already exists";
+	case LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED:
+		return "Object class mods prohibited";
+/* 70 RESERVED FOR CLDAP */
+	case LDB_ERR_AFFECTS_MULTIPLE_DSAS:
+		return "Affects multiple DSAs";
+/* 72-79 unused */
+	case LDB_ERR_OTHER:
+		return "Other";
+	}
+
+	return "Unknown error";
+}
 
 /*
   set backend specific opaque parameters
-- 
cgit 


From 2283810356c9836072b1f948228f6b47f25e9e98 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Sun, 23 Apr 2006 11:25:02 +0000
Subject: r15176: Ensure we don't segfault when we try and delete @FOO records.

Don't try and steal the result of a search on failure, it has already
been talloc_free()'ed by the ildb code.

Andrew Bartlett
(This used to be commit a99bd2e033501954aca8f35afe8a7f2bbfadf6b7)
---
 source4/lib/ldb/common/ldb.c | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index eef02bd760..a681811cb9 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -244,6 +244,10 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 
 int ldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
 {
+	if (!handle) {
+		return LDB_SUCCESS;
+	}
+
 	return handle->module->ops->async_wait(handle, type);
 }
 
@@ -308,9 +312,9 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 /*
   search the database given a LDAP-like search expression
 
-  return the number of records found, or -1 on error
+  returns an LDB error code
 
-  Use talloc_free to free the ldb_message returned in 'res'
+  Use talloc_free to free the ldb_message returned in 'res', if successful
 
 */
 int ldb_search(struct ldb_context *ldb, 
@@ -346,9 +350,10 @@ int ldb_search(struct ldb_context *ldb,
 	req->controls = NULL;
 
 	ret = ldb_request(ldb, req);
-
-	(*res) = talloc_steal(ldb, req->op.search.res);
-
+	
+	if (ret == LDB_SUCCESS) {
+		(*res) = talloc_steal(ldb, req->op.search.res);
+	}
 	talloc_free(req);
 	return ret;
 }
-- 
cgit 


From 827cdb949ba22e05f88c03028acb747ca437f4e3 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Tue, 2 May 2006 02:36:11 +0000
Subject: r15388: Fix cut&paste typo. (This used to be commit
 88e854929f10947aa1a7f57bbfef436bc8832529)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index a681811cb9..68e3c116fc 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -533,7 +533,7 @@ const char *ldb_strerror(int ldb_err)
 		return "Alias problem";
 	case LDB_ERR_INVALID_DN_SYNTAX:
 		return "Invalid DN syntax";
-/* 53 RESERVED */
+/* 35 RESERVED */
 	case LDB_ERR_ALIAS_DEREFERENCING_PROBLEM:
 		return "Alias dereferencing problem";
 /* 37-47 unused */
-- 
cgit 


From 8081e4f40276034c47bd799aca64a7d01ffb1bce Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 22 May 2006 03:55:01 +0000
Subject: r15795: Try to use the async code by default It passess all my tests,
 but I still need to work on a lot of stuff. Shouldn't impact anybody else
 work, so I want to commit now and see what happens

Will work to remove the old code from modules and backends soon, and make some
more restyling in ldb internals.

So, if there is something you don't like in this desgin please speak now.

Simo.
(This used to be commit 8b2a563e716a789ea77cbfbf2f372724de5361ce)
---
 source4/lib/ldb/common/ldb.c | 152 +++++++++++++++++++++++++++++++++++++++----
 1 file changed, 140 insertions(+), 12 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 68e3c116fc..3d5f816fe8 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -2,6 +2,7 @@
    ldb database library
 
    Copyright (C) Andrew Tridgell  2004
+   Copyright (C) Simo Sorce  2005-2006
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -251,6 +252,7 @@ int ldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type typ
 	return handle->module->ops->async_wait(handle, type);
 }
 
+
 /*
   check for an error return from an op 
   if an op fails, but has not setup an error string, then setup one now
@@ -272,6 +274,7 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 /*
   start an ldb request
   autostarts a transacion if none active and the operation is not a search
+  does not work for ASYNC operations
   NOTE: the request must be a talloc context.
   returns LDB_ERR_* on errors.
 */
@@ -285,7 +288,7 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 		req->op.search.res = NULL;
 	}
 
-	/* start a transaction if needed */
+	/* start a transaction if not async and not search */
 	if ((!ldb->transaction_active) &&
 	    (req->operation == LDB_REQ_ADD ||
 	     req->operation == LDB_REQ_MODIFY ||
@@ -317,6 +320,71 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
   Use talloc_free to free the ldb_message returned in 'res', if successful
 
 */
+static int ldb_search_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->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;
+}
+
 int ldb_search(struct ldb_context *ldb, 
 	       const struct ldb_dn *base,
 	       enum ldb_scope scope,
@@ -327,7 +395,10 @@ int ldb_search(struct ldb_context *ldb,
 	struct ldb_request *req;
 	int ret;
 
-	(*res) = NULL;
+	*res = talloc_zero(ldb, struct ldb_result);
+	if (! *res) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
 
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
@@ -335,7 +406,7 @@ int ldb_search(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_REQ_SEARCH;
+	req->operation = LDB_ASYNC_SEARCH;
 	req->op.search.base = base;
 	req->op.search.scope = scope;
 
@@ -348,16 +419,53 @@ int ldb_search(struct ldb_context *ldb,
 
 	req->op.search.attrs = attrs;
 	req->controls = NULL;
+	req->creds = NULL;
+	req->async.context = res;
+	req->async.callback = ldb_search_callback;
+	req->async.timeout = 600; /* 10 minutes */
 
 	ret = ldb_request(ldb, req);
 	
 	if (ret == LDB_SUCCESS) {
-		(*res) = talloc_steal(ldb, req->op.search.res);
+		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
 	}
+	
+	if (ret != LDB_SUCCESS) {
+		talloc_free(*res);
+		*res = NULL;
+	}
+
 	talloc_free(req);
 	return ret;
 }
 
+static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_request *req)
+{
+	int ret, close_transaction;
+
+	close_transaction = 0;
+	if (!ldb->transaction_active) {
+		ret = ldb_transaction_start(ldb);
+		if (ret != LDB_SUCCESS) {
+			return ret;
+		}
+		close_transaction = 1;
+	}
+
+	ret = ldb_request(ldb, req);
+
+	if (ret == LDB_SUCCESS) {
+		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
+	}
+
+	if (close_transaction) {
+		return ldb_op_finish(ldb, ret);
+	}
+
+	return ret;
+}
+
+
 /*
   add a record to the database. Will fail if a record with the given class and key
   already exists
@@ -377,11 +485,16 @@ int ldb_add(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_REQ_ADD;
+	req->operation = LDB_ASYNC_ADD;
 	req->op.add.message = message;
 	req->controls = NULL;
+	req->creds = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = 600; /* 10 minutes */
 
-	ret = ldb_request(ldb, req);
+	/* do request and autostart a transaction */
+	ret = ldb_autotransaction_request(ldb, req);
 
 	talloc_free(req);
 	return ret;
@@ -405,11 +518,16 @@ int ldb_modify(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_REQ_MODIFY;
+	req->operation = LDB_ASYNC_MODIFY;
 	req->op.add.message = message;
 	req->controls = NULL;
+	req->creds = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = 600; /* 10 minutes */
 
-	ret = ldb_request(ldb, req);
+	/* do request and autostart a transaction */
+	ret = ldb_autotransaction_request(ldb, req);
 
 	talloc_free(req);
 	return ret;
@@ -430,11 +548,16 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_REQ_DELETE;
+	req->operation = LDB_ASYNC_DELETE;
 	req->op.del.dn = dn;
 	req->controls = NULL;
+	req->creds = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = 600; /* 10 minutes */
 
-	ret = ldb_request(ldb, req);
+	/* do request and autostart a transaction */
+	ret = ldb_autotransaction_request(ldb, req);
 
 	talloc_free(req);
 	return ret;
@@ -454,12 +577,17 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_REQ_RENAME;
+	req->operation = LDB_ASYNC_RENAME;
 	req->op.rename.olddn = olddn;
 	req->op.rename.newdn = newdn;
 	req->controls = NULL;
+	req->creds = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	req->async.timeout = 600; /* 10 minutes */
 
-	ret = ldb_request(ldb, req);
+	/* do request and autostart a transaction */
+	ret = ldb_autotransaction_request(ldb, req);
 
 	talloc_free(req);
 	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/common/ldb.c | 44 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 34 insertions(+), 10 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 3d5f816fe8..f348001456 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -280,7 +280,8 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 */
 int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 {
-	int status, started_transaction=0;
+	struct ldb_module *module;
+	int ret, started_transaction=0;
 
 	ldb_reset_err_string(ldb);
 
@@ -288,28 +289,52 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 		req->op.search.res = NULL;
 	}
 
-	/* start a transaction if not async and not search */
+	/* start a transaction if SYNC and not search */
 	if ((!ldb->transaction_active) &&
 	    (req->operation == LDB_REQ_ADD ||
 	     req->operation == LDB_REQ_MODIFY ||
 	     req->operation == LDB_REQ_DELETE ||
 	     req->operation == LDB_REQ_RENAME)) {
-		status = ldb_transaction_start(ldb);
-		if (status != LDB_SUCCESS) {
-			talloc_free(req);
-			return status;
+		ret = ldb_transaction_start(ldb);
+		if (ret != LDB_SUCCESS) {
+			return ret;
 		}
 		started_transaction = 1;
 	}
 
 	/* call the first module in the chain */
-	status = ldb->modules->ops->request(ldb->modules, req);
+	switch (req->operation) {
+	case LDB_ASYNC_SEARCH:
+		FIRST_OP(ldb, search);
+		ret = module->ops->search(module, req);
+		break;
+	case LDB_ASYNC_ADD:
+		FIRST_OP(ldb, add);
+		ret = module->ops->add(module, req);
+		break;
+	case LDB_ASYNC_MODIFY:
+		FIRST_OP(ldb, modify);
+		ret = module->ops->modify(module, req);
+		break;
+	case LDB_ASYNC_DELETE:
+		FIRST_OP(ldb, del);
+		ret = module->ops->del(module, req);
+		break;
+	case LDB_ASYNC_RENAME:
+		FIRST_OP(ldb, rename);
+		ret = module->ops->rename(module, req);
+		break;
+	default:
+		FIRST_OP(ldb, request);
+		ret = module->ops->request(module, req);
+		break;
+	}
 
 	if (started_transaction) {
-		return ldb_op_finish(ldb, status);
+		return ldb_op_finish(ldb, ret);
 	}
 
-	return status;
+	return ret;
 }
 
 /*
@@ -453,7 +478,6 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 	}
 
 	ret = ldb_request(ldb, req);
-
 	if (ret == LDB_SUCCESS) {
 		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
 	}
-- 
cgit 


From 03703a58d7fe441ec5dcbe1814cea3f55544de55 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 29 May 2006 11:57:09 +0000
Subject: r15932: Remove per request creds They have never benn used and make
 little sense too imo (This used to be commit
 f0c1d08d50f8a3e25650ac85b178ec7a43e433d9)

---
 source4/lib/ldb/common/ldb.c | 5 -----
 1 file changed, 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index f348001456..28b9728d0a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -444,7 +444,6 @@ int ldb_search(struct ldb_context *ldb,
 
 	req->op.search.attrs = attrs;
 	req->controls = NULL;
-	req->creds = NULL;
 	req->async.context = res;
 	req->async.callback = ldb_search_callback;
 	req->async.timeout = 600; /* 10 minutes */
@@ -512,7 +511,6 @@ int ldb_add(struct ldb_context *ldb,
 	req->operation = LDB_ASYNC_ADD;
 	req->op.add.message = message;
 	req->controls = NULL;
-	req->creds = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
 	req->async.timeout = 600; /* 10 minutes */
@@ -545,7 +543,6 @@ int ldb_modify(struct ldb_context *ldb,
 	req->operation = LDB_ASYNC_MODIFY;
 	req->op.add.message = message;
 	req->controls = NULL;
-	req->creds = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
 	req->async.timeout = 600; /* 10 minutes */
@@ -575,7 +572,6 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 	req->operation = LDB_ASYNC_DELETE;
 	req->op.del.dn = dn;
 	req->controls = NULL;
-	req->creds = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
 	req->async.timeout = 600; /* 10 minutes */
@@ -605,7 +601,6 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 	req->op.rename.olddn = olddn;
 	req->op.rename.newdn = newdn;
 	req->controls = NULL;
-	req->creds = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
 	req->async.timeout = 600; /* 10 minutes */
-- 
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/common/ldb.c | 26 ++------------------------
 1 file changed, 2 insertions(+), 24 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 28b9728d0a..5fbaf54920 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -273,35 +273,16 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 
 /*
   start an ldb request
-  autostarts a transacion if none active and the operation is not a search
-  does not work for ASYNC operations
   NOTE: the request must be a talloc context.
   returns LDB_ERR_* on errors.
 */
 int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 {
 	struct ldb_module *module;
-	int ret, started_transaction=0;
+	int ret;
 
 	ldb_reset_err_string(ldb);
 
-	if (req->operation == LDB_REQ_SEARCH) {
-		req->op.search.res = NULL;
-	}
-
-	/* start a transaction if SYNC and not search */
-	if ((!ldb->transaction_active) &&
-	    (req->operation == LDB_REQ_ADD ||
-	     req->operation == LDB_REQ_MODIFY ||
-	     req->operation == LDB_REQ_DELETE ||
-	     req->operation == LDB_REQ_RENAME)) {
-		ret = ldb_transaction_start(ldb);
-		if (ret != LDB_SUCCESS) {
-			return ret;
-		}
-		started_transaction = 1;
-	}
-
 	/* call the first module in the chain */
 	switch (req->operation) {
 	case LDB_ASYNC_SEARCH:
@@ -330,10 +311,6 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 		break;
 	}
 
-	if (started_transaction) {
-		return ldb_op_finish(ldb, ret);
-	}
-
 	return ret;
 }
 
@@ -463,6 +440,7 @@ int ldb_search(struct ldb_context *ldb,
 	return ret;
 }
 
+/* autostarts a transacion if none active */
 static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_request *req)
 {
 	int ret, close_transaction;
-- 
cgit 


From 2d19dca9c80a5e3990296dde67163fce36ac883d Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 30 May 2006 00:33:52 +0000
Subject: r15944: rename LDB_ASYNC_ADD -> LDB_ADD, LDB_ASYNC_MODIFY ->
 LDB_MODIFY, etc... (This used to be commit
 55d97ef88f377ef1dbf7b1774a15cf9035e2f320)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 5fbaf54920..53b4e51ff3 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -285,23 +285,23 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 
 	/* call the first module in the chain */
 	switch (req->operation) {
-	case LDB_ASYNC_SEARCH:
+	case LDB_SEARCH:
 		FIRST_OP(ldb, search);
 		ret = module->ops->search(module, req);
 		break;
-	case LDB_ASYNC_ADD:
+	case LDB_ADD:
 		FIRST_OP(ldb, add);
 		ret = module->ops->add(module, req);
 		break;
-	case LDB_ASYNC_MODIFY:
+	case LDB_MODIFY:
 		FIRST_OP(ldb, modify);
 		ret = module->ops->modify(module, req);
 		break;
-	case LDB_ASYNC_DELETE:
+	case LDB_DELETE:
 		FIRST_OP(ldb, del);
 		ret = module->ops->del(module, req);
 		break;
-	case LDB_ASYNC_RENAME:
+	case LDB_RENAME:
 		FIRST_OP(ldb, rename);
 		ret = module->ops->rename(module, req);
 		break;
@@ -408,7 +408,7 @@ int ldb_search(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_ASYNC_SEARCH;
+	req->operation = LDB_SEARCH;
 	req->op.search.base = base;
 	req->op.search.scope = scope;
 
@@ -486,7 +486,7 @@ int ldb_add(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_ASYNC_ADD;
+	req->operation = LDB_ADD;
 	req->op.add.message = message;
 	req->controls = NULL;
 	req->async.context = NULL;
@@ -518,7 +518,7 @@ int ldb_modify(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_ASYNC_MODIFY;
+	req->operation = LDB_MODIFY;
 	req->op.add.message = message;
 	req->controls = NULL;
 	req->async.context = NULL;
@@ -547,7 +547,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_ASYNC_DELETE;
+	req->operation = LDB_DELETE;
 	req->op.del.dn = dn;
 	req->controls = NULL;
 	req->async.context = NULL;
@@ -575,7 +575,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	req->operation = LDB_ASYNC_RENAME;
+	req->operation = LDB_RENAME;
 	req->op.rename.olddn = olddn;
 	req->op.rename.newdn = newdn;
 	req->controls = NULL;
-- 
cgit 


From e3482ffeed80c156ce3832609515e3aea4ba907f Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Fri, 2 Jun 2006 14:33:57 +0000
Subject: r16007: If no error string was setup by the backend, ensure that we
 always get at least a generic error, even when inside a transaction.

This helps debugging ldb/js interactions a lot...

Andrew Bartlett
(This used to be commit b607acf6f0b3567a40a3e35911c690feda243f50)
---
 source4/lib/ldb/common/ldb.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 53b4e51ff3..126ad37d9b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -265,7 +265,8 @@ static int ldb_op_finish(struct ldb_context *ldb, int status)
 	if (ldb->err_string == NULL) {
 		/* no error string was setup by the backend */
 		ldb_set_errstring(ldb, 
-				  talloc_asprintf(ldb, "ldb error %d", status));
+				  talloc_asprintf(ldb, "%s (%d)", 
+						  ldb_strerror(status), status));
 	}
 	ldb_transaction_cancel(ldb);
 	return status;
@@ -463,6 +464,13 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 		return ldb_op_finish(ldb, ret);
 	}
 
+	if (ldb->err_string == NULL) {
+		/* no error string was setup by the backend */
+		ldb_set_errstring(ldb, 
+				  talloc_asprintf(ldb, "%s (%d)", 
+						  ldb_strerror(ret), ret));
+	}
+
 	return ret;
 }
 
-- 
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/common/ldb.c | 65 ++++++++++++++++++++++++++++++--------------
 1 file changed, 44 insertions(+), 21 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 126ad37d9b..b6c22437bd 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -140,6 +140,9 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 		return LDB_ERR_OTHER;
 	}
 
+	/* TODO: get timeout from options if available there */
+	ldb->default_timeout = 300; /* set default to 5 minutes */
+
 	return LDB_SUCCESS;
 }
 
@@ -252,24 +255,41 @@ int ldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type typ
 	return handle->module->ops->async_wait(handle, type);
 }
 
-
-/*
-  check for an error return from an op 
-  if an op fails, but has not setup an error string, then setup one now
-*/
-static int ldb_op_finish(struct ldb_context *ldb, int status)
+/* set the specified timeout or, if timeout is 0 set the default timeout */
+/* timeout == -1 means no timeout */
+int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeout)
 {
-	if (status == LDB_SUCCESS) {
-		return ldb_transaction_commit(ldb);
+	if (req == NULL) return LDB_ERR_OPERATIONS_ERROR;
+	
+	if (timeout != 0) {
+		req->async.timeout = timeout;
+	} else {
+		req->async.timeout = ldb->default_timeout;
 	}
-	if (ldb->err_string == NULL) {
-		/* no error string was setup by the backend */
-		ldb_set_errstring(ldb, 
-				  talloc_asprintf(ldb, "%s (%d)", 
-						  ldb_strerror(status), status));
+	req->async.starttime = time(NULL);
+
+	return LDB_SUCCESS;
+}
+
+/* calculates the new timeout based on the previous starttime and timeout */
+int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *oldreq, struct ldb_request *newreq)
+{
+	time_t now;
+
+	if (newreq == NULL) return LDB_ERR_OPERATIONS_ERROR;
+
+	now = time(NULL);
+
+	if (oldreq == NULL)
+		return ldb_set_timeout(ldb, newreq, 0);
+
+	if ((now - oldreq->async.starttime) > oldreq->async.timeout) {
+		return LDB_ERR_TIME_LIMIT_EXCEEDED;
 	}
-	ldb_transaction_cancel(ldb);
-	return status;
+	newreq->async.starttime = oldreq->async.starttime;
+	newreq->async.timeout = oldreq->async.timeout - (now - oldreq->async.starttime);
+
+	return LDB_SUCCESS;
 }
 
 /*
@@ -424,7 +444,7 @@ int ldb_search(struct ldb_context *ldb,
 	req->controls = NULL;
 	req->async.context = res;
 	req->async.callback = ldb_search_callback;
-	req->async.timeout = 600; /* 10 minutes */
+	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	ret = ldb_request(ldb, req);
 	
@@ -461,7 +481,10 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 	}
 
 	if (close_transaction) {
-		return ldb_op_finish(ldb, ret);
+		if (ret == LDB_SUCCESS) {
+			return ldb_transaction_commit(ldb);
+		}
+		ldb_transaction_cancel(ldb);
 	}
 
 	if (ldb->err_string == NULL) {
@@ -499,7 +522,7 @@ int ldb_add(struct ldb_context *ldb,
 	req->controls = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
-	req->async.timeout = 600; /* 10 minutes */
+	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
 	ret = ldb_autotransaction_request(ldb, req);
@@ -531,7 +554,7 @@ int ldb_modify(struct ldb_context *ldb,
 	req->controls = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
-	req->async.timeout = 600; /* 10 minutes */
+	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
 	ret = ldb_autotransaction_request(ldb, req);
@@ -560,7 +583,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 	req->controls = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
-	req->async.timeout = 600; /* 10 minutes */
+	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
 	ret = ldb_autotransaction_request(ldb, req);
@@ -589,7 +612,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 	req->controls = NULL;
 	req->async.context = NULL;
 	req->async.callback = NULL;
-	req->async.timeout = 600; /* 10 minutes */
+	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
 	ret = ldb_autotransaction_request(ldb, req);
-- 
cgit 


From 2452d41b2292c2f48de99a519e2cb948709daa76 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 7 Jun 2006 00:55:48 +0000
Subject: r16071: tdb has nested transactions change the code to exploit that
 in ldb

I still have to reintroduce transactions when you call ldb_request directly,
I have some plans I hop to be able to develop in the next weekend
(This used to be commit 35111206021d667dfd217b5fd8d82f5c2714cc9e)
---
 source4/lib/ldb/common/ldb.c | 139 ++++++++++++++++++++++++++-----------------
 1 file changed, 86 insertions(+), 53 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index b6c22437bd..1fdbeb55d2 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -171,13 +171,11 @@ void ldb_reset_err_string(struct ldb_context *ldb)
 /*
   start a transaction
 */
-int ldb_transaction_start(struct ldb_context *ldb)
+static int ldb_transaction_start_internal(struct ldb_context *ldb)
 {
 	struct ldb_module *module;
 	int status;
 	FIRST_OP(ldb, start_transaction);
-	
-	ldb->transaction_active++;
 
 	ldb_reset_err_string(ldb);
 
@@ -195,18 +193,12 @@ int ldb_transaction_start(struct ldb_context *ldb)
 /*
   commit a transaction
 */
-int ldb_transaction_commit(struct ldb_context *ldb)
+static int ldb_transaction_commit_internal(struct ldb_context *ldb)
 {
 	struct ldb_module *module;
 	int status;
 	FIRST_OP(ldb, end_transaction);
 
-	if (ldb->transaction_active > 0) {
-		ldb->transaction_active--;
-	} else {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
 	ldb_reset_err_string(ldb);
 
 	status = module->ops->end_transaction(module);
@@ -223,18 +215,12 @@ int ldb_transaction_commit(struct ldb_context *ldb)
 /*
   cancel a transaction
 */
-int ldb_transaction_cancel(struct ldb_context *ldb)
+static int ldb_transaction_cancel_internal(struct ldb_context *ldb)
 {
 	struct ldb_module *module;
 	int status;
 	FIRST_OP(ldb, del_transaction);
 
-	if (ldb->transaction_active > 0) {
-		ldb->transaction_active--;
-	} else {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
 	status = module->ops->del_transaction(module);
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
@@ -246,6 +232,89 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 	return status;
 }
 
+int ldb_transaction_start(struct ldb_context *ldb)
+{
+	/* disable autotransactions */
+	ldb->transaction_active++;
+
+	return ldb_transaction_start_internal(ldb);
+}
+
+int ldb_transaction_commit(struct ldb_context *ldb)
+{
+	/* renable autotransactions (when we reach 0) */
+	if (ldb->transaction_active > 0)
+		ldb->transaction_active--;
+
+	return ldb_transaction_commit_internal(ldb);
+}
+
+int ldb_transaction_cancel(struct ldb_context *ldb)
+{
+	/* renable autotransactions (when we reach 0) */
+	if (ldb->transaction_active > 0)
+		ldb->transaction_active--;
+
+	return ldb_transaction_cancel_internal(ldb);
+}
+
+int ldb_autotransaction_start(struct ldb_context *ldb)
+{
+	/* explicit transaction active, ignore autotransaction request */
+	if (ldb->transaction_active)
+		return LDB_SUCCESS;
+
+	return ldb_transaction_start_internal(ldb);
+}
+
+int ldb_autotransaction_commit(struct ldb_context *ldb)
+{
+	/* explicit transaction active, ignore autotransaction request */
+	if (ldb->transaction_active)
+		return LDB_SUCCESS;
+
+	return ldb_transaction_commit_internal(ldb);
+}
+
+int ldb_autotransaction_cancel(struct ldb_context *ldb)
+{
+	/* explicit transaction active, ignore autotransaction request */
+	if (ldb->transaction_active)
+		return LDB_SUCCESS;
+
+	return ldb_transaction_cancel_internal(ldb);
+}
+
+/* autostarts a transacion if none active */
+static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_request *req)
+{
+	int ret;
+
+	ret = ldb_autotransaction_start(ldb);
+	if (ret != LDB_SUCCESS) {
+		return ret;
+	}
+
+	ret = ldb_request(ldb, req);
+	if (ret == LDB_SUCCESS) {
+		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
+	}
+
+	if (ret == LDB_SUCCESS) {
+		return ldb_autotransaction_commit(ldb);
+	}
+	ldb_autotransaction_cancel(ldb);
+
+	if (ldb->err_string == NULL) {
+		/* no error string was setup by the backend */
+		ldb_set_errstring(ldb, 
+				  talloc_asprintf(ldb, "%s (%d)", 
+						  ldb_strerror(ret), ret));
+	}
+
+	return ret;
+}
+
 int ldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
 {
 	if (!handle) {
@@ -461,42 +530,6 @@ int ldb_search(struct ldb_context *ldb,
 	return ret;
 }
 
-/* autostarts a transacion if none active */
-static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_request *req)
-{
-	int ret, close_transaction;
-
-	close_transaction = 0;
-	if (!ldb->transaction_active) {
-		ret = ldb_transaction_start(ldb);
-		if (ret != LDB_SUCCESS) {
-			return ret;
-		}
-		close_transaction = 1;
-	}
-
-	ret = ldb_request(ldb, req);
-	if (ret == LDB_SUCCESS) {
-		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
-	}
-
-	if (close_transaction) {
-		if (ret == LDB_SUCCESS) {
-			return ldb_transaction_commit(ldb);
-		}
-		ldb_transaction_cancel(ldb);
-	}
-
-	if (ldb->err_string == NULL) {
-		/* no error string was setup by the backend */
-		ldb_set_errstring(ldb, 
-				  talloc_asprintf(ldb, "%s (%d)", 
-						  ldb_strerror(ret), ret));
-	}
-
-	return ret;
-}
-
 
 /*
   add a record to the database. Will fail if a record with the given class and key
-- 
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/common/ldb.c | 70 +++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 66 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 1fdbeb55d2..ff5d2a2e8b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -91,16 +91,20 @@ static ldb_connect_fn ldb_find_backend(const char *url)
 }
 
 /* 
- connect to a database. The URL can either be one of the following forms
+   Return the ldb module form of a database. The URL can either be one of the following forms
    ldb://path
    ldapi://path
 
    flags is made up of LDB_FLG_*
 
    the options are passed uninterpreted to the backend, and are
-   backend specific
+   backend specific.
+
+  This allows modules to get at only the backend module, for example where a module 
+  may wish to direct certain requests at a particular backend.
 */
-int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[])
+int ldb_connect_backend(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[],
+			struct ldb_module **backend_module)
 {
 	int ret;
 	char *backend;
@@ -128,12 +132,34 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 		return LDB_ERR_OTHER;
 	}
 
-	ret = fn(ldb, url, flags, options);
+	ret = fn(ldb, url, flags, options, backend_module);
 
 	if (ret != LDB_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'\n", url);
 		return ret;
 	}
+	return ret;
+}
+
+
+/* 
+ connect to a database. The URL can either be one of the following forms
+   ldb://path
+   ldapi://path
+
+   flags is made up of LDB_FLG_*
+
+   the options are passed uninterpreted to the backend, and are
+   backend specific
+*/
+int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[])
+{
+	int ret;
+
+	ret = ldb_connect_backend(ldb, url, flags, options, &ldb->modules);
+	if (ret != LDB_SUCCESS) {
+		return ret;
+	}
 
 	if (ldb_load_modules(ldb, options) != LDB_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for '%s'\n", url);
@@ -395,6 +421,10 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 		FIRST_OP(ldb, rename);
 		ret = module->ops->rename(module, req);
 		break;
+	case LDB_SEQUENCE_NUMBER:
+		FIRST_OP(ldb, sequence_number);
+		ret = module->ops->sequence_number(module, req);
+		break;
 	default:
 		FIRST_OP(ldb, request);
 		ret = module->ops->request(module, req);
@@ -655,6 +685,38 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 }
 
 
+/*
+  rename a record in the database
+*/
+int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num)
+{
+	struct ldb_request *req;
+	int ret;
+
+	req = talloc(ldb, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_SEQUENCE_NUMBER;
+	req->controls = NULL;
+	req->async.context = NULL;
+	req->async.callback = NULL;
+	ldb_set_timeout(ldb, req, 0); /* use default timeout */
+
+	/* do request and autostart a transaction */
+	ret = ldb_request(ldb, req);
+	
+	if (ret == LDB_SUCCESS) {
+		*seq_num = req->op.seq_num.seq_num;
+	}
+
+	talloc_free(req);
+	return ret;
+}
+
+
 
 /*
   return extended error information 
-- 
cgit 


From 6664ac88860d3e6d21ce6fdf06d2ff927496a31a Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 8 Jun 2006 00:58:57 +0000
Subject: r16085: Set the error string if we fail to find a valid op to
 execute.  Helps in chasing down bugs :-)

Andrew Bartlett
(This used to be commit 9ede8edbaf1731f32814917439326f49b5f9f3ef)
---
 source4/lib/ldb/common/ldb.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ff5d2a2e8b..857c995a0e 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -189,9 +189,13 @@ void ldb_reset_err_string(struct ldb_context *ldb)
 }
 
 #define FIRST_OP(ldb, op) do { \
-	module = ldb->modules; \
+	module = ldb->modules;					\
 	while (module && module->ops->op == NULL) module = module->next; \
-	if (module == NULL) return LDB_ERR_OPERATIONS_ERROR; \
+	if (module == NULL) {						\
+		ldb_set_errstring(ldb, \
+				  talloc_asprintf(ldb, "unable to find module or backend to handle operation: " #op)); \
+		return LDB_ERR_OPERATIONS_ERROR;			\
+	} \
 } while (0)
 
 /*
-- 
cgit 


From a42365befc91b673c478d9a8520a49b9fd7d724b Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Mon, 12 Jun 2006 21:29:21 +0000
Subject: r16172: Translate the ldb error codes into appropriate messages for
 the transaction cases.

Andrew Bartlett
(This used to be commit 28883f719304ee438c54a4d33e6bf1239f8c4094)
---
 source4/lib/ldb/common/ldb.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 857c995a0e..1022f422c0 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -214,7 +214,9 @@ static int ldb_transaction_start_internal(struct ldb_context *ldb)
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
 			ldb_set_errstring(ldb, 
-					  talloc_asprintf(ldb, "ldb transaction start error %d", status));
+					  talloc_asprintf(ldb, "ldb transaction start: %s (%d)", 
+							  ldb_strerror(status), 
+							  status));
 		}
 	}
 	return status;
@@ -236,7 +238,9 @@ static int ldb_transaction_commit_internal(struct ldb_context *ldb)
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
 			ldb_set_errstring(ldb, 
-					  talloc_asprintf(ldb, "ldb transaction commit error %d", status));
+					  talloc_asprintf(ldb, "ldb transaction commit: %s (%d)", 
+							  ldb_strerror(status), 
+							  status));
 		}
 	}
 	return status;
@@ -256,7 +260,9 @@ static int ldb_transaction_cancel_internal(struct ldb_context *ldb)
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
 			ldb_set_errstring(ldb, 
-					  talloc_asprintf(ldb, "ldb transaction cancel error %d", status));
+					  talloc_asprintf(ldb, "ldb transaction cancel: %s (%d)", 
+							  ldb_strerror(status), 
+							  status));
 		}
 	}
 	return status;
-- 
cgit 


From a3f606f6cab58e7e15f8a4f6a05a7437dc0569c8 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 3 Jul 2006 15:49:23 +0000
Subject: r16784: - make some function in ldb static, they not need to be
 exported anywhere

- fix a bad segfault
  Andrew please make test before committing.

Simo.
(This used to be commit b9b6bb3e89d3b0e04ccce15156c1a128b6f20d88)
---
 source4/lib/ldb/common/ldb.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 1022f422c0..5228eeb6b3 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -294,7 +294,7 @@ int ldb_transaction_cancel(struct ldb_context *ldb)
 	return ldb_transaction_cancel_internal(ldb);
 }
 
-int ldb_autotransaction_start(struct ldb_context *ldb)
+static int ldb_autotransaction_start(struct ldb_context *ldb)
 {
 	/* explicit transaction active, ignore autotransaction request */
 	if (ldb->transaction_active)
@@ -303,7 +303,7 @@ int ldb_autotransaction_start(struct ldb_context *ldb)
 	return ldb_transaction_start_internal(ldb);
 }
 
-int ldb_autotransaction_commit(struct ldb_context *ldb)
+static int ldb_autotransaction_commit(struct ldb_context *ldb)
 {
 	/* explicit transaction active, ignore autotransaction request */
 	if (ldb->transaction_active)
@@ -312,7 +312,7 @@ int ldb_autotransaction_commit(struct ldb_context *ldb)
 	return ldb_transaction_commit_internal(ldb);
 }
 
-int ldb_autotransaction_cancel(struct ldb_context *ldb)
+static int ldb_autotransaction_cancel(struct ldb_context *ldb)
 {
 	/* explicit transaction active, ignore autotransaction request */
 	if (ldb->transaction_active)
-- 
cgit 


From 44e6f21393ea6f2531c6d1e789a0a01582bc6dca Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 6 Jul 2006 05:08:30 +0000
Subject: r16825: Make ldb_sainity_check() set an error string.  This makes it
 much easier to chase down what modules or application code gets wrong.

Ensure not to leave memory allocated on failure in ldb_search()

Andrew Bartlett
(This used to be commit 0828739951ed879640f8ed6e4700d8ca6b8221b8)
---
 source4/lib/ldb/common/ldb.c | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 5228eeb6b3..c059646629 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -527,11 +527,8 @@ int ldb_search(struct ldb_context *ldb,
 	struct ldb_request *req;
 	int ret;
 
-	*res = talloc_zero(ldb, struct ldb_result);
-	if (! *res) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
+	*res = NULL;
+	
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
 		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
@@ -549,6 +546,12 @@ int ldb_search(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	*res = talloc_zero(ldb, struct ldb_result);
+	if (! *res) {
+		talloc_free(req);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
 	req->op.search.attrs = attrs;
 	req->controls = NULL;
 	req->async.context = res;
@@ -581,9 +584,11 @@ int ldb_add(struct ldb_context *ldb,
 	struct ldb_request *req;
 	int ret;
 
-	ret = ldb_msg_sanity_check(message);
-	if (ret != LDB_SUCCESS) return ret;
-
+	ret = ldb_msg_sanity_check(ldb, message);
+	if (ret != LDB_SUCCESS) {
+		return ret;
+	}
+		
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
 		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
@@ -613,7 +618,7 @@ int ldb_modify(struct ldb_context *ldb,
 	struct ldb_request *req;
 	int ret;
 
-	ret = ldb_msg_sanity_check(message);
+	ret = ldb_msg_sanity_check(ldb, message);
 	if (ret != LDB_SUCCESS) return ret;
 
 	req = talloc(ldb, struct ldb_request);
-- 
cgit 


From 32ab51876728577375b954a04103f71ddd4d93dc Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 12 Jul 2006 04:59:41 +0000
Subject: r16972: Replace the sequence_number function pointer in ldb with the
 ldb flags.

The function pointer was meant to be unused, this patch fixes
partition.c to use ldb_sequence_number().  (No backend provided the
pointer any more).

Set the flags onto the ldb structure, so that all backends opened by
the partitions module inherit the flags.

Set the read-ony flag when accessed as the global catalog

Modify the LDAP server to track that this query is for the global
catalog (by incoming port), and set a opqaue pointer.

Next step is to read that opaque pointer in the partitions module.

Andrew Bartlett
(This used to be commit a1161cb30e4ffa09657a89e03ca85dd6efd4feba)
---
 source4/lib/ldb/common/ldb.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index c059646629..8e814778d1 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -103,7 +103,7 @@ static ldb_connect_fn ldb_find_backend(const char *url)
   This allows modules to get at only the backend module, for example where a module 
   may wish to direct certain requests at a particular backend.
 */
-int ldb_connect_backend(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[],
+int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *options[],
 			struct ldb_module **backend_module)
 {
 	int ret;
@@ -132,7 +132,7 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, unsigned int f
 		return LDB_ERR_OTHER;
 	}
 
-	ret = fn(ldb, url, flags, options, backend_module);
+	ret = fn(ldb, url, ldb->flags, options, backend_module);
 
 	if (ret != LDB_SUCCESS) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'\n", url);
@@ -156,7 +156,9 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 {
 	int ret;
 
-	ret = ldb_connect_backend(ldb, url, flags, options, &ldb->modules);
+	ldb->flags = flags;
+
+	ret = ldb_connect_backend(ldb, url, options, &ldb->modules);
 	if (ret != LDB_SUCCESS) {
 		return ret;
 	}
@@ -701,7 +703,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 
 
 /*
-  rename a record in the database
+  return the global sequence number
 */
 int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num)
 {
-- 
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/common/ldb.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 8e814778d1..a962aa4322 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -335,7 +335,7 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 
 	ret = ldb_request(ldb, req);
 	if (ret == LDB_SUCCESS) {
-		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
+		ret = ldb_wait(req->async.handle, LDB_WAIT_ALL);
 	}
 
 	if (ret == LDB_SUCCESS) {
@@ -353,13 +353,13 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 	return ret;
 }
 
-int ldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 {
 	if (!handle) {
 		return LDB_SUCCESS;
 	}
 
-	return handle->module->ops->async_wait(handle, type);
+	return handle->module->ops->wait(handle, type);
 }
 
 /* set the specified timeout or, if timeout is 0 set the default timeout */
@@ -454,7 +454,7 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
   Use talloc_free to free the ldb_message returned in 'res', if successful
 
 */
-static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
+static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
 {
 	struct ldb_result *res;
 	int n;
@@ -563,7 +563,7 @@ int ldb_search(struct ldb_context *ldb,
 	ret = ldb_request(ldb, req);
 	
 	if (ret == LDB_SUCCESS) {
-		ret = ldb_async_wait(req->async.handle, LDB_WAIT_ALL);
+		ret = ldb_wait(req->async.handle, LDB_WAIT_ALL);
 	}
 	
 	if (ret != LDB_SUCCESS) {
-- 
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/common/ldb.c | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index a962aa4322..9420318fa9 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -335,7 +335,7 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 
 	ret = ldb_request(ldb, req);
 	if (ret == LDB_SUCCESS) {
-		ret = ldb_wait(req->async.handle, LDB_WAIT_ALL);
+		ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 	}
 
 	if (ret == LDB_SUCCESS) {
@@ -369,11 +369,11 @@ int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeou
 	if (req == NULL) return LDB_ERR_OPERATIONS_ERROR;
 	
 	if (timeout != 0) {
-		req->async.timeout = timeout;
+		req->timeout = timeout;
 	} else {
-		req->async.timeout = ldb->default_timeout;
+		req->timeout = ldb->default_timeout;
 	}
-	req->async.starttime = time(NULL);
+	req->starttime = time(NULL);
 
 	return LDB_SUCCESS;
 }
@@ -390,11 +390,11 @@ int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *o
 	if (oldreq == NULL)
 		return ldb_set_timeout(ldb, newreq, 0);
 
-	if ((now - oldreq->async.starttime) > oldreq->async.timeout) {
+	if ((now - oldreq->starttime) > oldreq->timeout) {
 		return LDB_ERR_TIME_LIMIT_EXCEEDED;
 	}
-	newreq->async.starttime = oldreq->async.starttime;
-	newreq->async.timeout = oldreq->async.timeout - (now - oldreq->async.starttime);
+	newreq->starttime = oldreq->starttime;
+	newreq->timeout = oldreq->timeout - (now - oldreq->starttime);
 
 	return LDB_SUCCESS;
 }
@@ -556,14 +556,14 @@ int ldb_search(struct ldb_context *ldb,
 
 	req->op.search.attrs = attrs;
 	req->controls = NULL;
-	req->async.context = res;
-	req->async.callback = ldb_search_callback;
+	req->context = res;
+	req->callback = ldb_search_callback;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	ret = ldb_request(ldb, req);
 	
 	if (ret == LDB_SUCCESS) {
-		ret = ldb_wait(req->async.handle, LDB_WAIT_ALL);
+		ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 	}
 	
 	if (ret != LDB_SUCCESS) {
@@ -600,8 +600,8 @@ int ldb_add(struct ldb_context *ldb,
 	req->operation = LDB_ADD;
 	req->op.add.message = message;
 	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
+	req->context = NULL;
+	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
@@ -632,8 +632,8 @@ int ldb_modify(struct ldb_context *ldb,
 	req->operation = LDB_MODIFY;
 	req->op.add.message = message;
 	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
+	req->context = NULL;
+	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
@@ -661,8 +661,8 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 	req->operation = LDB_DELETE;
 	req->op.del.dn = dn;
 	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
+	req->context = NULL;
+	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
@@ -690,8 +690,8 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 	req->op.rename.olddn = olddn;
 	req->op.rename.newdn = newdn;
 	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
+	req->context = NULL;
+	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
@@ -718,8 +718,8 @@ int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num)
 
 	req->operation = LDB_SEQUENCE_NUMBER;
 	req->controls = NULL;
-	req->async.context = NULL;
-	req->async.callback = NULL;
+	req->context = NULL;
+	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
-- 
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/common/ldb.c | 64 +++++++++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 27 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 9420318fa9..ce42a36a59 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -174,12 +174,25 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	return LDB_SUCCESS;
 }
 
-void ldb_set_errstring(struct ldb_context *ldb, char *err_string)
+void ldb_set_errstring(struct ldb_context *ldb, const char *err_string)
 {
 	if (ldb->err_string) {
 		talloc_free(ldb->err_string);
 	}
-	ldb->err_string = talloc_steal(ldb, err_string);
+	ldb->err_string = talloc_strdup(ldb, err_string);
+}
+
+void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...)
+{
+	va_list ap;
+
+	if (ldb->err_string) {
+		talloc_free(ldb->err_string);
+	}
+
+	va_start(ap, format);
+	ldb->err_string = talloc_vasprintf(ldb, format, ap);
+	va_end(ap);
 }
 
 void ldb_reset_err_string(struct ldb_context *ldb)
@@ -194,8 +207,7 @@ void ldb_reset_err_string(struct ldb_context *ldb)
 	module = ldb->modules;					\
 	while (module && module->ops->op == NULL) module = module->next; \
 	if (module == NULL) {						\
-		ldb_set_errstring(ldb, \
-				  talloc_asprintf(ldb, "unable to find module or backend to handle operation: " #op)); \
+		ldb_asprintf_errstring(ldb, "unable to find module or backend to handle operation: " #op); \
 		return LDB_ERR_OPERATIONS_ERROR;			\
 	} \
 } while (0)
@@ -215,10 +227,10 @@ static int ldb_transaction_start_internal(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_set_errstring(ldb, 
-					  talloc_asprintf(ldb, "ldb transaction start: %s (%d)", 
-							  ldb_strerror(status), 
-							  status));
+			ldb_asprintf_errstring(ldb,
+						"ldb transaction start: %s (%d)", 
+						ldb_strerror(status), 
+						status);
 		}
 	}
 	return status;
@@ -239,10 +251,10 @@ static int ldb_transaction_commit_internal(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_set_errstring(ldb, 
-					  talloc_asprintf(ldb, "ldb transaction commit: %s (%d)", 
-							  ldb_strerror(status), 
-							  status));
+			ldb_asprintf_errstring(ldb, 
+						"ldb transaction commit: %s (%d)", 
+						ldb_strerror(status), 
+						status);
 		}
 	}
 	return status;
@@ -261,10 +273,10 @@ static int ldb_transaction_cancel_internal(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_set_errstring(ldb, 
-					  talloc_asprintf(ldb, "ldb transaction cancel: %s (%d)", 
-							  ldb_strerror(status), 
-							  status));
+			ldb_asprintf_errstring(ldb, 
+						"ldb transaction cancel: %s (%d)", 
+						ldb_strerror(status), 
+						status);
 		}
 	}
 	return status;
@@ -345,9 +357,7 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 
 	if (ldb->err_string == NULL) {
 		/* no error string was setup by the backend */
-		ldb_set_errstring(ldb, 
-				  talloc_asprintf(ldb, "%s (%d)", 
-						  ldb_strerror(ret), ret));
+		ldb_asprintf_errstring(ldb, "%s (%d)", ldb_strerror(ret), ret);
 	}
 
 	return ret;
@@ -460,7 +470,7 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 	int n;
 	
  	if (!context) {
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context in callback"));
+		ldb_set_errstring(ldb, "NULL Context in callback");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}	
 
@@ -533,7 +543,7 @@ int ldb_search(struct ldb_context *ldb,
 	
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		ldb_set_errstring(ldb, "Out of Memory");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -543,7 +553,7 @@ int ldb_search(struct ldb_context *ldb,
 
 	req->op.search.tree = ldb_parse_tree(req, expression);
 	if (req->op.search.tree == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Unable to parse search expression"));
+		ldb_set_errstring(ldb, "Unable to parse search expression");
 		talloc_free(req);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -593,7 +603,7 @@ int ldb_add(struct ldb_context *ldb,
 		
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		ldb_set_errstring(ldb, "Out of Memory");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -625,7 +635,7 @@ int ldb_modify(struct ldb_context *ldb,
 
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		ldb_set_errstring(ldb, "Out of Memory!");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -654,7 +664,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		ldb_set_errstring(ldb, "Out of Memory!");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -682,7 +692,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		ldb_set_errstring(ldb, "Out of Memory!");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -712,7 +722,7 @@ int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num)
 
 	req = talloc(ldb, struct ldb_request);
 	if (req == NULL) {
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "Out of memory!"));
+		ldb_set_errstring(ldb, "Out of Memory");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-- 
cgit 


From a2ca0b5e3cf2e1ac485f7046d67de9fc4e5171f9 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 25 Aug 2006 06:41:37 +0000
Subject: r17821: changed ldb_search() and the ldbsearch command line utility
 to automatically work out the basedn when basedn==NULL. The basedn is fetched
 from the rootDSE defaultNamingContext value (if there is one)

This means we don't have to have the defaultNamingContext logic in
lots of places. It makes a lot of sense to me to have basedn==NULL
mean "use the default, as given by the database"

Note that explicitly specifing a basedn of '' is not the same thing,
and will not trigger this code

The baseDN is cached in a ldb opaque, so we only have to fetch it once
(This used to be commit 5d1b66b68fc517ce684f75e466ed5f25e46857d5)
---
 source4/lib/ldb/common/ldb.c | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ce42a36a59..f49fb2d955 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -529,6 +529,43 @@ error:
 	return LDB_ERR_OPERATIONS_ERROR;
 }
 
+/*
+  try to autodetect a basedn if none specified. This fixes one of my
+  pet hates about ldapsearch, which is that you have to get a long,
+  complex basedn right to make any use of it.
+*/
+const struct ldb_dn *ldb_auto_basedn(struct ldb_context *ldb)
+{
+	TALLOC_CTX *tmp_ctx;
+	int ret;
+	static const char *attrs[] = { "defaultNamingContext", NULL };
+	struct ldb_result *res;
+	struct ldb_dn *basedn=NULL;
+
+	basedn = ldb_get_opaque(ldb, "auto_baseDN");
+	if (basedn) {
+		return basedn;
+	}
+
+	tmp_ctx = talloc_new(ldb);
+	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx), LDB_SCOPE_BASE, 
+			 "(objectClass=*)", attrs, &res);
+	if (ret == LDB_SUCCESS && res->count == 1) {
+		basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
+	}
+
+	if (basedn) {
+		ldb_set_opaque(ldb, "auto_baseDN", basedn);
+	}
+
+	talloc_free(tmp_ctx);
+	return basedn;
+}
+
+/*
+  note that ldb_search() will automatically replace a NULL 'base' value with the 
+  defaultNamingContext from the rootDSE if available.
+*/
 int ldb_search(struct ldb_context *ldb, 
 	       const struct ldb_dn *base,
 	       enum ldb_scope scope,
@@ -547,6 +584,10 @@ int ldb_search(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	if (base == NULL) {
+		base = ldb_auto_basedn(ldb);
+	}
+
 	req->operation = LDB_SEARCH;
 	req->op.search.base = base;
 	req->op.search.scope = scope;
-- 
cgit 


From 60898ca0b7cf3cacc160e430441cb7f701bbd389 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 25 Aug 2006 12:45:19 +0000
Subject: r17828: set the auto_baseDN opaque even on failure to fetch rootDSE.
 That ensures we never try twice (This used to be commit
 946901e5dde9d31727448070a06e56da38d4a59e)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index f49fb2d955..db5333187b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -554,9 +554,7 @@ const struct ldb_dn *ldb_auto_basedn(struct ldb_context *ldb)
 		basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
 	}
 
-	if (basedn) {
-		ldb_set_opaque(ldb, "auto_baseDN", basedn);
-	}
+	ldb_set_opaque(ldb, "auto_baseDN", basedn);
 
 	talloc_free(tmp_ctx);
 	return basedn;
-- 
cgit 


From 88b04ab6e65137079b2dad76d1cea07e7ea9ab80 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 25 Aug 2006 12:59:03 +0000
Subject: r17830: Set the default_basedn (hey, it comes from the "default"
 naming contex :-) once at connection time, after modules have been loaded.

Introduce a function to retrieve the value where needed.
(This used to be commit 0caf6a44e03393c645030a9288e7dfd31e97c98b)
---
 source4/lib/ldb/common/ldb.c | 71 ++++++++++++++++++++++++--------------------
 1 file changed, 39 insertions(+), 32 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index db5333187b..04ac3e7d81 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -141,6 +141,41 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
 	return ret;
 }
 
+/*
+  try to autodetect a basedn if none specified. This fixes one of my
+  pet hates about ldapsearch, which is that you have to get a long,
+  complex basedn right to make any use of it.
+*/
+static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
+{
+	TALLOC_CTX *tmp_ctx;
+	int ret;
+	static const char *attrs[] = { "defaultNamingContext", NULL };
+	struct ldb_result *res;
+	struct ldb_dn *basedn=NULL;
+
+	basedn = ldb_get_opaque(ldb, "default_baseDN");
+	if (basedn) {
+		return basedn;
+	}
+
+	tmp_ctx = talloc_new(ldb);
+	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx), LDB_SCOPE_BASE, 
+			 "(objectClass=*)", attrs, &res);
+	if (ret == LDB_SUCCESS && res->count == 1) {
+		basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
+	}
+
+	ldb_set_opaque(ldb, "default_baseDN", basedn);
+
+	talloc_free(tmp_ctx);
+	return basedn;
+}
+
+const struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
+{
+	return ldb_get_opaque(ldb, "default_baseDN");
+}
 
 /* 
  connect to a database. The URL can either be one of the following forms
@@ -171,6 +206,9 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	/* TODO: get timeout from options if available there */
 	ldb->default_timeout = 300; /* set default to 5 minutes */
 
+	/* set the default base dn */
+	ldb_set_default_basedn(ldb);
+
 	return LDB_SUCCESS;
 }
 
@@ -529,37 +567,6 @@ error:
 	return LDB_ERR_OPERATIONS_ERROR;
 }
 
-/*
-  try to autodetect a basedn if none specified. This fixes one of my
-  pet hates about ldapsearch, which is that you have to get a long,
-  complex basedn right to make any use of it.
-*/
-const struct ldb_dn *ldb_auto_basedn(struct ldb_context *ldb)
-{
-	TALLOC_CTX *tmp_ctx;
-	int ret;
-	static const char *attrs[] = { "defaultNamingContext", NULL };
-	struct ldb_result *res;
-	struct ldb_dn *basedn=NULL;
-
-	basedn = ldb_get_opaque(ldb, "auto_baseDN");
-	if (basedn) {
-		return basedn;
-	}
-
-	tmp_ctx = talloc_new(ldb);
-	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx), LDB_SCOPE_BASE, 
-			 "(objectClass=*)", attrs, &res);
-	if (ret == LDB_SUCCESS && res->count == 1) {
-		basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
-	}
-
-	ldb_set_opaque(ldb, "auto_baseDN", basedn);
-
-	talloc_free(tmp_ctx);
-	return basedn;
-}
-
 /*
   note that ldb_search() will automatically replace a NULL 'base' value with the 
   defaultNamingContext from the rootDSE if available.
@@ -583,7 +590,7 @@ int ldb_search(struct ldb_context *ldb,
 	}
 
 	if (base == NULL) {
-		base = ldb_auto_basedn(ldb);
+		base = ldb_get_default_basedn(ldb);
 	}
 
 	req->operation = LDB_SEARCH;
-- 
cgit 


From f140bd7e38947847a1bb9a42dbb9c6760e5c3756 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Fri, 8 Sep 2006 04:04:30 +0000
Subject: r18245: Ensure we don't keep the rootdse record around (steal it onto
 the correct memory context).

Andrew Bartlett
(This used to be commit b4f234e507fa94e9600c362fb6edb704d299cfce)
---
 source4/lib/ldb/common/ldb.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 04ac3e7d81..5aa243ac7a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -162,12 +162,14 @@ static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
 	tmp_ctx = talloc_new(ldb);
 	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx), LDB_SCOPE_BASE, 
 			 "(objectClass=*)", attrs, &res);
-	if (ret == LDB_SUCCESS && res->count == 1) {
-		basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
+	if (ret == LDB_SUCCESS) {
+		talloc_steal(tmp_ctx, res);
+		if (res->count == 1) {
+			basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
+			ldb_set_opaque(ldb, "default_baseDN", basedn);
+		}
 	}
 
-	ldb_set_opaque(ldb, "default_baseDN", basedn);
-
 	talloc_free(tmp_ctx);
 	return basedn;
 }
-- 
cgit 


From a865dcf02fa5e523492ba194dc6a941c2e70847a Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 8 Sep 2006 14:32:36 +0000
Subject: r18272: Couldn't resist to change this. What we want to do here is to
 just make sure res is freed. Well let's just do so explicitly, the steal
 cofused me initially while reading the code. This way it is clear what we
 want to do.

Simo.
(This used to be commit 30a26a501fef939991a2e998003c5a43fd5cb67e)
---
 source4/lib/ldb/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 5aa243ac7a..991a810135 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -163,11 +163,11 @@ static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
 	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx), LDB_SCOPE_BASE, 
 			 "(objectClass=*)", attrs, &res);
 	if (ret == LDB_SUCCESS) {
-		talloc_steal(tmp_ctx, res);
 		if (res->count == 1) {
 			basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
 			ldb_set_opaque(ldb, "default_baseDN", basedn);
 		}
+		talloc_free(res);
 	}
 
 	talloc_free(tmp_ctx);
-- 
cgit 


From 7f63cebd331793d059b1dbfd2f7d7ce38105c4fe Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 13 Sep 2006 00:10:38 +0000
Subject: r18436: converted ldb to use talloc_move() instead of talloc_steal()
 when appropriate.

Note that I also removed the error checks that were being done on the
result of talloc_steal(). They are pointless as talloc_steal() doesn't
have any failure modes that wouldn't cause a segv anyway, and they
tend to clutter the code
(This used to be commit c0d9e7d473b8e3eb2524a9fc29cf88680f994b36)
---
 source4/lib/ldb/common/ldb.c | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 991a810135..50ec106d84 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -528,11 +528,7 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 
 		res->msgs[res->count + 1] = NULL;
 
-		res->msgs[res->count] = talloc_steal(res->msgs, ares->message);
-		if (! res->msgs[res->count]) {
-			goto error;
-		}
-
+		res->msgs[res->count] = talloc_move(res->msgs, ares->message);
 		res->count++;
 	}
 
@@ -548,15 +544,12 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 			goto error;
 		}
 
-		res->refs[n] = talloc_steal(res->refs, ares->referral);
+		res->refs[n] = talloc_move(res->refs, ares->referral);
 		res->refs[n + 1] = NULL;
 	}
 
 	if (ares->controls) {
-		res->controls = talloc_steal(res, ares->controls);
-		if (! res->controls) {
-			goto error;
-		}
+		res->controls = talloc_move(res, ares->controls);
 	}
 
 	talloc_free(ares);
-- 
cgit 


From 24fe49a3d10633fa9be5547e89d10be1d5f9ccb1 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 13 Sep 2006 02:03:20 +0000
Subject: r18438: I should have examined these uses of talloc_move() more
 carefully. Most of them are OK, but a couple were not. (This used to be
 commit b0de2838829d9750817c31f28c11c6b2be6e7b64)

---
 source4/lib/ldb/common/ldb.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 50ec106d84..1089fb3d92 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -548,10 +548,7 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 		res->refs[n + 1] = NULL;
 	}
 
-	if (ares->controls) {
-		res->controls = talloc_move(res, ares->controls);
-	}
-
+	talloc_steal(res, ares->controls);
 	talloc_free(ares);
 	return LDB_SUCCESS;
 
-- 
cgit 


From 05cdd9ccafeeb384792b9ce7ca044bcec1bfc839 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 13 Sep 2006 02:33:51 +0000
Subject: r18439: 2nd try at a talloc_move() api. This type with the ** ptr
 interface exposed.

Unfortunately this generates a large number of type punning
warnings. We'll have to find some magic to hide those.
(This used to be commit 254cbf09dee5a1e20c47e47a298f1a8d172b41b9)
---
 source4/lib/ldb/common/ldb.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 1089fb3d92..473c6324ed 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -528,7 +528,7 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 
 		res->msgs[res->count + 1] = NULL;
 
-		res->msgs[res->count] = talloc_move(res->msgs, ares->message);
+		res->msgs[res->count] = talloc_move(res->msgs, &ares->message);
 		res->count++;
 	}
 
@@ -544,7 +544,7 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 			goto error;
 		}
 
-		res->refs[n] = talloc_move(res->refs, ares->referral);
+		res->refs[n] = talloc_move(res->refs, &ares->referral);
 		res->refs[n + 1] = NULL;
 	}
 
-- 
cgit 


From 8d1b32083eb9f35b5e3de3354480aa5e0e8a76d1 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 21 Sep 2006 06:14:32 +0000
Subject: r18777: add helper functions to create an ldb_request structure (This
 used to be commit bcbe82873f2f0a4e2552ed27eb171028de4560a7)

---
 source4/lib/ldb/common/ldb.c | 271 ++++++++++++++++++++++++++++++++-----------
 1 file changed, 203 insertions(+), 68 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 473c6324ed..a68733244d 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -559,34 +559,33 @@ error:
 	return LDB_ERR_OPERATIONS_ERROR;
 }
 
-/*
-  note that ldb_search() will automatically replace a NULL 'base' value with the 
-  defaultNamingContext from the rootDSE if available.
-*/
-int ldb_search(struct ldb_context *ldb, 
-	       const struct ldb_dn *base,
-	       enum ldb_scope scope,
-	       const char *expression,
-	       const char * const *attrs, 
-	       struct ldb_result **res)
+int ldb_build_search_req(struct ldb_request **ret_req,
+			struct ldb_context *ldb,
+			void *mem_ctx,
+			const struct ldb_dn *base,
+	       		enum ldb_scope scope,
+			const char *expression,
+			const char * const *attrs,
+			struct ldb_control **controls,
+			void *context,
+			ldb_request_callback_t callback)
 {
 	struct ldb_request *req;
-	int ret;
 
-	*res = NULL;
-	
-	req = talloc(ldb, struct ldb_request);
+	*ret_req = NULL;
+
+	req = talloc(mem_ctx, struct ldb_request);
 	if (req == NULL) {
 		ldb_set_errstring(ldb, "Out of Memory");
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	req->operation = LDB_SEARCH;
 	if (base == NULL) {
-		base = ldb_get_default_basedn(ldb);
+		req->op.search.base = ldb_dn_new(req);
+	} else {
+		req->op.search.base = base;
 	}
-
-	req->operation = LDB_SEARCH;
-	req->op.search.base = base;
 	req->op.search.scope = scope;
 
 	req->op.search.tree = ldb_parse_tree(req, expression);
@@ -596,16 +595,163 @@ int ldb_search(struct ldb_context *ldb,
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	req->op.search.attrs = attrs;
+	req->controls = controls;
+	req->context = context;
+	req->callback = callback;
+
+	*ret_req = req;
+	return LDB_SUCCESS;
+}
+
+int ldb_build_add_req(struct ldb_request **ret_req,
+			struct ldb_context *ldb,
+			void *mem_ctx,
+			struct ldb_message *message,
+			struct ldb_control **controls,
+			void *context,
+			ldb_request_callback_t callback)
+{
+	struct ldb_request *req;
+
+	*ret_req = NULL;
+
+	req = talloc(mem_ctx, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, "Out of Memory");
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_ADD;
+	req->op.add.message = message;
+	req->controls = controls;
+	req->context = context;
+	req->callback = callback;
+
+	*ret_req = req;
+
+	return LDB_SUCCESS;
+}
+
+int ldb_build_mod_req(struct ldb_request **ret_req,
+			struct ldb_context *ldb,
+			void *mem_ctx,
+			struct ldb_message *message,
+			struct ldb_control **controls,
+			void *context,
+			ldb_request_callback_t callback)
+{
+	struct ldb_request *req;
+
+	*ret_req = NULL;
+
+	req = talloc(mem_ctx, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, "Out of Memory");
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_MODIFY;
+	req->op.mod.message = message;
+	req->controls = controls;
+	req->context = context;
+	req->callback = callback;
+
+	*ret_req = req;
+
+	return LDB_SUCCESS;
+}
+
+int ldb_build_del_req(struct ldb_request **ret_req,
+			struct ldb_context *ldb,
+			void *mem_ctx,
+			struct ldb_dn *dn,
+			struct ldb_control **controls,
+			void *context,
+			ldb_request_callback_t callback)
+{
+	struct ldb_request *req;
+
+	*ret_req = NULL;
+
+	req = talloc(mem_ctx, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, "Out of Memory");
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_DELETE;
+	req->op.del.dn = dn;
+	req->controls = controls;
+	req->context = context;
+	req->callback = callback;
+
+	*ret_req = req;
+
+	return LDB_SUCCESS;
+}
+
+int ldb_build_rename_req(struct ldb_request **ret_req,
+			struct ldb_context *ldb,
+			void *mem_ctx,
+			struct ldb_dn *olddn,
+			struct ldb_dn *newdn,
+			struct ldb_control **controls,
+			void *context,
+			ldb_request_callback_t callback)
+{
+	struct ldb_request *req;
+
+	*ret_req = NULL;
+
+	req = talloc(mem_ctx, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, "Out of Memory");
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_RENAME;
+	req->op.rename.olddn = olddn;
+	req->op.rename.newdn = newdn;
+	req->controls = controls;
+	req->context = context;
+	req->callback = callback;
+
+	*ret_req = req;
+
+	return LDB_SUCCESS;
+}
+
+/*
+  note that ldb_search() will automatically replace a NULL 'base' value with the 
+  defaultNamingContext from the rootDSE if available.
+*/
+int ldb_search(struct ldb_context *ldb, 
+	       const struct ldb_dn *base,
+	       enum ldb_scope scope,
+	       const char *expression,
+	       const char * const *attrs, 
+	       struct ldb_result **res)
+{
+	struct ldb_request *req;
+	int ret;
+
 	*res = talloc_zero(ldb, struct ldb_result);
 	if (! *res) {
-		talloc_free(req);
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
+	
+	ret = ldb_build_search_req(&req, ldb, ldb,
+					base?base:ldb_get_default_basedn(ldb),
+	       				scope,
+					expression,
+					attrs,
+					NULL,
+					res,
+					ldb_search_callback);
+
+	if (ret != LDB_SUCCESS) goto done;
 
-	req->op.search.attrs = attrs;
-	req->controls = NULL;
-	req->context = res;
-	req->callback = ldb_search_callback;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	ret = ldb_request(ldb, req);
@@ -613,17 +759,18 @@ int ldb_search(struct ldb_context *ldb,
 	if (ret == LDB_SUCCESS) {
 		ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 	}
-	
+
+	talloc_free(req);
+
+done:
 	if (ret != LDB_SUCCESS) {
 		talloc_free(*res);
 		*res = NULL;
 	}
 
-	talloc_free(req);
 	return ret;
 }
 
-
 /*
   add a record to the database. Will fail if a record with the given class and key
   already exists
@@ -638,18 +785,15 @@ int ldb_add(struct ldb_context *ldb,
 	if (ret != LDB_SUCCESS) {
 		return ret;
 	}
-		
-	req = talloc(ldb, struct ldb_request);
-	if (req == NULL) {
-		ldb_set_errstring(ldb, "Out of Memory");
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
 
-	req->operation = LDB_ADD;
-	req->op.add.message = message;
-	req->controls = NULL;
-	req->context = NULL;
-	req->callback = NULL;
+	ret = ldb_build_add_req(&req, ldb, ldb,
+					message,
+					NULL,
+					NULL,
+					NULL);
+
+	if (ret != LDB_SUCCESS) return ret;
+
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
@@ -671,17 +815,14 @@ int ldb_modify(struct ldb_context *ldb,
 	ret = ldb_msg_sanity_check(ldb, message);
 	if (ret != LDB_SUCCESS) return ret;
 
-	req = talloc(ldb, struct ldb_request);
-	if (req == NULL) {
-		ldb_set_errstring(ldb, "Out of Memory!");
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
+	ret = ldb_build_mod_req(&req, ldb, ldb,
+					message,
+					NULL,
+					NULL,
+					NULL);
+
+	if (ret != LDB_SUCCESS) return ret;
 
-	req->operation = LDB_MODIFY;
-	req->op.add.message = message;
-	req->controls = NULL;
-	req->context = NULL;
-	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
@@ -700,17 +841,14 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 	struct ldb_request *req;
 	int ret;
 
-	req = talloc(ldb, struct ldb_request);
-	if (req == NULL) {
-		ldb_set_errstring(ldb, "Out of Memory!");
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
+	ret = ldb_build_del_req(&req, ldb, ldb,
+					dn,
+					NULL,
+					NULL,
+					NULL);
+
+	if (ret != LDB_SUCCESS) return ret;
 
-	req->operation = LDB_DELETE;
-	req->op.del.dn = dn;
-	req->controls = NULL;
-	req->context = NULL;
-	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
@@ -728,18 +866,15 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 	struct ldb_request *req;
 	int ret;
 
-	req = talloc(ldb, struct ldb_request);
-	if (req == NULL) {
-		ldb_set_errstring(ldb, "Out of Memory!");
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
+	ret = ldb_build_rename_req(&req, ldb, ldb,
+					olddn,
+					newdn,
+					NULL,
+					NULL,
+					NULL);
+
+	if (ret != LDB_SUCCESS) return ret;
 
-	req->operation = LDB_RENAME;
-	req->op.rename.olddn = olddn;
-	req->op.rename.newdn = newdn;
-	req->controls = NULL;
-	req->context = NULL;
-	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	/* do request and autostart a transaction */
-- 
cgit 


From 77db3973c417cc934485dbd6bf1a8a1c84c1b30b Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 21 Sep 2006 06:44:12 +0000
Subject: r18781: Move the usnCreated and usnChanged handling around again.

This moves these attributes from objectguid into an optional backend
(objectguid), used by ltdb.  For OpenLDAP, the entryUUID module
converts entryCSN into usnChanged.

This also changes the sequence number API, and uses 'time based'
sequence numbers, when an LDAP or similar backend is detected.

To assist this, we also store the last modified time in the TDB,
whenever we change a value.

Andrew Bartlett
(This used to be commit 72858f859483c0c532dddb2c146d6bd7b9be5072)
---
 source4/lib/ldb/common/ldb.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index a68733244d..1aae76bad6 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -888,7 +888,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
 /*
   return the global sequence number
 */
-int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num)
+int ldb_sequence_number(struct ldb_context *ldb, enum ldb_sequence_type type, uint64_t *seq_num)
 {
 	struct ldb_request *req;
 	int ret;
@@ -905,6 +905,7 @@ int ldb_sequence_number(struct ldb_context *ldb, uint64_t *seq_num)
 	req->callback = NULL;
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
+	req->op.seq_num.type = type;
 	/* do request and autostart a transaction */
 	ret = ldb_request(ldb, req);
 	
-- 
cgit 


From 6c86ed60fc6111f3f0091e5dadbc70b39d6cfb93 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 22 Sep 2006 23:21:36 +0000
Subject: r18830: ensure backends aren't added twice (needed for samba3) (This
 used to be commit 54b864b491d8a10c28833d28b764262503a72e91)

---
 source4/lib/ldb/common/ldb.c | 32 +++++++++++++++++++-------------
 1 file changed, 19 insertions(+), 13 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 1aae76bad6..760a311383 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -61,6 +61,21 @@ static struct ldb_backend {
 	ldb_connect_fn connect_fn;
 	struct ldb_backend *prev, *next;
 } *ldb_backends = NULL;
+
+
+static ldb_connect_fn ldb_find_backend(const char *url)
+{
+	struct ldb_backend *backend;
+
+	for (backend = ldb_backends; backend; backend = backend->next) {
+		if (strncmp(backend->name, url, strlen(backend->name)) == 0) {
+			return backend->connect_fn;
+		}
+	}
+
+	return NULL;
+}
+
 /*
  register a new ldb backend
 */
@@ -68,6 +83,10 @@ int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 {
 	struct ldb_backend *backend = talloc(talloc_autofree_context(), struct ldb_backend);
 
+	if (ldb_find_backend(url_prefix)) {
+		return LDB_SUCCESS;
+	}
+
 	/* Maybe check for duplicity here later on? */
 
 	backend->name = talloc_strdup(backend, url_prefix);
@@ -77,19 +96,6 @@ int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 	return LDB_SUCCESS;
 }
 
-static ldb_connect_fn ldb_find_backend(const char *url)
-{
-	struct ldb_backend *backend;
-
-	for (backend = ldb_backends; backend; backend = backend->next) {
-		if (strncmp(backend->name, url, strlen(backend->name)) == 0) {
-			return backend->connect_fn;
-		}
-	}
-
-	return NULL;
-}
-
 /* 
    Return the ldb module form of a database. The URL can either be one of the following forms
    ldb://path
-- 
cgit 


From 5e1e97a20d981d0c0f3b95fe1bc8a657183c2157 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 25 Sep 2006 02:56:41 +0000
Subject: r18882: make style consistent (This used to be commit
 a141ee9473ae46c63dea247456f156b40f766d42)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 760a311383..1e0cfec96d 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -819,7 +819,9 @@ int ldb_modify(struct ldb_context *ldb,
 	int ret;
 
 	ret = ldb_msg_sanity_check(ldb, message);
-	if (ret != LDB_SUCCESS) return ret;
+	if (ret != LDB_SUCCESS) {
+		return ret;
+	}
 
 	ret = ldb_build_mod_req(&req, ldb, ldb,
 					message,
-- 
cgit 


From 1b8d6b3e7d78c9b4d0fdb1676d5a116c12cfe127 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Mon, 25 Sep 2006 05:59:38 +0000
Subject: r18894: Merge const fixes from 3_0 (This used to be commit
 4ce447223cc71b8b2a31c2da3b0afd8e3fcf0c01)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 1e0cfec96d..00bf5e79ba 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -613,7 +613,7 @@ int ldb_build_search_req(struct ldb_request **ret_req,
 int ldb_build_add_req(struct ldb_request **ret_req,
 			struct ldb_context *ldb,
 			void *mem_ctx,
-			struct ldb_message *message,
+			const struct ldb_message *message,
 			struct ldb_control **controls,
 			void *context,
 			ldb_request_callback_t callback)
@@ -642,7 +642,7 @@ int ldb_build_add_req(struct ldb_request **ret_req,
 int ldb_build_mod_req(struct ldb_request **ret_req,
 			struct ldb_context *ldb,
 			void *mem_ctx,
-			struct ldb_message *message,
+			const struct ldb_message *message,
 			struct ldb_control **controls,
 			void *context,
 			ldb_request_callback_t callback)
@@ -671,7 +671,7 @@ int ldb_build_mod_req(struct ldb_request **ret_req,
 int ldb_build_del_req(struct ldb_request **ret_req,
 			struct ldb_context *ldb,
 			void *mem_ctx,
-			struct ldb_dn *dn,
+			const struct ldb_dn *dn,
 			struct ldb_control **controls,
 			void *context,
 			ldb_request_callback_t callback)
@@ -700,8 +700,8 @@ int ldb_build_del_req(struct ldb_request **ret_req,
 int ldb_build_rename_req(struct ldb_request **ret_req,
 			struct ldb_context *ldb,
 			void *mem_ctx,
-			struct ldb_dn *olddn,
-			struct ldb_dn *newdn,
+			const struct ldb_dn *olddn,
+			const struct ldb_dn *newdn,
 			struct ldb_control **controls,
 			void *context,
 			ldb_request_callback_t callback)
-- 
cgit 


From 4c3b07b654f4eb9041da0e9a84bc60d667901fe5 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 27 Sep 2006 05:57:41 +0000
Subject: r18942: add a ldb_set_create_perms() function in ldb. I didn't call
 it ldb_set_umask() (which is what we had discussed) as it doesn't actually
 set the umask (in effect it sets the inverse of the umask - the perms to be
 used for the file) (This used to be commit
 7e2ec875908c112d5c3b0f6d18f9a8bbacf33539)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 00bf5e79ba..0981d9b25b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -52,6 +52,7 @@ struct ldb_context *ldb_init(void *mem_ctx)
 	}
 
 	ldb_set_utf8_default(ldb);
+	ldb_set_create_perms(ldb, 0666);
 
 	return ldb;
 }
@@ -455,6 +456,16 @@ int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *o
 	return LDB_SUCCESS;
 }
 
+
+/* 
+   set the permissions for new files to be passed to open() in
+   backends that use local files
+ */
+void ldb_set_create_perms(struct ldb_context *ldb, unsigned int perms)
+{
+	ldb->create_perms = perms;
+}
+
 /*
   start an ldb request
   NOTE: the request must be a talloc context.
-- 
cgit 


From c403dd11fb33755809a23338ecac99676d766b88 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 9 Oct 2006 08:00:18 +0000
Subject: r19188: merge from samba3:

fix compiler warnings

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 0981d9b25b..28d1c7235a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -161,7 +161,7 @@ static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
 	struct ldb_result *res;
 	struct ldb_dn *basedn=NULL;
 
-	basedn = ldb_get_opaque(ldb, "default_baseDN");
+	basedn = (struct ldb_dn *)ldb_get_opaque(ldb, "default_baseDN");
 	if (basedn) {
 		return basedn;
 	}
@@ -183,7 +183,7 @@ static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
 
 const struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
 {
-	return ldb_get_opaque(ldb, "default_baseDN");
+	return (const struct ldb_dn *)ldb_get_opaque(ldb, "default_baseDN");
 }
 
 /* 
-- 
cgit 


From fa67b43ae8cf850b29e61d5e11e1764f8cd1282e Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Fri, 13 Oct 2006 09:44:55 +0000
Subject: r19264: Clarify behaviour in ldb_search_callback() and provide more
 information when modules fail to load.

Andrew Bartlett
(This used to be commit 512ef62f4a63fd90b67757b2c7b2e8ec83969204)
---
 source4/lib/ldb/common/ldb.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 28d1c7235a..7648abf795 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -208,7 +208,8 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	}
 
 	if (ldb_load_modules(ldb, options) != LDB_SUCCESS) {
-		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for '%s'\n", url);
+		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for %s: %s\n",
+			  url, ldb_errstring(ldb));
 		return LDB_ERR_OTHER;
 	}
 
@@ -536,8 +537,9 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 	if (!res || !ares) {
 		goto error;
 	}
-
-	if (ares->type == LDB_REPLY_ENTRY) {
+	
+	switch (ares->type) {
+	case LDB_REPLY_ENTRY:
 		res->msgs = talloc_realloc(res, res->msgs, struct ldb_message *, res->count + 2);
 		if (! res->msgs) {
 			goto error;
@@ -547,9 +549,8 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 
 		res->msgs[res->count] = talloc_move(res->msgs, &ares->message);
 		res->count++;
-	}
-
-	if (ares->type == LDB_REPLY_REFERRAL) {
+		break;
+	case LDB_REPLY_REFERRAL:
 		if (res->refs) {
 			for (n = 0; res->refs[n]; n++) /*noop*/ ;
 		} else {
@@ -563,8 +564,11 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 
 		res->refs[n] = talloc_move(res->refs, &ares->referral);
 		res->refs[n + 1] = NULL;
+	case LDB_REPLY_DONE:
+		/* Should do something here to detect if this never
+		 * happens */
+		break;		
 	}
-
 	talloc_steal(res, ares->controls);
 	talloc_free(ares);
 	return LDB_SUCCESS;
-- 
cgit 


From 21e63dca9b6503d377c5605384341cd7079b868b Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 22 Oct 2006 21:16:22 +0000
Subject: r19453: Expose helper functions (This used to be commit
 ee86e88e4f523d67900b52b5a4d4040a76360c61)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 7648abf795..0eacf214b5 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -522,7 +522,7 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
   Use talloc_free to free the ldb_message returned in 'res', if successful
 
 */
-static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
 {
 	struct ldb_result *res;
 	int n;
@@ -564,6 +564,7 @@ static int ldb_search_callback(struct ldb_context *ldb, void *context, struct ld
 
 		res->refs[n] = talloc_move(res->refs, &ares->referral);
 		res->refs[n + 1] = NULL;
+	case LDB_REPLY_EXTENDED:
 	case LDB_REPLY_DONE:
 		/* Should do something here to detect if this never
 		 * happens */
@@ -769,7 +770,7 @@ int ldb_search(struct ldb_context *ldb,
 					attrs,
 					NULL,
 					res,
-					ldb_search_callback);
+					ldb_search_default_callback);
 
 	if (ret != LDB_SUCCESS) goto done;
 
-- 
cgit 


From c046f2e7a35e2cef2c1482f7d6a3f16be45b49d4 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 15 Nov 2006 16:09:36 +0000
Subject: r19720: - don't pass a pointer reference to
 ldb_search_default_callback()   as it's ugly when it free's the callers
 memory on failure!

- only steal the controls on a LDB_REPLY_EXTENDED, LDB_REPLY_DONE
  and ignore them on LDB_REPLY_ENTRY, LDB_REPLY_REFERRAL as we currently
  have not way to return them in a ldb_result (we should fix this!)

metze
(This used to be commit 47da62b15abf48f97ce6fc8dc4627792728349ae)
---
 source4/lib/ldb/common/ldb.c | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 0eacf214b5..9e0ee6ebca 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -532,12 +532,13 @@ int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct l
 		return LDB_ERR_OPERATIONS_ERROR;
 	}	
 
-	res = *((struct ldb_result **)context);
+	res = talloc_get_type(context, struct ldb_result);
 
 	if (!res || !ares) {
+		ldb_set_errstring(ldb, "NULL res or ares in callback");
 		goto error;
 	}
-	
+
 	switch (ares->type) {
 	case LDB_REPLY_ENTRY:
 		res->msgs = talloc_realloc(res, res->msgs, struct ldb_message *, res->count + 2);
@@ -566,18 +567,15 @@ int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct l
 		res->refs[n + 1] = NULL;
 	case LDB_REPLY_EXTENDED:
 	case LDB_REPLY_DONE:
-		/* Should do something here to detect if this never
-		 * happens */
+		/* TODO: we should really support controls on entries and referrals too! */
+		res->controls = talloc_move(res, &ares->controls);
 		break;		
 	}
-	talloc_steal(res, ares->controls);
 	talloc_free(ares);
 	return LDB_SUCCESS;
 
 error:
 	talloc_free(ares);
-	talloc_free(res);
-	*((struct ldb_result **)context) = NULL;
 	return LDB_ERR_OPERATIONS_ERROR;
 }
 
@@ -753,16 +751,19 @@ int ldb_search(struct ldb_context *ldb,
 	       enum ldb_scope scope,
 	       const char *expression,
 	       const char * const *attrs, 
-	       struct ldb_result **res)
+	       struct ldb_result **_res)
 {
 	struct ldb_request *req;
 	int ret;
+	struct ldb_result *res;
+
+	*_res = NULL;
 
-	*res = talloc_zero(ldb, struct ldb_result);
-	if (! *res) {
+	res = talloc_zero(ldb, struct ldb_result);
+	if (!res) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	
+
 	ret = ldb_build_search_req(&req, ldb, ldb,
 					base?base:ldb_get_default_basedn(ldb),
 	       				scope,
@@ -786,10 +787,10 @@ int ldb_search(struct ldb_context *ldb,
 
 done:
 	if (ret != LDB_SUCCESS) {
-		talloc_free(*res);
-		*res = NULL;
+		talloc_free(res);
 	}
 
+	*_res = res;
 	return ret;
 }
 
-- 
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/common/ldb.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 9e0ee6ebca..c05f8313f1 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -153,7 +153,7 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
   pet hates about ldapsearch, which is that you have to get a long,
   complex basedn right to make any use of it.
 */
-static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
+static struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
 {
 	TALLOC_CTX *tmp_ctx;
 	int ret;
@@ -167,11 +167,11 @@ static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
 	}
 
 	tmp_ctx = talloc_new(ldb);
-	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx), LDB_SCOPE_BASE, 
+	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, NULL), LDB_SCOPE_BASE, 
 			 "(objectClass=*)", attrs, &res);
 	if (ret == LDB_SUCCESS) {
 		if (res->count == 1) {
-			basedn = ldb_msg_find_attr_as_dn(ldb, res->msgs[0], "defaultNamingContext");
+			basedn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "defaultNamingContext");
 			ldb_set_opaque(ldb, "default_baseDN", basedn);
 		}
 		talloc_free(res);
@@ -181,9 +181,9 @@ static const struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
 	return basedn;
 }
 
-const struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
+struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
 {
-	return (const struct ldb_dn *)ldb_get_opaque(ldb, "default_baseDN");
+	return (struct ldb_dn *)ldb_get_opaque(ldb, "default_baseDN");
 }
 
 /* 
@@ -582,7 +582,7 @@ error:
 int ldb_build_search_req(struct ldb_request **ret_req,
 			struct ldb_context *ldb,
 			void *mem_ctx,
-			const struct ldb_dn *base,
+			struct ldb_dn *base,
 	       		enum ldb_scope scope,
 			const char *expression,
 			const char * const *attrs,
@@ -602,7 +602,7 @@ int ldb_build_search_req(struct ldb_request **ret_req,
 
 	req->operation = LDB_SEARCH;
 	if (base == NULL) {
-		req->op.search.base = ldb_dn_new(req);
+		req->op.search.base = ldb_dn_new(req, ldb, NULL);
 	} else {
 		req->op.search.base = base;
 	}
@@ -685,7 +685,7 @@ int ldb_build_mod_req(struct ldb_request **ret_req,
 int ldb_build_del_req(struct ldb_request **ret_req,
 			struct ldb_context *ldb,
 			void *mem_ctx,
-			const struct ldb_dn *dn,
+			struct ldb_dn *dn,
 			struct ldb_control **controls,
 			void *context,
 			ldb_request_callback_t callback)
@@ -714,8 +714,8 @@ int ldb_build_del_req(struct ldb_request **ret_req,
 int ldb_build_rename_req(struct ldb_request **ret_req,
 			struct ldb_context *ldb,
 			void *mem_ctx,
-			const struct ldb_dn *olddn,
-			const struct ldb_dn *newdn,
+			struct ldb_dn *olddn,
+			struct ldb_dn *newdn,
 			struct ldb_control **controls,
 			void *context,
 			ldb_request_callback_t callback)
@@ -747,7 +747,7 @@ int ldb_build_rename_req(struct ldb_request **ret_req,
   defaultNamingContext from the rootDSE if available.
 */
 int ldb_search(struct ldb_context *ldb, 
-	       const struct ldb_dn *base,
+	       struct ldb_dn *base,
 	       enum ldb_scope scope,
 	       const char *expression,
 	       const char * const *attrs, 
@@ -861,7 +861,7 @@ int ldb_modify(struct ldb_context *ldb,
 /*
   delete a record from the database
 */
-int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
+int ldb_delete(struct ldb_context *ldb, struct ldb_dn *dn)
 {
 	struct ldb_request *req;
 	int ret;
@@ -886,7 +886,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
 /*
   rename a record in the database
 */
-int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
+int ldb_rename(struct ldb_context *ldb, struct ldb_dn *olddn, struct ldb_dn *newdn)
 {
 	struct ldb_request *req;
 	int ret;
-- 
cgit 


From 5e583a96d4da28daac71efd44002480bb3f0fe17 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 5 Dec 2006 02:48:58 +0000
Subject: r20032: Add ldb_search_exp_fmt() This functions adds support of a
 memory context to hook the results to and a printf style exp_fmt partameter
 to easily build expressions at once. (This used to be commit
 2a2e181e4bc382d69056cebace9a4ae9897bdfbc)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index c05f8313f1..733f0bc29a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -794,6 +794,42 @@ done:
 	return ret;
 }
 
+/*
+ a useful search function where you can easily define the expression and that
+ takes a memory context where results are allocated
+*/
+
+int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct ldb_result **result,
+                        struct ldb_dn *base, enum ldb_scope scope, const char * const *attrs,
+                        const char *exp_fmt, ...)
+{
+	struct ldb_result **res;
+	char *expression;
+	va_list ap;
+	int ret;
+
+	*result = NULL;
+
+	va_start(ap, exp_fmt);
+	expression = talloc_vasprintf(mem_ctx, exp_fmt, ap);
+	va_end(ap);
+
+	if ( ! expression) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ret = ldb_search(ldb, base, scope, expression, attrs, res);
+
+	if (ret == LDB_SUCCESS) {
+		talloc_steal(mem_ctx, res);
+		result = res;
+	}
+
+	talloc_free(expression);
+
+	return ret;
+}
+
 /*
   add a record to the database. Will fail if a record with the given class and key
   already exists
-- 
cgit 


From 07b7d84f0601c7047341c33493fcc9695e5e703b Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 5 Dec 2006 03:52:58 +0000
Subject: r20033: Never commit before testing Never commit before testing Never
 commit before testing

:-)
(This used to be commit fdd6ce6b7e288137aeaf62f9869441c73bedbd45)
---
 source4/lib/ldb/common/ldb.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 733f0bc29a..b52cc8e301 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -803,11 +803,12 @@ int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct ldb_
                         struct ldb_dn *base, enum ldb_scope scope, const char * const *attrs,
                         const char *exp_fmt, ...)
 {
-	struct ldb_result **res;
+	struct ldb_result *res;
 	char *expression;
 	va_list ap;
 	int ret;
 
+	res = NULL;
 	*result = NULL;
 
 	va_start(ap, exp_fmt);
@@ -818,11 +819,13 @@ int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct ldb_
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = ldb_search(ldb, base, scope, expression, attrs, res);
+	ret = ldb_search(ldb, base, scope, expression, attrs, &res);
 
 	if (ret == LDB_SUCCESS) {
 		talloc_steal(mem_ctx, res);
-		result = res;
+		*result = res;
+	} else {
+		talloc_free(res);
 	}
 
 	talloc_free(expression);
-- 
cgit 


From f0eaae956f37a0b25baf8fbfb8019b5b6c9e23a1 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 15 Dec 2006 22:37:06 +0000
Subject: r20192: I assume a 'break' is the correct thing to do here,

simo,tridge: please check this.

found by the IBM checker

metze
(This used to be commit 5ac373c8b853d4527a095111253f3cb10522f5e8)
---
 source4/lib/ldb/common/ldb.c | 1 +
 1 file changed, 1 insertion(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index b52cc8e301..7321f7a6f7 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -565,6 +565,7 @@ int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct l
 
 		res->refs[n] = talloc_move(res->refs, &ares->referral);
 		res->refs[n + 1] = NULL;
+		break;
 	case LDB_REPLY_EXTENDED:
 	case LDB_REPLY_DONE:
 		/* TODO: we should really support controls on entries and referrals too! */
-- 
cgit 


From ff322519af326452ea86c5f5d4cb19d1f27e0f16 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 22 Dec 2006 16:59:07 +0000
Subject: r20317: store references to all important naming contexts.

add ldb_get_config_basedn(), ldb_get_schema_basedn()
and ldb_get_root_basedn()

metze
(This used to be commit e28cb83904299fe01e8c0797f5429387f254ed1e)
---
 source4/lib/ldb/common/ldb.c | 58 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 45 insertions(+), 13 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 7321f7a6f7..9b4386547c 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -153,37 +153,69 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
   pet hates about ldapsearch, which is that you have to get a long,
   complex basedn right to make any use of it.
 */
-static struct ldb_dn *ldb_set_default_basedn(struct ldb_context *ldb)
+static void ldb_set_default_dns(struct ldb_context *ldb)
 {
 	TALLOC_CTX *tmp_ctx;
 	int ret;
-	static const char *attrs[] = { "defaultNamingContext", NULL };
 	struct ldb_result *res;
-	struct ldb_dn *basedn=NULL;
-
-	basedn = (struct ldb_dn *)ldb_get_opaque(ldb, "default_baseDN");
-	if (basedn) {
-		return basedn;
-	}
+	struct ldb_dn *tmp_dn=NULL;
+	static const char *attrs[] = {
+		"rootDomainNamingContext",
+		"configurationNamingContext",
+		"schemaNamingContext",
+		"defaultNamingContext",
+		NULL
+	};
 
 	tmp_ctx = talloc_new(ldb);
 	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, NULL), LDB_SCOPE_BASE, 
 			 "(objectClass=*)", attrs, &res);
 	if (ret == LDB_SUCCESS) {
 		if (res->count == 1) {
-			basedn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "defaultNamingContext");
-			ldb_set_opaque(ldb, "default_baseDN", basedn);
+			if (!ldb_get_opaque(ldb, "rootDomainNamingContext")) {
+				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "rootDomainNamingContext");
+				ldb_set_opaque(ldb, "rootDomainNamingContext", tmp_dn);
+			}
+
+			if (!ldb_get_opaque(ldb, "configurationNamingContext")) {
+				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "configurationNamingContext");
+				ldb_set_opaque(ldb, "configurationNamingContext", tmp_dn);
+			}
+
+			if (!ldb_get_opaque(ldb, "schemaNamingContext")) {
+				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "schemaNamingContext");
+				ldb_set_opaque(ldb, "schemaNamingContext", tmp_dn);
+			}
+
+			if (!ldb_get_opaque(ldb, "defaultNamingContext")) {
+				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "defaultNamingContext");
+				ldb_set_opaque(ldb, "defaultNamingContext", tmp_dn);
+			}
 		}
 		talloc_free(res);
 	}
 
 	talloc_free(tmp_ctx);
-	return basedn;
+}
+
+struct ldb_dn *ldb_get_root_basedn(struct ldb_context *ldb)
+{
+	return talloc_get_type(ldb_get_opaque(ldb, "rootDomainNamingContext"), struct ldb_dn);
+}
+
+struct ldb_dn *ldb_get_config_basedn(struct ldb_context *ldb)
+{
+	return talloc_get_type(ldb_get_opaque(ldb, "configurationNamingContext"), struct ldb_dn);
+}
+
+struct ldb_dn *ldb_get_schema_basedn(struct ldb_context *ldb)
+{
+	return talloc_get_type(ldb_get_opaque(ldb, "schemaNamingContext"), struct ldb_dn);
 }
 
 struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
 {
-	return (struct ldb_dn *)ldb_get_opaque(ldb, "default_baseDN");
+	return talloc_get_type(ldb_get_opaque(ldb, "defaultNamingContext"), struct ldb_dn);
 }
 
 /* 
@@ -217,7 +249,7 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	ldb->default_timeout = 300; /* set default to 5 minutes */
 
 	/* set the default base dn */
-	ldb_set_default_basedn(ldb);
+	ldb_set_default_dns(ldb);
 
 	return LDB_SUCCESS;
 }
-- 
cgit 


From f29ea516f99a250765c8a718d7212577167f7931 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 6 Jan 2007 09:03:28 +0000
Subject: r20581: - the ldb modules have explicit hooks for extended operations
   so call them - reorder the request operations first all with explixit hooks

metze
(This used to be commit aababcbb05ad476507bba35723eaef01d18b4d4e)
---
 source4/lib/ldb/common/ldb.c | 4 ++++
 1 file changed, 4 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 9b4386547c..28fe34c767 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -533,6 +533,10 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 		FIRST_OP(ldb, rename);
 		ret = module->ops->rename(module, req);
 		break;
+	case LDB_EXTENDED:
+		FIRST_OP(ldb, extended);
+		ret = module->ops->extended(module, req);
+		break;
 	case LDB_SEQUENCE_NUMBER:
 		FIRST_OP(ldb, sequence_number);
 		ret = module->ops->sequence_number(module, req);
-- 
cgit 


From b5eb73280e82905bafbe827e781481386c98cc82 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 6 Jan 2007 09:49:29 +0000
Subject: r20583: implement the frontend calls for extended operations

metze
(This used to be commit cfcd05adc03effeaf85dc776c2d5bb5244f0d6d4)
---
 source4/lib/ldb/common/ldb.c | 106 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 106 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 28fe34c767..af89748236 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -779,6 +779,112 @@ int ldb_build_rename_req(struct ldb_request **ret_req,
 	return LDB_SUCCESS;
 }
 
+int ldb_extended_default_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+{
+	struct ldb_result *res;
+	
+ 	if (!context) {
+		ldb_set_errstring(ldb, "NULL Context in callback");
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	res = talloc_get_type(context, struct ldb_result);
+	if (!res || !ares) {
+		ldb_set_errstring(ldb, "NULL res or ares in callback");
+		goto error;
+	}
+
+	switch (ares->type) {
+	case LDB_REPLY_ENTRY:
+	case LDB_REPLY_REFERRAL:
+	case LDB_REPLY_DONE:
+		ldb_set_errstring(ldb, "invalid ares type in callback");
+		goto error;
+	case LDB_REPLY_EXTENDED:
+		/* TODO: we should really support controls on entries and referrals too! */
+		res->extended = talloc_move(res, &ares->response);
+		res->controls = talloc_move(res, &ares->controls);
+		break;		
+	}
+	talloc_free(ares);
+	return LDB_SUCCESS;
+
+error:
+	talloc_free(ares);
+	return LDB_ERR_OPERATIONS_ERROR;
+}
+
+int ldb_build_extended_req(struct ldb_request **ret_req,
+			   struct ldb_context *ldb,
+			   void *mem_ctx,
+			   const char *oid,
+			   void *data,
+			   struct ldb_control **controls,
+			   void *context,
+			   ldb_request_callback_t callback)
+{
+	struct ldb_request *req;
+
+	*ret_req = NULL;
+
+	req = talloc(mem_ctx, struct ldb_request);
+	if (req == NULL) {
+		ldb_set_errstring(ldb, "Out of Memory");
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	req->operation = LDB_EXTENDED;
+	req->op.extended.oid = oid;
+	req->op.extended.data = data;
+	req->controls = controls;
+	req->context = context;
+	req->callback = callback;
+
+	*ret_req = req;
+
+	return LDB_SUCCESS;
+}
+
+int ldb_extended(struct ldb_context *ldb, 
+		 const char *oid,
+		 void *data,
+		 struct ldb_result **_res)
+{
+	struct ldb_request *req;
+	int ret;
+	struct ldb_result *res;
+
+	*_res = NULL;
+
+	res = talloc_zero(ldb, struct ldb_result);
+	if (!res) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ret = ldb_build_extended_req(&req, ldb, ldb,
+				     oid, data, NULL,
+				     res, ldb_extended_default_callback);
+	if (ret != LDB_SUCCESS) goto done;
+
+	ldb_set_timeout(ldb, req, 0); /* use default timeout */
+
+	ret = ldb_request(ldb, req);
+	
+	if (ret == LDB_SUCCESS) {
+		ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+	}
+
+	talloc_free(req);
+
+done:
+	if (ret != LDB_SUCCESS) {
+		talloc_free(res);
+	}
+
+	*_res = res;
+	return ret;
+}
+
 /*
   note that ldb_search() will automatically replace a NULL 'base' value with the 
   defaultNamingContext from the rootDSE if available.
-- 
cgit 


From 0c29f6d56da1ce9b01a54be6a8d3a48cf6b2e27f Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sun, 14 Jan 2007 13:43:09 +0000
Subject: r20761: let ldb modules call ldb_set_default_dns()

metze
(This used to be commit 224a31cdbf12a555b8c46786c9f83fec8e839c5a)
---
 source4/lib/ldb/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index af89748236..268756dc93 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -153,7 +153,7 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
   pet hates about ldapsearch, which is that you have to get a long,
   complex basedn right to make any use of it.
 */
-static void ldb_set_default_dns(struct ldb_context *ldb)
+void ldb_set_default_dns(struct ldb_context *ldb)
 {
 	TALLOC_CTX *tmp_ctx;
 	int ret;
-- 
cgit 


From 847102c6ca17f7b7d665863b8caa1d85baef46ad Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 7 Mar 2007 04:20:10 +0000
Subject: r21736: Fix the smbclient test to do something more interesting with
 the last few authentication tests.  Now that the tests correctly 'fail', I
 was able to fix the credentials subsystem to honour USER and PASSWD.

To get --machine-pass working, I needed ldb to always load it's static
modules, so I put this in ldb_connect().

Andrew Bartlett
(This used to be commit 3430d8c072407a1c33c32229095fc9db2142b6fa)
---
 source4/lib/ldb/common/ldb.c | 3 +++
 1 file changed, 3 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 268756dc93..5b3520766d 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -232,6 +232,9 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 {
 	int ret;
 
+	/* We seem to need to do this here, or else some utilities don't get ldb backends */
+	ldb_global_init();
+
 	ldb->flags = flags;
 
 	ret = ldb_connect_backend(ldb, url, options, &ldb->modules);
-- 
cgit 


From f72d4bfea1d436712448619b257930aa52e543c2 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Mon, 23 Apr 2007 07:22:16 +0000
Subject: r22474: If ldb does not return sucess, then the res variable may not
 be valid. It *should* just be NULL from the initialisation above, but I've
 had this not be the case...

Andrew Bartlett
(This used to be commit a2848dbf1fa9eafdef93bd914b12ff2f9f223a70)
---
 source4/lib/ldb/common/ldb.c | 2 --
 1 file changed, 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 5b3520766d..c317fe57fa 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -970,8 +970,6 @@ int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct ldb_
 	if (ret == LDB_SUCCESS) {
 		talloc_steal(mem_ctx, res);
 		*result = res;
-	} else {
-		talloc_free(res);
 	}
 
 	talloc_free(expression);
-- 
cgit 


From f34c57f4fc1a1817735ddb653011e6deb0edf912 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Sat, 28 Apr 2007 15:18:25 +0000
Subject: r22557: Simo has long bugged me that the paths in the sam.ldb
 partitions were not relative to the location of the sam.ldb, but instead
 lp_private_dir().

This fixes that issue.

Andrew Bartlett
(This used to be commit c0fd6f63399d55a1938e31ae7b10689cc02ff2fa)
---
 source4/lib/ldb/common/ldb.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index c317fe57fa..26213facf2 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -231,12 +231,22 @@ struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
 int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[])
 {
 	int ret;
-
+	const char *url2;
 	/* We seem to need to do this here, or else some utilities don't get ldb backends */
 	ldb_global_init();
 
 	ldb->flags = flags;
 
+	url2 = talloc_strdup(ldb, url);
+	if (!url2) {
+		ldb_oom(ldb);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	ret = ldb_set_opaque(ldb, "ldb_url", talloc_strdup(ldb, url2));
+	if (ret != LDB_SUCCESS) {
+		return ret;
+	}
+
 	ret = ldb_connect_backend(ldb, url, options, &ldb->modules);
 	if (ret != LDB_SUCCESS) {
 		return ret;
-- 
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/common/ldb.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 26213facf2..da085af747 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -33,8 +33,7 @@
  *  Author: Andrew Tridgell
  */
 
-#include "includes.h"
-#include "ldb/include/includes.h"
+#include "ldb_includes.h"
 
 /* 
    initialise a ldb context
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index da085af747..a925a5d3b9 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.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/common/ldb.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index a925a5d3b9..f8085d213a 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.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 ed2a1c718ae4fb56fdfe73da6f63ddb7fb15d9fd Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 11 Sep 2007 15:42:19 +0000
Subject: r25081: Add modules_dir member to ldb_context that is used rather
 than a global modulesdir setting. Samba always sets this to
 lp_modulesdir()/ldb (This used to be commit
 e672380d2156cf0421108a9c34f04f096c2afeed)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index f8085d213a..eb8ff62a0d 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -51,6 +51,7 @@ struct ldb_context *ldb_init(void *mem_ctx)
 
 	ldb_set_utf8_default(ldb);
 	ldb_set_create_perms(ldb, 0666);
+	ldb_set_modules_dir(ldb, LDB_MODULESDIR);
 
 	return ldb;
 }
-- 
cgit 


From 61b5dce0e617c3f1f7f30829f3a70b4a20237110 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 5 Nov 2007 21:57:39 +0100
Subject: r25843: Finish check-soloading. (This used to be commit
 4fd3770f0c3f9a3e586f1a03a759dab782e04ba7)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index eb8ff62a0d..25d273f8e9 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -56,7 +56,7 @@ struct ldb_context *ldb_init(void *mem_ctx)
 	return ldb;
 }
 
-static struct ldb_backend {
+struct ldb_backend {
 	const char *name;
 	ldb_connect_fn connect_fn;
 	struct ldb_backend *prev, *next;
-- 
cgit 


From f1ec8da56dd106481b9d79f5d590ee6ba26f7a4b Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 13 Nov 2007 04:31:28 +0100
Subject: r25933: LDB: Don't free errstring until after the printf, in case it
 is one of

the arguments.

Andrew Bartlett
(This used to be commit af40b1cd88f0e932665f6fe90daae8e687a3dc0c)
---
 source4/lib/ldb/common/ldb.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 25d273f8e9..f687e152d3 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -277,14 +277,16 @@ void ldb_set_errstring(struct ldb_context *ldb, const char *err_string)
 void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...)
 {
 	va_list ap;
+	char *old_string = NULL;
 
 	if (ldb->err_string) {
-		talloc_free(ldb->err_string);
+		old_string = ldb->err_string;
 	}
 
 	va_start(ap, format);
 	ldb->err_string = talloc_vasprintf(ldb, format, ap);
 	va_end(ap);
+	talloc_free(old_string);
 }
 
 void ldb_reset_err_string(struct ldb_context *ldb)
-- 
cgit 


From cb62bbbb7c2ee542a3a5f978ed25e501825a44d7 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 17 Dec 2007 03:35:59 +0100
Subject: r26481: Make function for loading symbol from DSO more generic, and
 allow modules to provide an ops table directly rather than an initialization
 function. (This used to be commit a71419a73a869c24121005ccbbcb4396f888888b)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index f687e152d3..87f791cb38 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -126,7 +126,11 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
 	fn = ldb_find_backend(backend);
 
 	if (fn == NULL) {
-		if (ldb_try_load_dso(ldb, backend) == 0) {
+		int (*init_fn) (void);
+
+		init_fn = ldb_dso_load_symbol(ldb, backend,
+					      "init_module");
+		if (init_fn != NULL && init_fn() == 0) {
 			fn = ldb_find_backend(backend);
 		}
 	}
-- 
cgit 


From 3e75f222bcdf114238cc4f2bcc61332dc059135f Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 19 Dec 2007 23:27:42 +0100
Subject: r26539: Remove unnecessary statics. (This used to be commit
 e53e79eebef3ece6978f0a2b4a1ee0a0814bb5d2)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 87f791cb38..ab4abe6701 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -162,7 +162,7 @@ void ldb_set_default_dns(struct ldb_context *ldb)
 	int ret;
 	struct ldb_result *res;
 	struct ldb_dn *tmp_dn=NULL;
-	static const char *attrs[] = {
+	const char *attrs[] = {
 		"rootDomainNamingContext",
 		"configurationNamingContext",
 		"schemaNamingContext",
-- 
cgit 


From 0500b87092540d300b4e021a0fb95ce16a44fbd2 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 20 Dec 2007 00:02:15 +0100
Subject: r26540: Revert my previous commit after concerns raised by Andrew.
 (This used to be commit 6ac86f8be7d9a8c5ab396a93e6d1e6819e11f173)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ab4abe6701..87f791cb38 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -162,7 +162,7 @@ void ldb_set_default_dns(struct ldb_context *ldb)
 	int ret;
 	struct ldb_result *res;
 	struct ldb_dn *tmp_dn=NULL;
-	const char *attrs[] = {
+	static const char *attrs[] = {
 		"rootDomainNamingContext",
 		"configurationNamingContext",
 		"schemaNamingContext",
-- 
cgit 


From 71bc5acead0e16473273eb8741373e865b6d2c44 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 20 Feb 2008 01:37:53 +0100
Subject: Allow ldb backends without init function, use init function-less ldb
 modules. (This used to be commit 141ee91272fb4dafca0149f679e17721b6a3011e)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 87f791cb38..ffda705a0b 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -135,6 +135,15 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
 		}
 	}
 
+	if (fn == NULL) {
+		char *symbol_name = talloc_asprintf(ldb, "ldb_%s_connect", backend);
+		if (symbol_name == NULL) {
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+		fn = ldb_dso_load_symbol(ldb, backend, symbol_name);
+		talloc_free(symbol_name);
+	}
+
 	talloc_free(backend);
 
 	if (fn == NULL) {
-- 
cgit 


From 995788536e5ba7b3a0e67e377a9769b279d0b8ae Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 20 Feb 2008 02:57:07 +0100
Subject: Remove more function-based inits. (This used to be commit
 b1a7810f3e70f9a831d9b8e85d531e448072adaf)

---
 source4/lib/ldb/common/ldb.c | 59 +++++++++++++++++++++++++++++++++++---------
 1 file changed, 48 insertions(+), 11 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ffda705a0b..ce69256c69 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -56,20 +56,51 @@ struct ldb_context *ldb_init(void *mem_ctx)
 	return ldb;
 }
 
-struct ldb_backend {
-	const char *name;
-	ldb_connect_fn connect_fn;
-	struct ldb_backend *prev, *next;
+static struct backends_list_entry {
+	struct ldb_backend_ops *ops;
+	struct backends_list_entry *prev, *next;
 } *ldb_backends = NULL;
 
+#ifndef STATIC_LIBLDB_BACKENDS 
+
+#ifdef HAVE_LDB_LDAP
+#define LDAP_INIT &ldb_ldap_backend_ops, \
+				  &ldb_ildap_backend_ops, \
+				  &ldb_ldaps_backend_ops,
+#else
+#define LDAP_INIT
+#endif
+
+#ifdef HAVE_LDB_SQLITE3
+#define SQLITE3_INIT &ldb_sqlite3_backend_ops,
+#else
+#define SQLITE3_INIT
+#endif
+
+#define STATIC_LIBLDB_BACKENDS \
+	LDAP_INIT \
+	SQLITE3_INIT \
+	&ldb_tdb_backend_ops, 	\
+	NULL
+#endif
+
+const static struct ldb_backend_ops *builtin_backends[] = {
+	STATIC_LIBLDB_BACKENDS
+};
 
 static ldb_connect_fn ldb_find_backend(const char *url)
 {
-	struct ldb_backend *backend;
+	struct backends_list_entry *backend;
+	int i;
+
+	for (i = 0; builtin_backends[i]; i++) {
+		if (strncmp(builtin_backends[i]->name, url, strlen(builtin_backends[i]->name)) == 0)
+			return builtin_backends[i]->connect_fn;
+	}
 
 	for (backend = ldb_backends; backend; backend = backend->next) {
-		if (strncmp(backend->name, url, strlen(backend->name)) == 0) {
-			return backend->connect_fn;
+		if (strncmp(backend->ops->name, url, strlen(backend->ops->name)) == 0) {
+			return backend->ops->connect_fn;
 		}
 	}
 
@@ -81,7 +112,8 @@ static ldb_connect_fn ldb_find_backend(const char *url)
 */
 int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 {
-	struct ldb_backend *backend = talloc(talloc_autofree_context(), struct ldb_backend);
+	struct ldb_backend_ops *backend = talloc(talloc_autofree_context(), struct ldb_backend_ops);
+	struct backends_list_entry *entry = talloc(talloc_autofree_context(), struct backends_list_entry);
 
 	if (ldb_find_backend(url_prefix)) {
 		return LDB_SUCCESS;
@@ -91,7 +123,8 @@ int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 
 	backend->name = talloc_strdup(backend, url_prefix);
 	backend->connect_fn = connectfn;
-	DLIST_ADD(ldb_backends, backend);
+	entry->ops = backend;
+	DLIST_ADD(ldb_backends, entry);
 
 	return LDB_SUCCESS;
 }
@@ -136,11 +169,15 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
 	}
 
 	if (fn == NULL) {
-		char *symbol_name = talloc_asprintf(ldb, "ldb_%s_connect", backend);
+		struct ldb_backend_ops *ops;
+		char *symbol_name = talloc_asprintf(ldb, "ldb_%s_backend_ops", backend);
 		if (symbol_name == NULL) {
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
-		fn = ldb_dso_load_symbol(ldb, backend, symbol_name);
+		ops = ldb_dso_load_symbol(ldb, backend, symbol_name);
+		if (ops != NULL) {
+			fn = ops->connect_fn;
+		}
 		talloc_free(symbol_name);
 	}
 
-- 
cgit 


From 0020793515ade04f3ef5754717490e2eb2ca6bb9 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 20 Feb 2008 03:40:44 +0100
Subject: Fix static module list generation for ldb. (This used to be commit
 92c1c0e9137f0845cac6cc96bf78711b6aaffe21)

---
 source4/lib/ldb/common/ldb.c | 1 -
 1 file changed, 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ce69256c69..5f2e5e3ffc 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -282,7 +282,6 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	int ret;
 	const char *url2;
 	/* We seem to need to do this here, or else some utilities don't get ldb backends */
-	ldb_global_init();
 
 	ldb->flags = flags;
 
-- 
cgit 


From 49b3a4829325967df9d1e616ad32e5379ce6cf5d Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 21 Feb 2008 09:53:11 +1100
Subject: Until the new ldb changes land, make ldb_wait set the error string.

This makes it easier to track down which module only returned and
error code, but not the error string.

Andrew Bartlett
(This used to be commit c4d502f68fbd5d5bc2ac5bb6369950379c9176fc)
---
 source4/lib/ldb/common/ldb.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 87f791cb38..5601a33191 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -463,11 +463,17 @@ static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_reque
 
 int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 {
+	int ret;
 	if (!handle) {
 		return LDB_SUCCESS;
 	}
 
-	return handle->module->ops->wait(handle, type);
+	ret = handle->module->ops->wait(handle, type);
+	if (!ldb_errstring(handle->module->ldb)) {
+		/* Set a default error string, to place the blame somewhere */
+		ldb_asprintf_errstring(handle->module->ldb, "error waiting on module %s: %s (%d)", handle->module->ops->name, ldb_strerror(ret), ret);
+	}
+	return ret;
 }
 
 /* set the specified timeout or, if timeout is 0 set the default timeout */
-- 
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/common/ldb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 3c9ef3ff69..b51c288993 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -65,7 +65,7 @@ static struct backends_list_entry {
 
 #ifdef HAVE_LDB_LDAP
 #define LDAP_INIT &ldb_ldap_backend_ops, \
-				  &ldb_ildap_backend_ops, \
+				  &ldb_ldapi_backend_ops, \
 				  &ldb_ldaps_backend_ops,
 #else
 #define LDAP_INIT
-- 
cgit 


From 929adc9efa5cf985f0585214d30d18521aa1a821 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 14 Jun 2008 11:24:17 -0400
Subject: Make up the right dependencies now that ldb depends on libevents
 (This used to be commit 3b8eec7ca334528cad3cdcd5e3fc5ee555d8d0e0)

---
 source4/lib/ldb/common/ldb.c | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index b51c288993..bfce12bdd3 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -1,13 +1,13 @@
-/* 
+/*
    ldb database library
 
    Copyright (C) Andrew Tridgell  2004
-   Copyright (C) Simo Sorce  2005-2006
+   Copyright (C) Simo Sorce  2005-2008
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
      ** 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
@@ -34,15 +34,21 @@
 
 #include "ldb_includes.h"
 
-/* 
+/*
    initialise a ldb context
-   The mem_ctx is optional
+   The mem_ctx is required
+   The event_ctx is required
 */
-struct ldb_context *ldb_init(void *mem_ctx)
+struct ldb_context *ldb_init(TALLOC_CTX *mem_ctx, struct event_context *ev_ctx)
 {
-	struct ldb_context *ldb = talloc_zero(mem_ctx, struct ldb_context);
+	struct ldb_context *ldb;
 	int ret;
 
+	ldb = talloc_zero(mem_ctx, struct ldb_context);
+	if (ev_ctx == NULL) {
+		ev_ctx = event_context_init(ldb);
+	}
+
 	ret = ldb_setup_wellknown_attributes(ldb);
 	if (ret != 0) {
 		talloc_free(ldb);
@@ -52,6 +58,10 @@ struct ldb_context *ldb_init(void *mem_ctx)
 	ldb_set_utf8_default(ldb);
 	ldb_set_create_perms(ldb, 0666);
 	ldb_set_modules_dir(ldb, LDB_MODULESDIR);
+	ldb_set_event_context(ldb, ev_ctx);
+
+	/* TODO: get timeout from options if available there */
+	ldb->default_timeout = 300; /* set default to 5 minutes */
 
 	return ldb;
 }
@@ -568,6 +578,16 @@ void ldb_set_create_perms(struct ldb_context *ldb, unsigned int perms)
 	ldb->create_perms = perms;
 }
 
+void ldb_set_event_context(struct ldb_context *ldb, struct event_context *ev)
+{
+	ldb->ev_ctx = ev;
+}
+
+struct event_context * ldb_get_event_context(struct ldb_context *ldb)
+{
+	return ldb->ev_ctx;
+}
+
 /*
   start an ldb request
   NOTE: the request must be a talloc context.
-- 
cgit 


From fb8723d28c491815a8db13b6ea1a62287e6bafc1 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 14 Jun 2008 17:33:27 -0400
Subject: Cosmetic fixes. Remove trailing spaces adn try to fit 80 columns
 where possible (This used to be commit
 5457c667647ec156bb7b4f86ce580def4e9350d5)

---
 source4/lib/ldb/common/ldb.c | 229 ++++++++++++++++++++++++++-----------------
 1 file changed, 141 insertions(+), 88 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index bfce12bdd3..20557bd83d 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -71,7 +71,7 @@ static struct backends_list_entry {
 	struct backends_list_entry *prev, *next;
 } *ldb_backends = NULL;
 
-#ifndef STATIC_LIBLDB_BACKENDS 
+#ifndef STATIC_LIBLDB_BACKENDS
 
 #ifdef HAVE_LDB_LDAP
 #define LDAP_INIT &ldb_ldap_backend_ops, \
@@ -104,12 +104,14 @@ static ldb_connect_fn ldb_find_backend(const char *url)
 	int i;
 
 	for (i = 0; builtin_backends[i]; i++) {
-		if (strncmp(builtin_backends[i]->name, url, strlen(builtin_backends[i]->name)) == 0)
+		if (strncmp(builtin_backends[i]->name, url,
+			    strlen(builtin_backends[i]->name)) == 0)
 			return builtin_backends[i]->connect_fn;
 	}
 
 	for (backend = ldb_backends; backend; backend = backend->next) {
-		if (strncmp(backend->ops->name, url, strlen(backend->ops->name)) == 0) {
+		if (strncmp(backend->ops->name, url,
+			    strlen(backend->ops->name)) == 0) {
 			return backend->ops->connect_fn;
 		}
 	}
@@ -122,8 +124,17 @@ static ldb_connect_fn ldb_find_backend(const char *url)
 */
 int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 {
-	struct ldb_backend_ops *backend = talloc(talloc_autofree_context(), struct ldb_backend_ops);
-	struct backends_list_entry *entry = talloc(talloc_autofree_context(), struct backends_list_entry);
+	struct ldb_backend_ops *backend;
+	struct backends_list_entry *entry;
+
+	backend = talloc(talloc_autofree_context(), struct ldb_backend_ops);
+	if (!backend) return LDB_OPERATIONS_ERROR;
+
+	entry = talloc(talloc_autofree_context(), struct backends_list_entry);
+	if (!entry) {
+		talloc_free(backend);
+		return LDB_OPERATIONS_ERROR;
+	}
 
 	if (ldb_find_backend(url_prefix)) {
 		return LDB_SUCCESS;
@@ -139,8 +150,9 @@ int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 	return LDB_SUCCESS;
 }
 
-/* 
-   Return the ldb module form of a database. The URL can either be one of the following forms
+/*
+   Return the ldb module form of a database.
+   The URL can either be one of the following forms
    ldb://path
    ldapi://path
 
@@ -149,10 +161,12 @@ int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
    the options are passed uninterpreted to the backend, and are
    backend specific.
 
-  This allows modules to get at only the backend module, for example where a module 
-  may wish to direct certain requests at a particular backend.
+   This allows modules to get at only the backend module, for example where a
+   module may wish to direct certain requests at a particular backend.
 */
-int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *options[],
+int ldb_connect_backend(struct ldb_context *ldb,
+			const char *url,
+			const char *options[],
 			struct ldb_module **backend_module)
 {
 	int ret;
@@ -194,14 +208,16 @@ int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *op
 	talloc_free(backend);
 
 	if (fn == NULL) {
-		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to find backend for '%s'\n", url);
+		ldb_debug(ldb, LDB_DEBUG_FATAL,
+			  "Unable to find backend for '%s'\n", url);
 		return LDB_ERR_OTHER;
 	}
 
 	ret = fn(ldb, url, ldb->flags, options, backend_module);
 
 	if (ret != LDB_SUCCESS) {
-		ldb_debug(ldb, LDB_DEBUG_ERROR, "Failed to connect to '%s'\n", url);
+		ldb_debug(ldb, LDB_DEBUG_ERROR,
+			  "Failed to connect to '%s'\n", url);
 		return ret;
 	}
 	return ret;
@@ -227,58 +243,72 @@ void ldb_set_default_dns(struct ldb_context *ldb)
 	};
 
 	tmp_ctx = talloc_new(ldb);
-	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, NULL), LDB_SCOPE_BASE, 
+	ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, NULL), LDB_SCOPE_BASE,
 			 "(objectClass=*)", attrs, &res);
-	if (ret == LDB_SUCCESS) {
-		if (res->count == 1) {
-			if (!ldb_get_opaque(ldb, "rootDomainNamingContext")) {
-				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "rootDomainNamingContext");
-				ldb_set_opaque(ldb, "rootDomainNamingContext", tmp_dn);
-			}
-
-			if (!ldb_get_opaque(ldb, "configurationNamingContext")) {
-				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "configurationNamingContext");
-				ldb_set_opaque(ldb, "configurationNamingContext", tmp_dn);
-			}
-
-			if (!ldb_get_opaque(ldb, "schemaNamingContext")) {
-				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "schemaNamingContext");
-				ldb_set_opaque(ldb, "schemaNamingContext", tmp_dn);
-			}
-
-			if (!ldb_get_opaque(ldb, "defaultNamingContext")) {
-				tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0], "defaultNamingContext");
-				ldb_set_opaque(ldb, "defaultNamingContext", tmp_dn);
-			}
-		}
+	if (ret != LDB_SUCCESS) {
+		talloc_free(tmp_ctx);
+		return;
+	}
+
+	if (res->count != 1) {
 		talloc_free(res);
+		return;
+	}
+
+	if (!ldb_get_opaque(ldb, "rootDomainNamingContext")) {
+		tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
+						 "rootDomainNamingContext");
+		ldb_set_opaque(ldb, "rootDomainNamingContext", tmp_dn);
+	}
+
+	if (!ldb_get_opaque(ldb, "configurationNamingContext")) {
+		tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
+						 "configurationNamingContext");
+		ldb_set_opaque(ldb, "configurationNamingContext", tmp_dn);
+	}
+
+	if (!ldb_get_opaque(ldb, "schemaNamingContext")) {
+		tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
+						 "schemaNamingContext");
+		ldb_set_opaque(ldb, "schemaNamingContext", tmp_dn);
 	}
 
+	if (!ldb_get_opaque(ldb, "defaultNamingContext")) {
+		tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
+						 "defaultNamingContext");
+		ldb_set_opaque(ldb, "defaultNamingContext", tmp_dn);
+	}
+
+	talloc_free(res);
 	talloc_free(tmp_ctx);
 }
 
 struct ldb_dn *ldb_get_root_basedn(struct ldb_context *ldb)
 {
-	return talloc_get_type(ldb_get_opaque(ldb, "rootDomainNamingContext"), struct ldb_dn);
+	void *opaque = ldb_get_opaque(ldb, "rootDomainNamingContext");
+	return talloc_get_type(opaque, struct ldb_dn);
 }
 
 struct ldb_dn *ldb_get_config_basedn(struct ldb_context *ldb)
 {
-	return talloc_get_type(ldb_get_opaque(ldb, "configurationNamingContext"), struct ldb_dn);
+	void *opaque = ldb_get_opaque(ldb, "configurationNamingContext");
+	return talloc_get_type(opaque, struct ldb_dn);
 }
 
 struct ldb_dn *ldb_get_schema_basedn(struct ldb_context *ldb)
 {
-	return talloc_get_type(ldb_get_opaque(ldb, "schemaNamingContext"), struct ldb_dn);
+	void *opaque = ldb_get_opaque(ldb, "schemaNamingContext");
+	return talloc_get_type(opaque, struct ldb_dn);
 }
 
 struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
 {
-	return talloc_get_type(ldb_get_opaque(ldb, "defaultNamingContext"), struct ldb_dn);
+	void *opaque = ldb_get_opaque(ldb, "defaultNamingContext");
+	return talloc_get_type(opaque, struct ldb_dn);
 }
 
-/* 
- connect to a database. The URL can either be one of the following forms
+/*
+   connect to a database. The URL can either be one of the following forms
    ldb://path
    ldapi://path
 
@@ -287,11 +317,13 @@ struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
    the options are passed uninterpreted to the backend, and are
    backend specific
 */
-int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[])
+int ldb_connect(struct ldb_context *ldb, const char *url,
+		unsigned int flags, const char *options[])
 {
 	int ret;
 	const char *url2;
-	/* We seem to need to do this here, or else some utilities don't get ldb backends */
+	/* We seem to need to do this here, or else some utilities don't
+	 * get ldb backends */
 
 	ldb->flags = flags;
 
@@ -311,7 +343,8 @@ int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, co
 	}
 
 	if (ldb_load_modules(ldb, options) != LDB_SUCCESS) {
-		ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to load modules for %s: %s\n",
+		ldb_debug(ldb, LDB_DEBUG_FATAL,
+			  "Unable to load modules for %s: %s\n",
 			  url, ldb_errstring(ldb));
 		return LDB_ERR_OTHER;
 	}
@@ -381,9 +414,9 @@ static int ldb_transaction_start_internal(struct ldb_context *ldb)
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
 			ldb_asprintf_errstring(ldb,
-						"ldb transaction start: %s (%d)", 
-						ldb_strerror(status), 
-						status);
+				"ldb transaction start: %s (%d)",
+				ldb_strerror(status),
+				status);
 		}
 	}
 	return status;
@@ -404,10 +437,10 @@ static int ldb_transaction_commit_internal(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_asprintf_errstring(ldb, 
-						"ldb transaction commit: %s (%d)", 
-						ldb_strerror(status), 
-						status);
+			ldb_asprintf_errstring(ldb,
+				"ldb transaction commit: %s (%d)",
+				ldb_strerror(status),
+				status);
 		}
 	}
 	return status;
@@ -426,10 +459,10 @@ static int ldb_transaction_cancel_internal(struct ldb_context *ldb)
 	if (status != LDB_SUCCESS) {
 		if (ldb->err_string == NULL) {
 			/* no error string was setup by the backend */
-			ldb_asprintf_errstring(ldb, 
-						"ldb transaction cancel: %s (%d)", 
-						ldb_strerror(status), 
-						status);
+			ldb_asprintf_errstring(ldb,
+				"ldb transaction cancel: %s (%d)",
+				ldb_strerror(status),
+				status);
 		}
 	}
 	return status;
@@ -489,7 +522,8 @@ static int ldb_autotransaction_cancel(struct ldb_context *ldb)
 }
 
 /* autostarts a transacion if none active */
-static int ldb_autotransaction_request(struct ldb_context *ldb, struct ldb_request *req)
+static int ldb_autotransaction_request(struct ldb_context *ldb,
+				       struct ldb_request *req)
 {
 	int ret;
 
@@ -526,17 +560,22 @@ int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 	ret = handle->module->ops->wait(handle, type);
 	if (!ldb_errstring(handle->module->ldb)) {
 		/* Set a default error string, to place the blame somewhere */
-		ldb_asprintf_errstring(handle->module->ldb, "error waiting on module %s: %s (%d)", handle->module->ops->name, ldb_strerror(ret), ret);
+		ldb_asprintf_errstring(handle->module->ldb,
+					"error waiting on module %s: %s (%d)",
+					handle->module->ops->name,
+					ldb_strerror(ret), ret);
 	}
 	return ret;
 }
 
 /* set the specified timeout or, if timeout is 0 set the default timeout */
 /* timeout == -1 means no timeout */
-int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeout)
+int ldb_set_timeout(struct ldb_context *ldb,
+		    struct ldb_request *req,
+		    int timeout)
 {
 	if (req == NULL) return LDB_ERR_OPERATIONS_ERROR;
-	
+
 	if (timeout != 0) {
 		req->timeout = timeout;
 	} else {
@@ -548,7 +587,9 @@ int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeou
 }
 
 /* calculates the new timeout based on the previous starttime and timeout */
-int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *oldreq, struct ldb_request *newreq)
+int ldb_set_timeout_from_prev_req(struct ldb_context *ldb,
+				  struct ldb_request *oldreq,
+				  struct ldb_request *newreq)
 {
 	time_t now;
 
@@ -569,7 +610,7 @@ int ldb_set_timeout_from_prev_req(struct ldb_context *ldb, struct ldb_request *o
 }
 
 
-/* 
+/*
    set the permissions for new files to be passed to open() in
    backends that use local files
  */
@@ -647,15 +688,17 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
   Use talloc_free to free the ldb_message returned in 'res', if successful
 
 */
-int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+int ldb_search_default_callback(struct ldb_context *ldb,
+				void *context,
+				struct ldb_reply *ares)
 {
 	struct ldb_result *res;
 	int n;
-	
+
  	if (!context) {
 		ldb_set_errstring(ldb, "NULL Context in callback");
 		return LDB_ERR_OPERATIONS_ERROR;
-	}	
+	}
 
 	res = talloc_get_type(context, struct ldb_result);
 
@@ -666,7 +709,9 @@ int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct l
 
 	switch (ares->type) {
 	case LDB_REPLY_ENTRY:
-		res->msgs = talloc_realloc(res, res->msgs, struct ldb_message *, res->count + 2);
+		res->msgs = talloc_realloc(res, res->msgs,
+					   struct ldb_message *,
+					   res->count + 2);
 		if (! res->msgs) {
 			goto error;
 		}
@@ -693,9 +738,10 @@ int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct l
 		break;
 	case LDB_REPLY_EXTENDED:
 	case LDB_REPLY_DONE:
-		/* TODO: we should really support controls on entries and referrals too! */
+		/* TODO: we should really support controls on entries
+		 * and referrals too! */
 		res->controls = talloc_move(res, &ares->controls);
-		break;		
+		break;
 	}
 	talloc_free(ares);
 	return LDB_SUCCESS;
@@ -868,10 +914,12 @@ int ldb_build_rename_req(struct ldb_request **ret_req,
 	return LDB_SUCCESS;
 }
 
-int ldb_extended_default_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+int ldb_extended_default_callback(struct ldb_context *ldb,
+				  void *context,
+				  struct ldb_reply *ares)
 {
 	struct ldb_result *res;
-	
+
  	if (!context) {
 		ldb_set_errstring(ldb, "NULL Context in callback");
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -890,10 +938,11 @@ int ldb_extended_default_callback(struct ldb_context *ldb, void *context, struct
 		ldb_set_errstring(ldb, "invalid ares type in callback");
 		goto error;
 	case LDB_REPLY_EXTENDED:
-		/* TODO: we should really support controls on entries and referrals too! */
+		/* TODO: we should really support controls on entries and
+		 * referrals too! */
 		res->extended = talloc_move(res, &ares->response);
 		res->controls = talloc_move(res, &ares->controls);
-		break;		
+		break;
 	}
 	talloc_free(ares);
 	return LDB_SUCCESS;
@@ -934,7 +983,7 @@ int ldb_build_extended_req(struct ldb_request **ret_req,
 	return LDB_SUCCESS;
 }
 
-int ldb_extended(struct ldb_context *ldb, 
+int ldb_extended(struct ldb_context *ldb,
 		 const char *oid,
 		 void *data,
 		 struct ldb_result **_res)
@@ -958,7 +1007,7 @@ int ldb_extended(struct ldb_context *ldb,
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	ret = ldb_request(ldb, req);
-	
+
 	if (ret == LDB_SUCCESS) {
 		ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 	}
@@ -975,14 +1024,14 @@ done:
 }
 
 /*
-  note that ldb_search() will automatically replace a NULL 'base' value with the 
-  defaultNamingContext from the rootDSE if available.
+  note that ldb_search() will automatically replace a NULL 'base' value
+  with the defaultNamingContext from the rootDSE if available.
 */
-int ldb_search(struct ldb_context *ldb, 
+int ldb_search(struct ldb_context *ldb,
 	       struct ldb_dn *base,
 	       enum ldb_scope scope,
 	       const char *expression,
-	       const char * const *attrs, 
+	       const char * const *attrs,
 	       struct ldb_result **_res)
 {
 	struct ldb_request *req;
@@ -1010,7 +1059,7 @@ int ldb_search(struct ldb_context *ldb,
 	ldb_set_timeout(ldb, req, 0); /* use default timeout */
 
 	ret = ldb_request(ldb, req);
-	
+
 	if (ret == LDB_SUCCESS) {
 		ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 	}
@@ -1031,8 +1080,9 @@ done:
  takes a memory context where results are allocated
 */
 
-int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct ldb_result **result,
-                        struct ldb_dn *base, enum ldb_scope scope, const char * const *attrs,
+int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
+			struct ldb_result **result, struct ldb_dn *base,
+			enum ldb_scope scope, const char * const *attrs,
                         const char *exp_fmt, ...)
 {
 	struct ldb_result *res;
@@ -1064,10 +1114,10 @@ int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct ldb_
 }
 
 /*
-  add a record to the database. Will fail if a record with the given class and key
-  already exists
+  add a record to the database. Will fail if a record with the
+  given class and key already exists
 */
-int ldb_add(struct ldb_context *ldb, 
+int ldb_add(struct ldb_context *ldb,
 	    const struct ldb_message *message)
 {
 	struct ldb_request *req;
@@ -1098,7 +1148,7 @@ int ldb_add(struct ldb_context *ldb,
 /*
   modify the specified attributes of a record
 */
-int ldb_modify(struct ldb_context *ldb, 
+int ldb_modify(struct ldb_context *ldb,
 	       const struct ldb_message *message)
 {
 	struct ldb_request *req;
@@ -1155,7 +1205,8 @@ int ldb_delete(struct ldb_context *ldb, struct ldb_dn *dn)
 /*
   rename a record in the database
 */
-int ldb_rename(struct ldb_context *ldb, struct ldb_dn *olddn, struct ldb_dn *newdn)
+int ldb_rename(struct ldb_context *ldb,
+		struct ldb_dn *olddn, struct ldb_dn *newdn)
 {
 	struct ldb_request *req;
 	int ret;
@@ -1182,7 +1233,9 @@ int ldb_rename(struct ldb_context *ldb, struct ldb_dn *olddn, struct ldb_dn *new
 /*
   return the global sequence number
 */
-int ldb_sequence_number(struct ldb_context *ldb, enum ldb_sequence_type type, uint64_t *seq_num)
+int ldb_sequence_number(struct ldb_context *ldb,
+			enum ldb_sequence_type type,
+			uint64_t *seq_num)
 {
 	struct ldb_request *req;
 	int ret;
@@ -1202,7 +1255,7 @@ int ldb_sequence_number(struct ldb_context *ldb, enum ldb_sequence_type type, ui
 	req->op.seq_num.type = type;
 	/* do request and autostart a transaction */
 	ret = ldb_request(ldb, req);
-	
+
 	if (ret == LDB_SUCCESS) {
 		*seq_num = req->op.seq_num.seq_num;
 	}
@@ -1214,7 +1267,7 @@ int ldb_sequence_number(struct ldb_context *ldb, enum ldb_sequence_type type, ui
 
 
 /*
-  return extended error information 
+  return extended error information
 */
 const char *ldb_errstring(struct ldb_context *ldb)
 {
-- 
cgit 


From 21943bf0af9276e3f52341d726407aee872dd5cc Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 14 Jun 2008 20:18:50 -0400
Subject: Ups fix typo in error type (This used to be commit
 eb351e33e58abdacdf44cf700f028cc13f52c4c8)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 20557bd83d..3e725a5c09 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -128,12 +128,12 @@ int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 	struct backends_list_entry *entry;
 
 	backend = talloc(talloc_autofree_context(), struct ldb_backend_ops);
-	if (!backend) return LDB_OPERATIONS_ERROR;
+	if (!backend) return LDB_ERR_OPERATIONS_ERROR;
 
 	entry = talloc(talloc_autofree_context(), struct backends_list_entry);
 	if (!entry) {
 		talloc_free(backend);
-		return LDB_OPERATIONS_ERROR;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	if (ldb_find_backend(url_prefix)) {
-- 
cgit 


From 1a7823823eab04baacee140ebd45b380dcee9cef Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 15 Jun 2008 11:11:14 -0400
Subject: Now that we pass down the event context, start removing calls to
 event_context_init() where possible (This used to be commit
 412f7a98dd809306ac9f35003fce554e1e1252e7)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 3e725a5c09..22cd46d13f 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -45,6 +45,8 @@ struct ldb_context *ldb_init(TALLOC_CTX *mem_ctx, struct event_context *ev_ctx)
 	int ret;
 
 	ldb = talloc_zero(mem_ctx, struct ldb_context);
+	/* FIXME: Hack a new event context so that CMD line utilities work
+	 * until we have them all converted */
 	if (ev_ctx == NULL) {
 		ev_ctx = event_context_init(ldb);
 	}
-- 
cgit 


From 59ce56749130c4e3656e8c4aa9208005d93c6da6 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 15 Jun 2008 11:11:14 -0400
Subject: Note that making ldb the event context parent seem to lead to races
 when freeing up resources. Try to avoid races by making the autofree context
 be the parent of the event system (This used to be commit
 10ffa87b6b7ebfe51e81819feb93a72e9ec10418)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 22cd46d13f..d0570c5382 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -48,7 +48,7 @@ struct ldb_context *ldb_init(TALLOC_CTX *mem_ctx, struct event_context *ev_ctx)
 	/* FIXME: Hack a new event context so that CMD line utilities work
 	 * until we have them all converted */
 	if (ev_ctx == NULL) {
-		ev_ctx = event_context_init(ldb);
+		ev_ctx = event_context_init(talloc_autofree_context());
 	}
 
 	ret = ldb_setup_wellknown_attributes(ldb);
-- 
cgit 


From 310875e637fd237752770027b28675ed970352dd Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 17 Jun 2008 13:11:29 +1000
Subject: Change our module code to not use the special symbol name
 init_module()

Current glibc libraries include a function called init_module(). If we
use the same name, then a dlsym() can find the glibc function if the
module doesn't have an initialisation function.

In ldb, none of our modules have an init_module(), so we end up calling the libc
functions with bogus arguments.
(This used to be commit 1b0621068998590e7b1e9528b78744dcd2cd5909)
---
 source4/lib/ldb/common/ldb.c | 10 ----------
 1 file changed, 10 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index d0570c5382..cac0a383d8 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -184,16 +184,6 @@ int ldb_connect_backend(struct ldb_context *ldb,
 
 	fn = ldb_find_backend(backend);
 
-	if (fn == NULL) {
-		int (*init_fn) (void);
-
-		init_fn = ldb_dso_load_symbol(ldb, backend,
-					      "init_module");
-		if (init_fn != NULL && init_fn() == 0) {
-			fn = ldb_find_backend(backend);
-		}
-	}
-
 	if (fn == NULL) {
 		struct ldb_backend_ops *ops;
 		char *symbol_name = talloc_asprintf(ldb, "ldb_%s_backend_ops", backend);
-- 
cgit 


From 5ccfd6a90ed81209d055524be51f54cc2f5d8de6 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 28 Jun 2008 10:49:49 +0200
Subject: ldb: allow ldb modules to specify LDB_MODULE(name) or
 LDB_BACKEND(name)

metze
(This used to be commit 1d5b714438a955d76f92f4ccd8aa2f7f89ffa5fd)
---
 source4/lib/ldb/common/ldb.c | 147 -------------------------------------------
 1 file changed, 147 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index cac0a383d8..ce4796dee2 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -68,153 +68,6 @@ struct ldb_context *ldb_init(TALLOC_CTX *mem_ctx, struct event_context *ev_ctx)
 	return ldb;
 }
 
-static struct backends_list_entry {
-	struct ldb_backend_ops *ops;
-	struct backends_list_entry *prev, *next;
-} *ldb_backends = NULL;
-
-#ifndef STATIC_LIBLDB_BACKENDS
-
-#ifdef HAVE_LDB_LDAP
-#define LDAP_INIT &ldb_ldap_backend_ops, \
-				  &ldb_ldapi_backend_ops, \
-				  &ldb_ldaps_backend_ops,
-#else
-#define LDAP_INIT
-#endif
-
-#ifdef HAVE_LDB_SQLITE3
-#define SQLITE3_INIT &ldb_sqlite3_backend_ops,
-#else
-#define SQLITE3_INIT
-#endif
-
-#define STATIC_LIBLDB_BACKENDS \
-	LDAP_INIT \
-	SQLITE3_INIT \
-	&ldb_tdb_backend_ops, 	\
-	NULL
-#endif
-
-const static struct ldb_backend_ops *builtin_backends[] = {
-	STATIC_LIBLDB_BACKENDS
-};
-
-static ldb_connect_fn ldb_find_backend(const char *url)
-{
-	struct backends_list_entry *backend;
-	int i;
-
-	for (i = 0; builtin_backends[i]; i++) {
-		if (strncmp(builtin_backends[i]->name, url,
-			    strlen(builtin_backends[i]->name)) == 0)
-			return builtin_backends[i]->connect_fn;
-	}
-
-	for (backend = ldb_backends; backend; backend = backend->next) {
-		if (strncmp(backend->ops->name, url,
-			    strlen(backend->ops->name)) == 0) {
-			return backend->ops->connect_fn;
-		}
-	}
-
-	return NULL;
-}
-
-/*
- register a new ldb backend
-*/
-int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
-{
-	struct ldb_backend_ops *backend;
-	struct backends_list_entry *entry;
-
-	backend = talloc(talloc_autofree_context(), struct ldb_backend_ops);
-	if (!backend) return LDB_ERR_OPERATIONS_ERROR;
-
-	entry = talloc(talloc_autofree_context(), struct backends_list_entry);
-	if (!entry) {
-		talloc_free(backend);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	if (ldb_find_backend(url_prefix)) {
-		return LDB_SUCCESS;
-	}
-
-	/* Maybe check for duplicity here later on? */
-
-	backend->name = talloc_strdup(backend, url_prefix);
-	backend->connect_fn = connectfn;
-	entry->ops = backend;
-	DLIST_ADD(ldb_backends, entry);
-
-	return LDB_SUCCESS;
-}
-
-/*
-   Return the ldb module form of a database.
-   The URL can either be one of the following forms
-   ldb://path
-   ldapi://path
-
-   flags is made up of LDB_FLG_*
-
-   the options are passed uninterpreted to the backend, and are
-   backend specific.
-
-   This allows modules to get at only the backend module, for example where a
-   module may wish to direct certain requests at a particular backend.
-*/
-int ldb_connect_backend(struct ldb_context *ldb,
-			const char *url,
-			const char *options[],
-			struct ldb_module **backend_module)
-{
-	int ret;
-	char *backend;
-	ldb_connect_fn fn;
-
-	if (strchr(url, ':') != NULL) {
-		backend = talloc_strndup(ldb, url, strchr(url, ':')-url);
-	} else {
-		/* Default to tdb */
-		backend = talloc_strdup(ldb, "tdb");
-	}
-
-	fn = ldb_find_backend(backend);
-
-	if (fn == NULL) {
-		struct ldb_backend_ops *ops;
-		char *symbol_name = talloc_asprintf(ldb, "ldb_%s_backend_ops", backend);
-		if (symbol_name == NULL) {
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
-		ops = ldb_dso_load_symbol(ldb, backend, symbol_name);
-		if (ops != NULL) {
-			fn = ops->connect_fn;
-		}
-		talloc_free(symbol_name);
-	}
-
-	talloc_free(backend);
-
-	if (fn == NULL) {
-		ldb_debug(ldb, LDB_DEBUG_FATAL,
-			  "Unable to find backend for '%s'\n", url);
-		return LDB_ERR_OTHER;
-	}
-
-	ret = fn(ldb, url, ldb->flags, options, backend_module);
-
-	if (ret != LDB_SUCCESS) {
-		ldb_debug(ldb, LDB_DEBUG_ERROR,
-			  "Failed to connect to '%s'\n", url);
-		return ret;
-	}
-	return ret;
-}
-
 /*
   try to autodetect a basedn if none specified. This fixes one of my
   pet hates about ldapsearch, which is that you have to get a long,
-- 
cgit 


From 14965b7260f74fe8c49ace21562d913d37d50063 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 6 Sep 2008 12:31:50 -0400
Subject: Always free tmp contexts before returning (This used to be commit
 40b71bbd718f6dee70c0611e527f55c56623dea6)

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

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

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index ce4796dee2..9e04cc7845 100644
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -97,6 +97,7 @@ void ldb_set_default_dns(struct ldb_context *ldb)
 
 	if (res->count != 1) {
 		talloc_free(res);
+		talloc_free(tmp_ctx);
 		return;
 	}
 
-- 
cgit