From e1e95277c0c7f86b15acd70ee3151ec2b3131c5e Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 27 Jun 2005 00:00:50 +0000
Subject: r7937: main file was missing (This used to be commit
 3898cdb0dc4722a7eb60a61b54ef778dab475aed)

---
 source4/lib/ldb/common/ldb_dn.c | 471 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 471 insertions(+)
 create mode 100644 source4/lib/ldb/common/ldb_dn.c

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
new file mode 100644
index 0000000000..7ae314e46c
--- /dev/null
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -0,0 +1,471 @@
+/* 
+   ldb database library
+
+   Copyright (C) Simo Sorce 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 dn explode and utility functions
+ *
+ *  Description: - explode a dn into it's own basic elements
+ *                 and put them in a structure
+ *               - manipulate ldb_dn structures
+ *
+ *  Author: Simo Sorce
+ */
+
+#include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
+#include "ldb/include/ldb_dn.h"
+
+
+#define LDB_DN_NULL_RETURN(x) do { if (!x) return NULL; } while(0) 
+
+static char *escape_string(void *mem_ctx, const char *src)
+{
+	const char *p, *s;
+	char *d, *dst;
+
+	LDB_DN_NULL_RETURN(src);
+
+	/* allocate destination string, it will be at most 3 times the source */
+	dst = d = talloc_array(mem_ctx, char, strlen(src) * 3 + 1);
+	LDB_DN_NULL_RETURN(dst);
+
+	p = s = src;
+
+	while (p) {
+		p += strcspn(p, ",=\n+<>#;\\\"");
+		if (*p == '\0') /* no special s found, all ok */
+			break;
+
+		if (*p) { /* copy part of the string and escape */
+			memcpy(d, s, p - s);
+			d += (p - s);
+			*d++ = '\\';
+			*d++ = *p++;
+			s = p;
+		}
+	}
+
+	/* copy the last part (with zero) and return */
+	memcpy(d, s, &src[strlen(src)] - s + 1);
+
+	return dst;
+}
+
+static char *unescape_string(void *mem_ctx, const char *src)
+{
+	unsigned x;
+	char *p, *dst, *end;
+
+	LDB_DN_NULL_RETURN(src);
+
+	dst = p = talloc_strdup(mem_ctx, src);
+	LDB_DN_NULL_RETURN(dst);
+
+	end = &dst[strlen(dst)];
+
+	while (*p) {
+		p += strcspn(p, ",=\n+<>#;\\\"");
+		if (*p == '\0')	/* no escapes or specials found, all ok */
+			return dst;
+
+		if (*p == '\\') {
+			if (strchr(",=\n+<>#;\\\"", p[1])) {
+				memmove(p, p + 1, end - (p + 1) + 1);
+				end--;
+				p++;
+				continue;
+			}
+
+			if (sscanf(p + 1, "%02x", &x) == 1) {
+				*p = (unsigned char)x;
+				memmove(p + 1, p + 3, end - (p + 3) + 1);
+				end -= 2;
+				p++;
+				continue;
+			}
+		}
+
+		/* a string with not escaped specials is invalid */	
+
+		return NULL;
+	}
+
+	return dst;
+}
+
+static char *seek_to_separator(char *string, const char *separator)
+{
+	char *p;
+
+	p = strchr(string, '=');
+
+	LDB_DN_NULL_RETURN(p);
+
+	p++;
+
+	/* check if there are quotes surrounding the value */
+	p += strspn(p, " \n"); /* skip white spaces after '=' */
+
+	if (*p == '\"') {
+		p++;
+		while (*p != '\"') {
+			p = strchr(p, '\"');
+			LDB_DN_NULL_RETURN(p);
+
+			if (*(p - 1) == '\\')
+				p++;
+		}
+	}
+
+	p += strcspn(p, separator);
+
+	return p;
+}
+
+static char *ldb_dn_trim_string(char *string, const char *edge)
+{
+	char *s, *p;
+
+	/* seek out edge from start of string */
+	s = string + strspn(string, edge);
+
+	/* backwards skip from end of string */
+	p = &s[strlen(s) - 1];
+	while (p > s && strchr(edge, *p)) {
+		*p = '\0';
+		p--;
+	}
+
+	return s;
+}
+
+static struct ldb_dn_attribute *ldb_dn_explode_attribute(void *mem_ctx, char *raw_attribute)
+{
+	struct ldb_dn_attribute *at;
+	char *p;
+
+	at = talloc(mem_ctx, struct ldb_dn_attribute);
+	LDB_DN_NULL_RETURN(at);
+
+	p = strchr(raw_attribute, '=');
+
+	LDB_DN_NULL_RETURN(p);
+
+	*p = '\0';
+
+	at->name = talloc_strdup(at, ldb_dn_trim_string(raw_attribute, " \n"));
+	LDB_DN_NULL_RETURN(at->name);
+
+	p++;
+
+	p = ldb_dn_trim_string(p, " \n");
+
+	if (*p == '\"') { /* quotes at start means there must be quotes at the end */
+		if (p[strlen(p) - 1] != '\"') /* malformed value */
+			return NULL;
+	
+		p++;
+		p[strlen(p) - 1] = '\0';
+		at->value = talloc_strdup(at, p);
+
+		return at;
+	}
+	/* no quotes means we must unescape the string */
+	at->value = unescape_string(at, p);
+	LDB_DN_NULL_RETURN(at->value);
+
+	return at;
+}
+
+static struct ldb_dn_component *explode_component(void *mem_ctx, char *raw_component)
+{
+	struct ldb_dn_component *dc;
+	char *p;
+
+	dc = talloc(mem_ctx, struct ldb_dn_component);
+	LDB_DN_NULL_RETURN(dc);
+
+	dc->attr_num = 0;
+	dc->attributes = NULL;
+
+	p = raw_component;
+
+	/* get the components */
+	do {
+		char *t;
+
+		/* terminate the current attribute and return pointer to the next one */
+		t = seek_to_separator(p, "+");
+		LDB_DN_NULL_RETURN(t);
+
+		if (*t) { /* here there is a separator */
+			*t = '\0'; /*terminate */
+			t++; /* a separtor means there's another attribute that follows */
+		}
+
+		/* allocate attributes pointer */
+		dc->attributes = talloc_realloc(dc, dc->attributes,
+						struct ldb_dn_attribute *,
+						dc->attr_num + 1);
+		LDB_DN_NULL_RETURN(dc->attributes);
+
+		/* store the exploded attirbute in the main structure */
+		dc->attributes[dc->attr_num] = ldb_dn_explode_attribute(dc->attributes, p);
+		LDB_DN_NULL_RETURN(dc->attributes[dc->attr_num]);
+
+		dc->attr_num++;
+
+		/* jump to the next attribute if any */
+		p = t;
+
+	} while(*p);
+
+	return dc;
+}
+
+/* FIXME: currently consider a dn composed of only case insensitive attributes
+	  this is not correct and need to be fixed soon */
+static void ldb_dn_sort_attributes(struct ldb_dn *edn)
+{
+	struct ldb_dn_attribute *at0, *at1;
+	int i, j, k, l;
+
+	for (i = 0; i < edn->comp_num; i++) {
+		if (edn->components[i]->attr_num > 1) {
+
+			/* it is very unlikely that there is a multivalued RDN. In that
+			   unlikely case it is very unlikely you will find more than 2
+			   values. So the use of bubble sort here seem to be acceptable */
+			for (j = 0; (j + 1) < edn->components[i]->attr_num; j++) {
+				for (k = j; k >= 0; k--) {
+					at0 = edn->components[i]->attributes[k];
+					at1 = edn->components[i]->attributes[k + 1];
+					l = ldb_caseless_cmp(at0->name, at1->name);
+					if (l > 0) {
+						/* already sorted, so no bubbles to move exit inner loop */
+						break;
+					}
+					if (l == 0) {
+						if (ldb_caseless_cmp(at0->value, at1->value) >= 0) {
+							/* already sorted, so no bubbles to move exit inner loop */
+							break;
+						}
+					}
+					
+					edn->components[i]->attributes[k] = at1;
+					edn->components[i]->attributes[k + 1] = at0;
+				}
+			}
+		}
+	}
+}
+
+struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
+{
+	struct ldb_dn *edn; /* the exploded dn */
+	char *pdn, *p;
+
+	/* Allocate a structure to hold the exploded DN */
+	edn = talloc(mem_ctx, struct ldb_dn);
+	LDB_DN_NULL_RETURN(edn);
+
+	/* Initially there are no components */
+	edn->comp_num = 0;
+	edn->components = NULL;
+
+	pdn = p = talloc_strdup(edn, dn);
+	if (!pdn)
+		goto error;
+
+	/* get the components */
+	do {
+		char *t;
+
+		/* terminate the current component and return pointer to the next one */
+		t = seek_to_separator(p, ",;");
+		if (t == NULL)
+			goto error;
+
+		if (*t) { /* here there is a separator */
+			*t = '\0'; /*terminate */
+			t++; /* a separtor means there's another component that follows */
+		}
+
+		/* allocate space to hold the dn component */
+		edn->components = talloc_realloc(edn, edn->components,
+						 struct ldb_dn_component *,
+						 edn->comp_num + 1);
+		if (edn->components == NULL)
+			goto error;
+
+		/* store the exploded component in the main structure */
+		edn->components[edn->comp_num] = explode_component(edn->components, p);
+		if (edn->components[edn->comp_num] == NULL)
+			goto error;
+
+		edn->comp_num++;
+
+		/* jump to the next component if any */
+		p = t;
+
+	} while(*p);
+
+	/* sort attributes if there's any multivalued component */
+	ldb_dn_sort_attributes(edn);
+
+	talloc_free(pdn);
+	return edn;
+
+error:
+	talloc_free(edn);
+	return NULL;
+}
+
+char *ldb_dn_linearize(void *mem_ctx, struct ldb_dn *edn)
+{
+	char *dn, *format, *ename, *evalue;
+	int i, j;
+
+	dn = talloc_strdup(mem_ctx, "");
+	LDB_DN_NULL_RETURN(dn);
+
+	for (i = 0; i < edn->comp_num; i++) {
+		if (i != 0) {
+			dn = talloc_append_string(mem_ctx, dn, ",");
+		}
+		for (j = 0; j < edn->components[i]->attr_num; j++) {
+			if (i != 0 && j == 0)
+				format = ",%s=%s";
+			else if (i == 0 && j == 0)
+				format = "%s=%s";
+			else
+				format = "+%s=%s";
+
+			ename = escape_string(mem_ctx, edn->components[i]->attributes[j]->name);
+			LDB_DN_NULL_RETURN(ename);
+
+			evalue = escape_string(mem_ctx, edn->components[i]->attributes[j]->value);
+			LDB_DN_NULL_RETURN(evalue);
+
+			dn = talloc_asprintf_append(dn, format, ename, evalue);
+			LDB_DN_NULL_RETURN(dn);
+
+			talloc_free(ename);
+			talloc_free(evalue);
+		}
+	}
+
+	return dn;
+}
+
+/* FIXME: currently consider a dn composed of only case insensitive attributes
+	  this is not correct and need to be fixed soon */
+int ldb_dn_compare(struct ldb_dn *edn0, struct ldb_dn *edn1)
+{
+	struct ldb_dn_attribute *at0, *at1;
+	int i, j, k;
+
+	/* if the number of components doesn't match they differ */
+	if (edn0->comp_num != edn1->comp_num)
+		return (edn1->comp_num - edn0->comp_num);
+
+	for (i = 0; i < edn0->comp_num; i++) {
+
+		/* if the number of attributes per component doesn't match they differ */
+		if (edn0->components[i]->attr_num != edn1->components[i]->attr_num)
+			return (edn1->components[i]->attr_num - edn0->components[i]->attr_num);
+
+		for (j = 0; j < edn0->components[i]->attr_num; j++) {
+			at0 = edn0->components[i]->attributes[j];
+			at1 = edn1->components[i]->attributes[j];
+
+			/* compare names */
+			k = ldb_caseless_cmp(at0->name, at1->name);
+			if (k)
+				return k;
+
+			/* names match, compare values */
+			k = ldb_caseless_cmp(at0->value, at1->value);
+			if (k)
+				return k;
+		}
+	}
+}
+
+/*
+  casefold a dn. We need to uppercase the attribute names, and the 
+  attribute values of case insensitive attributes. We also need to remove
+  extraneous spaces between elements
+*/
+struct ldb_dn *ldb_dn_casefold(void *mem_ctx, struct ldb_dn *edn, void *user_data,
+				int (* case_fold_attr_fn)(void * user_data, char * attr))
+{
+	struct ldb_dn *cedn;
+	int i, j;
+
+	cedn = talloc(mem_ctx, struct ldb_dn);
+	LDB_DN_NULL_RETURN(cedn);
+
+	cedn->comp_num = edn->comp_num;
+	cedn->components = talloc_array(cedn, struct ldb_dn_component *, edn->comp_num);
+	LDB_DN_NULL_RETURN(cedn->components);
+
+	for (i = 0; i < edn->comp_num; i++) {
+		struct ldb_dn_component *dc;
+
+		dc = talloc(cedn->components, struct ldb_dn_component);
+		LDB_DN_NULL_RETURN(dc);
+
+		dc->attr_num = edn->components[i]->attr_num;
+		dc->attributes = edn->components[i]->attributes;
+		LDB_DN_NULL_RETURN(dc->attributes);
+
+		for (j = 0; j < edn->components[i]->attr_num; j++) {
+			struct ldb_dn_attribute *at;
+
+			at = talloc(dc->attributes, struct ldb_dn_attribute);
+			LDB_DN_NULL_RETURN(at);
+
+			at->name = ldb_casefold(at, edn->components[i]->attributes[j]->name);
+			LDB_DN_NULL_RETURN(at->name);
+
+			if (case_fold_attr_fn(user_data, at->name)) {
+				at->value = ldb_casefold(at, edn->components[i]->attributes[j]->value);
+			} else {
+				at->value = talloc_strdup(at, edn->components[i]->attributes[j]->value);
+			}
+			LDB_DN_NULL_RETURN(at->value);
+
+			dc->attributes[j] = at;
+		}
+
+		cedn->components[i] = dc;
+	}
+
+	return cedn;
+}
+
-- 
cgit 


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

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

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

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

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

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

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

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

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 7ae314e46c..f147197499 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -1,7 +1,7 @@
 /* 
    ldb database library
 
-   Copyright (C) Simo Sorce 2004
+   Copyright (C) Simo Sorce 2005
 
      ** NOTE! The following LGPL license applies to the ldb
      ** library. This does NOT imply that all of Samba is released
@@ -40,22 +40,22 @@
 #include "ldb/include/ldb_dn.h"
 
 
-#define LDB_DN_NULL_RETURN(x) do { if (!x) return NULL; } while(0) 
+#define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
 static char *escape_string(void *mem_ctx, const char *src)
 {
 	const char *p, *s;
-	char *d, *dst;
+	char *d, *dst=NULL;
 
-	LDB_DN_NULL_RETURN(src);
+	LDB_DN_NULL_FAILED(src);
 
 	/* allocate destination string, it will be at most 3 times the source */
 	dst = d = talloc_array(mem_ctx, char, strlen(src) * 3 + 1);
-	LDB_DN_NULL_RETURN(dst);
+	LDB_DN_NULL_FAILED(dst);
 
 	p = s = src;
 
-	while (p) {
+	while (*p) {
 		p += strcspn(p, ",=\n+<>#;\\\"");
 		if (*p == '\0') /* no special s found, all ok */
 			break;
@@ -73,17 +73,20 @@ static char *escape_string(void *mem_ctx, const char *src)
 	memcpy(d, s, &src[strlen(src)] - s + 1);
 
 	return dst;
+failed:
+	talloc_free(dst);
+	return NULL;
 }
 
 static char *unescape_string(void *mem_ctx, const char *src)
 {
 	unsigned x;
-	char *p, *dst, *end;
+	char *p, *dst=NULL, *end;
 
-	LDB_DN_NULL_RETURN(src);
+	LDB_DN_NULL_FAILED(src);
 
 	dst = p = talloc_strdup(mem_ctx, src);
-	LDB_DN_NULL_RETURN(dst);
+	LDB_DN_NULL_FAILED(dst);
 
 	end = &dst[strlen(dst)];
 
@@ -115,6 +118,9 @@ static char *unescape_string(void *mem_ctx, const char *src)
 	}
 
 	return dst;
+failed:
+	talloc_free(dst);
+	return NULL;
 }
 
 static char *seek_to_separator(char *string, const char *separator)
@@ -123,7 +129,7 @@ static char *seek_to_separator(char *string, const char *separator)
 
 	p = strchr(string, '=');
 
-	LDB_DN_NULL_RETURN(p);
+	LDB_DN_NULL_FAILED(p);
 
 	p++;
 
@@ -134,7 +140,7 @@ static char *seek_to_separator(char *string, const char *separator)
 		p++;
 		while (*p != '\"') {
 			p = strchr(p, '\"');
-			LDB_DN_NULL_RETURN(p);
+			LDB_DN_NULL_FAILED(p);
 
 			if (*(p - 1) == '\\')
 				p++;
@@ -144,6 +150,9 @@ static char *seek_to_separator(char *string, const char *separator)
 	p += strcspn(p, separator);
 
 	return p;
+
+failed:
+	return NULL;
 }
 
 static char *ldb_dn_trim_string(char *string, const char *edge)
@@ -169,16 +178,16 @@ static struct ldb_dn_attribute *ldb_dn_explode_attribute(void *mem_ctx, char *ra
 	char *p;
 
 	at = talloc(mem_ctx, struct ldb_dn_attribute);
-	LDB_DN_NULL_RETURN(at);
+	LDB_DN_NULL_FAILED(at);
 
 	p = strchr(raw_attribute, '=');
 
-	LDB_DN_NULL_RETURN(p);
+	LDB_DN_NULL_FAILED(p);
 
 	*p = '\0';
 
 	at->name = talloc_strdup(at, ldb_dn_trim_string(raw_attribute, " \n"));
-	LDB_DN_NULL_RETURN(at->name);
+	LDB_DN_NULL_FAILED(at->name);
 
 	p++;
 
@@ -196,9 +205,13 @@ static struct ldb_dn_attribute *ldb_dn_explode_attribute(void *mem_ctx, char *ra
 	}
 	/* no quotes means we must unescape the string */
 	at->value = unescape_string(at, p);
-	LDB_DN_NULL_RETURN(at->value);
+	LDB_DN_NULL_FAILED(at->value);
 
 	return at;
+
+failed:
+	talloc_free(at);
+	return NULL;
 }
 
 static struct ldb_dn_component *explode_component(void *mem_ctx, char *raw_component)
