From a599edf04cbdeef9014923ba0d3713b8ff84f266 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 12 Oct 2005 06:10:23 +0000
Subject: r10913: This patch isn't as big as it looks ...

most of the changes are fixes to make all the ldb code compile without
warnings on gcc4. Unfortunately That required a lot of casts :-(

I have also added the start of an 'operational' module, which will
replace the timestamp module, plus add support for some other
operational attributes

In ldb_msg_*() I added some new utility functions to make the
operational module sane, and remove the 'ldb' argument from the
ldb_msg_add_*() functions. That argument was only needed back in the
early days of ldb when we didn't use the hierarchical talloc and thus
needed a place to get the allocation function from. Now its just a
pain to pass around everywhere.

Also added a ldb_debug_set() function that calls ldb_debug() plus sets
the result using ldb_set_errstring(). That saves on some awkward
coding in a few places.
(This used to be commit f6818daecca95760c12f79fd307770cbe3346f57)
---
 source4/lib/ldb/modules/operational.c | 217 ++++++++++++++++++++++++++++++++++
 1 file changed, 217 insertions(+)
 create mode 100644 source4/lib/ldb/modules/operational.c

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
new file mode 100644
index 0000000000..911bc087ca
--- /dev/null
+++ b/source4/lib/ldb/modules/operational.c
@@ -0,0 +1,217 @@
+/* 
+   ldb database library
+
+   Copyright (C) Andrew Tridgell 2005
+
+     ** 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
+*/
+/*
+  handle operational attributes
+ */
+
+/*
+  createTimestamp: HIDDEN, searchable, ldaptime, alias for whenCreated
+  modifyTimestamp: HIDDEN, searchable, ldaptime, alias for whenChanged
+
+     for the above two, we do the search as normal, and if
+     createTimestamp or modifyTimestamp is asked for, then do
+     additional searches for whenCreated and whenChanged and fill in
+     the resulting values
+
+     we also need to replace these with the whenCreated/whenChanged
+     equivalent in the search expression trees
+
+  whenCreated: not-HIDDEN, CONSTRUCTED, SEARCHABLE
+  whenChanged: not-HIDDEN, CONSTRUCTED, SEARCHABLE
+
+     on init we need to setup attribute handlers for these so
+     comparisons are done correctly. The resolution is 1 second.
+
+     on add we need to add both the above, for current time
+
+     on modify we need to change whenChanged
+
+
+  subschemaSubentry: HIDDEN, not-searchable, 
+                     points at DN CN=Aggregate,CN=Schema,CN=Configuration,$BASEDN
+
+     for this one we do the search as normal, then add the static
+     value if requested. How do we work out the $BASEDN from inside a
+     module?
+     
+
+  structuralObjectClass: HIDDEN, CONSTRUCTED, not-searchable. always same as objectclass?
+
+     for this one we do the search as normal, then if requested ask
+     for objectclass, change the attribute name, and add it
+
+  attributeTypes: in schema only
+  objectClasses: in schema only
+  matchingRules: in schema only
+  matchingRuleUse: in schema only
+  creatorsName: not supported by w2k3?
+  modifiersName: not supported by w2k3?
+*/
+
+
+#include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
+#include <time.h>
+
+/*
+  a list of attribute names that should be substituted in the parse
+  tree before the search is done
+*/
+static const struct {
+	const char *attr;
+	const char *replace;
+} parse_tree_sub[] = {
+	{ "createTimestamp", "whenCreated" },
+	{ "modifyTimestamp", "whenChanged" }
+};
+
+/*
+  a list of attribute names that are hidden, but can be searched for
+  using another (non-hidden) name to produce the correct result
+*/
+static const struct {
+	const char *attr;
+	const char *replace;
+} search_sub[] = {
+	{ "createTimestamp", "whenCreated" },
+	{ "modifyTimestamp", "whenChanged" },
+	{ "structuralObjectClass", "objectClass" }
+};
+
+/*
+  hook search operations
+*/
+static int operational_search_bytree(struct ldb_module *module, 
+				     const struct ldb_dn *base,
+				     enum ldb_scope scope, struct ldb_parse_tree *tree,
+				     const char * const *attrs, 
+				     struct ldb_message ***res)
+{
+	int i, r, a;
+	int ret;
+	const char **search_attrs = NULL;
+
+	/* replace any attributes in the parse tree that are
+	   searchable, but are stored using a different name in the
+	   backend */
+	for (i=0;i<ARRAY_SIZE(parse_tree_sub);i++) {
+		ldb_parse_tree_attr_replace(tree, 
+					    parse_tree_sub[i].attr, 
+					    parse_tree_sub[i].replace);
+	}
+
+	/* in the list of attributes we are looking for, rename any
+	   attributes to the alias for any hidden attributes that can
+	   be fetched directly using non-hidden names */
+	for (i=0;i<ARRAY_SIZE(search_sub);i++) {
+		for (a=0;attrs[a];a++) {
+			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) == 0) {
+				if (!search_attrs) {
+					search_attrs = ldb_attr_list_copy(module, attrs);
+					if (search_attrs == NULL) {
+						goto oom;
+					}
+				}
+				search_attrs[a] = search_sub[i].replace;
+			}
+		}
+	}
+	
+
+	/* perform the search */
+	ret = ldb_next_search_bytree(module, base, scope, tree, 
+				     search_attrs?search_attrs:attrs, res);
+	if (ret <= 0) {
+		return ret;
+	}
+
+	/* for each record returned see if we have added any
+	   attributes to the search, and if we have then either copy
+	   them (if the aliased name was also asked for) or rename
+	   them (if the aliased entry was not asked for) */
+	for (r=0;r<ret;r++) {
+		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
+			for (a=0;attrs[a];a++) {
+				if (ldb_attr_cmp(attrs[a], search_sub[i].attr) != 0) {
+					continue;
+				}
+				if (ldb_attr_in_list(attrs, search_sub[i].replace) ||
+				    ldb_attr_in_list(attrs, "*")) {
+					if (ldb_msg_copy_attr((*res)[r], 
+							      search_sub[i].replace,
+							      search_sub[i].attr) != 0) {
+						goto oom;
+					}
+				} else {
+					ldb_msg_rename_attr((*res)[r], 
+							    search_sub[i].replace,
+							    search_sub[i].attr);
+				}
+			}
+		}
+	}
+
+	/* all done */
+	talloc_free(search_attrs);
+	return ret;
+
+oom:
+	talloc_free(search_attrs);
+	ldb_oom(module->ldb);
+	return -1;
+}
+
+
+static const struct ldb_module_ops operational_ops = {
+	.name              = "operational",
+	.search_bytree     = operational_search_bytree,
+#if 0
+	.add_record        = operational_add_record,
+	.modify_record     = operational_modify_record,
+	.rename_record     = operational_rename_record
+#endif
+};
+
+
+/* the init function */
+#ifdef HAVE_DLOPEN_DISABLED
+ struct ldb_module *init_module(struct ldb_context *ldb, const char *options[])
+#else
+struct ldb_module *operational_module_init(struct ldb_context *ldb, const char *options[])
+#endif
+{
+	struct ldb_module *ctx;
+
+	ctx = talloc(ldb, struct ldb_module);
+	if (!ctx)
+		return NULL;
+
+	ctx->private_data = NULL;
+	ctx->ldb = ldb;
+	ctx->prev = ctx->next = NULL;
+	ctx->ops = &operational_ops;
+
+	return ctx;
+}
-- 
cgit 


From 35720734911169acde6bf9f2c9a1f83336744f6f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 12 Oct 2005 07:57:39 +0000
Subject: r10916: - finished the 'operational' ldb module

- removed the timestamps module, replacing it with the operational module

- added a ldb_msg_copy_shallow() function which should be used when a module
  wants to add new elements to a message on add/modify. This is needed
  because the caller might be using a constant structure, or may want to
  re-use the structure again

