r7937: main file was missing

(This used to be commit 3898cdb0dc4722a7eb60a61b54ef778dab475aed)

3 files changed, 482 insertions, 527 deletions

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;
+}
+
diff --git a/source4/lib/ldb/common/ldb_explode_dn.c b/source4/lib/ldb/common/ldb_explode_dn.c
deleted file mode 100644
index 0e2efa876c..0000000000
--- a/source4/lib/ldb/common/ldb_explode_dn.c
+++ /dev/null
@@ -1,512 +0,0 @@
-/* 
-   ldb database library
-
-   Copyright (C) Simo Sorce 2004
-   Copyright (C) Derrell Lipman 2005
-
-     ** NOTE! The following LGPL license applies to the ldb
-     ** library. This does NOT imply that all of Samba is released
-     ** under the LGPL
-   
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this library; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-/*
- *  Name: ldb
- *
- *  Component: ldb dn parsing
- *
- *  Description: explode a dn into it's own basic elements
- *               and put them in a structure
- *
- *  Author: Simo Sorce
- *  Author: Derrell Lipman
- */
-
-#include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_private.h"
-#include "ldb/include/ldb_explode_dn.h"
-
-#define LDB_PARSE_DN_INVALID(x) do {            \
-	if (x) {                                \
-                goto failed;                    \
-	}                                       \
-} while(0)
-
-
-/*
- * Forward declarations
- */
-
-static char *
-parse_slash(char *p,
-            char *end);
-
-
-
-/*
- * Public functions
- */
-
-/*
- * ldb_explode_dn()
- *
- * Explode, normalize, and optionally case-fold a DN string.  The result is a
- * structure containing arrays of the constituent RDNs.
- *
- * Parameters:
- *   mem_ctx -
- *     talloc context on which all allocated memory is hung
- *
- *   orig_dn -
- *     The distinguished name, in string format, to be exploded
- *
- *   hUserData -
- *     Data handle provided by the caller, and passed back to the caller in
- *     the case_fold_attr_fn callback function.  This handle is not otherwise
- *     used within this function.
- *
- *   case_fold_attr_fn -
- *     Pointer to a callback function which will be called to determine if a
- *     particular attribute type (name) requires case-folding of its values.
- *     If this function pointer is non-null, then attribute names will always
- *     be case-folded.  Additionally, the function pointed to by
- *     case_fold_attr_fn will be called with the data handle (hUserData) and
- *     an attribute name as its parameters, and should return TRUE or FALSE to
- *     indicate whether values of that attribute type should be case-folded.
- *
- *     If case_fold_attr_fn is null, then neither attribute names nor
- *     attribute values will be case-folded.
- *
- * Returns:
- *   Upon success, an ldb_dn structure pointer is returned, containing the
- *   exploded DN.
- *
- *   If memory could not be allocated or if the DN was improperly formatted,
- *   NULL is returned.
- */
-struct ldb_dn *
-ldb_explode_dn(void * mem_ctx,
-               const char * orig_dn,
-               void * hUserData,
-               int (*case_fold_attr_fn)(void * hUserData,
-                                        char * attr))
-{
-	struct ldb_dn *             dn;
-	struct ldb_dn_component *   component;
-	struct ldb_dn_attribute *   attribute;
-	char *                      p;
-        char *                      start;
-        char *                      separator;
-        char *                      src;
-        char *                      dest;
-        char *                      dn_copy;
-        char *                      dn_end;
-	int                         i;
-        int                         size;
-        int                         orig_len;
-
-        /* Allocate a structure to hold the exploded DN */
-	if ((dn = talloc(mem_ctx, struct ldb_dn)) == NULL) {
-            return NULL;
-        }
-
-        /* Initially there are no components */
-	dn->comp_num = 0;
-
-        /* Allocate the component array, with space for one component */
-	if ((dn->components =
-             talloc_array(dn, struct ldb_dn_component *, 1)) == NULL) {
-
-                goto failed;
-        }
-
-        /* Allocate the first component */
-	if ((component = talloc(dn, struct ldb_dn_component)) == NULL) {
-                goto failed;
-        }
-
-        /* This component has no attributes yet */
-	component->attr_num = 0;
-
-        /* Get the length of the provided DN */
-	if ((orig_len = strlen(orig_dn)) == 0) {
-
-                /* We found a zero-length DN.  Return it. */
-		if ((dn->dn = talloc_strdup(dn, orig_dn)) == NULL) {
-                        goto failed;
-                }
-		return dn;
-	}
-
-        /* Copy the provided DN so we can manipulate it */
-        if ((dn_copy = talloc_strdup(mem_ctx, orig_dn)) == NULL) {
-                goto failed;
-        }
-
-        p = dn_copy;
-        
-        /* Our copy may end shorter than the original as we unescape chars */
-	dn_end = dn_copy + orig_len + 1;
-
-        /* For each attribute/value pair... */
-	do {
-                /* Allocate an array to hold the attributes, initially len 1 */
-		if ((component->attributes =
-                     talloc_array(component,
-                                  struct ldb_dn_attribute *, 1)) == NULL) {
-                        goto failed;
-                }
-                
-                /* Allocate this attribute */
-		if ((attribute =
-                     talloc(component, struct ldb_dn_attribute)) == NULL) {
-                        goto failed;
-                }
-
-		/* skip white space */
-		while (*p == ' ' || *p == '\n') {
-			p++;
-		}
-
-		/* start parsing this component */
-		do {
-                        /* Save pointer to beginning of attribute name */
-			start = p;
-
-			/* find our attribute/value separator '=' */
-			while (*p != '\0' && *p != '=') {
-				if (*p == '\\') {
-					if ((dn_end =
-                                             parse_slash(p, dn_end)) == NULL) {
-                                                goto failed;
-                                        }
-				}
-				p++;
-			}
-
-                        /* Ensure we found the attribute/value separator */
-                        if (*p != '=') {
-                                goto failed;
-                        }
-
-                        /* Save pointer to separator */
-			separator = p;
-
-			/* remove trailing white space from attribute name */
-			while (p > start &&
-                               (*(p - 1) == ' ' || *(p - 1) == '\n')) {
-
-				p--;
-			}
-			LDB_PARSE_DN_INVALID((p - start) < 1);
-
-			/* save attribute name */
-			if ((attribute->name =
-                             talloc_strndup(attribute,
-                                            start,
-                                            p - start)) == NULL) {
-                                goto failed;
-                        }
-
-                        /* see if this attribute name needs case folding */
-                        if (case_fold_attr_fn != NULL &&
-                            (* case_fold_attr_fn)(hUserData,
-                                                  attribute->name)) {
-	                        p = attribute->name;
-        	                if ((attribute->name =
-                	             ldb_casefold(attribute, p)) == NULL) {
-                        	        goto failed;
-                        	}
-                        	talloc_free(p);
-			}
-
-			ldb_debug(mem_ctx,
-                                  LDB_DEBUG_TRACE,
-                                  "attribute name: [%s]\n", attribute->name);
-
-                        /* skip white space after the separator */
-                        p = separator + 1;
-                        p += strspn(p, " \n");
-                        
-                        /* ensure there's a value here */
-                        if (*p == '\0') {
-                                goto failed;
-                        }
-
-			/* check if the value is enclosed in QUOTATION */
-			if (*p == '"') {
-                                /* save pointer to beginning of attr value */
-				start = p + 1;
-
-                                /* find the trailing QUOTE */
-				while (*p != '\0' && *p != '"') {
-					if (*p == '\\') {
-						if ((dn_end =
-                                                     parse_slash(p, dn_end)) == NULL) {
-                                                        goto failed;
-                                                }
-					}
-
-					p++;
-				}
-
-                                /* skip spaces until the separator */
-                                if (*p == '\0') {
-                                        /* We're already at end of string */
-                                        separator = p;
-                                } else {
-                                        /* Skip spaces */
-                                        separator = p + 1 + strspn(p+1, " \n");
-                                }
-
-                                /* must be end of string or a separator here */
-				if (*separator != '\0' &&
-                                    *separator != ',' &&
-                                    *separator != ';' &&
-                                    *separator != '+') { 
-					/* Error Malformed DN */
-                                        goto failed;
-				}
-			} else {
-                                /*
-                                 * Value is not quouted.
-                                 */
-
-                                /* save pointer to beginning of value */
-                                start = p;
-
-                                /* find end of value */
-				while (*p != '\0' &&
-                                       *p != ',' &&
-                                       *p != ';' &&
-                                       *p != '+') {
-
-					if (*p == '\\') {
-						if ((dn_end =
-                                                     parse_slash(p, dn_end)) == NULL) {
-                                                        goto failed;
-                                                }
-					}
-
-					p++;
-				}
-
-                                /* save pointer to the terminating separator */
-				separator = p;
-
-				/* remove trailing whitespace */
-				while (p > start &&
-                                       (*(p - 1) == ' ' ||
-                                        *(p - 1) == '\n')) {
-                                    
-					p--;
-				}
-			}
-			LDB_PARSE_DN_INVALID((p - start) < 1);
-
-			/* save the value */
-			if ((attribute->value =
-                             talloc_strndup(attribute,
-                                            start,
-                                            p - start)) == NULL) {
-                                goto failed;
-                        }
-
-                        /* see if this attribute value needs case folding */
-                        if (case_fold_attr_fn != NULL &&
-                            (* case_fold_attr_fn)(hUserData,
-                                                  attribute->name)) {
-                                /* yup, case-fold it. */
-                                p = attribute->value;
-                                if ((attribute->value =
-                                     ldb_casefold(attribute, p)) == NULL) {
-                                        goto failed;
-                                }
-                                talloc_free(p);
-                        }
-
-                        ldb_debug(mem_ctx,
-                                  LDB_DEBUG_TRACE,
-                                  "attribute value: [%s]\n", attribute->value);
-
-                        /* save the entire RDN */
-                        if ((attribute->rdn =
-                             talloc_asprintf(attribute,
-                                             "%s=%s",
-                                             attribute->name,
-                                             attribute->value)) == NULL) {
-                                goto failed;
-                        }
-
-                        ldb_debug(mem_ctx,
-                                  LDB_DEBUG_TRACE,
-                                  "attribute: [%s]\n", attribute->rdn);
-
-                        /* add this attribute to the attribute list */
-			component->attributes[component->attr_num] = attribute;
-			component->attr_num++;
-
-                        /* is this a multi-valued attribute? */
-			if (*separator == '+') {
-                                /* Yup.  prepare for the next value. */
-                                if ((component->attributes =
-                                     talloc_realloc(component,
-                                                    component->attributes,
-                                                    struct ldb_dn_attribute *,
-                                                    component->attr_num + 1)) == NULL) {
-                                        goto failed;
-                                }
-
-				/* allocate new attribute structure */
-				if ((attribute =
-                                     talloc(component,
-                                            struct ldb_dn_attribute)) == NULL) {
-                                        goto failed;
-                                }
-			}
-
-                        /* if we're not at end of string, skip white space */
-                        if (*separator != '\0') {
-                                /* skip spaces past the separator */
-                                p = separator + 1;
-                                p += strspn(p, " \n");
-                        }
-
-		} while (*separator == '+');
-
-                /* find total length of all attributes */
-		for (i = 0, size = 0; i < component->attr_num; i++) {
-			size += strlen(component->attributes[i]->rdn) + 1;
-		}
-
-		/*
-                 * rebuild the normalized component
-                 */
-
-                /* allocate space for the normalized component */
-		if ((dest = talloc_size(component, size)) == NULL) {
-
-                        goto failed;
-                }
-
-                /* Save the pointer to the beginning of the string */
-                component->component = dest;
-
-                /* copy each of the attributes to the normalized component */
-		for (i = 0; i < component->attr_num; i++) {
-			if (i != 0) {
-				*dest++ = '+';
-			}
-			src = component->attributes[i]->rdn;
-
-                        /* we are guaranteed to have enough space in dest */
-                        size = strlen(src);
-                        strncpy(dest, src, size + 1);
-                        dest += size;
-		}
-
-		ldb_debug(mem_ctx,
-                          LDB_DEBUG_TRACE,
-                          "component: [%s]\n", component->component);
-
-                /* insert the component into the component list */
-		dn->components[dn->comp_num] = component;
-		dn->comp_num++;
-
-                /* if there are additional components... */
-		if (*separator == ',' || *separator == ';') {
-                        /* ... then prepare to parse them */
-                        if ((dn->components =
-                             talloc_realloc(dn,
-                                            dn->components,
-                                            struct ldb_dn_component *,
-                                            dn->comp_num + 1)) == NULL ||
-                            (component =
-                             talloc(dn, struct ldb_dn_component)) == NULL) {
-
-                                goto failed;
-                        }
-
-			component->attr_num = 0;
-		}
-
-                /* update pointer to after the separator */
-		p = separator + 1;
-
-	} while(*separator == ',' || *separator == ';');
-
-        /* find total length of all components */
-	for (i = 0, size = 0; i < dn->comp_num; i++) {
-		size = size + strlen(dn->components[i]->component) + 1;
-	}
-
-	/* rebuild the normalized DN */
-	if ((dest = talloc_size(dn, size)) == NULL) {
-                goto failed;
-        }
-
-        /* Save the pointer to the beginning of the */
-        dn->dn = dest;
-
-        /* copy the normalized components into the DN */
-	for (i = 0; i < dn->comp_num; i++) {
-
-                /* add a separator between DN components */
-		if (i != 0) {
-			*dest++ = ',';
-		}
-
-                /* point to this component of the DN */
-		src = dn->components[i]->component;
-
-                /* we are guaranteed to have enough space in dest */
-                size = strlen(src);
-                strncpy(dest, src, size + 1);
-                dest += size;
-	}
-
-	ldb_debug(mem_ctx, LDB_DEBUG_TRACE, "dn: [%s]\n", dn->dn);
-
-        /* we don't need the copy of the DN any more */
-	talloc_free(dn_copy);
-
-        /* give 'em what they came for! */
-	return dn;
-
-failed:
-        /* something went wrong.  free memory and tell 'em it failed */
-        talloc_free(dn);
-        ldb_debug(mem_ctx, LDB_DEBUG_TRACE, "Failed to parse %s\n", orig_dn);
-        return NULL;
-}
-
-
-static char *parse_slash(char *p, char *end)
-{
-	unsigned x;
-	if (strchr(",=\n+<>#;\\\"", p[1])) {
-		memmove(p, p + 1, end - (p + 1));
-		return (end - 1);
-	}
-	if (sscanf(p + 1, "%02x", &x) == 1) {
-		*p = (unsigned char)x;
-		memmove(p + 1, p + 3, end - (p + 3));
-		return (end - 2);
-	}
-	return NULL;
-}
-
diff --git a/source4/lib/ldb/include/ldb_explode_dn.h b/source4/lib/ldb/include/ldb_dn.h
index af9829ba40..f355ee4879 100644
--- a/source4/lib/ldb/include/ldb_explode_dn.h
+++ b/source4/lib/ldb/include/ldb_dn.h
@@ -20,27 +20,23 @@
 */
 
 struct ldb_dn_attribute {
-	char *                      rdn;
-	char *                      name;
-	char *                      value;
+	char *name;
+	char *value;
 };
 
 struct ldb_dn_component {
-	char *                      component;
-	int                         attr_num;
-	struct ldb_dn_attribute **  attributes;
+	int attr_num;
+	struct ldb_dn_attribute **attributes;
 };
 
 struct ldb_dn {
-	char *                      dn;
-	int                         comp_num;
-	struct ldb_dn_component **  components;
+	int comp_num;
+	struct ldb_dn_component **components;
 };
 
 
-extern struct ldb_dn *
-ldb_explode_dn(void * mem_ctx,
-               const char * orig_dn,
-               void * hUserData,
-               int (*case_fold_attr_fn)(void * hUserData,
-                                        char * attr));
+struct ldb_dn *ldb_dn_explode(void *mem_ctx, const char *dn);
+char *ldb_dn_linearize(void *mem_ctx, struct ldb_dn *edn);
+int ldb_dn_compare(struct ldb_dn *edn0, struct ldb_dn *edn1);
+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));