@@ -207,7 +220,7 @@ static struct ldb_dn_component *explode_component(void *mem_ctx, char *raw_compo
 	char *p;
 
 	dc = talloc(mem_ctx, struct ldb_dn_component);
-	LDB_DN_NULL_RETURN(dc);
+	LDB_DN_NULL_FAILED(dc);
 
 	dc->attr_num = 0;
 	dc->attributes = NULL;
@@ -220,7 +233,7 @@ static struct ldb_dn_component *explode_component(void *mem_ctx, char *raw_compo
 
 		/* terminate the current attribute and return pointer to the next one */
 		t = seek_to_separator(p, "+");
-		LDB_DN_NULL_RETURN(t);
+		LDB_DN_NULL_FAILED(t);
 
 		if (*t) { /* here there is a separator */
 			*t = '\0'; /*terminate */
@@ -231,11 +244,11 @@ static struct ldb_dn_component *explode_component(void *mem_ctx, char *raw_compo
 		dc->attributes = talloc_realloc(dc, dc->attributes,
 						struct ldb_dn_attribute *,
 						dc->attr_num + 1);
-		LDB_DN_NULL_RETURN(dc->attributes);
+		LDB_DN_NULL_FAILED(dc->attributes);
 
 		/* store the exploded attirbute in the main structure */
 		dc->attributes[dc->attr_num] = ldb_dn_explode_attribute(dc->attributes, p);
-		LDB_DN_NULL_RETURN(dc->attributes[dc->attr_num]);
+		LDB_DN_NULL_FAILED(dc->attributes[dc->attr_num]);
 
 		dc->attr_num++;
 
@@ -245,6 +258,9 @@ static struct ldb_dn_component *explode_component(void *mem_ctx, char *raw_compo
 	} while(*p);
 
 	return dc;
+failed:
+	talloc_free(dc);
+	return NULL;
 }
 
 /* FIXME: currently consider a dn composed of only case insensitive attributes
@@ -291,7 +307,7 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 
 	/* Allocate a structure to hold the exploded DN */
 	edn = talloc(mem_ctx, struct ldb_dn);
-	LDB_DN_NULL_RETURN(edn);
+	LDB_DN_NULL_FAILED(edn);
 
 	/* Initially there are no components */
 	edn->comp_num = 0;
@@ -299,7 +315,7 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 
 	pdn = p = talloc_strdup(edn, dn);
 	if (!pdn)
-		goto error;
+		goto failed;
 
 	/* get the components */
 	do {
@@ -308,7 +324,7 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 		/* terminate the current component and return pointer to the next one */
 		t = seek_to_separator(p, ",;");
 		if (t == NULL)
-			goto error;
+			goto failed;
 
 		if (*t) { /* here there is a separator */
 			*t = '\0'; /*terminate */
@@ -320,12 +336,12 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 						 struct ldb_dn_component *,
 						 edn->comp_num + 1);
 		if (edn->components == NULL)
-			goto error;
+			goto failed;
 
 		/* store the exploded component in the main structure */
 		edn->components[edn->comp_num] = explode_component(edn->components, p);
 		if (edn->components[edn->comp_num] == NULL)
-			goto error;
+			goto failed;
 
 		edn->comp_num++;
 
@@ -340,39 +356,39 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 	talloc_free(pdn);
 	return edn;
 
-error:
+failed:
 	talloc_free(edn);
 	return NULL;
 }
 
 char *ldb_dn_linearize(void *mem_ctx, struct ldb_dn *edn)
 {
-	char *dn, *format, *ename, *evalue;
+	char *dn, *ename, *evalue;
+	const char *format;
 	int i, j;
 
 	dn = talloc_strdup(mem_ctx, "");
-	LDB_DN_NULL_RETURN(dn);
+	LDB_DN_NULL_FAILED(dn);
 
 	for (i = 0; i < edn->comp_num; i++) {
 		if (i != 0) {
 			dn = talloc_append_string(mem_ctx, dn, ",");
 		}
 		for (j = 0; j < edn->components[i]->attr_num; j++) {
-			if (i != 0 && j == 0)
-				format = ",%s=%s";
-			else if (i == 0 && j == 0)
+			if (j == 0) {
 				format = "%s=%s";
-			else
+			} else {
 				format = "+%s=%s";
+			}
 
-			ename = escape_string(mem_ctx, edn->components[i]->attributes[j]->name);
-			LDB_DN_NULL_RETURN(ename);
+			ename = escape_string(dn, edn->components[i]->attributes[j]->name);
+			LDB_DN_NULL_FAILED(ename);
 
-			evalue = escape_string(mem_ctx, edn->components[i]->attributes[j]->value);
-			LDB_DN_NULL_RETURN(evalue);
+			evalue = escape_string(dn, edn->components[i]->attributes[j]->value);
+			LDB_DN_NULL_FAILED(evalue);
 
 			dn = talloc_asprintf_append(dn, format, ename, evalue);
-			LDB_DN_NULL_RETURN(dn);
+			LDB_DN_NULL_FAILED(dn);
 
 			talloc_free(ename);
 			talloc_free(evalue);
@@ -380,6 +396,9 @@ char *ldb_dn_linearize(void *mem_ctx, struct ldb_dn *edn)
 	}
 
 	return dn;
+failed:
+	talloc_free(dn);
+	return NULL;
 }
 
 /* FIXME: currently consider a dn composed of only case insensitive attributes
@@ -414,6 +433,8 @@ int ldb_dn_compare(struct ldb_dn *edn0, struct ldb_dn *edn1)
 				return k;
 		}
 	}
+
+	return 0;
 }
 
 /*
@@ -421,45 +442,50 @@ int ldb_dn_compare(struct ldb_dn *edn0, struct ldb_dn *edn1)
   attribute values of case insensitive attributes. We also need to remove
   extraneous spaces between elements
 */
-struct ldb_dn *ldb_dn_casefold(void *mem_ctx, struct ldb_dn *edn, void *user_data,
-				int (* case_fold_attr_fn)(void * user_data, char * attr))
+struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, struct ldb_dn *edn)
 {
 	struct ldb_dn *cedn;
 	int i, j;
 
-	cedn = talloc(mem_ctx, struct ldb_dn);
-	LDB_DN_NULL_RETURN(cedn);
+	cedn = talloc(ldb, struct ldb_dn);
+	LDB_DN_NULL_FAILED(cedn);
 
 	cedn->comp_num = edn->comp_num;
 	cedn->components = talloc_array(cedn, struct ldb_dn_component *, edn->comp_num);
-	LDB_DN_NULL_RETURN(cedn->components);
+	LDB_DN_NULL_FAILED(cedn->components);
 
 	for (i = 0; i < edn->comp_num; i++) {
 		struct ldb_dn_component *dc;
 
 		dc = talloc(cedn->components, struct ldb_dn_component);
-		LDB_DN_NULL_RETURN(dc);
+		LDB_DN_NULL_FAILED(dc);
 
 		dc->attr_num = edn->components[i]->attr_num;
 		dc->attributes = edn->components[i]->attributes;
-		LDB_DN_NULL_RETURN(dc->attributes);
+		LDB_DN_NULL_FAILED(dc->attributes);
 
 		for (j = 0; j < edn->components[i]->attr_num; j++) {
 			struct ldb_dn_attribute *at;
+			struct ldb_val v0, v;
+			const struct ldb_attrib_handler *h;
 
 			at = talloc(dc->attributes, struct ldb_dn_attribute);
-			LDB_DN_NULL_RETURN(at);
+			LDB_DN_NULL_FAILED(at);
 
 			at->name = ldb_casefold(at, edn->components[i]->attributes[j]->name);
-			LDB_DN_NULL_RETURN(at->name);
-
-			if (case_fold_attr_fn(user_data, at->name)) {
-				at->value = ldb_casefold(at, edn->components[i]->attributes[j]->value);
-			} else {
-				at->value = talloc_strdup(at, edn->components[i]->attributes[j]->value);
+			LDB_DN_NULL_FAILED(at->name);
+
+			h = ldb_attrib_handler(ldb, at->name);
+			/* at->value should be a ldb_val, work around
+			   this for now .... */
+			v0.data = edn->components[i]->attributes[j]->value;
+			v0.length = strlen(v0.data);
+			if (h->canonicalise_fn(ldb, &v0, &v) != 0) {
+				return NULL;
 			}
-			LDB_DN_NULL_RETURN(at->value);
 
+			talloc_steal(at, v.data);
+			at->value = v.data;
 			dc->attributes[j] = at;
 		}
 
@@ -467,5 +493,9 @@ struct ldb_dn *ldb_dn_casefold(void *mem_ctx, struct ldb_dn *edn, void *user_dat
 	}
 
 	return cedn;
+
+failed:
+	talloc_free(cedn);
+	return NULL;
 }
 
-- 
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/common/ldb_dn.c | 410 +++++++++++++++++-----------------------
 1 file changed, 175 insertions(+), 235 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index f147197499..18b620b506 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -37,63 +37,74 @@
 #include "includes.h"
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_private.h"
-#include "ldb/include/ldb_dn.h"
 
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
-static char *escape_string(void *mem_ctx, const char *src)
+static char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 {
-	const char *p, *s;
-	char *d, *dst=NULL;
+	const char *p, *s, *src;
+	char *d, *dst;
+	int len;
 
-	LDB_DN_NULL_FAILED(src);
+	if (!value.length)
+		return NULL;
+
+	p = s = src = (const char *)value.data;
+	len = value.length;
 
 	/* allocate destination string, it will be at most 3 times the source */
-	dst = d = talloc_array(mem_ctx, char, strlen(src) * 3 + 1);
+	dst = d = talloc_array(mem_ctx, char, len * 3 + 1);
 	LDB_DN_NULL_FAILED(dst);
 
-	p = s = src;
+	while (p - src < len) {
 
-	while (*p) {
 		p += strcspn(p, ",=\n+<>#;\\\"");
-		if (*p == '\0') /* no special s found, all ok */
+
+		if (p - src == len) /* found no escapable chars */
 			break;
 
-		if (*p) { /* copy part of the string and escape */
-			memcpy(d, s, p - s);
-			d += (p - s);
+		memcpy(d, s, p - s); /* copy the part of the string before the stop */
+		d += (p - s); /* move to current position */
+
+		if (*p) { /* it is a normal escapable character */
 			*d++ = '\\';
 			*d++ = *p++;
-			s = p;
+		} else { /* we have a zero byte in the string */
+			strncpy(d, "\00", 3); /* escape the zero */
+			d = d + 3;
+			p++; /* skip the zero */
 		}
+		s = p; /* move forward */
 	}
 
 	/* copy the last part (with zero) and return */
-	memcpy(d, s, &src[strlen(src)] - s + 1);
+	memcpy(d, s, &src[len] - s + 1);
 
 	return dst;
+
 failed:
 	talloc_free(dst);
 	return NULL;
 }
 
-static char *unescape_string(void *mem_ctx, const char *src)
+static struct ldb_val ldb_dn_unescape_value(void *mem_ctx, const char *src)
 {
+	struct ldb_val value;
 	unsigned x;
-	char *p, *dst=NULL, *end;
+	char *p, *dst = NULL, *end;
+
+	value.length = 0;
 
 	LDB_DN_NULL_FAILED(src);
 
-	dst = p = talloc_strdup(mem_ctx, src);
+	dst = p = talloc_memdup(mem_ctx, src, strlen(src) + 1);
 	LDB_DN_NULL_FAILED(dst);
 
 	end = &dst[strlen(dst)];
 
 	while (*p) {
 		p += strcspn(p, ",=\n+<>#;\\\"");
-		if (*p == '\0')	/* no escapes or specials found, all ok */
-			return dst;
 
 		if (*p == '\\') {
 			if (strchr(",=\n+<>#;\\\"", p[1])) {
@@ -112,31 +123,41 @@ static char *unescape_string(void *mem_ctx, const char *src)
 			}
 		}
 
-		/* a string with not escaped specials is invalid */	
-
-		return NULL;
+		/* a string with not escaped specials is invalid (tested) */
+		if (*p != '\0') {
+			goto failed;
+		}
 	}
 
-	return dst;
+	value.length = end - dst;
+	value.data = dst;
+	return value;
+
 failed:
 	talloc_free(dst);
-	return NULL;
+	return value;
 }
 
-static char *seek_to_separator(char *string, const char *separator)
-{
-	char *p;
-
-	p = strchr(string, '=');
+/* check if the string contains quotes
+ * skips leading and trailing spaces
+ * - returns 0 if no quotes found
+ * - returns 1 if quotes are found and put their position
+ *   in *quote_start and *quote_end parameters
+ * - return -1 if there are open quotes
+ */
 
-	LDB_DN_NULL_FAILED(p);
+static int get_quotes_position(const char *source, int *quote_start, int *quote_end)
+{
+	const char *p;
 
-	p++;
+	p = source;
 
 	/* check if there are quotes surrounding the value */
-	p += strspn(p, " \n"); /* skip white spaces after '=' */
+	p += strspn(p, " \n"); /* skip white spaces */
 
 	if (*p == '\"') {
+		*quote_start = p - source;
+
 		p++;
 		while (*p != '\"') {
 			p = strchr(p, '\"');
@@ -145,11 +166,50 @@ static char *seek_to_separator(char *string, const char *separator)
 			if (*(p - 1) == '\\')
 				p++;
 		}
+
+		*quote_end = p - source;
+		return 1;
+	}
+
+	return 0;
+
+failed:
+	return -1;
+}
+
+static char *seek_to_separator(char *string, const char *separators)
+{
+	char *p;
+	int ret, qs, qe;
+
+	p = strchr(string, '=');
+	LDB_DN_NULL_FAILED(p);
+
+	p++;
+
+	/* check if there are quotes surrounding the value */
+
+	ret = get_quotes_position(p, &qs, &qe);
+	if (ret == -1)
+		return NULL;
+
+	if (ret == 1) { /* quotes found */
+
+		p += qe; /* positioning after quotes */
+		p += strspn(p, " \n"); /* skip white spaces after the quote */
+
+		if (strcspn(p, separators) != 0) /* if there are characters between quotes */
+			return NULL;	    /* and separators, the dn is invalid */
+
+		return p; /* return on the separator */
 	}
 
-	p += strcspn(p, separator);
+	/* no quotes found seek to separators */
+	ret = strcspn(p, separators);
+	if (ret == 0) /* no separators ?! bail out */
+		return NULL;
 
-	return p;
+	return p + ret;
 
 failed:
 	return NULL;
@@ -172,132 +232,53 @@ static char *ldb_dn_trim_string(char *string, const char *edge)
 	return s;
 }
 
-static struct ldb_dn_attribute *ldb_dn_explode_attribute(void *mem_ctx, char *raw_attribute)
+/* we choosed to not support multpile valued components */
+static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw_component)
 {
-	struct ldb_dn_attribute *at;
+	struct ldb_dn_component dc;
 	char *p;
+	int ret, qs, qe;
 
-	at = talloc(mem_ctx, struct ldb_dn_attribute);
-	LDB_DN_NULL_FAILED(at);
-
-	p = strchr(raw_attribute, '=');
-
+	/* find attribute type/value separator */
+	p = strchr(raw_component, '=');
 	LDB_DN_NULL_FAILED(p);
 
-	*p = '\0';
+	*p++ = '\0'; /* terminate name and point to value */
 
-	at->name = talloc_strdup(at, ldb_dn_trim_string(raw_attribute, " \n"));
-	LDB_DN_NULL_FAILED(at->name);
+	/* copy and trim name in the component */
+	dc.name = talloc_strdup(mem_ctx, ldb_dn_trim_string(raw_component, " \n"));
+	if (!dc.name)
+		return dc;
 
-	p++;
+	ret = get_quotes_position(p, &qs, &qe);
 
-	p = ldb_dn_trim_string(p, " \n");
+	switch (ret) {
+	case 0: /* no quotes trim the string */
+		p = ldb_dn_trim_string(p, " \n");
+		dc.value = ldb_dn_unescape_value(mem_ctx, p);
+		break;
 
-	if (*p == '\"') { /* quotes at start means there must be quotes at the end */
-		if (p[strlen(p) - 1] != '\"') /* malformed value */
-			return NULL;
-	
-		p++;
-		p[strlen(p) - 1] = '\0';
-		at->value = talloc_strdup(at, p);
+	case 1: /* quotes found get the unquoted string */
+		p[qe] = '\0';
+		p = p + qs + 1;
+		dc.value.length = strlen(p);
+		dc.value.data = talloc_memdup(mem_ctx, p, dc.value.length + 1);
+		break;
 
-		return at;
+	default: /* mismatched quotes ot other error, bail out */
+		goto failed;
 	}
-	/* no quotes means we must unescape the string */
-	at->value = unescape_string(at, p);
-	LDB_DN_NULL_FAILED(at->value);
-
-	return at;
-
-failed:
-	talloc_free(at);
-	return NULL;
-}
 
-static struct ldb_dn_component *explode_component(void *mem_ctx, char *raw_component)
-{
-	struct ldb_dn_component *dc;
-	char *p;
-
-	dc = talloc(mem_ctx, struct ldb_dn_component);
-	LDB_DN_NULL_FAILED(dc);
-
-	dc->attr_num = 0;
-	dc->attributes = NULL;
-
-	p = raw_component;
-
-	/* get the components */
-	do {
-		char *t;
-
-		/* terminate the current attribute and return pointer to the next one */
-		t = seek_to_separator(p, "+");
-		LDB_DN_NULL_FAILED(t);
-
-		if (*t) { /* here there is a separator */
-			*t = '\0'; /*terminate */
-			t++; /* a separtor means there's another attribute that follows */
-		}
-
-		/* allocate attributes pointer */
-		dc->attributes = talloc_realloc(dc, dc->attributes,
-						struct ldb_dn_attribute *,
-						dc->attr_num + 1);
-		LDB_DN_NULL_FAILED(dc->attributes);
-
-		/* store the exploded attirbute in the main structure */
-		dc->attributes[dc->attr_num] = ldb_dn_explode_attribute(dc->attributes, p);
-		LDB_DN_NULL_FAILED(dc->attributes[dc->attr_num]);
-
-		dc->attr_num++;
-
-		/* jump to the next attribute if any */
-		p = t;
-
-	} while(*p);
+	if (dc.value.length == 0) {
+		goto failed;
+	}
 
 	return dc;
-failed:
-	talloc_free(dc);
-	return NULL;
-}
-
-/* FIXME: currently consider a dn composed of only case insensitive attributes
-	  this is not correct and need to be fixed soon */
-static void ldb_dn_sort_attributes(struct ldb_dn *edn)
-{
-	struct ldb_dn_attribute *at0, *at1;
-	int i, j, k, l;
 
-	for (i = 0; i < edn->comp_num; i++) {
-		if (edn->components[i]->attr_num > 1) {
-
-			/* it is very unlikely that there is a multivalued RDN. In that
-			   unlikely case it is very unlikely you will find more than 2
-			   values. So the use of bubble sort here seem to be acceptable */
-			for (j = 0; (j + 1) < edn->components[i]->attr_num; j++) {
-				for (k = j; k >= 0; k--) {
-					at0 = edn->components[i]->attributes[k];
-					at1 = edn->components[i]->attributes[k + 1];
-					l = ldb_caseless_cmp(at0->name, at1->name);
-					if (l > 0) {
-						/* already sorted, so no bubbles to move exit inner loop */
-						break;
-					}
-					if (l == 0) {
-						if (ldb_caseless_cmp(at0->value, at1->value) >= 0) {
-							/* already sorted, so no bubbles to move exit inner loop */
-							break;
-						}
-					}
-					
-					edn->components[i]->attributes[k] = at1;
-					edn->components[i]->attributes[k + 1] = at0;
-				}
-			}
-		}
-	}
+failed:
+	talloc_free(dc.name);
+	dc.name = NULL;
+	return dc;
 }
 
 struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
@@ -305,6 +286,8 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 	struct ldb_dn *edn; /* the exploded dn */
 	char *pdn, *p;
 
+	pdn = NULL;
+
 	/* Allocate a structure to hold the exploded DN */
 	edn = talloc(mem_ctx, struct ldb_dn);
 	LDB_DN_NULL_FAILED(edn);
@@ -314,8 +297,7 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 	edn->components = NULL;
 
 	pdn = p = talloc_strdup(edn, dn);
-	if (!pdn)
-		goto failed;
+	LDB_DN_NULL_FAILED(pdn);
 
 	/* get the components */
 	do {
@@ -323,25 +305,23 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 
 		/* terminate the current component and return pointer to the next one */
 		t = seek_to_separator(p, ",;");
-		if (t == NULL)
-			goto failed;
+		LDB_DN_NULL_FAILED(t);
 
 		if (*t) { /* here there is a separator */
 			*t = '\0'; /*terminate */
-			t++; /* a separtor means there's another component that follows */
+			t++; /* a separtor means another component follows */
 		}
 
 		/* allocate space to hold the dn component */
 		edn->components = talloc_realloc(edn, edn->components,
-						 struct ldb_dn_component *,
+						 struct ldb_dn_component,
 						 edn->comp_num + 1);
 		if (edn->components == NULL)
 			goto failed;
 
 		/* store the exploded component in the main structure */
-		edn->components[edn->comp_num] = explode_component(edn->components, p);
-		if (edn->components[edn->comp_num] == NULL)
-			goto failed;
+		edn->components[edn->comp_num] = ldb_dn_explode_component(edn, p);
+		LDB_DN_NULL_FAILED(edn->components[edn->comp_num].name);
 
 		edn->comp_num++;
 
@@ -350,87 +330,71 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 
 	} while(*p);
 
-	/* sort attributes if there's any multivalued component */
-	ldb_dn_sort_attributes(edn);
-
 	talloc_free(pdn);
 	return edn;
 
 failed:
+	talloc_free(pdn);
 	talloc_free(edn);
 	return NULL;
 }
 
-char *ldb_dn_linearize(void *mem_ctx, struct ldb_dn *edn)
+char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
 {
-	char *dn, *ename, *evalue;
-	const char *format;
-	int i, j;
+	char *dn, *value;
+	const char *format = "%s=%s";
+	int i;
 
 	dn = talloc_strdup(mem_ctx, "");
 	LDB_DN_NULL_FAILED(dn);
 
 	for (i = 0; i < edn->comp_num; i++) {
+
 		if (i != 0) {
-			dn = talloc_append_string(mem_ctx, dn, ",");
+			format = ",%s=%s";
 		}
-		for (j = 0; j < edn->components[i]->attr_num; j++) {
-			if (j == 0) {
-				format = "%s=%s";
-			} else {
-				format = "+%s=%s";
-			}
-
-			ename = escape_string(dn, edn->components[i]->attributes[j]->name);
-			LDB_DN_NULL_FAILED(ename);
 
-			evalue = escape_string(dn, edn->components[i]->attributes[j]->value);
-			LDB_DN_NULL_FAILED(evalue);
+		value = ldb_dn_escape_value(dn, edn->components[i].value);
+		LDB_DN_NULL_FAILED(value);
 
-			dn = talloc_asprintf_append(dn, format, ename, evalue);
-			LDB_DN_NULL_FAILED(dn);
+		dn = talloc_asprintf_append(dn, format, edn->components[i].name, value);
+		LDB_DN_NULL_FAILED(dn);
 
-			talloc_free(ename);
-			talloc_free(evalue);
-		}
+		talloc_free(value);
 	}
 
 	return dn;
+
 failed:
 	talloc_free(dn);
 	return NULL;
 }
 
-/* FIXME: currently consider a dn composed of only case insensitive attributes
-	  this is not correct and need to be fixed soon */
-int ldb_dn_compare(struct ldb_dn *edn0, struct ldb_dn *edn1)
+/* compare DNs using casefolding compare functions */
+int ldb_dn_compare(struct ldb_context *ldb, const struct ldb_dn *edn0, const struct ldb_dn *edn1)
 {
-	struct ldb_dn_attribute *at0, *at1;
-	int i, j, k;
+	int i, ret;
 
 	/* if the number of components doesn't match they differ */
 	if (edn0->comp_num != edn1->comp_num)
 		return (edn1->comp_num - edn0->comp_num);
 
 	for (i = 0; i < edn0->comp_num; i++) {
+		const struct ldb_attrib_handler *h;
 
-		/* if the number of attributes per component doesn't match they differ */
-		if (edn0->components[i]->attr_num != edn1->components[i]->attr_num)
-			return (edn1->components[i]->attr_num - edn0->components[i]->attr_num);
-
-		for (j = 0; j < edn0->components[i]->attr_num; j++) {
-			at0 = edn0->components[i]->attributes[j];
-			at1 = edn1->components[i]->attributes[j];
-
-			/* compare names */
-			k = ldb_caseless_cmp(at0->name, at1->name);
-			if (k)
-				return k;
+		/* compare names (attribute names are guaranteed to be ASCII only) */
+		ret = ldb_caseless_cmp(edn0->components[i].name,
+				       edn1->components[i].name);
+		if (ret) {
+			return ret;
+		}
 
-			/* names match, compare values */
-			k = ldb_caseless_cmp(at0->value, at1->value);
-			if (k)
-				return k;
+		/* names match, compare values */
+		h = ldb_attrib_handler(ldb, edn0->components[i].name);
+		ret = h->comparison_fn(ldb, ldb, &(edn0->components[i].value),
+						  &(edn1->components[i].value));
+		if (ret) {
+			return ret;
 		}
 	}
 
@@ -438,55 +402,31 @@ int ldb_dn_compare(struct ldb_dn *edn0, struct ldb_dn *edn1)
 }
 
 /*
-  casefold a dn. We need to uppercase the attribute names, and the 
-  attribute values of case insensitive attributes. We also need to remove
-  extraneous spaces between elements
+  casefold a dn. We need to casefold the attribute names, and canonicalize 
+  attribute values of case insensitive attributes.
 */
-struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, struct ldb_dn *edn)
+struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn)
 {
 	struct ldb_dn *cedn;
-	int i, j;
+	int i;
 
 	cedn = talloc(ldb, struct ldb_dn);
 	LDB_DN_NULL_FAILED(cedn);
 
 	cedn->comp_num = edn->comp_num;
-	cedn->components = talloc_array(cedn, struct ldb_dn_component *, edn->comp_num);
+	cedn->components = talloc_array(cedn, struct ldb_dn_component, edn->comp_num);
 	LDB_DN_NULL_FAILED(cedn->components);
 
 	for (i = 0; i < edn->comp_num; i++) {
-		struct ldb_dn_component *dc;
+		struct ldb_dn_component dc;
+		const struct ldb_attrib_handler *h;
 
-		dc = talloc(cedn->components, struct ldb_dn_component);
-		LDB_DN_NULL_FAILED(dc);
+		dc.name = ldb_casefold(cedn, edn->components[i].name);
+		LDB_DN_NULL_FAILED(dc.name);
 
-		dc->attr_num = edn->components[i]->attr_num;
-		dc->attributes = edn->components[i]->attributes;
-		LDB_DN_NULL_FAILED(dc->attributes);
-
-		for (j = 0; j < edn->components[i]->attr_num; j++) {
-			struct ldb_dn_attribute *at;
-			struct ldb_val v0, v;
-			const struct ldb_attrib_handler *h;
-
-			at = talloc(dc->attributes, struct ldb_dn_attribute);
-			LDB_DN_NULL_FAILED(at);
-
-			at->name = ldb_casefold(at, edn->components[i]->attributes[j]->name);
-			LDB_DN_NULL_FAILED(at->name);
-
-			h = ldb_attrib_handler(ldb, at->name);
-			/* at->value should be a ldb_val, work around
-			   this for now .... */
-			v0.data = edn->components[i]->attributes[j]->value;
-			v0.length = strlen(v0.data);
-			if (h->canonicalise_fn(ldb, &v0, &v) != 0) {
-				return NULL;
-			}
-
-			talloc_steal(at, v.data);
-			at->value = v.data;
-			dc->attributes[j] = at;
+		h = ldb_attrib_handler(ldb, dc.name);
+		if (h->canonicalise_fn(ldb, cedn, &(edn->components[i].value), &(dc.value)) != 0) {
+			goto failed;
 		}
 
 		cedn->components[i] = dc;
-- 
cgit 


From e6b353e7640dcc98cd6d519cee1d5ff42e8c676f Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 2 Jul 2005 18:34:13 +0000
Subject: r8083: check attribute type is valid (only ascii alphanum chars and
 '-' char) fail if not (This used to be commit
 b1a61cd5d03b4c61b81c810123ffeb3621831617)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 18b620b506..8b9cf4e129 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -41,6 +41,21 @@
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
+static int ldb_dn_is_valid_attribute_name(const char *name)
+{
+	while (*name) {
+		if (! isascii(*name)) {
+			return 0;
+		}
+		if (! (isalnum(*name) || *name == '-')) {
+			return 0;
+		}
+		name++;
+	}
+
+	return 1;
+}
+
 static char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 {
 	const char *p, *s, *src;
@@ -250,6 +265,10 @@ static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw
 	if (!dc.name)
 		return dc;
 
+	if (! ldb_dn_is_valid_attribute_name(dc.name)) {
+		goto failed;
+	}
+
 	ret = get_quotes_position(p, &qs, &qe);
 
 	switch (ret) {
-- 
cgit 


From 3fe6ca1c189f43e8e9f7059943ab7e2939c7582e Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 2 Jul 2005 18:43:22 +0000
Subject: r8084: do not leak memory on errors (This used to be commit
 2e328e6c2fc2c66b0d0de910cd43ab232049bc90)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 8b9cf4e129..7556a144e2 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -37,7 +37,7 @@
 #include "includes.h"
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_private.h"
-
+#include <ctype.h>
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
-- 
cgit 


From 8f9e87d858ae1cf2209cfd8332ad54a750252e24 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 4 Jul 2005 15:06:05 +0000
Subject: r8146: fix compiler warning

metze
(This used to be commit 5fcaa21d67e399aab4af15f4f6f919203c1152e5)
---
 source4/lib/ldb/common/ldb_dn.c | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 7556a144e2..1eaf4c486b 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -361,22 +361,20 @@ failed:
 char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
 {
 	char *dn, *value;
-	const char *format = "%s=%s";
 	int i;
 
 	dn = talloc_strdup(mem_ctx, "");
 	LDB_DN_NULL_FAILED(dn);
 
 	for (i = 0; i < edn->comp_num; i++) {
-
-		if (i != 0) {
-			format = ",%s=%s";
-		}
-
 		value = ldb_dn_escape_value(dn, edn->components[i].value);
 		LDB_DN_NULL_FAILED(value);
 
-		dn = talloc_asprintf_append(dn, format, edn->components[i].name, value);
+		if (i == 0) {
+			dn = talloc_asprintf_append(dn, "%s=%s", edn->components[i].name, value);
+		} else {
+			dn = talloc_asprintf_append(dn, ",%s=%s", edn->components[i].name, value);
+		}
 		LDB_DN_NULL_FAILED(dn);
 
 		talloc_free(value);
-- 
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/common/ldb_dn.c | 64 ++++++++++++++++++++++++++++++++++-------
 1 file changed, 54 insertions(+), 10 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 1eaf4c486b..b421a7fe75 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -315,6 +315,19 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 	edn->comp_num = 0;
 	edn->components = NULL;
 
+	/* Special DNs case */
+	if (dn[0] == '@') {
+		edn->comp_num = 1;
+		edn->components = talloc(edn, struct ldb_dn_component);
+		if (edn->components == NULL) goto failed;
+		edn->components[0].name = talloc_strdup(edn->components, "@SPECIAL");
+		if (edn->components[0].name == NULL) goto failed;
+		edn->components[0].value.data = talloc_strdup(edn->components, dn);
+		if (edn->components[0].value.data== NULL) goto failed;
+		edn->components[0].value.length = strlen(dn);
+		return edn;
+	}
+
 	pdn = p = talloc_strdup(edn, dn);
 	LDB_DN_NULL_FAILED(pdn);
 
@@ -363,6 +376,12 @@ char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
 	char *dn, *value;
 	int i;
 
+	/* Special DNs */
+	if ((edn->comp_num == 1) && strcmp("@SPECIAL", edn->components[0].name) == 0) {
+		dn = talloc_strdup(mem_ctx, edn->components[0].value.data);
+		return dn;
+	}
+
 	dn = talloc_strdup(mem_ctx, "");
 	LDB_DN_NULL_FAILED(dn);
 
@@ -388,28 +407,31 @@ failed:
 }
 
 /* compare DNs using casefolding compare functions */
-int ldb_dn_compare(struct ldb_context *ldb, const struct ldb_dn *edn0, const struct ldb_dn *edn1)
+
+int ldb_dn_compare_base(struct ldb_context *ldb,
+		   const struct ldb_dn *base,
+		   const struct ldb_dn *dn)
 {
 	int i, ret;
+	int n0, n1;
 
 	/* if the number of components doesn't match they differ */
-	if (edn0->comp_num != edn1->comp_num)
-		return (edn1->comp_num - edn0->comp_num);
-
-	for (i = 0; i < edn0->comp_num; i++) {
+	n0 = base->comp_num - 1;
+	n1 = dn->comp_num - 1;
+	for (i = 0; i < base->comp_num; i++, n0--, n1--) {
 		const struct ldb_attrib_handler *h;
 
 		/* compare names (attribute names are guaranteed to be ASCII only) */
-		ret = ldb_caseless_cmp(edn0->components[i].name,
-				       edn1->components[i].name);
+		ret = ldb_caseless_cmp(base->components[n0].name,
+				       dn->components[n1].name);
 		if (ret) {
 			return ret;
 		}
 
 		/* names match, compare values */
-		h = ldb_attrib_handler(ldb, edn0->components[i].name);
-		ret = h->comparison_fn(ldb, ldb, &(edn0->components[i].value),
-						  &(edn1->components[i].value));
+		h = ldb_attrib_handler(ldb, base->components[n0].name);
+		ret = h->comparison_fn(ldb, ldb, &(base->components[n0].value),
+						  &(dn->components[n1].value));
 		if (ret) {
 			return ret;
 		}
@@ -418,6 +440,16 @@ int ldb_dn_compare(struct ldb_context *ldb, const struct ldb_dn *edn0, const str
 	return 0;
 }
 
+int ldb_dn_compare(struct ldb_context *ldb,
+		   const struct ldb_dn *edn0,
+		   const struct ldb_dn *edn1)
+{
+	if (edn0->comp_num != edn1->comp_num)
+		return (edn1->comp_num - edn0->comp_num);
+
+	return ldb_dn_compare_base(ldb, edn0, edn1);
+}
+
 /*
   casefold a dn. We need to casefold the attribute names, and canonicalize 
   attribute values of case insensitive attributes.
@@ -456,3 +488,15 @@ failed:
 	return NULL;
 }
 
+struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn)
+{
+	struct ldb_dn *edn, *cdn;
+
+	edn = ldb_dn_explode(ldb, dn);
+	if (edn == NULL) return NULL;
+
+	cdn = ldb_dn_casefold(ldb, edn);
+	
+	talloc_free(edn);
+	return cdn;
+}
-- 
cgit 


From 61edb97bdfabf1ab313fbec5f47f5e6c8a79da1a Mon Sep 17 00:00:00 2001
From: Love Hörnquist Åstrand <lha@samba.org>
Date: Tue, 12 Jul 2005 22:22:59 +0000
Subject: r8394: Make sure the argument to ctype is*(3) macros are unsigned
 char as required by ISO C99. (This used to be commit
 56fd21c806e816cf4c3d23881f26474f858b45e2)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index b421a7fe75..32b575dd36 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -47,7 +47,7 @@ static int ldb_dn_is_valid_attribute_name(const char *name)
 		if (! isascii(*name)) {
 			return 0;
 		}
-		if (! (isalnum(*name) || *name == '-')) {
+		if (! (isalnum((unsigned char)*name) || *name == '-')) {
 			return 0;
 		}
 		name++;
-- 
cgit 


From cb2c43f7b032c26adf82f3ba7d6e3dc855f89fa4 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 16 Jul 2005 18:16:32 +0000
Subject: r8515: ldb_dn_cmp now uses ldb_dn_compare so that the DNs are
 compared on a content level not ona form level, his means that the 2 DNs: a)
 cn= user, dc=this, dc = is,dc=test b) cn=user,dc=this,dc=is,dc=test are now
 identical even if the string form differ (spaces) (This used to be commit
 76d496c30867ae80434483a34b0d842523aed762)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 32b575dd36..3cdc7ba85f 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -450,6 +450,29 @@ int ldb_dn_compare(struct ldb_context *ldb,
 	return ldb_dn_compare_base(ldb, edn0, edn1);
 }
 
+int ldb_dn_cmp(struct ldb_context *ldb, const char *dn0, const char *dn1)
+{
+	struct ldb_dn *edn0;
+	struct ldb_dn *edn1;
+	int ret;
+
+	edn0 = ldb_dn_explode_casefold(ldb, dn0);
+	if (edn0 == NULL) return 0;
+
+	edn1 = ldb_dn_explode_casefold(ldb, dn1);
+	if (edn1 == NULL) {
+		talloc_free(edn0);
+		return 0;
+	}
+
+	ret = ldb_dn_compare(ldb, edn0, edn1);
+
+	talloc_free(edn0);
+	talloc_free(edn1);
+
+	return ret;
+}
+
 /*
   casefold a dn. We need to casefold the attribute names, and canonicalize 
   attribute values of case insensitive attributes.
-- 
cgit 


From 6e4bcaffa051f69f4e6595cf7d659ec22a22ef21 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 17 Jul 2005 09:06:58 +0000
Subject: r8517: fixed a crash bug in ldb_dn_compare_base() (This used to be
 commit 19d789e82526eff236aeed77ddc8d2606c5118b6)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 3cdc7ba85f..edb5124d99 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -412,13 +412,13 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 		   const struct ldb_dn *base,
 		   const struct ldb_dn *dn)
 {
-	int i, ret;
+	int ret;
 	int n0, n1;
 
 	/* if the number of components doesn't match they differ */
 	n0 = base->comp_num - 1;
 	n1 = dn->comp_num - 1;
-	for (i = 0; i < base->comp_num; i++, n0--, n1--) {
+	while (n0 >= 0 && n1 >= 0) {
 		const struct ldb_attrib_handler *h;
 
 		/* compare names (attribute names are guaranteed to be ASCII only) */
@@ -435,6 +435,8 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 		if (ret) {
 			return ret;
 		}
+		n1--;
+		n0--;
 	}
 
 	return 0;
-- 
cgit 


From 8609e7993237e5ffe54830299212c128e082d9b9 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 16 Aug 2005 06:55:40 +0000
Subject: r9318: fix searches with scope ONE and SUB,

the problem was that ldb_dn_compare_base() just looked at if
both dn's mtach some how, and the following happens:

basedn: CN=bar,DC=foo,DC=com
dn: DC=foo,DC=com

and dn: DC=foo,DC=com was return as result of a sub and base search

and also the ONE search with
basedn: DC=foo,DC=com

returned this

dn: CN=bla,CN=bar,DC=foo,DC=com

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index edb5124d99..5dcb540fa1 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -415,6 +415,10 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 	int ret;
 	int n0, n1;
 
+	if (base->comp_num > dn->comp_num) {
+		return (dn->comp_num - base->comp_num);
+	}
+
 	/* if the number of components doesn't match they differ */
 	n0 = base->comp_num - 1;
 	n1 = dn->comp_num - 1;
-- 
cgit 


From 6195932b4241d94453438a857179debc08495ece Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 18 Aug 2005 11:15:15 +0000
Subject: r9387: regedit uses "New Key #nn" for newly created keys, which
 conflicts with the stricter DN rules in ldb. Escape the DN components to
 cope.

Simo, sorry for making a change in ldb_dn.c while you have changes
pending. Please feel free to revert these and switch reg_backend_ldb.c
to use the new dn construction code.
(This used to be commit 136ecf5cb23758558b4119b08047fc273be8b0f8)
---
 source4/lib/ldb/common/ldb_dn.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 5dcb540fa1..d13238cc17 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -56,7 +56,7 @@ static int ldb_dn_is_valid_attribute_name(const char *name)
 	return 1;
 }
 
-static char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
+char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 {
 	const char *p, *s, *src;
 	char *d, *dst;
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index d13238cc17..dae79fd9e1 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -41,8 +41,26 @@
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
+#define LDB_SPECIAL "@SPECIAL"
+
+BOOL ldb_dn_is_special(const struct ldb_dn *dn)
+{
+	if (dn == NULL || dn->comp_num != 1) return 0;
+
+	return ! strcmp(dn->components[0].name, LDB_SPECIAL);
+}
+
+BOOL ldb_dn_check_special(const struct ldb_dn *dn, const char *check)
+{
+	if (dn == NULL || dn->comp_num != 1) return 0;
+
+	return ! strcmp(dn->components[0].value.data, check);
+}
+
 static int ldb_dn_is_valid_attribute_name(const char *name)
 {
+	if (name == NULL) return 0;
+
 	while (*name) {
 		if (! isascii(*name)) {
 			return 0;
@@ -165,6 +183,8 @@ static int get_quotes_position(const char *source, int *quote_start, int *quote_
 {
 	const char *p;
 
+	if (source == NULL || quote_start == NULL || quote_end == NULL) return -1;
+
 	p = source;
 
 	/* check if there are quotes surrounding the value */
@@ -197,6 +217,8 @@ static char *seek_to_separator(char *string, const char *separators)
 	char *p;
 	int ret, qs, qe;
 
+	if (string == NULL || separators == NULL) return NULL;
+
 	p = strchr(string, '=');
 	LDB_DN_NULL_FAILED(p);
 
@@ -254,6 +276,11 @@ static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw
 	char *p;
 	int ret, qs, qe;
 
+	if (raw_component == NULL) {
+		dc.name = NULL;
+		return dc;
+	}
+
 	/* find attribute type/value separator */
 	p = strchr(raw_component, '=');
 	LDB_DN_NULL_FAILED(p);
@@ -300,14 +327,10 @@ failed:
 	return dc;
 }
 
-struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
+struct ldb_dn *ldb_dn_new(void *mem_ctx)
 {
-	struct ldb_dn *edn; /* the exploded dn */
-	char *pdn, *p;
+	struct ldb_dn *edn;
 
-	pdn = NULL;
-
-	/* Allocate a structure to hold the exploded DN */
 	edn = talloc(mem_ctx, struct ldb_dn);
 	LDB_DN_NULL_FAILED(edn);
 
@@ -315,12 +338,33 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 	edn->comp_num = 0;
 	edn->components = NULL;
 
+	return edn;
+
+failed:
+	return NULL;
+}
+
+struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
+{
+	struct ldb_dn *edn; /* the exploded dn */
+	char *pdn, *p;
+
+	if (dn == NULL) return NULL;
+
+	/* Allocate a structure to hold the exploded DN */
+	edn = ldb_dn_new(mem_ctx);
+
+	/* Empty DNs */
+	if (dn[0] == '\0') {
+		return edn;
+	}
+
 	/* Special DNs case */
 	if (dn[0] == '@') {
 		edn->comp_num = 1;
 		edn->components = talloc(edn, struct ldb_dn_component);
 		if (edn->components == NULL) goto failed;
-		edn->components[0].name = talloc_strdup(edn->components, "@SPECIAL");
+		edn->components[0].name = talloc_strdup(edn->components, LDB_SPECIAL);
 		if (edn->components[0].name == NULL) goto failed;
 		edn->components[0].value.data = talloc_strdup(edn->components, dn);
 		if (edn->components[0].value.data== NULL) goto failed;
@@ -376,8 +420,10 @@ char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
 	char *dn, *value;
 	int i;
 
+	if (edn == NULL) return NULL;
+
 	/* Special DNs */
-	if ((edn->comp_num == 1) && strcmp("@SPECIAL", edn->components[0].name) == 0) {
+	if (ldb_dn_is_special(edn)) {
 		dn = talloc_strdup(mem_ctx, edn->components[0].value.data);
 		return dn;
 	}
@@ -419,6 +465,10 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 		return (dn->comp_num - base->comp_num);
 	}
 
+	if (base == NULL || base->comp_num == 0) return 0;
+	if (dn == NULL || dn->comp_num == 0) return -1;
+	if (base->comp_num > dn->comp_num) return -1;
+
 	/* if the number of components doesn't match they differ */
 	n0 = base->comp_num - 1;
 	n1 = dn->comp_num - 1;
@@ -450,6 +500,8 @@ int ldb_dn_compare(struct ldb_context *ldb,
 		   const struct ldb_dn *edn0,
 		   const struct ldb_dn *edn1)
 {
+	if (edn0 == NULL || edn1 == NULL) return edn1 - edn0;
+
 	if (edn0->comp_num != edn1->comp_num)
 		return (edn1->comp_num - edn0->comp_num);
 
@@ -462,6 +514,8 @@ int ldb_dn_cmp(struct ldb_context *ldb, const char *dn0, const char *dn1)
 	struct ldb_dn *edn1;
 	int ret;
 
+	if (dn0 == NULL || dn1 == NULL) return dn1 - dn0;
+
 	edn0 = ldb_dn_explode_casefold(ldb, dn0);
 	if (edn0 == NULL) return 0;
 
@@ -488,7 +542,9 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 	struct ldb_dn *cedn;
 	int i;
 
-	cedn = talloc(ldb, struct ldb_dn);
+	if (edn == NULL) return NULL;
+
+	cedn = ldb_dn_new(ldb);
 	LDB_DN_NULL_FAILED(cedn);
 
 	cedn->comp_num = edn->comp_num;
@@ -521,6 +577,8 @@ struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn)
 {
 	struct ldb_dn *edn, *cdn;
 
+	if (dn == NULL) return NULL;
+
 	edn = ldb_dn_explode(ldb, dn);
 	if (edn == NULL) return NULL;
 
@@ -529,3 +587,235 @@ struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn)
 	talloc_free(edn);
 	return cdn;
 }
+
+char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *edn)
+{
+	struct ldb_dn *cdn;
+	char *dn;
+
+	if (edn == NULL) return NULL;
+
+	/* Special DNs */
+	if (ldb_dn_is_special(edn)) {
+		dn = talloc_strdup(ldb, edn->components[0].value.data);
+		return dn;
+	}
+
+	cdn = ldb_dn_casefold(ldb, edn);
+	if (cdn == NULL) return NULL;
+
+	dn = ldb_dn_linearize(ldb, cdn);
+	if (dn == NULL) {
+		talloc_free(cdn);
+		return NULL;
+	}
+
+	talloc_free(cdn);
+	return dn;
+}
+
+static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_dn_component *src)
+{
+	struct ldb_dn_component dst;
+	
+	dst.name = NULL;
+
+	if (src == NULL) {
+		return dst;
+	}
+
+	dst.value = ldb_val_dup(mem_ctx, &(src->value));
+	if (dst.value.data == NULL) {
+		return dst;
+	}
+
+	dst.name = talloc_strdup(mem_ctx, src->name);
+	if (dst.name == NULL) {
+		talloc_free(dst.value.data);
+	}
+
+	return dst;
+}
+
+/* copy specified number of elements of a dn into a new one
+   element are copied from top level up to the unique rdn
+   num_el may be greater then dn->comp_num (see ldb_dn_make_child)
+*/
+struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el)
+{
+	struct ldb_dn *new;
+	int i, n, e;
+
+	if (dn == NULL) return NULL;
+	if (num_el <= 0) return NULL;
+
+	new = ldb_dn_new(mem_ctx);
+	LDB_DN_NULL_FAILED(new);
+
+	new->comp_num = num_el;
+	n = new->comp_num - 1;
+	new->components = talloc_array(new, struct ldb_dn_component, new->comp_num);
+
+	if (dn->comp_num == 0) return new;
+	e = dn->comp_num - 1;
+
+	for (i = 0; i < new->comp_num; i++) {
+		new->components[n - i] = ldb_dn_copy_component(new->components,
+								&(dn->components[e - i]));
+		if ((e - i) == 0) {
+			return new;
+		}
+	}
+
+	return new;
+
+failed:
+	talloc_free(new);
+	return NULL;
+}
+
+struct ldb_dn *ldb_dn_copy(void *mem_ctx, const struct ldb_dn *dn)
+{
+	if (dn == NULL) return NULL;
+	return ldb_dn_copy_partial(mem_ctx, dn, dn->comp_num);
+}
+
+struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, const struct ldb_dn *dn)
+{
+	if (dn == NULL) return NULL;
+	return ldb_dn_copy_partial(mem_ctx, dn, dn->comp_num - 1);
+}
+
+struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
+							       const char *val)
+{
+	struct ldb_dn_component *dc;
+
+	if (attr == NULL || val == NULL) return NULL;
+
+	dc = talloc(mem_ctx, struct ldb_dn_component);
+	if (dc == NULL) return NULL;
+
+	dc->name = talloc_strdup(dc, attr);
+	if (dc->name ==  NULL) {
+		talloc_free(dc);
+		return NULL;
+	}
+
+	dc->value.data = talloc_strdup(dc, val);
+	if (dc->value.data ==  NULL) {
+		talloc_free(dc);
+		return NULL;
+	}
+
+	dc->value.length = strlen(val);
+
+	return dc;
+}
+
+struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
+						 const char * value,
+						 const struct ldb_dn *base)
+{
+	struct ldb_dn *new;
+	if (! ldb_dn_is_valid_attribute_name(attr)) return NULL;
+	if (value == NULL || value == '\0') return NULL; 
+
+	if (base != NULL) {
+		new = ldb_dn_copy_partial(mem_ctx, base, base->comp_num + 1);
+		LDB_DN_NULL_FAILED(new);
+	} else {
+		new = ldb_dn_new(mem_ctx);
+		LDB_DN_NULL_FAILED(new);
+
+		new->comp_num = 1;
+		new->components = talloc_array(new, struct ldb_dn_component, new->comp_num);
+	}
+
+	new->components[0].name = talloc_strdup(new->components, attr);
+	LDB_DN_NULL_FAILED(new->components[0].name);
+
+	new->components[0].value.data = talloc_strdup(new->components, value);
+	LDB_DN_NULL_FAILED(new->components[0].value.data);
+	new->components[0].value.length = strlen(new->components[0].value.data);
+
+	return new;
+
+failed:
+	talloc_free(new);
+	return NULL;
+
+}
+
+struct ldb_dn *ldb_dn_make_child(void *mem_ctx, const struct ldb_dn_component *component,
+						const struct ldb_dn *base)
+{
+	if (component == NULL) return NULL;
+
+	return ldb_dn_build_child(mem_ctx, component->name, component->value.data, base);
+}
+
+struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2)
+{
+	int i;
+	struct ldb_dn *new;
+
+	if (dn2 == NULL && dn1 == NULL) {
+		return NULL;
+	}
+
+	if (dn2 == NULL) {
+		new = ldb_dn_new(mem_ctx);
+		LDB_DN_NULL_FAILED(new);
+
+		new->comp_num = dn1->comp_num;
+		new->components = talloc_array(new, struct ldb_dn_component, new->comp_num);
+	} else {
+		new = ldb_dn_copy_partial(mem_ctx, dn2, dn2->comp_num + dn1?dn1->comp_num:0);
+	}
+
+	if (dn1 == NULL) {
+		return new;
+	}
+
+	for (i = 0; i < dn1->comp_num; i++) {
+		new->components[i] = ldb_dn_copy_component(new->components,
+								&(dn1->components[i]));
+	}
+
+	return new;
+
+failed:
+	talloc_free(new);
+	return NULL;
+}
+
+struct ldb_dn *ldb_dn_compose_string_dn(void *mem_ctx, const char *dn1, const struct ldb_dn *dn2)
+{
+	if (dn1 == NULL) return NULL;
+
+	return ldb_dn_compose(mem_ctx, ldb_dn_explode(mem_ctx, dn1), dn2);
+}
+
+struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn)
+{
+	struct ldb_dn_component *rdn;
+
+	if (dn == NULL) return NULL;
+
+	if (dn->comp_num < 1) {
+		return NULL;
+	}
+
+	rdn = talloc(mem_ctx, struct ldb_dn_component);
+	if (rdn == NULL) return NULL;
+
+	*rdn = ldb_dn_copy_component(mem_ctx, &dn->components[0]);
+	if (rdn->name == NULL) {
+		talloc_free(rdn);
+		return NULL;
+	}
+
+	return rdn;
+}
+
-- 
cgit 


From ac90ddfdb28050912ecab0e998089b93216c5c35 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 18 Aug 2005 16:18:48 +0000
Subject: r9392: Fix ldb_dn_compose to make build farm happy

Add ldb_dn_string_compose so that you can build a dn starting from a
struct ldb_dn base and a set of parameters to be composed in a format
string with the same syntax of printf
(This used to be commit 31c69d0655752cc8ea3bc5b7ea87792291302091)
---
 source4/lib/ldb/common/ldb_dn.c | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index dae79fd9e1..df95e37dac 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -771,7 +771,9 @@ struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const str
 		new->comp_num = dn1->comp_num;
 		new->components = talloc_array(new, struct ldb_dn_component, new->comp_num);
 	} else {
-		new = ldb_dn_copy_partial(mem_ctx, dn2, dn2->comp_num + dn1?dn1->comp_num:0);
+		int comp_num = dn2->comp_num;
+		if (dn1 != NULL) comp_num += dn1->comp_num;
+		new = ldb_dn_copy_partial(mem_ctx, dn2, comp_num);
 	}
 
 	if (dn1 == NULL) {
@@ -790,11 +792,26 @@ failed:
 	return NULL;
 }
 
-struct ldb_dn *ldb_dn_compose_string_dn(void *mem_ctx, const char *dn1, const struct ldb_dn *dn2)
+struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, const char *child_fmt, ...)
 {
-	if (dn1 == NULL) return NULL;
+	struct ldb_dn *dn;
+	char *child_str;
+	va_list ap;
+	int ret;
+	
+	if (child_fmt == NULL) return NULL;
+
+	va_start(ap, child_fmt);
+	ret = vasprintf(&child_str, child_fmt, ap);
+	va_end(ap);
+
+	if (ret <= 0) return NULL;
 
-	return ldb_dn_compose(mem_ctx, ldb_dn_explode(mem_ctx, dn1), dn2);
+	dn = ldb_dn_compose(mem_ctx, ldb_dn_explode(mem_ctx, child_str), base);
+
+	free(child_str);
+
+	return dn;
 }
 
 struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn)
-- 
cgit 


From 7c7b93f6497737a09d3e76a626ee4f20284effde Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 18 Aug 2005 16:27:09 +0000
Subject: r9393: Fix ldb standalone build (This used to be commit
 796d0ea2fcf5132b157a397cc1a54aa26c042691)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index df95e37dac..12078231b8 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -353,6 +353,7 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 
 	/* Allocate a structure to hold the exploded DN */
 	edn = ldb_dn_new(mem_ctx);
+	pdn = NULL;
 
 	/* Empty DNs */
 	if (dn[0] == '\0') {
-- 
cgit 


From f2ac4b8d6b24bec9aecfe00daf8c0b4ccf3964a6 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 18 Aug 2005 16:41:27 +0000
Subject: r9394: avoid to use BOOL in ldb (This used to be commit
 d2055849fba56e8620403621f3fb9684f24e853f)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 12078231b8..20cef9dd81 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -43,14 +43,14 @@
 
 #define LDB_SPECIAL "@SPECIAL"
 
-BOOL ldb_dn_is_special(const struct ldb_dn *dn)
+int ldb_dn_is_special(const struct ldb_dn *dn)
 {
 	if (dn == NULL || dn->comp_num != 1) return 0;
 
 	return ! strcmp(dn->components[0].name, LDB_SPECIAL);
 }
 
-BOOL ldb_dn_check_special(const struct ldb_dn *dn, const char *check)
+int ldb_dn_check_special(const struct ldb_dn *dn, const char *check)
 {
 	if (dn == NULL || dn->comp_num != 1) return 0;
 
-- 
cgit 


From 95fcf031b0480ada75ed5ed02826f4acf196be77 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 1 Sep 2005 23:24:47 +0000
Subject: r9929: Fix indentation

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 20cef9dd81..d1a311dad6 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -688,7 +688,7 @@ struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, const struct ldb_dn *dn)
 }
 
 struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
-							       const char *val)
+						const char *val)
 {
 	struct ldb_dn_component *dc;
 
@@ -783,7 +783,7 @@ struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const str
 
 	for (i = 0; i < dn1->comp_num; i++) {
 		new->components[i] = ldb_dn_copy_component(new->components,
-								&(dn1->components[i]));
+							   &(dn1->components[i]));
 	}
 
 	return new;
-- 
cgit 


From 2b2e1337523aa45f2028c15d46471e59e898ee50 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 14 Sep 2005 22:39:24 +0000
Subject: r10231: seem I flipped these, fix. (This used to be commit
 8ddf4de162f42ed53ab0603dd0e1536796f9197e)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index d1a311dad6..2cd7d590fe 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -518,12 +518,12 @@ int ldb_dn_cmp(struct ldb_context *ldb, const char *dn0, const char *dn1)
 	if (dn0 == NULL || dn1 == NULL) return dn1 - dn0;
 
 	edn0 = ldb_dn_explode_casefold(ldb, dn0);
-	if (edn0 == NULL) return 0;
+	if (edn0 == NULL) return 1;
 
 	edn1 = ldb_dn_explode_casefold(ldb, dn1);
 	if (edn1 == NULL) {
 		talloc_free(edn0);
-		return 0;
+		return -1;
 	}
 
 	ret = ldb_dn_compare(ldb, edn0, edn1);
-- 
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/common/ldb_dn.c | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 2cd7d590fe..92e06025d5 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -54,7 +54,7 @@ int ldb_dn_check_special(const struct ldb_dn *dn, const char *check)
 {
 	if (dn == NULL || dn->comp_num != 1) return 0;
 
-	return ! strcmp(dn->components[0].value.data, check);
+	return ! strcmp((char *)dn->components[0].value.data, check);
 }
 
 static int ldb_dn_is_valid_attribute_name(const char *name)
@@ -163,7 +163,7 @@ static struct ldb_val ldb_dn_unescape_value(void *mem_ctx, const char *src)
 	}
 
 	value.length = end - dst;
-	value.data = dst;
+	value.data = (uint8_t *)dst;
 	return value;
 
 failed:
@@ -367,7 +367,7 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 		if (edn->components == NULL) goto failed;
 		edn->components[0].name = talloc_strdup(edn->components, LDB_SPECIAL);
 		if (edn->components[0].name == NULL) goto failed;
-		edn->components[0].value.data = talloc_strdup(edn->components, dn);
+		edn->components[0].value.data = (uint8_t *)talloc_strdup(edn->components, dn);
 		if (edn->components[0].value.data== NULL) goto failed;
 		edn->components[0].value.length = strlen(dn);
 		return edn;
@@ -425,7 +425,7 @@ char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
 
 	/* Special DNs */
 	if (ldb_dn_is_special(edn)) {
-		dn = talloc_strdup(mem_ctx, edn->components[0].value.data);
+		dn = talloc_strdup(mem_ctx, (char *)edn->components[0].value.data);
 		return dn;
 	}
 
@@ -598,7 +598,7 @@ char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *ed
 
 	/* Special DNs */
 	if (ldb_dn_is_special(edn)) {
-		dn = talloc_strdup(ldb, edn->components[0].value.data);
+		dn = talloc_strdup(ldb, (char *)edn->components[0].value.data);
 		return dn;
 	}
 
@@ -703,7 +703,7 @@ struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
 		return NULL;
 	}
 
-	dc->value.data = talloc_strdup(dc, val);
+	dc->value.data = (uint8_t *)talloc_strdup(dc, val);
 	if (dc->value.data ==  NULL) {
 		talloc_free(dc);
 		return NULL;
@@ -736,9 +736,9 @@ struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
 	new->components[0].name = talloc_strdup(new->components, attr);
 	LDB_DN_NULL_FAILED(new->components[0].name);
 
-	new->components[0].value.data = talloc_strdup(new->components, value);
+	new->components[0].value.data = (uint8_t *)talloc_strdup(new->components, value);
 	LDB_DN_NULL_FAILED(new->components[0].value.data);
-	new->components[0].value.length = strlen(new->components[0].value.data);
+	new->components[0].value.length = strlen((char *)new->components[0].value.data);
 
 	return new;
 
@@ -753,7 +753,8 @@ struct ldb_dn *ldb_dn_make_child(void *mem_ctx, const struct ldb_dn_component *c
 {
 	if (component == NULL) return NULL;
 
-	return ldb_dn_build_child(mem_ctx, component->name, component->value.data, base);
+	return ldb_dn_build_child(mem_ctx, component->name, 
+				  (char *)component->value.data, base);
 }
 
 struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2)
-- 
cgit 


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

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

- fixed some more ldb warnings
(This used to be commit e9e4d81b6976549db8a7668572a5da466fbec4a9)
---
 source4/lib/ldb/common/ldb_dn.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 92e06025d5..b497de142b 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -127,7 +127,7 @@ static struct ldb_val ldb_dn_unescape_value(void *mem_ctx, const char *src)
 	unsigned x;
 	char *p, *dst = NULL, *end;
 
-	value.length = 0;
+	memset(&value, 0, sizeof(value));
 
 	LDB_DN_NULL_FAILED(src);
 
@@ -276,8 +276,9 @@ static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw
 	char *p;
 	int ret, qs, qe;
 
+	memset(&dc, 0, sizeof(dc));
+
 	if (raw_component == NULL) {
-		dc.name = NULL;
 		return dc;
 	}
 
@@ -618,8 +619,8 @@ char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *ed
 static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_dn_component *src)
 {
 	struct ldb_dn_component dst;
-	
-	dst.name = NULL;
+
+	memset(&dst, 0, sizeof(dst));
 
 	if (src == NULL) {
 		return dst;
-- 
cgit 


From d96f706bb0a6b41eddec9d467ef3d5f31bee41ab Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 13 Oct 2005 04:24:49 +0000
Subject: r10953: Add a new function to form a canonicalName out of a DN to
 ldb_dn.c

Use this new function in the client and server for the CrackNames
case, where we particularly need it.

Andrew Bartlett
(This used to be commit 380037ee09ef8293bdb288d6c015e7c80f180a30)
---
 source4/lib/ldb/common/ldb_dn.c | 55 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index b497de142b..abe8985f9d 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -839,3 +839,58 @@ struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn)
 	return rdn;
 }
 
+static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_format) {
+	int i;
+	char *cracked = NULL;
+	for (i = dn->comp_num - 1 ; i >= 0; i--) {
+		if (strcasecmp(dn->components[i].name, "dc") != 0) {
+			break;
+		}
+		if (cracked) {
+			cracked = talloc_asprintf(mem_ctx, "%s.%s", dn->components[i].value.data,
+						  cracked);
+		} else {
+			cracked = talloc_strdup(mem_ctx, dn->components[i].value.data);
+		}
+		if (!cracked) {
+			return NULL;
+		}
+	}
+
+	/* Only domain components */
+	if (i < 0) {
+		if (ex_format) {
+			cracked = talloc_asprintf(mem_ctx, "%s\n", cracked);
+		} else {
+			cracked = talloc_asprintf(mem_ctx, "%s/", cracked);
+		}
+		return cracked;
+	}
+
+	for (; i > 0; i--) {
+		cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked, 
+					  dn->components[i].value.data);
+		if (!cracked) {
+			return NULL;
+		}
+	}
+
+	/* Last one */
+	if (ex_format) {
+		cracked = talloc_asprintf(mem_ctx, "%s\n%s", cracked, 
+					  dn->components[i].value.data);
+	} else {
+		cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked, 
+					  dn->components[i].value.data);
+	}
+	return cracked;
+}
+
+char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn) {
+	return ldb_dn_canonical(mem_ctx, dn, 0);
+
+}
+
+char *ldb_dn_canonical_ex_string(void *mem_ctx, const struct ldb_dn *dn) {
+	return ldb_dn_canonical(mem_ctx, dn, 1);
+}
-- 
cgit 


From 52cc7a55018c0a8243e4b7e35206bd9d3616abd8 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 13 Oct 2005 07:47:57 +0000
Subject: r10956: Tridge thought some comments might be a good idea :-)

Andrew Bartlett
(This used to be commit c0d6126effdf31e0a107c06a400973c731e0e263)
---
 source4/lib/ldb/common/ldb_dn.c | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index abe8985f9d..5895432431 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -839,9 +839,19 @@ struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn)
 	return rdn;
 }
 