- enabled the UTC time attribute syntaxes in the operational module
(This used to be commit 61e8b010223ac6a0573185008f3719ba29574688)
---
 source4/lib/ldb/modules/operational.c | 101 ++++++++++++++++++++++++++++++++--
 1 file changed, 95 insertions(+), 6 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 911bc087ca..d1e83c02e0 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -126,7 +126,7 @@ static int operational_search_bytree(struct ldb_module *module,
 	   attributes to the alias for any hidden attributes that can
 	   be fetched directly using non-hidden names */
 	for (i=0;i<ARRAY_SIZE(search_sub);i++) {
-		for (a=0;attrs[a];a++) {
+		for (a=0;attrs && attrs[a];a++) {
 			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) == 0) {
 				if (!search_attrs) {
 					search_attrs = ldb_attr_list_copy(module, attrs);
@@ -153,7 +153,7 @@ static int operational_search_bytree(struct ldb_module *module,
 	   them (if the aliased entry was not asked for) */
 	for (r=0;r<ret;r++) {
 		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
-			for (a=0;attrs[a];a++) {
+			for (a=0;attrs && attrs[a];a++) {
 				if (ldb_attr_cmp(attrs[a], search_sub[i].attr) != 0) {
 					continue;
 				}
@@ -183,15 +183,98 @@ oom:
 	return -1;
 }
 
+/*
+  add a time element to a record
+*/
+static int add_time_element(struct ldb_message *msg, const char *attr, time_t t)
+{
+	struct ldb_message_element *el;
+	char *s;
+
+	if (ldb_msg_find_element(msg, attr) != NULL) {
+		return 0;
+	}
+
+	s = ldb_timestring(msg, t);
+	if (s == NULL) {
+		return -1;
+	}
+
+	if (ldb_msg_add_string(msg, attr, s) != 0) {
+		return -1;
+	}
+
+	el = ldb_msg_find_element(msg, attr);
+	/* always set as replace. This works because on add ops, the flag
+	   is ignored */
+	el->flags = LDB_FLAG_MOD_REPLACE;
+
+	return 0;
+}
+
+
+/*
+  hook add record ops
+*/
+static int operational_add_record(struct ldb_module *module, 
+				  const struct ldb_message *msg)
+{
+	time_t t = time(NULL);
+	struct ldb_message *msg2;
+	int ret;
+
+	if (ldb_dn_is_special(msg->dn)) {
+		return ldb_next_add_record(module, msg);
+	}
+
+	/* we have to copy the message as the caller might have it as a const */
+	msg2 = ldb_msg_copy_shallow(module, msg);
+	if (msg2 == NULL) {
+		return -1;
+	}
+	if (add_time_element(msg2, "whenCreated", t) != 0 ||
+	    add_time_element(msg2, "whenChanged", t) != 0) {
+		talloc_free(msg2);
+		return -1;
+	}
+	ret = ldb_next_add_record(module, msg2);
+	talloc_free(msg2);
+	return ret;
+}
+
+/*
+  hook modify record ops
+*/
+static int operational_modify_record(struct ldb_module *module, 
+				     const struct ldb_message *msg)
+{
+	time_t t = time(NULL);
+	struct ldb_message *msg2;
+	int ret;
+
+	if (ldb_dn_is_special(msg->dn)) {
+		return ldb_next_modify_record(module, msg);
+	}
+
+	/* we have to copy the message as the caller might have it as a const */
+	msg2 = ldb_msg_copy_shallow(module, msg);
+	if (msg2 == NULL) {
+		return -1;
+	}
+	if (add_time_element(msg2, "whenChanged", t) != 0) {
+		talloc_free(msg2);
+		return -1;
+	}
+	ret = ldb_next_modify_record(module, msg2);
+	talloc_free(msg2);
+	return ret;
+}
 
 static const struct ldb_module_ops operational_ops = {
 	.name              = "operational",
 	.search_bytree     = operational_search_bytree,
-#if 0
 	.add_record        = operational_add_record,
-	.modify_record     = operational_modify_record,
-	.rename_record     = operational_rename_record
-#endif
+	.modify_record     = operational_modify_record
 };
 
 
@@ -213,5 +296,11 @@ struct ldb_module *operational_module_init(struct ldb_context *ldb, const char *
 	ctx->prev = ctx->next = NULL;
 	ctx->ops = &operational_ops;
 
+	/* setup some standard attribute handlers */
+	ldb_set_attrib_handler_syntax(ldb, "whenCreated", LDB_SYNTAX_UTC_TIME);
+	ldb_set_attrib_handler_syntax(ldb, "whenChanged", LDB_SYNTAX_UTC_TIME);
+	ldb_set_attrib_handler_syntax(ldb, "subschemaSubentry", LDB_SYNTAX_DN);
+	ldb_set_attrib_handler_syntax(ldb, "structuralObjectClass", LDB_SYNTAX_OBJECTCLASS);
+
 	return ctx;
 }
-- 
cgit 


From dc3e65b25295f68d0c7c5d3a7cc9bade638661f4 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 12 Oct 2005 08:11:45 +0000
Subject: r10917: copy the element name in a ldb_msg_rename_attr() and
 ldb_msg_copy_attr() to ensure that callers (like the ldap server) can
 talloc_steal the name (This used to be commit
 9c914542cc346758c82f89990c80eb096a9c0959)

---
 source4/lib/ldb/modules/operational.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index d1e83c02e0..09f9a9e62c 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -113,6 +113,8 @@ static int operational_search_bytree(struct ldb_module *module,
 	int ret;
 	const char **search_attrs = NULL;
 
+	(*res) = NULL;
+
 	/* replace any attributes in the parse tree that are
 	   searchable, but are stored using a different name in the
 	   backend */
@@ -165,9 +167,11 @@ static int operational_search_bytree(struct ldb_module *module,
 						goto oom;
 					}
 				} else {
-					ldb_msg_rename_attr((*res)[r], 
-							    search_sub[i].replace,
-							    search_sub[i].attr);
+					if (ldb_msg_rename_attr((*res)[r], 
+							      search_sub[i].replace,
+							      search_sub[i].attr) != 0) {
+						goto oom;
+					}
 				}
 			}
 		}
@@ -179,6 +183,7 @@ static int operational_search_bytree(struct ldb_module *module,
 
 oom:
 	talloc_free(search_attrs);
+	talloc_free(*res);
 	ldb_oom(module->ldb);
 	return -1;
 }
-- 
cgit 


From c8978cb1f15b1ddc0c420baa568bd11db080b744 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 12 Oct 2005 08:51:12 +0000
Subject: r10918: - fixed standalone ldb build

- added note about allowedAttributesEffective (will be needed for mmc)

- fixed some more ldb warnings
(This used to be commit e9e4d81b6976549db8a7668572a5da466fbec4a9)
---
 source4/lib/ldb/modules/operational.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 09f9a9e62c..c40936df07 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -61,6 +61,10 @@
      for this one we do the search as normal, then if requested ask
      for objectclass, change the attribute name, and add it
 
+  allowedAttributesEffective: HIDDEN, CONSTRUCTED, not-searchable, 
+     list of attributes that can be modified - requires schema lookup
+
+
   attributeTypes: in schema only
   objectClasses: in schema only
   matchingRules: in schema only
-- 
cgit 


From 0fa924bb8f446e35a0fd543cda20b23c81e7dc9e Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 13 Oct 2005 05:04:16 +0000
Subject: r10954: added support for canonicalName in the operational module,
 using the dn->canonicalName function abartlet just committed (This used to be
 commit 197e8a27f0557869eacd17b74e1b14e0665883b1)

---
 source4/lib/ldb/modules/operational.c | 112 ++++++++++++++++++++++++----------
 1 file changed, 80 insertions(+), 32 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index c40936df07..8a06e20c29 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -79,6 +79,19 @@
 #include "ldb/include/ldb_private.h"
 #include <time.h>
 
+/*
+  construct a canonical name from a message
+*/
+static int construct_canonical_name(struct ldb_module *module, struct ldb_message *msg)
+{
+	char *canonicalName;
+	canonicalName = ldb_dn_canonical_string(msg, msg->dn);
+	if (canonicalName == NULL) {
+		return -1;
+	}
+	return ldb_msg_add_string(msg, "canonicalName", canonicalName);
+}
+
 /*
   a list of attribute names that should be substituted in the parse
   tree before the search is done
@@ -91,6 +104,7 @@ static const struct {
 	{ "modifyTimestamp", "whenChanged" }
 };
 
+
 /*
   a list of attribute names that are hidden, but can be searched for
   using another (non-hidden) name to produce the correct result
@@ -98,12 +112,65 @@ static const struct {
 static const struct {
 	const char *attr;
 	const char *replace;
+	int (*constructor)(struct ldb_module *, struct ldb_message *);
 } search_sub[] = {
-	{ "createTimestamp", "whenCreated" },
-	{ "modifyTimestamp", "whenChanged" },
-	{ "structuralObjectClass", "objectClass" }
+	{ "createTimestamp", "whenCreated", NULL },
+	{ "modifyTimestamp", "whenChanged", NULL },
+	{ "structuralObjectClass", "objectClass", NULL },
+	{ "canonicalName", "distinguishedName", construct_canonical_name }
 };
 
+/*
+  post process a search result record. For any search_sub[] attributes that were
+  asked for, we need to call the appropriate copy routine to copy the result
+  into the message, then remove any attributes that we added to the search but were
+  not asked for by the user
+*/
+static int operational_search_post_process(struct ldb_module *module,
+					   struct ldb_message *msg, 
+					   const char * const *attrs)
+{
+	int i, a=0;
+
+	for (a=0;attrs && attrs[a];a++) {
+		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
+			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) != 0) {
+				continue;
+			}
+
+			/* construct the new attribute, using either a supplied 
+			   constructor or a simple copy */
+			if (search_sub[i].constructor) {
+				if (search_sub[i].constructor(module, msg) != 0) {
+					goto failed;
+				}
+			} else if (ldb_msg_copy_attr(msg,
+						     search_sub[i].replace,
+						     search_sub[i].attr) != 0) {
+				goto failed;
+			}
+
+			/* remove the added search attribute, unless it was asked for 
+			   by the user */
+			if (search_sub[i].replace == NULL ||
+			    ldb_attr_in_list(attrs, search_sub[i].replace) ||
+			    ldb_attr_in_list(attrs, "*")) {
+				continue;
+			}
+
+			ldb_msg_remove_attr(msg, search_sub[i].replace);
+		}
+	}
+
+	return 0;
+
+failed:
+	ldb_debug_set(module->ldb, LDB_DEBUG_WARNING, 
+		      "operational_search_post_process failed for attribute '%s'\n", 
+		      attrs[a]);
+	return -1;
+}
+
 /*
   hook search operations
 */
@@ -131,13 +198,14 @@ static int operational_search_bytree(struct ldb_module *module,
 	/* in the list of attributes we are looking for, rename any
 	   attributes to the alias for any hidden attributes that can
 	   be fetched directly using non-hidden names */
-	for (i=0;i<ARRAY_SIZE(search_sub);i++) {
-		for (a=0;attrs && attrs[a];a++) {
-			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) == 0) {
+	for (a=0;attrs && attrs[a];a++) {
+		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
+			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) == 0 &&
+			    search_sub[i].replace) {
 				if (!search_attrs) {
 					search_attrs = ldb_attr_list_copy(module, attrs);
 					if (search_attrs == NULL) {
-						goto oom;
+						goto failed;
 					}
 				}
 				search_attrs[a] = search_sub[i].replace;
@@ -153,31 +221,11 @@ static int operational_search_bytree(struct ldb_module *module,
 		return ret;
 	}
 
-	/* for each record returned see if we have added any
-	   attributes to the search, and if we have then either copy
-	   them (if the aliased name was also asked for) or rename
-	   them (if the aliased entry was not asked for) */
+	/* for each record returned post-process to add any derived
+	   attributes that have been asked for */
 	for (r=0;r<ret;r++) {
-		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
-			for (a=0;attrs && attrs[a];a++) {
-				if (ldb_attr_cmp(attrs[a], search_sub[i].attr) != 0) {
-					continue;
-				}
-				if (ldb_attr_in_list(attrs, search_sub[i].replace) ||
-				    ldb_attr_in_list(attrs, "*")) {
-					if (ldb_msg_copy_attr((*res)[r], 
-							      search_sub[i].replace,
-							      search_sub[i].attr) != 0) {
-						goto oom;
-					}
-				} else {
-					if (ldb_msg_rename_attr((*res)[r], 
-							      search_sub[i].replace,
-							      search_sub[i].attr) != 0) {
-						goto oom;
-					}
-				}
-			}
+		if (operational_search_post_process(module, (*res)[r], attrs) != 0) {
+			goto failed;
 		}
 	}
 
@@ -185,7 +233,7 @@ static int operational_search_bytree(struct ldb_module *module,
 	talloc_free(search_attrs);
 	return ret;
 
-oom:
+failed:
 	talloc_free(search_attrs);
 	talloc_free(*res);
 	ldb_oom(module->ldb);
-- 
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/modules/operational.c | 84 ++++++++++++++++++++++++-----------
 1 file changed, 58 insertions(+), 26 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 8a06e20c29..7c554e8541 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -76,6 +76,7 @@
 
 #include "includes.h"
 #include "ldb/include/ldb.h"
+#include "ldb/include/ldb_errors.h"
 #include "ldb/include/ldb_private.h"
 #include <time.h>
 
@@ -174,23 +175,20 @@ failed:
 /*
   hook search operations
 */
-static int operational_search_bytree(struct ldb_module *module, 
-				     const struct ldb_dn *base,
-				     enum ldb_scope scope, struct ldb_parse_tree *tree,
-				     const char * const *attrs, 
-				     struct ldb_message ***res)
+static int operational_search_bytree(struct ldb_module *module, struct ldb_request *req)
 {
 	int i, r, a;
 	int ret;
+	const char * const *attrs = req->op.search.attrs;
 	const char **search_attrs = NULL;
 
-	(*res) = NULL;
+	*(req->op.search.res) = NULL;
 
 	/* replace any attributes in the parse tree that are
 	   searchable, but are stored using a different name in the
 	   backend */
 	for (i=0;i<ARRAY_SIZE(parse_tree_sub);i++) {
-		ldb_parse_tree_attr_replace(tree, 
+		ldb_parse_tree_attr_replace(req->op.search.tree, 
 					    parse_tree_sub[i].attr, 
 					    parse_tree_sub[i].replace);
 	}
@@ -213,18 +211,22 @@ static int operational_search_bytree(struct ldb_module *module,
 		}
 	}
 	
-
+	/* use new set of attrs if any */
+	if (search_attrs) req->op.search.attrs = search_attrs;
 	/* perform the search */
-	ret = ldb_next_search_bytree(module, base, scope, tree, 
-				     search_attrs?search_attrs:attrs, res);
-	if (ret <= 0) {
+	ret = ldb_next_request(module, req);
+	/* set back saved attrs if needed */
+	if (search_attrs) req->op.search.attrs = attrs;
+
+	/* check operation result */
+	if (ret != LDB_SUCCESS) {
 		return ret;
 	}
 
 	/* for each record returned post-process to add any derived
 	   attributes that have been asked for */
-	for (r=0;r<ret;r++) {
-		if (operational_search_post_process(module, (*res)[r], attrs) != 0) {
+	for (r = 0; r < (*(req->op.search.res))->count; r++) {
+		if (operational_search_post_process(module, (*(req->op.search.res))->msgs[r], attrs) != 0) {
 			goto failed;
 		}
 	}
@@ -235,9 +237,9 @@ static int operational_search_bytree(struct ldb_module *module,
 
 failed:
 	talloc_free(search_attrs);
-	talloc_free(*res);
+	talloc_free(*(req->op.search.res));
 	ldb_oom(module->ldb);
-	return -1;
+	return LDB_ERR_OTHER;
 }
 
 /*
@@ -273,15 +275,15 @@ static int add_time_element(struct ldb_message *msg, const char *attr, time_t t)
 /*
   hook add record ops
 */
-static int operational_add_record(struct ldb_module *module, 
-				  const struct ldb_message *msg)
+static int operational_add(struct ldb_module *module, struct ldb_request *req)
 {
+	const struct ldb_message *msg = req->op.add.message;
 	time_t t = time(NULL);
 	struct ldb_message *msg2;
 	int ret;
 
 	if (ldb_dn_is_special(msg->dn)) {
-		return ldb_next_add_record(module, msg);
+		return ldb_next_request(module, req);
 	}
 
 	/* we have to copy the message as the caller might have it as a const */
@@ -294,7 +296,13 @@ static int operational_add_record(struct ldb_module *module,
 		talloc_free(msg2);
 		return -1;
 	}
-	ret = ldb_next_add_record(module, msg2);
+	/* use the new structure for the call chain below this point */
+	req->op.add.message = msg2;
+	/* go on with the call chain */
+	ret = ldb_next_request(module, req);
+	/* put back saved message */
+	req->op.add.message = msg;
+	/* free temproary compy */
 	talloc_free(msg2);
 	return ret;
 }
@@ -302,15 +310,15 @@ static int operational_add_record(struct ldb_module *module,
 /*
   hook modify record ops
 */
-static int operational_modify_record(struct ldb_module *module, 
-				     const struct ldb_message *msg)
+static int operational_modify(struct ldb_module *module, struct ldb_request *req)
 {
+	const struct ldb_message *msg = req->op.mod.message;
 	time_t t = time(NULL);
 	struct ldb_message *msg2;
 	int ret;
 
 	if (ldb_dn_is_special(msg->dn)) {
-		return ldb_next_modify_record(module, msg);
+		return ldb_next_request(module, req);
 	}
 
 	/* we have to copy the message as the caller might have it as a const */
@@ -322,16 +330,40 @@ static int operational_modify_record(struct ldb_module *module,
 		talloc_free(msg2);
 		return -1;
 	}
-	ret = ldb_next_modify_record(module, msg2);
+	/* use the new structure for the call chain below this point */
+	req->op.mod.message = msg2;
+	/* go on with the call chain */
+	ret = ldb_next_request(module, req);
+	/* put back saved message */
+	req->op.mod.message = msg;
+	/* free temproary compy */
 	talloc_free(msg2);
 	return ret;
 }
 
+
+static int operational_request(struct ldb_module *module, struct ldb_request *req)
+{
+	switch (req->operation) {
+
+	case LDB_REQ_SEARCH:
+		return operational_search_bytree(module, req);
+
+	case LDB_REQ_ADD:
+		return operational_add(module, req);
+
+	case LDB_REQ_MODIFY:
+		return operational_modify(module, req);
+
+	default:
+		return ldb_next_request(module, req);
+
+	}
+}
+
 static const struct ldb_module_ops operational_ops = {
 	.name              = "operational",
-	.search_bytree     = operational_search_bytree,
-	.add_record        = operational_add_record,
-	.modify_record     = operational_modify_record
+	.request           = operational_request
 };
 
 
-- 
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/modules/operational.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 7c554e8541..2fdd255e99 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -182,7 +182,7 @@ static int operational_search_bytree(struct ldb_module *module, struct ldb_reque
 	const char * const *attrs = req->op.search.attrs;
 	const char **search_attrs = NULL;
 
-	*(req->op.search.res) = NULL;
+	req->op.search.res = NULL;
 
 	/* replace any attributes in the parse tree that are
 	   searchable, but are stored using a different name in the
@@ -225,8 +225,8 @@ static int operational_search_bytree(struct ldb_module *module, struct ldb_reque
 
 	/* for each record returned post-process to add any derived
 	   attributes that have been asked for */
-	for (r = 0; r < (*(req->op.search.res))->count; r++) {
-		if (operational_search_post_process(module, (*(req->op.search.res))->msgs[r], attrs) != 0) {
+	for (r = 0; r < req->op.search.res->count; r++) {
+		if (operational_search_post_process(module, req->op.search.res->msgs[r], attrs) != 0) {
 			goto failed;
 		}
 	}
@@ -237,7 +237,7 @@ static int operational_search_bytree(struct ldb_module *module, struct ldb_reque
 
 failed:
 	talloc_free(search_attrs);
-	talloc_free(*(req->op.search.res));
+	talloc_free(req->op.search.res);
 	ldb_oom(module->ldb);
 	return LDB_ERR_OTHER;
 }
-- 
cgit 


From 7d960dfc39969860ed0fba5883417591377f5539 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 1 Dec 2005 00:19:36 +0000
Subject: r11981: we should allocate request specific memory in ldb modules off
 the request strucutre. It will take a while for this to happen everywhere.
 (This used to be commit b1d38153b8c1d2d5be2d41005eadb0e0aa46bd72)

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

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 2fdd255e99..d98dfe1266 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -201,7 +201,7 @@ static int operational_search_bytree(struct ldb_module *module, struct ldb_reque
 			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) == 0 &&
 			    search_sub[i].replace) {
 				if (!search_attrs) {
-					search_attrs = ldb_attr_list_copy(module, attrs);
+					search_attrs = ldb_attr_list_copy(req, attrs);
 					if (search_attrs == NULL) {
 						goto failed;
 					}
-- 
cgit 


From 3b99d9c5bd563203adc4b017d6e6599dd84b8d57 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 1 Jan 2006 17:32:10 +0000
Subject: r12658: Couple of fixes related to shared module builds. (This used
 to be commit c297c93faf3b748de68679f5a4be50845ebe25fe)

---
 source4/lib/ldb/modules/operational.c | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index d98dfe1266..65d9f12e34 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -368,11 +368,7 @@ static const struct ldb_module_ops operational_ops = {
 
 
 /* the init function */
-#ifdef HAVE_DLOPEN_DISABLED
- struct ldb_module *init_module(struct ldb_context *ldb, const char *options[])
-#else
 struct ldb_module *operational_module_init(struct ldb_context *ldb, const char *options[])
-#endif
 {
 	struct ldb_module *ctx;
 
-- 
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/modules/operational.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 65d9f12e34..09de0936a1 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -368,10 +368,12 @@ static const struct ldb_module_ops operational_ops = {
 
 
 /* the init function */
-struct ldb_module *operational_module_init(struct ldb_context *ldb, const char *options[])
+struct ldb_module *operational_module_init(struct ldb_context *ldb, int stage, const char *options[])
 {
 	struct ldb_module *ctx;
 
+	if (stage != LDB_MODULES_INIT_STAGE_1) return NULL;
+	
 	ctx = talloc(ldb, struct ldb_module);
 	if (!ctx)
 		return NULL;
-- 
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/modules/operational.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 09de0936a1..65d9f12e34 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -368,12 +368,10 @@ static const struct ldb_module_ops operational_ops = {
 
 
 /* the init function */
-struct ldb_module *operational_module_init(struct ldb_context *ldb, int stage, const char *options[])
+struct ldb_module *operational_module_init(struct ldb_context *ldb, const char *options[])
 {
 	struct ldb_module *ctx;
 
-	if (stage != LDB_MODULES_INIT_STAGE_1) return NULL;
-	
 	ctx = talloc(ldb, struct ldb_module);
 	if (!ctx)
 		return NULL;
-- 
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/modules/operational.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 65d9f12e34..3deb9422f3 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -73,12 +73,8 @@
   modifiersName: not supported by w2k3?
 */
 
-
 #include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
-#include <time.h>
+#include "ldb/include/includes.h"
 
 /*
   construct a canonical name from a message
-- 
cgit 


From 98c0767677156ff31791bd93f473ac11f856c75a Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 22 Feb 2006 09:28:58 +0000
Subject: r13616: Add new ldb functions: ldb_msg_add_steal_string() and
 ldb_msg_add_steal_value().

These try to maintain the talloc heirachy, which must be correct
otherwise talloc_steal operations of entire attribute lists fails.

This fixes the currentTime value, found by using Microsoft's dcdiag
tool (before this commit, it pointed to invalid memory, due to the
changes in -r 13606)

Andrew Bartlett
(This used to be commit 424df1bb369fddcfd358cf26dd0da9d3851d181e)
---
 source4/lib/ldb/modules/operational.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 3deb9422f3..8b7d6b3518 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -86,7 +86,7 @@ static int construct_canonical_name(struct ldb_module *module, struct ldb_messag
 	if (canonicalName == NULL) {
 		return -1;
 	}
-	return ldb_msg_add_string(msg, "canonicalName", canonicalName);
+	return ldb_msg_add_steal_string(msg, "canonicalName", canonicalName);
 }
 
 /*
-- 
cgit 


From 57d5f19b3f032dfcecde9883651c6df8b18a8b58 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 27 Feb 2006 00:39:26 +0000
Subject: r13700: added highestCommittedUSN, uSNChanged and uSNCreated support,
 using the @BASEINFO sequenceNumber

(simo, I changed the function pointer to a structure element as you
preferred)
(This used to be commit 68c9ac38c7eed221b44499ee3d74597063dfe7a1)
---
 source4/lib/ldb/modules/operational.c | 43 +++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 8b7d6b3518..51f0ce25e4 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -267,6 +267,29 @@ static int add_time_element(struct ldb_message *msg, const char *attr, time_t t)
 	return 0;
 }
 
+/*
+  add a uint64_t element to a record
+*/
+static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_t v)
+{
+	struct ldb_message_element *el;
+
+	if (ldb_msg_find_element(msg, attr) != NULL) {
+		return 0;
+	}
+
+	if (ldb_msg_add_fmt(msg, attr, "%llu", v) != 0) {
+		return -1;
+	}
+
+	el = ldb_msg_find_element(msg, attr);
+	/* always set as replace. This works because on add ops, the flag
+	   is ignored */
+	el->flags = LDB_FLAG_MOD_REPLACE;
+
+	return 0;
+}
+
 
 /*
   hook add record ops
@@ -292,6 +315,17 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 		talloc_free(msg2);
 		return -1;
 	}
+
+	/* see if the backend can give us the USN */
+	if (module->ldb->sequence_number != NULL) {
+		uint64_t seq_num = module->ldb->sequence_number(module->ldb);
+		if (add_uint64_element(msg2, "uSNCreated", seq_num) != 0 ||
+		    add_uint64_element(msg2, "uSNChanged", seq_num) != 0) {
+			talloc_free(msg2);
+			return -1;
+		}
+	}
+
 	/* use the new structure for the call chain below this point */
 	req->op.add.message = msg2;
 	/* go on with the call chain */
@@ -326,6 +360,15 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 		talloc_free(msg2);
 		return -1;
 	}
+
+	/* update the records USN if possible */
+	if (module->ldb->sequence_number != NULL &&
+	    add_uint64_element(msg2, "uSNChanged", 
+			       module->ldb->sequence_number(module->ldb)) != 0) {
+		talloc_free(msg2);
+		return -1;
+	}
+
 	/* use the new structure for the call chain below this point */
 	req->op.mod.message = msg2;
 	/* go on with the call chain */
-- 
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/modules/operational.c | 37 ++++++++++++++---------------------
 1 file changed, 15 insertions(+), 22 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 51f0ce25e4..441c899a58 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -400,31 +400,24 @@ static int operational_request(struct ldb_module *module, struct ldb_request *re
 	}
 }
 
+static int operational_init(struct ldb_module *ctx)
+{
+	/* setup some standard attribute handlers */
+	ldb_set_attrib_handler_syntax(ctx->ldb, "whenCreated", LDB_SYNTAX_UTC_TIME);
+	ldb_set_attrib_handler_syntax(ctx->ldb, "whenChanged", LDB_SYNTAX_UTC_TIME);
+	ldb_set_attrib_handler_syntax(ctx->ldb, "subschemaSubentry", LDB_SYNTAX_DN);
+	ldb_set_attrib_handler_syntax(ctx->ldb, "structuralObjectClass", LDB_SYNTAX_OBJECTCLASS);
+
+	return ldb_next_init(ctx);
+}
+
 static const struct ldb_module_ops operational_ops = {
 	.name              = "operational",
-	.request           = operational_request
+	.request           = operational_request,
+	.init_context	   = operational_init
 };
 
-
-/* the init function */
-struct ldb_module *operational_module_init(struct ldb_context *ldb, const char *options[])
+int ldb_operational_init(void)
 {
-	struct ldb_module *ctx;
-
-	ctx = talloc(ldb, struct ldb_module);
-	if (!ctx)
-		return NULL;
-
-	ctx->private_data = NULL;
-	ctx->ldb = ldb;
-	ctx->prev = ctx->next = NULL;
-	ctx->ops = &operational_ops;
-
-	/* setup some standard attribute handlers */
-	ldb_set_attrib_handler_syntax(ldb, "whenCreated", LDB_SYNTAX_UTC_TIME);
-	ldb_set_attrib_handler_syntax(ldb, "whenChanged", LDB_SYNTAX_UTC_TIME);
-	ldb_set_attrib_handler_syntax(ldb, "subschemaSubentry", LDB_SYNTAX_DN);
-	ldb_set_attrib_handler_syntax(ldb, "structuralObjectClass", LDB_SYNTAX_OBJECTCLASS);
-
-	return ctx;
+	return ldb_register_module(&operational_ops);
 }
-- 
cgit 


From 611bad9de34a2cd7d8f474dcce84ebbddfcafba3 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 14 Mar 2006 05:38:05 +0000
Subject: r14364: operational -> async (untested) (This used to be commit
 b112eb774fb1a3d689c8598bbf55ac3e978b8682)

---
 source4/lib/ldb/modules/operational.c | 251 ++++++++++++++++++++++++++++++++++
 1 file changed, 251 insertions(+)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 441c899a58..fc15da4f6e 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -2,6 +2,7 @@
    ldb database library
 
    Copyright (C) Andrew Tridgell 2005
+   Copyright (C) Simo Sorce 2006
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -380,6 +381,247 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 	return ret;
 }
 
+/*
+  hook search operations
+*/
+
+struct operational_async_context {
+
+	struct ldb_module *module;
+	void *up_context;
+	int (*up_callback)(struct ldb_context *, void *, struct ldb_async_result *);
+	int timeout;
+
+	const char * const *attrs;
+};
+
+static int operational_async_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares) {
+
+	struct operational_async_context *ac;
+
+	if (!context || !ares) {
+		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback"));
+		goto error;
+	}
+
+	ac = talloc_get_type(context, struct operational_async_context);
+
+	if (ares->type == LDB_REPLY_ENTRY) {
+		/* for each record returned post-process to add any derived
+		   attributes that have been asked for */
+		if (operational_search_post_process(ac->module, ares->message, ac->attrs) != 0) {
+			goto error;
+		}
+	}
+
+	return ac->up_callback(ldb, ac->up_context, ares);
+
+error:
+	talloc_free(ares);
+	return LDB_ERR_OPERATIONS_ERROR;
+}
+
+static int operational_search_async(struct ldb_module *module, struct ldb_request *req)
+{
+	struct operational_async_context *ac;
+	struct ldb_request *down_req;
+	const char **search_attrs = NULL;
+	int i, a, ret;
+
+	req->async.handle = NULL;
+
+	ac = talloc(req, struct operational_async_context);
+	if (ac == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	ac->module = module;
+	ac->up_context = req->async.context;
+	ac->up_callback = req->async.callback;
+	ac->timeout = req->async.timeout;
+	ac->attrs = req->op.search.attrs;
+
+	down_req = talloc_zero(req, struct ldb_request);
+	if (down_req == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	down_req->operation = req->operation;
+	down_req->op.search.base = req->op.search.base;
+	down_req->op.search.scope = req->op.search.scope;
+	down_req->op.search.tree = req->op.search.tree;
+
+	/*  FIXME: I hink we should copy the tree and keep the original
+	 *  unmodified. SSS */
+	/* replace any attributes in the parse tree that are
+	   searchable, but are stored using a different name in the
+	   backend */
+	for (i=0;i<ARRAY_SIZE(parse_tree_sub);i++) {
+		ldb_parse_tree_attr_replace(req->op.search.tree, 
+					    parse_tree_sub[i].attr, 
+					    parse_tree_sub[i].replace);
+	}
+
+	/* in the list of attributes we are looking for, rename any
+	   attributes to the alias for any hidden attributes that can
+	   be fetched directly using non-hidden names */
+	for (a=0;ac->attrs && ac->attrs[a];a++) {
+		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
+			if (ldb_attr_cmp(ac->attrs[a], search_sub[i].attr) == 0 &&
+			    search_sub[i].replace) {
+				if (!search_attrs) {
+					search_attrs = ldb_attr_list_copy(req, ac->attrs);
+					if (search_attrs == NULL) {
+						return LDB_ERR_OPERATIONS_ERROR;
+					}
+				}
+				search_attrs[a] = search_sub[i].replace;
+			}
+		}
+	}
+	
+	/* use new set of attrs if any */
+	if (search_attrs) down_req->op.search.attrs = search_attrs;
+	else down_req->op.search.attrs = req->op.search.attrs;
+	
+	down_req->controls = req->controls;
+	down_req->creds = req->creds;
+
+	down_req->async.context = ac;
+	down_req->async.callback = operational_async_callback;
+	down_req->async.timeout = req->async.timeout;
+
+	/* perform the search */
+	ret = ldb_next_request(module, down_req);
+
+	/* do not free down_req as the call results may be linked to it,
+	 * it will be freed when the upper level request get freed */
+	if (ret == LDB_SUCCESS) {
+		req->async.handle = down_req->async.handle;
+	}
+
+	return ret;
+}
+
+/*
+  hook add record ops
+*/
+static int operational_add_async(struct ldb_module *module, struct ldb_request *req)
+{
+	struct ldb_request *down_req;
+	struct ldb_message *msg;
+	time_t t = time(NULL);
+	int ret;
+
+	if (ldb_dn_is_special(req->op.add.message->dn)) {
+		return ldb_next_request(module, req);
+	}
+
+	down_req = talloc(req, struct ldb_request);
+	if (down_req == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	/* we have to copy the message as the caller might have it as a const */
+	msg = ldb_msg_copy_shallow(down_req, req->op.add.message);
+	if (msg == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	if (add_time_element(msg, "whenCreated", t) != 0 ||
+	    add_time_element(msg, "whenChanged", t) != 0) {
+		talloc_free(down_req);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	/* see if the backend can give us the USN */
+	if (module->ldb->sequence_number != NULL) {
+		uint64_t seq_num = module->ldb->sequence_number(module->ldb);
+		if (add_uint64_element(msg, "uSNCreated", seq_num) != 0 ||
+		    add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
+			talloc_free(down_req);
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+	}
+
+	down_req->op.add.message = msg;
+	
+	down_req->controls = req->controls;
+	down_req->creds = req->creds;
+
+	down_req->async.context = req->async.context;
+	down_req->async.callback = req->async.callback;
+	down_req->async.timeout = req->async.timeout;
+
+	/* go on with the call chain */
+	ret = ldb_next_request(module, down_req);
+
+	/* do not free down_req as the call results may be linked to it,
+	 * it will be freed when the upper level request get freed */
+	if (ret == LDB_SUCCESS) {
+		req->async.handle = down_req->async.handle;
+	}
+
+	return ret;
+}
+
+/*
+  hook modify record ops
+*/
+static int operational_modify_async(struct ldb_module *module, struct ldb_request *req)
+{
+	struct ldb_request *down_req;
+	struct ldb_message *msg;
+	time_t t = time(NULL);
+	int ret;
+
+	if (ldb_dn_is_special(req->op.mod.message->dn)) {
+		return ldb_next_request(module, req);
+	}
+
+	down_req = talloc(req, struct ldb_request);
+	if (down_req == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	/* we have to copy the message as the caller might have it as a const */
+	msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
+	if (msg == NULL) {
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+	if (add_time_element(msg, "whenChanged", t) != 0) {
+		talloc_free(down_req);
+		return LDB_ERR_OPERATIONS_ERROR;
+	}
+
+	/* update the records USN if possible */
+	if (module->ldb->sequence_number != NULL &&
+	    add_uint64_element(msg, "uSNChanged", 
+			       module->ldb->sequence_number(module->ldb)) != 0) {
+		talloc_free(down_req);
+		return -1;
+	}
+
+	down_req->op.mod.message = msg;
+	
+	down_req->controls = req->controls;
+	down_req->creds = req->creds;
+
+	down_req->async.context = req->async.context;
+	down_req->async.callback = req->async.callback;
+	down_req->async.timeout = req->async.timeout;
+
+	/* go on with the call chain */
+	ret = ldb_next_request(module, down_req);
+
+	/* do not free down_req as the call results may be linked to it,
+	 * it will be freed when the upper level request get freed */
+	if (ret == LDB_SUCCESS) {
+		req->async.handle = down_req->async.handle;
+	}
+
+	return ret;
+}
+
 
 static int operational_request(struct ldb_module *module, struct ldb_request *req)
 {
@@ -394,6 +636,15 @@ static int operational_request(struct ldb_module *module, struct ldb_request *re
 	case LDB_REQ_MODIFY:
 		return operational_modify(module, req);
 
+	case LDB_ASYNC_SEARCH:
+		return operational_search_async(module, req);
+
+	case LDB_ASYNC_ADD:
+		return operational_add_async(module, req);
+
+	case LDB_ASYNC_MODIFY:
+		return operational_modify_async(module, req);
+
 	default:
 		return ldb_next_request(module, req);
 
-- 
cgit 


From 2d774763f095cdf9d72ee6efc69755404f380890 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 14 Mar 2006 17:39:58 +0000
Subject: r14391: rdn_name -> async (This used to be commit
 0bc3caa9187e992b09bf797e7de507cca9734ab2)

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

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index fc15da4f6e..070f91e762 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -395,8 +395,8 @@ struct operational_async_context {
 	const char * const *attrs;
 };
 
-static int operational_async_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares) {
-
+static int operational_async_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
+{
 	struct operational_async_context *ac;
 
 	if (!context || !ares) {
-- 
cgit 


From 6d0969aa1adff4c7f134bd6e3e42997e72b41cf6 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 20 May 2006 19:37:21 +0000
Subject: r15761: Fix-as-you-go ... Testing various async paths and uncovering
 bugs (This used to be commit 099d873ea596ece18efe63b06bc64e7f97a96f82)

---
 source4/lib/ldb/modules/operational.c | 26 ++++++--------------------
 1 file changed, 6 insertions(+), 20 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 070f91e762..d796e93e54 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -522,8 +522,10 @@ static int operational_add_async(struct ldb_module *module, struct ldb_request *
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	*down_req = *req;
+
 	/* we have to copy the message as the caller might have it as a const */
-	msg = ldb_msg_copy_shallow(down_req, req->op.add.message);
+	down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
 	if (msg == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -543,15 +545,6 @@ static int operational_add_async(struct ldb_module *module, struct ldb_request *
 		}
 	}
 
-	down_req->op.add.message = msg;
-	
-	down_req->controls = req->controls;
-	down_req->creds = req->creds;
-
-	down_req->async.context = req->async.context;
-	down_req->async.callback = req->async.callback;
-	down_req->async.timeout = req->async.timeout;
-
 	/* go on with the call chain */
 	ret = ldb_next_request(module, down_req);
 
@@ -583,8 +576,10 @@ static int operational_modify_async(struct ldb_module *module, struct ldb_reques
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
+	*down_req = *req;
+
 	/* we have to copy the message as the caller might have it as a const */
-	msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
+	down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
 	if (msg == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -600,16 +595,7 @@ static int operational_modify_async(struct ldb_module *module, struct ldb_reques
 		talloc_free(down_req);
 		return -1;
 	}
-
-	down_req->op.mod.message = msg;
 	
-	down_req->controls = req->controls;
-	down_req->creds = req->creds;
-
-	down_req->async.context = req->async.context;
-	down_req->async.callback = req->async.callback;
-	down_req->async.timeout = req->async.timeout;
-
 	/* go on with the call chain */
 	ret = ldb_next_request(module, down_req);
 
-- 
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/modules/operational.c | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index d796e93e54..b47adf0652 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -295,7 +295,7 @@ static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_
 /*
   hook add record ops
 */
-static int operational_add(struct ldb_module *module, struct ldb_request *req)
+static int operational_add_sync(struct ldb_module *module, struct ldb_request *req)
 {
 	const struct ldb_message *msg = req->op.add.message;
 	time_t t = time(NULL);
@@ -341,7 +341,7 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 /*
   hook modify record ops
 */
-static int operational_modify(struct ldb_module *module, struct ldb_request *req)
+static int operational_modify_sync(struct ldb_module *module, struct ldb_request *req)
 {
 	const struct ldb_message *msg = req->op.mod.message;
 	time_t t = time(NULL);
@@ -421,7 +421,7 @@ error:
 	return LDB_ERR_OPERATIONS_ERROR;
 }
 
-static int operational_search_async(struct ldb_module *module, struct ldb_request *req)
+static int operational_search(struct ldb_module *module, struct ldb_request *req)
 {
 	struct operational_async_context *ac;
 	struct ldb_request *down_req;
@@ -506,7 +506,7 @@ static int operational_search_async(struct ldb_module *module, struct ldb_reques
 /*
   hook add record ops
 */
-static int operational_add_async(struct ldb_module *module, struct ldb_request *req)
+static int operational_add(struct ldb_module *module, struct ldb_request *req)
 {
 	struct ldb_request *down_req;
 	struct ldb_message *msg;
@@ -560,7 +560,7 @@ static int operational_add_async(struct ldb_module *module, struct ldb_request *
 /*
   hook modify record ops
 */
-static int operational_modify_async(struct ldb_module *module, struct ldb_request *req)
+static int operational_modify(struct ldb_module *module, struct ldb_request *req)
 {
 	struct ldb_request *down_req;
 	struct ldb_message *msg;
@@ -617,19 +617,10 @@ static int operational_request(struct ldb_module *module, struct ldb_request *re
 		return operational_search_bytree(module, req);
 
 	case LDB_REQ_ADD:
-		return operational_add(module, req);
+		return operational_add_sync(module, req);
 
 	case LDB_REQ_MODIFY:
-		return operational_modify(module, req);
-
-	case LDB_ASYNC_SEARCH:
-		return operational_search_async(module, req);
-
-	case LDB_ASYNC_ADD:
-		return operational_add_async(module, req);
-
-	case LDB_ASYNC_MODIFY:
-		return operational_modify_async(module, req);
+		return operational_modify_sync(module, req);
 
 	default:
 		return ldb_next_request(module, req);
@@ -650,6 +641,9 @@ static int operational_init(struct ldb_module *ctx)
 
 static const struct ldb_module_ops operational_ops = {
 	.name              = "operational",
+	.search            = operational_search,
+	.add               = operational_add,
+	.modify            = operational_modify,
 	.request           = operational_request,
 	.init_context	   = operational_init
 };
-- 
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/modules/operational.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index b47adf0652..084105fd85 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -485,7 +485,6 @@ static int operational_search(struct ldb_module *module, struct ldb_request *req
 	else down_req->op.search.attrs = req->op.search.attrs;
 	
 	down_req->controls = req->controls;
-	down_req->creds = req->creds;
 
 	down_req->async.context = ac;
 	down_req->async.callback = operational_async_callback;
-- 
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/modules/operational.c | 180 ----------------------------------
 1 file changed, 180 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 084105fd85..4b1daba30f 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -169,76 +169,6 @@ failed:
 	return -1;
 }
 
-/*
-  hook search operations
-*/
-static int operational_search_bytree(struct ldb_module *module, struct ldb_request *req)
-{
-	int i, r, a;
-	int ret;
-	const char * const *attrs = req->op.search.attrs;
-	const char **search_attrs = NULL;
-
-	req->op.search.res = NULL;
-
-	/* replace any attributes in the parse tree that are
-	   searchable, but are stored using a different name in the
-	   backend */
-	for (i=0;i<ARRAY_SIZE(parse_tree_sub);i++) {
-		ldb_parse_tree_attr_replace(req->op.search.tree, 
-					    parse_tree_sub[i].attr, 
-					    parse_tree_sub[i].replace);
-	}
-
-	/* in the list of attributes we are looking for, rename any
-	   attributes to the alias for any hidden attributes that can
-	   be fetched directly using non-hidden names */
-	for (a=0;attrs && attrs[a];a++) {
-		for (i=0;i<ARRAY_SIZE(search_sub);i++) {
-			if (ldb_attr_cmp(attrs[a], search_sub[i].attr) == 0 &&
-			    search_sub[i].replace) {
-				if (!search_attrs) {
-					search_attrs = ldb_attr_list_copy(req, attrs);
-					if (search_attrs == NULL) {
-						goto failed;
-					}
-				}
-				search_attrs[a] = search_sub[i].replace;
-			}
-		}
-	}
-	
-	/* use new set of attrs if any */
-	if (search_attrs) req->op.search.attrs = search_attrs;
-	/* perform the search */
-	ret = ldb_next_request(module, req);
-	/* set back saved attrs if needed */
-	if (search_attrs) req->op.search.attrs = attrs;
-
-	/* check operation result */
-	if (ret != LDB_SUCCESS) {
-		return ret;
-	}
-
-	/* for each record returned post-process to add any derived
-	   attributes that have been asked for */
-	for (r = 0; r < req->op.search.res->count; r++) {
-		if (operational_search_post_process(module, req->op.search.res->msgs[r], attrs) != 0) {
-			goto failed;
-		}
-	}
-
-	/* all done */
-	talloc_free(search_attrs);
-	return ret;
-
-failed:
-	talloc_free(search_attrs);
-	talloc_free(req->op.search.res);
-	ldb_oom(module->ldb);
-	return LDB_ERR_OTHER;
-}
-
 /*
   add a time element to a record
 */
@@ -292,95 +222,6 @@ static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_
 }
 
 
-/*
-  hook add record ops
-*/
-static int operational_add_sync(struct ldb_module *module, struct ldb_request *req)
-{
-	const struct ldb_message *msg = req->op.add.message;
-	time_t t = time(NULL);
-	struct ldb_message *msg2;
-	int ret;
-
-	if (ldb_dn_is_special(msg->dn)) {
-		return ldb_next_request(module, req);
-	}
-
-	/* we have to copy the message as the caller might have it as a const */
-	msg2 = ldb_msg_copy_shallow(module, msg);
-	if (msg2 == NULL) {
-		return -1;
-	}
-	if (add_time_element(msg2, "whenCreated", t) != 0 ||
-	    add_time_element(msg2, "whenChanged", t) != 0) {
-		talloc_free(msg2);
-		return -1;
-	}
-
-	/* see if the backend can give us the USN */
-	if (module->ldb->sequence_number != NULL) {
-		uint64_t seq_num = module->ldb->sequence_number(module->ldb);
-		if (add_uint64_element(msg2, "uSNCreated", seq_num) != 0 ||
-		    add_uint64_element(msg2, "uSNChanged", seq_num) != 0) {
-			talloc_free(msg2);
-			return -1;
-		}
-	}
-
-	/* use the new structure for the call chain below this point */
-	req->op.add.message = msg2;
-	/* go on with the call chain */
-	ret = ldb_next_request(module, req);
-	/* put back saved message */
-	req->op.add.message = msg;
-	/* free temproary compy */
-	talloc_free(msg2);
-	return ret;
-}
-
-/*
-  hook modify record ops
-*/
-static int operational_modify_sync(struct ldb_module *module, struct ldb_request *req)
-{
-	const struct ldb_message *msg = req->op.mod.message;
-	time_t t = time(NULL);
-	struct ldb_message *msg2;
-	int ret;
-
-	if (ldb_dn_is_special(msg->dn)) {
-		return ldb_next_request(module, req);
-	}
-
-	/* we have to copy the message as the caller might have it as a const */
-	msg2 = ldb_msg_copy_shallow(module, msg);
-	if (msg2 == NULL) {
-		return -1;
-	}
-	if (add_time_element(msg2, "whenChanged", t) != 0) {
-		talloc_free(msg2);
-		return -1;
-	}
-
-	/* update the records USN if possible */
-	if (module->ldb->sequence_number != NULL &&
-	    add_uint64_element(msg2, "uSNChanged", 
-			       module->ldb->sequence_number(module->ldb)) != 0) {
-		talloc_free(msg2);
-		return -1;
-	}
-
-	/* use the new structure for the call chain below this point */
-	req->op.mod.message = msg2;
-	/* go on with the call chain */
-	ret = ldb_next_request(module, req);
-	/* put back saved message */
-	req->op.mod.message = msg;
-	/* free temproary compy */
-	talloc_free(msg2);
-	return ret;
-}
-
 /*
   hook search operations
 */
@@ -607,26 +448,6 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 	return ret;
 }
 
-
-static int operational_request(struct ldb_module *module, struct ldb_request *req)
-{
-	switch (req->operation) {
-
-	case LDB_REQ_SEARCH:
-		return operational_search_bytree(module, req);
-
-	case LDB_REQ_ADD:
-		return operational_add_sync(module, req);
-
-	case LDB_REQ_MODIFY:
-		return operational_modify_sync(module, req);
-
-	default:
-		return ldb_next_request(module, req);
-
-	}
-}
-
 static int operational_init(struct ldb_module *ctx)
 {
 	/* setup some standard attribute handlers */
@@ -643,7 +464,6 @@ static const struct ldb_module_ops operational_ops = {
 	.search            = operational_search,
 	.add               = operational_add,
 	.modify            = operational_modify,
-	.request           = operational_request,
 	.init_context	   = operational_init
 };
 
-- 
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/modules/operational.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 4b1daba30f..b404e94580 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -231,7 +231,6 @@ struct operational_async_context {
 	struct ldb_module *module;
 	void *up_context;
 	int (*up_callback)(struct ldb_context *, void *, struct ldb_async_result *);
-	int timeout;
 
 	const char * const *attrs;
 };
@@ -279,7 +278,6 @@ static int operational_search(struct ldb_module *module, struct ldb_request *req
 	ac->module = module;
 	ac->up_context = req->async.context;
 	ac->up_callback = req->async.callback;
-	ac->timeout = req->async.timeout;
 	ac->attrs = req->op.search.attrs;
 
 	down_req = talloc_zero(req, struct ldb_request);
@@ -329,7 +327,7 @@ static int operational_search(struct ldb_module *module, struct ldb_request *req
 
 	down_req->async.context = ac;
 	down_req->async.callback = operational_async_callback;
-	down_req->async.timeout = req->async.timeout;
+	ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
 
 	/* perform the search */
 	ret = ldb_next_request(module, down_req);
@@ -385,6 +383,8 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 		}
 	}
 
+	ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
+
 	/* go on with the call chain */
 	ret = ldb_next_request(module, down_req);
 
@@ -436,6 +436,8 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 		return -1;
 	}
 	
+	ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
+
 	/* go on with the call chain */
 	ret = ldb_next_request(module, down_req);
 
-- 
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/modules/operational.c | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index b404e94580..a15a553286 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -349,6 +349,7 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 	struct ldb_request *down_req;
 	struct ldb_message *msg;
 	time_t t = time(NULL);
+	uint64_t seq_num;
 	int ret;
 
 	if (ldb_dn_is_special(req->op.add.message->dn)) {
@@ -373,9 +374,9 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	/* see if the backend can give us the USN */
-	if (module->ldb->sequence_number != NULL) {
-		uint64_t seq_num = module->ldb->sequence_number(module->ldb);
+	/* Get a sequence number from the backend */
+	ret = ldb_sequence_number(module->ldb, &seq_num);
+	if (ret == LDB_SUCCESS) {
 		if (add_uint64_element(msg, "uSNCreated", seq_num) != 0 ||
 		    add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
 			talloc_free(down_req);
@@ -405,6 +406,7 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 	struct ldb_request *down_req;
 	struct ldb_message *msg;
 	time_t t = time(NULL);
+	uint64_t seq_num;
 	int ret;
 
 	if (ldb_dn_is_special(req->op.mod.message->dn)) {
@@ -428,12 +430,15 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	/* update the records USN if possible */
-	if (module->ldb->sequence_number != NULL &&
-	    add_uint64_element(msg, "uSNChanged", 
-			       module->ldb->sequence_number(module->ldb)) != 0) {
-		talloc_free(down_req);
-		return -1;
+	/* Get a sequence number from the backend */
+	ret = ldb_sequence_number(module->ldb, &seq_num);
+	if (ret == LDB_SUCCESS) {
+		/* update the records USN if possible */
+		if (add_uint64_element(msg, "uSNChanged", 
+				       seq_num) != 0) {
+			talloc_free(down_req);
+			return -1;
+		}
 	}
 	
 	ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-- 
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/modules/operational.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index a15a553286..4cadaa27ee 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -230,12 +230,12 @@ struct operational_async_context {
 
 	struct ldb_module *module;
 	void *up_context;
-	int (*up_callback)(struct ldb_context *, void *, struct ldb_async_result *);
+	int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
 
 	const char * const *attrs;
 };
 
-static int operational_async_callback(struct ldb_context *ldb, void *context, struct ldb_async_result *ares)
+static int operational_async_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
 {
 	struct operational_async_context *ac;
 
-- 
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/modules/operational.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 4cadaa27ee..7e7c8d83ad 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -226,7 +226,7 @@ static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_
   hook search operations
 */
 
-struct operational_async_context {
+struct operational_context {
 
 	struct ldb_module *module;
 	void *up_context;
@@ -235,16 +235,16 @@ struct operational_async_context {
 	const char * const *attrs;
 };
 
-static int operational_async_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int operational_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
 {
-	struct operational_async_context *ac;
+	struct operational_context *ac;
 
 	if (!context || !ares) {
 		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback"));
 		goto error;
 	}
 
-	ac = talloc_get_type(context, struct operational_async_context);
+	ac = talloc_get_type(context, struct operational_context);
 
 	if (ares->type == LDB_REPLY_ENTRY) {
 		/* for each record returned post-process to add any derived
@@ -263,21 +263,21 @@ error:
 
 static int operational_search(struct ldb_module *module, struct ldb_request *req)
 {
-	struct operational_async_context *ac;
+	struct operational_context *ac;
 	struct ldb_request *down_req;
 	const char **search_attrs = NULL;
 	int i, a, ret;
 
-	req->async.handle = NULL;
+	req->handle = NULL;
 
-	ac = talloc(req, struct operational_async_context);
+	ac = talloc(req, struct operational_context);
 	if (ac == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ac->module = module;
-	ac->up_context = req->async.context;
-	ac->up_callback = req->async.callback;
+	ac->up_context = req->context;
+	ac->up_callback = req->callback;
 	ac->attrs = req->op.search.attrs;
 
 	down_req = talloc_zero(req, struct ldb_request);
@@ -325,8 +325,8 @@ static int operational_search(struct ldb_module *module, struct ldb_request *req
 	
 	down_req->controls = req->controls;
 
-	down_req->async.context = ac;
-	down_req->async.callback = operational_async_callback;
+	down_req->context = ac;
+	down_req->callback = operational_callback;
 	ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
 
 	/* perform the search */
@@ -335,7 +335,7 @@ static int operational_search(struct ldb_module *module, struct ldb_request *req
 	/* do not free down_req as the call results may be linked to it,
 	 * it will be freed when the upper level request get freed */
 	if (ret == LDB_SUCCESS) {
-		req->async.handle = down_req->async.handle;
+		req->handle = down_req->handle;
 	}
 
 	return ret;
@@ -392,7 +392,7 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 	/* do not free down_req as the call results may be linked to it,
 	 * it will be freed when the upper level request get freed */
 	if (ret == LDB_SUCCESS) {
-		req->async.handle = down_req->async.handle;
+		req->handle = down_req->handle;
 	}
 
 	return ret;
@@ -449,7 +449,7 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 	/* do not free down_req as the call results may be linked to it,
 	 * it will be freed when the upper level request get freed */
 	if (ret == LDB_SUCCESS) {
-		req->async.handle = down_req->async.handle;
+		req->handle = down_req->handle;
 	}
 
 	return ret;
-- 
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/modules/operational.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 7e7c8d83ad..934622eccd 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -240,7 +240,7 @@ static int operational_callback(struct ldb_context *ldb, void *context, struct l
 	struct operational_context *ac;
 
 	if (!context || !ares) {
-		ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback"));
+		ldb_set_errstring(ldb, "NULL Context or Result in callback");
 		goto error;
 	}
 
-- 
cgit 


From 8f42f1292c2f1f1002b8446dc8b5351eb633d5ce Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Mon, 14 Aug 2006 00:59:57 +0000
Subject: r17526: Move timestamp generation into the objectGUID module.  It
 probably needs to be renamed (operation_add?).

This allows me to match the behaviour and substitute with the
entryUUID module for remote LDAP connections.

Andrew Bartlett
(This used to be commit af02b4d7c631bb15bf5a5f73f9fdc23075d50f60)
---
 source4/lib/ldb/modules/operational.c | 41 -----------------------------------
 1 file changed, 41 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 934622eccd..b14d552e83 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -169,35 +169,6 @@ failed:
 	return -1;
 }
 
-/*
-  add a time element to a record
-*/
-static int add_time_element(struct ldb_message *msg, const char *attr, time_t t)
-{
-	struct ldb_message_element *el;
-	char *s;
-
-	if (ldb_msg_find_element(msg, attr) != NULL) {
-		return 0;
-	}
-
-	s = ldb_timestring(msg, t);
-	if (s == NULL) {
-		return -1;
-	}
-
-	if (ldb_msg_add_string(msg, attr, s) != 0) {
-		return -1;
-	}
-
-	el = ldb_msg_find_element(msg, attr);
-	/* always set as replace. This works because on add ops, the flag
-	   is ignored */
-	el->flags = LDB_FLAG_MOD_REPLACE;
-
-	return 0;
-}
-
 /*
   add a uint64_t element to a record
 */
@@ -348,7 +319,6 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 {
 	struct ldb_request *down_req;
 	struct ldb_message *msg;
-	time_t t = time(NULL);
 	uint64_t seq_num;
 	int ret;
 
@@ -368,11 +338,6 @@ static int operational_add(struct ldb_module *module, struct ldb_request *req)
 	if (msg == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	if (add_time_element(msg, "whenCreated", t) != 0 ||
-	    add_time_element(msg, "whenChanged", t) != 0) {
-		talloc_free(down_req);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
 
 	/* Get a sequence number from the backend */
 	ret = ldb_sequence_number(module->ldb, &seq_num);
@@ -405,7 +370,6 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 {
 	struct ldb_request *down_req;
 	struct ldb_message *msg;
-	time_t t = time(NULL);
 	uint64_t seq_num;
 	int ret;
 
@@ -425,11 +389,6 @@ static int operational_modify(struct ldb_module *module, struct ldb_request *req
 	if (msg == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	if (add_time_element(msg, "whenChanged", t) != 0) {
-		talloc_free(down_req);
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
 	/* Get a sequence number from the backend */
 	ret = ldb_sequence_number(module->ldb, &seq_num);
 	if (ret == LDB_SUCCESS) {
-- 
cgit 


From 30ee8beb9316a99e8a49993306252591106cb349 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 9 Sep 2006 10:05:58 +0000
Subject: r18301: I discovered how to load the warnings from a build farm build
 into emacs compile mode (hint, paste to a file, and compile as "cat
 filename").

This allowed me to fix nearly all the warnings for a IA_64 SuSE build
very quickly.
(This used to be commit eba6c84efff735bb0ca941ac4b755ce2b0591667)
---
 source4/lib/ldb/modules/operational.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index b14d552e83..1e405355c4 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -180,7 +180,7 @@ static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_
 		return 0;
 	}
 
-	if (ldb_msg_add_fmt(msg, attr, "%llu", v) != 0) {
+	if (ldb_msg_add_fmt(msg, attr, "%llu", (unsigned long long)v) != 0) {
 		return -1;
 	}
 
-- 
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/modules/operational.c | 127 ----------------------------------
 1 file changed, 127 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 1e405355c4..c327a96f90 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -169,29 +169,6 @@ failed:
 	return -1;
 }
 
-/*
-  add a uint64_t element to a record
-*/
-static int add_uint64_element(struct ldb_message *msg, const char *attr, uint64_t v)
-{
-	struct ldb_message_element *el;
-
-	if (ldb_msg_find_element(msg, attr) != NULL) {
-		return 0;
-	}
-
-	if (ldb_msg_add_fmt(msg, attr, "%llu", (unsigned long long)v) != 0) {
-		return -1;
-	}
-
-	el = ldb_msg_find_element(msg, attr);
-	/* always set as replace. This works because on add ops, the flag
-	   is ignored */
-	el->flags = LDB_FLAG_MOD_REPLACE;
-
-	return 0;
-}
-
 
 /*
   hook search operations
@@ -312,108 +289,6 @@ static int operational_search(struct ldb_module *module, struct ldb_request *req
 	return ret;
 }
 
-/*
-  hook add record ops
-*/
-static int operational_add(struct ldb_module *module, struct ldb_request *req)
-{
-	struct ldb_request *down_req;
-	struct ldb_message *msg;
-	uint64_t seq_num;
-	int ret;
-
-	if (ldb_dn_is_special(req->op.add.message->dn)) {
-		return ldb_next_request(module, req);
-	}
-
-	down_req = talloc(req, struct ldb_request);
-	if (down_req == NULL) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	*down_req = *req;
-
-	/* we have to copy the message as the caller might have it as a const */
-	down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
-	if (msg == NULL) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	/* Get a sequence number from the backend */
-	ret = ldb_sequence_number(module->ldb, &seq_num);
-	if (ret == LDB_SUCCESS) {
-		if (add_uint64_element(msg, "uSNCreated", seq_num) != 0 ||
-		    add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
-			talloc_free(down_req);
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
-	}
-
-	ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
-	/* go on with the call chain */
-	ret = ldb_next_request(module, down_req);
-
-	/* do not free down_req as the call results may be linked to it,
-	 * it will be freed when the upper level request get freed */
-	if (ret == LDB_SUCCESS) {
-		req->handle = down_req->handle;
-	}
-
-	return ret;
-}
-
-/*
-  hook modify record ops
-*/
-static int operational_modify(struct ldb_module *module, struct ldb_request *req)
-{
-	struct ldb_request *down_req;
-	struct ldb_message *msg;
-	uint64_t seq_num;
-	int ret;
-
-	if (ldb_dn_is_special(req->op.mod.message->dn)) {
-		return ldb_next_request(module, req);
-	}
-
-	down_req = talloc(req, struct ldb_request);
-	if (down_req == NULL) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
-	*down_req = *req;
-
-	/* we have to copy the message as the caller might have it as a const */
-	down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
-	if (msg == NULL) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-	/* Get a sequence number from the backend */
-	ret = ldb_sequence_number(module->ldb, &seq_num);
-	if (ret == LDB_SUCCESS) {
-		/* update the records USN if possible */
-		if (add_uint64_element(msg, "uSNChanged", 
-				       seq_num) != 0) {
-			talloc_free(down_req);
-			return -1;
-		}
-	}
-	
-	ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
-	/* go on with the call chain */
-	ret = ldb_next_request(module, down_req);
-
-	/* do not free down_req as the call results may be linked to it,
-	 * it will be freed when the upper level request get freed */
-	if (ret == LDB_SUCCESS) {
-		req->handle = down_req->handle;
-	}
-
-	return ret;
-}
-
 static int operational_init(struct ldb_module *ctx)
 {
 	/* setup some standard attribute handlers */
@@ -428,8 +303,6 @@ static int operational_init(struct ldb_module *ctx)
 static const struct ldb_module_ops operational_ops = {
 	.name              = "operational",
 	.search            = operational_search,
-	.add               = operational_add,
-	.modify            = operational_modify,
 	.init_context	   = operational_init
 };
 
-- 
cgit 


From c69717755abeaf8bf93e76255d0912e3a24b7cb0 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 15 Dec 2006 13:08:57 +0000
Subject: r20184: change ldb_attrib_handler into ldb_schema_attribute, which
 has a pointer to a ldb_schema_syntax struct.

the default attribute handler is now registered dynamicly as "*"
attribute, instead of having its own code path.

ldb_schema_attribute's can be added to the ldb_schema given a
ldb_schema_syntax struct or the syntax name

we may also need to introduce a ldb_schema_matching_rule,
and add a pointer to a default ldb_schema_matching_rule
in the ldb_schema_syntax.

metze
(This used to be commit b97b8f5dcbce006f005e53ca79df3330e62f117b)
---
 source4/lib/ldb/modules/operational.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index c327a96f90..764ce76294 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -291,11 +291,17 @@ static int operational_search(struct ldb_module *module, struct ldb_request *req
 
 static int operational_init(struct ldb_module *ctx)
 {
+	int ret = 0;
+
 	/* setup some standard attribute handlers */
-	ldb_set_attrib_handler_syntax(ctx->ldb, "whenCreated", LDB_SYNTAX_UTC_TIME);
-	ldb_set_attrib_handler_syntax(ctx->ldb, "whenChanged", LDB_SYNTAX_UTC_TIME);
-	ldb_set_attrib_handler_syntax(ctx->ldb, "subschemaSubentry", LDB_SYNTAX_DN);
-	ldb_set_attrib_handler_syntax(ctx->ldb, "structuralObjectClass", LDB_SYNTAX_OBJECTCLASS);
+	ret |= ldb_schema_attribute_add(ctx->ldb, "whenCreated", 0, LDB_SYNTAX_UTC_TIME);
+	ret |= ldb_schema_attribute_add(ctx->ldb, "whenChanged", 0, LDB_SYNTAX_UTC_TIME);
+	ret |= ldb_schema_attribute_add(ctx->ldb, "subschemaSubentry", 0, LDB_SYNTAX_DN);
+	ret |= ldb_schema_attribute_add(ctx->ldb, "structuralObjectClass", 0, LDB_SYNTAX_OBJECTCLASS);
+
+	if (ret != 0) {
+		return ret;
+	}
 
 	return ldb_next_init(ctx);
 }
-- 
cgit 


From b92c5d454e0eeae4a75a421bf72c6156ef43171f Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 15 Feb 2007 11:51:06 +0000
Subject: r21354: fix comment

metze
(This used to be commit 545f769c2fb29323f2fa06e076af894c0be678d0)
---
 source4/lib/ldb/modules/operational.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 764ce76294..4fa572501f 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -50,7 +50,7 @@
 
 
   subschemaSubentry: HIDDEN, not-searchable, 
-                     points at DN CN=Aggregate,CN=Schema,CN=Configuration,$BASEDN
+                     points at DN CN=Aggregate,$SCHEMADN
 
      for this one we do the search as normal, then add the static
      value if requested. How do we work out the $BASEDN from inside a
-- 
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/modules/operational.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 4fa572501f..96590a49a9 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -74,8 +74,7 @@
   modifiersName: not supported by w2k3?
 */
 
-#include "includes.h"
-#include "ldb/include/includes.h"
+#include "ldb_includes.h"
 
 /*
   construct a canonical name from a message
-- 
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/modules/operational.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 96590a49a9..a9e7f0398c 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.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/modules/operational.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index a9e7f0398c..45f23aa0c1 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.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/>.
 */
 /*
   handle operational attributes
-- 
cgit 


From 16109a40c0abd8c30a5eb9bf9ef692bfae9dfc7d Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 20 Feb 2008 01:54:32 +0100
Subject: Use struct-based rather than function-based initialization for ldb
 modules everywhere. (This used to be commit
 85c96a325867f7bcdb412ebc53f8a47dbf7cd89b)

---
 source4/lib/ldb/modules/operational.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 45f23aa0c1..7dc4ae08c3 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -304,13 +304,8 @@ static int operational_init(struct ldb_module *ctx)
 	return ldb_next_init(ctx);
 }
 
-static const struct ldb_module_ops operational_ops = {
+const struct ldb_module_ops ldb_operational_module_ops = {
 	.name              = "operational",
 	.search            = operational_search,
 	.init_context	   = operational_init
 };
-
-int ldb_operational_init(void)
-{
-	return ldb_register_module(&operational_ops);
-}
-- 
cgit 


From 64293ca4afb6aa252d9e49bbcb8450a3dff04c37 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 21 Aug 2008 12:56:34 +1000
Subject: All these syntaxes are now handled by the schema. (This used to be
 commit 94d5e69190f34d66d4defd4a7de7ce24bee77bc3)

---
 source4/lib/ldb/modules/operational.c | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'source4/lib/ldb/modules/operational.c')

diff --git a/source4/lib/ldb/modules/operational.c b/source4/lib/ldb/modules/operational.c
index 7dc4ae08c3..a59e81becd 100644
--- a/source4/lib/ldb/modules/operational.c
+++ b/source4/lib/ldb/modules/operational.c
@@ -291,12 +291,6 @@ static int operational_init(struct ldb_module *ctx)
 {
 	int ret = 0;
 
-	/* setup some standard attribute handlers */
-	ret |= ldb_schema_attribute_add(ctx->ldb, "whenCreated", 0, LDB_SYNTAX_UTC_TIME);
-	ret |= ldb_schema_attribute_add(ctx->ldb, "whenChanged", 0, LDB_SYNTAX_UTC_TIME);
-	ret |= ldb_schema_attribute_add(ctx->ldb, "subschemaSubentry", 0, LDB_SYNTAX_DN);
-	ret |= ldb_schema_attribute_add(ctx->ldb, "structuralObjectClass", 0, LDB_SYNTAX_OBJECTCLASS);
-
 	if (ret != 0) {
 		return ret;
 	}
-- 
cgit