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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
new file mode 100644
index 0000000000..dda80a6b2a
--- /dev/null
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -0,0 +1,641 @@
+/* 
+   ldb database library
+
+   Copyright (C) Andrew Tridgell  2004
+
+     ** NOTE! The following LGPL license applies to the ldb
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
+   
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/*
+ *  Name: ldb
+ *
+ *  Component: ldb tdb backend - indexing
+ *
+ *  Description: indexing routines for ldb tdb backend
+ *
+ *  Author: Andrew Tridgell
+ */
+
+#include "includes.h"
+
+struct dn_list {
+	unsigned int count;
+	char **dn;
+};
+
+/*
+  free a struct dn_list
+*/
+static void dn_list_free(struct dn_list *list)
+{
+	int i;
+	for (i=0;i<list->count;i++) {
+		free(list->dn[i]);
+	}
+	if (list->dn) free(list->dn);
+}
+
+/*
+  return the dn key to be used for an index
+  caller frees
+*/
+static char *ldb_dn_key(const char *attr, const struct ldb_val *value)
+{
+	char *ret = NULL;
+
+	if (ldb_should_b64_encode(value)) {
+		char *vstr = ldb_base64_encode(value->data, value->length);
+		if (!vstr) return NULL;
+		asprintf(&ret, "@INDEX:%s::%s", attr, vstr);
+		free(vstr);
+		return ret;
+	}
+
+	asprintf(&ret, "@INDEX:%s:%s", attr, (char *)value->data);
+	return ret;
+}
+
+/*
+  see if a attribute value is in the list of indexed attributes
+*/
+static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr)
+{
+	int i;
+	for (i=0;i<msg->num_elements;i++) {
+		if (strcmp(msg->elements[i].name, "@IDXATTR") == 0 &&
+		    strcmp((char *)msg->elements[i].value.data, attr) == 0) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+/*
+  return a list of dn's that might match a simple indexed search or
+ */
+static int ltdb_index_dn_simple(struct ldb_context *ldb, 
+				struct ldb_parse_tree *tree,
+				const struct ldb_message *index_list,
+				struct dn_list *list)
+{
+	char *dn = NULL;
+	int ret, i;
+	struct ldb_message msg;
+
+	list->count = 0;
+	list->dn = NULL;
+
+	/*
+	  if the value is a wildcard then we can't do a match via indexing
+	*/
+	if (ltdb_has_wildcard(&tree->u.simple.value)) {
+		return -1;
+	}
+
+	/* if the attribute isn't in the list of indexed attributes then
+	   this node needs a full search */
+	if (ldb_msg_find_idx(index_list, tree->u.simple.attr) == -1) {
+		return -1;
+	}
+
+	/* the attribute is indexed. Pull the list of DNs that match the 
+	   search criterion */
+	dn = ldb_dn_key(tree->u.simple.attr, &tree->u.simple.value);
+	if (!dn) return -1;
+
+	ret = ltdb_search_dn1(ldb, dn, &msg);
+	free(dn);
+	if (ret == 0 || ret == -1) {
+		return ret;
+	}
+
+	list->dn = malloc_array_p(char *, msg.num_elements);
+	if (!list->dn) {
+		ltdb_search_dn1_free(ldb, &msg);
+	}
+
+	for (i=0;i<msg.num_elements;i++) {
+		if (strcmp(msg.elements[i].name, "@IDX") != 0) {
+			continue;
+		}
+		list->dn[list->count] = 
+			strdup((char *)msg.elements[i].value.data);
+		if (!list->dn[list->count]) {
+			dn_list_free(list);
+			ltdb_search_dn1_free(ldb, &msg);
+			return -1;
+		}
+		list->count++;
+	}
+
+	ltdb_search_dn1_free(ldb, &msg);
+
+	qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) strcmp);
+
+	return 1;
+}
+
+/*
+  list intersection
+  list = list & list2
+  relies on the lists being sorted
+*/
+static int list_intersect(struct dn_list *list, const struct dn_list *list2)
+{
+	struct dn_list list3;
+	int i;
+
+	if (list->count == 0 || list2->count == 0) {
+		/* 0 & X == 0 */
+		dn_list_free(list);
+		return 0;
+	}
+
+	list3.dn = malloc_array_p(char *, list->count);
+	if (!list3.dn) {
+		dn_list_free(list);
+		return -1;
+	}
+	list3.count = 0;
+
+	for (i=0;i<list->count;i++) {
+		if (list_find(list->dn[i], list2->dn, list2->count, 
+			      sizeof(char *), (comparison_fn_t)strcmp) != -1) {
+			list3.dn[list3.count] = list->dn[i];
+			list3.count++;
+		} else {
+			free(list->dn[i]);
+		}		
+	}
+
+	free(list->dn);
+	list->dn = list3.dn;
+	list->count = list3.count;
+
+	return 0;
+}
+
+
+/*
+  list union
+  list = list | list2
+  relies on the lists being sorted
+*/
+static int list_union(struct dn_list *list, const struct dn_list *list2)
+{
+	int i;
+	char **d;
+	unsigned int count = list->count;
+
+	if (list->count == 0 && list2->count == 0) {
+		/* 0 | 0 == 0 */
+		dn_list_free(list);
+		return 0;
+	}
+
+	d = realloc_p(list->dn, char *, list->count + list2->count);
+	if (!d) {
+		dn_list_free(list);
+		return -1;
+	}
+	list->dn = d;
+
+	for (i=0;i<list2->count;i++) {
+		if (list_find(list2->dn[i], list->dn, count, 
+			      sizeof(char *), (comparison_fn_t)strcmp) == -1) {
+			list->dn[list->count] = strdup(list2->dn[i]);
+			if (!list->dn[list->count]) {
+				dn_list_free(list);
+				return -1;
+			}
+			list->count++;
+		}		
+	}
+
+	if (list->count != count) {
+		qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t)strcmp);
+	}
+
+	return 0;
+}
+
+static int ltdb_index_dn(struct ldb_context *ldb, 
+			 struct ldb_parse_tree *tree,
+			 const struct ldb_message *index_list,
+			 struct dn_list *list);
+
+
+/*
+  OR two index results
+ */
+static int ltdb_index_dn_or(struct ldb_context *ldb, 
+			    struct ldb_parse_tree *tree,
+			    const struct ldb_message *index_list,
+			    struct dn_list *list)
+{
+	int ret, i;
+	
+	ret = -1;
+	list->dn = NULL;
+	list->count = 0;
+
+	for (i=0;i<tree->u.list.num_elements;i++) {
+		struct dn_list list2;
+		int v;
+		v = ltdb_index_dn(ldb, tree->u.list.elements[i], index_list, &list2);
+
+		if (v == 0) {
+			/* 0 || X == X */
+			if (ret == -1) {
+				ret = 0;
+			}
+			continue;
+		}
+
+		if (v == -1) {
+			/* 1 || X == 1 */
+			dn_list_free(list);
+			return -1;
+		}
+
+		if (ret == -1) {
+			ret = 1;
+			*list = list2;
+		} else {
+			if (list_union(list, &list2) == -1) {
+				dn_list_free(&list2);
+				return -1;
+			}
+			dn_list_free(&list2);
+		}
+	}
+
+	if (list->count == 0) {
+		dn_list_free(list);
+		return 0;
+	}
+
+	return ret;
+}
+
+
+/*
+  NOT an index results
+ */
+static int ltdb_index_dn_not(struct ldb_context *ldb, 
+			     struct ldb_parse_tree *tree,
+			     const struct ldb_message *index_list,
+			     struct dn_list *list)
+{
+	/* the only way to do an indexed not would be if we could
+	   negate the not via another not or if we knew the total
+	   number of database elements so we could know that the
+	   existing expression covered the whole database. 
+	   
+	   instead, we just give up, and rely on a full index scan
+	   (unless an outer & manages to reduce the list)
+	*/
+	return -1;
+}
+
+/*
+  AND two index results
+ */
+static int ltdb_index_dn_and(struct ldb_context *ldb, 
+			     struct ldb_parse_tree *tree,
+			     const struct ldb_message *index_list,
+			     struct dn_list *list)
+{
+	int ret, i;
+	
+	ret = -1;
+	list->dn = NULL;
+	list->count = 0;
+
+	for (i=0;i<tree->u.list.num_elements;i++) {
+		struct dn_list list2;
+		int v;
+		v = ltdb_index_dn(ldb, tree->u.list.elements[i], index_list, &list2);
+
+		if (v == 0) {
+			/* 0 && X == 0 */
+			dn_list_free(list);
+			return 0;
+		}
+
+		if (v == -1) {
+			continue;
+		}
+
+		if (ret == -1) {
+			ret = 1;
+			*list = list2;
+		} else {
+			if (list_intersect(list, &list2) == -1) {
+				dn_list_free(&list2);
+				return -1;
+			}
+			dn_list_free(&list2);
+		}
+
+		if (list->count == 0) {
+			if (list->dn) free(list->dn);
+			return 0;
+		}
+	}
+
+	return ret;
+}
+
+/*
+  return a list of dn's that might match a indexed search or
+  -1 if an error. return 0 for no matches, or 1 for matches
+ */
+static int ltdb_index_dn(struct ldb_context *ldb, 
+			 struct ldb_parse_tree *tree,
+			 const struct ldb_message *index_list,
+			 struct dn_list *list)
+{
+	int ret;
+
+	switch (tree->operation) {
+	case LDB_OP_SIMPLE:
+		ret = ltdb_index_dn_simple(ldb, tree, index_list, list);
+		break;
+
+	case LDB_OP_AND:
+		ret = ltdb_index_dn_and(ldb, tree, index_list, list);
+		break;
+
+	case LDB_OP_OR:
+		ret = ltdb_index_dn_or(ldb, tree, index_list, list);
+		break;
+
+	case LDB_OP_NOT:
+		ret = ltdb_index_dn_not(ldb, tree, index_list, list);
+		break;
+	}
+
+	return ret;
+}
+
+/*
+  filter a candidate dn_list from an indexed search into a set of results
+  extracting just the given attributes
+*/
+static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree,
+			    const char *base,
+			    enum ldb_scope scope,
+			    const struct dn_list *dn_list, 
+			    const char *attrs[], struct ldb_message ***res)
+{
+	int i;
+	unsigned int count = 0;
+
+	for (i=0;i<dn_list->count;i++) {
+		struct ldb_message msg;
+		int ret;
+		ret = ltdb_search_dn1(ldb, dn_list->dn[i], &msg);
+		if (ret == 0) {
+			/* the record has disappeared? yes, this can happen */
+			continue;
+		}
+
+		if (ret == -1) {
+			/* an internal error */
+			return -1;
+		}
+
+		if (ldb_message_match(ldb, &msg, tree, base, scope) == 1) {
+			ret = ltdb_add_attr_results(ldb, &msg, attrs, &count, res);
+		}
+		ltdb_search_dn1_free(ldb, &msg);
+		if (ret != 0) {
+			return -1;
+		}
+	}
+
+	return count;
+}
+
+/*
+  search the database with a LDAP-like expression using indexes
+  returns -1 if an indexed search is not possible, in which
+  case the caller should call ltdb_search_full() 
+*/
+int ltdb_search_indexed(struct ldb_context *ldb, 
+			const char *base,
+			enum ldb_scope scope,
+			struct ldb_parse_tree *tree,
+			const char *attrs[], struct ldb_message ***res)
+{
+	struct ldb_message index_list;
+	struct dn_list dn_list;
+	int ret;
+
+	/* find the list of indexed fields */	
+	ret = ltdb_search_dn1(ldb, "@INDEXLIST", &index_list);
+	if (ret != 1) {
+		/* no index list? must do full search */
+		return -1;
+	}
+
+	ret = ltdb_index_dn(ldb, tree, &index_list, &dn_list);
+	ltdb_search_dn1_free(ldb, &index_list);
+
+	if (ret == 1) {
+		/* we've got a candidate list - now filter by the full tree
+		   and extract the needed attributes */
+		ret = ldb_index_filter(ldb, tree, base, scope, &dn_list, 
+				       attrs, res);
+		dn_list_free(&dn_list);
+	}
+
+	return ret;
+}
+
+/*
+  add an index entry for one message element
+*/
+static int ltdb_index_add1(struct ldb_context *ldb, const char *dn, 
+			   struct ldb_message_element *el)
+{
+	struct ldb_message msg;
+	char *dn_key;
+	int ret;
+	struct ldb_message_element *el2;
+
+	dn_key = ldb_dn_key(el->name, &el->value);
+	if (!dn_key) {
+		return -1;
+	}
+
+	ret = ltdb_search_dn1(ldb, dn_key, &msg);
+	if (ret == -1) {
+		free(dn_key);
+		return -1;
+	}
+
+	if (ret == 0) {
+		msg.dn = dn_key;
+		msg.num_elements = 0;
+		msg.elements = NULL;
+		msg.private = NULL;
+	}
+
+	/* add another entry */
+	el2 = realloc_p(msg.elements, struct ldb_message_element, msg.num_elements+1);
+	if (!el2) {
+		if (ret == 1) {
+			ltdb_search_dn1_free(ldb, &msg);
+		}
+		free(dn_key);
+		return -1;
+	}
+
+	msg.elements = el2;
+	msg.elements[msg.num_elements].name = "@IDX";
+	msg.elements[msg.num_elements].value.length = strlen(dn);
+	msg.elements[msg.num_elements].value.data = dn;
+	msg.num_elements++;
+
+	ret = ltdb_store(ldb, &msg, TDB_REPLACE);
+
+	if (msg.num_elements == 1) {
+		free(msg.elements);
+	} else {
+		ltdb_search_dn1_free(ldb, &msg);
+	}
+
+	return ret;
+}
+
+/*
+  add the index entries for a new record
+  return -1 on failure
+*/
+int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
+{
+	int ret, i;
+	struct ldb_message index_list;
+
+	/* find the list of indexed fields */	
+	ret = ltdb_search_dn1(ldb, "@INDEXLIST", &index_list);
+	if (ret != 1) {
+		/* no indexed fields or an error */
+		return ret;
+	}
+
+	for (i=0;i<msg->num_elements;i++) {
+		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name);
+		if (ret == -1) {
+			continue;
+		}
+		ret = ltdb_index_add1(ldb, msg->dn, &msg->elements[i]);
+		if (ret == -1) {
+			ltdb_search_dn1_free(ldb, &index_list);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+/*
+  delete an index entry for one message element
+*/
+static int ltdb_index_del1(struct ldb_context *ldb, const char *dn, 
+			   struct ldb_message_element *el)
+{
+	struct ldb_message msg;
+	char *dn_key;
+	int ret, i;
+
+	dn_key = ldb_dn_key(el->name, &el->value);
+	if (!dn_key) {
+		return -1;
+	}
+
+	ret = ltdb_search_dn1(ldb, dn_key, &msg);
+	if (ret == -1) {
+		free(dn_key);
+		return -1;
+	}
+
+	if (ret == 0) {
+		/* it wasn't indexed. Did we have an earlier error? If we did then
+		   its gone now */
+		ltdb_search_dn1_free(ldb, &msg);
+		return 0;
+	}
+
+	i = ldb_msg_find_idx(&msg, dn);
+	if (i == -1) {
+		/* it ain't there. hmmm */
+		ltdb_search_dn1_free(ldb, &msg);
+		return 0;
+	}
+
+	if (i != msg.num_elements - 1) {
+		memmove(&msg.elements[i], &msg.elements[i+1], sizeof(msg.elements[i]));
+	}
+	msg.num_elements--;
+
+	if (msg.num_elements == 0) {
+		ret = ltdb_delete_noindex(ldb, dn_key);
+	} else {
+		ret = ltdb_store(ldb, &msg, TDB_REPLACE);
+	}
+
+	ltdb_search_dn1_free(ldb, &msg);
+
+	return ret;
+}
+
+/*
+  delete the index entries for a record
+  return -1 on failure
+*/
+int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
+{
+	int ret, i;
+	struct ldb_message index_list;
+
+	/* find the list of indexed fields */	
+	ret = ltdb_search_dn1(ldb, "@INDEXLIST", &index_list);
+	if (ret != 1) {
+		/* no indexed fields or an error */
+		return ret;
+	}
+
+	for (i=0;i<msg->num_elements;i++) {
+		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name);
+		if (ret == -1) {
+			continue;
+		}
+		ret = ltdb_index_del1(ldb, msg->dn, &msg->elements[i]);
+		if (ret == -1) {
+			ltdb_search_dn1_free(ldb, &index_list);
+			return -1;
+		}
+	}
+
+	return 0;
+}
-- 
cgit 


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

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 208 +++++++++++++++++++++++++-----------
 1 file changed, 146 insertions(+), 62 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index dda80a6b2a..8cda8abff8 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -74,13 +74,22 @@ static char *ldb_dn_key(const char *attr, const struct ldb_val *value)
 /*
   see if a attribute value is in the list of indexed attributes
 */
-static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr)
+static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
+			    int *v_idx)
 {
-	int i;
+	int i, j;
 	for (i=0;i<msg->num_elements;i++) {
-		if (strcmp(msg->elements[i].name, "@IDXATTR") == 0 &&
-		    strcmp((char *)msg->elements[i].value.data, attr) == 0) {
-			return i;
+		if (strcmp(msg->elements[i].name, "@IDXATTR") == 0) {
+			const struct ldb_message_element *el = 
+				&msg->elements[i];
+			for (j=0;j<el->num_values;j++) {
+				if (strcmp((char *)el->values[j].data, attr) == 0) {
+					if (v_idx) {
+						*v_idx = j;
+					}
+					return i;
+				}
+			}
 		}
 	}
 	return -1;
@@ -95,7 +104,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 				struct dn_list *list)
 {
 	char *dn = NULL;
-	int ret, i;
+	int ret, i, j;
 	struct ldb_message msg;
 
 	list->count = 0;
@@ -110,7 +119,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 
 	/* if the attribute isn't in the list of indexed attributes then
 	   this node needs a full search */
-	if (ldb_msg_find_idx(index_list, tree->u.simple.attr) == -1) {
+	if (ldb_msg_find_idx(index_list, tree->u.simple.attr, NULL) == -1) {
 		return -1;
 	}
 
@@ -125,23 +134,30 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 		return ret;
 	}
 
-	list->dn = malloc_array_p(char *, msg.num_elements);
-	if (!list->dn) {
-		ltdb_search_dn1_free(ldb, &msg);
-	}
-
 	for (i=0;i<msg.num_elements;i++) {
+		struct ldb_message_element *el;
+
 		if (strcmp(msg.elements[i].name, "@IDX") != 0) {
 			continue;
 		}
-		list->dn[list->count] = 
-			strdup((char *)msg.elements[i].value.data);
-		if (!list->dn[list->count]) {
-			dn_list_free(list);
-			ltdb_search_dn1_free(ldb, &msg);
-			return -1;
+
+		el = &msg.elements[i];
+
+		list->dn = malloc_array_p(char *, el->num_values);
+		if (!list->dn) {
+			break;		
+		}
+
+		for (j=0;j<el->num_values;j++) {
+			list->dn[list->count] = 
+				strdup((char *)el->values[j].data);
+			if (!list->dn[list->count]) {
+				dn_list_free(list);
+				ltdb_search_dn1_free(ldb, &msg);
+				return -1;
+			}
+			list->count++;
 		}
-		list->count++;
 	}
 
 	ltdb_search_dn1_free(ldb, &msg);
@@ -470,18 +486,76 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 	return ret;
 }
 
+/*
+  add a index element where this is the first indexed DN for this value
+*/
+static int ltdb_index_add1_new(struct ldb_context *ldb, 
+			       struct ldb_message *msg,
+			       struct ldb_message_element *el,
+			       const char *dn)
+{
+	struct ldb_message_element *el2;
+
+	/* add another entry */
+	el2 = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1);
+	if (!el2) {
+		return -1;
+	}
+
+	msg->elements = el2;
+	msg->elements[msg->num_elements].name = "@IDX";
+	msg->elements[msg->num_elements].num_values = 0;
+	msg->elements[msg->num_elements].values = malloc_p(struct ldb_val);
+	if (!msg->elements[msg->num_elements].values) {
+		return -1;
+	}
+	msg->elements[msg->num_elements].values[0].length = strlen(dn);
+	msg->elements[msg->num_elements].values[0].data = dn;
+	msg->elements[msg->num_elements].num_values = 1;
+	msg->num_elements++;
+
+	return 0;
+}
+
+
+/*
+  add a index element where this is not the first indexed DN for this
+  value
+*/
+static int ltdb_index_add1_add(struct ldb_context *ldb, 
+			       struct ldb_message *msg,
+			       struct ldb_message_element *el,
+			       int idx,
+			       const char *dn)
+{
+	struct ldb_val *v2;
+
+	v2 = realloc_p(msg->elements[idx].values,
+		       struct ldb_val, 
+		       msg->elements[idx].num_values+1);
+	if (!v2) {
+		return -1;
+	}
+	msg->elements[idx].values = v2;
+
+	msg->elements[idx].values[msg->elements[idx].num_values].length = strlen(dn);
+	msg->elements[idx].values[msg->elements[idx].num_values].data = dn;
+	msg->elements[idx].num_values++;
+
+	return 0;
+}
+
 /*
   add an index entry for one message element
 */
 static int ltdb_index_add1(struct ldb_context *ldb, const char *dn, 
-			   struct ldb_message_element *el)
+			   struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_message msg;
 	char *dn_key;
-	int ret;
-	struct ldb_message_element *el2;
+	int ret, i;
 
-	dn_key = ldb_dn_key(el->name, &el->value);
+	dn_key = ldb_dn_key(el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		return -1;
 	}
@@ -493,36 +567,37 @@ static int ltdb_index_add1(struct ldb_context *ldb, const char *dn,
 	}
 
 	if (ret == 0) {
-		msg.dn = dn_key;
+		msg.dn = strdup(dn_key);
+		if (!msg.dn) {
+			free(dn_key);
+			errno = ENOMEM;
+			return -1;
+		}
 		msg.num_elements = 0;
 		msg.elements = NULL;
 		msg.private = NULL;
 	}
 
-	/* add another entry */
-	el2 = realloc_p(msg.elements, struct ldb_message_element, msg.num_elements+1);
-	if (!el2) {
-		if (ret == 1) {
-			ltdb_search_dn1_free(ldb, &msg);
+	free(dn_key);
+
+	for (i=0;i<msg.num_elements;i++) {
+		if (strcmp("@IDX", msg.elements[i].name) == 0) {
+			break;
 		}
-		free(dn_key);
-		return -1;
 	}
 
-	msg.elements = el2;
-	msg.elements[msg.num_elements].name = "@IDX";
-	msg.elements[msg.num_elements].value.length = strlen(dn);
-	msg.elements[msg.num_elements].value.data = dn;
-	msg.num_elements++;
-
-	ret = ltdb_store(ldb, &msg, TDB_REPLACE);
-
-	if (msg.num_elements == 1) {
-		free(msg.elements);
+	if (i == msg.num_elements) {
+		ret = ltdb_index_add1_new(ldb, &msg, el, dn);
 	} else {
-		ltdb_search_dn1_free(ldb, &msg);
+		ret = ltdb_index_add1_add(ldb, &msg, el, i, dn);
+	}
+
+	if (ret == 0) {
+		ret = ltdb_store(ldb, &msg, TDB_REPLACE);
 	}
 
+	ltdb_search_dn1_free(ldb, &msg);
+
 	return ret;
 }
 
@@ -532,7 +607,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, const char *dn,
 */
 int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
 {
-	int ret, i;
+	int ret, i, j;
 	struct ldb_message index_list;
 
 	/* find the list of indexed fields */	
@@ -543,17 +618,21 @@ int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name);
+		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name, NULL);
 		if (ret == -1) {
 			continue;
 		}
-		ret = ltdb_index_add1(ldb, msg->dn, &msg->elements[i]);
-		if (ret == -1) {
-			ltdb_search_dn1_free(ldb, &index_list);
-			return -1;
+		for (j=0;j<msg->elements[i].num_values;j++) {
+			ret = ltdb_index_add1(ldb, msg->dn, &msg->elements[i], j);
+			if (ret == -1) {
+				ltdb_search_dn1_free(ldb, &index_list);
+				return -1;
+			}
 		}
 	}
 
+	ltdb_search_dn1_free(ldb, &index_list);
+
 	return 0;
 }
 
@@ -562,13 +641,13 @@ int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
   delete an index entry for one message element
 */
 static int ltdb_index_del1(struct ldb_context *ldb, const char *dn, 
-			   struct ldb_message_element *el)
+			   struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_message msg;
 	char *dn_key;
-	int ret, i;
+	int ret, i, j;
 
-	dn_key = ldb_dn_key(el->name, &el->value);
+	dn_key = ldb_dn_key(el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		return -1;
 	}
@@ -586,19 +665,22 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 		return 0;
 	}
 
-	i = ldb_msg_find_idx(&msg, dn);
+	i = ldb_msg_find_idx(&msg, dn, &j);
 	if (i == -1) {
 		/* it ain't there. hmmm */
 		ltdb_search_dn1_free(ldb, &msg);
 		return 0;
 	}
 