+/* Create a 'canonical name' string from a DN:
+
+   ie dc=samba,dc=org -> samba.org/
+      uid=administrator,ou=users,dc=samba,dc=org = samba.org/users/administrator
+
+   There are two formats, the EX format has the last / replaced with a newline (\n).
+
+*/
 static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_format) {
 	int i;
 	char *cracked = NULL;
+
+	/* Walk backwards down the DN, grabbing 'dc' components at first */
 	for (i = dn->comp_num - 1 ; i >= 0; i--) {
 		if (strcasecmp(dn->components[i].name, "dc") != 0) {
 			break;
@@ -857,7 +867,7 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 		}
 	}
 
-	/* Only domain components */
+	/* Only domain components?  Finish here */
 	if (i < 0) {
 		if (ex_format) {
 			cracked = talloc_asprintf(mem_ctx, "%s\n", cracked);
@@ -867,6 +877,7 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 		return cracked;
 	}
 
+	/* Now walk backwards appending remaining components */
 	for (; i > 0; i--) {
 		cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked, 
 					  dn->components[i].value.data);
@@ -875,7 +886,7 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 		}
 	}
 
-	/* Last one */
+	/* Last one, possibly a newline for the 'ex' format */
 	if (ex_format) {
 		cracked = talloc_asprintf(mem_ctx, "%s\n%s", cracked, 
 					  dn->components[i].value.data);
@@ -886,6 +897,7 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 	return cracked;
 }
 
+/* Wrapper functions for the above, for the two different string formats */
 char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn) {
 	return ldb_dn_canonical(mem_ctx, dn, 0);
 
-- 
cgit 


From 7b77baff161853f7469df899803861339a3dbc4e Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 13 Oct 2005 10:02:36 +0000
Subject: r10959: fix compiler warnings

metze
(This used to be commit 9a9311fa6b4bbb2a385413c056c8be57cdb9eb59)
---
 source4/lib/ldb/common/ldb_dn.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 5895432431..4c1e9a9d07 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -857,10 +857,11 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 			break;
 		}
 		if (cracked) {
-			cracked = talloc_asprintf(mem_ctx, "%s.%s", dn->components[i].value.data,
+			cracked = talloc_asprintf(mem_ctx, "%s.%s",
+						  (const char *)dn->components[i].value.data,
 						  cracked);
 		} else {
-			cracked = talloc_strdup(mem_ctx, dn->components[i].value.data);
+			cracked = talloc_strdup(mem_ctx, (const char *)dn->components[i].value.data);
 		}
 		if (!cracked) {
 			return NULL;
-- 
cgit 


From 1f9703de40c09b86e25d07fad0e06e303764da8e Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Fri, 14 Oct 2005 02:05:51 +0000
Subject: r10980: Use ldb_attr_cmp and ldb_dn_escape_value

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 4c1e9a9d07..4ae00ee6dc 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -853,15 +853,15 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 
 	/* Walk backwards down the DN, grabbing 'dc' components at first */
 	for (i = dn->comp_num - 1 ; i >= 0; i--) {
-		if (strcasecmp(dn->components[i].name, "dc") != 0) {
+		if (ldb_attr_cmp(dn->components[i].name, "dc") != 0) {
 			break;
 		}
 		if (cracked) {
 			cracked = talloc_asprintf(mem_ctx, "%s.%s",
-						  (const char *)dn->components[i].value.data,
+						  ldb_dn_escape_value(mem_ctx, dn->components[i].value),
 						  cracked);
 		} else {
-			cracked = talloc_strdup(mem_ctx, (const char *)dn->components[i].value.data);
+			cracked = ldb_dn_escape_value(mem_ctx, dn->components[i].value);
 		}
 		if (!cracked) {
 			return NULL;
@@ -881,7 +881,7 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 	/* Now walk backwards appending remaining components */
 	for (; i > 0; i--) {
 		cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked, 
-					  dn->components[i].value.data);
+					  ldb_dn_escape_value(mem_ctx, dn->components[i].value));
 		if (!cracked) {
 			return NULL;
 		}
@@ -890,10 +890,10 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 	/* Last one, possibly a newline for the 'ex' format */
 	if (ex_format) {
 		cracked = talloc_asprintf(mem_ctx, "%s\n%s", cracked, 
-					  dn->components[i].value.data);
+					  ldb_dn_escape_value(mem_ctx, dn->components[i].value));
 	} else {
 		cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked, 
-					  dn->components[i].value.data);
+					  ldb_dn_escape_value(mem_ctx, dn->components[i].value));
 	}
 	return cracked;
 }
-- 
cgit 


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

Simo.
(This used to be commit 77125feaff252cab44d26593093a9c211c846ce8)
---
 source4/lib/ldb/common/ldb_dn.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 4ae00ee6dc..5ed54ae316 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -417,6 +417,39 @@ failed:
 	return NULL;
 }
 
+struct ldb_dn *ldb_dn_explode_or_special(void *mem_ctx, const char *dn)
+{
+	struct ldb_dn *edn; /* the exploded dn */
+
+	if (dn == NULL) return NULL;
+
+	if (strncasecmp(dn, "<GUID=", 6) == 0) {
+		/* this is special DN returned when the
+		 * exploded_dn control is used
+		 */
+
+		/* Allocate a structure to hold the exploded DN */
+		edn = ldb_dn_new(mem_ctx);
+
+		edn->comp_num = 1;
+		edn->components = talloc(edn, struct ldb_dn_component);
+		if (edn->components == NULL) goto failed;
+		edn->components[0].name = talloc_strdup(edn->components, LDB_SPECIAL);
+		if (edn->components[0].name == NULL) goto failed;
+		edn->components[0].value.data = (uint8_t *)talloc_strdup(edn->components, dn);
+		if (edn->components[0].value.data== NULL) goto failed;
+		edn->components[0].value.length = strlen(dn);
+		return edn;
+
+	}
+	
+	return ldb_dn_explode(mem_ctx, dn);
+
+failed:
+	talloc_free(edn);
+	return NULL;
+}
+
 char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
 {
 	char *dn, *value;
-- 
cgit 


From 528470d4a74b1e2068fdc98b62076e8b19db47fc Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Fri, 6 Jan 2006 21:39:37 +0000
Subject: r12748: Fix wrong handling of separation characters for RDNs allow
 escaped separation chars as part of the attr value of an RDN (This used to be
 commit 7ba341d6c3745cd99c4c79933f9bd54f41e12a9c)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 5ed54ae316..4164814f4f 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -214,8 +214,8 @@ failed:
 
 static char *seek_to_separator(char *string, const char *separators)
 {
-	char *p;
-	int ret, qs, qe;
+	char *p, *q;
+	int ret, qs, qe, escaped;
 
 	if (string == NULL || separators == NULL) return NULL;
 
@@ -242,11 +242,21 @@ static char *seek_to_separator(char *string, const char *separators)
 	}
 
 	/* no quotes found seek to separators */
-	ret = strcspn(p, separators);
-	if (ret == 0) /* no separators ?! bail out */
+	q = p;
+	do {
+		escaped = 0;
+		ret = strcspn(q, separators);
+		
+		if (q[ret - 1] == '\\') {
+			escaped = 1;
+			q = q + ret + 1;
+		}
+	} while (escaped);
+
+	if (ret == 0 && p == q) /* no separators ?! bail out */
 		return NULL;
 
-	return p + ret;
+	return q + ret;
 
 failed:
 	return NULL;
-- 
cgit 


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

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

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 4164814f4f..e0c6f4a103 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -35,9 +35,7 @@
  */
 
 #include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_private.h"
-#include <ctype.h>
+#include "ldb/include/includes.h"
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
-- 
cgit 


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

Next comes code to register samba internal utf8 functions.

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index e0c6f4a103..c2212fd6fe 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -55,23 +55,6 @@ int ldb_dn_check_special(const struct ldb_dn *dn, const char *check)
 	return ! strcmp((char *)dn->components[0].value.data, check);
 }
 
-static int ldb_dn_is_valid_attribute_name(const char *name)
-{
-	if (name == NULL) return 0;
-
-	while (*name) {
-		if (! isascii(*name)) {
-			return 0;
-		}
-		if (! (isalnum((unsigned char)*name) || *name == '-')) {
-			return 0;
-		}
-		name++;
-	}
-
-	return 1;
-}
-
 char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 {
 	const char *p, *s, *src;
@@ -301,7 +284,7 @@ static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw
 	if (!dc.name)
 		return dc;
 
-	if (! ldb_dn_is_valid_attribute_name(dc.name)) {
+	if (! ldb_valid_attr_name(dc.name)) {
 		goto failed;
 	}
 
@@ -519,7 +502,8 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 		const struct ldb_attrib_handler *h;
 
 		/* compare names (attribute names are guaranteed to be ASCII only) */
-		ret = ldb_caseless_cmp(base->components[n0].name,
+		ret = ldb_caseless_cmp(ldb,
+				       base->components[n0].name,
 				       dn->components[n1].name);
 		if (ret) {
 			return ret;
@@ -598,7 +582,7 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 		struct ldb_dn_component dc;
 		const struct ldb_attrib_handler *h;
 
-		dc.name = ldb_casefold(cedn, edn->components[i].name);
+		dc.name = ldb_casefold(ldb, cedn, edn->components[i].name);
 		LDB_DN_NULL_FAILED(dc.name);
 
 		h = ldb_attrib_handler(ldb, dc.name);
@@ -761,7 +745,7 @@ struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
 						 const struct ldb_dn *base)
 {
 	struct ldb_dn *new;
-	if (! ldb_dn_is_valid_attribute_name(attr)) return NULL;
+	if (! ldb_valid_attr_name(attr)) return NULL;
 	if (value == NULL || value == '\0') return NULL; 
 
 	if (base != NULL) {
-- 
cgit 


From 88279373abc07fa50a969135eb5ecf58d6c40cc7 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 4 Feb 2006 05:59:48 +0000
Subject: r13328: After the attribute name check cleanup it turned up
 ldb_caseless_cmp() was used just in one places and by mistake, as there we
 should have been using ldb_attr_cmp()

Remove ldb_caseless_cmp() ... going on with the cleanup and utf8 compliance
effort.

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index c2212fd6fe..bcd5a067a6 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -502,9 +502,8 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 		const struct ldb_attrib_handler *h;
 
 		/* compare names (attribute names are guaranteed to be ASCII only) */
-		ret = ldb_caseless_cmp(ldb,
-				       base->components[n0].name,
-				       dn->components[n1].name);
+		ret = ldb_attr_cmp(base->components[n0].name,
+				   dn->components[n1].name);
 		if (ret) {
 			return ret;
 		}
-- 
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/common/ldb_dn.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index bcd5a067a6..9f3374bceb 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -581,7 +581,7 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 		struct ldb_dn_component dc;
 		const struct ldb_attrib_handler *h;
 
-		dc.name = ldb_casefold(ldb, cedn, edn->components[i].name);
+		dc.name = ldb_attr_casefold(cedn, edn->components[i].name);
 		LDB_DN_NULL_FAILED(dc.name);
 
 		h = ldb_attrib_handler(ldb, dc.name);
-- 
cgit 


From f4f194aad102fb6c8740867ac198e1cad0796b63 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 8 Jun 2006 01:00:46 +0000
Subject: r16086: Ensure we can never dereference NULL pointers, and that
 describe what these two DN comparison functions do.

Andrew Bartlett
(This used to be commit 733b64a733779daade7d1cabbacac2275564b697)
---
 source4/lib/ldb/common/ldb_dn.c | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 9f3374bceb..b90d3d8c9b 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -478,23 +478,25 @@ failed:
 	return NULL;
 }
 
-/* compare DNs using casefolding compare functions */
+/* Determine if dn is below base, in the ldap tree.  Used for
+ * evaluating a subtree search.
+ * 0 if they match, otherwise non-zero
+ */
 
 int ldb_dn_compare_base(struct ldb_context *ldb,
-		   const struct ldb_dn *base,
-		   const struct ldb_dn *dn)
+			const struct ldb_dn *base,
+			const struct ldb_dn *dn)
 {
 	int ret;
 	int n0, n1;
 
+	if (base == NULL || base->comp_num == 0) return 0;
+	if (dn == NULL || dn->comp_num == 0) return -1;
+
 	if (base->comp_num > dn->comp_num) {
 		return (dn->comp_num - base->comp_num);
 	}
 
-	if (base == NULL || base->comp_num == 0) return 0;
-	if (dn == NULL || dn->comp_num == 0) return -1;
-	if (base->comp_num > dn->comp_num) return -1;
-
 	/* if the number of components doesn't match they differ */
 	n0 = base->comp_num - 1;
 	n1 = dn->comp_num - 1;
@@ -522,6 +524,11 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 	return 0;
 }
 
+/* compare DNs using casefolding compare functions.  
+
+   If they match, then return 0
+ */
+
 int ldb_dn_compare(struct ldb_context *ldb,
 		   const struct ldb_dn *edn0,
 		   const struct ldb_dn *edn1)
-- 
cgit 


From e3a6c6be79326578a1e9c7cb8547234eab62235f Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Thu, 8 Jun 2006 15:20:05 +0000
Subject: r16100: Patch from Michael Wood <mwood@icts.uct.ac.za>: s/then/than/
 for correct grammar (This used to be commit
 26a2fa97e4c819e630bc9b50e11c8d5328c7b8c8)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index b90d3d8c9b..a659f676c6 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -672,7 +672,7 @@ static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_d
 
 /* copy specified number of elements of a dn into a new one
    element are copied from top level up to the unique rdn
-   num_el may be greater then dn->comp_num (see ldb_dn_make_child)
+   num_el may be greater than dn->comp_num (see ldb_dn_make_child)
 */
 struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el)
 {
-- 
cgit 


From 3ed1e8ff3c351296adfa78a99c19cc7b0fd5d7e7 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 6 Jul 2006 05:51:39 +0000
Subject: r16829: Fix a number of issues raised by the IBM checker, or gcc
 warnings.

In particular, this removes one use of the LDB_DN_NULL_FAILED macro,
which was being used on more than DNs, had an embedded goto, and
confused the IBM checker.

In the password_hash code, ensure that sambaAttr is not, before
checking the number of values.

In GENSEC, note that this switch value can't occour.  This seems to be
the only way to quiet both the IBM checker and gcc, as well as cope
with possibly invalid inputs.

Andrew Bartlet
(This used to be commit 3e58350ec2ab883795b1dd03ac46a3520cac67d0)
---
 source4/lib/ldb/common/ldb_dn.c | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index a659f676c6..0d7a3c6141 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -578,32 +578,35 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 	if (edn == NULL) return NULL;
 
 	cedn = ldb_dn_new(ldb);
-	LDB_DN_NULL_FAILED(cedn);
+	return NULL;
 
 	cedn->comp_num = edn->comp_num;
 	cedn->components = talloc_array(cedn, struct ldb_dn_component, edn->comp_num);
-	LDB_DN_NULL_FAILED(cedn->components);
+	if (!cedn->components) {
+		talloc_free(cedn);
+		return NULL;
+	}
 
 	for (i = 0; i < edn->comp_num; i++) {
 		struct ldb_dn_component dc;
 		const struct ldb_attrib_handler *h;
 
 		dc.name = ldb_attr_casefold(cedn, edn->components[i].name);
-		LDB_DN_NULL_FAILED(dc.name);
+		if (!dc.name) {
+			talloc_free(cedn);
+			return NULL;
+		}
 
 		h = ldb_attrib_handler(ldb, dc.name);
 		if (h->canonicalise_fn(ldb, cedn, &(edn->components[i].value), &(dc.value)) != 0) {
-			goto failed;
+			talloc_free(cedn);
+			return NULL;
 		}
 
 		cedn->components[i] = dc;
 	}
 
 	return cedn;
-
-failed:
-	talloc_free(cedn);
-	return NULL;
 }
 
 struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn)
-- 
cgit 


From 1f1b34b3e815b0a6f502c7ae6e98887e280e7040 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 6 Jul 2006 07:37:41 +0000
Subject: r16832: I should be more careful (and test!) when trying to make
 compilers and static checkers happy...

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 0d7a3c6141..bebb6cc9a0 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -578,7 +578,9 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 	if (edn == NULL) return NULL;
 
 	cedn = ldb_dn_new(ldb);
-	return NULL;
+	if (!cedn) {
+		return NULL;
+	}
 
 	cedn->comp_num = edn->comp_num;
 	cedn->components = talloc_array(cedn, struct ldb_dn_component, edn->comp_num);
-- 
cgit 


From 8d62a6ba2cf223ae99f1c10b6d3593328de83ef5 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 11 Jul 2006 03:44:51 +0000
Subject: r16936: Correct comment in this comparison function

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index bebb6cc9a0..064dc27a27 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -493,11 +493,11 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
 	if (base == NULL || base->comp_num == 0) return 0;
 	if (dn == NULL || dn->comp_num == 0) return -1;
 
+	/* if the base has more componts than the dn, then they differ */
 	if (base->comp_num > dn->comp_num) {
 		return (dn->comp_num - base->comp_num);
 	}
 
-	/* if the number of components doesn't match they differ */
 	n0 = base->comp_num - 1;
 	n1 = dn->comp_num - 1;
 	while (n0 >= 0 && n1 >= 0) {
-- 
cgit 


From 9f7da6fea0bc9a330f8620d100e27d4eabbae253 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 17 Aug 2006 01:52:24 +0000
Subject: r17579: make ldb build g++ friendly (This used to be commit
 403cbd335594112e0c58fd68d20f0e3faad7d186)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 064dc27a27..7dfcba0631 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -681,34 +681,34 @@ static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_d
 */
 struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el)
 {
-	struct ldb_dn *new;
+	struct ldb_dn *newdn;
 	int i, n, e;
 
 	if (dn == NULL) return NULL;
 	if (num_el <= 0) return NULL;
 
-	new = ldb_dn_new(mem_ctx);
-	LDB_DN_NULL_FAILED(new);
+	newdn = ldb_dn_new(mem_ctx);
+	LDB_DN_NULL_FAILED(newdn);
 
-	new->comp_num = num_el;
-	n = new->comp_num - 1;
-	new->components = talloc_array(new, struct ldb_dn_component, new->comp_num);
+	newdn->comp_num = num_el;
+	n = newdn->comp_num - 1;
+	newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
 
-	if (dn->comp_num == 0) return new;
+	if (dn->comp_num == 0) return newdn;
 	e = dn->comp_num - 1;
 
-	for (i = 0; i < new->comp_num; i++) {
-		new->components[n - i] = ldb_dn_copy_component(new->components,
+	for (i = 0; i < newdn->comp_num; i++) {
+		newdn->components[n - i] = ldb_dn_copy_component(newdn->components,
 								&(dn->components[e - i]));
 		if ((e - i) == 0) {
-			return new;
+			return newdn;
 		}
 	}
 
-	return new;
+	return newdn;
 
 failed:
-	talloc_free(new);
+	talloc_free(newdn);
 	return NULL;
 }
 
@@ -755,32 +755,32 @@ struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
 						 const char * value,
 						 const struct ldb_dn *base)
 {
-	struct ldb_dn *new;
+	struct ldb_dn *newdn;
 	if (! ldb_valid_attr_name(attr)) return NULL;
 	if (value == NULL || value == '\0') return NULL; 
 
 	if (base != NULL) {
-		new = ldb_dn_copy_partial(mem_ctx, base, base->comp_num + 1);
-		LDB_DN_NULL_FAILED(new);
+		newdn = ldb_dn_copy_partial(mem_ctx, base, base->comp_num + 1);
+		LDB_DN_NULL_FAILED(newdn);
 	} else {
-		new = ldb_dn_new(mem_ctx);
-		LDB_DN_NULL_FAILED(new);
+		newdn = ldb_dn_new(mem_ctx);
+		LDB_DN_NULL_FAILED(newdn);
 
-		new->comp_num = 1;
-		new->components = talloc_array(new, struct ldb_dn_component, new->comp_num);
+		newdn->comp_num = 1;
+		newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
 	}
 
-	new->components[0].name = talloc_strdup(new->components, attr);
-	LDB_DN_NULL_FAILED(new->components[0].name);
+	newdn->components[0].name = talloc_strdup(newdn->components, attr);
+	LDB_DN_NULL_FAILED(newdn->components[0].name);
 
-	new->components[0].value.data = (uint8_t *)talloc_strdup(new->components, value);
-	LDB_DN_NULL_FAILED(new->components[0].value.data);
-	new->components[0].value.length = strlen((char *)new->components[0].value.data);
+	newdn->components[0].value.data = (uint8_t *)talloc_strdup(newdn->components, value);
+	LDB_DN_NULL_FAILED(newdn->components[0].value.data);
+	newdn->components[0].value.length = strlen((char *)newdn->components[0].value.data);
 
-	return new;
+	return newdn;
 
 failed:
-	talloc_free(new);
+	talloc_free(newdn);
 	return NULL;
 
 }
@@ -797,37 +797,37 @@ struct ldb_dn *ldb_dn_make_child(void *mem_ctx, const struct ldb_dn_component *c
 struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2)
 {
 	int i;
-	struct ldb_dn *new;
+	struct ldb_dn *newdn;
 
 	if (dn2 == NULL && dn1 == NULL) {
 		return NULL;
 	}
 
 	if (dn2 == NULL) {
-		new = ldb_dn_new(mem_ctx);
-		LDB_DN_NULL_FAILED(new);
+		newdn = ldb_dn_new(mem_ctx);
+		LDB_DN_NULL_FAILED(newdn);
 
-		new->comp_num = dn1->comp_num;
-		new->components = talloc_array(new, struct ldb_dn_component, new->comp_num);
+		newdn->comp_num = dn1->comp_num;
+		newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
 	} else {
 		int comp_num = dn2->comp_num;
 		if (dn1 != NULL) comp_num += dn1->comp_num;
-		new = ldb_dn_copy_partial(mem_ctx, dn2, comp_num);
+		newdn = ldb_dn_copy_partial(mem_ctx, dn2, comp_num);
 	}
 
 	if (dn1 == NULL) {
-		return new;
+		return newdn;
 	}
 
 	for (i = 0; i < dn1->comp_num; i++) {
-		new->components[i] = ldb_dn_copy_component(new->components,
+		newdn->components[i] = ldb_dn_copy_component(newdn->components,
 							   &(dn1->components[i]));
 	}
 
-	return new;
+	return newdn;
 
 failed:
-	talloc_free(new);
+	talloc_free(newdn);
 	return NULL;
 }
 
-- 
cgit 


From 2fe39a82bf3fcd7d9c214151bfaa570f617630f0 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 22 Aug 2006 22:28:37 +0000
Subject: r17722: better to use talloc_vasprintf() than vasprintf() directly,
 as it depends on less libc functions (This used to be commit
 a05101d83b06543cd32b08b4dec29d8f6bd27674)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 7dfcba0631..a0f48723ab 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -836,19 +836,18 @@ struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, c
 	struct ldb_dn *dn;
 	char *child_str;
 	va_list ap;
-	int ret;
 	
 	if (child_fmt == NULL) return NULL;
 
 	va_start(ap, child_fmt);
-	ret = vasprintf(&child_str, child_fmt, ap);
+	child_str = talloc_vasprintf(mem_ctx, child_fmt, ap);
 	va_end(ap);
 
-	if (ret <= 0) return NULL;
+	if (child_str == NULL) return NULL;
 
 	dn = ldb_dn_compose(mem_ctx, ldb_dn_explode(mem_ctx, child_str), base);
 
-	free(child_str);
+	talloc_free(child_str);
 
 	return dn;
 }
-- 
cgit 


From 19df9091358092adf2f6df48783a4f91bc573a5f Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Wed, 4 Oct 2006 19:03:29 +0000
Subject: r19068: Fix a potential NULL dereference (This used to be commit
 2dff8ee8cc8b9faf3fbec46d458d6de214622afc)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index a0f48723ab..204dd3b462 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -345,6 +345,10 @@ struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 
 	/* Allocate a structure to hold the exploded DN */
 	edn = ldb_dn_new(mem_ctx);
+	if (edn == NULL) {
+		return NULL;
+	}
+
 	pdn = NULL;
 
 	/* Empty DNs */
-- 
cgit 


From c56585e5fecb409524607a00dbe5b6e6a956b895 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Wed, 4 Oct 2006 20:15:23 +0000
Subject: r19075: Fix a potential NULL dereference (This used to be commit
 84ae80b39bfa49fe7f9fa801d45a79bf04df8aff)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 204dd3b462..a52569119f 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -674,6 +674,7 @@ static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_d
 	dst.name = talloc_strdup(mem_ctx, src->name);
 	if (dst.name == NULL) {
 		talloc_free(dst.value.data);
+		dst.value.data = NULL;
 	}
 
 	return dst;
@@ -826,6 +827,9 @@ struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const str
 	for (i = 0; i < dn1->comp_num; i++) {
 		newdn->components[i] = ldb_dn_copy_component(newdn->components,
 							   &(dn1->components[i]));
+		if (newdn->components[i].value.data == NULL) {
+			goto failed;
+		}
 	}
 
 	return newdn;
-- 
cgit 


From ecd970abb657ac9472d05bef0f67148cb8ce33e7 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Wed, 4 Oct 2006 20:22:08 +0000
Subject: r19076: ldb_dn_copy_partial can fail (This used to be commit
 78aa689a74941cd6873a91c429889a4c1d1a6432)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index a52569119f..f1d0f185ad 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -818,6 +818,7 @@ struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const str
 		int comp_num = dn2->comp_num;
 		if (dn1 != NULL) comp_num += dn1->comp_num;
 		newdn = ldb_dn_copy_partial(mem_ctx, dn2, comp_num);
+		LDB_DN_NULL_FAILED(newdn);
 	}
 
 	if (dn1 == NULL) {
-- 
cgit 


From 06ac3dbd9aa90e1182106bea731642895b9045fe Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Wed, 4 Oct 2006 20:59:06 +0000
Subject: r19079: talloc_array can fail (This used to be commit
 441ad8a45c390f807a6ec5f27d585aad54f3b210)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index f1d0f185ad..f9b044d5b8 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -698,6 +698,7 @@ struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int n
 	newdn->comp_num = num_el;
 	n = newdn->comp_num - 1;
 	newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
+	if (newdn->components == NULL) goto failed;
 
 	if (dn->comp_num == 0) return newdn;
 	e = dn->comp_num - 1;
-- 
cgit 


From f1f807e66bba73dcb2eb4b1f923167815908a77d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 6 Oct 2006 06:42:05 +0000
Subject: r19113: fixed another checker warning. (This used to be commit
 d12550af01f8d4c135fbf6f429852c31570ec92b)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index f9b044d5b8..e0ef29ccfd 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -597,6 +597,7 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 		struct ldb_dn_component dc;
 		const struct ldb_attrib_handler *h;
 
+		memset(&dc, 0, sizeof(dc));
 		dc.name = ldb_attr_casefold(cedn, edn->components[i].name);
 		if (!dc.name) {
 			talloc_free(cedn);
-- 
cgit 


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

fix compiler warnings

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index e0ef29ccfd..f10e2812f1 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -112,7 +112,7 @@ static struct ldb_val ldb_dn_unescape_value(void *mem_ctx, const char *src)
 
 	LDB_DN_NULL_FAILED(src);
 
-	dst = p = talloc_memdup(mem_ctx, src, strlen(src) + 1);
+	dst = p = (char *)talloc_memdup(mem_ctx, src, strlen(src) + 1);
 	LDB_DN_NULL_FAILED(dst);
 
 	end = &dst[strlen(dst)];
@@ -300,7 +300,8 @@ static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw
 		p[qe] = '\0';
 		p = p + qs + 1;
 		dc.value.length = strlen(p);
-		dc.value.data = talloc_memdup(mem_ctx, p, dc.value.length + 1);
+		dc.value.data = (uint8_t *)talloc_memdup(mem_ctx, p,
+							 dc.value.length + 1);
 		break;
 
 	default: /* mismatched quotes ot other error, bail out */
-- 
cgit 


From bbc056e067e1b721dc2ef6958ab653c1eddec3a1 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 9 Oct 2006 09:56:13 +0000
Subject: r19196: merge from samba3:

pass always a mem_ctx to functions and a ldb_context where needed

metze
(This used to be commit 67a6a41ba3af840cd8226de73576a90ecf602caa)
---
 source4/lib/ldb/common/ldb_dn.c | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index f10e2812f1..d035b0d3c2 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -554,10 +554,10 @@ int ldb_dn_cmp(struct ldb_context *ldb, const char *dn0, const char *dn1)
 
 	if (dn0 == NULL || dn1 == NULL) return dn1 - dn0;
 
-	edn0 = ldb_dn_explode_casefold(ldb, dn0);
+	edn0 = ldb_dn_explode_casefold(ldb, ldb, dn0);
 	if (edn0 == NULL) return 1;
 
-	edn1 = ldb_dn_explode_casefold(ldb, dn1);
+	edn1 = ldb_dn_explode_casefold(ldb, ldb, dn1);
 	if (edn1 == NULL) {
 		talloc_free(edn0);
 		return -1;
@@ -575,14 +575,14 @@ int ldb_dn_cmp(struct ldb_context *ldb, const char *dn0, const char *dn1)
   casefold a dn. We need to casefold the attribute names, and canonicalize 
   attribute values of case insensitive attributes.
 */
-struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn)
+struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, void *mem_ctx, const struct ldb_dn *edn)
 {
 	struct ldb_dn *cedn;
-	int i;
+	int i, ret;
 
 	if (edn == NULL) return NULL;
 
-	cedn = ldb_dn_new(ldb);
+	cedn = ldb_dn_new(mem_ctx);
 	if (!cedn) {
 		return NULL;
 	}
@@ -599,14 +599,17 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 		const struct ldb_attrib_handler *h;
 
 		memset(&dc, 0, sizeof(dc));
-		dc.name = ldb_attr_casefold(cedn, edn->components[i].name);
+		dc.name = ldb_attr_casefold(cedn->components, edn->components[i].name);
 		if (!dc.name) {
 			talloc_free(cedn);
 			return NULL;
 		}
 
 		h = ldb_attrib_handler(ldb, dc.name);
-		if (h->canonicalise_fn(ldb, cedn, &(edn->components[i].value), &(dc.value)) != 0) {
+		ret = h->canonicalise_fn(ldb, cedn->components,
+					 &(edn->components[i].value),
+					 &(dc.value));
+		if (ret != 0) {
 			talloc_free(cedn);
 			return NULL;
 		}
@@ -617,7 +620,7 @@ struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, const struct ldb_dn *edn
 	return cedn;
 }
 
-struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn)
+struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, void *mem_ctx, const char *dn)
 {
 	struct ldb_dn *edn, *cdn;
 
@@ -626,13 +629,13 @@ struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, const char *dn)
 	edn = ldb_dn_explode(ldb, dn);
 	if (edn == NULL) return NULL;
 
-	cdn = ldb_dn_casefold(ldb, edn);
+	cdn = ldb_dn_casefold(ldb, mem_ctx, edn);
 	
 	talloc_free(edn);
 	return cdn;
 }
 