-	if (i != msg.num_elements - 1) {
-		memmove(&msg.elements[i], &msg.elements[i+1], sizeof(msg.elements[i]));
+	if (j != msg.elements[i].num_values - 1) {
+		memmove(&msg.elements[i].values[j], 
+			&msg.elements[i].values[j+1], 
+			(msg.elements[i].num_values-1) * 
+			sizeof(msg.elements[i].values[0]));
 	}
-	msg.num_elements--;
+	msg.elements[i].num_values--;
 
-	if (msg.num_elements == 0) {
+	if (msg.elements[i].num_values == 0) {
 		ret = ltdb_delete_noindex(ldb, dn_key);
 	} else {
 		ret = ltdb_store(ldb, &msg, TDB_REPLACE);
@@ -615,7 +697,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 */
 int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 {
-	int ret, i;
+	int ret, i, j;
 	struct ldb_message index_list;
 
 	/* find the list of indexed fields */	
@@ -626,14 +708,16 @@ int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name);
+		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name, NULL);
 		if (ret == -1) {
 			continue;
 		}
-		ret = ltdb_index_del1(ldb, msg->dn, &msg->elements[i]);
-		if (ret == -1) {
-			ltdb_search_dn1_free(ldb, &index_list);
-			return -1;
+		for (j=0;j<msg->elements[i].num_values;j++) {
+			ret = ltdb_index_del1(ldb, msg->dn, &msg->elements[i], j);
+			if (ret == -1) {
+				ltdb_search_dn1_free(ldb, &index_list);
+				return -1;
+			}
 		}
 	}
 
-- 
cgit 


From 07882b5460121c4ed100f9655935501f7cf23856 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 23 Apr 2004 13:05:27 +0000
Subject: r343: added automatic reindexing of the database when the index list
 changes (This used to be commit a811640ce408373a5c2c0ee2c125bd735d96d5e1)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 66 +++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 8cda8abff8..95162ae575 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -33,6 +33,7 @@
  */
 
 #include "includes.h"
+#include "ldb/ldb_tdb/ldb_tdb.h"
 
 struct dn_list {
 	unsigned int count;
@@ -723,3 +724,68 @@ int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 
 	return 0;
 }
+
+
+/*
+  traversal function that deletes all @INDEX records
+*/
+static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
+{
+	if (strncmp(key.dptr, "@INDEX:", 7) == 0) {
+		return tdb_delete(tdb, key);
+	}
+	return 0;
+}
+
+/*
+  traversal function that adds @INDEX records during a re index
+*/
+static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
+{
+	struct ldb_context *ldb = state;
+	struct ldb_message msg;
+	int ret;
+
+	if (strncmp(key.dptr, "DN=@", 4) == 0 ||
+	    strncmp(key.dptr, "DN=", 3) != 0) {
+		return 0;
+	}
+
+	ret = ltdb_unpack_data(ldb, &data, &msg);
+	if (ret != 0) {
+		return -1;
+	}
+
+	msg.dn = key.dptr+3;
+
+	ret = ltdb_index_add(ldb, &msg);
+
+	ltdb_unpack_data_free(&msg);
+
+	return ret;
+}
+
+/*
+  force a complete reindex of the database
+*/
+int ltdb_reindex(struct ldb_context *ldb)
+{
+	struct ltdb_private *ltdb = ldb->private;
+	int ret;
+
+	/* first traverse the database deleting any @INDEX records */
+	ret = tdb_traverse(ltdb->tdb, delete_index, NULL);
+	if (ret == -1) {
+		errno = EIO;
+		return -1;
+	}
+
+	/* now traverse adding any indexes for normal LDB records */
+	ret = tdb_traverse(ltdb->tdb, re_index, ldb);
+	if (ret == -1) {
+		errno = EIO;
+		return -1;
+	}
+
+	return 0;
+}
-- 
cgit 


From 803b5d8aa46f5a26a31b65992e5aa34e3df9495c Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 23 Apr 2004 13:09:53 +0000
Subject: r344: fixed deletion of index records (This used to be commit
 246f17cd4a7851042739574f1e07b113c44275c7)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 95162ae575..05ae2bbc14 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -731,7 +731,7 @@ int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 */
 static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
 {
-	if (strncmp(key.dptr, "@INDEX:", 7) == 0) {
+	if (strncmp(key.dptr, "DN=@INDEX:", 10) == 0) {
 		return tdb_delete(tdb, key);
 	}
 	return 0;
-- 
cgit 


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 05ae2bbc14..d4e6c95d63 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -770,7 +770,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 */
 int ltdb_reindex(struct ldb_context *ldb)
 {
-	struct ltdb_private *ltdb = ldb->private;
+	struct ltdb_private *ltdb = ldb->private_data;
 	int ret;
 
 	/* first traverse the database deleting any @INDEX records */
-- 
cgit 


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index d4e6c95d63..a23fc2d525 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -576,7 +576,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, const char *dn,
 		}
 		msg.num_elements = 0;
 		msg.elements = NULL;
-		msg.private = NULL;
+		msg.private_data = NULL;
 	}
 
 	free(dn_key);
-- 
cgit 


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

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

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

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

 - cleaned up a number of const warnings

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

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

 - changed some variable names to avoid conflicts with C++
(This used to be commit f2bf06f25c2e6c744817711c7bedbd1d3b52f994)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 75 ++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 38 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index a23fc2d525..c4243e9b40 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -63,12 +63,12 @@ static char *ldb_dn_key(const char *attr, const struct ldb_val *value)
 	if (ldb_should_b64_encode(value)) {
 		char *vstr = ldb_base64_encode(value->data, value->length);
 		if (!vstr) return NULL;
-		asprintf(&ret, "@INDEX:%s::%s", attr, vstr);
+		asprintf(&ret, "%s:%s::%s", LTDB_INDEX, attr, vstr);
 		free(vstr);
 		return ret;
 	}
 
-	asprintf(&ret, "@INDEX:%s:%s", attr, (char *)value->data);
+	asprintf(&ret, "%s:%s:%s", LTDB_INDEX, attr, (char *)value->data);
 	return ret;
 }
 
@@ -80,11 +80,11 @@ static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
 {
 	int i, j;
 	for (i=0;i<msg->num_elements;i++) {
-		if (strcmp(msg->elements[i].name, "@IDXATTR") == 0) {
+		if (ldb_attr_cmp(msg->elements[i].name, LTDB_IDXATTR) == 0) {
 			const struct ldb_message_element *el = 
 				&msg->elements[i];
 			for (j=0;j<el->num_values;j++) {
-				if (strcmp((char *)el->values[j].data, attr) == 0) {
+				if (ldb_attr_cmp((char *)el->values[j].data, attr) == 0) {
 					if (v_idx) {
 						*v_idx = j;
 					}
@@ -114,7 +114,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 	/*
 	  if the value is a wildcard then we can't do a match via indexing
 	*/
-	if (ltdb_has_wildcard(&tree->u.simple.value)) {
+	if (ltdb_has_wildcard(ldb, tree->u.simple.attr, &tree->u.simple.value)) {
 		return -1;
 	}
 
@@ -138,7 +138,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 	for (i=0;i<msg.num_elements;i++) {
 		struct ldb_message_element *el;
 
-		if (strcmp(msg.elements[i].name, "@IDX") != 0) {
+		if (strcmp(msg.elements[i].name, LTDB_IDX) != 0) {
 			continue;
 		}
 
@@ -420,7 +420,7 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
 			    const char *base,
 			    enum ldb_scope scope,
 			    const struct dn_list *dn_list, 
-			    const char *attrs[], struct ldb_message ***res)
+			    char * const attrs[], struct ldb_message ***res)
 {
 	int i;
 	unsigned int count = 0;
@@ -460,21 +460,18 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 			const char *base,
 			enum ldb_scope scope,
 			struct ldb_parse_tree *tree,
-			const char *attrs[], struct ldb_message ***res)
+			char * const attrs[], struct ldb_message ***res)
 {
-	struct ldb_message index_list;
+	struct ltdb_private *ltdb = ldb->private_data;
 	struct dn_list dn_list;
 	int ret;
 
-	/* find the list of indexed fields */	
-	ret = ltdb_search_dn1(ldb, "@INDEXLIST", &index_list);
-	if (ret != 1) {
+	if (ltdb->cache.indexlist.num_elements == 0) {
 		/* no index list? must do full search */
 		return -1;
 	}
 
-	ret = ltdb_index_dn(ldb, tree, &index_list, &dn_list);
-	ltdb_search_dn1_free(ldb, &index_list);
+	ret = ltdb_index_dn(ldb, tree, &ltdb->cache.indexlist, &dn_list);
 
 	if (ret == 1) {
 		/* we've got a candidate list - now filter by the full tree
@@ -493,7 +490,7 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 static int ltdb_index_add1_new(struct ldb_context *ldb, 
 			       struct ldb_message *msg,
 			       struct ldb_message_element *el,
-			       const char *dn)
+			       char *dn)
 {
 	struct ldb_message_element *el2;
 
@@ -504,7 +501,7 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 	}
 
 	msg->elements = el2;
-	msg->elements[msg->num_elements].name = "@IDX";
+	msg->elements[msg->num_elements].name = LTDB_IDX;
 	msg->elements[msg->num_elements].num_values = 0;
 	msg->elements[msg->num_elements].values = malloc_p(struct ldb_val);
 	if (!msg->elements[msg->num_elements].values) {
@@ -527,7 +524,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 			       struct ldb_message *msg,
 			       struct ldb_message_element *el,
 			       int idx,
-			       const char *dn)
+			       char *dn)
 {
 	struct ldb_val *v2;
 
@@ -549,7 +546,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 /*
   add an index entry for one message element
 */
-static int ltdb_index_add1(struct ldb_context *ldb, const char *dn, 
+static int ltdb_index_add1(struct ldb_context *ldb, char *dn, 
 			   struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_message msg;
@@ -582,7 +579,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, const char *dn,
 	free(dn_key);
 
 	for (i=0;i<msg.num_elements;i++) {
-		if (strcmp("@IDX", msg.elements[i].name) == 0) {
+		if (strcmp(LTDB_IDX, msg.elements[i].name) == 0) {
 			break;
 		}
 	}
@@ -608,32 +605,27 @@ static int ltdb_index_add1(struct ldb_context *ldb, const char *dn,
 */
 int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
 {
+	struct ltdb_private *ltdb = ldb->private_data;
 	int ret, i, j;
-	struct ldb_message index_list;
 
-	/* find the list of indexed fields */	
-	ret = ltdb_search_dn1(ldb, "@INDEXLIST", &index_list);
-	if (ret != 1) {
-		/* no indexed fields or an error */
-		return ret;
+	if (ltdb->cache.indexlist.num_elements == 0) {
+		/* no indexed fields */
+		return 0;
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name, NULL);
+		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, NULL);
 		if (ret == -1) {
 			continue;
 		}
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			ret = ltdb_index_add1(ldb, msg->dn, &msg->elements[i], j);
 			if (ret == -1) {
-				ltdb_search_dn1_free(ldb, &index_list);
 				return -1;
 			}
 		}
 	}
 
-	ltdb_search_dn1_free(ldb, &index_list);
-
 	return 0;
 }
 
@@ -698,25 +690,23 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 */
 int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 {
+	struct ltdb_private *ltdb = ldb->private_data;
 	int ret, i, j;
-	struct ldb_message index_list;
 
 	/* find the list of indexed fields */	
-	ret = ltdb_search_dn1(ldb, "@INDEXLIST", &index_list);
-	if (ret != 1) {
-		/* no indexed fields or an error */
-		return ret;
+	if (ltdb->cache.indexlist.num_elements == 0) {
+		/* no indexed fields */
+		return 0;
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&index_list, msg->elements[i].name, NULL);
+		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, NULL);
 		if (ret == -1) {
 			continue;
 		}
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			ret = ltdb_index_del1(ldb, msg->dn, &msg->elements[i], j);
 			if (ret == -1) {
-				ltdb_search_dn1_free(ldb, &index_list);
 				return -1;
 			}
 		}
@@ -731,7 +721,8 @@ int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 */
 static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
 {
-	if (strncmp(key.dptr, "DN=@INDEX:", 10) == 0) {
+	const char *dn = "DN=" LTDB_INDEX ":";
+	if (strncmp(key.dptr, dn, strlen(dn)) == 0) {
 		return tdb_delete(tdb, key);
 	}
 	return 0;
@@ -756,7 +747,9 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		return -1;
 	}
 
-	msg.dn = key.dptr+3;
+	if (!msg.dn) {
+		msg.dn = key.dptr+3;
+	}
 
 	ret = ltdb_index_add(ldb, &msg);
 
@@ -773,6 +766,12 @@ int ltdb_reindex(struct ldb_context *ldb)
 	struct ltdb_private *ltdb = ldb->private_data;
 	int ret;
 
+	ltdb_cache_free(ldb);
+
+	if (ltdb_cache_load(ldb) != 0) {
+		return -1;
+	}
+
 	/* first traverse the database deleting any @INDEX records */
 	ret = tdb_traverse(ltdb->tdb, delete_index, NULL);
 	if (ret == -1) {
-- 
cgit 


From 3c117a484316f963114cbeb1ba83872cfa95d854 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 1 May 2004 10:39:32 +0000
Subject: r436: fixed indexing of objectclass with subclasses (This used to be
 commit 4d92e6f79f52ec0d580dfda2a91b4afc95838ff4)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 65 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index c4243e9b40..6c21ae2986 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -96,6 +96,7 @@ static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
 	return -1;
 }
 
+
 /*
   return a list of dn's that might match a simple indexed search or
  */
@@ -168,6 +169,68 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 	return 1;
 }
 
+/*
+  return a list of dn's that might match a simple indexed search on
+  the special objectclass attribute
+ */
+static int ltdb_index_dn_objectclass(struct ldb_context *ldb, 
+				     struct ldb_parse_tree *tree,
+				     const struct ldb_message *index_list,
+				     struct dn_list *list)
+{
+	struct ltdb_private *ltdb = ldb->private_data;
+	int i;
+	int ret;
+	const char *target = tree->u.simple.value.data;
+	static int list_union(struct dn_list *, const struct dn_list *);
+
+	list->count = 0;
+	list->dn = NULL;
+
+	ret = ltdb_index_dn_simple(ldb, tree, index_list, list);
+
+	for (i=0;i<ltdb->cache.subclasses.num_elements;i++) {
+		struct ldb_message_element *el = &ltdb->cache.subclasses.elements[i];
+		if (ldb_attr_cmp(el->name, target) == 0) {
+			int j;
+			for (j=0;j<el->num_values;j++) {
+				struct ldb_parse_tree tree2;
+				struct dn_list list2;
+				tree2.operation = LDB_OP_SIMPLE;
+				tree2.u.simple.attr = LTDB_OBJECTCLASS;
+				tree2.u.simple.value = el->values[j];
+				if (ltdb_index_dn_objectclass(ldb, &tree2, 
+							      index_list, &list2) == 1) {
+					if (list->count == 0) {
+						*list = list2;
+						ret = 1;
+					} else {
+						list_union(list, &list2);
+						dn_list_free(&list2);
+					}
+				}
+			}
+		}
+	}
+
+	return ret;
+}
+
+/*
+  return a list of dn's that might match a leaf indexed search
+ */
+static int ltdb_index_dn_leaf(struct ldb_context *ldb, 
+			      struct ldb_parse_tree *tree,
+			      const struct ldb_message *index_list,
+			      struct dn_list *list)
+{
+	if (ldb_attr_cmp(tree->u.simple.attr, LTDB_OBJECTCLASS) == 0) {
+		return ltdb_index_dn_objectclass(ldb, tree, index_list, list);
+	}
+	return ltdb_index_dn_simple(ldb, tree, index_list, list);
+}
+
+
 /*
   list intersection
   list = list & list2
@@ -393,7 +456,7 @@ static int ltdb_index_dn(struct ldb_context *ldb,
 
 	switch (tree->operation) {
 	case LDB_OP_SIMPLE:
-		ret = ltdb_index_dn_simple(ldb, tree, index_list, list);
+		ret = ltdb_index_dn_leaf(ldb, tree, index_list, list);
 		break;
 
 	case LDB_OP_AND:
-- 
cgit 


From 29bc1f5c605b53635eea805cdd3ca6b2873bc792 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 1 May 2004 14:04:33 +0000
Subject: r437: fixed handling of a corner case with multi-valued indexing
 (This used to be commit b38612185657512419c4b3dc806cf1183e0db0cb)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 6c21ae2986..76e17cdfd5 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -590,6 +590,14 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 			       char *dn)
 {
 	struct ldb_val *v2;
+	int i;
+
+	/* for multi-valued attributes we can end up with repeats */
+	for (i=0;i<msg->elements[idx].num_values;i++) {
+		if (strcmp(dn, msg->elements[idx].values[i].data) == 0) {
+			return 0;
+		}
+	}
 
 	v2 = realloc_p(msg->elements[idx].values,
 		       struct ldb_val, 
-- 
cgit 


From 585d87a9590ecf64681700d70c37e5276ee8514a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 2 May 2004 05:16:15 +0000
Subject: r442: fixed some uninitialised variables pointed out by gcc -O3 (This
 used to be commit ff31cfb941b77e99e648011a6b7639b2a5923a6a)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 76e17cdfd5..987ee017b6 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -452,7 +452,7 @@ static int ltdb_index_dn(struct ldb_context *ldb,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list)
 {
-	int ret;
+	int ret = -1;
 
 	switch (tree->operation) {
 	case LDB_OP_SIMPLE:
-- 
cgit 


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

 - fixed sorting bug in ldb index handing
(This used to be commit cdd48e2b9b3ca6be5503eec401e09db162408ac8)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 987ee017b6..d250bc10be 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -96,6 +96,11 @@ static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
 	return -1;
 }
 
+/* used in sorting dn lists */
+static int list_cmp(const char **s1, const char **s2)
+{
+	return strcmp(*s1, *s2);
+}
 
 /*
   return a list of dn's that might match a simple indexed search or
@@ -164,7 +169,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 
 	ltdb_search_dn1_free(ldb, &msg);
 
-	qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) strcmp);
+	qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
 
 	return 1;
 }
@@ -309,7 +314,7 @@ static int list_union(struct dn_list *list, const struct dn_list *list2)
 	}
 
 	if (list->count != count) {
-		qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t)strcmp);
+		qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t)list_cmp);
 	}
 
 	return 0;
@@ -483,7 +488,7 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
 			    const char *base,
 			    enum ldb_scope scope,
 			    const struct dn_list *dn_list, 
-			    char * const attrs[], struct ldb_message ***res)
+			    const char * const attrs[], struct ldb_message ***res)
 {
 	int i;
 	unsigned int count = 0;
@@ -523,7 +528,7 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 			const char *base,
 			enum ldb_scope scope,
 			struct ldb_parse_tree *tree,
-			char * const attrs[], struct ldb_message ***res)
+			const char * const attrs[], struct ldb_message ***res)
 {
 	struct ltdb_private *ltdb = ldb->private_data;
 	struct dn_list dn_list;
-- 
cgit 


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

- made yet another attempt to make ldb const clean.

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

- added prototypes in ldb.h for ldb_msg_*() public functions
(This used to be commit 01e87406768cb5a98ac8530a2f361a4987a36cd3)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index d250bc10be..0b9581e52f 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -202,7 +202,10 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 				struct ldb_parse_tree tree2;
 				struct dn_list list2;
 				tree2.operation = LDB_OP_SIMPLE;
-				tree2.u.simple.attr = LTDB_OBJECTCLASS;
+				tree2.u.simple.attr = strdup(LTDB_OBJECTCLASS);
+				if (!tree2.u.simple.attr) {
+					return -1;
+				}
 				tree2.u.simple.value = el->values[j];
 				if (ltdb_index_dn_objectclass(ldb, &tree2, 
 							      index_list, &list2) == 1) {
@@ -214,6 +217,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 						dn_list_free(&list2);
 					}
 				}
+				free(tree2.u.simple.attr);
 			}
 		}
 	}
@@ -488,7 +492,7 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
 			    const char *base,
 			    enum ldb_scope scope,
 			    const struct dn_list *dn_list, 
-			    const char * const attrs[], struct ldb_message ***res)
+			    char * const attrs[], struct ldb_message ***res)
 {
 	int i;
 	unsigned int count = 0;
@@ -528,7 +532,7 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 			const char *base,
 			enum ldb_scope scope,
 			struct ldb_parse_tree *tree,
-			const char * const attrs[], struct ldb_message ***res)
+			char * const attrs[], struct ldb_message ***res)
 {
 	struct ltdb_private *ltdb = ldb->private_data;
 	struct dn_list dn_list;
@@ -569,7 +573,10 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 	}
 
 	msg->elements = el2;
-	msg->elements[msg->num_elements].name = LTDB_IDX;
+	msg->elements[msg->num_elements].name = strdup(LTDB_IDX);
+	if (!msg->elements[msg->num_elements].name) {
+		return -1;
+	}
 	msg->elements[msg->num_elements].num_values = 0;
 	msg->elements[msg->num_elements].values = malloc_p(struct ldb_val);
 	if (!msg->elements[msg->num_elements].values) {
@@ -627,7 +634,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 {
 	struct ldb_message msg;
 	char *dn_key;
-	int ret, i;
+	int ret, i, added=0;
 
 	dn_key = ldb_dn_key(el->name, &el->values[v_idx]);
 	if (!dn_key) {
@@ -661,6 +668,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 	}
 
 	if (i == msg.num_elements) {
+		added = 1;
 		ret = ltdb_index_add1_new(ldb, &msg, el, dn);
 	} else {
 		ret = ltdb_index_add1_add(ldb, &msg, el, i, dn);
@@ -670,6 +678,10 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 		ret = ltdb_store(ldb, &msg, TDB_REPLACE);
 	}
 
+	if (added) {
+		free(msg.elements[i].name);
+	}
+
 	ltdb_search_dn1_free(ldb, &msg);
 
 	return ret;
-- 
cgit 


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

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 121 ++++++++++++++++++++----------------
 1 file changed, 66 insertions(+), 55 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 0b9581e52f..07077281ce 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -43,32 +43,33 @@ struct dn_list {
 /*
   free a struct dn_list
 */
-static void dn_list_free(struct dn_list *list)
+static void dn_list_free(struct ldb_context *ldb, struct dn_list *list)
 {
 	int i;
 	for (i=0;i<list->count;i++) {
-		free(list->dn[i]);
+		ldb_free(ldb, list->dn[i]);
 	}
-	if (list->dn) free(list->dn);
+	ldb_free(ldb, list->dn);
 }
 
 /*
   return the dn key to be used for an index
   caller frees
 */
-static char *ldb_dn_key(const char *attr, const struct ldb_val *value)
+static char *ldb_dn_key(struct ldb_context *ldb,
+			const char *attr, const struct ldb_val *value)
 {
 	char *ret = NULL;
 
 	if (ldb_should_b64_encode(value)) {
-		char *vstr = ldb_base64_encode(value->data, value->length);
+		char *vstr = ldb_base64_encode(ldb, value->data, value->length);
 		if (!vstr) return NULL;
-		asprintf(&ret, "%s:%s::%s", LTDB_INDEX, attr, vstr);
-		free(vstr);
+		ldb_asprintf(ldb, &ret, "%s:%s::%s", LTDB_INDEX, attr, vstr);
+		ldb_free(ldb, vstr);
 		return ret;
 	}
 
-	asprintf(&ret, "%s:%s:%s", LTDB_INDEX, attr, (char *)value->data);
+	ldb_asprintf(ldb, &ret, "%s:%s:%s", LTDB_INDEX, attr, (char *)value->data);
 	return ret;
 }
 
@@ -132,11 +133,11 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 
 	/* the attribute is indexed. Pull the list of DNs that match the 
 	   search criterion */
-	dn = ldb_dn_key(tree->u.simple.attr, &tree->u.simple.value);
+	dn = ldb_dn_key(ldb, tree->u.simple.attr, &tree->u.simple.value);
 	if (!dn) return -1;
 
 	ret = ltdb_search_dn1(ldb, dn, &msg);
-	free(dn);
+	ldb_free(ldb, dn);
 	if (ret == 0 || ret == -1) {
 		return ret;
 	}
@@ -150,16 +151,16 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 
 		el = &msg.elements[i];
 
-		list->dn = malloc_array_p(char *, el->num_values);
+		list->dn = ldb_malloc_array_p(ldb, char *, el->num_values);
 		if (!list->dn) {
 			break;		
 		}
 
 		for (j=0;j<el->num_values;j++) {
 			list->dn[list->count] = 
-				strdup((char *)el->values[j].data);
+				ldb_strdup(ldb, (char *)el->values[j].data);
 			if (!list->dn[list->count]) {
-				dn_list_free(list);
+				dn_list_free(ldb, list);
 				ltdb_search_dn1_free(ldb, &msg);
 				return -1;
 			}
@@ -202,7 +203,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 				struct ldb_parse_tree tree2;
 				struct dn_list list2;
 				tree2.operation = LDB_OP_SIMPLE;
-				tree2.u.simple.attr = strdup(LTDB_OBJECTCLASS);
+				tree2.u.simple.attr = ldb_strdup(ldb, LTDB_OBJECTCLASS);
 				if (!tree2.u.simple.attr) {
 					return -1;
 				}
@@ -214,10 +215,10 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 						ret = 1;
 					} else {
 						list_union(list, &list2);
-						dn_list_free(&list2);
+						dn_list_free(ldb, &list2);
 					}
 				}
-				free(tree2.u.simple.attr);
+				ldb_free(ldb, tree2.u.simple.attr);
 			}
 		}
 	}
@@ -245,20 +246,21 @@ static int ltdb_index_dn_leaf(struct ldb_context *ldb,
   list = list & list2
   relies on the lists being sorted
 */
-static int list_intersect(struct dn_list *list, const struct dn_list *list2)
+static int list_intersect(struct ldb_context *ldb,
+			  struct dn_list *list, const struct dn_list *list2)
 {
 	struct dn_list list3;
 	int i;
 
 	if (list->count == 0 || list2->count == 0) {
 		/* 0 & X == 0 */
-		dn_list_free(list);
+		dn_list_free(ldb, list);
 		return 0;
 	}
 
-	list3.dn = malloc_array_p(char *, list->count);
+	list3.dn = ldb_malloc_array_p(ldb, char *, list->count);
 	if (!list3.dn) {
-		dn_list_free(list);
+		dn_list_free(ldb, list);
 		return -1;
 	}
 	list3.count = 0;
@@ -269,11 +271,11 @@ static int list_intersect(struct dn_list *list, const struct dn_list *list2)
 			list3.dn[list3.count] = list->dn[i];
 			list3.count++;
 		} else {
-			free(list->dn[i]);
+			ldb_free(ldb, list->dn[i]);
 		}		
 	}
 
-	free(list->dn);
+	ldb_free(ldb, list->dn);
 	list->dn = list3.dn;
 	list->count = list3.count;
 
@@ -286,7 +288,8 @@ static int list_intersect(struct dn_list *list, const struct dn_list *list2)
   list = list | list2
   relies on the lists being sorted
 */
-static int list_union(struct dn_list *list, const struct dn_list *list2)
+static int list_union(struct ldb_context *ldb, 
+		      struct dn_list *list, const struct dn_list *list2)
 {
 	int i;
 	char **d;
@@ -294,13 +297,13 @@ static int list_union(struct dn_list *list, const struct dn_list *list2)
 
 	if (list->count == 0 && list2->count == 0) {
 		/* 0 | 0 == 0 */
-		dn_list_free(list);
+		dn_list_free(ldb, list);
 		return 0;
 	}
 
-	d = realloc_p(list->dn, char *, list->count + list2->count);
+	d = ldb_realloc_p(ldb, list->dn, char *, list->count + list2->count);
 	if (!d) {
-		dn_list_free(list);
+		dn_list_free(ldb, list);
 		return -1;
 	}
 	list->dn = d;
@@ -308,9 +311,9 @@ static int list_union(struct dn_list *list, const struct dn_list *list2)
 	for (i=0;i<list2->count;i++) {
 		if (list_find(list2->dn[i], list->dn, count, 
 			      sizeof(char *), (comparison_fn_t)strcmp) == -1) {
-			list->dn[list->count] = strdup(list2->dn[i]);
+			list->dn[list->count] = ldb_strdup(ldb, list2->dn[i]);
 			if (!list->dn[list->count]) {
-				dn_list_free(list);
+				dn_list_free(ldb, list);
 				return -1;
 			}
 			list->count++;
@@ -359,7 +362,7 @@ static int ltdb_index_dn_or(struct ldb_context *ldb,
 
 		if (v == -1) {
 			/* 1 || X == 1 */
-			dn_list_free(list);
+			dn_list_free(ldb, list);
 			return -1;
 		}
 
@@ -367,16 +370,16 @@ static int ltdb_index_dn_or(struct ldb_context *ldb,
 			ret = 1;
 			*list = list2;
 		} else {
-			if (list_union(list, &list2) == -1) {
-				dn_list_free(&list2);
+			if (list_union(ldb, list, &list2) == -1) {
+				dn_list_free(ldb, &list2);
 				return -1;
 			}
-			dn_list_free(&list2);
+			dn_list_free(ldb, &list2);
 		}
 	}
 
 	if (list->count == 0) {
-		dn_list_free(list);
+		dn_list_free(ldb, list);
 		return 0;
 	}
 
@@ -424,7 +427,7 @@ static int ltdb_index_dn_and(struct ldb_context *ldb,
 
 		if (v == 0) {
 			/* 0 && X == 0 */
-			dn_list_free(list);
+			dn_list_free(ldb, list);
 			return 0;
 		}
 
@@ -436,15 +439,15 @@ static int ltdb_index_dn_and(struct ldb_context *ldb,
 			ret = 1;
 			*list = list2;
 		} else {
-			if (list_intersect(list, &list2) == -1) {
-				dn_list_free(&list2);
+			if (list_intersect(ldb, list, &list2) == -1) {
+				dn_list_free(ldb, &list2);
 				return -1;
 			}
-			dn_list_free(&list2);
+			dn_list_free(ldb, &list2);
 		}
 
 		if (list->count == 0) {
-			if (list->dn) free(list->dn);
+			if (list->dn) ldb_free(ldb, list->dn);
 			return 0;
 		}
 	}
@@ -550,7 +553,7 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 		   and extract the needed attributes */
 		ret = ldb_index_filter(ldb, tree, base, scope, &dn_list, 
 				       attrs, res);
-		dn_list_free(&dn_list);
+		dn_list_free(ldb, &dn_list);
 	}
 
 	return ret;
@@ -567,18 +570,19 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 	struct ldb_message_element *el2;
 
 	/* add another entry */
-	el2 = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1);
+	el2 = ldb_realloc_p(ldb, msg->elements, 
+			    struct ldb_message_element, msg->num_elements+1);
 	if (!el2) {
 		return -1;
 	}
 
 	msg->elements = el2;
-	msg->elements[msg->num_elements].name = strdup(LTDB_IDX);
+	msg->elements[msg->num_elements].name = ldb_strdup(ldb, LTDB_IDX);
 	if (!msg->elements[msg->num_elements].name) {
 		return -1;
 	}
 	msg->elements[msg->num_elements].num_values = 0;
-	msg->elements[msg->num_elements].values = malloc_p(struct ldb_val);
+	msg->elements[msg->num_elements].values = ldb_malloc_p(ldb, struct ldb_val);
 	if (!msg->elements[msg->num_elements].values) {
 		return -1;
 	}
@@ -611,9 +615,9 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 		}
 	}
 
-	v2 = realloc_p(msg->elements[idx].values,
-		       struct ldb_val, 
-		       msg->elements[idx].num_values+1);
+	v2 = ldb_realloc_p(ldb, msg->elements[idx].values,
+			   struct ldb_val, 
+			   msg->elements[idx].num_values+1);
 	if (!v2) {
 		return -1;
 	}
@@ -634,23 +638,24 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 {
 	struct ldb_message msg;
 	char *dn_key;
-	int ret, i, added=0;
+	int ret, i, added=0, added_dn=0;
 
-	dn_key = ldb_dn_key(el->name, &el->values[v_idx]);
+	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		return -1;
 	}
 
 	ret = ltdb_search_dn1(ldb, dn_key, &msg);
 	if (ret == -1) {
-		free(dn_key);
+		ldb_free(ldb, dn_key);
 		return -1;
 	}
 
 	if (ret == 0) {
-		msg.dn = strdup(dn_key);
+		added_dn = 1;
+		msg.dn = ldb_strdup(ldb, dn_key);
 		if (!msg.dn) {
-			free(dn_key);
+			ldb_free(ldb, dn_key);
 			errno = ENOMEM;
 			return -1;
 		}
@@ -659,7 +664,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 		msg.private_data = NULL;
 	}
 
-	free(dn_key);
+	ldb_free(ldb, dn_key);
 
 	for (i=0;i<msg.num_elements;i++) {
 		if (strcmp(LTDB_IDX, msg.elements[i].name) == 0) {
@@ -679,7 +684,10 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 	}
 
 	if (added) {
-		free(msg.elements[i].name);
+		ldb_free(ldb, msg.elements[i].name);
+	}
+	if (added_dn) {
+		ldb_free(ldb, msg.dn);
 	}
 
 	ltdb_search_dn1_free(ldb, &msg);
@@ -728,14 +736,14 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 	char *dn_key;
 	int ret, i, j;
 
-	dn_key = ldb_dn_key(el->name, &el->values[v_idx]);
+	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		return -1;
 	}
 
 	ret = ltdb_search_dn1(ldb, dn_key, &msg);
 	if (ret == -1) {
-		free(dn_key);
+		ldb_free(ldb, dn_key);
 		return -1;
 	}
 
@@ -743,6 +751,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 		/* it wasn't indexed. Did we have an earlier error? If we did then
 		   its gone now */
 		ltdb_search_dn1_free(ldb, &msg);
+		ldb_free(ldb, dn_key);
 		return 0;
 	}
 
@@ -750,6 +759,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 	if (i == -1) {
 		/* it ain't there. hmmm */
 		ltdb_search_dn1_free(ldb, &msg);
+		ldb_free(ldb, dn_key);
 		return 0;
 	}
 
@@ -768,6 +778,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 	}
 
 	ltdb_search_dn1_free(ldb, &msg);
+	ldb_free(ldb, dn_key);
 
 	return ret;
 }
@@ -841,7 +852,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 
 	ret = ltdb_index_add(ldb, &msg);
 
-	ltdb_unpack_data_free(&msg);
+	ltdb_unpack_data_free(ldb, &msg);
 
 	return ret;
 }
-- 
cgit 


From 9261ceb89e3394da3d41197354a7da723678187e Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 May 2004 04:45:29 +0000
Subject: r504: fixed a bad call to list_union() (This used to be commit
 4404056cd5fd65d72a38ea474fe330281b3ee19e)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 07077281ce..877955a9b7 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -188,7 +188,8 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 	int i;
 	int ret;
 	const char *target = tree->u.simple.value.data;
-	static int list_union(struct dn_list *, const struct dn_list *);
+	static int list_union(struct ldb_context *, 
+			      struct dn_list *, const struct dn_list *);
 
 	list->count = 0;
 	list->dn = NULL;
@@ -214,7 +215,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 						*list = list2;
 						ret = 1;
 					} else {
-						list_union(list, &list2);
+						list_union(ldb, list, &list2);
 						dn_list_free(ldb, &list2);
 					}
 				}
-- 
cgit 


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

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

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

 - added some more ldb_msg_*() utilities
(This used to be commit 62b4ec367d170330d837b0f1fe5cd13205a53b59)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 877955a9b7..0e9f3e3c55 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -496,7 +496,7 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
 			    const char *base,
 			    enum ldb_scope scope,
 			    const struct dn_list *dn_list, 
-			    char * const attrs[], struct ldb_message ***res)
+			    const char * const attrs[], struct ldb_message ***res)
 {
 	int i;
 	unsigned int count = 0;
@@ -536,7 +536,7 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 			const char *base,
 			enum ldb_scope scope,
 			struct ldb_parse_tree *tree,
-			char * const attrs[], struct ldb_message ***res)
+			const char * const attrs[], struct ldb_message ***res)
 {
 	struct ltdb_private *ltdb = ldb->private_data;
 	struct dn_list dn_list;
-- 
cgit 


From d2c7b5cd338d41f9b47113ec21b36a12fe10c3fc Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 8 May 2004 03:44:47 +0000
Subject: r583: fixed two bugs in the handling of index entry deletion (This
 used to be commit 7b5f3370e6c078bf506ac3eb24fb330d4aee7688)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 0e9f3e3c55..3febdaa711 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -77,11 +77,11 @@ static char *ldb_dn_key(struct ldb_context *ldb,
   see if a attribute value is in the list of indexed attributes
 */
 static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
-			    int *v_idx)
+			    int *v_idx, const char *key)
 {
 	int i, j;
 	for (i=0;i<msg->num_elements;i++) {
-		if (ldb_attr_cmp(msg->elements[i].name, LTDB_IDXATTR) == 0) {
+		if (ldb_attr_cmp(msg->elements[i].name, key) == 0) {
 			const struct ldb_message_element *el = 
 				&msg->elements[i];
 			for (j=0;j<el->num_values;j++) {
@@ -127,7 +127,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 
 	/* if the attribute isn't in the list of indexed attributes then
 	   this node needs a full search */
-	if (ldb_msg_find_idx(index_list, tree->u.simple.attr, NULL) == -1) {
+	if (ldb_msg_find_idx(index_list, tree->u.simple.attr, NULL, LTDB_IDXATTR) == -1) {
 		return -1;
 	}
 
@@ -711,7 +711,8 @@ int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, NULL);
+		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, 
+				       NULL, LTDB_IDXATTR);
 		if (ret == -1) {
 			continue;
 		}
@@ -751,13 +752,14 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 	if (ret == 0) {
 		/* it wasn't indexed. Did we have an earlier error? If we did then
 		   its gone now */
-		ltdb_search_dn1_free(ldb, &msg);
+		ldb_debug(ldb, LDB_DEBUG_ERROR, "ERROR: dn_key %s was not indexed\n", dn_key);
 		ldb_free(ldb, dn_key);
 		return 0;
 	}
 
-	i = ldb_msg_find_idx(&msg, dn, &j);
+	i = ldb_msg_find_idx(&msg, dn, &j, LTDB_IDX);
 	if (i == -1) {
+		ldb_debug(ldb, LDB_DEBUG_ERROR, "ERROR: dn %s not found in %s\n", dn, dn_key);
 		/* it ain't there. hmmm */
 		ltdb_search_dn1_free(ldb, &msg);
 		ldb_free(ldb, dn_key);
@@ -767,7 +769,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 	if (j != msg.elements[i].num_values - 1) {
 		memmove(&msg.elements[i].values[j], 
 			&msg.elements[i].values[j+1], 
-			(msg.elements[i].num_values-1) * 
+			(msg.elements[i].num_values-(j+1)) * 
 			sizeof(msg.elements[i].values[0]));
 	}
 	msg.elements[i].num_values--;
@@ -800,7 +802,8 @@ int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, NULL);
+		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, 
+				       NULL, LTDB_IDXATTR);
 		if (ret == -1) {
 			continue;
 		}
-- 
cgit 


From f0a8f718ff474009300af6746fa0fbb61c649ea9 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 20 May 2004 13:25:06 +0000
Subject: r792:  - changed the ldb ldif_* functions to be in the ldb_ namespace

 - added better error reporting in ldbdel

 - fixed a bug in handling packing of records which contain elements
   with no values (it caused db corruption)

 - allow search with "dn" as target attribute
(This used to be commit 36575396234e3d35dbd442c8f1ff54a17ae64e64)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 3febdaa711..b4ca666287 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -34,6 +34,7 @@
 
 #include "includes.h"
 #include "ldb/ldb_tdb/ldb_tdb.h"
+#include "ldb/include/ldb_parse.h"
 
 struct dn_list {
 	unsigned int count;
-- 
cgit 


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

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 38 +++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 16 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index b4ca666287..8a26e2d197 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -46,7 +46,7 @@ struct dn_list {
 */
 static void dn_list_free(struct ldb_context *ldb, struct dn_list *list)
 {
-	int i;
+	unsigned int i;
 	for (i=0;i<list->count;i++) {
 		ldb_free(ldb, list->dn[i]);
 	}
@@ -80,7 +80,7 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
 			    int *v_idx, const char *key)
 {
-	int i, j;
+	unsigned int i, j;
 	for (i=0;i<msg->num_elements;i++) {
 		if (ldb_attr_cmp(msg->elements[i].name, key) == 0) {
 			const struct ldb_message_element *el = 
@@ -113,7 +113,8 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 				struct dn_list *list)
 {
 	char *dn = NULL;
-	int ret, i, j;
+	int ret;
+	unsigned int i, j;
 	struct ldb_message msg;
 
 	list->count = 0;
@@ -186,7 +187,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 				     struct dn_list *list)
 {
 	struct ltdb_private *ltdb = ldb->private_data;
-	int i;
+	unsigned int i;
 	int ret;
 	const char *target = tree->u.simple.value.data;
 	static int list_union(struct ldb_context *, 
@@ -200,7 +201,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 	for (i=0;i<ltdb->cache.subclasses.num_elements;i++) {
 		struct ldb_message_element *el = &ltdb->cache.subclasses.elements[i];
 		if (ldb_attr_cmp(el->name, target) == 0) {
-			int j;
+			unsigned int j;
 			for (j=0;j<el->num_values;j++) {
 				struct ldb_parse_tree tree2;
 				struct dn_list list2;
@@ -252,7 +253,7 @@ static int list_intersect(struct ldb_context *ldb,
 			  struct dn_list *list, const struct dn_list *list2)
 {
 	struct dn_list list3;
-	int i;
+	unsigned int i;
 
 	if (list->count == 0 || list2->count == 0) {
 		/* 0 & X == 0 */
@@ -293,7 +294,7 @@ static int list_intersect(struct ldb_context *ldb,
 static int list_union(struct ldb_context *ldb, 
 		      struct dn_list *list, const struct dn_list *list2)
 {
-	int i;
+	unsigned int i;
 	char **d;
 	unsigned int count = list->count;
 
@@ -343,7 +344,8 @@ static int ltdb_index_dn_or(struct ldb_context *ldb,
 			    const struct ldb_message *index_list,
 			    struct dn_list *list)
 {
-	int ret, i;
+	unsigned int i;
+	int ret;
 	
 	ret = -1;
 	list->dn = NULL;
@@ -416,7 +418,8 @@ static int ltdb_index_dn_and(struct ldb_context *ldb,
 			     const struct ldb_message *index_list,
 			     struct dn_list *list)
 {
-	int ret, i;
+	unsigned int i;
+	int ret;
 	
 	ret = -1;
 	list->dn = NULL;
@@ -499,8 +502,7 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
 			    const struct dn_list *dn_list, 
 			    const char * const attrs[], struct ldb_message ***res)
 {
-	int i;
-	unsigned int count = 0;
+	unsigned int count = 0, i;
 
 	for (i=0;i<dn_list->count;i++) {
 		struct ldb_message msg;
@@ -608,7 +610,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 			       char *dn)
 {
 	struct ldb_val *v2;
-	int i;
+	unsigned int i;
 
 	/* for multi-valued attributes we can end up with repeats */
 	for (i=0;i<msg->elements[idx].num_values;i++) {
@@ -640,7 +642,8 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 {
 	struct ldb_message msg;
 	char *dn_key;
-	int ret, i, added=0, added_dn=0;
+	int ret, added=0, added_dn=0;
+	unsigned int i;
 
 	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
@@ -704,7 +707,8 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
 {
 	struct ltdb_private *ltdb = ldb->private_data;
-	int ret, i, j;
+	int ret;
+	unsigned int i, j;
 
 	if (ltdb->cache.indexlist.num_elements == 0) {
 		/* no indexed fields */
@@ -737,7 +741,8 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 {
 	struct ldb_message msg;
 	char *dn_key;
-	int ret, i, j;
+	int ret, i;
+	unsigned int j;
 
 	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
@@ -794,7 +799,8 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 {
 	struct ltdb_private *ltdb = ldb->private_data;
-	int ret, i, j;
+	int ret;
+	unsigned int i, j;
 
 	/* find the list of indexed fields */	
 	if (ltdb->cache.indexlist.num_elements == 0) {
-- 
cgit 


From 8d811df12b7e535e6e44bac088a4724a8478c4b1 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 26 Sep 2004 22:19:48 +0000
Subject: r2667: Remove forward declaration of static function from function.
 GCC 3.5 and 4.0 don't accept declarations of static functions inside other
 functions, see http://gcc.gnu.org/ml/gcc-patches/2004-08/msg02514.html (This
 used to be commit 8768168aadf51b9559831954e349d9aa94101c41)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 8a26e2d197..e23ae1e7dd 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -177,6 +177,9 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 	return 1;
 }
 
+
+static int list_union(struct ldb_context *, struct dn_list *, const struct dn_list *);
+
 /*
   return a list of dn's that might match a simple indexed search on
   the special objectclass attribute
@@ -190,8 +193,6 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 	unsigned int i;
 	int ret;
 	const char *target = tree->u.simple.value.data;
-	static int list_union(struct ldb_context *, 
-			      struct dn_list *, const struct dn_list *);
 
 	list->count = 0;
 	list->dn = NULL;
-- 
cgit 


From 14a0e37582c9aea69d92cf2ad449dda0bdf3bce0 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 28 Sep 2004 09:34:49 +0000
Subject: r2713: better handling of binary values in index key creation (This
 used to be commit b0c92616fb69d8139f66dc8144cfcc88ea6825dc)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index e23ae1e7dd..cfd097e361 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -70,7 +70,7 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 		return ret;
 	}
 
-	ldb_asprintf(ldb, &ret, "%s:%s:%s", LTDB_INDEX, attr, (char *)value->data);
+	ldb_asprintf(ldb, &ret, "%s:%s:%.*s", LTDB_INDEX, attr, value->length, (char *)value->data);
 	return ret;
 }
 
-- 
cgit 


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

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 121 +++++++++++++++++++-----------------
 1 file changed, 64 insertions(+), 57 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index cfd097e361..d54208777d 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -107,11 +107,12 @@ static int list_cmp(const char **s1, const char **s2)
 /*
   return a list of dn's that might match a simple indexed search or
  */
-static int ltdb_index_dn_simple(struct ldb_context *ldb, 
+static int ltdb_index_dn_simple(struct ldb_module *module, 
 				struct ldb_parse_tree *tree,
 				const struct ldb_message *index_list,
 				struct dn_list *list)
 {
+	struct ldb_context *ldb = module->ldb;
 	char *dn = NULL;
 	int ret;
 	unsigned int i, j;
@@ -123,7 +124,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 	/*
 	  if the value is a wildcard then we can't do a match via indexing
 	*/
-	if (ltdb_has_wildcard(ldb, tree->u.simple.attr, &tree->u.simple.value)) {
+	if (ltdb_has_wildcard(module, tree->u.simple.attr, &tree->u.simple.value)) {
 		return -1;
 	}
 
@@ -138,7 +139,7 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 	dn = ldb_dn_key(ldb, tree->u.simple.attr, &tree->u.simple.value);
 	if (!dn) return -1;
 
-	ret = ltdb_search_dn1(ldb, dn, &msg);
+	ret = ltdb_search_dn1(module, dn, &msg);
 	ldb_free(ldb, dn);
 	if (ret == 0 || ret == -1) {
 		return ret;
@@ -163,14 +164,14 @@ static int ltdb_index_dn_simple(struct ldb_context *ldb,
 				ldb_strdup(ldb, (char *)el->values[j].data);
 			if (!list->dn[list->count]) {
 				dn_list_free(ldb, list);
-				ltdb_search_dn1_free(ldb, &msg);
+				ltdb_search_dn1_free(module, &msg);
 				return -1;
 			}
 			list->count++;
 		}
 	}
 
-	ltdb_search_dn1_free(ldb, &msg);
+	ltdb_search_dn1_free(module, &msg);
 
 	qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
 
@@ -184,12 +185,13 @@ static int list_union(struct ldb_context *, struct dn_list *, const struct dn_li
   return a list of dn's that might match a simple indexed search on
   the special objectclass attribute
  */
-static int ltdb_index_dn_objectclass(struct ldb_context *ldb, 
+static int ltdb_index_dn_objectclass(struct ldb_module *module, 
 				     struct ldb_parse_tree *tree,
 				     const struct ldb_message *index_list,
 				     struct dn_list *list)
 {
-	struct ltdb_private *ltdb = ldb->private_data;
+	struct ldb_context *ldb = module->ldb;
+	struct ltdb_private *ltdb = module->private_data;
 	unsigned int i;
 	int ret;
 	const char *target = tree->u.simple.value.data;
@@ -197,7 +199,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 	list->count = 0;
 	list->dn = NULL;
 
-	ret = ltdb_index_dn_simple(ldb, tree, index_list, list);
+	ret = ltdb_index_dn_simple(module, tree, index_list, list);
 
 	for (i=0;i<ltdb->cache.subclasses.num_elements;i++) {
 		struct ldb_message_element *el = &ltdb->cache.subclasses.elements[i];
@@ -212,7 +214,7 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 					return -1;
 				}
 				tree2.u.simple.value = el->values[j];
-				if (ltdb_index_dn_objectclass(ldb, &tree2, 
+				if (ltdb_index_dn_objectclass(module, &tree2, 
 							      index_list, &list2) == 1) {
 					if (list->count == 0) {
 						*list = list2;
@@ -233,15 +235,15 @@ static int ltdb_index_dn_objectclass(struct ldb_context *ldb,
 /*
   return a list of dn's that might match a leaf indexed search
  */
-static int ltdb_index_dn_leaf(struct ldb_context *ldb, 
+static int ltdb_index_dn_leaf(struct ldb_module *module, 
 			      struct ldb_parse_tree *tree,
 			      const struct ldb_message *index_list,
 			      struct dn_list *list)
 {
 	if (ldb_attr_cmp(tree->u.simple.attr, LTDB_OBJECTCLASS) == 0) {
-		return ltdb_index_dn_objectclass(ldb, tree, index_list, list);
+		return ltdb_index_dn_objectclass(module, tree, index_list, list);
 	}
-	return ltdb_index_dn_simple(ldb, tree, index_list, list);
+	return ltdb_index_dn_simple(module, tree, index_list, list);
 }
 
 
@@ -331,7 +333,7 @@ static int list_union(struct ldb_context *ldb,
 	return 0;
 }
 
-static int ltdb_index_dn(struct ldb_context *ldb, 
+static int ltdb_index_dn(struct ldb_module *module, 
 			 struct ldb_parse_tree *tree,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list);
@@ -340,11 +342,12 @@ static int ltdb_index_dn(struct ldb_context *ldb,
 /*
   OR two index results
  */
-static int ltdb_index_dn_or(struct ldb_context *ldb, 
+static int ltdb_index_dn_or(struct ldb_module *module, 
 			    struct ldb_parse_tree *tree,
 			    const struct ldb_message *index_list,
 			    struct dn_list *list)
 {
+	struct ldb_context *ldb = module->ldb;
 	unsigned int i;
 	int ret;
 	
@@ -355,7 +358,7 @@ static int ltdb_index_dn_or(struct ldb_context *ldb,
 	for (i=0;i<tree->u.list.num_elements;i++) {
 		struct dn_list list2;
 		int v;
-		v = ltdb_index_dn(ldb, tree->u.list.elements[i], index_list, &list2);
+		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, &list2);
 
 		if (v == 0) {
 			/* 0 || X == X */
@@ -395,7 +398,7 @@ static int ltdb_index_dn_or(struct ldb_context *ldb,
 /*
   NOT an index results
  */
-static int ltdb_index_dn_not(struct ldb_context *ldb, 
+static int ltdb_index_dn_not(struct ldb_module *module, 
 			     struct ldb_parse_tree *tree,
 			     const struct ldb_message *index_list,
 			     struct dn_list *list)
@@ -414,11 +417,12 @@ static int ltdb_index_dn_not(struct ldb_context *ldb,
 /*
   AND two index results
  */
-static int ltdb_index_dn_and(struct ldb_context *ldb, 
+static int ltdb_index_dn_and(struct ldb_module *module, 
 			     struct ldb_parse_tree *tree,
 			     const struct ldb_message *index_list,
 			     struct dn_list *list)
 {
+	struct ldb_context *ldb = module->ldb;
 	unsigned int i;
 	int ret;
 	
@@ -429,7 +433,7 @@ static int ltdb_index_dn_and(struct ldb_context *ldb,
 	for (i=0;i<tree->u.list.num_elements;i++) {
 		struct dn_list list2;
 		int v;
-		v = ltdb_index_dn(ldb, tree->u.list.elements[i], index_list, &list2);
+		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, &list2);
 
 		if (v == 0) {
 			/* 0 && X == 0 */
@@ -465,7 +469,7 @@ static int ltdb_index_dn_and(struct ldb_context *ldb,
   return a list of dn's that might match a indexed search or
   -1 if an error. return 0 for no matches, or 1 for matches
  */
-static int ltdb_index_dn(struct ldb_context *ldb, 
+static int ltdb_index_dn(struct ldb_module *module, 
 			 struct ldb_parse_tree *tree,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list)
@@ -474,19 +478,19 @@ static int ltdb_index_dn(struct ldb_context *ldb,
 
 	switch (tree->operation) {
 	case LDB_OP_SIMPLE:
-		ret = ltdb_index_dn_leaf(ldb, tree, index_list, list);
+		ret = ltdb_index_dn_leaf(module, tree, index_list, list);
 		break;
 
 	case LDB_OP_AND:
-		ret = ltdb_index_dn_and(ldb, tree, index_list, list);
+		ret = ltdb_index_dn_and(module, tree, index_list, list);
 		break;
 
 	case LDB_OP_OR:
-		ret = ltdb_index_dn_or(ldb, tree, index_list, list);
+		ret = ltdb_index_dn_or(module, tree, index_list, list);
 		break;
 
 	case LDB_OP_NOT:
-		ret = ltdb_index_dn_not(ldb, tree, index_list, list);
+		ret = ltdb_index_dn_not(module, tree, index_list, list);
 		break;
 	}
 
@@ -497,7 +501,7 @@ static int ltdb_index_dn(struct ldb_context *ldb,
   filter a candidate dn_list from an indexed search into a set of results
   extracting just the given attributes
 */
-static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree,
+static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tree,
 			    const char *base,
 			    enum ldb_scope scope,
 			    const struct dn_list *dn_list, 
@@ -508,7 +512,7 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
 	for (i=0;i<dn_list->count;i++) {
 		struct ldb_message msg;
 		int ret;
-		ret = ltdb_search_dn1(ldb, dn_list->dn[i], &msg);
+		ret = ltdb_search_dn1(module, dn_list->dn[i], &msg);
 		if (ret == 0) {
 			/* the record has disappeared? yes, this can happen */
 			continue;
@@ -519,10 +523,10 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
 			return -1;
 		}
 
-		if (ldb_message_match(ldb, &msg, tree, base, scope) == 1) {
-			ret = ltdb_add_attr_results(ldb, &msg, attrs, &count, res);
+		if (ldb_message_match(module, &msg, tree, base, scope) == 1) {
+			ret = ltdb_add_attr_results(module, &msg, attrs, &count, res);
 		}
-		ltdb_search_dn1_free(ldb, &msg);
+		ltdb_search_dn1_free(module, &msg);
 		if (ret != 0) {
 			return -1;
 		}
@@ -536,13 +540,14 @@ static int ldb_index_filter(struct ldb_context *ldb, struct ldb_parse_tree *tree
   returns -1 if an indexed search is not possible, in which
   case the caller should call ltdb_search_full() 
 */
-int ltdb_search_indexed(struct ldb_context *ldb, 
+int ltdb_search_indexed(struct ldb_module *module, 
 			const char *base,
 			enum ldb_scope scope,
 			struct ldb_parse_tree *tree,
 			const char * const attrs[], struct ldb_message ***res)
 {
-	struct ltdb_private *ltdb = ldb->private_data;
+	struct ldb_context *ldb = module->ldb;
+	struct ltdb_private *ltdb = module->private_data;
 	struct dn_list dn_list;
 	int ret;
 
@@ -551,12 +556,12 @@ int ltdb_search_indexed(struct ldb_context *ldb,
 		return -1;
 	}
 
-	ret = ltdb_index_dn(ldb, tree, &ltdb->cache.indexlist, &dn_list);
+	ret = ltdb_index_dn(module, tree, &ltdb->cache.indexlist, &dn_list);
 
 	if (ret == 1) {
 		/* we've got a candidate list - now filter by the full tree
 		   and extract the needed attributes */
-		ret = ldb_index_filter(ldb, tree, base, scope, &dn_list, 
+		ret = ldb_index_filter(module, tree, base, scope, &dn_list, 
 				       attrs, res);
 		dn_list_free(ldb, &dn_list);
 	}
@@ -638,9 +643,10 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 /*
   add an index entry for one message element
 */
-static int ltdb_index_add1(struct ldb_context *ldb, char *dn, 
+static int ltdb_index_add1(struct ldb_module *module, char *dn, 
 			   struct ldb_message_element *el, int v_idx)
 {
+	struct ldb_context *ldb = module->ldb;
 	struct ldb_message msg;
 	char *dn_key;
 	int ret, added=0, added_dn=0;
@@ -651,7 +657,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 		return -1;
 	}
 
-	ret = ltdb_search_dn1(ldb, dn_key, &msg);
+	ret = ltdb_search_dn1(module, dn_key, &msg);
 	if (ret == -1) {
 		ldb_free(ldb, dn_key);
 		return -1;
@@ -686,7 +692,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 	}
 
 	if (ret == 0) {
-		ret = ltdb_store(ldb, &msg, TDB_REPLACE);
+		ret = ltdb_store(module, &msg, TDB_REPLACE);
 	}
 
 	if (added) {
@@ -696,7 +702,7 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
 		ldb_free(ldb, msg.dn);
 	}
 
-	ltdb_search_dn1_free(ldb, &msg);
+	ltdb_search_dn1_free(module, &msg);
 
 	return ret;
 }
@@ -705,9 +711,9 @@ static int ltdb_index_add1(struct ldb_context *ldb, char *dn,
   add the index entries for a new record
   return -1 on failure
 */
-int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
+int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 {
-	struct ltdb_private *ltdb = ldb->private_data;
+	struct ltdb_private *ltdb = module->private_data;
 	int ret;
 	unsigned int i, j;
 
@@ -723,7 +729,7 @@ int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
 			continue;
 		}
 		for (j=0;j<msg->elements[i].num_values;j++) {
-			ret = ltdb_index_add1(ldb, msg->dn, &msg->elements[i], j);
+			ret = ltdb_index_add1(module, msg->dn, &msg->elements[i], j);
 			if (ret == -1) {
 				return -1;
 			}
@@ -737,9 +743,10 @@ int ltdb_index_add(struct ldb_context *ldb, const struct ldb_message *msg)
 /*
   delete an index entry for one message element
 */
-static int ltdb_index_del1(struct ldb_context *ldb, const char *dn, 
+static int ltdb_index_del1(struct ldb_module *module, const char *dn, 
 			   struct ldb_message_element *el, int v_idx)
 {
+	struct ldb_context *ldb = module->ldb;
 	struct ldb_message msg;
 	char *dn_key;
 	int ret, i;
@@ -750,7 +757,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 		return -1;
 	}
 
-	ret = ltdb_search_dn1(ldb, dn_key, &msg);
+	ret = ltdb_search_dn1(module, dn_key, &msg);
 	if (ret == -1) {
 		ldb_free(ldb, dn_key);
 		return -1;
@@ -768,7 +775,7 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 	if (i == -1) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "ERROR: dn %s not found in %s\n", dn, dn_key);
 		/* it ain't there. hmmm */
-		ltdb_search_dn1_free(ldb, &msg);
+		ltdb_search_dn1_free(module, &msg);
 		ldb_free(ldb, dn_key);
 		return 0;
 	}
@@ -782,12 +789,12 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
 	msg.elements[i].num_values--;
 
 	if (msg.elements[i].num_values == 0) {
-		ret = ltdb_delete_noindex(ldb, dn_key);
+		ret = ltdb_delete_noindex(module, dn_key);
 	} else {
-		ret = ltdb_store(ldb, &msg, TDB_REPLACE);
+		ret = ltdb_store(module, &msg, TDB_REPLACE);
 	}
 
-	ltdb_search_dn1_free(ldb, &msg);
+	ltdb_search_dn1_free(module, &msg);
 	ldb_free(ldb, dn_key);
 
 	return ret;
@@ -797,9 +804,9 @@ static int ltdb_index_del1(struct ldb_context *ldb, const char *dn,
   delete the index entries for a record
   return -1 on failure
 */
-int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
+int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 {
-	struct ltdb_private *ltdb = ldb->private_data;
+	struct ltdb_private *ltdb = module->private_data;
 	int ret;
 	unsigned int i, j;
 
@@ -816,7 +823,7 @@ int ltdb_index_del(struct ldb_context *ldb, const struct ldb_message *msg)
 			continue;
 		}
 		for (j=0;j<msg->elements[i].num_values;j++) {
-			ret = ltdb_index_del1(ldb, msg->dn, &msg->elements[i], j);
+			ret = ltdb_index_del1(module, msg->dn, &msg->elements[i], j);
 			if (ret == -1) {
 				return -1;
 			}
@@ -844,7 +851,7 @@ static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, vo
 */
 static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
 {
-	struct ldb_context *ldb = state;
+	struct ldb_module *module = state;
 	struct ldb_message msg;
 	int ret;
 
@@ -853,7 +860,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		return 0;
 	}
 
-	ret = ltdb_unpack_data(ldb, &data, &msg);
+	ret = ltdb_unpack_data(module->ldb, &data, &msg);
 	if (ret != 0) {
 		return -1;
 	}
@@ -862,9 +869,9 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		msg.dn = key.dptr+3;
 	}
 
-	ret = ltdb_index_add(ldb, &msg);
+	ret = ltdb_index_add(module, &msg);
 
-	ltdb_unpack_data_free(ldb, &msg);
+	ltdb_unpack_data_free(module->ldb, &msg);
 
 	return ret;
 }
@@ -872,14 +879,14 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 /*
   force a complete reindex of the database
 */
-int ltdb_reindex(struct ldb_context *ldb)
+int ltdb_reindex(struct ldb_module *module)
 {
-	struct ltdb_private *ltdb = ldb->private_data;
+	struct ltdb_private *ltdb = module->private_data;
 	int ret;
 
-	ltdb_cache_free(ldb);
+	ltdb_cache_free(module);
 
-	if (ltdb_cache_load(ldb) != 0) {
+	if (ltdb_cache_load(module) != 0) {
 		return -1;
 	}
 
@@ -891,7 +898,7 @@ int ltdb_reindex(struct ldb_context *ldb)
 	}
 
 	/* now traverse adding any indexes for normal LDB records */
-	ret = tdb_traverse(ltdb->tdb, re_index, ldb);
+	ret = tdb_traverse(ltdb->tdb, re_index, module);
 	if (ret == -1) {
 		errno = EIO;
 		return -1;
-- 
cgit 


From e81157c7379116d83b9906e27c9fd418c779d129 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 16 Nov 2004 06:14:36 +0000
Subject: r3782: use ldb_ namespace

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index d54208777d..93e358e4d2 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -272,7 +272,7 @@ static int list_intersect(struct ldb_context *ldb,
 	list3.count = 0;
 
 	for (i=0;i<list->count;i++) {
-		if (list_find(list->dn[i], list2->dn, list2->count, 
+		if (ldb_list_find(list->dn[i], list2->dn, list2->count, 
 			      sizeof(char *), (comparison_fn_t)strcmp) != -1) {
 			list3.dn[list3.count] = list->dn[i];
 			list3.count++;
@@ -315,7 +315,7 @@ static int list_union(struct ldb_context *ldb,
 	list->dn = d;
 
 	for (i=0;i<list2->count;i++) {
-		if (list_find(list2->dn[i], list->dn, count, 
+		if (ldb_list_find(list2->dn[i], list->dn, count, 
 			      sizeof(char *), (comparison_fn_t)strcmp) == -1) {
 			list->dn[list->count] = ldb_strdup(ldb, list2->dn[i]);
 			if (!list->dn[list->count]) {
-- 
cgit 


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

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

- make ldb_context and ldb_module private to the subsystem

- use ltdb_ prefix for all ldb_tdb functions

metze
(This used to be commit f5ee40d6ce8224e280070975efc9911558fe675c)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 93e358e4d2..b651aa38c1 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -33,6 +33,8 @@
  */
 
 #include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
 #include "ldb/ldb_tdb/ldb_tdb.h"
 #include "ldb/include/ldb_parse.h"
 
@@ -523,7 +525,7 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 			return -1;
 		}
 
-		if (ldb_message_match(module, &msg, tree, base, scope) == 1) {
+		if (ltdb_message_match(module, &msg, tree, base, scope) == 1) {
 			ret = ltdb_add_attr_results(module, &msg, attrs, &count, res);
 		}
 		ltdb_search_dn1_free(module, &msg);
@@ -860,7 +862,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		return 0;
 	}
 
-	ret = ltdb_unpack_data(module->ldb, &data, &msg);
+	ret = ltdb_unpack_data(module, &data, &msg);
 	if (ret != 0) {
 		return -1;
 	}
@@ -871,7 +873,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 
 	ret = ltdb_index_add(module, &msg);
 
-	ltdb_unpack_data_free(module->ldb, &msg);
+	ltdb_unpack_data_free(module, &msg);
 
 	return ret;
 }
-- 
cgit 


From b6c4b63dc59d10e7f93e726282b6f93f64dd7bb8 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 30 Nov 2004 22:55:36 +0000
Subject: r4022: fix compiler warnings

metze
(This used to be commit 79d0eb2f677f9e985ba476a9680f68537d41be6f)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index b651aa38c1..df0a436172 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -80,7 +80,7 @@ static char *ldb_dn_key(struct ldb_context *ldb,
   see if a attribute value is in the list of indexed attributes
 */
 static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
-			    int *v_idx, const char *key)
+			    unsigned int *v_idx, const char *key)
 {
 	unsigned int i, j;
 	for (i=0;i<msg->num_elements;i++) {
@@ -509,7 +509,8 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 			    const struct dn_list *dn_list, 
 			    const char * const attrs[], struct ldb_message ***res)
 {
-	unsigned int count = 0, i;
+	unsigned int i;
+	int count = 0;
 
 	for (i=0;i<dn_list->count;i++) {
 		struct ldb_message msg;
-- 
cgit 


From cf4298874c01644eaedb8f80eec131ec5a220e08 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 19 Dec 2004 10:56:29 +0000
Subject: r4281: fixed an ldb indexing bug in ldb found by volker.

index entries were not always being removed on modify
(This used to be commit 9c668e7b43dc2d82d3d639b64c53e887723ccba7)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index df0a436172..b0a1b0f89f 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -746,8 +746,8 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 /*
   delete an index entry for one message element
 */
-static int ltdb_index_del1(struct ldb_module *module, const char *dn, 
-			   struct ldb_message_element *el, int v_idx)
+int ltdb_index_del_value(struct ldb_module *module, const char *dn, 
+			 struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_context *ldb = module->ldb;
 	struct ldb_message msg;
@@ -826,7 +826,7 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 			continue;
 		}
 		for (j=0;j<msg->elements[i].num_values;j++) {
-			ret = ltdb_index_del1(module, msg->dn, &msg->elements[i], j);
+			ret = ltdb_index_del_value(module, msg->dn, &msg->elements[i], j);
 			if (ret == -1) {
 				return -1;
 			}
-- 
cgit 


From 04e1d5f77cfba8dd69eccf510cf07bbc3df0ec2b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 19 Dec 2004 10:58:36 +0000
Subject: r4282: removed a spurious error message now we remove index entries
 in the modify call (This used to be commit
 58fcc326241e73cc8a122e6130b5ff0d6a3b9232)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index b0a1b0f89f..8d31a3a81f 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -769,7 +769,6 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 	if (ret == 0) {
 		/* it wasn't indexed. Did we have an earlier error? If we did then
 		   its gone now */
-		ldb_debug(ldb, LDB_DEBUG_ERROR, "ERROR: dn_key %s was not indexed\n", dn_key);
 		ldb_free(ldb, dn_key);
 		return 0;
 	}
-- 
cgit 


From 91abe814d160c4aaf55ce989bacb9c115e159896 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Wed, 29 Dec 2004 22:25:46 +0000
Subject: r4397: Fix a bug where
 '(&(objectclass=domain)(!(objectclass=builtindomain)))' fell back to a full
 search.

Volker
(This used to be commit 55c9fbd4f4afdde30a0d92bfd31f5c9ebb98c59b)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 8d31a3a81f..01fa4be44b 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -526,6 +526,7 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 			return -1;
 		}
 
+		ret = 0;
 		if (ltdb_message_match(module, &msg, tree, base, scope) == 1) {
 			ret = ltdb_add_attr_results(module, &msg, attrs, &count, res);
 		}
-- 
cgit 


From c5fa6f7516dca066359f73b1c4aba3e0d8a4c850 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 31 Dec 2004 02:18:14 +0000
Subject: r4424: fixed a simple bug in the '|' handling in indexed ldb
 searches. I'm amazed we got along for so long with this bug! (This used to be
 commit 937159cf2c6ae08808bd10946fcdbd8741e1a560)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 01fa4be44b..eaf699be62 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -385,6 +385,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 				return -1;
 			}
 			dn_list_free(ldb, &list2);
+			ret = 1;
 		}
 	}
 
-- 
cgit 


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

- added gcov flags to Makefile.ldb

- expanded ldb test suite to get more coverage
(This used to be commit 0ab98f50a7e0fe15347a99e5c29a6590a87729a0)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 327 ++++++++++++++++++++----------------
 1 file changed, 182 insertions(+), 145 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index eaf699be62..ff0cabb0d6 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -43,18 +43,6 @@ struct dn_list {
 	char **dn;
 };
 
-/*
-  free a struct dn_list
-*/
-static void dn_list_free(struct ldb_context *ldb, struct dn_list *list)
-{
-	unsigned int i;
-	for (i=0;i<list->count;i++) {
-		ldb_free(ldb, list->dn[i]);
-	}
-	ldb_free(ldb, list->dn);
-}
-
 /*
   return the dn key to be used for an index
   caller frees
@@ -67,13 +55,13 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 	if (ldb_should_b64_encode(value)) {
 		char *vstr = ldb_base64_encode(ldb, value->data, value->length);
 		if (!vstr) return NULL;
-		ldb_asprintf(ldb, &ret, "%s:%s::%s", LTDB_INDEX, attr, vstr);
-		ldb_free(ldb, vstr);
+		ret = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr, vstr);
+		talloc_free(vstr);
 		return ret;
 	}
 
-	ldb_asprintf(ldb, &ret, "%s:%s:%.*s", LTDB_INDEX, attr, value->length, (char *)value->data);
-	return ret;
+	return talloc_asprintf(ldb, "%s:%s:%.*s", 
+			       LTDB_INDEX, attr, value->length, (char *)value->data);
 }
 
 /*
@@ -118,7 +106,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 	char *dn = NULL;
 	int ret;
 	unsigned int i, j;
-	struct ldb_message msg;
+	struct ldb_message *msg;
 
 	list->count = 0;
 	list->dn = NULL;
@@ -141,39 +129,43 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 	dn = ldb_dn_key(ldb, tree->u.simple.attr, &tree->u.simple.value);
 	if (!dn) return -1;
 
-	ret = ltdb_search_dn1(module, dn, &msg);
-	ldb_free(ldb, dn);
+	msg = talloc_p(list, struct ldb_message);
+	if (msg == NULL) {
+		return -1;
+	}
+
+	ret = ltdb_search_dn1(module, dn, msg);
+	talloc_free(dn);
 	if (ret == 0 || ret == -1) {
 		return ret;
 	}
 
-	for (i=0;i<msg.num_elements;i++) {
+	for (i=0;i<msg->num_elements;i++) {
 		struct ldb_message_element *el;
 
-		if (strcmp(msg.elements[i].name, LTDB_IDX) != 0) {
+		if (strcmp(msg->elements[i].name, LTDB_IDX) != 0) {
 			continue;
 		}
 
-		el = &msg.elements[i];
+		el = &msg->elements[i];
 
-		list->dn = ldb_malloc_array_p(ldb, char *, el->num_values);
+		list->dn = talloc_array_p(list, char *, el->num_values);
 		if (!list->dn) {
 			break;		
 		}
 
 		for (j=0;j<el->num_values;j++) {
 			list->dn[list->count] = 
-				ldb_strdup(ldb, (char *)el->values[j].data);
+				talloc_strdup(list->dn, (char *)el->values[j].data);
 			if (!list->dn[list->count]) {
-				dn_list_free(ldb, list);
-				ltdb_search_dn1_free(module, &msg);
+				talloc_free(list);
 				return -1;
 			}
 			list->count++;
 		}
 	}
 
-	ltdb_search_dn1_free(module, &msg);
+	talloc_free(msg);
 
 	qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
 
@@ -203,30 +195,34 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 
 	ret = ltdb_index_dn_simple(module, tree, index_list, list);
 
-	for (i=0;i<ltdb->cache.subclasses.num_elements;i++) {
-		struct ldb_message_element *el = &ltdb->cache.subclasses.elements[i];
+	for (i=0;i<ltdb->cache->subclasses->num_elements;i++) {
+		struct ldb_message_element *el = &ltdb->cache->subclasses->elements[i];
 		if (ldb_attr_cmp(el->name, target) == 0) {
 			unsigned int j;
 			for (j=0;j<el->num_values;j++) {
 				struct ldb_parse_tree tree2;
-				struct dn_list list2;
+				struct dn_list *list2;
 				tree2.operation = LDB_OP_SIMPLE;
-				tree2.u.simple.attr = ldb_strdup(ldb, LTDB_OBJECTCLASS);
+				tree2.u.simple.attr = talloc_strdup(list, LTDB_OBJECTCLASS);
 				if (!tree2.u.simple.attr) {
 					return -1;
 				}
 				tree2.u.simple.value = el->values[j];
+				list2 = talloc_p(list, struct dn_list);
+				if (list2 == NULL) {
+					return -1;
+				}
 				if (ltdb_index_dn_objectclass(module, &tree2, 
-							      index_list, &list2) == 1) {
+							      index_list, list2) == 1) {
 					if (list->count == 0) {
-						*list = list2;
+						*list = *list2;
 						ret = 1;
 					} else {
-						list_union(ldb, list, &list2);
-						dn_list_free(ldb, &list2);
+						list_union(ldb, list, list2);
+						talloc_free(list2);
 					}
 				}
-				ldb_free(ldb, tree2.u.simple.attr);
+				talloc_free(tree2.u.simple.attr);
 			}
 		}
 	}
@@ -257,35 +253,42 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 static int list_intersect(struct ldb_context *ldb,
 			  struct dn_list *list, const struct dn_list *list2)
 {
-	struct dn_list list3;
+	struct dn_list *list3;
 	unsigned int i;
 
 	if (list->count == 0 || list2->count == 0) {
 		/* 0 & X == 0 */
-		dn_list_free(ldb, list);
+		talloc_free(list);
 		return 0;
 	}
 
-	list3.dn = ldb_malloc_array_p(ldb, char *, list->count);
-	if (!list3.dn) {
-		dn_list_free(ldb, list);
+	list3 = talloc_p(ldb, struct dn_list);
+	if (list3 == NULL) {
 		return -1;
 	}
-	list3.count = 0;
+
+	list3->dn = talloc_array_p(list3, char *, list->count);
+	if (!list3->dn) {
+		talloc_free(list);
+		talloc_free(list3);
+		return -1;
+	}
+	list3->count = 0;
 
 	for (i=0;i<list->count;i++) {
 		if (ldb_list_find(list->dn[i], list2->dn, list2->count, 
 			      sizeof(char *), (comparison_fn_t)strcmp) != -1) {
-			list3.dn[list3.count] = list->dn[i];
-			list3.count++;
+			list3->dn[list3->count] = talloc_steal(list3->dn, list->dn[i]);
+			list3->count++;
 		} else {
-			ldb_free(ldb, list->dn[i]);
+			talloc_free(list->dn[i]);
 		}		
 	}
 
-	ldb_free(ldb, list->dn);
-	list->dn = list3.dn;
-	list->count = list3.count;
+	talloc_free(list->dn);
+	list->dn = talloc_steal(list, list3->dn);
+	list->count = list3->count;
+	talloc_free(list3);
 
 	return 0;
 }
@@ -305,13 +308,13 @@ static int list_union(struct ldb_context *ldb,
 
 	if (list->count == 0 && list2->count == 0) {
 		/* 0 | 0 == 0 */
-		dn_list_free(ldb, list);
+		talloc_free(list);
 		return 0;
 	}
 
-	d = ldb_realloc_p(ldb, list->dn, char *, list->count + list2->count);
+	d = talloc_realloc_p(list, list->dn, char *, list->count + list2->count);
 	if (!d) {
-		dn_list_free(ldb, list);
+		talloc_free(list);
 		return -1;
 	}
 	list->dn = d;
@@ -319,9 +322,9 @@ static int list_union(struct ldb_context *ldb,
 	for (i=0;i<list2->count;i++) {
 		if (ldb_list_find(list2->dn[i], list->dn, count, 
 			      sizeof(char *), (comparison_fn_t)strcmp) == -1) {
-			list->dn[list->count] = ldb_strdup(ldb, list2->dn[i]);
+			list->dn[list->count] = talloc_strdup(list->dn, list2->dn[i]);
 			if (!list->dn[list->count]) {
-				dn_list_free(ldb, list);
+				talloc_free(list);
 				return -1;
 			}
 			list->count++;
@@ -358,39 +361,48 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 	list->count = 0;
 
 	for (i=0;i<tree->u.list.num_elements;i++) {
-		struct dn_list list2;
+		struct dn_list *list2;
 		int v;
-		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, &list2);
+
+		list2 = talloc_p(module, struct dn_list);
+		if (list2 == NULL) {
+			return -1;
+		}
+
+		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
 
 		if (v == 0) {
 			/* 0 || X == X */
 			if (ret == -1) {
 				ret = 0;
 			}
+			talloc_free(list2);
 			continue;
 		}
 
 		if (v == -1) {
 			/* 1 || X == 1 */
-			dn_list_free(ldb, list);
+			talloc_free(list->dn);
+			talloc_free(list2);
 			return -1;
 		}
 
 		if (ret == -1) {
 			ret = 1;
-			*list = list2;
+			list->dn = talloc_steal(list, list2->dn);
+			list->count = list2->count;
 		} else {
-			if (list_union(ldb, list, &list2) == -1) {
-				dn_list_free(ldb, &list2);
+			if (list_union(ldb, list, list2) == -1) {
+				talloc_free(list2);
 				return -1;
 			}
-			dn_list_free(ldb, &list2);
 			ret = 1;
 		}
+		talloc_free(list2);
 	}
 
 	if (list->count == 0) {
-		dn_list_free(ldb, list);
+		talloc_free(list);
 		return 0;
 	}
 
@@ -434,33 +446,44 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 	list->count = 0;
 
 	for (i=0;i<tree->u.list.num_elements;i++) {
-		struct dn_list list2;
+		struct dn_list *list2;
 		int v;
-		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, &list2);
+
+		list2 = talloc_p(module, struct dn_list);
+		if (list2 == NULL) {
+			return -1;
+		}
+
+		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
 
 		if (v == 0) {
 			/* 0 && X == 0 */
-			dn_list_free(ldb, list);
+			talloc_free(list->dn);
+			talloc_free(list2);
 			return 0;
 		}
 
 		if (v == -1) {
+			talloc_free(list2);
 			continue;
 		}
 
 		if (ret == -1) {
 			ret = 1;
-			*list = list2;
+			talloc_free(list->dn);
+			list->dn = talloc_steal(list, list2->dn);
+			list->count = list2->count;
 		} else {
-			if (list_intersect(ldb, list, &list2) == -1) {
-				dn_list_free(ldb, &list2);
+			if (list_intersect(ldb, list, list2) == -1) {
+				talloc_free(list2);
 				return -1;
 			}
-			dn_list_free(ldb, &list2);
 		}
 
+		talloc_free(list2);
+
 		if (list->count == 0) {
-			if (list->dn) ldb_free(ldb, list->dn);
+			talloc_free(list->dn);
 			return 0;
 		}
 	}
@@ -514,24 +537,32 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 	int count = 0;
 
 	for (i=0;i<dn_list->count;i++) {
-		struct ldb_message msg;
+		struct ldb_message *msg;
 		int ret;
-		ret = ltdb_search_dn1(module, dn_list->dn[i], &msg);
+
+		msg = talloc_p(module, struct ldb_message);
+		if (msg == NULL) {
+			return -1;
+		}
+
+		ret = ltdb_search_dn1(module, dn_list->dn[i], msg);
 		if (ret == 0) {
 			/* the record has disappeared? yes, this can happen */
+			talloc_free(msg);
 			continue;
 		}
 
 		if (ret == -1) {
 			/* an internal error */
+			talloc_free(msg);
 			return -1;
 		}
 
 		ret = 0;
-		if (ltdb_message_match(module, &msg, tree, base, scope) == 1) {
-			ret = ltdb_add_attr_results(module, &msg, attrs, &count, res);
+		if (ltdb_message_match(module, msg, tree, base, scope) == 1) {
+			ret = ltdb_add_attr_results(module, msg, attrs, &count, res);
 		}
-		ltdb_search_dn1_free(module, &msg);
+		talloc_free(msg);
 		if (ret != 0) {
 			return -1;
 		}
@@ -551,26 +582,31 @@ int ltdb_search_indexed(struct ldb_module *module,
 			struct ldb_parse_tree *tree,
 			const char * const attrs[], struct ldb_message ***res)
 {
-	struct ldb_context *ldb = module->ldb;
 	struct ltdb_private *ltdb = module->private_data;
-	struct dn_list dn_list;
+	struct dn_list *dn_list;
 	int ret;
 
-	if (ltdb->cache.indexlist.num_elements == 0) {
+	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no index list? must do full search */
 		return -1;
 	}
 
-	ret = ltdb_index_dn(module, tree, &ltdb->cache.indexlist, &dn_list);
+	dn_list = talloc_p(module, struct dn_list);
+	if (dn_list == NULL) {
+		return -1;
+	}
+
+	ret = ltdb_index_dn(module, tree, ltdb->cache->indexlist, dn_list);
 
 	if (ret == 1) {
 		/* we've got a candidate list - now filter by the full tree
 		   and extract the needed attributes */
-		ret = ldb_index_filter(module, tree, base, scope, &dn_list, 
+		ret = ldb_index_filter(module, tree, base, scope, dn_list, 
 				       attrs, res);
-		dn_list_free(ldb, &dn_list);
 	}
 
+	talloc_free(dn_list);
+
 	return ret;
 }
 
@@ -585,19 +621,19 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 	struct ldb_message_element *el2;
 
 	/* add another entry */
-	el2 = ldb_realloc_p(ldb, msg->elements, 
-			    struct ldb_message_element, msg->num_elements+1);
+	el2 = talloc_realloc_p(msg, msg->elements, 
+			       struct ldb_message_element, msg->num_elements+1);
 	if (!el2) {
 		return -1;
 	}
 
 	msg->elements = el2;
-	msg->elements[msg->num_elements].name = ldb_strdup(ldb, LTDB_IDX);
+	msg->elements[msg->num_elements].name = talloc_strdup(msg->elements, LTDB_IDX);
 	if (!msg->elements[msg->num_elements].name) {
 		return -1;
 	}
 	msg->elements[msg->num_elements].num_values = 0;
-	msg->elements[msg->num_elements].values = ldb_malloc_p(ldb, struct ldb_val);
+	msg->elements[msg->num_elements].values = talloc_p(msg->elements, struct ldb_val);
 	if (!msg->elements[msg->num_elements].values) {
 		return -1;
 	}
@@ -630,9 +666,9 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 		}
 	}
 
-	v2 = ldb_realloc_p(ldb, msg->elements[idx].values,
-			   struct ldb_val, 
-			   msg->elements[idx].num_values+1);
+	v2 = talloc_realloc_p(msg->elements, msg->elements[idx].values,
+			      struct ldb_val, 
+			      msg->elements[idx].num_values+1);
 	if (!v2) {
 		return -1;
 	}
@@ -652,9 +688,9 @@ static int ltdb_index_add1(struct ldb_module *module, char *dn,
 			   struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_context *ldb = module->ldb;
-	struct ldb_message msg;
+	struct ldb_message *msg;
 	char *dn_key;
-	int ret, added=0, added_dn=0;
+	int ret;
 	unsigned int i;
 
 	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
@@ -662,52 +698,45 @@ static int ltdb_index_add1(struct ldb_module *module, char *dn,
 		return -1;
 	}
 
-	ret = ltdb_search_dn1(module, dn_key, &msg);
+	msg = talloc_p(dn_key, struct ldb_message);
+	if (msg == NULL) {
+		return -1;
+	}
+
+	ret = ltdb_search_dn1(module, dn_key, msg);
 	if (ret == -1) {
-		ldb_free(ldb, dn_key);
+		talloc_free(dn_key);
 		return -1;
 	}
 
 	if (ret == 0) {
-		added_dn = 1;
-		msg.dn = ldb_strdup(ldb, dn_key);
-		if (!msg.dn) {
-			ldb_free(ldb, dn_key);
+		msg->dn = talloc_strdup(msg, dn_key);
+		if (!msg->dn) {
+			talloc_free(dn_key);
 			errno = ENOMEM;
 			return -1;
 		}
-		msg.num_elements = 0;
-		msg.elements = NULL;
-		msg.private_data = NULL;
+		msg->num_elements = 0;
+		msg->elements = NULL;
 	}
 
-	ldb_free(ldb, dn_key);
-
-	for (i=0;i<msg.num_elements;i++) {
-		if (strcmp(LTDB_IDX, msg.elements[i].name) == 0) {
+	for (i=0;i<msg->num_elements;i++) {
+		if (strcmp(LTDB_IDX, msg->elements[i].name) == 0) {
 			break;
 		}
 	}
 
-	if (i == msg.num_elements) {
-		added = 1;
-		ret = ltdb_index_add1_new(ldb, &msg, el, dn);
+	if (i == msg->num_elements) {
+		ret = ltdb_index_add1_new(ldb, msg, el, dn);
 	} else {
-		ret = ltdb_index_add1_add(ldb, &msg, el, i, dn);
+		ret = ltdb_index_add1_add(ldb, msg, el, i, dn);
 	}
 
 	if (ret == 0) {
-		ret = ltdb_store(module, &msg, TDB_REPLACE);
+		ret = ltdb_store(module, msg, TDB_REPLACE);
 	}
 
-	if (added) {
-		ldb_free(ldb, msg.elements[i].name);
-	}
-	if (added_dn) {
-		ldb_free(ldb, msg.dn);
-	}
-
-	ltdb_search_dn1_free(module, &msg);
+	talloc_free(dn_key);
 
 	return ret;
 }
@@ -722,13 +751,13 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 	int ret;
 	unsigned int i, j;
 
-	if (ltdb->cache.indexlist.num_elements == 0) {
+	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
 		return 0;
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, 
+		ret = ldb_msg_find_idx(ltdb->cache->indexlist, msg->elements[i].name, 
 				       NULL, LTDB_IDXATTR);
 		if (ret == -1) {
 			continue;
@@ -752,7 +781,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 			 struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_context *ldb = module->ldb;
-	struct ldb_message msg;
+	struct ldb_message *msg;
 	char *dn_key;
 	int ret, i;
 	unsigned int j;
@@ -762,44 +791,48 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 		return -1;
 	}
 
-	ret = ltdb_search_dn1(module, dn_key, &msg);
+	msg = talloc_p(dn_key, struct ldb_message);
+	if (msg == NULL) {
+		talloc_free(dn_key);
+		return -1;
+	}
+
+	ret = ltdb_search_dn1(module, dn_key, msg);
 	if (ret == -1) {
-		ldb_free(ldb, dn_key);
+		talloc_free(dn_key);
 		return -1;
 	}
 
 	if (ret == 0) {
 		/* it wasn't indexed. Did we have an earlier error? If we did then
 		   its gone now */
-		ldb_free(ldb, dn_key);
+		talloc_free(dn_key);
 		return 0;
 	}
 
-	i = ldb_msg_find_idx(&msg, dn, &j, LTDB_IDX);
+	i = ldb_msg_find_idx(msg, dn, &j, LTDB_IDX);
 	if (i == -1) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "ERROR: dn %s not found in %s\n", dn, dn_key);
 		/* it ain't there. hmmm */
-		ltdb_search_dn1_free(module, &msg);
-		ldb_free(ldb, dn_key);
+		talloc_free(dn_key);
 		return 0;
 	}
 
-	if (j != msg.elements[i].num_values - 1) {
-		memmove(&msg.elements[i].values[j], 
-			&msg.elements[i].values[j+1], 
-			(msg.elements[i].num_values-(j+1)) * 
-			sizeof(msg.elements[i].values[0]));
+	if (j != msg->elements[i].num_values - 1) {
+		memmove(&msg->elements[i].values[j], 
+			&msg->elements[i].values[j+1], 
+			(msg->elements[i].num_values-(j+1)) * 
+			sizeof(msg->elements[i].values[0]));
 	}
-	msg.elements[i].num_values--;
+	msg->elements[i].num_values--;
 
-	if (msg.elements[i].num_values == 0) {
+	if (msg->elements[i].num_values == 0) {
 		ret = ltdb_delete_noindex(module, dn_key);
 	} else {
-		ret = ltdb_store(module, &msg, TDB_REPLACE);
+		ret = ltdb_store(module, msg, TDB_REPLACE);
 	}
 
-	ltdb_search_dn1_free(module, &msg);
-	ldb_free(ldb, dn_key);
+	talloc_free(dn_key);
 
 	return ret;
 }
@@ -815,13 +848,13 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 	unsigned int i, j;
 
 	/* find the list of indexed fields */	
-	if (ltdb->cache.indexlist.num_elements == 0) {
+	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
 		return 0;
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(&ltdb->cache.indexlist, msg->elements[i].name, 
+		ret = ldb_msg_find_idx(ltdb->cache->indexlist, msg->elements[i].name, 
 				       NULL, LTDB_IDXATTR);
 		if (ret == -1) {
 			continue;
@@ -856,7 +889,7 @@ static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, vo
 static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
 {
 	struct ldb_module *module = state;
-	struct ldb_message msg;
+	struct ldb_message *msg;
 	int ret;
 
 	if (strncmp(key.dptr, "DN=@", 4) == 0 ||
@@ -864,18 +897,24 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		return 0;
 	}
 
-	ret = ltdb_unpack_data(module, &data, &msg);
+	msg = talloc_p(module, struct ldb_message);
+	if (msg == NULL) {
+		return -1;
+	}
+
+	ret = ltdb_unpack_data(module, &data, msg);
 	if (ret != 0) {
+		talloc_free(msg);
 		return -1;
 	}
 
-	if (!msg.dn) {
-		msg.dn = key.dptr+3;
+	if (!msg->dn) {
+		msg->dn = key.dptr+3;
 	}
 
-	ret = ltdb_index_add(module, &msg);
+	ret = ltdb_index_add(module, msg);
 
-	ltdb_unpack_data_free(module, &msg);
+	talloc_free(msg);
 
 	return ret;
 }
@@ -888,9 +927,7 @@ int ltdb_reindex(struct ldb_module *module)
 	struct ltdb_private *ltdb = module->private_data;
 	int ret;
 
-	ltdb_cache_free(module);
-
-	if (ltdb_cache_load(module) != 0) {
+	if (ltdb_cache_reload(module) != 0) {
 		return -1;
 	}
 
-- 
cgit 


From 09a76e204cf339862f8b0b45979d65cc34aa3c36 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 2 Jan 2005 09:46:59 +0000
Subject: r4477: expanded the test suite to increase code coverage a lot (This
 used to be commit 4edbd1b18ee38e584cf844b64c7fcb2645921837)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 51 +++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index ff0cabb0d6..88ef997a03 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -38,6 +38,57 @@
 #include "ldb/ldb_tdb/ldb_tdb.h"
 #include "ldb/include/ldb_parse.h"
 
+/*
+  find an element in a list, using the given comparison function and
+  assuming that the list is already sorted using comp_fn
+
+  return -1 if not found, or the index of the first occurance of needle if found
+*/
+static int ldb_list_find(const void *needle, 
+			 const void *base, size_t nmemb, size_t size, 
+			 comparison_fn_t comp_fn)
+{
+	const char *base_p = base;
+	size_t min_i, max_i, test_i;
+
+	if (nmemb == 0) {
+		return -1;
+	}
+
+	min_i = 0;
+	max_i = nmemb-1;
+
+	while (min_i < max_i) {
+		int r;
+
+		test_i = (min_i + max_i) / 2;
+		r = comp_fn(needle, *(void * const *)(base_p + (size * test_i)));
+		if (r == 0) {
+			/* scan back for first element */
+			while (test_i > 0 &&
+			       comp_fn(needle, *(void * const *)(base_p + (size * (test_i-1)))) == 0) {
+				test_i--;
+			}
+			return test_i;
+		}
+		if (r < 0) {
+			if (test_i == 0) {
+				return -1;
+			}
+			max_i = test_i - 1;
+		}
+		if (r > 0) {
+			min_i = test_i + 1;
+		}
+	}
+
+	if (comp_fn(needle, *(void * const *)(base_p + (size * min_i))) == 0) {
+		return min_i;
+	}
+
+	return -1;
+}
+
 struct dn_list {
 	unsigned int count;
 	char **dn;
-- 
cgit 


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

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

add and modify works correctly but we need a proper testsuite

Simo
(This used to be commit a681ae365ff1b5a2771b42ebd90336651ce1e513)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 88ef997a03..af325f9203 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -180,7 +180,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 	dn = ldb_dn_key(ldb, tree->u.simple.attr, &tree->u.simple.value);
 	if (!dn) return -1;
 
-	msg = talloc_p(list, struct ldb_message);
+	msg = talloc(list, struct ldb_message);
 	if (msg == NULL) {
 		return -1;
 	}
@@ -200,7 +200,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 
 		el = &msg->elements[i];
 
-		list->dn = talloc_array_p(list, char *, el->num_values);
+		list->dn = talloc_array(list, char *, el->num_values);
 		if (!list->dn) {
 			break;		
 		}
@@ -259,7 +259,7 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 					return -1;
 				}
 				tree2.u.simple.value = el->values[j];
-				list2 = talloc_p(list, struct dn_list);
+				list2 = talloc(list, struct dn_list);
 				if (list2 == NULL) {
 					return -1;
 				}
@@ -313,12 +313,12 @@ static int list_intersect(struct ldb_context *ldb,
 		return 0;
 	}
 
-	list3 = talloc_p(ldb, struct dn_list);
+	list3 = talloc(ldb, struct dn_list);
 	if (list3 == NULL) {
 		return -1;
 	}
 
-	list3->dn = talloc_array_p(list3, char *, list->count);
+	list3->dn = talloc_array(list3, char *, list->count);
 	if (!list3->dn) {
 		talloc_free(list);
 		talloc_free(list3);
@@ -363,7 +363,7 @@ static int list_union(struct ldb_context *ldb,
 		return 0;
 	}
 
-	d = talloc_realloc_p(list, list->dn, char *, list->count + list2->count);
+	d = talloc_realloc(list, list->dn, char *, list->count + list2->count);
 	if (!d) {
 		talloc_free(list);
 		return -1;
@@ -415,7 +415,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 		struct dn_list *list2;
 		int v;
 
-		list2 = talloc_p(module, struct dn_list);
+		list2 = talloc(module, struct dn_list);
 		if (list2 == NULL) {
 			return -1;
 		}
@@ -500,7 +500,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 		struct dn_list *list2;
 		int v;
 
-		list2 = talloc_p(module, struct dn_list);
+		list2 = talloc(module, struct dn_list);
 		if (list2 == NULL) {
 			return -1;
 		}
@@ -591,7 +591,7 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 		struct ldb_message *msg;
 		int ret;
 
-		msg = talloc_p(module, struct ldb_message);
+		msg = talloc(module, struct ldb_message);
 		if (msg == NULL) {
 			return -1;
 		}
@@ -642,7 +642,7 @@ int ltdb_search_indexed(struct ldb_module *module,
 		return -1;
 	}
 
-	dn_list = talloc_p(module, struct dn_list);
+	dn_list = talloc(module, struct dn_list);
 	if (dn_list == NULL) {
 		return -1;
 	}
@@ -672,7 +672,7 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 	struct ldb_message_element *el2;
 
 	/* add another entry */
-	el2 = talloc_realloc_p(msg, msg->elements, 
+	el2 = talloc_realloc(msg, msg->elements, 
 			       struct ldb_message_element, msg->num_elements+1);
 	if (!el2) {
 		return -1;
@@ -684,7 +684,7 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 		return -1;
 	}
 	msg->elements[msg->num_elements].num_values = 0;
-	msg->elements[msg->num_elements].values = talloc_p(msg->elements, struct ldb_val);
+	msg->elements[msg->num_elements].values = talloc(msg->elements, struct ldb_val);
 	if (!msg->elements[msg->num_elements].values) {
 		return -1;
 	}
@@ -717,7 +717,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 		}
 	}
 
-	v2 = talloc_realloc_p(msg->elements, msg->elements[idx].values,
+	v2 = talloc_realloc(msg->elements, msg->elements[idx].values,
 			      struct ldb_val, 
 			      msg->elements[idx].num_values+1);
 	if (!v2) {
@@ -749,7 +749,7 @@ static int ltdb_index_add1(struct ldb_module *module, char *dn,
 		return -1;
 	}
 
-	msg = talloc_p(dn_key, struct ldb_message);
+	msg = talloc(dn_key, struct ldb_message);
 	if (msg == NULL) {
 		return -1;
 	}
@@ -842,7 +842,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 		return -1;
 	}
 
-	msg = talloc_p(dn_key, struct ldb_message);
+	msg = talloc(dn_key, struct ldb_message);
 	if (msg == NULL) {
 		talloc_free(dn_key);
 		return -1;
@@ -948,7 +948,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		return 0;
 	}
 
-	msg = talloc_p(module, struct ldb_message);
+	msg = talloc(module, struct ldb_message);
 	if (msg == NULL) {
 		return -1;
 	}
-- 
cgit 


From df9d1a3709bdfe793ae124b0303fccc0b558f180 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 3 Feb 2005 04:03:28 +0000
Subject: r5189: fixed a double free bug in the ltdb indexing code (This used
 to be commit 7be0bc93bd6757e52fd10bd3d3b3d1a8f5221452)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 7 -------
 1 file changed, 7 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index af325f9203..c7dc9f1345 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -209,7 +209,6 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 			list->dn[list->count] = 
 				talloc_strdup(list->dn, (char *)el->values[j].data);
 			if (!list->dn[list->count]) {
-				talloc_free(list);
 				return -1;
 			}
 			list->count++;
@@ -309,7 +308,6 @@ static int list_intersect(struct ldb_context *ldb,
 
 	if (list->count == 0 || list2->count == 0) {
 		/* 0 & X == 0 */
-		talloc_free(list);
 		return 0;
 	}
 
@@ -320,7 +318,6 @@ static int list_intersect(struct ldb_context *ldb,
 
 	list3->dn = talloc_array(list3, char *, list->count);
 	if (!list3->dn) {
-		talloc_free(list);
 		talloc_free(list3);
 		return -1;
 	}
@@ -359,13 +356,11 @@ static int list_union(struct ldb_context *ldb,
 
 	if (list->count == 0 && list2->count == 0) {
 		/* 0 | 0 == 0 */
-		talloc_free(list);
 		return 0;
 	}
 
 	d = talloc_realloc(list, list->dn, char *, list->count + list2->count);
 	if (!d) {
-		talloc_free(list);
 		return -1;
 	}
 	list->dn = d;
@@ -375,7 +370,6 @@ static int list_union(struct ldb_context *ldb,
 			      sizeof(char *), (comparison_fn_t)strcmp) == -1) {
 			list->dn[list->count] = talloc_strdup(list->dn, list2->dn[i]);
 			if (!list->dn[list->count]) {
-				talloc_free(list);
 				return -1;
 			}
 			list->count++;
@@ -453,7 +447,6 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 	}
 
 	if (list->count == 0) {
-		talloc_free(list);
 		return 0;
 	}
 
-- 
cgit 


From 5a88d5211ba0f6b1d09cdd92489b34d0e603716b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 13 Feb 2005 12:27:57 +0000
Subject: r5374: - changed the dn key code in the ldb tdb backend to correctly
 honor   the case sensitive/insensitive flags on sections of a dn. So if a dn 
  is made up of 4 attributes, and 2 of those are case insensitive and 2   are
 case sensitive, then all the attribute names are uppercases, but   only the
 values of the case insensitive attributes are uppercased when   forming the
 tdb key.

- added code to canonicalise the dn, removing leading and trailing
  spaces from attribute names and values

- when the @ATTRIBUTES record changes, fix the dn keys of any records that should now have new
  dn keys due to changes in the case sensitivity of the record

I really did this to allow me to make the WINS database properly case
insensitive, but it is also the correct general fix for ldb, as it
matches the LDAP specification (and w2k LDAP server behaviour)
(This used to be commit 0f034dc5636d182a1d9207ad662b3fc8df7ca3e4)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index c7dc9f1345..1cf1b5c531 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -935,6 +935,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	struct ldb_module *module = state;
 	struct ldb_message *msg;
 	int ret;
+	TDB_DATA key2;
 
 	if (strncmp(key.dptr, "DN=@", 4) == 0 ||
 	    strncmp(key.dptr, "DN=", 3) != 0) {
@@ -952,6 +953,15 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		return -1;
 	}
 
+	/* check if the DN key has changed, perhaps due to the 
+	   case insensitivity of an element changing */
+	key2 = ltdb_key(module, msg->dn);
+	if (strcmp(key2.dptr, key.dptr) != 0) {
+		tdb_delete(tdb, key);
+		tdb_store(tdb, key2, data, 0);
+	}
+	talloc_free(key2.dptr);
+
 	if (!msg->dn) {
 		msg->dn = key.dptr+3;
 	}
-- 
cgit 


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

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

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

- moved to C99 structure initialisation in ldb

- switched ldap server to using ldb_search_bytree()
(This used to be commit 96620ab2ee5d440bbbc51c1bc0cad9977770f897)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 1cf1b5c531..b6ba413ba5 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -36,7 +36,6 @@
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_private.h"
 #include "ldb/ldb_tdb/ldb_tdb.h"
-#include "ldb/include/ldb_parse.h"
 
 /*
   find an element in a list, using the given comparison function and
-- 
cgit 


From 4fec6356ea190d202783fe19013387462a22c441 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 14 Jun 2005 01:35:44 +0000
Subject: r7558: added support in ldb for extended ldap search requests. These
 are using to perform such things as bitop tests on integers.

So far I have only added support for the 1.2.840.113556.1.4.803 and
1.2.840.113556.1.4.804 rules, which are for bitwise and/or
(This used to be commit 5f773b065f1db959e59c02de68bcf30cef1a6c2c)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index b6ba413ba5..00b124a9cf 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -550,6 +550,11 @@ static int ltdb_index_dn(struct ldb_module *module,
 		ret = ltdb_index_dn_leaf(module, tree, index_list, list);
 		break;
 
+	case LDB_OP_EXTENDED:
+		/* we can't index with fancy bitops yet */
+		ret = -1;
+		break;
+
 	case LDB_OP_AND:
 		ret = ltdb_index_dn_and(module, tree, index_list, list);
 		break;
-- 
cgit 


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

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

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

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

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

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

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

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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 00b124a9cf..4d8a14f7f0 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -101,17 +101,45 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 			const char *attr, const struct ldb_val *value)
 {
 	char *ret = NULL;
+	struct ldb_val v;
+	const struct ldb_attrib_handler *h;
+	char *attr_folded;
 
-	if (ldb_should_b64_encode(value)) {
+	attr_folded = ldb_casefold(ldb, attr);
+	if (!attr_folded) {
+		return NULL;
+	}
+
+	h = ldb_attrib_handler(ldb, attr);
+	if (h->canonicalise_fn(ldb, value, &v) != 0) {
+		/* canonicalisation can be refused. For example, 
+		   a attribute that takes wildcards will refuse to canonicalise
+		   if the value contains a wildcard */
+		talloc_free(attr_folded);
+		return NULL;
+	}
+	
+	if (ldb_should_b64_encode(&v)) {
 		char *vstr = ldb_base64_encode(ldb, value->data, value->length);
 		if (!vstr) return NULL;
-		ret = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr, vstr);
+		ret = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
 		talloc_free(vstr);
+		if (v.data != value->data) {
+			talloc_free(v.data);
+		}
+		talloc_free(attr_folded);
 		return ret;
 	}
 
-	return talloc_asprintf(ldb, "%s:%s:%.*s", 
-			       LTDB_INDEX, attr, value->length, (char *)value->data);
+	ret = talloc_asprintf(ldb, "%s:%s:%.*s", 
+			      LTDB_INDEX, attr_folded, v.length, (char *)v.data);
+
+	if (v.data != value->data) {
+		talloc_free(v.data);
+	}
+	talloc_free(attr_folded);
+
+	return ret;
 }
 
 /*
@@ -234,46 +262,50 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 				     struct dn_list *list)
 {
 	struct ldb_context *ldb = module->ldb;
-	struct ltdb_private *ltdb = module->private_data;
 	unsigned int i;
 	int ret;
 	const char *target = tree->u.simple.value.data;
+	const char **subclasses;
 
 	list->count = 0;
 	list->dn = NULL;
 
 	ret = ltdb_index_dn_simple(module, tree, index_list, list);
 
-	for (i=0;i<ltdb->cache->subclasses->num_elements;i++) {
-		struct ldb_message_element *el = &ltdb->cache->subclasses->elements[i];
-		if (ldb_attr_cmp(el->name, target) == 0) {
-			unsigned int j;
-			for (j=0;j<el->num_values;j++) {
-				struct ldb_parse_tree tree2;
-				struct dn_list *list2;
-				tree2.operation = LDB_OP_SIMPLE;
-				tree2.u.simple.attr = talloc_strdup(list, LTDB_OBJECTCLASS);
-				if (!tree2.u.simple.attr) {
-					return -1;
-				}
-				tree2.u.simple.value = el->values[j];
-				list2 = talloc(list, struct dn_list);
-				if (list2 == NULL) {
-					return -1;
-				}
-				if (ltdb_index_dn_objectclass(module, &tree2, 
-							      index_list, list2) == 1) {
-					if (list->count == 0) {
-						*list = *list2;
-						ret = 1;
-					} else {
-						list_union(ldb, list, list2);
-						talloc_free(list2);
-					}
-				}
-				talloc_free(tree2.u.simple.attr);
+	subclasses = ldb_subclass_list(module->ldb, target);
+
+	if (subclasses == NULL) {
+		return ret;
+	}
+
+	for (i=0;subclasses[i];i++) {
+		struct ldb_parse_tree tree2;
+		struct dn_list *list2;
+		tree2.operation = LDB_OP_SIMPLE;
+		tree2.u.simple.attr = talloc_strdup(list, LTDB_OBJECTCLASS);
+		if (!tree2.u.simple.attr) {
+			return -1;
+		}
+		tree2.u.simple.value.data = talloc_strdup(tree2.u.simple.attr, subclasses[i]);
+		if (tree2.u.simple.value.data == NULL) {
+			return -1;			
+		}
+		tree2.u.simple.value.length = strlen(subclasses[i]);
+		list2 = talloc(list, struct dn_list);
+		if (list2 == NULL) {
+			return -1;
+		}
+		if (ltdb_index_dn_objectclass(module, &tree2, 
+					      index_list, list2) == 1) {
+			if (list->count == 0) {
+				*list = *list2;
+				ret = 1;
+			} else {
+				list_union(ldb, list, list2);
+				talloc_free(list2);
 			}
 		}
+		talloc_free(tree2.u.simple.attr);
 	}
 
 	return ret;
@@ -607,7 +639,7 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 		}
 
 		ret = 0;
-		if (ltdb_message_match(module, msg, tree, base, scope) == 1) {
+		if (ldb_match_message(module->ldb, msg, tree, base, scope) == 1) {
 			ret = ltdb_add_attr_results(module, msg, attrs, &count, res);
 		}
 		talloc_free(msg);
@@ -799,6 +831,10 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 	int ret;
 	unsigned int i, j;
 
+	if (msg->dn[0] == '@') {
+		return 0;
+	}
+
 	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
 		return 0;
@@ -834,6 +870,10 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 	int ret, i;
 	unsigned int j;
 
+	if (dn[0] == '@') {
+		return 0;
+	}
+
 	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		return -1;
@@ -895,6 +935,10 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 	int ret;
 	unsigned int i, j;
 
+	if (msg->dn[0] == '@') {
+		return 0;
+	}
+
 	/* find the list of indexed fields */	
 	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
-- 
cgit 


From bd7812be319556162b22562a7c9670dce00d90f9 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 1 Jul 2005 07:02:26 +0000
Subject: r8038: - fixed indexing on binary values that need base64 encoding
 and canonicalisation

- added support for recognising the S- form of objectsid in search
  expressions. I thought this could be done with just a comparison
  modified comparison function, but it turns out it also needs a
  canonicalisation function so that indexing can work
(This used to be commit 7d2bee2c5619f284375ecbed14371c5e8639ed1c)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 4d8a14f7f0..089c24eae4 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -118,9 +118,8 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 		talloc_free(attr_folded);
 		return NULL;
 	}
-	
 	if (ldb_should_b64_encode(&v)) {
-		char *vstr = ldb_base64_encode(ldb, value->data, value->length);
+		char *vstr = ldb_base64_encode(ldb, v.data, v.length);
 		if (!vstr) return NULL;
 		ret = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
 		talloc_free(vstr);
-- 
cgit 


From 1c5105065a44173667de2a022dd2417e56b527d6 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 2 Jul 2005 17:30:03 +0000
Subject: r8082: large rewite of ldb_dn.c

- we do not support multpiple attribute components anymore, makes code a lot easier
  they will be readded later if we found out they are really used, so far my tests
  show w2k3 do not handle them as well

- fix escaping issues, move component value to be in an ldb_val structure
  still need to handle binary values case

- make cononicalize functions leak less memory by giving a specific memory context

- fix tests scripts so that test-ldap can start
- make test not delete databases on completion so that I can inspect them
(This used to be commit 624a73148d125690ce18515f19231d26df207738)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 089c24eae4..a3317a8765 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -111,7 +111,7 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 	}
 
 	h = ldb_attrib_handler(ldb, attr);
-	if (h->canonicalise_fn(ldb, value, &v) != 0) {
+	if (h->canonicalise_fn(ldb, ldb, value, &v) != 0) {
 		/* canonicalisation can be refused. For example, 
 		   a attribute that takes wildcards will refuse to canonicalise
 		   if the value contains a wildcard */
-- 
cgit 


From c9b0e86a436b5b169a4c33bd25eac379cb622b17 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 12 Jul 2005 12:04:54 +0000
Subject: r8373: New wildcard matching code. This code applies correct ldap
 standard wildcard matching code removes WILDCARD matching from tdb
 @ATTRIBUTES, that's now handled independently adds some more tests for
 wildcard matching fixes dn comparison code in ldb_match (This used to be
 commit 4eb5863042011988d85092d7dde3d809aa15bd59)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index a3317a8765..03ad0612d4 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -188,13 +188,6 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 	list->count = 0;
 	list->dn = NULL;
 
-	/*
-	  if the value is a wildcard then we can't do a match via indexing
-	*/
-	if (ltdb_has_wildcard(module, tree->u.simple.attr, &tree->u.simple.value)) {
-		return -1;
-	}
-
 	/* if the attribute isn't in the list of indexed attributes then
 	   this node needs a full search */
 	if (ldb_msg_find_idx(index_list, tree->u.simple.attr, NULL, LTDB_IDXATTR) == -1) {
@@ -581,6 +574,8 @@ static int ltdb_index_dn(struct ldb_module *module,
 		ret = ltdb_index_dn_leaf(module, tree, index_list, list);
 		break;
 
+	case LDB_OP_PRESENT:
+	case LDB_OP_SUBSTRING:
 	case LDB_OP_EXTENDED:
 		/* we can't index with fancy bitops yet */
 		ret = -1;
@@ -638,7 +633,7 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 		}
 
 		ret = 0;
-		if (ldb_match_message(module->ldb, msg, tree, base, scope) == 1) {
+		if (ldb_match_msg(module->ldb, msg, tree, base, scope) == 1) {
 			ret = ltdb_add_attr_results(module, msg, attrs, &count, res);
 		}
 		talloc_free(msg);
-- 
cgit 


From e835621799647ee70630b389fb53d15b15d68355 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 17 Jul 2005 09:20:52 +0000
Subject: r8520: fixed a pile of warnings from the build farm gcc -Wall output
 on S390. This is an attempt to avoid the panic we're seeing in the automatic
 builds.

The main fixes are:

 - assumptions that sizeof(size_t) == sizeof(int), mostly in printf formats

 - use of NULL format statements to perform dn searches.

 - assumption that sizeof() returns an int
(This used to be commit a58ea6b3854973b694d2b1e22323ed7eb00e3a3f)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 03ad0612d4..87b52ac366 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -131,7 +131,7 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 	}
 
 	ret = talloc_asprintf(ldb, "%s:%s:%.*s", 
-			      LTDB_INDEX, attr_folded, v.length, (char *)v.data);
+			      LTDB_INDEX, attr_folded, (int)v.length, (char *)v.data);
 
 	if (v.data != value->data) {
 		talloc_free(v.data);
-- 
cgit 


From bfb11862698743ee36bc6050269378321e6e577c Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 19 Jul 2005 09:09:00 +0000
Subject: r8585: add to ldb and ldap comparison functionality better pares
 filters Approx is currently only a stub need to dig more info to understand
 what it really means and how it works exactly (This used to be commit
 a9e8cd0bad27ed2b3c6a12302e787ba3c9a70a3c)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 47 ++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 22 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 87b52ac366..1cfebe6864 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -190,13 +190,13 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 
 	/* if the attribute isn't in the list of indexed attributes then
 	   this node needs a full search */
-	if (ldb_msg_find_idx(index_list, tree->u.simple.attr, NULL, LTDB_IDXATTR) == -1) {
+	if (ldb_msg_find_idx(index_list, tree->u.equality.attr, NULL, LTDB_IDXATTR) == -1) {
 		return -1;
 	}
 
 	/* the attribute is indexed. Pull the list of DNs that match the 
 	   search criterion */
-	dn = ldb_dn_key(ldb, tree->u.simple.attr, &tree->u.simple.value);
+	dn = ldb_dn_key(ldb, tree->u.equality.attr, &tree->u.equality.value);
 	if (!dn) return -1;
 
 	msg = talloc(list, struct ldb_message);
@@ -256,7 +256,7 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 	struct ldb_context *ldb = module->ldb;
 	unsigned int i;
 	int ret;
-	const char *target = tree->u.simple.value.data;
+	const char *target = tree->u.equality.value.data;
 	const char **subclasses;
 
 	list->count = 0;
@@ -273,16 +273,16 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 	for (i=0;subclasses[i];i++) {
 		struct ldb_parse_tree tree2;
 		struct dn_list *list2;
-		tree2.operation = LDB_OP_SIMPLE;
-		tree2.u.simple.attr = talloc_strdup(list, LTDB_OBJECTCLASS);
-		if (!tree2.u.simple.attr) {
+		tree2.operation = LDB_OP_EQUALITY;
+		tree2.u.equality.attr = talloc_strdup(list, LTDB_OBJECTCLASS);
+		if (!tree2.u.equality.attr) {
 			return -1;
 		}
-		tree2.u.simple.value.data = talloc_strdup(tree2.u.simple.attr, subclasses[i]);
-		if (tree2.u.simple.value.data == NULL) {
+		tree2.u.equality.value.data = talloc_strdup(tree2.u.equality.attr, subclasses[i]);
+		if (tree2.u.equality.value.data == NULL) {
 			return -1;			
 		}
-		tree2.u.simple.value.length = strlen(subclasses[i]);
+		tree2.u.equality.value.length = strlen(subclasses[i]);
 		list2 = talloc(list, struct dn_list);
 		if (list2 == NULL) {
 			return -1;
@@ -297,7 +297,7 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 				talloc_free(list2);
 			}
 		}
-		talloc_free(tree2.u.simple.attr);
+		talloc_free(tree2.u.equality.attr);
 	}
 
 	return ret;
@@ -311,7 +311,7 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 			      const struct ldb_message *index_list,
 			      struct dn_list *list)
 {
-	if (ldb_attr_cmp(tree->u.simple.attr, LTDB_OBJECTCLASS) == 0) {
+	if (ldb_attr_cmp(tree->u.equality.attr, LTDB_OBJECTCLASS) == 0) {
 		return ltdb_index_dn_objectclass(module, tree, index_list, list);
 	}
 	return ltdb_index_dn_simple(module, tree, index_list, list);
@@ -570,17 +570,6 @@ static int ltdb_index_dn(struct ldb_module *module,
 	int ret = -1;
 
 	switch (tree->operation) {
-	case LDB_OP_SIMPLE:
-		ret = ltdb_index_dn_leaf(module, tree, index_list, list);
-		break;
-
-	case LDB_OP_PRESENT:
-	case LDB_OP_SUBSTRING:
-	case LDB_OP_EXTENDED:
-		/* we can't index with fancy bitops yet */
-		ret = -1;
-		break;
-
 	case LDB_OP_AND:
 		ret = ltdb_index_dn_and(module, tree, index_list, list);
 		break;
@@ -592,6 +581,20 @@ static int ltdb_index_dn(struct ldb_module *module,
 	case LDB_OP_NOT:
 		ret = ltdb_index_dn_not(module, tree, index_list, list);
 		break;
+
+	case LDB_OP_EQUALITY:
+		ret = ltdb_index_dn_leaf(module, tree, index_list, list);
+		break;
+
+	case LDB_OP_SUBSTRING:
+	case LDB_OP_GREATER:
+	case LDB_OP_LESS:
+	case LDB_OP_PRESENT:
+	case LDB_OP_APPROX:
+	case LDB_OP_EXTENDED:
+		/* we can't index with fancy bitops yet */
+		ret = -1;
+		break;
 	}
 
 	return ret;
-- 
cgit 


From eb08c1fc8f877bffeaf63acfbc97ae00a4370a15 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 21 Jul 2005 08:06:39 +0000
Subject: r8668: fixed a segv during upgrade of a very old ldb. Thanks to
 volker for finding this one too. Keep them coming! (This used to be commit
 756796ad2ea86a9471d1b09e66b1a74c4523f6f4)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 1cfebe6864..2fb6c34227 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -1001,6 +1001,11 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	/* check if the DN key has changed, perhaps due to the 
 	   case insensitivity of an element changing */
 	key2 = ltdb_key(module, msg->dn);
+	if (key2.dptr == NULL) {
+		/* probably a corrupt record ... darn */
+		ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Invalid DN in re_index: %s\n", msg->dn);
+		return 0;
+	}
 	if (strcmp(key2.dptr, key.dptr) != 0) {
 		tdb_delete(tdb, key);
 		tdb_store(tdb, key2, data, 0);
-- 
cgit 


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

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 133 ++++++++++++++++++++++++------------
 1 file changed, 90 insertions(+), 43 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 2fb6c34227..f78d840206 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -97,10 +97,11 @@ struct dn_list {
   return the dn key to be used for an index
   caller frees
 */
-static char *ldb_dn_key(struct ldb_context *ldb,
+static struct ldb_dn *ldb_dn_key(struct ldb_context *ldb,
 			const char *attr, const struct ldb_val *value)
 {
-	char *ret = NULL;
+	struct ldb_dn *ret;
+	char *dn;
 	struct ldb_val v;
 	const struct ldb_attrib_handler *h;
 	char *attr_folded;
@@ -121,16 +122,17 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 	if (ldb_should_b64_encode(&v)) {
 		char *vstr = ldb_base64_encode(ldb, v.data, v.length);
 		if (!vstr) return NULL;
-		ret = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
+		dn = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
 		talloc_free(vstr);
 		if (v.data != value->data) {
 			talloc_free(v.data);
 		}
 		talloc_free(attr_folded);
-		return ret;
+		if (dn == NULL) return NULL;
+		goto done;
 	}
 
-	ret = talloc_asprintf(ldb, "%s:%s:%.*s", 
+	dn = talloc_asprintf(ldb, "%s:%s:%.*s", 
 			      LTDB_INDEX, attr_folded, (int)v.length, (char *)v.data);
 
 	if (v.data != value->data) {
@@ -138,6 +140,9 @@ static char *ldb_dn_key(struct ldb_context *ldb,
 	}
 	talloc_free(attr_folded);
 
+done:
+	ret = ldb_dn_explode(ldb, dn);
+	talloc_free(dn);
 	return ret;
 }
 
@@ -180,7 +185,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 				struct dn_list *list)
 {
 	struct ldb_context *ldb = module->ldb;
-	char *dn = NULL;
+	struct ldb_dn *dn;
 	int ret;
 	unsigned int i, j;
 	struct ldb_message *msg;
@@ -605,7 +610,7 @@ static int ltdb_index_dn(struct ldb_module *module,
   extracting just the given attributes
 */
 static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tree,
-			    const char *base,
+			    const struct ldb_dn *base,
 			    enum ldb_scope scope,
 			    const struct dn_list *dn_list, 
 			    const char * const attrs[], struct ldb_message ***res)
@@ -613,8 +618,9 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 	unsigned int i;
 	int count = 0;
 
-	for (i=0;i<dn_list->count;i++) {
+	for (i = 0; i < dn_list->count; i++) {
 		struct ldb_message *msg;
+		struct ldb_dn *dn;
 		int ret;
 
 		msg = talloc(module, struct ldb_message);
@@ -622,7 +628,14 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 			return -1;
 		}
 
-		ret = ltdb_search_dn1(module, dn_list->dn[i], msg);
+		dn = ldb_dn_explode(msg, dn_list->dn[i]);
+		if (dn == NULL) {
+			talloc_free(msg);
+			return -1;
+		}
+
+		ret = ltdb_search_dn1(module, dn, msg);
+		talloc_free(dn);
 		if (ret == 0) {
 			/* the record has disappeared? yes, this can happen */
 			talloc_free(msg);
@@ -654,7 +667,7 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
   case the caller should call ltdb_search_full() 
 */
 int ltdb_search_indexed(struct ldb_module *module, 
-			const char *base,
+			const struct ldb_dn *base,
 			enum ldb_scope scope,
 			struct ldb_parse_tree *tree,
 			const char * const attrs[], struct ldb_message ***res)
@@ -766,33 +779,32 @@ static int ltdb_index_add1(struct ldb_module *module, char *dn,
 {
 	struct ldb_context *ldb = module->ldb;
 	struct ldb_message *msg;
-	char *dn_key;
+	struct ldb_dn *dn_key;
 	int ret;
 	unsigned int i;
 
-	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
-	if (!dn_key) {
+	msg = talloc(module, struct ldb_message);
+	if (msg == NULL) {
+		errno = ENOMEM;
 		return -1;
 	}
 
-	msg = talloc(dn_key, struct ldb_message);
-	if (msg == NULL) {
+	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
+	if (!dn_key) {
+		talloc_free(msg);
+		errno = ENOMEM;
 		return -1;
 	}
+	talloc_steal(msg, dn_key);
 
 	ret = ltdb_search_dn1(module, dn_key, msg);
 	if (ret == -1) {
-		talloc_free(dn_key);
+		talloc_free(msg);
 		return -1;
 	}
 
 	if (ret == 0) {
-		msg->dn = talloc_strdup(msg, dn_key);
-		if (!msg->dn) {
-			talloc_free(dn_key);
-			errno = ENOMEM;
-			return -1;
-		}
+		msg->dn = dn_key;
 		msg->num_elements = 0;
 		msg->elements = NULL;
 	}
@@ -813,22 +825,19 @@ static int ltdb_index_add1(struct ldb_module *module, char *dn,
 		ret = ltdb_store(module, msg, TDB_REPLACE);
 	}
 
-	talloc_free(dn_key);
+	talloc_free(msg);
 
 	return ret;
 }
 
-/*
-  add the index entries for a new record
-  return -1 on failure
-*/
-int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
+static int ltdb_index_add0(struct ldb_module *module, char *dn,
+			   struct ldb_message_element *elements, int num_el)
 {
 	struct ltdb_private *ltdb = module->private_data;
 	int ret;
 	unsigned int i, j;
 
-	if (msg->dn[0] == '@') {
+	if (dn[0] == '@') {
 		return 0;
 	}
 
@@ -837,15 +846,16 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 		return 0;
 	}
 
-	for (i=0;i<msg->num_elements;i++) {
-		ret = ldb_msg_find_idx(ltdb->cache->indexlist, msg->elements[i].name, 
+	for (i = 0; i < num_el; i++) {
+		ret = ldb_msg_find_idx(ltdb->cache->indexlist, elements[i].name, 
 				       NULL, LTDB_IDXATTR);
 		if (ret == -1) {
 			continue;
 		}
-		for (j=0;j<msg->elements[i].num_values;j++) {
-			ret = ltdb_index_add1(module, msg->dn, &msg->elements[i], j);
+		for (j = 0; j < elements[i].num_values; j++) {
+			ret = ltdb_index_add1(module, dn, &elements[i], j);
 			if (ret == -1) {
+				talloc_free(dn);
 				return -1;
 			}
 		}
@@ -854,6 +864,28 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 	return 0;
 }
 
+/*
+  add the index entries for a new record
+  return -1 on failure
+*/
+int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
+{
+	struct ltdb_private *ltdb = module->private_data;
+	char *dn;
+	int ret;
+
+	dn = ldb_dn_linearize(ltdb, msg->dn);
+	if (dn == NULL) {
+		return -1;
+	}
+
+	ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
+
+	talloc_free(dn);
+
+	return ret;
+}
+
 
 /*
   delete an index entry for one message element
@@ -863,7 +895,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 {
 	struct ldb_context *ldb = module->ldb;
 	struct ldb_message *msg;
-	char *dn_key;
+	struct ldb_dn *dn_key;
 	int ret, i;
 	unsigned int j;
 
@@ -897,7 +929,9 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 
 	i = ldb_msg_find_idx(msg, dn, &j, LTDB_IDX);
 	if (i == -1) {
-		ldb_debug(ldb, LDB_DEBUG_ERROR, "ERROR: dn %s not found in %s\n", dn, dn_key);
+		ldb_debug(ldb, LDB_DEBUG_ERROR,
+				"ERROR: dn %s not found in %s\n", dn,
+				ldb_dn_linearize(dn_key, dn_key));
 		/* it ain't there. hmmm */
 		talloc_free(dn_key);
 		return 0;
@@ -930,32 +964,40 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 {
 	struct ltdb_private *ltdb = module->private_data;
 	int ret;
+	char *dn;
 	unsigned int i, j;
 
-	if (msg->dn[0] == '@') {
+	if (ldb_dn_is_special(msg->dn)) {
 		return 0;
 	}
 
+	dn = ldb_dn_linearize(ltdb, msg->dn);
+	if (dn == NULL) {
+		return -1;
+	}
+
 	/* find the list of indexed fields */	
 	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
 		return 0;
 	}
 
-	for (i=0;i<msg->num_elements;i++) {
+	for (i = 0; i < msg->num_elements; i++) {
 		ret = ldb_msg_find_idx(ltdb->cache->indexlist, msg->elements[i].name, 
 				       NULL, LTDB_IDXATTR);
 		if (ret == -1) {
 			continue;
 		}
-		for (j=0;j<msg->elements[i].num_values;j++) {
-			ret = ltdb_index_del_value(module, msg->dn, &msg->elements[i], j);
+		for (j = 0; j < msg->elements[i].num_values; j++) {
+			ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
 			if (ret == -1) {
+				talloc_free(dn);
 				return -1;
 			}
 		}
 	}
 
+	talloc_free(dn);
 	return 0;
 }
 
@@ -979,6 +1021,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 {
 	struct ldb_module *module = state;
 	struct ldb_message *msg;
+	char *dn = NULL;
 	int ret;
 	TDB_DATA key2;
 
@@ -1003,7 +1046,9 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	key2 = ltdb_key(module, msg->dn);
 	if (key2.dptr == NULL) {
 		/* probably a corrupt record ... darn */
-		ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Invalid DN in re_index: %s\n", msg->dn);
+		ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Invalid DN in re_index: %s\n",
+							ldb_dn_linearize(msg, msg->dn));
+		talloc_free(msg);
 		return 0;
 	}
 	if (strcmp(key2.dptr, key.dptr) != 0) {
@@ -1012,11 +1057,13 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	}
 	talloc_free(key2.dptr);
 
-	if (!msg->dn) {
-		msg->dn = key.dptr+3;
+	if (msg->dn == NULL) {
+		dn = key.dptr + 3;
+	} else {
+		dn = ldb_dn_linearize(msg->dn, msg->dn);
 	}
 
-	ret = ltdb_index_add(module, msg);
+	ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
 
 	talloc_free(msg);
 
-- 
cgit 


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index f78d840206..c2a4fb1ea8 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -676,7 +676,8 @@ int ltdb_search_indexed(struct ldb_module *module,
 	struct dn_list *dn_list;
 	int ret;
 
-	if (ltdb->cache->indexlist->num_elements == 0) {
+	if (ltdb->cache->indexlist->num_elements == 0 && 
+	    scope != LDB_SCOPE_BASE) {
 		/* no index list? must do full search */
 		return -1;
 	}
@@ -686,7 +687,18 @@ int ltdb_search_indexed(struct ldb_module *module,
 		return -1;
 	}
 
-	ret = ltdb_index_dn(module, tree, ltdb->cache->indexlist, dn_list);
+	if (scope == LDB_SCOPE_BASE) {
+		/* with BASE searches only one DN can match */
+		char *dn = ldb_dn_linearize(dn_list, base);
+		if (dn == NULL) {
+			return -1;
+		}
+		dn_list->count = 1;
+		dn_list->dn = &dn;
+		ret = 1;
+	} else {
+		ret = ltdb_index_dn(module, tree, ltdb->cache->indexlist, dn_list);
+	}
 
 	if (ret == 1) {
 		/* we've got a candidate list - now filter by the full tree
-- 
cgit 


From a3b33d6fa811dd1277e51e17ba4a4c3954457397 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 11 Oct 2005 04:34:15 +0000
Subject: r10889: make searches for dn's less of a special case, and much
 faster when part of more complex expressions (This used to be commit
 40d304140b4cf22559d6b55c8cbaf1b984baf62f)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index c2a4fb1ea8..7c920dd78b 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -319,6 +319,13 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 	if (ldb_attr_cmp(tree->u.equality.attr, LTDB_OBJECTCLASS) == 0) {
 		return ltdb_index_dn_objectclass(module, tree, index_list, list);
 	}
+	if (ldb_attr_cmp(tree->u.equality.attr, "distinguishedName") == 0 ||
+	    ldb_attr_cmp(tree->u.equality.attr, "dn") == 0) {
+		char *dn = talloc_strdup(list, (char *)tree->u.equality.value.data);
+		list->count = 1;
+		list->dn = &dn;
+		return 1;
+	}
 	return ltdb_index_dn_simple(module, tree, index_list, list);
 }
 
-- 
cgit 


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/ldb_tdb/ldb_index.c | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 7c920dd78b..e80cf74c62 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -120,7 +120,7 @@ static struct ldb_dn *ldb_dn_key(struct ldb_context *ldb,
 		return NULL;
 	}
 	if (ldb_should_b64_encode(&v)) {
-		char *vstr = ldb_base64_encode(ldb, v.data, v.length);
+		char *vstr = ldb_base64_encode(ldb, (char *)v.data, v.length);
 		if (!vstr) return NULL;
 		dn = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
 		talloc_free(vstr);
@@ -261,7 +261,7 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 	struct ldb_context *ldb = module->ldb;
 	unsigned int i;
 	int ret;
-	const char *target = tree->u.equality.value.data;
+	const char *target = (const char *)tree->u.equality.value.data;
 	const char **subclasses;
 
 	list->count = 0;
@@ -279,17 +279,19 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 		struct ldb_parse_tree tree2;
 		struct dn_list *list2;
 		tree2.operation = LDB_OP_EQUALITY;
-		tree2.u.equality.attr = talloc_strdup(list, LTDB_OBJECTCLASS);
+		tree2.u.equality.attr = LTDB_OBJECTCLASS;
 		if (!tree2.u.equality.attr) {
 			return -1;
 		}
-		tree2.u.equality.value.data = talloc_strdup(tree2.u.equality.attr, subclasses[i]);
+		tree2.u.equality.value.data = 
+			(uint8_t *)talloc_strdup(list, subclasses[i]);
 		if (tree2.u.equality.value.data == NULL) {
 			return -1;			
 		}
 		tree2.u.equality.value.length = strlen(subclasses[i]);
 		list2 = talloc(list, struct dn_list);
 		if (list2 == NULL) {
+			talloc_free(tree2.u.equality.value.data);
 			return -1;
 		}
 		if (ltdb_index_dn_objectclass(module, &tree2, 
@@ -302,7 +304,7 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 				talloc_free(list2);
 			}
 		}
-		talloc_free(tree2.u.equality.attr);
+		talloc_free(tree2.u.equality.value.data);
 	}
 
 	return ret;
@@ -747,7 +749,7 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 		return -1;
 	}
 	msg->elements[msg->num_elements].values[0].length = strlen(dn);
-	msg->elements[msg->num_elements].values[0].data = dn;
+	msg->elements[msg->num_elements].values[0].data = (uint8_t *)dn;
 	msg->elements[msg->num_elements].num_values = 1;
 	msg->num_elements++;
 
@@ -770,7 +772,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 
 	/* for multi-valued attributes we can end up with repeats */
 	for (i=0;i<msg->elements[idx].num_values;i++) {
-		if (strcmp(dn, msg->elements[idx].values[i].data) == 0) {
+		if (strcmp(dn, (char *)msg->elements[idx].values[i].data) == 0) {
 			return 0;
 		}
 	}
@@ -784,7 +786,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 	msg->elements[idx].values = v2;
 
 	msg->elements[idx].values[msg->elements[idx].num_values].length = strlen(dn);
-	msg->elements[idx].values[msg->elements[idx].num_values].data = dn;
+	msg->elements[idx].values[msg->elements[idx].num_values].data = (uint8_t *)dn;
 	msg->elements[idx].num_values++;
 
 	return 0;
@@ -1027,7 +1029,7 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
 {
 	const char *dn = "DN=" LTDB_INDEX ":";
-	if (strncmp(key.dptr, dn, strlen(dn)) == 0) {
+	if (strncmp((char *)key.dptr, dn, strlen(dn)) == 0) {
 		return tdb_delete(tdb, key);
 	}
 	return 0;
@@ -1044,8 +1046,8 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	int ret;
 	TDB_DATA key2;
 
-	if (strncmp(key.dptr, "DN=@", 4) == 0 ||
-	    strncmp(key.dptr, "DN=", 3) != 0) {
+	if (strncmp((char *)key.dptr, "DN=@", 4) == 0 ||
+	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
 		return 0;
 	}
 
@@ -1070,14 +1072,14 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		talloc_free(msg);
 		return 0;
 	}
-	if (strcmp(key2.dptr, key.dptr) != 0) {
+	if (strcmp((char *)key2.dptr, (char *)key.dptr) != 0) {
 		tdb_delete(tdb, key);
 		tdb_store(tdb, key2, data, 0);
 	}
 	talloc_free(key2.dptr);
 
 	if (msg->dn == NULL) {
-		dn = key.dptr + 3;
+		dn = (char *)key.dptr + 3;
 	} else {
 		dn = ldb_dn_linearize(msg->dn, msg->dn);
 	}
-- 
cgit 


From 70e73a45d9e473777eb3eecbd3babc397292da71 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 17 Oct 2005 11:27:29 +0000
Subject: r11111: fixed a talloc error in the dn shortcut code (This used to be
 commit e28a334eeb8fa22f686d0c1dc48b2977d85b9e10)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index e80cf74c62..275aadbd78 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -323,9 +323,17 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 	}
 	if (ldb_attr_cmp(tree->u.equality.attr, "distinguishedName") == 0 ||
 	    ldb_attr_cmp(tree->u.equality.attr, "dn") == 0) {
-		char *dn = talloc_strdup(list, (char *)tree->u.equality.value.data);
+		list->dn = talloc_array(list, char *, 1);
+		if (list->dn == NULL) {
+			ldb_oom(module->ldb);
+			return -1;
+		}
+		list->dn[0] = talloc_strdup(list, (char *)tree->u.equality.value.data);
+		if (list->dn[0] == NULL) {
+			ldb_oom(module->ldb);
+			return -1;
+		}
 		list->count = 1;
-		list->dn = &dn;
 		return 1;
 	}
 	return ltdb_index_dn_simple(module, tree, index_list, list);
@@ -698,12 +706,17 @@ int ltdb_search_indexed(struct ldb_module *module,
 
 	if (scope == LDB_SCOPE_BASE) {
 		/* with BASE searches only one DN can match */
-		char *dn = ldb_dn_linearize(dn_list, base);
-		if (dn == NULL) {
+		dn_list->dn = talloc_array(dn_list, char *, 1);
+		if (dn_list->dn == NULL) {
+			ldb_oom(module->ldb);
+			return -1;
+		}
+		dn_list->dn[0] = ldb_dn_linearize(dn_list, base);
+		if (dn_list->dn[0] == NULL) {
+			ldb_oom(module->ldb);
 			return -1;
 		}
 		dn_list->count = 1;
-		dn_list->dn = &dn;
 		ret = 1;
 	} else {
 		ret = ltdb_index_dn(module, tree, ltdb->cache->indexlist, dn_list);
-- 
cgit 


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

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 2 --
 1 file changed, 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 275aadbd78..093b0dab1d 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -1119,14 +1119,12 @@ int ltdb_reindex(struct ldb_module *module)
 	/* first traverse the database deleting any @INDEX records */
 	ret = tdb_traverse(ltdb->tdb, delete_index, NULL);
 	if (ret == -1) {
-		errno = EIO;
 		return -1;
 	}
 
 	/* now traverse adding any indexes for normal LDB records */
 	ret = tdb_traverse(ltdb->tdb, re_index, module);
 	if (ret == -1) {
-		errno = EIO;
 		return -1;
 	}
 
-- 
cgit 


From 804cf59a489dd41a83fda56acfec4e9f561b1245 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 28 Oct 2005 07:05:32 +0000
Subject: r11364: added a ldb_attr_dn() function for testing if an attribute
 name is "dn" or "distinguishedName". This makes us a bit more consistent
 (This used to be commit b41b374b55f9a056c47ffa2ff88aa5272dbc42fc)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 093b0dab1d..de9665cb4d 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -321,8 +321,7 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 	if (ldb_attr_cmp(tree->u.equality.attr, LTDB_OBJECTCLASS) == 0) {
 		return ltdb_index_dn_objectclass(module, tree, index_list, list);
 	}
-	if (ldb_attr_cmp(tree->u.equality.attr, "distinguishedName") == 0 ||
-	    ldb_attr_cmp(tree->u.equality.attr, "dn") == 0) {
+	if (ldb_attr_dn(tree->u.equality.attr) == 0) {
 		list->dn = talloc_array(list, char *, 1);
 		if (list->dn == NULL) {
 			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/ldb_tdb/ldb_index.c | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index de9665cb4d..75514fac83 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -34,6 +34,7 @@
 
 #include "includes.h"
 #include "ldb/include/ldb.h"
+#include "ldb/include/ldb_errors.h"
 #include "ldb/include/ldb_private.h"
 #include "ldb/ldb_tdb/ldb_tdb.h"
 
@@ -629,10 +630,9 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 			    const struct ldb_dn *base,
 			    enum ldb_scope scope,
 			    const struct dn_list *dn_list, 
-			    const char * const attrs[], struct ldb_message ***res)
+			    const char * const attrs[], struct ldb_result *res)
 {
 	unsigned int i;
-	int count = 0;
 
 	for (i = 0; i < dn_list->count; i++) {
 		struct ldb_message *msg;
@@ -641,13 +641,13 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 
 		msg = talloc(module, struct ldb_message);
 		if (msg == NULL) {
-			return -1;
+			return LDB_ERR_OTHER;
 		}
 
 		dn = ldb_dn_explode(msg, dn_list->dn[i]);
 		if (dn == NULL) {
 			talloc_free(msg);
-			return -1;
+			return LDB_ERR_OTHER;
 		}
 
 		ret = ltdb_search_dn1(module, dn, msg);
@@ -661,20 +661,20 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 		if (ret == -1) {
 			/* an internal error */
 			talloc_free(msg);
-			return -1;
+			return LDB_ERR_OTHER;
 		}
 
 		ret = 0;
 		if (ldb_match_msg(module->ldb, msg, tree, base, scope) == 1) {
-			ret = ltdb_add_attr_results(module, msg, attrs, &count, res);
+			ret = ltdb_add_attr_results(module, msg, attrs, &(res->count), &(res->msgs));
 		}
 		talloc_free(msg);
 		if (ret != 0) {
-			return -1;
+			return LDB_ERR_OTHER;
 		}
 	}
 
-	return count;
+	return LDB_SUCCESS;
 }
 
 /*
@@ -686,7 +686,7 @@ int ltdb_search_indexed(struct ldb_module *module,
 			const struct ldb_dn *base,
 			enum ldb_scope scope,
 			struct ldb_parse_tree *tree,
-			const char * const attrs[], struct ldb_message ***res)
+			const char * const attrs[], struct ldb_result **res)
 {
 	struct ltdb_private *ltdb = module->private_data;
 	struct dn_list *dn_list;
@@ -703,6 +703,13 @@ int ltdb_search_indexed(struct ldb_module *module,
 		return -1;
 	}
 
+	*res = talloc(module, struct ldb_result);
+	if (*res == NULL) {
+		return LDB_ERR_OTHER;
+	}
+	(*res)->count = 0;
+	(*res)->msgs = NULL;
+
 	if (scope == LDB_SCOPE_BASE) {
 		/* with BASE searches only one DN can match */
 		dn_list->dn = talloc_array(dn_list, char *, 1);
@@ -725,7 +732,7 @@ int ltdb_search_indexed(struct ldb_module *module,
 		/* we've got a candidate list - now filter by the full tree
 		   and extract the needed attributes */
 		ret = ldb_index_filter(module, tree, base, scope, dn_list, 
-				       attrs, res);
+				       attrs, *res);
 	}
 
 	talloc_free(dn_list);
-- 
cgit 


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

Simo.
(This used to be commit 77125feaff252cab44d26593093a9c211c846ce8)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 75514fac83..cf9ad3b7fe 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -709,6 +709,7 @@ int ltdb_search_indexed(struct ldb_module *module,
 	}
 	(*res)->count = 0;
 	(*res)->msgs = NULL;
+	(*res)->controls = NULL;
 
 	if (scope == LDB_SCOPE_BASE) {
 		/* with BASE searches only one DN can match */
-- 
cgit 


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

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

metze
(This used to be commit 380938e97f31c7860aed1e73cc0110c6e17b472e)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index cf9ad3b7fe..93d0ebd6e9 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -33,9 +33,8 @@
  */
 
 #include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
+#include "ldb/include/includes.h"
+
 #include "ldb/ldb_tdb/ldb_tdb.h"
 
 /*
-- 
cgit 


From b60415745a0038dbfdca752861201fba0d942ff6 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 31 Jan 2006 11:16:43 +0000
Subject: r13258: Fix the talloc heirachy for ldb_tdb.

In the return value res->msgs, msgs was not a child of res, in the
indexed path.  Instead, it hung directly off the ldb, which was
sometimes a long-term context.

Also remove unused parameters.

Found by --leak-report-full

Andrew Bartlett
(This used to be commit 29cb5af827c459758997c80dca034d471bb92449)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 93d0ebd6e9..c74ce62fbf 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -665,7 +665,8 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
 
 		ret = 0;
 		if (ldb_match_msg(module->ldb, msg, tree, base, scope) == 1) {
-			ret = ltdb_add_attr_results(module, msg, attrs, &(res->count), &(res->msgs));
+			ret = ltdb_add_attr_results(module, res, msg, 
+						    attrs, &(res->count), &(res->msgs));
 		}
 		talloc_free(msg);
 		if (ret != 0) {
-- 
cgit 


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

Next comes code to register samba internal utf8 functions.

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index c74ce62fbf..fb29a9ddbf 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -106,7 +106,7 @@ static struct ldb_dn *ldb_dn_key(struct ldb_context *ldb,
 	const struct ldb_attrib_handler *h;
 	char *attr_folded;
 
-	attr_folded = ldb_casefold(ldb, attr);
+	attr_folded = ldb_casefold(ldb, ldb, attr);
 	if (!attr_folded) {
 		return NULL;
 	}
-- 
cgit 


From 04396c36d3ee8300b2b73ea8b43a45ea1b250828 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 4 Feb 2006 06:57:28 +0000
Subject: r13333: revert previous commit I will use ldb_caseless_cmp in
 attrib_handlers to correctly support utf8 comparisons

add an ldb_attr_Casefold function for attribute names and use it
instead of casefold in the right places
(This used to be commit 3b4eb2413bbce059dde69f35c03cdc3cc2ba85c5)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index fb29a9ddbf..ac3063ef28 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -106,7 +106,7 @@ static struct ldb_dn *ldb_dn_key(struct ldb_context *ldb,
 	const struct ldb_attrib_handler *h;
 	char *attr_folded;
 
-	attr_folded = ldb_casefold(ldb, ldb, attr);
+	attr_folded = ldb_attr_casefold(ldb, ldb, attr);
 	if (!attr_folded) {
 		return NULL;
 	}
-- 
cgit 


From 3ba24e4a35156a36f900cdbdbbef770861e9c7eb Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 4 Feb 2006 07:57:57 +0000
Subject: r13335: Fix the build and add an utf8 safe ldb_hadler_fold function
 based on ldb_casefold (This used to be commit
 6104f900863c688707809d42c5429a42d654d5fb)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index ac3063ef28..5c601f9ea8 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -106,7 +106,7 @@ static struct ldb_dn *ldb_dn_key(struct ldb_context *ldb,
 	const struct ldb_attrib_handler *h;
 	char *attr_folded;
 
-	attr_folded = ldb_attr_casefold(ldb, ldb, attr);
+	attr_folded = ldb_attr_casefold(ldb, attr);
 	if (!attr_folded) {
 		return NULL;
 	}
-- 
cgit 


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

Modules will need to be transformed along the way.

Simo
(This used to be commit 1e2c13b2d52de7c534493dd79a2c0596a3e8c1f5)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 5c601f9ea8..b1b82d0360 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -709,6 +709,7 @@ int ltdb_search_indexed(struct ldb_module *module,
 	}
 	(*res)->count = 0;
 	(*res)->msgs = NULL;
+	(*res)->refs = NULL;
 	(*res)->controls = NULL;
 
 	if (scope == LDB_SCOPE_BASE) {
-- 
cgit 


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

Simo.
(This used to be commit 0db616ef59ed51cac7e0bfaea8a799d5aa42ef16)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 106 ++++++++++++++++++++----------------
 1 file changed, 59 insertions(+), 47 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index b1b82d0360..2fc20adb30 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -625,52 +625,75 @@ static int ltdb_index_dn(struct ldb_module *module,
   filter a candidate dn_list from an indexed search into a set of results
   extracting just the given attributes
 */
-static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tree,
-			    const struct ldb_dn *base,
-			    enum ldb_scope scope,
-			    const struct dn_list *dn_list, 
-			    const char * const attrs[], struct ldb_result *res)
+static int ltdb_index_filter(const struct dn_list *dn_list, 
+			     struct ldb_async_handle *handle)
 {
+	struct ltdb_async_context *ac = talloc_get_type(handle->private_data, struct ltdb_async_context);
+	struct ldb_async_result *ares = NULL;
 	unsigned int i;
 
 	for (i = 0; i < dn_list->count; i++) {
-		struct ldb_message *msg;
 		struct ldb_dn *dn;
 		int ret;
 
-		msg = talloc(module, struct ldb_message);
-		if (msg == NULL) {
-			return LDB_ERR_OTHER;
+		ares = talloc_zero(ac, struct ldb_async_result);
+		if (!ares) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			handle->state = LDB_ASYNC_DONE;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
-		dn = ldb_dn_explode(msg, dn_list->dn[i]);
+		ares->message = ldb_msg_new(ares);
+		if (!ares->message) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			handle->state = LDB_ASYNC_DONE;
+			talloc_free(ares);
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+
+
+		dn = ldb_dn_explode(ares->message, dn_list->dn[i]);
 		if (dn == NULL) {
-			talloc_free(msg);
-			return LDB_ERR_OTHER;
+			talloc_free(ares);
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
-		ret = ltdb_search_dn1(module, dn, msg);
+		ret = ltdb_search_dn1(ac->module, dn, ares->message);
 		talloc_free(dn);
 		if (ret == 0) {
 			/* the record has disappeared? yes, this can happen */
-			talloc_free(msg);
+			talloc_free(ares);
 			continue;
 		}
 
 		if (ret == -1) {
 			/* an internal error */
-			talloc_free(msg);
-			return LDB_ERR_OTHER;
+			talloc_free(ares);
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
-		ret = 0;
-		if (ldb_match_msg(module->ldb, msg, tree, base, scope) == 1) {
-			ret = ltdb_add_attr_results(module, res, msg, 
-						    attrs, &(res->count), &(res->msgs));
+		if (!ldb_match_msg(ac->module->ldb, ares->message, ac->tree, ac->base, ac->scope)) {
+			talloc_free(ares);
+			continue;
 		}
-		talloc_free(msg);
-		if (ret != 0) {
-			return LDB_ERR_OTHER;
+
+		/* filter the attributes that the user wants */
+		ret = ltdb_filter_attrs(ares->message, ac->attrs);
+
+		if (ret == -1) {
+			handle->status = LDB_ERR_OPERATIONS_ERROR;
+			handle->state = LDB_ASYNC_DONE;
+			talloc_free(ares);
+			return LDB_ERR_OPERATIONS_ERROR;
+		}
+
+		ares->type = LDB_REPLY_ENTRY;
+        	handle->state = LDB_ASYNC_PENDING;
+		handle->status = ac->callback(ac->module->ldb, ac->context, ares);
+
+		if (handle->status != LDB_SUCCESS) {
+			handle->state = LDB_ASYNC_DONE;
+			return handle->status;
 		}
 	}
 
@@ -682,59 +705,48 @@ static int ldb_index_filter(struct ldb_module *module, struct ldb_parse_tree *tr
   returns -1 if an indexed search is not possible, in which
   case the caller should call ltdb_search_full() 
 */
-int ltdb_search_indexed(struct ldb_module *module, 
-			const struct ldb_dn *base,
-			enum ldb_scope scope,
-			struct ldb_parse_tree *tree,
-			const char * const attrs[], struct ldb_result **res)
+int ltdb_search_indexed(struct ldb_async_handle *handle)
 {
-	struct ltdb_private *ltdb = module->private_data;
+	struct ltdb_async_context *ac = talloc_get_type(handle->private_data, struct ltdb_async_context);
+	struct ltdb_private *ltdb = talloc_get_type(ac->module->private_data, struct ltdb_private);
 	struct dn_list *dn_list;
 	int ret;
 
 	if (ltdb->cache->indexlist->num_elements == 0 && 
-	    scope != LDB_SCOPE_BASE) {
+	    ac->scope != LDB_SCOPE_BASE) {
 		/* no index list? must do full search */
 		return -1;
 	}
 
-	dn_list = talloc(module, struct dn_list);
+	dn_list = talloc(handle, struct dn_list);
 	if (dn_list == NULL) {
 		return -1;
 	}
 
-	*res = talloc(module, struct ldb_result);
-	if (*res == NULL) {
-		return LDB_ERR_OTHER;
-	}
-	(*res)->count = 0;
-	(*res)->msgs = NULL;
-	(*res)->refs = NULL;
-	(*res)->controls = NULL;
-
-	if (scope == LDB_SCOPE_BASE) {
+	if (ac->scope == LDB_SCOPE_BASE) {
 		/* with BASE searches only one DN can match */
 		dn_list->dn = talloc_array(dn_list, char *, 1);
 		if (dn_list->dn == NULL) {
-			ldb_oom(module->ldb);
+			ldb_oom(ac->module->ldb);
 			return -1;
 		}
-		dn_list->dn[0] = ldb_dn_linearize(dn_list, base);
+		dn_list->dn[0] = ldb_dn_linearize(dn_list, ac->base);
 		if (dn_list->dn[0] == NULL) {
-			ldb_oom(module->ldb);
+			ldb_oom(ac->module->ldb);
 			return -1;
 		}
 		dn_list->count = 1;
 		ret = 1;
 	} else {
-		ret = ltdb_index_dn(module, tree, ltdb->cache->indexlist, dn_list);
+		ret = ltdb_index_dn(ac->module, ac->tree, ltdb->cache->indexlist, dn_list);
 	}
 
 	if (ret == 1) {
 		/* we've got a candidate list - now filter by the full tree
 		   and extract the needed attributes */
-		ret = ldb_index_filter(module, tree, base, scope, dn_list, 
-				       attrs, *res);
+		ret = ltdb_index_filter(dn_list, handle);
+		handle->status = ret;
+		handle->state = LDB_ASYNC_DONE;
 	}
 
 	talloc_free(dn_list);
-- 
cgit 


From 737d05bfb3538ac33a81efc2f3d8dfaa35a6ef86 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 15 Mar 2006 05:50:42 +0000
Subject: r14431: don't call qsort with a null array (This used to be commit
 2c33f577ad5bf8cddec735e75a26c4a4c07d8c51)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 2fc20adb30..e2a3201884 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -241,7 +241,9 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 
 	talloc_free(msg);
 
-	qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
+	if (list->count > 1) {
+		qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
+	}
 
 	return 1;
 }
-- 
cgit 


From e29e30d0688afaaf9d7c26972e82dcb4b3788ccd Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 11 Jul 2006 03:46:22 +0000
Subject: r16937: Add const, to make it clear that it is invalid to
 talloc_free() the DN at this point.

Andrew Bartlett
(This used to be commit f7fb168ab69e39ab3ff236bb5db4e5306a79971d)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index e2a3201884..3473ed3ac1 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -762,7 +762,7 @@ int ltdb_search_indexed(struct ldb_async_handle *handle)
 static int ltdb_index_add1_new(struct ldb_context *ldb, 
 			       struct ldb_message *msg,
 			       struct ldb_message_element *el,
-			       char *dn)
+			       const char *dn)
 {
 	struct ldb_message_element *el2;
 
@@ -784,7 +784,7 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 		return -1;
 	}
 	msg->elements[msg->num_elements].values[0].length = strlen(dn);
-	msg->elements[msg->num_elements].values[0].data = (uint8_t *)dn;
+	msg->elements[msg->num_elements].values[0].data = discard_const_p(uint8_t, dn);
 	msg->elements[msg->num_elements].num_values = 1;
 	msg->num_elements++;
 
@@ -800,7 +800,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 			       struct ldb_message *msg,
 			       struct ldb_message_element *el,
 			       int idx,
-			       char *dn)
+			       const char *dn)
 {
 	struct ldb_val *v2;
 	unsigned int i;
@@ -821,7 +821,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 	msg->elements[idx].values = v2;
 
 	msg->elements[idx].values[msg->elements[idx].num_values].length = strlen(dn);
-	msg->elements[idx].values[msg->elements[idx].num_values].data = (uint8_t *)dn;
+	msg->elements[idx].values[msg->elements[idx].num_values].data = discard_const_p(uint8_t, dn);
 	msg->elements[idx].num_values++;
 
 	return 0;
@@ -830,7 +830,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 /*
   add an index entry for one message element
 */
-static int ltdb_index_add1(struct ldb_module *module, char *dn, 
+static int ltdb_index_add1(struct ldb_module *module, const char *dn, 
 			   struct ldb_message_element *el, int v_idx)
 {
 	struct ldb_context *ldb = module->ldb;
@@ -886,7 +886,7 @@ static int ltdb_index_add1(struct ldb_module *module, char *dn,
 	return ret;
 }
 
-static int ltdb_index_add0(struct ldb_module *module, char *dn,
+static int ltdb_index_add0(struct ldb_module *module, const char *dn,
 			   struct ldb_message_element *elements, int num_el)
 {
 	struct ltdb_private *ltdb = module->private_data;
@@ -911,7 +911,6 @@ static int ltdb_index_add0(struct ldb_module *module, char *dn,
 		for (j = 0; j < elements[i].num_values; j++) {
 			ret = ltdb_index_add1(module, dn, &elements[i], j);
 			if (ret == -1) {
-				talloc_free(dn);
 				return -1;
 			}
 		}
-- 
cgit 


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

Simo.
(This used to be commit 25fc7354049d62efeba17681ef1cdd326bc3f2ef)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 3473ed3ac1..7b67db33d3 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -628,17 +628,17 @@ static int ltdb_index_dn(struct ldb_module *module,
   extracting just the given attributes
 */
 static int ltdb_index_filter(const struct dn_list *dn_list, 
-			     struct ldb_async_handle *handle)
+			     struct ldb_handle *handle)
 {
-	struct ltdb_async_context *ac = talloc_get_type(handle->private_data, struct ltdb_async_context);
-	struct ldb_async_result *ares = NULL;
+	struct ltdb_context *ac = talloc_get_type(handle->private_data, struct ltdb_context);
+	struct ldb_reply *ares = NULL;
 	unsigned int i;
 
 	for (i = 0; i < dn_list->count; i++) {
 		struct ldb_dn *dn;
 		int ret;
 
-		ares = talloc_zero(ac, struct ldb_async_result);
+		ares = talloc_zero(ac, struct ldb_reply);
 		if (!ares) {
 			handle->status = LDB_ERR_OPERATIONS_ERROR;
 			handle->state = LDB_ASYNC_DONE;
@@ -707,9 +707,9 @@ static int ltdb_index_filter(const struct dn_list *dn_list,
   returns -1 if an indexed search is not possible, in which
   case the caller should call ltdb_search_full() 
 */
-int ltdb_search_indexed(struct ldb_async_handle *handle)
+int ltdb_search_indexed(struct ldb_handle *handle)
 {
-	struct ltdb_async_context *ac = talloc_get_type(handle->private_data, struct ltdb_async_context);
+	struct ltdb_context *ac = talloc_get_type(handle->private_data, struct ltdb_context);
 	struct ltdb_private *ltdb = talloc_get_type(ac->module->private_data, struct ltdb_private);
 	struct dn_list *dn_list;
 	int ret;
-- 
cgit 


From cc973cbd7776ba03a08047ca7e6bef7700bbf37d Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 22 Aug 2006 18:09:49 +0000
Subject: r17711: fix compiler warnings

metze
(This used to be commit f3dc51fef53287cc2e2af7ed4a9f3f52a5cd06ed)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 7b67db33d3..c6feeaeb42 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -180,7 +180,7 @@ static int list_cmp(const char **s1, const char **s2)
   return a list of dn's that might match a simple indexed search or
  */
 static int ltdb_index_dn_simple(struct ldb_module *module, 
-				struct ldb_parse_tree *tree,
+				const struct ldb_parse_tree *tree,
 				const struct ldb_message *index_list,
 				struct dn_list *list)
 {
@@ -256,7 +256,7 @@ static int list_union(struct ldb_context *, struct dn_list *, const struct dn_li
   the special objectclass attribute
  */
 static int ltdb_index_dn_objectclass(struct ldb_module *module, 
-				     struct ldb_parse_tree *tree,
+				     const struct ldb_parse_tree *tree,
 				     const struct ldb_message *index_list,
 				     struct dn_list *list)
 {
@@ -316,7 +316,7 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
   return a list of dn's that might match a leaf indexed search
  */
 static int ltdb_index_dn_leaf(struct ldb_module *module, 
-			      struct ldb_parse_tree *tree,
+			      const struct ldb_parse_tree *tree,
 			      const struct ldb_message *index_list,
 			      struct dn_list *list)
 {
@@ -430,7 +430,7 @@ static int list_union(struct ldb_context *ldb,
 }
 
 static int ltdb_index_dn(struct ldb_module *module, 
-			 struct ldb_parse_tree *tree,
+			 const struct ldb_parse_tree *tree,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list);
 
@@ -439,7 +439,7 @@ static int ltdb_index_dn(struct ldb_module *module,
   OR two index results
  */
 static int ltdb_index_dn_or(struct ldb_module *module, 
-			    struct ldb_parse_tree *tree,
+			    const struct ldb_parse_tree *tree,
 			    const struct ldb_message *index_list,
 			    struct dn_list *list)
 {
@@ -504,7 +504,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
   NOT an index results
  */
 static int ltdb_index_dn_not(struct ldb_module *module, 
-			     struct ldb_parse_tree *tree,
+			     const struct ldb_parse_tree *tree,
 			     const struct ldb_message *index_list,
 			     struct dn_list *list)
 {
@@ -523,7 +523,7 @@ static int ltdb_index_dn_not(struct ldb_module *module,
   AND two index results
  */
 static int ltdb_index_dn_and(struct ldb_module *module, 
-			     struct ldb_parse_tree *tree,
+			     const struct ldb_parse_tree *tree,
 			     const struct ldb_message *index_list,
 			     struct dn_list *list)
 {
@@ -586,7 +586,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
   -1 if an error. return 0 for no matches, or 1 for matches
  */
 static int ltdb_index_dn(struct ldb_module *module, 
-			 struct ldb_parse_tree *tree,
+			 const struct ldb_parse_tree *tree,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list)
 {
-- 
cgit 


From 78525245329a627460db6bbcfd85f29bff2ff373 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 23 Aug 2006 11:29:08 +0000
Subject: r17748: make the casts much easier to understand

metze
(This used to be commit 5992f3b918967ff478ad24333cfe583e0b14a4c9)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index c6feeaeb42..03dfe693ac 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -61,11 +61,11 @@ static int ldb_list_find(const void *needle,
 		int r;
 
 		test_i = (min_i + max_i) / 2;
-		r = comp_fn(needle, *(void * const *)(base_p + (size * test_i)));
+		r = comp_fn(needle, (const void *)(base_p + (size * test_i)));
 		if (r == 0) {
 			/* scan back for first element */
 			while (test_i > 0 &&
-			       comp_fn(needle, *(void * const *)(base_p + (size * (test_i-1)))) == 0) {
+			       comp_fn(needle, (const void *)(base_p + (size * (test_i-1)))) == 0) {
 				test_i--;
 			}
 			return test_i;
@@ -81,7 +81,7 @@ static int ldb_list_find(const void *needle,
 		}
 	}
 
-	if (comp_fn(needle, *(void * const *)(base_p + (size * min_i))) == 0) {
+	if (comp_fn(needle, (const void *)(base_p + (size * min_i))) == 0) {
 		return min_i;
 	}
 
-- 
cgit 


From 48c7cfcb749f2df1500339c1046854721f8a1a7e Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 23 Aug 2006 14:48:19 +0000
Subject: r17756: I don't know why but this only works with the standalone ldb
 build...I'll test more tomorrow.

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 03dfe693ac..c6feeaeb42 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -61,11 +61,11 @@ static int ldb_list_find(const void *needle,
 		int r;
 
 		test_i = (min_i + max_i) / 2;
-		r = comp_fn(needle, (const void *)(base_p + (size * test_i)));
+		r = comp_fn(needle, *(void * const *)(base_p + (size * test_i)));
 		if (r == 0) {
 			/* scan back for first element */
 			while (test_i > 0 &&
-			       comp_fn(needle, (const void *)(base_p + (size * (test_i-1)))) == 0) {
+			       comp_fn(needle, *(void * const *)(base_p + (size * (test_i-1)))) == 0) {
 				test_i--;
 			}
 			return test_i;
@@ -81,7 +81,7 @@ static int ldb_list_find(const void *needle,
 		}
 	}
 
-	if (comp_fn(needle, (const void *)(base_p + (size * min_i))) == 0) {
+	if (comp_fn(needle, *(void * const *)(base_p + (size * min_i))) == 0) {
 		return min_i;
 	}
 
-- 
cgit 


From 66337169f13592c85b15d18115893f5c8a53f866 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 24 Aug 2006 07:20:32 +0000
Subject: r17771: add a comment explaing the odd cast (This used to be commit
 47e695ed88d364a7d423e804fe5340006ebf7c18)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index c6feeaeb42..b628c31b09 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -61,6 +61,12 @@ static int ldb_list_find(const void *needle,
 		int r;
 
 		test_i = (min_i + max_i) / 2;
+		/* the following cast looks strange, but is
+		 correct. The key to understanding it is that base_p
+		 is a pointer to an array of pointers, so we have to
+		 dereference it after casting to void **. The strange
+		 const in the middle gives us the right type of pointer
+		 after the dereference  (tridge) */
 		r = comp_fn(needle, *(void * const *)(base_p + (size * test_i)));
 		if (r == 0) {
 			/* scan back for first element */
-- 
cgit 


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index b628c31b09..f2816ec1da 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -378,7 +378,7 @@ static int list_intersect(struct ldb_context *ldb,
 	for (i=0;i<list->count;i++) {
 		if (ldb_list_find(list->dn[i], list2->dn, list2->count, 
 			      sizeof(char *), (comparison_fn_t)strcmp) != -1) {
-			list3->dn[list3->count] = talloc_steal(list3->dn, list->dn[i]);
+			list3->dn[list3->count] = talloc_move(list3->dn, list->dn[i]);
 			list3->count++;
 		} else {
 			talloc_free(list->dn[i]);
@@ -386,7 +386,7 @@ static int list_intersect(struct ldb_context *ldb,
 	}
 
 	talloc_free(list->dn);
-	list->dn = talloc_steal(list, list3->dn);
+	list->dn = talloc_move(list, list3->dn);
 	list->count = list3->count;
 	talloc_free(list3);
 
@@ -486,7 +486,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 
 		if (ret == -1) {
 			ret = 1;
-			list->dn = talloc_steal(list, list2->dn);
+			list->dn = talloc_move(list, list2->dn);
 			list->count = list2->count;
 		} else {
 			if (list_union(ldb, list, list2) == -1) {
@@ -567,7 +567,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 		if (ret == -1) {
 			ret = 1;
 			talloc_free(list->dn);
-			list->dn = talloc_steal(list, list2->dn);
+			list->dn = talloc_move(list, list2->dn);
 			list->count = list2->count;
 		} else {
 			if (list_intersect(ldb, list, list2) == -1) {
-- 
cgit 


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index f2816ec1da..59c1645ba8 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -378,7 +378,7 @@ static int list_intersect(struct ldb_context *ldb,
 	for (i=0;i<list->count;i++) {
 		if (ldb_list_find(list->dn[i], list2->dn, list2->count, 
 			      sizeof(char *), (comparison_fn_t)strcmp) != -1) {
-			list3->dn[list3->count] = talloc_move(list3->dn, list->dn[i]);
+			list3->dn[list3->count] = talloc_move(list3->dn, &list->dn[i]);
 			list3->count++;
 		} else {
 			talloc_free(list->dn[i]);
@@ -386,7 +386,7 @@ static int list_intersect(struct ldb_context *ldb,
 	}
 
 	talloc_free(list->dn);
-	list->dn = talloc_move(list, list3->dn);
+	list->dn = talloc_move(list, &list3->dn);
 	list->count = list3->count;
 	talloc_free(list3);
 
@@ -486,7 +486,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 
 		if (ret == -1) {
 			ret = 1;
-			list->dn = talloc_move(list, list2->dn);
+			list->dn = talloc_move(list, &list2->dn);
 			list->count = list2->count;
 		} else {
 			if (list_union(ldb, list, list2) == -1) {
@@ -567,7 +567,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 		if (ret == -1) {
 			ret = 1;
 			talloc_free(list->dn);
-			list->dn = talloc_move(list, list2->dn);
+			list->dn = talloc_move(list, &list2->dn);
 			list->count = list2->count;
 		} else {
 			if (list_intersect(ldb, list, list2) == -1) {
-- 
cgit 


From 31e50ccae79e5ab4c292bf85fb1cec1b0babfa26 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 6 Oct 2006 06:52:30 +0000
Subject: r19114: fixed another checker warning and a possible error on
 allocation failure (This used to be commit
 bc02f7ef96e164a59441e3fd9429221be83fc7e4)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 59c1645ba8..8a9a82a98c 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -232,13 +232,15 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 
 		list->dn = talloc_array(list, char *, el->num_values);
 		if (!list->dn) {
-			break;		
+			talloc_free(msg);
+			return -1;
 		}
 
 		for (j=0;j<el->num_values;j++) {
 			list->dn[list->count] = 
 				talloc_strdup(list->dn, (char *)el->values[j].data);
 			if (!list->dn[list->count]) {
+				talloc_free(msg);
 				return -1;
 			}
 			list->count++;
-- 
cgit 


From 91c33d44b61ee775534ab723e20e6ea4070309b7 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 16 Oct 2006 10:12:43 +0000
Subject: r19324: fixed a leak on deleting records when no index is in place
 (This used to be commit 0824b3b8c1003064b0f2c5a3f084f3e711155e8c)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 8a9a82a98c..0c9d1f33a1 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -1030,6 +1030,12 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 	char *dn;
 	unsigned int i, j;
 
+	/* find the list of indexed fields */	
+	if (ltdb->cache->indexlist->num_elements == 0) {
+		/* no indexed fields */
+		return 0;
+	}
+
 	if (ldb_dn_is_special(msg->dn)) {
 		return 0;
 	}
@@ -1039,12 +1045,6 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 		return -1;
 	}
 
-	/* find the list of indexed fields */	
-	if (ltdb->cache->indexlist->num_elements == 0) {
-		/* no indexed fields */
-		return 0;
-	}
-
 	for (i = 0; i < msg->num_elements; i++) {
 		ret = ldb_msg_find_idx(ltdb->cache->indexlist, msg->elements[i].name, 
 				       NULL, LTDB_IDXATTR);
-- 
cgit 


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

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

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

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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 0c9d1f33a1..874d047186 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -147,7 +147,7 @@ static struct ldb_dn *ldb_dn_key(struct ldb_context *ldb,
 	talloc_free(attr_folded);
 
 done:
-	ret = ldb_dn_explode(ldb, dn);
+	ret = ldb_dn_new(ldb, ldb, dn);
 	talloc_free(dn);
 	return ret;
 }
@@ -662,7 +662,7 @@ static int ltdb_index_filter(const struct dn_list *dn_list,
 		}
 
 
-		dn = ldb_dn_explode(ares->message, dn_list->dn[i]);
+		dn = ldb_dn_new(ares->message, ac->module->ldb, dn_list->dn[i]);
 		if (dn == NULL) {
 			talloc_free(ares);
 			return LDB_ERR_OPERATIONS_ERROR;
-- 
cgit 


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

- ldb_dn_get_linearized
  returns a const string

- ldb_dn_alloc_linearized
  allocs astring with the linearized dn
(This used to be commit 3929c086d5d0b3f08b1c4f2f3f9602c3f4a9a4bd)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 874d047186..8b90604902 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -740,7 +740,7 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 			ldb_oom(ac->module->ldb);
 			return -1;
 		}
-		dn_list->dn[0] = ldb_dn_linearize(dn_list, ac->base);
+		dn_list->dn[0] = ldb_dn_alloc_linearized(dn_list, ac->base);
 		if (dn_list->dn[0] == NULL) {
 			ldb_oom(ac->module->ldb);
 			return -1;
@@ -933,19 +933,16 @@ static int ltdb_index_add0(struct ldb_module *module, const char *dn,
 */
 int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 {
-	struct ltdb_private *ltdb = module->private_data;
-	char *dn;
+	const char *dn;
 	int ret;
 
-	dn = ldb_dn_linearize(ltdb, msg->dn);
+	dn = ldb_dn_get_linearized(msg->dn);
 	if (dn == NULL) {
 		return -1;
 	}
 
 	ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
 
-	talloc_free(dn);
-
 	return ret;
 }
 
@@ -994,7 +991,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 	if (i == -1) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR,
 				"ERROR: dn %s not found in %s\n", dn,
-				ldb_dn_linearize(dn_key, dn_key));
+				ldb_dn_get_linearized(dn_key));
 		/* it ain't there. hmmm */
 		talloc_free(dn_key);
 		return 0;
@@ -1027,7 +1024,7 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 {
 	struct ltdb_private *ltdb = module->private_data;
 	int ret;
-	char *dn;
+	const char *dn;
 	unsigned int i, j;
 
 	/* find the list of indexed fields */	
@@ -1040,7 +1037,7 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 		return 0;
 	}
 
-	dn = ldb_dn_linearize(ltdb, msg->dn);
+	dn = ldb_dn_get_linearized(msg->dn);
 	if (dn == NULL) {
 		return -1;
 	}
@@ -1054,13 +1051,11 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 		for (j = 0; j < msg->elements[i].num_values; j++) {
 			ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
 			if (ret == -1) {
-				talloc_free(dn);
 				return -1;
 			}
 		}
 	}
 
-	talloc_free(dn);
 	return 0;
 }
 
@@ -1084,7 +1079,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 {
 	struct ldb_module *module = state;
 	struct ldb_message *msg;
-	char *dn = NULL;
+	const char *dn = NULL;
 	int ret;
 	TDB_DATA key2;
 
@@ -1110,7 +1105,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	if (key2.dptr == NULL) {
 		/* probably a corrupt record ... darn */
 		ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Invalid DN in re_index: %s\n",
-							ldb_dn_linearize(msg, msg->dn));
+							ldb_dn_get_linearized(msg->dn));
 		talloc_free(msg);
 		return 0;
 	}
@@ -1123,7 +1118,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	if (msg->dn == NULL) {
 		dn = (char *)key.dptr + 3;
 	} else {
-		dn = ldb_dn_linearize(msg->dn, msg->dn);
+		dn = ldb_dn_get_linearized(msg->dn);
 	}
 
 	ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
-- 
cgit 


From 2ad51046e3becd5257d7bb25c0dc43be13172809 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 25 Nov 2006 14:49:17 +0000
Subject: r19884: rename ldb_dn_key -> ltdb_index_key to make more clear what
 it's for...

metze
(This used to be commit 6b76a7be4ac5443d68a1253dc9ec430dcdc327f1)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 8b90604902..872afb78ae 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -103,8 +103,8 @@ struct dn_list {
   return the dn key to be used for an index
   caller frees
 */
-static struct ldb_dn *ldb_dn_key(struct ldb_context *ldb,
-			const char *attr, const struct ldb_val *value)
+static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
+				     const char *attr, const struct ldb_val *value)
 {
 	struct ldb_dn *ret;
 	char *dn;
@@ -207,7 +207,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 
 	/* the attribute is indexed. Pull the list of DNs that match the 
 	   search criterion */
-	dn = ldb_dn_key(ldb, tree->u.equality.attr, &tree->u.equality.value);
+	dn = ltdb_index_key(ldb, tree->u.equality.attr, &tree->u.equality.value);
 	if (!dn) return -1;
 
 	msg = talloc(list, struct ldb_message);
@@ -853,7 +853,7 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 		return -1;
 	}
 
-	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
+	dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		talloc_free(msg);
 		errno = ENOMEM;
@@ -963,7 +963,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 		return 0;
 	}
 
-	dn_key = ldb_dn_key(ldb, el->name, &el->values[v_idx]);
+	dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		return -1;
 	}
-- 
cgit 


From baa8ed20153883ba2c5cfb5211cd1255b38b6a20 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 26 Nov 2006 03:59:01 +0000
Subject: r19905: use ldb_dn_new_fmt() to avoid double strdups (This used to be
 commit 32a6b6c75b041bf829ecf272a9b10164f7ffe12b)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 872afb78ae..045be985a4 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -107,7 +107,6 @@ static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 				     const char *attr, const struct ldb_val *value)
 {
 	struct ldb_dn *ret;
-	char *dn;
 	struct ldb_val v;
 	const struct ldb_attrib_handler *h;
 	char *attr_folded;
@@ -128,27 +127,17 @@ static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 	if (ldb_should_b64_encode(&v)) {
 		char *vstr = ldb_base64_encode(ldb, (char *)v.data, v.length);
 		if (!vstr) return NULL;
-		dn = talloc_asprintf(ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
+		ret = ldb_dn_new_fmt(ldb, ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
 		talloc_free(vstr);
-		if (v.data != value->data) {
-			talloc_free(v.data);
-		}
-		talloc_free(attr_folded);
-		if (dn == NULL) return NULL;
-		goto done;
+	} else {
+		ret = ldb_dn_new_fmt(ldb, ldb, "%s:%s:%.*s", LTDB_INDEX, attr_folded, (int)v.length, (char *)v.data);
 	}
 
-	dn = talloc_asprintf(ldb, "%s:%s:%.*s", 
-			      LTDB_INDEX, attr_folded, (int)v.length, (char *)v.data);
-
 	if (v.data != value->data) {
 		talloc_free(v.data);
 	}
 	talloc_free(attr_folded);
 
-done:
-	ret = ldb_dn_new(ldb, ldb, dn);
-	talloc_free(dn);
 	return ret;
 }
 
-- 
cgit 


From 6045b6f314be519cfb7faeeef6b3daaac673582f Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 30 Nov 2006 10:03:54 +0000
Subject: r19964: make debuging easier and report usefull error messages

metze
(This used to be commit f129d78256d965d52e80aedfa76c7c079e611c5f)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 045be985a4..99288d2b5f 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -110,6 +110,7 @@ static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 	struct ldb_val v;
 	const struct ldb_attrib_handler *h;
 	char *attr_folded;
+	int r;
 
 	attr_folded = ldb_attr_casefold(ldb, attr);
 	if (!attr_folded) {
@@ -117,10 +118,13 @@ static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 	}
 
 	h = ldb_attrib_handler(ldb, attr);
-	if (h->canonicalise_fn(ldb, ldb, value, &v) != 0) {
+	r = h->canonicalise_fn(ldb, ldb, value, &v);
+	if (r != LDB_SUCCESS) {
 		/* canonicalisation can be refused. For example, 
 		   a attribute that takes wildcards will refuse to canonicalise
 		   if the value contains a wildcard */
+		ldb_asprintf_errstring(ldb, "Failed to create index key for attribute '%s':%s:%s",
+				       attr, ldb_strerror(r), ldb_errstring(ldb));
 		talloc_free(attr_folded);
 		return NULL;
 	}
@@ -845,7 +849,6 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 	dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		talloc_free(msg);
-		errno = ENOMEM;
 		return -1;
 	}
 	talloc_steal(msg, dn_key);
-- 
cgit 


From aee9e6c7cdc46640a5dc8e95c1e4c16057d74b29 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 30 Nov 2006 10:16:19 +0000
Subject: r19965: make the output a bit nicer

metze
(This used to be commit 8655db41c1e776261ac61a975ca1883b7b59c6aa)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 99288d2b5f..7127c35f43 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -120,11 +120,12 @@ static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 	h = ldb_attrib_handler(ldb, attr);
 	r = h->canonicalise_fn(ldb, ldb, value, &v);
 	if (r != LDB_SUCCESS) {
+		const char *errstr = ldb_errstring(ldb);
 		/* canonicalisation can be refused. For example, 
 		   a attribute that takes wildcards will refuse to canonicalise
 		   if the value contains a wildcard */
-		ldb_asprintf_errstring(ldb, "Failed to create index key for attribute '%s':%s:%s",
-				       attr, ldb_strerror(r), ldb_errstring(ldb));
+		ldb_asprintf_errstring(ldb, "Failed to create index key for attribute '%s':%s%s%s",
+				       attr, ldb_strerror(r), (errstr?":":""), (errstr?errstr:""));
 		talloc_free(attr_folded);
 		return NULL;
 	}
-- 
cgit 


From 5dd224f2609d6202f2c4b617b3217dd57e99548d Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 10 Dec 2006 22:21:55 +0000
Subject: r20100: Remove completely unused parameters (This used to be commit
 cc1bcb814844e8a03dfa9a310d26ce3f3441e7bb)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 7127c35f43..1763c86064 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -763,7 +763,6 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 */
 static int ltdb_index_add1_new(struct ldb_context *ldb, 
 			       struct ldb_message *msg,
-			       struct ldb_message_element *el,
 			       const char *dn)
 {
 	struct ldb_message_element *el2;
@@ -800,7 +799,6 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 */
 static int ltdb_index_add1_add(struct ldb_context *ldb, 
 			       struct ldb_message *msg,
-			       struct ldb_message_element *el,
 			       int idx,
 			       const char *dn)
 {
@@ -873,9 +871,9 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 	}
 
 	if (i == msg->num_elements) {
-		ret = ltdb_index_add1_new(ldb, msg, el, dn);
+		ret = ltdb_index_add1_new(ldb, msg, dn);
 	} else {
-		ret = ltdb_index_add1_add(ldb, msg, el, i, dn);
+		ret = ltdb_index_add1_add(ldb, msg, i, dn);
 	}
 
 	if (ret == 0) {
-- 
cgit 


From 784fd1a2306530c62dc850df8088fc5d4e33f053 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 10 Dec 2006 22:24:28 +0000
Subject: r20101: Also rename a variable now that the unused parameter is gone
 (This used to be commit a2520bcfa918977f2139a963e9817370789cf077)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 1763c86064..156d9cd1ce 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -765,16 +765,16 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 			       struct ldb_message *msg,
 			       const char *dn)
 {
-	struct ldb_message_element *el2;
+	struct ldb_message_element *el;
 
 	/* add another entry */
-	el2 = talloc_realloc(msg, msg->elements, 
+	el = talloc_realloc(msg, msg->elements, 
 			       struct ldb_message_element, msg->num_elements+1);
-	if (!el2) {
+	if (!el) {
 		return -1;
 	}
 
-	msg->elements = el2;
+	msg->elements = el;
 	msg->elements[msg->num_elements].name = talloc_strdup(msg->elements, LTDB_IDX);
 	if (!msg->elements[msg->num_elements].name) {
 		return -1;
-- 
cgit 


From 2cd08c14a014a9326c6f42b83b4f2187bd2165b2 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 11 Dec 2006 15:49:39 +0000
Subject: r20106: Optional ONE Level indexing for ldb_tdb To activate it you
 must modify the @INDEXLIST object adding the attribute @IDXONE: 1

Ldb test included

Simo.
(This used to be commit ea111795f4016916473ccc05d23c6655e6af1207)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 204 ++++++++++++++++++++++++++++++++++--
 1 file changed, 195 insertions(+), 9 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 156d9cd1ce..19385f5504 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -155,8 +155,14 @@ static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
 	unsigned int i, j;
 	for (i=0;i<msg->num_elements;i++) {
 		if (ldb_attr_cmp(msg->elements[i].name, key) == 0) {
-			const struct ldb_message_element *el = 
-				&msg->elements[i];
+			const struct ldb_message_element *el = &msg->elements[i];
+
+			if (attr == NULL) {
+				/* in this case we are just looking to see if key is present,
+ 				   we are not spearching for a specific index */
+				return 0;
+			}
+
 			for (j=0;j<el->num_values;j++) {
 				if (ldb_attr_cmp((char *)el->values[j].data, attr) == 0) {
 					if (v_idx) {
@@ -583,6 +589,103 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 	return ret;
 }
 
+/*
+  AND index results and ONE level special index
+ */
+static int ltdb_index_dn_one(struct ldb_module *module, 
+			     struct ldb_dn *parent_dn,
+			     struct dn_list *list)
+{
+	struct ldb_context *ldb = module->ldb;
+	struct dn_list *list2;
+	struct ldb_message *msg;
+	struct ldb_dn *key;
+	struct ldb_val val;
+	unsigned int i, j;
+	int ret;
+	
+	list2 = talloc_zero(module, struct dn_list);
+	if (list2 == NULL) {
+		return -1;
+	}
+
+	/* the attribute is indexed. Pull the list of DNs that match the 
+	   search criterion */
+	val.data = (uint8_t *)((intptr_t)ldb_dn_get_casefold(parent_dn));
+	val.length = strlen((char *)val.data);
+	key = ltdb_index_key(ldb, LTDB_IDXONE, &val);
+	if (!key) {
+		talloc_free(list2);
+		return -1;
+	}
+
+	msg = talloc(list2, struct ldb_message);
+	if (msg == NULL) {
+		talloc_free(list2);
+		return -1;
+	}
+
+	ret = ltdb_search_dn1(module, key, msg);
+	talloc_free(key);
+	if (ret == 0 || ret == -1) {
+		return ret;
+	}
+
+	for (i = 0; i < msg->num_elements; i++) {
+		struct ldb_message_element *el;
+
+		if (strcmp(msg->elements[i].name, LTDB_IDX) != 0) {
+			continue;
+		}
+
+		el = &msg->elements[i];
+
+		list2->dn = talloc_array(list2, char *, el->num_values);
+		if (!list2->dn) {
+			talloc_free(list2);
+			return -1;
+		}
+
+		for (j = 0; j < el->num_values; j++) {
+			list2->dn[list2->count] = talloc_strdup(list2->dn, (char *)el->values[j].data);
+			if (!list2->dn[list2->count]) {
+				talloc_free(list2);
+				return -1;
+			}
+			list2->count++;
+		}
+	}
+
+	if (list2->count == 0) {
+		talloc_free(list2);
+		return 0;
+	}
+
+	if (list2->count > 1) {
+		qsort(list2->dn, list2->count, sizeof(char *), (comparison_fn_t) list_cmp);
+	}
+
+	if (list->count > 0) {
+		if (list_intersect(ldb, list, list2) == -1) {
+			talloc_free(list2);
+			return -1;
+		}
+
+		if (list->count == 0) {
+			talloc_free(list->dn);
+			talloc_free(list2);
+			return 0;
+		}
+	} else {
+		list->dn = talloc_move(list, &list2->dn);
+		list->count = list2->count;
+	}
+
+	talloc_free(list2);
+
+	return 1;
+}
+
 /*
   return a list of dn's that might match a indexed search or
   -1 if an error. return 0 for no matches, or 1 for matches
@@ -714,15 +817,29 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 	struct ltdb_context *ac = talloc_get_type(handle->private_data, struct ltdb_context);
 	struct ltdb_private *ltdb = talloc_get_type(ac->module->private_data, struct ltdb_private);
 	struct dn_list *dn_list;
-	int ret;
+	int ret, idxattr, idxone;
+
+	idxattr = idxone = 0;
+	ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXATTR);
+	if (ret == 0 ) {
+		idxattr = 1;
+	}
 
-	if (ltdb->cache->indexlist->num_elements == 0 && 
-	    ac->scope != LDB_SCOPE_BASE) {
-		/* no index list? must do full search */
+	/* We do one level indexing only if requested */
+	ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXONE);
+	if (ret == 0 ) {
+		idxone = 1;
+	}
+
+	if ((ac->scope == LDB_SCOPE_ONELEVEL && (idxattr+idxone == 0)) ||
+	    (ac->scope == LDB_SCOPE_SUBTREE && idxattr == 0)) {
+		/* no indexs? must do full search */
 		return -1;
 	}
 
-	dn_list = talloc(handle, struct dn_list);
+	ret = -1;
+
+	dn_list = talloc_zero(handle, struct dn_list);
 	if (dn_list == NULL) {
 		return -1;
 	}
@@ -741,8 +858,19 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 		}
 		dn_list->count = 1;
 		ret = 1;
-	} else {
+	}
+
+	if (ac->scope != LDB_SCOPE_BASE && idxattr == 1) {
 		ret = ltdb_index_dn(ac->module, ac->tree, ltdb->cache->indexlist, dn_list);
+
+		if (ret < 0) {
+			talloc_free(dn_list);
+			return ret;
+		}
+	}
+
+	if (ac->scope == LDB_SCOPE_ONELEVEL && idxone == 1) {
+		ret = ltdb_index_dn_one(ac->module, ac->base, dn_list);
 	}
 
 	if (ret == 1) {
@@ -1050,6 +1178,57 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 	return 0;
 }
 
+/* 
+  handle special index for one level searches
+*/
+int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int add)
+{
+	struct ltdb_private *ltdb = module->private_data;
+	struct ldb_message_element el;
+	struct ldb_val val;
+	struct ldb_dn *pdn;
+	const char *dn;
+	int ret;
+
+	/* We index for ONE Level only if requested */
+	ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXONE);
+	if (ret != 0) {
+		return 0;
+	}
+
+	pdn = ldb_dn_get_parent(module, msg->dn);
+	if (pdn == NULL) {
+		return -1;
+	}
+
+	dn = ldb_dn_get_linearized(msg->dn);
+	if (dn == NULL) {
+		talloc_free(pdn);
+		return -1;
+	}
+
+	val.data = (uint8_t *)((intptr_t)ldb_dn_get_casefold(pdn));
+	if (val.data == NULL) {
+		talloc_free(pdn);
+		return -1;
+	}
+
+	val.length = strlen((char *)val.data);
+	el.name = LTDB_IDXONE;
+	el.values = &val;
+	el.num_values = 1;
+
+	if (add) {
+		ret = ltdb_index_add1(module, dn, &el, 0);
+	} else { /* delete */
+		ret = ltdb_index_del_value(module, dn, &el, 0);
+	}
+
+	talloc_free(pdn);
+
+	return ret;
+}
+
 
 /*
   traversal function that deletes all @INDEX records
@@ -1112,7 +1291,14 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 		dn = ldb_dn_get_linearized(msg->dn);
 	}
 
-	ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
+	ret = ltdb_index_one(module, msg, 1);
+	if (ret == 0) {
+		ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
+	} else {
+		ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+			"Adding special ONE LEVEL index failed (%s)!\n",
+			ldb_dn_get_linearized(msg->dn));
+	}
 
 	talloc_free(msg);
 
-- 
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/ldb_tdb/ldb_index.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 19385f5504..fd61d41037 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -108,7 +108,7 @@ static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 {
 	struct ldb_dn *ret;
 	struct ldb_val v;
-	const struct ldb_attrib_handler *h;
+	const struct ldb_schema_attribute *a;
 	char *attr_folded;
 	int r;
 
@@ -117,8 +117,8 @@ static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 		return NULL;
 	}
 
-	h = ldb_attrib_handler(ldb, attr);
-	r = h->canonicalise_fn(ldb, ldb, value, &v);
+	a = ldb_schema_attribute_by_name(ldb, attr);
+	r = a->syntax->canonicalise_fn(ldb, ldb, value, &v);
 	if (r != LDB_SUCCESS) {
 		const char *errstr = ldb_errstring(ldb);
 		/* canonicalisation can be refused. For example, 
-- 
cgit 


From 930fca1c9728f5ba1f9f3bff003c23c508960c2d Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 11 Jan 2007 12:18:17 +0000
Subject: r20684: if we don't have any indexes, then we should not waste time
 to traverse the whole tdb and unpack each record

metze
(This used to be commit 492c79de13eab8db6079f880a8f0857dc7a29fa8)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index fd61d41037..f6dc997f3a 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -1323,6 +1323,11 @@ int ltdb_reindex(struct ldb_module *module)
 		return -1;
 	}
 
+	/* if we don't have indexes we have nothing todo */
+	if (ltdb->cache->indexlist->num_elements == 0) {
+		return 0;
+	}
+
 	/* now traverse adding any indexes for normal LDB records */
 	ret = tdb_traverse(ltdb->tdb, re_index, module);
 	if (ret == -1) {
-- 
cgit 


From f14c66ca3046d6561779d4cb1a53ea7b6d72d535 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 13 Feb 2007 12:32:48 +0000
Subject: r21311: fix very ugly "using free'ed memory" bug

This was there since 2005...

metze
(This used to be commit 393e4eeb82df8017eb0afb526f4d723cf8814311)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index f6dc997f3a..7fe769a010 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -337,7 +337,7 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 			ldb_oom(module->ldb);
 			return -1;
 		}
-		list->dn[0] = talloc_strdup(list, (char *)tree->u.equality.value.data);
+		list->dn[0] = talloc_strdup(list->dn, (char *)tree->u.equality.value.data);
 		if (list->dn[0] == NULL) {
 			ldb_oom(module->ldb);
 			return -1;
-- 
cgit 


From 9ec83ae25df8e8e55ab1e25de4972ec4d082783b Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 23 Apr 2007 00:36:49 +0000
Subject: r22471: Convert more code to use proper LDB error codes. This is a 1
 to 1 convertion, next step is to make this code report an error if the basedn
 is not used, hopefully avoiding an  explicit search on the base object in the
 most common cases. (This used to be commit
 50534c84b4577b2d32565a74a4716088f706bfea)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 225 ++++++++++++++++++------------------
 1 file changed, 113 insertions(+), 112 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 7fe769a010..e3682afac7 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -202,22 +202,22 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 	/* if the attribute isn't in the list of indexed attributes then
 	   this node needs a full search */
 	if (ldb_msg_find_idx(index_list, tree->u.equality.attr, NULL, LTDB_IDXATTR) == -1) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	/* the attribute is indexed. Pull the list of DNs that match the 
 	   search criterion */
 	dn = ltdb_index_key(ldb, tree->u.equality.attr, &tree->u.equality.value);
-	if (!dn) return -1;
+	if (!dn) return LDB_ERR_OPERATIONS_ERROR;
 
 	msg = talloc(list, struct ldb_message);
 	if (msg == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ret = ltdb_search_dn1(module, dn, msg);
 	talloc_free(dn);
-	if (ret == 0 || ret == -1) {
+	if (ret != LDB_SUCCESS) {
 		return ret;
 	}
 
@@ -233,7 +233,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 		list->dn = talloc_array(list, char *, el->num_values);
 		if (!list->dn) {
 			talloc_free(msg);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
 		for (j=0;j<el->num_values;j++) {
@@ -241,7 +241,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 				talloc_strdup(list->dn, (char *)el->values[j].data);
 			if (!list->dn[list->count]) {
 				talloc_free(msg);
-				return -1;
+				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			list->count++;
 		}
@@ -253,7 +253,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 		qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
 	}
 
-	return 1;
+	return LDB_SUCCESS;
 }
 
 
@@ -291,24 +291,24 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
 		tree2.operation = LDB_OP_EQUALITY;
 		tree2.u.equality.attr = LTDB_OBJECTCLASS;
 		if (!tree2.u.equality.attr) {
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		tree2.u.equality.value.data = 
 			(uint8_t *)talloc_strdup(list, subclasses[i]);
 		if (tree2.u.equality.value.data == NULL) {
-			return -1;			
+			return LDB_ERR_OPERATIONS_ERROR;			
 		}
 		tree2.u.equality.value.length = strlen(subclasses[i]);
 		list2 = talloc(list, struct dn_list);
 		if (list2 == NULL) {
 			talloc_free(tree2.u.equality.value.data);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		if (ltdb_index_dn_objectclass(module, &tree2, 
-					      index_list, list2) == 1) {
+					      index_list, list2) == LDB_SUCCESS) {
 			if (list->count == 0) {
 				*list = *list2;
-				ret = 1;
+				ret = LDB_SUCCESS;
 			} else {
 				list_union(ldb, list, list2);
 				talloc_free(list2);
@@ -335,15 +335,15 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 		list->dn = talloc_array(list, char *, 1);
 		if (list->dn == NULL) {
 			ldb_oom(module->ldb);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		list->dn[0] = talloc_strdup(list->dn, (char *)tree->u.equality.value.data);
 		if (list->dn[0] == NULL) {
 			ldb_oom(module->ldb);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		list->count = 1;
-		return 1;
+		return LDB_SUCCESS;
 	}
 	return ltdb_index_dn_simple(module, tree, index_list, list);
 }
@@ -362,18 +362,18 @@ static int list_intersect(struct ldb_context *ldb,
 
 	if (list->count == 0 || list2->count == 0) {
 		/* 0 & X == 0 */
-		return 0;
+		return LDB_ERR_NO_SUCH_OBJECT;
 	}
 
 	list3 = talloc(ldb, struct dn_list);
 	if (list3 == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	list3->dn = talloc_array(list3, char *, list->count);
 	if (!list3->dn) {
 		talloc_free(list3);
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	list3->count = 0;
 
@@ -392,7 +392,7 @@ static int list_intersect(struct ldb_context *ldb,
 	list->count = list3->count;
 	talloc_free(list3);
 
-	return 0;
+	return LDB_ERR_NO_SUCH_OBJECT;
 }
 
 
@@ -410,12 +410,12 @@ static int list_union(struct ldb_context *ldb,
 
 	if (list->count == 0 && list2->count == 0) {
 		/* 0 | 0 == 0 */
-		return 0;
+		return LDB_ERR_NO_SUCH_OBJECT;
 	}
 
 	d = talloc_realloc(list, list->dn, char *, list->count + list2->count);
 	if (!d) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	list->dn = d;
 
@@ -424,7 +424,7 @@ static int list_union(struct ldb_context *ldb,
 			      sizeof(char *), (comparison_fn_t)strcmp) == -1) {
 			list->dn[list->count] = talloc_strdup(list->dn, list2->dn[i]);
 			if (!list->dn[list->count]) {
-				return -1;
+				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			list->count++;
 		}		
@@ -434,7 +434,7 @@ static int list_union(struct ldb_context *ldb,
 		qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t)list_cmp);
 	}
 
-	return 0;
+	return LDB_ERR_NO_SUCH_OBJECT;
 }
 
 static int ltdb_index_dn(struct ldb_module *module, 
@@ -455,7 +455,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 	unsigned int i;
 	int ret;
 	
-	ret = -1;
+	ret = LDB_ERR_OPERATIONS_ERROR;
 	list->dn = NULL;
 	list->count = 0;
 
@@ -465,43 +465,43 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 
 		list2 = talloc(module, struct dn_list);
 		if (list2 == NULL) {
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
 		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
 
-		if (v == 0) {
+		if (v == LDB_ERR_NO_SUCH_OBJECT) {
 			/* 0 || X == X */
-			if (ret == -1) {
-				ret = 0;
+			if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+				ret = v;
 			}
 			talloc_free(list2);
 			continue;
 		}
 
-		if (v == -1) {
+		if (v != LDB_SUCCESS && v != LDB_ERR_NO_SUCH_OBJECT) {
 			/* 1 || X == 1 */
 			talloc_free(list->dn);
 			talloc_free(list2);
-			return -1;
+			return v;
 		}
 
-		if (ret == -1) {
-			ret = 1;
+		if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+			ret = LDB_SUCCESS;
 			list->dn = talloc_move(list, &list2->dn);
 			list->count = list2->count;
 		} else {
 			if (list_union(ldb, list, list2) == -1) {
 				talloc_free(list2);
-				return -1;
+				return LDB_ERR_OPERATIONS_ERROR;
 			}
-			ret = 1;
+			ret = LDB_SUCCESS;
 		}
 		talloc_free(list2);
 	}
 
 	if (list->count == 0) {
-		return 0;
+		return LDB_ERR_NO_SUCH_OBJECT;
 	}
 
 	return ret;
@@ -524,7 +524,7 @@ static int ltdb_index_dn_not(struct ldb_module *module,
 	   instead, we just give up, and rely on a full index scan
 	   (unless an outer & manages to reduce the list)
 	*/
-	return -1;
+	return LDB_ERR_OPERATIONS_ERROR;
 }
 
 /*
@@ -539,7 +539,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 	unsigned int i;
 	int ret;
 	
-	ret = -1;
+	ret = LDB_ERR_OPERATIONS_ERROR;
 	list->dn = NULL;
 	list->count = 0;
 
@@ -549,32 +549,32 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 
 		list2 = talloc(module, struct dn_list);
 		if (list2 == NULL) {
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
 		v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
 
-		if (v == 0) {
+		if (v == LDB_ERR_NO_SUCH_OBJECT) {
 			/* 0 && X == 0 */
 			talloc_free(list->dn);
 			talloc_free(list2);
-			return 0;
+			return LDB_ERR_NO_SUCH_OBJECT;
 		}
 
-		if (v == -1) {
+		if (v != LDB_SUCCESS && v != LDB_ERR_NO_SUCH_OBJECT) {
 			talloc_free(list2);
 			continue;
 		}
 
-		if (ret == -1) {
-			ret = 1;
+		if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+			ret = LDB_SUCCESS;
 			talloc_free(list->dn);
 			list->dn = talloc_move(list, &list2->dn);
 			list->count = list2->count;
 		} else {
 			if (list_intersect(ldb, list, list2) == -1) {
 				talloc_free(list2);
-				return -1;
+				return LDB_ERR_OPERATIONS_ERROR;
 			}
 		}
 
@@ -582,7 +582,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 
 		if (list->count == 0) {
 			talloc_free(list->dn);
-			return 0;
+			return LDB_ERR_NO_SUCH_OBJECT;
 		}
 	}
 
@@ -606,7 +606,7 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 	
 	list2 = talloc_zero(module, struct dn_list);
 	if (list2 == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	/* the attribute is indexed. Pull the list of DNs that match the 
@@ -616,18 +616,18 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 	key = ltdb_index_key(ldb, LTDB_IDXONE, &val);
 	if (!key) {
 		talloc_free(list2);
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	msg = talloc(list2, struct ldb_message);
 	if (msg == NULL) {
 		talloc_free(list2);
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ret = ltdb_search_dn1(module, key, msg);
 	talloc_free(key);
-	if (ret == 0 || ret == -1) {
+	if (ret != LDB_SUCCESS) {
 		return ret;
 	}
 
@@ -643,14 +643,14 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 		list2->dn = talloc_array(list2, char *, el->num_values);
 		if (!list2->dn) {
 			talloc_free(list2);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
 		for (j = 0; j < el->num_values; j++) {
 			list2->dn[list2->count] = talloc_strdup(list2->dn, (char *)el->values[j].data);
 			if (!list2->dn[list2->count]) {
 				talloc_free(list2);
-				return -1;
+				return LDB_ERR_OPERATIONS_ERROR;
 			}
 			list2->count++;
 		}
@@ -658,7 +658,7 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 
 	if (list2->count == 0) {
 		talloc_free(list2);
-		return 0;
+		return LDB_ERR_NO_SUCH_OBJECT;
 	}
 
 	if (list2->count > 1) {
@@ -668,13 +668,13 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 	if (list->count > 0) {
 		if (list_intersect(ldb, list, list2) == -1) {
 			talloc_free(list2);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 
 		if (list->count == 0) {
 			talloc_free(list->dn);
 			talloc_free(list2);
-			return 0;
+			return LDB_ERR_NO_SUCH_OBJECT;
 		}
 	} else {
 		list->dn = talloc_move(list, &list2->dn);
@@ -683,19 +683,19 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 
 	talloc_free(list2);
 
-	return 1;
+	return LDB_SUCCESS;
 }
 
 /*
   return a list of dn's that might match a indexed search or
-  -1 if an error. return 0 for no matches, or 1 for matches
+  an error. return LDB_ERR_NO_SUCH_OBJECT for no matches, or LDB_SUCCESS for matches
  */
 static int ltdb_index_dn(struct ldb_module *module, 
 			 const struct ldb_parse_tree *tree,
 			 const struct ldb_message *index_list,
 			 struct dn_list *list)
 {
-	int ret = -1;
+	int ret = LDB_ERR_OPERATIONS_ERROR;
 
 	switch (tree->operation) {
 	case LDB_OP_AND:
@@ -721,7 +721,7 @@ static int ltdb_index_dn(struct ldb_module *module,
 	case LDB_OP_APPROX:
 	case LDB_OP_EXTENDED:
 		/* we can't index with fancy bitops yet */
-		ret = -1;
+		ret = LDB_ERR_OPERATIONS_ERROR;
 		break;
 	}
 
@@ -767,13 +767,13 @@ static int ltdb_index_filter(const struct dn_list *dn_list,
 
 		ret = ltdb_search_dn1(ac->module, dn, ares->message);
 		talloc_free(dn);
-		if (ret == 0) {
+		if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 			/* the record has disappeared? yes, this can happen */
 			talloc_free(ares);
 			continue;
 		}
 
-		if (ret == -1) {
+		if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
 			/* an internal error */
 			talloc_free(ares);
 			return LDB_ERR_OPERATIONS_ERROR;
@@ -834,14 +834,14 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 	if ((ac->scope == LDB_SCOPE_ONELEVEL && (idxattr+idxone == 0)) ||
 	    (ac->scope == LDB_SCOPE_SUBTREE && idxattr == 0)) {
 		/* no indexs? must do full search */
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	ret = -1;
+	ret = LDB_ERR_OPERATIONS_ERROR;
 
 	dn_list = talloc_zero(handle, struct dn_list);
 	if (dn_list == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	if (ac->scope == LDB_SCOPE_BASE) {
@@ -849,21 +849,21 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 		dn_list->dn = talloc_array(dn_list, char *, 1);
 		if (dn_list->dn == NULL) {
 			ldb_oom(ac->module->ldb);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		dn_list->dn[0] = ldb_dn_alloc_linearized(dn_list, ac->base);
 		if (dn_list->dn[0] == NULL) {
 			ldb_oom(ac->module->ldb);
-			return -1;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 		dn_list->count = 1;
-		ret = 1;
+		ret = LDB_SUCCESS;
 	}
 
 	if (ac->scope != LDB_SCOPE_BASE && idxattr == 1) {
 		ret = ltdb_index_dn(ac->module, ac->tree, ltdb->cache->indexlist, dn_list);
 
-		if (ret < 0) {
+		if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
 			talloc_free(dn_list);
 			return ret;
 		}
@@ -873,7 +873,7 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 		ret = ltdb_index_dn_one(ac->module, ac->base, dn_list);
 	}
 
-	if (ret == 1) {
+	if (ret == LDB_SUCCESS) {
 		/* we've got a candidate list - now filter by the full tree
 		   and extract the needed attributes */
 		ret = ltdb_index_filter(dn_list, handle);
@@ -899,25 +899,25 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
 	el = talloc_realloc(msg, msg->elements, 
 			       struct ldb_message_element, msg->num_elements+1);
 	if (!el) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	msg->elements = el;
 	msg->elements[msg->num_elements].name = talloc_strdup(msg->elements, LTDB_IDX);
 	if (!msg->elements[msg->num_elements].name) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	msg->elements[msg->num_elements].num_values = 0;
 	msg->elements[msg->num_elements].values = talloc(msg->elements, struct ldb_val);
 	if (!msg->elements[msg->num_elements].values) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	msg->elements[msg->num_elements].values[0].length = strlen(dn);
 	msg->elements[msg->num_elements].values[0].data = discard_const_p(uint8_t, dn);
 	msg->elements[msg->num_elements].num_values = 1;
 	msg->num_elements++;
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 
@@ -936,7 +936,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 	/* for multi-valued attributes we can end up with repeats */
 	for (i=0;i<msg->elements[idx].num_values;i++) {
 		if (strcmp(dn, (char *)msg->elements[idx].values[i].data) == 0) {
-			return 0;
+			return LDB_SUCCESS;
 		}
 	}
 
@@ -944,7 +944,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 			      struct ldb_val, 
 			      msg->elements[idx].num_values+1);
 	if (!v2) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	msg->elements[idx].values = v2;
 
@@ -970,23 +970,23 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 	msg = talloc(module, struct ldb_message);
 	if (msg == NULL) {
 		errno = ENOMEM;
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
 		talloc_free(msg);
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	talloc_steal(msg, dn_key);
 
 	ret = ltdb_search_dn1(module, dn_key, msg);
-	if (ret == -1) {
+	if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
 		talloc_free(msg);
-		return -1;
+		return ret;
 	}
 
-	if (ret == 0) {
+	if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 		msg->dn = dn_key;
 		msg->num_elements = 0;
 		msg->elements = NULL;
@@ -1004,7 +1004,7 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 		ret = ltdb_index_add1_add(ldb, msg, i, dn);
 	}
 
-	if (ret == 0) {
+	if (ret == LDB_SUCCESS) {
 		ret = ltdb_store(module, msg, TDB_REPLACE);
 	}
 
@@ -1021,12 +1021,12 @@ static int ltdb_index_add0(struct ldb_module *module, const char *dn,
 	unsigned int i, j;
 
 	if (dn[0] == '@') {
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	for (i = 0; i < num_el; i++) {
@@ -1037,18 +1037,17 @@ static int ltdb_index_add0(struct ldb_module *module, const char *dn,
 		}
 		for (j = 0; j < elements[i].num_values; j++) {
 			ret = ltdb_index_add1(module, dn, &elements[i], j);
-			if (ret == -1) {
-				return -1;
+			if (ret != LDB_SUCCESS) {
+				return ret;
 			}
 		}
 	}
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 /*
   add the index entries for a new record
-  return -1 on failure
 */
 int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 {
@@ -1057,7 +1056,7 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 
 	dn = ldb_dn_get_linearized(msg->dn);
 	if (dn == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
@@ -1079,31 +1078,31 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 	unsigned int j;
 
 	if (dn[0] == '@') {
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx]);
 	if (!dn_key) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	msg = talloc(dn_key, struct ldb_message);
 	if (msg == NULL) {
 		talloc_free(dn_key);
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ret = ltdb_search_dn1(module, dn_key, msg);
-	if (ret == -1) {
+	if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
 		talloc_free(dn_key);
-		return -1;
+		return ret;
 	}
 
-	if (ret == 0) {
+	if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 		/* it wasn't indexed. Did we have an earlier error? If we did then
 		   its gone now */
 		talloc_free(dn_key);
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	i = ldb_msg_find_idx(msg, dn, &j, LTDB_IDX);
@@ -1113,7 +1112,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 				ldb_dn_get_linearized(dn_key));
 		/* it ain't there. hmmm */
 		talloc_free(dn_key);
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	if (j != msg->elements[i].num_values - 1) {
@@ -1149,16 +1148,16 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 	/* find the list of indexed fields */	
 	if (ltdb->cache->indexlist->num_elements == 0) {
 		/* no indexed fields */
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	if (ldb_dn_is_special(msg->dn)) {
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	dn = ldb_dn_get_linearized(msg->dn);
 	if (dn == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	for (i = 0; i < msg->num_elements; i++) {
@@ -1169,13 +1168,13 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 		}
 		for (j = 0; j < msg->elements[i].num_values; j++) {
 			ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
-			if (ret == -1) {
-				return -1;
+			if (ret != LDB_SUCCESS) {
+				return ret;
 			}
 		}
 	}
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 /* 
@@ -1193,24 +1192,24 @@ int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int
 	/* We index for ONE Level only if requested */
 	ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXONE);
 	if (ret != 0) {
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	pdn = ldb_dn_get_parent(module, msg->dn);
 	if (pdn == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	dn = ldb_dn_get_linearized(msg->dn);
 	if (dn == NULL) {
 		talloc_free(pdn);
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	val.data = (uint8_t *)((intptr_t)ldb_dn_get_casefold(pdn));
 	if (val.data == NULL) {
 		talloc_free(pdn);
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	val.length = strlen((char *)val.data);
@@ -1292,7 +1291,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 	}
 
 	ret = ltdb_index_one(module, msg, 1);
-	if (ret == 0) {
+	if (ret == LDB_SUCCESS) {
 		ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
 	} else {
 		ldb_debug(module->ldb, LDB_DEBUG_ERROR,
@@ -1302,7 +1301,9 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 
 	talloc_free(msg);
 
-	return ret;
+	if (ret != LDB_SUCCESS) return -1;
+
+	return 0;
 }
 
 /*
@@ -1314,25 +1315,25 @@ int ltdb_reindex(struct ldb_module *module)
 	int ret;
 
 	if (ltdb_cache_reload(module) != 0) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	/* first traverse the database deleting any @INDEX records */
 	ret = tdb_traverse(ltdb->tdb, delete_index, NULL);
 	if (ret == -1) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	/* if we don't have indexes we have nothing todo */
 	if (ltdb->cache->indexlist->num_elements == 0) {
-		return 0;
+		return LDB_SUCCESS;
 	}
 
 	/* now traverse adding any indexes for normal LDB records */
 	ret = tdb_traverse(ltdb->tdb, re_index, module);
 	if (ret == -1) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	return 0;
+	return LDB_SUCCESS;
 }
-- 
cgit 


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index e3682afac7..caa410775c 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -32,10 +32,9 @@
  *  Author: Andrew Tridgell
  */
 
-#include "includes.h"
-#include "ldb/include/includes.h"
+#include "ldb_includes.h"
 
-#include "ldb/ldb_tdb/ldb_tdb.h"
+#include "ldb_tdb.h"
 
 /*
   find an element in a list, using the given comparison function and
-- 
cgit 


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

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


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

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

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


From cd962355abad90a2161765a7be7d26e63572cab7 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 7 Sep 2007 15:08:14 +0000
Subject: r25000: Fix some more C++ compatibility warnings. (This used to be
 commit 08bb1ef643ab906f1645cf6f32763dc73b1884e4)

---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 1fe697f277..bcab3acafe 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -45,7 +45,7 @@ static int ldb_list_find(const void *needle,
 			 const void *base, size_t nmemb, size_t size, 
 			 comparison_fn_t comp_fn)
 {
-	const char *base_p = base;
+	const char *base_p = (const char *)base;
 	size_t min_i, max_i, test_i;
 
 	if (nmemb == 0) {
@@ -1014,7 +1014,7 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
 static int ltdb_index_add0(struct ldb_module *module, const char *dn,
 			   struct ldb_message_element *elements, int num_el)
 {
-	struct ltdb_private *ltdb = module->private_data;
+	struct ltdb_private *ltdb = (struct ltdb_private *)module->private_data;
 	int ret;
 	unsigned int i, j;
 
@@ -1138,7 +1138,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
 */
 int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 {
-	struct ltdb_private *ltdb = module->private_data;
+	struct ltdb_private *ltdb = (struct ltdb_private *)module->private_data;
 	int ret;
 	const char *dn;
 	unsigned int i, j;
@@ -1180,7 +1180,7 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
 */
 int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int add)
 {
-	struct ltdb_private *ltdb = module->private_data;
+	struct ltdb_private *ltdb = (struct ltdb_private *)module->private_data;
 	struct ldb_message_element el;
 	struct ldb_val val;
 	struct ldb_dn *pdn;
@@ -1244,7 +1244,7 @@ static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, vo
 */
 static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
 {
-	struct ldb_module *module = state;
+	struct ldb_module *module = (struct ldb_module *)state;
 	struct ldb_message *msg;
 	const char *dn = NULL;
 	int ret;
@@ -1309,7 +1309,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 */
 int ltdb_reindex(struct ldb_module *module)
 {
-	struct ltdb_private *ltdb = module->private_data;
+	struct ltdb_private *ltdb = (struct ltdb_private *)module->private_data;
 	int ret;
 
 	if (ltdb_cache_reload(module) != 0) {
-- 
cgit 


From c64116e158080c7cd7304cdd3b80c8666f78c7c6 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 18 Sep 2007 22:43:06 +0000
Subject: r25218: After discussion with Simo, remove the subclass support from
 LDB.

Subclass support was designed to avoid needing to spell out the full
list of objectClasses that an entry was in.  However, Samba4 now
enforces this restriction in the objectClass module, and the way
subclass matching was handled was complex and counter-intuitive in my
opinion (and did not match LDAP).

Andrew Bartlett
(This used to be commit f5ce04b904e14445a2a7e7f92e7e1f64b645c6f2)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 64 -------------------------------------
 1 file changed, 64 deletions(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index bcab3acafe..cf9380f8c0 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -257,67 +257,6 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
 
 static int list_union(struct ldb_context *, struct dn_list *, const struct dn_list *);
 
-/*
-  return a list of dn's that might match a simple indexed search on
-  the special objectclass attribute
- */
-static int ltdb_index_dn_objectclass(struct ldb_module *module, 
-				     const struct ldb_parse_tree *tree,
-				     const struct ldb_message *index_list,
-				     struct dn_list *list)
-{
-	struct ldb_context *ldb = module->ldb;
-	unsigned int i;
-	int ret;
-	const char *target = (const char *)tree->u.equality.value.data;
-	const char **subclasses;
-
-	list->count = 0;
-	list->dn = NULL;
-
-	ret = ltdb_index_dn_simple(module, tree, index_list, list);
-
-	subclasses = ldb_subclass_list(module->ldb, target);
-
-	if (subclasses == NULL) {
-		return ret;
-	}
-
-	for (i=0;subclasses[i];i++) {
-		struct ldb_parse_tree tree2;
-		struct dn_list *list2;
-		tree2.operation = LDB_OP_EQUALITY;
-		tree2.u.equality.attr = LTDB_OBJECTCLASS;
-		if (!tree2.u.equality.attr) {
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
-		tree2.u.equality.value.data = 
-			(uint8_t *)talloc_strdup(list, subclasses[i]);
-		if (tree2.u.equality.value.data == NULL) {
-			return LDB_ERR_OPERATIONS_ERROR;			
-		}
-		tree2.u.equality.value.length = strlen(subclasses[i]);
-		list2 = talloc(list, struct dn_list);
-		if (list2 == NULL) {
-			talloc_free(tree2.u.equality.value.data);
-			return LDB_ERR_OPERATIONS_ERROR;
-		}
-		if (ltdb_index_dn_objectclass(module, &tree2, 
-					      index_list, list2) == LDB_SUCCESS) {
-			if (list->count == 0) {
-				*list = *list2;
-				ret = LDB_SUCCESS;
-			} else {
-				list_union(ldb, list, list2);
-				talloc_free(list2);
-			}
-		}
-		talloc_free(tree2.u.equality.value.data);
-	}
-
-	return ret;
-}
-
 /*
   return a list of dn's that might match a leaf indexed search
  */
@@ -326,9 +265,6 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
 			      const struct ldb_message *index_list,
 			      struct dn_list *list)
 {
-	if (ldb_attr_cmp(tree->u.equality.attr, LTDB_OBJECTCLASS) == 0) {
-		return ltdb_index_dn_objectclass(module, tree, index_list, list);
-	}
 	if (ldb_attr_dn(tree->u.equality.attr) == 0) {
 		list->dn = talloc_array(list, char *, 1);
 		if (list->dn == NULL) {
-- 
cgit 


From bb93a7ed5ea32aa947c4a15197a34a0eced14e10 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Mon, 7 Jan 2008 05:22:14 -0600
Subject: r26684: Trivial cleanup from Matthias Dieter Wallnöfer, from bug 5090
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Andrew Bartlett
(This used to be commit 0016231edd514e8db620bafc44ce877fcac19ed9)
---
 source4/lib/ldb/ldb_tdb/ldb_index.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index cf9380f8c0..d8776f48e2 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -886,7 +886,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
 	msg->elements[idx].values[msg->elements[idx].num_values].data = discard_const_p(uint8_t, dn);
 	msg->elements[idx].num_values++;
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 /*
-- 
cgit 


From 107ab090e23dfc517bc74bb553315cd3528e1f7d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 17 Apr 2008 14:47:07 +0200
Subject: use uintptr_t instead of intptr_t where appropriate (This used to be
 commit d62f2bcc85c13605c133db250e0a86d2d6ccc481)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index d8776f48e2..1b6d9feed6 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -545,7 +545,7 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 
 	/* the attribute is indexed. Pull the list of DNs that match the 
 	   search criterion */
-	val.data = (uint8_t *)((intptr_t)ldb_dn_get_casefold(parent_dn));
+	val.data = (uint8_t *)((uintptr_t)ldb_dn_get_casefold(parent_dn));
 	val.length = strlen((char *)val.data);
 	key = ltdb_index_key(ldb, LTDB_IDXONE, &val);
 	if (!key) {
@@ -1140,7 +1140,7 @@ int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	val.data = (uint8_t *)((intptr_t)ldb_dn_get_casefold(pdn));
+	val.data = (uint8_t *)((uintptr_t)ldb_dn_get_casefold(pdn));
 	if (val.data == NULL) {
 		talloc_free(pdn);
 		return LDB_ERR_OPERATIONS_ERROR;
-- 
cgit 


From c50d361e076625b6fc89b5ee197227a17149c70c Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 22 Aug 2008 18:37:11 +1000
Subject: fixed a speellling erra (This used to be commit
 3c058f50cc3b91d540feb51fb698d90565b2b7c9)

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

(limited to 'source4/lib/ldb/ldb_tdb/ldb_index.c')

diff --git a/source4/lib/ldb/ldb_tdb/ldb_index.c b/source4/lib/ldb/ldb_tdb/ldb_index.c
index 1b6d9feed6..269305a468 100644
--- a/source4/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source4/lib/ldb/ldb_tdb/ldb_index.c
@@ -767,7 +767,7 @@ int ltdb_search_indexed(struct ldb_handle *handle)
 
 	if ((ac->scope == LDB_SCOPE_ONELEVEL && (idxattr+idxone == 0)) ||
 	    (ac->scope == LDB_SCOPE_SUBTREE && idxattr == 0)) {
-		/* no indexs? must do full search */
+		/* no indexes? must do full search */
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-- 
cgit