-char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *edn)
+char *ldb_dn_linearize_casefold(struct ldb_context *ldb, void *mem_ctx, const struct ldb_dn *edn)
 {
 	struct ldb_dn *cdn;
 	char *dn;
@@ -641,11 +644,11 @@ char *ldb_dn_linearize_casefold(struct ldb_context *ldb, const struct ldb_dn *ed
 
 	/* Special DNs */
 	if (ldb_dn_is_special(edn)) {
-		dn = talloc_strdup(ldb, (char *)edn->components[0].value.data);
+		dn = talloc_strdup(mem_ctx, (char *)edn->components[0].value.data);
 		return dn;
 	}
 
-	cdn = ldb_dn_casefold(ldb, edn);
+	cdn = ldb_dn_casefold(ldb, mem_ctx, edn);
 	if (cdn == NULL) return NULL;
 
 	dn = ldb_dn_linearize(ldb, cdn);
-- 
cgit 


From d0ba572fabb5ede84b97d71d24d85a4869cc43ce Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 15 Oct 2006 10:11:15 +0000
Subject: r19289: fixed a memory leak in ldb_dn_string_compose() (This used to
 be commit 669aa1424c7a931f57856af0cd4a6f6f4a60b823)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index d035b0d3c2..2902309f10 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -848,7 +848,7 @@ failed:
 
 struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, const char *child_fmt, ...)
 {
-	struct ldb_dn *dn;
+	struct ldb_dn *dn, *dn1;
 	char *child_str;
 	va_list ap;
 	
@@ -860,9 +860,11 @@ struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, c
 
 	if (child_str == NULL) return NULL;
 
-	dn = ldb_dn_compose(mem_ctx, ldb_dn_explode(mem_ctx, child_str), base);
+	dn1 = ldb_dn_explode(mem_ctx, child_str);
+	dn = ldb_dn_compose(mem_ctx, dn1, base);
 
 	talloc_free(child_str);
+	talloc_free(dn1);
 
 	return dn;
 }
-- 
cgit 


From 5535b43efd297deb31c900a60762af1642779278 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 17 Oct 2006 01:18:47 +0000
Subject: r19361: added a comment (This used to be commit
 1581babfb5a5bbbfc2706dbec9b37b03fe9a5af6)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 2902309f10..e937a2b7fc 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -337,6 +337,9 @@ failed:
 	return NULL;
 }
 
+/*
+  explode a DN string into a ldb_dn structure
+*/
 struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
 {
 	struct ldb_dn *edn; /* the exploded dn */
-- 
cgit 


From b7774527faf095f612eb1de48efacec6bd710a87 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 1 Nov 2006 23:31:26 +0000
Subject: r19531: Make struct ldb_dn opaque and local to ldb_dn.c (This used to
 be commit 889fb983ba1cf8a11424a8b3dc3a5ef76e780082)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index e937a2b7fc..550b80c26a 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -41,6 +41,19 @@
 
 #define LDB_SPECIAL "@SPECIAL"
 
+/**
+   internal ldb exploded dn structures
+*/
+struct ldb_dn_component {
+	char *name;  
+	struct ldb_val value;
+};
+
+struct ldb_dn {
+	int comp_num;
+	struct ldb_dn_component *components;
+};
+
 int ldb_dn_is_special(const struct ldb_dn *dn)
 {
 	if (dn == NULL || dn->comp_num != 1) return 0;
@@ -688,6 +701,26 @@ static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_d
 	return dst;
 }
 
+/* Copy a DN but replace the old with the new base DN. */
+struct ldb_dn *ldb_dn_copy_rebase(void *mem_ctx, const struct ldb_dn *old, const struct ldb_dn *old_base, const struct ldb_dn *new_base)
+{
+	struct ldb_dn *new;
+	int i, offset;
+
+	/* Perhaps we don't need to rebase at all? */
+	if (!old_base || !new_base) {
+		return ldb_dn_copy(mem_ctx, old);
+	}
+
+	offset = old->comp_num - old_base->comp_num;
+	new = ldb_dn_copy_partial(mem_ctx, new_base, offset + new_base->comp_num);
+	for (i = 0; i < offset; i++) {
+		new->components[i] = ldb_dn_copy_component(new->components, &(old->components[i]));
+	}
+
+	return new;
+}
+
 /* copy specified number of elements of a dn into a new one
    element are copied from top level up to the unique rdn
    num_el may be greater than dn->comp_num (see ldb_dn_make_child)
@@ -799,15 +832,6 @@ failed:
 
 }
 
-struct ldb_dn *ldb_dn_make_child(void *mem_ctx, const struct ldb_dn_component *component,
-						const struct ldb_dn *base)
-{
-	if (component == NULL) return NULL;
-
-	return ldb_dn_build_child(mem_ctx, component->name, 
-				  (char *)component->value.data, base);
-}
-
 struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2)
 {
 	int i;
@@ -872,28 +896,6 @@ struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, c
 	return dn;
 }
 
-struct ldb_dn_component *ldb_dn_get_rdn(void *mem_ctx, const struct ldb_dn *dn)
-{
-	struct ldb_dn_component *rdn;
-
-	if (dn == NULL) return NULL;
-
-	if (dn->comp_num < 1) {
-		return NULL;
-	}
-
-	rdn = talloc(mem_ctx, struct ldb_dn_component);
-	if (rdn == NULL) return NULL;
-
-	*rdn = ldb_dn_copy_component(mem_ctx, &dn->components[0]);
-	if (rdn->name == NULL) {
-		talloc_free(rdn);
-		return NULL;
-	}
-
-	return rdn;
-}
-
 /* Create a 'canonical name' string from a DN:
 
    ie dc=samba,dc=org -> samba.org/
@@ -962,3 +964,58 @@ char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn) {
 char *ldb_dn_canonical_ex_string(void *mem_ctx, const struct ldb_dn *dn) {
 	return ldb_dn_canonical(mem_ctx, dn, 1);
 }
+
+int ldb_dn_get_comp_num(const struct ldb_dn *dn)
+{
+	return dn->comp_num;
+}
+
+const char *ldb_dn_get_component_name(const struct ldb_dn *dn, unsigned int num)
+{
+	if (num >= dn->comp_num) return NULL;
+	return dn->components[num].name;
+}
+
+const struct ldb_val *ldb_dn_get_component_val(const struct ldb_dn *dn, unsigned int num)
+{
+	if (num >= dn->comp_num) return NULL;
+	return &dn->components[num].value;
+}
+
+const char *ldb_dn_get_rdn_name(const struct ldb_dn *dn) {
+	if (dn->comp_num == 0) return NULL;
+	return dn->components[0].name;
+}
+
+const struct ldb_val *ldb_dn_get_rdn_val(const struct ldb_dn *dn) {
+	if (dn->comp_num == 0) return NULL;
+	return &dn->components[0].value;
+}
+
+int ldb_dn_set_component(struct ldb_dn *dn, int num, const char *name, const struct ldb_val val)
+{
+	char *n;
+	struct ldb_val v;
+
+	if (num >= dn->comp_num) {
+		return LDB_ERR_OTHER;
+	}
+
+	n = talloc_strdup(dn, name);
+	if ( ! n) {
+		return LDB_ERR_OTHER;
+	}
+
+	v.length = val.length;
+	v.data = (uint8_t *)talloc_memdup(dn, val.data, v.length+1);
+	if ( ! v.data) {
+		return LDB_ERR_OTHER;
+	}
+
+	talloc_free(dn->components[num].name);
+	talloc_free(dn->components[num].value.data);
+	dn->components[num].name = n;
+	dn->components[num].value = v;
+
+	return LDB_SUCCESS;
+}
-- 
cgit 


From a39db6303060466ab82366ac9395a6b5a9ca4627 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 15 Nov 2006 15:33:38 +0000
Subject: r19719: don't use 'new' as var name samba3 doesn't like it...

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 550b80c26a..48f471bf6f 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -704,7 +704,7 @@ static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_d
 /* Copy a DN but replace the old with the new base DN. */
 struct ldb_dn *ldb_dn_copy_rebase(void *mem_ctx, const struct ldb_dn *old, const struct ldb_dn *old_base, const struct ldb_dn *new_base)
 {
-	struct ldb_dn *new;
+	struct ldb_dn *new_dn;
 	int i, offset;
 
 	/* Perhaps we don't need to rebase at all? */
@@ -713,12 +713,12 @@ struct ldb_dn *ldb_dn_copy_rebase(void *mem_ctx, const struct ldb_dn *old, const
 	}
 
 	offset = old->comp_num - old_base->comp_num;
-	new = ldb_dn_copy_partial(mem_ctx, new_base, offset + new_base->comp_num);
+	new_dn = ldb_dn_copy_partial(mem_ctx, new_base, offset + new_base->comp_num);
 	for (i = 0; i < offset; i++) {
-		new->components[i] = ldb_dn_copy_component(new->components, &(old->components[i]));
+		new_dn->components[i] = ldb_dn_copy_component(new_dn->components, &(old->components[i]));
 	}
 
-	return new;
+	return new_dn;
 }
 
 /* copy specified number of elements of a dn into a new one
-- 
cgit 


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

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

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

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

Simo.
(This used to be commit a580c871d3784602a9cce32d33419e63c8236e63)
---
 source4/lib/ldb/common/ldb_dn.c | 1508 ++++++++++++++++++++++++---------------
 1 file changed, 921 insertions(+), 587 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 48f471bf6f..0a10ed6f2e 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -25,64 +25,138 @@
 /*
  *  Name: ldb
  *
- *  Component: ldb dn explode and utility functions
+ *  Component: ldb dn creation and manipulation utility functions
  *
  *  Description: - explode a dn into it's own basic elements
- *                 and put them in a structure
+ *                 and put them in a structure (only if necessary)
  *               - manipulate ldb_dn structures
  *
  *  Author: Simo Sorce
  */
 
 #include "includes.h"
+#include <ctype.h>
 #include "ldb/include/includes.h"
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
-#define LDB_SPECIAL "@SPECIAL"
+#define LDB_FREE(x) do { talloc_free(x); x = NULL; } while(0)
 
 /**
    internal ldb exploded dn structures
 */
 struct ldb_dn_component {
-	char *name;  
+
+	char *name;
 	struct ldb_val value;
+
+	char *cf_name;
+	struct ldb_val cf_value;
 };
 
 struct ldb_dn {
-	int comp_num;
+
+	struct ldb_context *ldb;
+
+	/* Special DNs are always linearized */
+	bool special;
+	bool invalid;
+
+	bool valid_lin;
+	bool valid_comp;
+	bool valid_case;
+
+	char *linearized;
+	char *casefold;
+
+	unsigned int comp_num;
 	struct ldb_dn_component *components;
+
 };
 
-int ldb_dn_is_special(const struct ldb_dn *dn)
+/* strdn may be NULL */
+struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *strdn)
 {
-	if (dn == NULL || dn->comp_num != 1) return 0;
+	struct ldb_dn *dn;
 
-	return ! strcmp(dn->components[0].name, LDB_SPECIAL);
-}
+	if ( (! mem_ctx) || (! ldb)) return NULL;
 
-int ldb_dn_check_special(const struct ldb_dn *dn, const char *check)
-{
-	if (dn == NULL || dn->comp_num != 1) return 0;
+	dn = talloc_zero(mem_ctx, struct ldb_dn);
+	LDB_DN_NULL_FAILED(dn);
+
+	dn->ldb = ldb;
+
+	if (strdn) {
+		if (strdn[0] == '@') {
+			dn->special = true;
+		}
+		if (strncasecmp(strdn, "<GUID=", 6) == 0) {
+			/* this is special DN returned when the
+			 * exploded_dn control is used */
+			dn->special = true;
+			/* FIXME: add a GUID string to ldb_dn structure */
+		}
+		dn->linearized = talloc_strdup(dn, strdn);
+	} else {
+		dn->linearized = talloc_strdup(dn, "");
+	}
+	LDB_DN_NULL_FAILED(dn->linearized);
+
+	dn->valid_lin = true;
+
+	return dn;
 
-	return ! strcmp((char *)dn->components[0].value.data, check);
+failed:
+	talloc_free(dn);
+	return NULL;
 }
 
-char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
+struct ldb_dn *ldb_dn_new_fmt(void *mem_ctx, struct ldb_context *ldb, const char *new_fmt, ...)
 {
-	const char *p, *s, *src;
-	char *d, *dst;
-	int len;
+	struct ldb_dn *dn;
+	char *strdn;
+	va_list ap;
 
-	if (!value.length)
-		return NULL;
+	if ( (! mem_ctx) || (! ldb)) return NULL;
+
+	dn = talloc_zero(mem_ctx, struct ldb_dn);
+	LDB_DN_NULL_FAILED(dn);
 
-	p = s = src = (const char *)value.data;
-	len = value.length;
+	dn->ldb = ldb;
 
-	/* allocate destination string, it will be at most 3 times the source */
-	dst = d = talloc_array(mem_ctx, char, len * 3 + 1);
-	LDB_DN_NULL_FAILED(dst);
+	va_start(ap, new_fmt);
+	strdn = talloc_vasprintf(dn, new_fmt, ap);
+	va_end(ap);
+	LDB_DN_NULL_FAILED(strdn);
+
+	if (strdn[0] == '@') {
+		dn->special = true;
+	}
+	if (strncasecmp(strdn, "<GUID=", 6) == 0) {
+		/* this is special DN returned when the
+		 * exploded_dn control is used */
+		dn->special = true;
+		/* FIXME: add a GUID string to ldb_dn structure */
+	}
+	dn->linearized = strdn;
+
+	dn->valid_lin = true;
+
+	return dn;
+
+failed:
+	talloc_free(dn);
+	return NULL;
+}
+
+static int ldb_dn_escape_internal(char *dst, const char *src, int len)
+{
+	const char *p, *s;
+	char *d;
+	int l;
+
+	p = s = src;
+	d = dst;
 
 	while (p - src < len) {
 
@@ -99,404 +173,500 @@ char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 			*d++ = *p++;
 		} else { /* we have a zero byte in the string */
 			strncpy(d, "\00", 3); /* escape the zero */
-			d = d + 3;
+			d += 3;
 			p++; /* skip the zero */
 		}
 		s = p; /* move forward */
 	}
 
 	/* copy the last part (with zero) and return */
-	memcpy(d, s, &src[len] - s + 1);
+	l = len - (s - src);
+	memcpy(d, s, l + 1);
 
-	return dst;
-
-failed:
-	talloc_free(dst);
-	return NULL;
-}
+	/* return the length of the resulting string */
+	return (l + (d - dst));
+} 
 
-static struct ldb_val ldb_dn_unescape_value(void *mem_ctx, const char *src)
+char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 {
-	struct ldb_val value;
-	unsigned x;
-	char *p, *dst = NULL, *end;
-
-	memset(&value, 0, sizeof(value));
-
-	LDB_DN_NULL_FAILED(src);
-
-	dst = p = (char *)talloc_memdup(mem_ctx, src, strlen(src) + 1);
-	LDB_DN_NULL_FAILED(dst);
-
-	end = &dst[strlen(dst)];
-
-	while (*p) {
-		p += strcspn(p, ",=\n+<>#;\\\"");
-
-		if (*p == '\\') {
-			if (strchr(",=\n+<>#;\\\"", p[1])) {
-				memmove(p, p + 1, end - (p + 1) + 1);
-				end--;
-				p++;
-				continue;
-			}
+	char *dst;
 
-			if (sscanf(p + 1, "%02x", &x) == 1) {
-				*p = (unsigned char)x;
-				memmove(p + 1, p + 3, end - (p + 3) + 1);
-				end -= 2;
-				p++;
-				continue;
-			}
-		}
+	if (!value.length)
+		return NULL;
 
-		/* a string with not escaped specials is invalid (tested) */
-		if (*p != '\0') {
-			goto failed;
-		}
+	/* allocate destination string, it will be at most 3 times the source */
+	dst = talloc_array(mem_ctx, char, value.length * 3 + 1);
+	if ( ! dst) {
+		talloc_free(dst);
+		return NULL;
 	}
 
-	value.length = end - dst;
-	value.data = (uint8_t *)dst;
-	return value;
+	ldb_dn_escape_internal(dst, (const char *)value.data, value.length);
 
-failed:
-	talloc_free(dst);
-	return value;
+	return dst;
 }
 
-/* check if the string contains quotes
- * skips leading and trailing spaces
- * - returns 0 if no quotes found
- * - returns 1 if quotes are found and put their position
- *   in *quote_start and *quote_end parameters
- * - return -1 if there are open quotes
- */
-
-static int get_quotes_position(const char *source, int *quote_start, int *quote_end)
+/*
+  explode a DN string into a ldb_dn structure
+  based on RFC4514 except that we don't support multiple valued RDNs
+*/
+static bool ldb_dn_explode(struct ldb_dn *dn)
 {
-	const char *p;
-
-	if (source == NULL || quote_start == NULL || quote_end == NULL) return -1;
-
-	p = source;
-
-	/* check if there are quotes surrounding the value */
-	p += strspn(p, " \n"); /* skip white spaces */
+	char *p, *data, *d, *dt, *t;
+	bool trim = false;
+	bool in_attr = false;
+	bool in_value = false;
+	bool in_quote = false;
+	bool is_oid = false;
+	bool escape = false;
+	unsigned x;
+	int l;
 
-	if (*p == '\"') {
-		*quote_start = p - source;
+	if ( ! dn || dn->invalid) return false;
 
-		p++;
-		while (*p != '\"') {
-			p = strchr(p, '\"');
-			LDB_DN_NULL_FAILED(p);
+	if (dn->valid_comp) {
+		return true;
+	}
 
-			if (*(p - 1) == '\\')
-				p++;
-		}
+	if ( ! dn->valid_lin) {
+		return false;
+	}
 
-		*quote_end = p - source;
-		return 1;
+	/* Empty DNs */
+	if (dn->linearized[0] == '\0') {
+		dn->valid_comp = true;
+		return true;
 	}
 
-	return 0;
+	/* Special DNs case */
+	if (dn->special) {
+		return true;
+	}
 
-failed:
-	return -1;
-}
+	/* in the common case we have 3 or more components */
+	/* make sure all components are zeroed, other functions depend on this */
+	dn->components = talloc_zero_array(dn, struct ldb_dn_component, 3);
+	if ( ! dn->components) {
+		return false;
+	}
+	dn->comp_num = 0;
 
-static char *seek_to_separator(char *string, const char *separators)
-{
-	char *p, *q;
-	int ret, qs, qe, escaped;
+	/* Components data space is allocated here once */
+	data = talloc_array(dn->components, char, strlen(dn->linearized) + 1);
 
-	if (string == NULL || separators == NULL) return NULL;
+	p = dn->linearized;
+	in_attr = true;
+	trim = true;
+	t = NULL;
+	d = dt = data;
 
-	p = strchr(string, '=');
-	LDB_DN_NULL_FAILED(p);
+	while (*p) {
 
-	p++;
+		if (in_attr) {
+			if (trim) {
+				if (*p == ' ') {
+					p++;
+					continue;
+				}
+
+				/* first char */
+				trim = false;
+
+				if (isdigit(*p)) {
+					is_oid = true;
+				} else
+				if ( ! isalpha(*p)) {
+					/* not a digit nor an alpha, invalid attribute name */
+					dn->invalid = true;
+					goto failed;
+				}
+				
+				*d++ = *p++;
+				continue;
+			}
 
-	/* check if there are quotes surrounding the value */
+			if (*p == ' ') {
+				p++;
+				/* valid only if we are at the end */
+				trim = true;
+				continue;
+			}
 
-	ret = get_quotes_position(p, &qs, &qe);
-	if (ret == -1)
-		return NULL;
+			if (trim && (*p != '=')) {
+				/* spaces/tabs are not allowed in attribute names */
+				dn->invalid = true;
+				goto failed;
+			}
 
-	if (ret == 1) { /* quotes found */
+			if (*p == '=') {
+				/* attribute terminated */
+				in_attr = false;
+				in_value = true;
+				trim = true;
+				l = 0;
 
-		p += qe; /* positioning after quotes */
-		p += strspn(p, " \n"); /* skip white spaces after the quote */
+				*d++ = '\0';
+				dn->components[dn->comp_num].name = dt;
+				dt = d;
 
-		if (strcspn(p, separators) != 0) /* if there are characters between quotes */
-			return NULL;	    /* and separators, the dn is invalid */
+				p++;
+				continue;
+			}
 
-		return p; /* return on the separator */
-	}
+			if (is_oid && ( ! (isdigit(*p) || (*p == '.')))) {
+				/* not a digit nor a dot, invalid attribute oid */
+				dn->invalid = true;
+				goto failed;
+			} else
+			if ( ! (isalpha(*p) || isdigit(*p) || (*p == '-'))) {
+				/* not ALPHA, DIGIT or HYPHEN */
+				dn->invalid = true;
+				goto failed;
+			}
 
-	/* no quotes found seek to separators */
-	q = p;
-	do {
-		escaped = 0;
-		ret = strcspn(q, separators);
-		
-		if (q[ret - 1] == '\\') {
-			escaped = 1;
-			q = q + ret + 1;
+			*d++ = *p++;
+			continue;
 		}
-	} while (escaped);
-
-	if (ret == 0 && p == q) /* no separators ?! bail out */
-		return NULL;
 
-	return q + ret;
+		if (in_value) {
+			if (in_quote) {
+				if (*p == '\"') {
+					if (p[-1] != '\\') {
+						p++;
+						in_quote = false;
+						continue;
+					}
+				}
+				*d++ = *p++;
+				l++;
+				continue;
+			}
 
-failed:
-	return NULL;
-}
+			if (trim) {
+				if (*p == ' ') {
+					p++;
+					continue;
+				}
 
-static char *ldb_dn_trim_string(char *string, const char *edge)
-{
-	char *s, *p;
+				/* first char */
+				trim = false;
 
-	/* seek out edge from start of string */
-	s = string + strspn(string, edge);
+				if (*p == '\"') {
+					in_quote = true;
+					p++;
+					continue;
+				}
+			}
 
-	/* backwards skip from end of string */
-	p = &s[strlen(s) - 1];
-	while (p > s && strchr(edge, *p)) {
-		*p = '\0';
-		p--;
-	}
+			switch (*p) {
 
-	return s;
-}
+			/* TODO: support ber encoded values
+			case '#':
+			*/
 
-/* we choosed to not support multpile valued components */
-static struct ldb_dn_component ldb_dn_explode_component(void *mem_ctx, char *raw_component)
-{
-	struct ldb_dn_component dc;
-	char *p;
-	int ret, qs, qe;
+			case ',':
+				if (escape) {
+					*d++ = *p++;
+					l++;
+					escape = false;
+					continue;
+				}
+				/* ok found value terminator */
 
-	memset(&dc, 0, sizeof(dc));
+				if ( t ) {
+					/* trim back */
+					d -= (p - t);
+					l -= (p - t);
+				}
 
-	if (raw_component == NULL) {
-		return dc;
-	}
+				in_attr = true;
+				in_value = false;
+				trim = true;
 
-	/* find attribute type/value separator */
-	p = strchr(raw_component, '=');
-	LDB_DN_NULL_FAILED(p);
+				p++;
+				*d++ = '\0';
+				dn->components[dn->comp_num].value.data = (uint8_t *)dt;
+				dn->components[dn->comp_num].value.length = l;
+				dt = d;
+
+				dn->comp_num++;
+				if (dn->comp_num > 2) {
+					dn->components = talloc_realloc(dn,
+									dn->components,
+									struct ldb_dn_component,
+									dn->comp_num + 1);
+					if ( ! dn->components) {
+						/* ouch ! */
+						goto failed;
+					}
+					/* make sure all components are zeroed, other functions depend on this */
+					memset(&dn->components[dn->comp_num], '\0', sizeof(struct ldb_dn_component));
+				}
 
-	*p++ = '\0'; /* terminate name and point to value */
+				continue;
 
-	/* copy and trim name in the component */
-	dc.name = talloc_strdup(mem_ctx, ldb_dn_trim_string(raw_component, " \n"));
-	if (!dc.name)
-		return dc;
+			case '=':
+			case '\n':
+			case '+':
+			case '<':
+			case '>':
+			case '#':
+			case ';':
+			case '\"':
+				/* a string with not escaped specials is invalid (tested) */
+				if ( ! escape) {
+					dn->invalid = true;
+					goto failed;
+				}
+				escape = false;
+
+				*d++ = *p++;
+				l++;
+
+				if ( t ) t = NULL;
+				break;
+
+			case '\\':
+				if ( ! escape) {
+					escape = true;
+					p++;
+					continue;
+				}
+				escape = false;
+
+				*d++ = *p++;
+				l++;
+
+				if ( t ) t = NULL;
+				break;
+
+			default:
+				if (escape) {
+	 				if (sscanf(p, "%02x", &x) != 1) {
+						/* invalid escaping sequence */
+						dn->invalid = true;
+						goto failed;
+					}
+					escape = false;
+
+					p += 2;
+					*d++ = (unsigned char)x;
+					l++;
+
+					if ( t ) t = NULL;
+					break;
+				}
+
+				if (*p == ' ') { 
+					if ( ! t) t = p;
+				} else {
+					if ( t ) t = NULL;
+				}
+
+				*d++ = *p++;
+				l++;
+				
+				break;
+			}
 
-	if (! ldb_valid_attr_name(dc.name)) {
-		goto failed;
+		}
 	}
 
-	ret = get_quotes_position(p, &qs, &qe);
-
-	switch (ret) {
-	case 0: /* no quotes trim the string */
-		p = ldb_dn_trim_string(p, " \n");
-		dc.value = ldb_dn_unescape_value(mem_ctx, p);
-		break;
-
-	case 1: /* quotes found get the unquoted string */
-		p[qe] = '\0';
-		p = p + qs + 1;
-		dc.value.length = strlen(p);
-		dc.value.data = (uint8_t *)talloc_memdup(mem_ctx, p,
-							 dc.value.length + 1);
-		break;
-
-	default: /* mismatched quotes ot other error, bail out */
+	if (in_attr || in_quote) {
+		/* invalid dn */
+		dn->invalid = true;
 		goto failed;
 	}
 
-	if (dc.value.length == 0) {
-		goto failed;
+	/* save last element */
+	if ( t ) {
+		/* trim back */
+		d -= (p - t);
+		l -= (p - t);
 	}
 
-	return dc;
+	*d++ = '\0';
+	dn->components[dn->comp_num].value.data = (uint8_t *)dt;
+	dn->components[dn->comp_num].value.length = l;
+
+	dn->comp_num++;
+
+	dn->valid_comp = true;
+	return true;
 
 failed:
-	talloc_free(dc.name);
-	dc.name = NULL;
-	return dc;
+	talloc_free(dn->components);
+	return false;
 }
 
-struct ldb_dn *ldb_dn_new(void *mem_ctx)
+bool ldb_dn_validate(struct ldb_dn *dn)
 {
-	struct ldb_dn *edn;
-
-	edn = talloc(mem_ctx, struct ldb_dn);
-	LDB_DN_NULL_FAILED(edn);
-
-	/* Initially there are no components */
-	edn->comp_num = 0;
-	edn->components = NULL;
-
-	return edn;
-
-failed:
-	return NULL;
+	return ldb_dn_explode(dn);
 }
 
-/*
-  explode a DN string into a ldb_dn structure
-*/
-struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn)
+const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 {
-	struct ldb_dn *edn; /* the exploded dn */
-	char *pdn, *p;
+	int i, len;
+	char *d, *n;
+
+	if ( ! dn || ( dn->invalid)) return NULL;
 
-	if (dn == NULL) return NULL;
+	if (dn->valid_lin) return dn->linearized;
 
-	/* Allocate a structure to hold the exploded DN */
-	edn = ldb_dn_new(mem_ctx);
-	if (edn == NULL) {
+	if ( ! dn->valid_comp) {
+		dn->invalid = true;
 		return NULL;
 	}
 
-	pdn = NULL;
-
-	/* Empty DNs */
-	if (dn[0] == '\0') {
-		return edn;
+	if (dn->comp_num == 0) {
+		dn->linearized = talloc_strdup(dn, "");
+		if ( ! dn->linearized) return NULL;
+		dn->valid_lin = true;
+		return dn->linearized;
 	}
 
-	/* Special DNs case */
-	if (dn[0] == '@') {
-		edn->comp_num = 1;
-		edn->components = talloc(edn, struct ldb_dn_component);
-		if (edn->components == NULL) goto failed;
-		edn->components[0].name = talloc_strdup(edn->components, LDB_SPECIAL);
-		if (edn->components[0].name == NULL) goto failed;
-		edn->components[0].value.data = (uint8_t *)talloc_strdup(edn->components, dn);
-		if (edn->components[0].value.data== NULL) goto failed;
-		edn->components[0].value.length = strlen(dn);
-		return edn;
+	/* calculate maximum possible length of DN */
+	for (len = 0, i = 0; i < dn->comp_num; i++) {
+		len += strlen(dn->components[i].name); /* name len */
+		len += (dn->components[i].value.length * 3); /* max escaped data len */
+		len += 2; /* '=' and ',' */
 	}
+	dn->linearized = talloc_array(dn, char, len);
+	if ( ! dn->linearized) return NULL;
 
-	pdn = p = talloc_strdup(edn, dn);
-	LDB_DN_NULL_FAILED(pdn);
+	d = dn->linearized;
 
-	/* get the components */
-	do {
-		char *t;
+	for (i = 0; i < dn->comp_num; i++) {
 
-		/* terminate the current component and return pointer to the next one */
-		t = seek_to_separator(p, ",;");
-		LDB_DN_NULL_FAILED(t);
+		/* copy the name */
+		n = dn->components[i].name;
+		while (*n) *d++ = *n++;
 
-		if (*t) { /* here there is a separator */
-			*t = '\0'; /*terminate */
-			t++; /* a separtor means another component follows */
-		}
-
-		/* allocate space to hold the dn component */
-		edn->components = talloc_realloc(edn, edn->components,
-						 struct ldb_dn_component,
-						 edn->comp_num + 1);
-		if (edn->components == NULL)
-			goto failed;
+		*d++ = '=';
 
-		/* store the exploded component in the main structure */
-		edn->components[edn->comp_num] = ldb_dn_explode_component(edn, p);
-		LDB_DN_NULL_FAILED(edn->components[edn->comp_num].name);
+		/* and the value */
+		d += ldb_dn_escape_internal( d,
+				(char *)dn->components[i].value.data,
+				dn->components[i].value.length);
+		*d++ = ',';
+	}
 
-		edn->comp_num++;
+	*(--d) = '\0';
 
-		/* jump to the next component if any */
-		p = t;
+	dn->valid_lin = true;
 
-	} while(*p);
+	/* don't waste more memory than necessary */
+	dn->linearized = talloc_realloc(dn, dn->linearized, char, (d - dn->linearized + 1));
 
-	talloc_free(pdn);
-	return edn;
+	return dn->linearized;
+}
 
-failed:
-	talloc_free(pdn);
-	talloc_free(edn);
-	return NULL;
+char *ldb_dn_linearize(void *mem_ctx, struct ldb_dn *dn)
+{
+	return talloc_strdup(mem_ctx, ldb_dn_get_linearized(dn));
 }
 
-struct ldb_dn *ldb_dn_explode_or_special(void *mem_ctx, const char *dn)
+/*
+  casefold a dn. We need to casefold the attribute names, and canonicalize 
+  attribute values of case insensitive attributes.
+*/
+
+static bool ldb_dn_casefold_internal(struct ldb_dn *dn)
 {
-	struct ldb_dn *edn; /* the exploded dn */
+	int i, ret;
 
-	if (dn == NULL) return NULL;
+	if ( ! dn || dn->invalid) return false;
 
-	if (strncasecmp(dn, "<GUID=", 6) == 0) {
-		/* this is special DN returned when the
-		 * exploded_dn control is used
-		 */
+	if (dn->valid_case) return true;
+
+	if (( ! dn->valid_comp) && ( ! ldb_dn_explode(dn))) {
+		return false;
+	}
 
-		/* Allocate a structure to hold the exploded DN */
-		edn = ldb_dn_new(mem_ctx);
+	for (i = 0; i < dn->comp_num; i++) {
+		struct ldb_dn_component dc;
+		const struct ldb_attrib_handler *h;
 
-		edn->comp_num = 1;
-		edn->components = talloc(edn, struct ldb_dn_component);
-		if (edn->components == NULL) goto failed;
-		edn->components[0].name = talloc_strdup(edn->components, LDB_SPECIAL);
-		if (edn->components[0].name == NULL) goto failed;
-		edn->components[0].value.data = (uint8_t *)talloc_strdup(edn->components, dn);
-		if (edn->components[0].value.data== NULL) goto failed;
-		edn->components[0].value.length = strlen(dn);
-		return edn;
+		memset(&dc, 0, sizeof(dc));
+		dn->components[i].cf_name = ldb_attr_casefold(dn->components, dn->components[i].name);
+		if (!dn->components[i].cf_name) {
+			return false;
+		}
 
+		h = ldb_attrib_handler(dn->ldb, dn->components[i].cf_name);
+		ret = h->canonicalise_fn(dn->ldb, dn->components,
+					 &(dn->components[i].value),
+					 &(dn->components[i].cf_value));
+		if (ret != 0) {
+			return false;
+		}
 	}
-	
-	return ldb_dn_explode(mem_ctx, dn);
 
-failed:
-	talloc_free(edn);
-	return NULL;
+	return true;
 }
 
-char *ldb_dn_linearize(void *mem_ctx, const struct ldb_dn *edn)
+const char *ldb_dn_get_casefold(struct ldb_dn *dn)
 {
-	char *dn, *value;
-	int i;
-
-	if (edn == NULL) return NULL;
+	int i, len;
+	char *d, *n;
 
-	/* Special DNs */
-	if (ldb_dn_is_special(edn)) {
-		dn = talloc_strdup(mem_ctx, (char *)edn->components[0].value.data);
-		return dn;
+	if ( ! ldb_dn_casefold_internal(dn)) {
+		return NULL;
 	}
 
-	dn = talloc_strdup(mem_ctx, "");
-	LDB_DN_NULL_FAILED(dn);
-
-	for (i = 0; i < edn->comp_num; i++) {
-		value = ldb_dn_escape_value(dn, edn->components[i].value);
-		LDB_DN_NULL_FAILED(value);
+	if (dn->casefold) return dn->casefold;
 
-		if (i == 0) {
-			dn = talloc_asprintf_append(dn, "%s=%s", edn->components[i].name, value);
+	if (dn->comp_num == 0) {
+		if (dn->special) {
+			len = strlen(dn->linearized);
+			dn->casefold = talloc_array(dn, char, len * 3 + 1);
+			if ( ! dn->casefold) return NULL;
+			ldb_dn_escape_internal(dn->casefold, dn->linearized, len);
+			/* don't waste more memory than necessary */
+			dn->casefold = talloc_realloc(dn, dn->casefold, char, strlen(dn->casefold) + 1);
 		} else {
-			dn = talloc_asprintf_append(dn, ",%s=%s", edn->components[i].name, value);
+			dn->casefold = talloc_strdup(dn, "");
+			if ( ! dn->casefold) return NULL;
 		}
-		LDB_DN_NULL_FAILED(dn);
+		dn->valid_case = true;
+		return dn->casefold;
+	}
 
-		talloc_free(value);
+	/* calculate maximum possible length of DN */
+	for (len = 0, i = 0; i < dn->comp_num; i++) {
+		len += strlen(dn->components[i].cf_name); /* name len */
+		len += (dn->components[i].cf_value.length * 3); /* max escaped data len */
+		len += 2; /* '=' and ',' */
 	}
+	dn->casefold = talloc_array(dn, char, len);
+	if ( ! dn->casefold) return NULL;
 
-	return dn;
+	d = dn->casefold;
 
-failed:
-	talloc_free(dn);
-	return NULL;
+	for (i = 0; i < dn->comp_num; i++) {
+
+		/* copy the name */
+		n = dn->components[i].cf_name;
+		while (*n) *d++ = *n++;
+
+		*d++ = '=';
+
+		/* and the value */
+		d += ldb_dn_escape_internal( d,
+				(char *)dn->components[i].cf_value.data,
+				dn->components[i].cf_value.length);
+		*d++ = ',';
+	}
+	*(--d) = '\0';
+
+	dn->valid_case = true;
+
+	return dn->casefold;
+}
+
+char *ldb_dn_casefold(void *mem_ctx, struct ldb_dn *dn)
+{
+	return talloc_strdup(mem_ctx, ldb_dn_get_casefold(dn));
 }
 
 /* Determine if dn is below base, in the ldap tree.  Used for
@@ -504,42 +674,65 @@ failed:
  * 0 if they match, otherwise non-zero
  */
 
-int ldb_dn_compare_base(struct ldb_context *ldb,
-			const struct ldb_dn *base,
-			const struct ldb_dn *dn)
+int ldb_dn_compare_base(struct ldb_dn *base, struct ldb_dn *dn)
 {
 	int ret;
-	int n0, n1;
+	int n_base, n_dn;
+
+	if ( ! base || base->invalid) return 1;
+	if ( ! dn || dn->invalid) return -1;
+
+	if (( ! base->valid_case) || ( ! dn->valid_case)) {
+		if (base->valid_lin && dn->valid_lin) {
+			/* try with a normal compare first, if we are lucky
+			 * we will avoid exploding and casfolding */
+			int dif;
+			dif = strlen(dn->linearized) - strlen(base->linearized);
+			if (dif < 0) return dif;
+			if (strcmp(base->linearized, &dn->linearized[dif]) == 0) return 0;
+		}
 
-	if (base == NULL || base->comp_num == 0) return 0;
-	if (dn == NULL || dn->comp_num == 0) return -1;
+		if ( ! ldb_dn_casefold_internal(base)) {
+			return 1;
+		}
 
-	/* if the base has more componts than the dn, then they differ */
+		if ( ! ldb_dn_casefold_internal(dn)) {
+			return -1;
+		}
+
+	}
+
+	/* if base has more components,
+	 * they don't have the same base */
 	if (base->comp_num > dn->comp_num) {
 		return (dn->comp_num - base->comp_num);
 	}
 
-	n0 = base->comp_num - 1;
-	n1 = dn->comp_num - 1;
-	while (n0 >= 0 && n1 >= 0) {
-		const struct ldb_attrib_handler *h;
-
-		/* compare names (attribute names are guaranteed to be ASCII only) */
-		ret = ldb_attr_cmp(base->components[n0].name,
-				   dn->components[n1].name);
-		if (ret) {
-			return ret;
+	if (dn->comp_num == 0) {
+		if (dn->special && base->special) {
+			return strcmp(base->linearized, dn->linearized);
+		} else {
+			return 0;
 		}
+	}
+
+	n_base = base->comp_num - 1;
+	n_dn = dn->comp_num - 1;
 
-		/* names match, compare values */
-		h = ldb_attrib_handler(ldb, base->components[n0].name);
-		ret = h->comparison_fn(ldb, ldb, &(base->components[n0].value),
-						  &(dn->components[n1].value));
-		if (ret) {
-			return ret;
+	while (n_base >= 0) {
+		/* compare attr names */
+		ret = strcmp(base->components[n_base].cf_name, dn->components[n_dn].cf_name);
+		if (ret != 0) return ret;
+
+		/* compare attr.cf_value. */ 
+		if (base->components[n_base].cf_value.length != dn->components[n_dn].cf_value.length) {
+			return base->components[n_base].cf_value.length - dn->components[n_dn].cf_value.length;
 		}
-		n1--;
-		n0--;
+		ret = strcmp((char *)base->components[n_base].cf_value.data, (char *)dn->components[n_dn].cf_value.data);
+		if (ret != 0) return ret;
+
+		n_base--;
+		n_dn--;
 	}
 
 	return 0;
@@ -550,350 +743,433 @@ int ldb_dn_compare_base(struct ldb_context *ldb,
    If they match, then return 0
  */
 
-int ldb_dn_compare(struct ldb_context *ldb,
-		   const struct ldb_dn *edn0,
-		   const struct ldb_dn *edn1)
+int ldb_dn_compare(struct ldb_dn *dn0, struct ldb_dn *dn1)
 {
-	if (edn0 == NULL || edn1 == NULL) return edn1 - edn0;
+	int i, ret;
 
-	if (edn0->comp_num != edn1->comp_num)
-		return (edn1->comp_num - edn0->comp_num);
+	if (( ! dn0) || dn0->invalid || ! dn1 || dn1->invalid) return -1;
 
-	return ldb_dn_compare_base(ldb, edn0, edn1);
+	if (( ! dn0->valid_case) || ( ! dn1->valid_case)) {
+		if (dn0->valid_lin && dn1->valid_lin) {
+			/* try with a normal compare first, if we are lucky
+			 * we will avoid exploding and casfolding */
+			if (strcmp(dn0->linearized, dn1->linearized) == 0) return 0;
+		}
+
+		if ( ! ldb_dn_casefold_internal(dn0)) {
+			return 1;
+		}
+
+		if ( ! ldb_dn_casefold_internal(dn1)) {
+			return -1;
+		}
+
+	}
+
+	if (dn0->comp_num != dn1->comp_num) {
+		return (dn1->comp_num - dn0->comp_num);
+	}
+
+	if (dn0->comp_num == 0) {
+		if (dn0->special && dn1->special) {
+			return strcmp(dn0->linearized, dn1->linearized);
+		} else {
+			return 0;
+		}
+	}
+
+	for (i = 0; i < dn0->comp_num; i++) {
+		/* compare attr names */
+		ret = strcmp(dn0->components[i].cf_name, dn1->components[i].cf_name);
+		if (ret != 0) return ret;
+
+		/* compare attr.cf_value. */ 
+		if (dn0->components[i].cf_value.length != dn1->components[i].cf_value.length) {
+			return dn0->components[i].cf_value.length - dn1->components[i].cf_value.length;
+		}
+		ret = strcmp((char *)dn0->components[i].cf_value.data, (char *)dn1->components[i].cf_value.data);
+		if (ret != 0) return ret;
+	}
+
+	return 0;
 }
 
-int ldb_dn_cmp(struct ldb_context *ldb, const char *dn0, const char *dn1)
+static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_dn_component *src)
 {
-	struct ldb_dn *edn0;
-	struct ldb_dn *edn1;
-	int ret;
+	struct ldb_dn_component dst;
+
+	memset(&dst, 0, sizeof(dst));
 
-	if (dn0 == NULL || dn1 == NULL) return dn1 - dn0;
+	if (src == NULL) {
+		return dst;
+	}
 
-	edn0 = ldb_dn_explode_casefold(ldb, ldb, dn0);
-	if (edn0 == NULL) return 1;
+	dst.value = ldb_val_dup(mem_ctx, &(src->value));
+	if (dst.value.data == NULL) {
+		return dst;
+	}
 
-	edn1 = ldb_dn_explode_casefold(ldb, ldb, dn1);
-	if (edn1 == NULL) {
-		talloc_free(edn0);
-		return -1;
+	dst.name = talloc_strdup(mem_ctx, src->name);
+	if (dst.name == NULL) {
+		LDB_FREE(dst.value.data);
 	}
 
-	ret = ldb_dn_compare(ldb, edn0, edn1);
+	if (src->cf_value.data) {
+		dst.cf_value = ldb_val_dup(mem_ctx, &(src->cf_value));
+		if (dst.cf_value.data == NULL) {
+			LDB_FREE(dst.value.data);
+			LDB_FREE(dst.name);
+			return dst;
+		}
 
-	talloc_free(edn0);
-	talloc_free(edn1);
+		dst.cf_name = talloc_strdup(mem_ctx, src->cf_name);
+		if (dst.cf_name == NULL) {
+			LDB_FREE(dst.cf_name);
+			LDB_FREE(dst.value.data);
+			LDB_FREE(dst.name);
+			return dst;
+		}
+	} else {
+		dst.cf_value.data = NULL;
+		dst.cf_name = NULL;
+	}
 
-	return ret;
+	return dst;
 }
 
-/*
-  casefold a dn. We need to casefold the attribute names, and canonicalize 
-  attribute values of case insensitive attributes.
-*/
-struct ldb_dn *ldb_dn_casefold(struct ldb_context *ldb, void *mem_ctx, const struct ldb_dn *edn)
+struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
 {
-	struct ldb_dn *cedn;
-	int i, ret;
-
-	if (edn == NULL) return NULL;
+	struct ldb_dn *new_dn;
 
-	cedn = ldb_dn_new(mem_ctx);
-	if (!cedn) {
+	if (!dn || dn->invalid) {
 		return NULL;
 	}
 
-	cedn->comp_num = edn->comp_num;
-	cedn->components = talloc_array(cedn, struct ldb_dn_component, edn->comp_num);
-	if (!cedn->components) {
-		talloc_free(cedn);
+	new_dn = talloc_zero(mem_ctx, struct ldb_dn);
+	if ( !new_dn) {
 		return NULL;
 	}
 
-	for (i = 0; i < edn->comp_num; i++) {
-		struct ldb_dn_component dc;
-		const struct ldb_attrib_handler *h;
+	*new_dn = *dn;
 
-		memset(&dc, 0, sizeof(dc));
-		dc.name = ldb_attr_casefold(cedn->components, edn->components[i].name);
-		if (!dc.name) {
-			talloc_free(cedn);
+	if (dn->valid_comp) {
+		int i;
+
+		new_dn->components = talloc_zero_array(new_dn, struct ldb_dn_component, dn->comp_num);
+		if ( ! new_dn->components) {
+			talloc_free(new_dn);
 			return NULL;
 		}
 
-		h = ldb_attrib_handler(ldb, dc.name);
-		ret = h->canonicalise_fn(ldb, cedn->components,
-					 &(edn->components[i].value),
-					 &(dc.value));
-		if (ret != 0) {
-			talloc_free(cedn);
-			return NULL;
+		for (i = 0; i < dn->comp_num; i++) {
+			new_dn->components[i] = ldb_dn_copy_component(new_dn->components, &dn->components[i]);
+			if ( ! new_dn->components[i].value.data) {
+				talloc_free(new_dn);
+				return NULL;
+			}
 		}
 
-		cedn->components[i] = dc;
+		if (dn->casefold) {
+			new_dn->casefold = talloc_strdup(new_dn, dn->casefold);
+			if ( ! new_dn->casefold) {
+				talloc_free(new_dn);
+				return NULL;
+			}
+		}
 	}
 
-	return cedn;
+	if (dn->valid_lin) {
+		new_dn->linearized = talloc_strdup(new_dn, dn->linearized);
+		if ( ! new_dn->linearized) {
+			talloc_free(new_dn);
+			return NULL;
+		}
+	}
+
+	return new_dn;
 }
 
-struct ldb_dn *ldb_dn_explode_casefold(struct ldb_context *ldb, void *mem_ctx, const char *dn)
+/* modify the given dn by adding a base.
+ *
+ * return true if successful and false if not
+ * if false is returned the dn may be marked invalid
+ */
+bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
 {
-	struct ldb_dn *edn, *cdn;
+	const char *s;
+	char *t;
 
-	if (dn == NULL) return NULL;
+	if ( !base || base->invalid || !dn || dn->invalid) {
+		return false;
+	}
 
-	edn = ldb_dn_explode(ldb, dn);
-	if (edn == NULL) return NULL;
+	if (dn->valid_comp) {
+		int i;
 
-	cdn = ldb_dn_casefold(ldb, mem_ctx, edn);
-	
-	talloc_free(edn);
-	return cdn;
-}
+		if ( ! ldb_dn_validate(base)) {
+			return false;
+		}
 
-char *ldb_dn_linearize_casefold(struct ldb_context *ldb, void *mem_ctx, const struct ldb_dn *edn)
-{
-	struct ldb_dn *cdn;
-	char *dn;
+		s = NULL;
+		if (dn->valid_case) {
+			if ( ! (s = ldb_dn_get_casefold(base))) {
+				return false;
+			}
+		}
 
-	if (edn == NULL) return NULL;
+		dn->components = talloc_realloc(dn,
+						dn->components,
+						struct ldb_dn_component,
+						dn->comp_num + base->comp_num);
+		if ( ! dn->components) {
+			dn->invalid = true;
+			return false;
+		}
 
-	/* Special DNs */
-	if (ldb_dn_is_special(edn)) {
-		dn = talloc_strdup(mem_ctx, (char *)edn->components[0].value.data);
-		return dn;
+		for (i = 0; i < base->comp_num; dn->comp_num++, i++) {
+			dn->components[dn->comp_num] = ldb_dn_copy_component(dn->components, &base->components[i]);
+			if (dn->components[dn->comp_num].value.data == NULL) {
+				dn->invalid = true;
+				return false;
+			}
+		}
+
+		if (s) {
+			t = talloc_asprintf(dn, "%s,%s", dn->casefold, s);
+			LDB_FREE(dn->casefold);
+			dn->casefold = t;
+		}
 	}
 
-	cdn = ldb_dn_casefold(ldb, mem_ctx, edn);
-	if (cdn == NULL) return NULL;
+	if (dn->valid_lin) {
 
-	dn = ldb_dn_linearize(ldb, cdn);
-	if (dn == NULL) {
-		talloc_free(cdn);
-		return NULL;
+		s = ldb_dn_get_linearized(base);
+		if ( ! s) {
+			return false;
+		}
+		
+		t = talloc_asprintf(dn, "%s,%s", dn->linearized, s);
+		if ( ! t) {
+			dn->invalid = true;
+			return false;
+		}
+		LDB_FREE(dn->linearized);
+		dn->linearized = t;
 	}
 
-	talloc_free(cdn);
-	return dn;
+	return true;
 }
 
-static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_dn_component *src)
+/* modify the given dn by adding a base.
+ *
+ * return true if successful and false if not
+ * if false is returned the dn may be marked invalid
+ */
+bool ldb_dn_add_base_fmt(struct ldb_dn *dn, const char *base_fmt, ...)
 {
-	struct ldb_dn_component dst;
-
-	memset(&dst, 0, sizeof(dst));
+	struct ldb_dn *base;
+	char *base_str;
+	va_list ap;
+	bool ret;
 
-	if (src == NULL) {
-		return dst;
+	if ( !dn || dn->invalid) {
+		return false;
 	}
 
-	dst.value = ldb_val_dup(mem_ctx, &(src->value));
-	if (dst.value.data == NULL) {
-		return dst;
-	}
+	va_start(ap, base_fmt);
+	base_str = talloc_vasprintf(dn, base_fmt, ap);
+	va_end(ap);
 
-	dst.name = talloc_strdup(mem_ctx, src->name);
-	if (dst.name == NULL) {
-		talloc_free(dst.value.data);
-		dst.value.data = NULL;
+	if (base_str == NULL) {
+		return false;
 	}
 
-	return dst;
-}
+	base = ldb_dn_new(base_str, dn->ldb, base_str);
 
-/* Copy a DN but replace the old with the new base DN. */
-struct ldb_dn *ldb_dn_copy_rebase(void *mem_ctx, const struct ldb_dn *old, const struct ldb_dn *old_base, const struct ldb_dn *new_base)
+	ret = ldb_dn_add_base(dn, base);
+
+	talloc_free(base_str);
+
+	return ret;
+}	
+
+/* modify the given dn by adding children elements.
+ *
+ * return true if successful and false if not
+ * if false is returned the dn may be marked invalid
+ */
+bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
 {
-	struct ldb_dn *new_dn;
-	int i, offset;
+	const char *s;
+	char *t;
 
-	/* Perhaps we don't need to rebase at all? */
-	if (!old_base || !new_base) {
-		return ldb_dn_copy(mem_ctx, old);
+	if ( !child || child->invalid || !dn || dn->invalid) {
+		return false;
 	}
 
-	offset = old->comp_num - old_base->comp_num;
-	new_dn = ldb_dn_copy_partial(mem_ctx, new_base, offset + new_base->comp_num);
-	for (i = 0; i < offset; i++) {
-		new_dn->components[i] = ldb_dn_copy_component(new_dn->components, &(old->components[i]));
-	}
+	if (dn->valid_comp) {
+		int n, i, j;
 
-	return new_dn;
-}
+		if ( ! ldb_dn_validate(child)) {
+			return false;
+		}
 
-/* copy specified number of elements of a dn into a new one
-   element are copied from top level up to the unique rdn
-   num_el may be greater than dn->comp_num (see ldb_dn_make_child)
-*/
-struct ldb_dn *ldb_dn_copy_partial(void *mem_ctx, const struct ldb_dn *dn, int num_el)
-{
-	struct ldb_dn *newdn;
-	int i, n, e;
+		s = NULL;
+		if (dn->valid_case) {
+			if ( ! (s = ldb_dn_get_casefold(child))) {
+				return false;
+			}
+		}
+
+		n = dn->comp_num + child->comp_num;
 
-	if (dn == NULL) return NULL;
-	if (num_el <= 0) return NULL;
+		dn->components = talloc_realloc(dn,
+						dn->components,
+						struct ldb_dn_component,
+						n);
+		if ( ! dn->components) {
+			dn->invalid = true;
+			return false;
+		}
 
-	newdn = ldb_dn_new(mem_ctx);
-	LDB_DN_NULL_FAILED(newdn);
+		for (i = dn->comp_num - 1, j = n - 1; i >= 0; i--, j--) {
+			dn->components[j] = dn->components[i];
+		}
 
-	newdn->comp_num = num_el;
-	n = newdn->comp_num - 1;
-	newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
-	if (newdn->components == NULL) goto failed;
+		for (i = 0; i < child->comp_num; i++) {	
+			dn->components[i] = ldb_dn_copy_component(dn->components, &child->components[i]);
+			if (dn->components[i].value.data == NULL) {
+				dn->invalid = true;
+				return false;
+			}
+		}
 
-	if (dn->comp_num == 0) return newdn;
-	e = dn->comp_num - 1;
+		dn->comp_num = n;
 
-	for (i = 0; i < newdn->comp_num; i++) {
-		newdn->components[n - i] = ldb_dn_copy_component(newdn->components,
-								&(dn->components[e - i]));
-		if ((e - i) == 0) {
-			return newdn;
+		if (s) {
+			t = talloc_asprintf(dn, "%s,%s", s, dn->casefold);
+			LDB_FREE(dn->casefold);
+			dn->casefold = t;
 		}
 	}
 
-	return newdn;
+	if (dn->valid_lin) {
 
-failed:
-	talloc_free(newdn);
-	return NULL;
-}
-
-struct ldb_dn *ldb_dn_copy(void *mem_ctx, const struct ldb_dn *dn)
-{
-	if (dn == NULL) return NULL;
-	return ldb_dn_copy_partial(mem_ctx, dn, dn->comp_num);
-}
+		s = ldb_dn_get_linearized(child);
+		if ( ! s) {
+			return false;
+		}
+		
+		t = talloc_asprintf(dn, "%s,%s", s, dn->linearized);
+		if ( ! t) {
+			dn->invalid = true;
+			return false;
+		}
+		LDB_FREE(dn->linearized);
+		dn->linearized = t;
+	}
 
-struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, const struct ldb_dn *dn)
-{
-	if (dn == NULL) return NULL;
-	return ldb_dn_copy_partial(mem_ctx, dn, dn->comp_num - 1);
+	return true;
 }
 
-struct ldb_dn_component *ldb_dn_build_component(void *mem_ctx, const char *attr,
-						const char *val)
+/* modify the given dn by adding children elements.
+ *
+ * return true if successful and false if not
+ * if false is returned the dn may be marked invalid
+ */
+bool ldb_dn_add_child_fmt(struct ldb_dn *dn, const char *child_fmt, ...)
 {
-	struct ldb_dn_component *dc;
+	struct ldb_dn *child;
+	char *child_str;
+	va_list ap;
+	bool ret;
 
-	if (attr == NULL || val == NULL) return NULL;
+	if ( !dn || dn->invalid) {
+		return false;
+	}
 
-	dc = talloc(mem_ctx, struct ldb_dn_component);
-	if (dc == NULL) return NULL;
+	va_start(ap, child_fmt);
+	child_str = talloc_vasprintf(dn, child_fmt, ap);
+	va_end(ap);
 
-	dc->name = talloc_strdup(dc, attr);
-	if (dc->name ==  NULL) {
-		talloc_free(dc);
-		return NULL;
+	if (child_str == NULL) {
+		return false;
 	}
 
-	dc->value.data = (uint8_t *)talloc_strdup(dc, val);
-	if (dc->value.data ==  NULL) {
-		talloc_free(dc);
-		return NULL;
-	}
+	child = ldb_dn_new(child_str, dn->ldb, child_str);
+
+	ret = ldb_dn_add_child(dn, child);
 
-	dc->value.length = strlen(val);
+	talloc_free(child_str);
 
-	return dc;
+	return ret;
 }
 
-struct ldb_dn *ldb_dn_build_child(void *mem_ctx, const char *attr,
-						 const char * value,
-						 const struct ldb_dn *base)
+bool ldb_dn_remove_base_components(struct ldb_dn *dn, unsigned int num)
 {
-	struct ldb_dn *newdn;
-	if (! ldb_valid_attr_name(attr)) return NULL;
-	if (value == NULL || value == '\0') return NULL; 
-
-	if (base != NULL) {
-		newdn = ldb_dn_copy_partial(mem_ctx, base, base->comp_num + 1);
-		LDB_DN_NULL_FAILED(newdn);
-	} else {
-		newdn = ldb_dn_new(mem_ctx);
-		LDB_DN_NULL_FAILED(newdn);
-
-		newdn->comp_num = 1;
-		newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
+	if ( ! ldb_dn_validate(dn)) {
+		return false;
 	}
 
-	newdn->components[0].name = talloc_strdup(newdn->components, attr);
-	LDB_DN_NULL_FAILED(newdn->components[0].name);
+	if (dn->comp_num < num) {
+		return false;
+	}
 
-	newdn->components[0].value.data = (uint8_t *)talloc_strdup(newdn->components, value);
-	LDB_DN_NULL_FAILED(newdn->components[0].value.data);
-	newdn->components[0].value.length = strlen((char *)newdn->components[0].value.data);
+	dn->comp_num -= num;
 
-	return newdn;
+	dn->valid_case = false;
 
-failed:
-	talloc_free(newdn);
-	return NULL;
+	if (dn->valid_lin) {	
+		dn->valid_lin = false;
+		LDB_FREE(dn->linearized);
+	}
 
+	return true;
 }
 
-struct ldb_dn *ldb_dn_compose(void *mem_ctx, const struct ldb_dn *dn1, const struct ldb_dn *dn2)
+bool ldb_dn_remove_child_components(struct ldb_dn *dn, unsigned int num)
 {
-	int i;
-	struct ldb_dn *newdn;
+	int i, j;
 
-	if (dn2 == NULL && dn1 == NULL) {
-		return NULL;
+	if ( ! ldb_dn_validate(dn)) {
+		return false;
 	}
 
-	if (dn2 == NULL) {
-		newdn = ldb_dn_new(mem_ctx);
-		LDB_DN_NULL_FAILED(newdn);
-
-		newdn->comp_num = dn1->comp_num;
-		newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
-	} else {
-		int comp_num = dn2->comp_num;
-		if (dn1 != NULL) comp_num += dn1->comp_num;
-		newdn = ldb_dn_copy_partial(mem_ctx, dn2, comp_num);
-		LDB_DN_NULL_FAILED(newdn);
+	if (dn->comp_num < num) {
+		return false;
 	}
 
-	if (dn1 == NULL) {
-		return newdn;
+	for (i = 0, j = num; j < dn->comp_num; i++, j++) {
+		dn->components[i] = dn->components[j];
 	}
 
-	for (i = 0; i < dn1->comp_num; i++) {
-		newdn->components[i] = ldb_dn_copy_component(newdn->components,
-							   &(dn1->components[i]));
-		if (newdn->components[i].value.data == NULL) {
-			goto failed;
-		}
-	}
+	dn->comp_num -= num;
 
-	return newdn;
+	dn->valid_case = false;
 
-failed:
-	talloc_free(newdn);
-	return NULL;
+	if (dn->valid_lin) {	
+		dn->valid_lin = false;
+		LDB_FREE(dn->linearized);
+	}
+
+	return true;
 }
 
-struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, const char *child_fmt, ...)
+struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, struct ldb_dn *dn)
 {
-	struct ldb_dn *dn, *dn1;
-	char *child_str;
-	va_list ap;
-	
-	if (child_fmt == NULL) return NULL;
-
-	va_start(ap, child_fmt);
-	child_str = talloc_vasprintf(mem_ctx, child_fmt, ap);
-	va_end(ap);
-
-	if (child_str == NULL) return NULL;
+	struct ldb_dn *new_dn;
 
-	dn1 = ldb_dn_explode(mem_ctx, child_str);
-	dn = ldb_dn_compose(mem_ctx, dn1, base);
+	new_dn = ldb_dn_copy(mem_ctx, dn);
+	if ( !new_dn ) {
+		return NULL;
+	}
 
-	talloc_free(child_str);
-	talloc_free(dn1);
+	if ( ! ldb_dn_remove_child_components(new_dn, 1)) {
+		talloc_free(new_dn);
+		return NULL;
+	}
 
-	return dn;
+	return new_dn;
 }
 
 /* Create a 'canonical name' string from a DN:
@@ -904,10 +1180,13 @@ struct ldb_dn *ldb_dn_string_compose(void *mem_ctx, const struct ldb_dn *base, c
    There are two formats, the EX format has the last / replaced with a newline (\n).
 
 */
-static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_format) {
+static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
 	int i;
 	char *cracked = NULL;
-
+ 
+	if ( ! ldb_dn_validate(dn)) {
+		return NULL;
+	}
 	/* Walk backwards down the DN, grabbing 'dc' components at first */
 	for (i = dn->comp_num - 1 ; i >= 0; i--) {
 		if (ldb_attr_cmp(dn->components[i].name, "dc") != 0) {
@@ -956,38 +1235,55 @@ static char *ldb_dn_canonical(void *mem_ctx, const struct ldb_dn *dn, int ex_for
 }
 
 /* Wrapper functions for the above, for the two different string formats */
-char *ldb_dn_canonical_string(void *mem_ctx, const struct ldb_dn *dn) {
+char *ldb_dn_canonical_string(void *mem_ctx, struct ldb_dn *dn) {
 	return ldb_dn_canonical(mem_ctx, dn, 0);
 
 }
 
-char *ldb_dn_canonical_ex_string(void *mem_ctx, const struct ldb_dn *dn) {
+char *ldb_dn_canonical_ex_string(void *mem_ctx, struct ldb_dn *dn) {
 	return ldb_dn_canonical(mem_ctx, dn, 1);
 }
 
-int ldb_dn_get_comp_num(const struct ldb_dn *dn)
+int ldb_dn_get_comp_num(struct ldb_dn *dn)
 {
+	if ( ! ldb_dn_validate(dn)) {
+		return -1;
+	}
 	return dn->comp_num;
 }
 
-const char *ldb_dn_get_component_name(const struct ldb_dn *dn, unsigned int num)
+const char *ldb_dn_get_component_name(struct ldb_dn *dn, unsigned int num)
 {
+	if ( ! ldb_dn_validate(dn)) {
+		return NULL;
+	}
 	if (num >= dn->comp_num) return NULL;
 	return dn->components[num].name;
 }
 
-const struct ldb_val *ldb_dn_get_component_val(const struct ldb_dn *dn, unsigned int num)
+const struct ldb_val *ldb_dn_get_component_val(struct ldb_dn *dn, unsigned int num)
 {
+	if ( ! ldb_dn_validate(dn)) {
+		return NULL;
+	}
 	if (num >= dn->comp_num) return NULL;
 	return &dn->components[num].value;
 }
 
-const char *ldb_dn_get_rdn_name(const struct ldb_dn *dn) {
+const char *ldb_dn_get_rdn_name(struct ldb_dn *dn)
+{
+	if ( ! ldb_dn_validate(dn)) {
+		return NULL;
+	}
 	if (dn->comp_num == 0) return NULL;
 	return dn->components[0].name;
 }
 
-const struct ldb_val *ldb_dn_get_rdn_val(const struct ldb_dn *dn) {
+const struct ldb_val *ldb_dn_get_rdn_val(struct ldb_dn *dn)
+{
+	if ( ! ldb_dn_validate(dn)) {
+		return NULL;
+	}
 	if (dn->comp_num == 0) return NULL;
 	return &dn->components[0].value;
 }
@@ -997,6 +1293,10 @@ int ldb_dn_set_component(struct ldb_dn *dn, int num, const char *name, const str
 	char *n;
 	struct ldb_val v;
 
+	if ( ! ldb_dn_validate(dn)) {
+		return LDB_ERR_OTHER;
+	}
+
 	if (num >= dn->comp_num) {
 		return LDB_ERR_OTHER;
 	}
@@ -1017,5 +1317,39 @@ int ldb_dn_set_component(struct ldb_dn *dn, int num, const char *name, const str
 	dn->components[num].name = n;
 	dn->components[num].value = v;
 
+	if (dn->valid_case) dn->valid_case = false;
+	if (dn->casefold) LDB_FREE(dn->casefold);
+
 	return LDB_SUCCESS;
 }
+
+bool ldb_dn_is_valid(struct ldb_dn *dn)
+{
+	if ( ! dn) return false;
+	return ! dn->invalid;
+}
+
+bool ldb_dn_is_special(struct ldb_dn *dn)
+{
+	if ( ! dn || dn->invalid) return false;
+	return dn->special;
+}
+
+bool ldb_dn_check_special(struct ldb_dn *dn, const char *check)
+{
+	if ( ! dn || dn->invalid) return false;
+	return ! strcmp(dn->linearized, check);
+}
+
+bool ldb_dn_is_null(struct ldb_dn *dn)
+{
+	if ( ! dn || dn->invalid) return false;
+	if (dn->special) return false;
+	if (dn->valid_comp) {
+		if (dn->comp_num == 0) return true;
+		return false;
+	} else {
+		if (dn->linearized[0] == '\0') return true;
+	}
+	return false;
+}
-- 
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/common/ldb_dn.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 0a10ed6f2e..8ee78ca06a 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -561,7 +561,7 @@ const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 	return dn->linearized;
 }
 
-char *ldb_dn_linearize(void *mem_ctx, struct ldb_dn *dn)
+char *ldb_dn_alloc_linearized(void *mem_ctx, struct ldb_dn *dn)
 {
 	return talloc_strdup(mem_ctx, ldb_dn_get_linearized(dn));
 }
@@ -664,7 +664,7 @@ const char *ldb_dn_get_casefold(struct ldb_dn *dn)
 	return dn->casefold;
 }
 
-char *ldb_dn_casefold(void *mem_ctx, struct ldb_dn *dn)
+char *ldb_dn_alloc_casefold(void *mem_ctx, struct ldb_dn *dn)
 {
 	return talloc_strdup(mem_ctx, ldb_dn_get_casefold(dn));
 }
-- 
cgit 


From 353b968025f126dc1dd0c0f7ac547f7a0cb5a83d Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 23 Nov 2006 22:06:07 +0000
Subject: r19869: fix memleaks (This used to be commit
 3a662a2d985bf801284c5dc1123dec6705e6d092)

---
 source4/lib/ldb/common/ldb_dn.c | 155 +++++++++++++++++++++++++++++++---------
 1 file changed, 121 insertions(+), 34 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 8ee78ca06a..fff70a883f 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -203,6 +203,8 @@ char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
 
 	ldb_dn_escape_internal(dst, (const char *)value.data, value.length);
 
+	dst = talloc_realloc(mem_ctx, dst, char, strlen(dst) + 1);
+
 	return dst;
 }
 
@@ -243,6 +245,9 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 		return true;
 	}
 
+	/* make sure we free this if alloced previously before replacing */
+	talloc_free(dn->components);
+
 	/* in the common case we have 3 or more components */
 	/* make sure all components are zeroed, other functions depend on this */
 	dn->components = talloc_zero_array(dn, struct ldb_dn_component, 3);
@@ -306,7 +311,12 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 				l = 0;
 
 				*d++ = '\0';
-				dn->components[dn->comp_num].name = dt;
+				dn->components[dn->comp_num].name = talloc_strdup(dn->components, dt);
+				if ( ! dn->components[dn->comp_num].name) {
+					/* ouch */
+					goto failed;
+				}
+
 				dt = d;
 
 				p++;
@@ -385,8 +395,13 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
 				p++;
 				*d++ = '\0';
-				dn->components[dn->comp_num].value.data = (uint8_t *)dt;
+				dn->components[dn->comp_num].value.data = (uint8_t *)talloc_strdup(dn->components, dt);
 				dn->components[dn->comp_num].value.length = l;
+				if ( ! dn->components[dn->comp_num].value.data) {
+					/* ouch ! */
+					goto failed;
+				}
+
 				dt = d;
 
 				dn->comp_num++;
@@ -486,15 +501,23 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 	}
 
 	*d++ = '\0';
-	dn->components[dn->comp_num].value.data = (uint8_t *)dt;
+	dn->components[dn->comp_num].value.data = (uint8_t *)talloc_strdup(dn->components, dt);
 	dn->components[dn->comp_num].value.length = l;
 
+	if ( ! dn->components[dn->comp_num].value.data) {
+		/* ouch */
+		goto failed;
+	}
+
 	dn->comp_num++;
 
 	dn->valid_comp = true;
+
+	talloc_free(data);
 	return true;
 
 failed:
+	dn->comp_num = 0;
 	talloc_free(dn->components);
 	return false;
 }
@@ -584,13 +607,11 @@ static bool ldb_dn_casefold_internal(struct ldb_dn *dn)
 	}
 
 	for (i = 0; i < dn->comp_num; i++) {
-		struct ldb_dn_component dc;
 		const struct ldb_attrib_handler *h;
 
-		memset(&dc, 0, sizeof(dc));
 		dn->components[i].cf_name = ldb_attr_casefold(dn->components, dn->components[i].name);
 		if (!dn->components[i].cf_name) {
-			return false;
+			goto failed;
 		}
 
 		h = ldb_attrib_handler(dn->ldb, dn->components[i].cf_name);
@@ -598,11 +619,20 @@ static bool ldb_dn_casefold_internal(struct ldb_dn *dn)
 					 &(dn->components[i].value),
 					 &(dn->components[i].cf_value));
 		if (ret != 0) {
-			return false;
+			goto failed;
 		}
 	}
 
+	dn->valid_case = true;
+
 	return true;
+
+failed:
+	for (i = 0; i < dn->comp_num; i++) {
+		LDB_FREE(dn->components[i].cf_name);
+		LDB_FREE(dn->components[i].cf_value.data);
+	}
+	return false;
 }
 
 const char *ldb_dn_get_casefold(struct ldb_dn *dn)
@@ -659,7 +689,8 @@ const char *ldb_dn_get_casefold(struct ldb_dn *dn)
 	}
 	*(--d) = '\0';
 
-	dn->valid_case = true;
+	/* don't waste more memory than necessary */
+	dn->casefold = talloc_realloc(dn, dn->casefold, char, strlen(dn->casefold) + 1);
 
 	return dn->casefold;
 }
@@ -711,6 +742,10 @@ int ldb_dn_compare_base(struct ldb_dn *base, struct ldb_dn *dn)
 	if (dn->comp_num == 0) {
 		if (dn->special && base->special) {
 			return strcmp(base->linearized, dn->linearized);
+		} else if (dn->special) {
+			return -1;
+		} else if (base->special) {
+			return 1;
 		} else {
 			return 0;
 		}
@@ -773,6 +808,10 @@ int ldb_dn_compare(struct ldb_dn *dn0, struct ldb_dn *dn1)
 	if (dn0->comp_num == 0) {
 		if (dn0->special && dn1->special) {
 			return strcmp(dn0->linearized, dn1->linearized);
+		} else if (dn0->special) {
+			return 1;
+		} else if (dn1->special) {
+			return -1;
 		} else {
 			return 0;
 		}
@@ -812,6 +851,7 @@ static struct ldb_dn_component ldb_dn_copy_component(void *mem_ctx, struct ldb_d
 	dst.name = talloc_strdup(mem_ctx, src->name);
 	if (dst.name == NULL) {
 		LDB_FREE(dst.value.data);
+		return dst;
 	}
 
 	if (src->cf_value.data) {
@@ -868,13 +908,13 @@ struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
 				return NULL;
 			}
 		}
+	}
 
-		if (dn->casefold) {
-			new_dn->casefold = talloc_strdup(new_dn, dn->casefold);
-			if ( ! new_dn->casefold) {
-				talloc_free(new_dn);
-				return NULL;
-			}
+	if (dn->casefold) {
+		new_dn->casefold = talloc_strdup(new_dn, dn->casefold);
+		if ( ! new_dn->casefold) {
+			talloc_free(new_dn);
+			return NULL;
 		}
 	}
 
@@ -934,7 +974,7 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
 			}
 		}
 
-		if (s) {
+		if (dn->casefold && s) {
 			t = talloc_asprintf(dn, "%s,%s", dn->casefold, s);
 			LDB_FREE(dn->casefold);
 			dn->casefold = t;
@@ -1046,7 +1086,7 @@ bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
 
 		dn->comp_num = n;
 
-		if (s) {
+		if (dn->casefold && s) {
 			t = talloc_asprintf(dn, "%s,%s", s, dn->casefold);
 			LDB_FREE(dn->casefold);
 			dn->casefold = t;
@@ -1107,6 +1147,8 @@ bool ldb_dn_add_child_fmt(struct ldb_dn *dn, const char *child_fmt, ...)
 
 bool ldb_dn_remove_base_components(struct ldb_dn *dn, unsigned int num)
 {
+	int i;
+
 	if ( ! ldb_dn_validate(dn)) {
 		return false;
 	}
@@ -1115,9 +1157,24 @@ bool ldb_dn_remove_base_components(struct ldb_dn *dn, unsigned int num)
 		return false;
 	}
 
+	/* free components */
+	for (i = num; i > 0; i--) {
+		LDB_FREE(dn->components[dn->comp_num - i].name);
+		LDB_FREE(dn->components[dn->comp_num - i].value.data);
+		LDB_FREE(dn->components[dn->comp_num - i].cf_name);
+		LDB_FREE(dn->components[dn->comp_num - i].cf_value.data);
+	}
+	
 	dn->comp_num -= num;
 
-	dn->valid_case = false;
+	if (dn->valid_case) {
+		for (i = 0; i < dn->comp_num; i++) {
+			LDB_FREE(dn->components[i].cf_name);
+			LDB_FREE(dn->components[i].cf_value.data);
+		}
+		dn->valid_case = false;
+		LDB_FREE(dn->casefold);
+	}
 
 	if (dn->valid_lin) {	
 		dn->valid_lin = false;
@@ -1140,12 +1197,25 @@ bool ldb_dn_remove_child_components(struct ldb_dn *dn, unsigned int num)
 	}
 
 	for (i = 0, j = num; j < dn->comp_num; i++, j++) {
+		if (i < num) {
+			LDB_FREE(dn->components[i].name);
+			LDB_FREE(dn->components[i].value.data);
+			LDB_FREE(dn->components[i].cf_name);
+			LDB_FREE(dn->components[i].cf_value.data);
+		}
 		dn->components[i] = dn->components[j];
 	}
 
 	dn->comp_num -= num;
 
-	dn->valid_case = false;
+	if (dn->valid_case) {
+		for (i = 0; i < dn->comp_num; i++) {
+			LDB_FREE(dn->components[i].cf_name);
+			LDB_FREE(dn->components[i].cf_value.data);
+		}
+		dn->valid_case = false;
+	}
+	LDB_FREE(dn->casefold);
 
 	if (dn->valid_lin) {	
 		dn->valid_lin = false;
@@ -1182,55 +1252,64 @@ struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, struct ldb_dn *dn)
 */
 static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
 	int i;
+	TALLOC_CTX *tmpctx;
 	char *cracked = NULL;
  
 	if ( ! ldb_dn_validate(dn)) {
 		return NULL;
 	}
+
+	tmpctx = talloc_new(mem_ctx);
+
 	/* Walk backwards down the DN, grabbing 'dc' components at first */
 	for (i = dn->comp_num - 1 ; i >= 0; i--) {
 		if (ldb_attr_cmp(dn->components[i].name, "dc") != 0) {
 			break;
 		}
 		if (cracked) {
-			cracked = talloc_asprintf(mem_ctx, "%s.%s",
-						  ldb_dn_escape_value(mem_ctx, dn->components[i].value),
+			cracked = talloc_asprintf(tmpctx, "%s.%s",
+						  ldb_dn_escape_value(tmpctx, dn->components[i].value),
 						  cracked);
 		} else {
-			cracked = ldb_dn_escape_value(mem_ctx, dn->components[i].value);
+			cracked = ldb_dn_escape_value(tmpctx, dn->components[i].value);
 		}
 		if (!cracked) {
-			return NULL;
+			goto done;
 		}
 	}
 
 	/* Only domain components?  Finish here */
 	if (i < 0) {
 		if (ex_format) {
-			cracked = talloc_asprintf(mem_ctx, "%s\n", cracked);
+			cracked = talloc_asprintf(tmpctx, "%s\n", cracked);
 		} else {
-			cracked = talloc_asprintf(mem_ctx, "%s/", cracked);
+			cracked = talloc_asprintf(tmpctx, "%s/", cracked);
 		}
-		return cracked;
+		talloc_steal(mem_ctx, cracked);
+		goto done;
 	}
 
 	/* Now walk backwards appending remaining components */
 	for (; i > 0; i--) {
-		cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked, 
-					  ldb_dn_escape_value(mem_ctx, dn->components[i].value));
+		cracked = talloc_asprintf(tmpctx, "%s/%s", cracked, 
+					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
 		if (!cracked) {
-			return NULL;
+			goto done;
 		}
 	}
 
 	/* Last one, possibly a newline for the 'ex' format */
 	if (ex_format) {
-		cracked = talloc_asprintf(mem_ctx, "%s\n%s", cracked, 
-					  ldb_dn_escape_value(mem_ctx, dn->components[i].value));
+		cracked = talloc_asprintf(tmpctx, "%s\n%s", cracked, 
+					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
 	} else {
-		cracked = talloc_asprintf(mem_ctx, "%s/%s", cracked, 
-					  ldb_dn_escape_value(mem_ctx, dn->components[i].value));
+		cracked = talloc_asprintf(tmpctx, "%s/%s", cracked, 
+					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
 	}
+
+	talloc_steal(mem_ctx, cracked);
+done:
+	talloc_free(tmpctx);
 	return cracked;
 }
 
@@ -1309,6 +1388,7 @@ int ldb_dn_set_component(struct ldb_dn *dn, int num, const char *name, const str
 	v.length = val.length;
 	v.data = (uint8_t *)talloc_memdup(dn, val.data, v.length+1);
 	if ( ! v.data) {
+		talloc_free(n);
 		return LDB_ERR_OTHER;
 	}
 
@@ -1317,8 +1397,15 @@ int ldb_dn_set_component(struct ldb_dn *dn, int num, const char *name, const str
 	dn->components[num].name = n;
 	dn->components[num].value = v;
 
-	if (dn->valid_case) dn->valid_case = false;
-	if (dn->casefold) LDB_FREE(dn->casefold);
+	if (dn->valid_case) {
+		int i;
+		for (i = 0; i < dn->comp_num; i++) {
+			LDB_FREE(dn->components[i].cf_name);
+			LDB_FREE(dn->components[i].cf_value.data);
+		}
+		dn->valid_case = false;
+	}
+	LDB_FREE(dn->casefold);
 
 	return LDB_SUCCESS;
 }
-- 
cgit 


From 5ab439893b4628cb195801018b36504bac5ee062 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 23 Nov 2006 22:11:47 +0000
Subject: r19870: Simplify code (This used to be commit
 c1737f9a52d9e4d118f969a0953a458188143d0d)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index fff70a883f..163b09b611 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -62,7 +62,6 @@ struct ldb_dn {
 	bool special;
 	bool invalid;
 
-	bool valid_lin;
 	bool valid_comp;
 	bool valid_case;
 
@@ -102,8 +101,6 @@ struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *st
 	}
 	LDB_DN_NULL_FAILED(dn->linearized);
 
-	dn->valid_lin = true;
-
 	return dn;
 
 failed:
@@ -140,8 +137,6 @@ struct ldb_dn *ldb_dn_new_fmt(void *mem_ctx, struct ldb_context *ldb, const char
 	}
 	dn->linearized = strdn;
 
-	dn->valid_lin = true;
-
 	return dn;
 
 failed:
@@ -230,7 +225,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 		return true;
 	}
 
-	if ( ! dn->valid_lin) {
+	if ( ! dn->linearized) {
 		return false;
 	}
 
@@ -534,7 +529,7 @@ const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 
 	if ( ! dn || ( dn->invalid)) return NULL;
 
-	if (dn->valid_lin) return dn->linearized;
+	if (dn->linearized) return dn->linearized;
 
 	if ( ! dn->valid_comp) {
 		dn->invalid = true;
@@ -544,7 +539,6 @@ const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 	if (dn->comp_num == 0) {
 		dn->linearized = talloc_strdup(dn, "");
 		if ( ! dn->linearized) return NULL;
-		dn->valid_lin = true;
 		return dn->linearized;
 	}
 
@@ -576,8 +570,6 @@ const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 
 	*(--d) = '\0';
 
-	dn->valid_lin = true;
-
 	/* don't waste more memory than necessary */
 	dn->linearized = talloc_realloc(dn, dn->linearized, char, (d - dn->linearized + 1));
 
@@ -714,7 +706,7 @@ int ldb_dn_compare_base(struct ldb_dn *base, struct ldb_dn *dn)
 	if ( ! dn || dn->invalid) return -1;
 
 	if (( ! base->valid_case) || ( ! dn->valid_case)) {
-		if (base->valid_lin && dn->valid_lin) {
+		if (base->linearized && dn->linearized) {
 			/* try with a normal compare first, if we are lucky
 			 * we will avoid exploding and casfolding */
 			int dif;
@@ -785,7 +777,7 @@ int ldb_dn_compare(struct ldb_dn *dn0, struct ldb_dn *dn1)
 	if (( ! dn0) || dn0->invalid || ! dn1 || dn1->invalid) return -1;
 
 	if (( ! dn0->valid_case) || ( ! dn1->valid_case)) {
-		if (dn0->valid_lin && dn1->valid_lin) {
+		if (dn0->linearized && dn1->linearized) {
 			/* try with a normal compare first, if we are lucky
 			 * we will avoid exploding and casfolding */
 			if (strcmp(dn0->linearized, dn1->linearized) == 0) return 0;
@@ -918,7 +910,7 @@ struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
 		}
 	}
 
-	if (dn->valid_lin) {
+	if (dn->linearized) {
 		new_dn->linearized = talloc_strdup(new_dn, dn->linearized);
 		if ( ! new_dn->linearized) {
 			talloc_free(new_dn);
@@ -981,7 +973,7 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
 		}
 	}
 
-	if (dn->valid_lin) {
+	if (dn->linearized) {
 
 		s = ldb_dn_get_linearized(base);
 		if ( ! s) {
@@ -1093,7 +1085,7 @@ bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
 		}
 	}
 
-	if (dn->valid_lin) {
+	if (dn->linearized) {
 
 		s = ldb_dn_get_linearized(child);
 		if ( ! s) {
@@ -1173,13 +1165,10 @@ bool ldb_dn_remove_base_components(struct ldb_dn *dn, unsigned int num)
 			LDB_FREE(dn->components[i].cf_value.data);
 		}
 		dn->valid_case = false;
-		LDB_FREE(dn->casefold);
 	}
 
-	if (dn->valid_lin) {	
-		dn->valid_lin = false;
-		LDB_FREE(dn->linearized);
-	}
+	LDB_FREE(dn->casefold);
+	LDB_FREE(dn->linearized);
 
 	return true;
 }
@@ -1215,12 +1204,9 @@ bool ldb_dn_remove_child_components(struct ldb_dn *dn, unsigned int num)
 		}
 		dn->valid_case = false;
 	}
-	LDB_FREE(dn->casefold);
 
-	if (dn->valid_lin) {	
-		dn->valid_lin = false;
-		LDB_FREE(dn->linearized);
-	}
+	LDB_FREE(dn->casefold);
+	LDB_FREE(dn->linearized);
 
 	return true;
 }
-- 
cgit 


From f4e6be00ac5ff1662253cc66de9f26d819a9ab89 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Thu, 23 Nov 2006 22:30:46 +0000
Subject: r19871: simplify more (This used to be commit
 e9ddb18c83518703f987bf141807639956612dbf)

---
 source4/lib/ldb/common/ldb_dn.c | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 163b09b611..1c535fda33 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -62,7 +62,6 @@ struct ldb_dn {
 	bool special;
 	bool invalid;
 
-	bool valid_comp;
 	bool valid_case;
 
 	char *linearized;
@@ -221,7 +220,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
 	if ( ! dn || dn->invalid) return false;
 
-	if (dn->valid_comp) {
+	if (dn->components) {
 		return true;
 	}
 
@@ -231,7 +230,6 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
 	/* Empty DNs */
 	if (dn->linearized[0] == '\0') {
-		dn->valid_comp = true;
 		return true;
 	}
 
@@ -506,8 +504,6 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
 	dn->comp_num++;
 
-	dn->valid_comp = true;
-
 	talloc_free(data);
 	return true;
 
@@ -531,7 +527,7 @@ const char *ldb_dn_get_linearized(struct ldb_dn *dn)
 
 	if (dn->linearized) return dn->linearized;
 
-	if ( ! dn->valid_comp) {
+	if ( ! dn->components) {
 		dn->invalid = true;
 		return NULL;
 	}
@@ -594,7 +590,7 @@ static bool ldb_dn_casefold_internal(struct ldb_dn *dn)
 
 	if (dn->valid_case) return true;
 
-	if (( ! dn->valid_comp) && ( ! ldb_dn_explode(dn))) {
+	if (( ! dn->components) && ( ! ldb_dn_explode(dn))) {
 		return false;
 	}
 
@@ -884,7 +880,7 @@ struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
 
 	*new_dn = *dn;
 
-	if (dn->valid_comp) {
+	if (dn->components) {
 		int i;
 
 		new_dn->components = talloc_zero_array(new_dn, struct ldb_dn_component, dn->comp_num);
@@ -935,7 +931,7 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
 		return false;
 	}
 
-	if (dn->valid_comp) {
+	if (dn->components) {
 		int i;
 
 		if ( ! ldb_dn_validate(base)) {
@@ -1039,7 +1035,7 @@ bool ldb_dn_add_child(struct ldb_dn *dn, struct ldb_dn *child)
 		return false;
 	}
 
-	if (dn->valid_comp) {
+	if (dn->components) {
 		int n, i, j;
 
 		if ( ! ldb_dn_validate(child)) {
@@ -1417,12 +1413,6 @@ bool ldb_dn_check_special(struct ldb_dn *dn, const char *check)
 bool ldb_dn_is_null(struct ldb_dn *dn)
 {
 	if ( ! dn || dn->invalid) return false;
-	if (dn->special) return false;
-	if (dn->valid_comp) {
-		if (dn->comp_num == 0) return true;
-		return false;
-	} else {
-		if (dn->linearized[0] == '\0') return true;
-	}
+	if (dn->linearized && (dn->linearized[0] == '\0')) return true;
 	return false;
 }
-- 
cgit 


From 6d074bcd4b869b3ff65cb999bf3c10d4affa17f7 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 25 Nov 2006 14:59:59 +0000
Subject: r19885: special dn's were not casefolded before rev 19831, act like
 this again...

also when we already have a casefoled value we should not call ldb_dn_casefold_internal()

metze
(This used to be commit cbf4eb16725992bfdfa5a334e0e5547e6df568e6)
---
 source4/lib/ldb/common/ldb_dn.c | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 1c535fda33..3f66943ad2 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -628,24 +628,22 @@ const char *ldb_dn_get_casefold(struct ldb_dn *dn)
 	int i, len;
 	char *d, *n;
 
+	if (dn->casefold) return dn->casefold;
+
+	if (dn->special) {
+		dn->casefold = talloc_strdup(dn, dn->linearized);
+		if (!dn->casefold) return NULL;
+		dn->valid_case = true;
+		return dn->casefold;
+	}
+
 	if ( ! ldb_dn_casefold_internal(dn)) {
 		return NULL;
 	}
 
-	if (dn->casefold) return dn->casefold;
-
 	if (dn->comp_num == 0) {
-		if (dn->special) {
-			len = strlen(dn->linearized);
-			dn->casefold = talloc_array(dn, char, len * 3 + 1);
-			if ( ! dn->casefold) return NULL;
-			ldb_dn_escape_internal(dn->casefold, dn->linearized, len);
-			/* don't waste more memory than necessary */
-			dn->casefold = talloc_realloc(dn, dn->casefold, char, strlen(dn->casefold) + 1);
-		} else {
-			dn->casefold = talloc_strdup(dn, "");
-			if ( ! dn->casefold) return NULL;
-		}
+		dn->casefold = talloc_strdup(dn, "");
+		if (!dn->casefold) return NULL;
 		dn->valid_case = true;
 		return dn->casefold;
 	}
-- 
cgit 


From 5b258c3b9dda634af721802916880bccffab45a2 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 25 Nov 2006 15:42:22 +0000
Subject: r19887: return "" string only if the dn is a valid one (This used to
 be commit 056f90798f6d2cea1debc50f31fea3d740c4a837)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 3f66943ad2..38d9ea3aff 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -630,7 +630,7 @@ const char *ldb_dn_get_casefold(struct ldb_dn *dn)
 
 	if (dn->casefold) return dn->casefold;
 
-	if (dn->special) {
+	if (dn->special) { 
 		dn->casefold = talloc_strdup(dn, dn->linearized);
 		if (!dn->casefold) return NULL;
 		dn->valid_case = true;
@@ -642,10 +642,14 @@ const char *ldb_dn_get_casefold(struct ldb_dn *dn)
 	}
 
 	if (dn->comp_num == 0) {
-		dn->casefold = talloc_strdup(dn, "");
-		if (!dn->casefold) return NULL;
-		dn->valid_case = true;
-		return dn->casefold;
+		if (dn->linearized && dn->linearized[0] == '\0') {
+			/* hmm a NULL dn, should we faild casefolding ? */
+			dn->casefold = talloc_strdup(dn, "");
+			return dn->casefold;
+		}
+		/* A DN must be NULL, special, or have components */
+		dn->invalid = true;
+		return NULL;
 	}
 
 	/* calculate maximum possible length of DN */
-- 
cgit 


From eee64196a3b6433606a436bba3ab36896fdada18 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sat, 25 Nov 2006 17:19:42 +0000
Subject: r19901: Fix a potential NULL dereference (This used to be commit
 75e6fb9654f10a076ed49b0582b40368e149d30a)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 38d9ea3aff..f76c3441e7 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -251,6 +251,9 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 
 	/* Components data space is allocated here once */
 	data = talloc_array(dn->components, char, strlen(dn->linearized) + 1);
+	if (!data) {
+		return false;
+	}
 
 	p = dn->linearized;
 	in_attr = true;
-- 
cgit 


From 921a596cd47c5ecdf40e9dea1754227418e9e13f Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 26 Nov 2006 21:50:24 +0000
Subject: r19910: Make better use of our set of talloc utility functions (This
 used to be commit b1197dbeebff062b8ea1e8466d436be82b0b61e0)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index f76c3441e7..bb314fbe40 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -1268,9 +1268,9 @@ static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
 	/* Only domain components?  Finish here */
 	if (i < 0) {
 		if (ex_format) {
-			cracked = talloc_asprintf(tmpctx, "%s\n", cracked);
+			cracked = talloc_append_string(tmpctx, cracked, "\n");
 		} else {
-			cracked = talloc_asprintf(tmpctx, "%s/", cracked);
+			cracked = talloc_append_string(tmpctx, cracked, "/");
 		}
 		talloc_steal(mem_ctx, cracked);
 		goto done;
@@ -1278,7 +1278,7 @@ static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
 
 	/* Now walk backwards appending remaining components */
 	for (; i > 0; i--) {
-		cracked = talloc_asprintf(tmpctx, "%s/%s", cracked, 
+		cracked = talloc_asprintf_append(cracked, "/%s", 
 					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
 		if (!cracked) {
 			goto done;
@@ -1287,10 +1287,10 @@ static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
 
 	/* Last one, possibly a newline for the 'ex' format */
 	if (ex_format) {
-		cracked = talloc_asprintf(tmpctx, "%s\n%s", cracked, 
+		cracked = talloc_asprintf_append(cracked, "\n%s",
 					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
 	} else {
-		cracked = talloc_asprintf(tmpctx, "%s/%s", cracked, 
+		cracked = talloc_asprintf_append(cracked, "/%s", 
 					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
 	}
 
-- 
cgit 


From 853418653091a102be7201c455d7dcc6497187df Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 29 Nov 2006 20:03:19 +0000
Subject: r19954: allow more special dn's:

this works now against w2k3:

bin/ldbedit -U administrator%test -H ldap://w2k3-101/ -b "<GUID=44087590-dd95-435c-adc1-ec20a50807be>" -s base
bin/ldbedit -U administrator%test -H ldap://w2k3-101/ -b "<SID=S-1-5-21-769185814-1958994947-1641909093-513>" -s base
bin/ldbedit -U administrator%test -H ldap://w2k3-101/ -b "<WKGUID=AB8153B7768811D1ADED00C04FD8D5CD,DC=w2k3,dc=vmnet1,dc=vm,dc=base>" -s base

and we should try to implement this in the server too...

metze
(This used to be commit 3c087c89707398d88799367240fe4e6f8b192bb4)
---
 source4/lib/ldb/common/ldb_dn.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index bb314fbe40..ae178986f4 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -93,6 +93,16 @@ struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *st
 			 * exploded_dn control is used */
 			dn->special = true;
 			/* FIXME: add a GUID string to ldb_dn structure */
+		} else if (strncasecmp(strdn, "<SID=", 8) == 0) {
+			/* this is special DN returned when the
+			 * exploded_dn control is used */
+			dn->special = true;
+			/* FIXME: add a SID string to ldb_dn structure */
+		} else if (strncasecmp(strdn, "<WKGUID=", 8) == 0) {
+			/* this is special DN returned when the
+			 * exploded_dn control is used */
+			dn->special = true;
+			/* FIXME: add a WKGUID string to ldb_dn structure */
 		}
 		dn->linearized = talloc_strdup(dn, strdn);
 	} else {
-- 
cgit 


From 2f1fa42fe884e074c50d28896ee36ef7f50a43c4 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sun, 3 Dec 2006 20:45:13 +0000
Subject: r20023: handle <SID=...> <WKGUID=...> dn's also in ldb_dn_new_fmt()

metze
(This used to be commit 01e3a5080a38c93c4bbf249b03135314b7e0b3f1)
---
 source4/lib/ldb/common/ldb_dn.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index ae178986f4..7a17d2cb71 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -143,6 +143,16 @@ struct ldb_dn *ldb_dn_new_fmt(void *mem_ctx, struct ldb_context *ldb, const char
 		 * exploded_dn control is used */
 		dn->special = true;
 		/* FIXME: add a GUID string to ldb_dn structure */
+	} else if (strncasecmp(strdn, "<SID=", 8) == 0) {
+		/* this is special DN returned when the
+		 * exploded_dn control is used */
+		dn->special = true;
+		/* FIXME: add a SID string to ldb_dn structure */
+	} else if (strncasecmp(strdn, "<WKGUID=", 8) == 0) {
+		/* this is special DN returned when the
+		 * exploded_dn control is used */
+		dn->special = true;
+		/* FIXME: add a WKGUID string to ldb_dn structure */
 	}
 	dn->linearized = strdn;
 
-- 
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/common/ldb_dn.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 7a17d2cb71..dc440ef3de 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -618,17 +618,17 @@ static bool ldb_dn_casefold_internal(struct ldb_dn *dn)
 	}
 
 	for (i = 0; i < dn->comp_num; i++) {
-		const struct ldb_attrib_handler *h;
+		const struct ldb_schema_attribute *a;
 
 		dn->components[i].cf_name = ldb_attr_casefold(dn->components, dn->components[i].name);
 		if (!dn->components[i].cf_name) {
 			goto failed;
 		}
 
-		h = ldb_attrib_handler(dn->ldb, dn->components[i].cf_name);
-		ret = h->canonicalise_fn(dn->ldb, dn->components,
-					 &(dn->components[i].value),
-					 &(dn->components[i].cf_value));
+		a = ldb_schema_attribute_by_name(dn->ldb, dn->components[i].cf_name);
+		ret = a->syntax->canonicalise_fn(dn->ldb, dn->components,
+						 &(dn->components[i].value),
+						 &(dn->components[i].cf_value));
 		if (ret != 0) {
 			goto failed;
 		}
-- 
cgit 


From c8fd1a6f2ea0a4c3ae6535d651077810c4ea611d Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 28 Dec 2006 03:31:18 +0000
Subject: r20373: When adding a base to a "" DN, don't precede it with a comma
 (,)

Andrew Bartlett
(This used to be commit ef1ca30180b1b225579a8200b65a4853a135602f)
---
 source4/lib/ldb/common/ldb_dn.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index dc440ef3de..0649626d61 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -988,7 +988,11 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
 		}
 
 		if (dn->casefold && s) {
-			t = talloc_asprintf(dn, "%s,%s", dn->casefold, s);
+			if (*dn->casefold) {
+				t = talloc_asprintf(dn, "%s,%s", dn->casefold, s);
+			} else {
+				t = talloc_strdup(dn, s);
+			}
 			LDB_FREE(dn->casefold);
 			dn->casefold = t;
 		}
@@ -1001,7 +1005,11 @@ bool ldb_dn_add_base(struct ldb_dn *dn, struct ldb_dn *base)
 			return false;
 		}
 		
-		t = talloc_asprintf(dn, "%s,%s", dn->linearized, s);
+		if (*dn->linearized) {
+			t = talloc_asprintf(dn, "%s,%s", dn->linearized, s);
+		} else {
+			t = talloc_strdup(dn, s);
+		}
 		if ( ! t) {
 			dn->invalid = true;
 			return false;
-- 
cgit 


From 784f11bd85cba85773e90ab56d97cc3f9fd70943 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 22 Jan 2007 17:46:38 +0000
Subject: r20952: when a component is changed we need to rebuild the linearized
 string

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 0649626d61..93f466c72d 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -1421,6 +1421,7 @@ int ldb_dn_set_component(struct ldb_dn *dn, int num, const char *name, const str
 		dn->valid_case = false;
 	}
 	LDB_FREE(dn->casefold);
+	LDB_FREE(dn->linearized);
 
 	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/common/ldb_dn.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 93f466c72d..766f8a174c 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -34,9 +34,8 @@
  *  Author: Simo Sorce
  */
 
-#include "includes.h"
 #include <ctype.h>
-#include "ldb/include/includes.h"
+#include "ldb_includes.h"
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
-- 
cgit 


From d6121458b0b3cfecb857877e0740560f282cbe48 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sun, 6 May 2007 11:03:33 +0000
Subject: r22694: It seems that AIX 5.3 with XLC has difficulties with
 <ctype.h>. This is an attempt to work around this: Maybe it helps if we
 include other stuff first.

This raises a question however: Do we want the DN handling to be locale
dependent? isalpha() can return different things depending on the
current locale.
(This used to be commit 75ba82dee052fa5f4141e66e1cb748101aa95d71)
---
 source4/lib/ldb/common/ldb_dn.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 766f8a174c..ea7c6b5f69 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -34,8 +34,8 @@
  *  Author: Simo Sorce
  */
 
-#include <ctype.h>
 #include "ldb_includes.h"
+#include <ctype.h>
 
 #define LDB_DN_NULL_FAILED(x) if (!(x)) goto failed
 
-- 
cgit 


From 31d28c5b8cc22fb158a808a1f9d3d0c8ed5d2090 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 6 May 2007 15:17:14 +0000
Subject: r22696: Make sure this is an ascii char spotted by Volker (This used
 to be commit e24812016f60f506f0df2cb5ba8c2c6987f7da40)

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index ea7c6b5f69..a277c71ba2 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -292,6 +292,12 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 				/* first char */
 				trim = false;
 
+				if (!isascii(*p)) {
+					/* attr names must be ascii only */
+					dn->invalid = true;
+					goto failed;
+				}
+
 				if (isdigit(*p)) {
 					is_oid = true;
 				} else
@@ -338,6 +344,12 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
 				continue;
 			}
 
+			if (!isascii(*p)) {
+				/* attr names must be ascii only */
+				dn->invalid = true;
+				goto failed;
+			}
+
 			if (is_oid && ( ! (isdigit(*p) || (*p == '.')))) {
 				/* not a digit nor a dot, invalid attribute oid */
 				dn->invalid = true;
-- 
cgit 


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

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

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

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

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 9149ec736c..41e70cffd1 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.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 c364bbbfa3441f40e3bcab76392d998163e7bf76 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Sep 2007 13:41:50 +0000
Subject: r25215: replace talloc_append_string() with
 talloc_strdup_append_buffer()

metze
(This used to be commit 8f2db3c130ce85d38f805836a7df039822ede066)
---
 source4/lib/ldb/common/ldb_dn.c | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 41e70cffd1..f0bd72e009 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -1279,6 +1279,7 @@ static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
 	int i;
 	TALLOC_CTX *tmpctx;
 	char *cracked = NULL;
+	const char *format = (ex_format ? "\n" : "/" );
  
 	if ( ! ldb_dn_validate(dn)) {
 		return NULL;
@@ -1305,32 +1306,23 @@ static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
 
 	/* Only domain components?  Finish here */
 	if (i < 0) {
-		if (ex_format) {
-			cracked = talloc_append_string(tmpctx, cracked, "\n");
-		} else {
-			cracked = talloc_append_string(tmpctx, cracked, "/");
-		}
+		cracked = talloc_strdup_append_buffer(cracked, format);
 		talloc_steal(mem_ctx, cracked);
 		goto done;
 	}
 
 	/* Now walk backwards appending remaining components */
 	for (; i > 0; i--) {
-		cracked = talloc_asprintf_append(cracked, "/%s", 
-					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
+		cracked = talloc_asprintf_append_buffer(cracked, "/%s", 
+							ldb_dn_escape_value(tmpctx, dn->components[i].value));
 		if (!cracked) {
 			goto done;
 		}
 	}
 
 	/* Last one, possibly a newline for the 'ex' format */
-	if (ex_format) {
-		cracked = talloc_asprintf_append(cracked, "\n%s",
-					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
-	} else {
-		cracked = talloc_asprintf_append(cracked, "/%s", 
-					  ldb_dn_escape_value(tmpctx, dn->components[i].value));
-	}
+	cracked = talloc_asprintf_append_buffer(cracked, "%s%s", format,
+						ldb_dn_escape_value(tmpctx, dn->components[i].value));
 
 	talloc_steal(mem_ctx, cracked);
 done:
-- 
cgit 


From 957af15e4b758114702255f8adc4e22b05310b50 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 14 Oct 2007 15:12:21 +0200
Subject: r25630: Allow "NULL" as memory context, for consistency with the rest
 of the code,

which also does.
(This used to be commit 083b606496308741958bb9fc6b3e50a582857677)
---
 source4/lib/ldb/common/ldb_dn.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index f0bd72e009..08911344b7 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -75,7 +75,7 @@ struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *st
 {
 	struct ldb_dn *dn;
 
-	if ( (! mem_ctx) || (! ldb)) return NULL;
+	if (! ldb) return NULL;
 
 	dn = talloc_zero(mem_ctx, struct ldb_dn);
 	LDB_DN_NULL_FAILED(dn);
-- 
cgit 


From 4ad97a1d0593b3401a352407009a99ead23f21f2 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 21 Aug 2008 19:24:58 +1000
Subject: Don't walk past the end of ldb values.

This is a partial fix towards bugs due to us walking past the end of
what we think are strings in ldb.  There is much more work to do in
this area.

Andrew Bartlett
(This used to be commit 5805a9a8f35fd90fa4f718f73534817fa3bbdfd2)
---
 source4/lib/ldb/common/ldb_dn.c | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_dn.c b/source4/lib/ldb/common/ldb_dn.c
index 08911344b7..c0d36cfbf3 100644
--- a/source4/lib/ldb/common/ldb_dn.c
+++ b/source4/lib/ldb/common/ldb_dn.c
@@ -71,7 +71,7 @@ struct ldb_dn {
 };
 
 /* strdn may be NULL */
-struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *strdn)
+struct ldb_dn *ldb_dn_from_ldb_val(void *mem_ctx, struct ldb_context *ldb, const struct ldb_val *strdn)
 {
 	struct ldb_dn *dn;
 
@@ -82,27 +82,27 @@ struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *st
 
 	dn->ldb = ldb;
 
-	if (strdn) {
-		if (strdn[0] == '@') {
+	if (strdn->data && strdn->length) {
+		if (strdn->data[0] == '@') {
 			dn->special = true;
 		}
-		if (strncasecmp(strdn, "<GUID=", 6) == 0) {
+		if (strdn->length >= 6 && strncasecmp((const char *)strdn->data, "<GUID=", 6) == 0) {
 			/* this is special DN returned when the
 			 * exploded_dn control is used */
 			dn->special = true;
 			/* FIXME: add a GUID string to ldb_dn structure */
-		} else if (strncasecmp(strdn, "<SID=", 8) == 0) {
+		} else if (strdn->length >= 8 && strncasecmp((const char *)strdn->data, "<SID=", 8) == 0) {
 			/* this is special DN returned when the
 			 * exploded_dn control is used */
 			dn->special = true;
 			/* FIXME: add a SID string to ldb_dn structure */
-		} else if (strncasecmp(strdn, "<WKGUID=", 8) == 0) {
+		} else if (strdn->length >= 8 && strncasecmp((const char *)strdn->data, "<WKGUID=", 8) == 0) {
 			/* this is special DN returned when the
 			 * exploded_dn control is used */
 			dn->special = true;
 			/* FIXME: add a WKGUID string to ldb_dn structure */
 		}
-		dn->linearized = talloc_strdup(dn, strdn);
+		dn->linearized = talloc_strndup(dn, (const char *)strdn->data, strdn->length);
 	} else {
 		dn->linearized = talloc_strdup(dn, "");
 	}
@@ -115,6 +115,15 @@ failed:
 	return NULL;
 }
 
+/* strdn may be NULL */
+struct ldb_dn *ldb_dn_new(void *mem_ctx, struct ldb_context *ldb, const char *strdn)
+{
+	struct ldb_val blob;
+	blob.data = strdn;
+	blob.length = strdn ? strlen(strdn) : 0;
+	return ldb_dn_from_ldb_val(mem_ctx, ldb, &blob);
+}
+
 struct ldb_dn *ldb_dn_new_fmt(void *mem_ctx, struct ldb_context *ldb, const char *new_fmt, ...)
 {
 	struct ldb_dn *dn;
-- 
cgit