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

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
new file mode 100644
index 0000000000..198c984823
--- /dev/null
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -0,0 +1,476 @@
+/* 
+   ldb database library
+
+   Copyright (C) Andrew Tridgell  2004
+
+     ** NOTE! The following LGPL license applies to the ldb
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
+   
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/*
+ *  Name: ldb
+ *
+ *  Component: ldif routines
+ *
+ *  Description: ldif pack/unpack routines
+ *
+ *  Author: Andrew Tridgell
+ */
+
+#include "includes.h"
+
+
+/*
+  this base64 decoder was taken from jitterbug (written by tridge).
+  we might need to replace it with a new version
+*/
+static int base64_decode(char *s)
+{
+	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	int bit_offset, byte_offset, idx, i, n;
+	unsigned char *d = (unsigned char *)s;
+	char *p;
+
+	n=i=0;
+
+	while (*s && (p=strchr(b64,*s))) {
+		idx = (int)(p - b64);
+		byte_offset = (i*6)/8;
+		bit_offset = (i*6)%8;
+		d[byte_offset] &= ~((1<<(8-bit_offset))-1);
+		if (bit_offset < 3) {
+			d[byte_offset] |= (idx << (2-bit_offset));
+			n = byte_offset+1;
+		} else {
+			d[byte_offset] |= (idx >> (bit_offset-2));
+			d[byte_offset+1] = 0;
+			d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
+			n = byte_offset+2;
+		}
+		s++; i++;
+	}
+
+	if (*s && !p) {
+		/* the only termination allowed */
+		if (*s != '=') {
+			return -1;
+		}
+	}
+
+	/* null terminate */
+	d[n] = 0;
+	return n;
+}
+
+
+/*
+  encode as base64
+  caller frees
+*/
+char *ldb_base64_encode(const char *buf, int len)
+{
+	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	int bit_offset, byte_offset, idx, i;
+	unsigned char *d = (unsigned char *)buf;
+	int bytes = (len*8 + 5)/6;
+	char *out;
+
+	out = malloc(bytes+2);
+	if (!out) return NULL;
+
+	for (i=0;i<bytes;i++) {
+		byte_offset = (i*6)/8;
+		bit_offset = (i*6)%8;
+		if (bit_offset < 3) {
+			idx = (d[byte_offset] >> (2-bit_offset)) & 0x3F;
+		} else {
+			idx = (d[byte_offset] << (bit_offset-2)) & 0x3F;
+			if (byte_offset+1 < len) {
+				idx |= (d[byte_offset+1] >> (8-(bit_offset-2)));
+			}
+		}
+		out[i] = b64[idx];
+	}
+
+	out[i++] = '=';
+	out[i] = 0;
+
+	return out;
+}
+
+/*
+  see if a buffer should be base64 encoded
+*/
+int ldb_should_b64_encode(const struct ldb_val *val)
+{
+	int i;
+	unsigned char *p = val->data;
+
+	if (val->length == 0 || p[0] == ' ' || p[0] == ':') {
+		return 1;
+	}
+
+	for (i=0; i<val->length; i++) {
+		if (!isprint(p[i]) || p[i] == '\n') {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/* this macro is used to handle the return checking on fprintf_fn() */
+#define CHECK_RET do { if (ret < 0) return ret; total += ret; } while (0)
+
+/*
+  write a line folded string onto a file
+*/
+static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *private,
+			const char *buf, size_t length, int start_pos)
+{
+	int i;
+	int total=0, ret;
+
+	for (i=0;i<length;i++) {
+		ret = fprintf_fn(private, "%c", buf[i]);
+		CHECK_RET;
+		if (i != (length-1) && (i + start_pos) % 77 == 0) {
+			ret = fprintf_fn(private, "\n ");
+			CHECK_RET;
+		}
+	}
+
+	return total;
+}
+
+/*
+  encode as base64 to a file
+*/
+static int base64_encode_f(int (*fprintf_fn)(void *, const char *, ...), void *private,
+			   const char *buf, int len, int start_pos)
+{
+	char *b = ldb_base64_encode(buf, len);
+	int ret;
+
+	if (!b) {
+		return -1;
+	}
+
+	ret = fold_string(fprintf_fn, private, b, strlen(b), start_pos);
+
+	free(b);
+	return ret;
+}
+
+/*
+  write to ldif, using a caller supplied write method
+*/
+int ldif_write(int (*fprintf_fn)(void *, const char *, ...), 
+	       void *private,
+	       const struct ldb_message *msg)
+{
+	int i;
+	int total=0, ret;
+
+	ret = fprintf_fn(private, "dn: %s\n", msg->dn);
+	CHECK_RET;
+
+	for (i=0;i<msg->num_elements;i++) {
+		if (ldb_should_b64_encode(&msg->elements[i].value)) {
+			ret = fprintf_fn(private, "%s:: ", msg->elements[i].name);
+			CHECK_RET;
+			ret = base64_encode_f(fprintf_fn, private, 
+					      msg->elements[i].value.data, 
+					      msg->elements[i].value.length,
+					      strlen(msg->elements[i].name)+3);
+			CHECK_RET;
+			ret = fprintf_fn(private, "\n");
+			CHECK_RET;
+		} else {
+			ret = fprintf_fn(private, "%s: ", msg->elements[i].name);
+			CHECK_RET;
+			ret = fold_string(fprintf_fn, private,
+					  msg->elements[i].value.data,
+					  msg->elements[i].value.length,
+					  strlen(msg->elements[i].name)+2);
+			CHECK_RET;
+			ret = fprintf_fn(private, "\n");
+			CHECK_RET;
+		}
+	}
+	ret = fprintf_fn(private,"\n");
+	CHECK_RET;
+
+	return total;
+}
+
+#undef CHECK_RET
+
+
+/*
+  pull a ldif chunk, which is defined as a piece of data ending in \n\n or EOF
+  this routine removes any RFC2849 continuations and comments
+
+  caller frees
+*/
+static char *next_chunk(int (*fgetc_fn)(void *), void *private)
+{
+	size_t alloc_size=0, chunk_size = 0;
+	char *chunk = NULL;
+	int c;
+	int in_comment = 0;
+
+	while ((c = fgetc_fn(private)) != EOF) {
+		if (chunk_size == alloc_size) {
+			char *c2;
+			alloc_size += 1024;
+			c2 = realloc_p(chunk, char, alloc_size);
+			if (!c2) {
+				free(chunk);
+				errno = ENOMEM;
+				return NULL;
+			}
+			chunk = c2;
+		}
+
+		if (in_comment) {
+			if (c == '\n') {
+				in_comment = 0;
+			}
+			continue;			
+		}
+		
+		/* handle continuation lines - see RFC2849 */
+		if (c == ' ' && chunk_size > 1 && chunk[chunk_size-1] == '\n') {
+			chunk_size--;
+			continue;
+		}
+		
+		/* chunks are terminated by a double line-feed */
+		if (c == '\n' && chunk_size > 0 && chunk[chunk_size-1] == '\n') {
+			chunk[chunk_size-1] = 0;
+			return chunk;
+		}
+
+		if (c == '#' && (chunk_size == 0 || chunk[chunk_size-1] == '\n')) {
+			in_comment = 1;
+			continue;
+		}
+
+		/* ignore leading blank lines */
+		if (chunk_size == 0 && c == '\n') {
+			continue;
+		}
+
+		chunk[chunk_size++] = c;
+	}
+
+	return chunk;
+}
+
+
+/* simple ldif attribute parser */
+static int next_attr(char **s, char **attr, struct ldb_val *value)
+{
+	char *p;
+	int base64_encoded = 0;
+
+	p = strchr(*s, ':');
+	if (!p) {
+		return -1;
+	}
+
+	*p++ = 0;
+
+	if (*p == ':') {
+		base64_encoded = 1;
+		p++;
+	}
+
+	*attr = *s;
+
+	while (isspace(*p)) {
+		p++;
+	}
+
+	value->data = p;
+
+	p = strchr(p, '\n');
+
+	if (!p) {
+		value->length = strlen((char *)value->data);
+		*s = ((char *)value->data) + value->length;
+	} else {
+		value->length = p - (char *)value->data;
+		*s = p+1;
+		*p = 0;
+	}
+
+	if (base64_encoded) {
+		int len = base64_decode(value->data);
+		if (len == -1) {
+			/* it wasn't valid base64 data */
+			return -1;
+		}
+		value->length = len;
+	}
+
+	return 0;
+}
+
+
+/*
+  free a message from a ldif_read
+*/
+void ldif_read_free(struct ldb_message *msg)
+{
+	if (msg->elements) free(msg->elements);
+	if (msg->private) free(msg->private);
+	free(msg);
+}
+
+/*
+ read from a LDIF source, creating a ldb_message
+*/
+struct ldb_message *ldif_read(int (*fgetc_fn)(void *), void *private)
+{
+	struct ldb_message *msg;
+	char *attr=NULL, *chunk=NULL, *s;
+	struct ldb_val value;
+
+	value.data = NULL;
+
+	msg = malloc_p(struct ldb_message);
+	if (!msg) return NULL;
+
+	msg->dn = NULL;
+	msg->elements = NULL;
+	msg->num_elements = 0;
+	msg->private = NULL;
+
+	chunk = next_chunk(fgetc_fn, private);
+	if (!chunk) {
+		goto failed;
+	}
+
+	msg->private = chunk;
+	s = chunk;
+
+	if (next_attr(&s, &attr, &value) != 0) {
+		goto failed;
+	}
+	
+	/* first line must be a dn */
+	if (strcmp(attr, "dn") != 0) {
+		fprintf(stderr, "First line must be a dn not '%s'\n", attr);
+		goto failed;
+	}
+
+	msg->dn = value.data;
+
+	while (next_attr(&s, &attr, &value) == 0) {
+		msg->elements = realloc_p(msg->elements, 
+					  struct ldb_message_element, 
+					  msg->num_elements+1);
+		if (!msg->elements) {
+			goto failed;
+		}
+		msg->elements[msg->num_elements].flags = 0;
+		msg->elements[msg->num_elements].name = attr;
+		msg->elements[msg->num_elements].value = value;
+		msg->num_elements++;
+	}
+
+	return msg;
+
+failed:
+	if (msg) ldif_read_free(msg);
+	return NULL;
+}
+
+
+
+/*
+  a wrapper around ldif_read() for reading from FILE*
+*/
+struct ldif_read_file_state {
+	FILE *f;
+};
+
+static int fgetc_file(void *private)
+{
+	struct ldif_read_file_state *state = private;
+	return fgetc(state->f);
+}
+
+struct ldb_message *ldif_read_file(FILE *f)
+{
+	struct ldif_read_file_state state;
+	state.f = f;
+	return ldif_read(fgetc_file, &state);
+}
+
+
+/*
+  a wrapper around ldif_read() for reading from const char*
+*/
+struct ldif_read_string_state {
+	const char *s;
+};
+
+static int fgetc_string(void *private)
+{
+	struct ldif_read_string_state *state = private;
+	if (state->s[0] != 0) {
+		return *state->s++;
+	}
+	return EOF;
+}
+
+struct ldb_message *ldif_read_string(const char *s)
+{
+	struct ldif_read_string_state state;
+	state.s = s;
+	return ldif_read(fgetc_string, &state);
+}
+
+
+/*
+  wrapper around ldif_write() for a file
+*/
+struct ldif_write_file_state {
+	FILE *f;
+};
+
+static int fprintf_file(void *private, const char *fmt, ...)
+{
+	struct ldif_write_file_state *state = private;
+	int ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = vfprintf(state->f, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+int ldif_write_file(FILE *f, const struct ldb_message *msg)
+{
+	struct ldif_write_file_state state;
+	state.f = f;
+	return ldif_write(fprintf_file, &state, msg);
+}
-- 
cgit 


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

---
 source4/lib/ldb/common/ldb_ldif.c | 233 +++++++++++++++++++++++++++++++-------
 1 file changed, 190 insertions(+), 43 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 198c984823..b4c27c3369 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -32,6 +32,10 @@
  *  Author: Andrew Tridgell
  */
 
+/*
+  see RFC2849 for the LDIF format definition
+*/
+
 #include "includes.h"
 
 
@@ -176,40 +180,71 @@ static int base64_encode_f(int (*fprintf_fn)(void *, const char *, ...), void *p
 	return ret;
 }
 
+
+static const struct {
+	const char *name;
+	enum ldb_changetype changetype;
+} ldb_changetypes[] = {
+	{"add",    LDB_CHANGETYPE_ADD},
+	{"delete", LDB_CHANGETYPE_DELETE},
+	{"modify", LDB_CHANGETYPE_MODIFY},
+	{NULL, 0}
+};
+
 /*
   write to ldif, using a caller supplied write method
 */
 int ldif_write(int (*fprintf_fn)(void *, const char *, ...), 
 	       void *private,
-	       const struct ldb_message *msg)
+	       const struct ldb_ldif *ldif)
 {
-	int i;
+	int i, j;
 	int total=0, ret;
+	const struct ldb_message *msg;
+
+	msg = &ldif->msg;
 
 	ret = fprintf_fn(private, "dn: %s\n", msg->dn);
 	CHECK_RET;
 
+	if (ldif->changetype != LDB_CHANGETYPE_NONE) {
+		for (i=0;ldb_changetypes[i].name;i++) {
+			if (ldb_changetypes[i].changetype == ldif->changetype) {
+				break;
+			}
+		}
+		if (!ldb_changetypes[i].name) {
+			fprintf(stderr,"Invalid changetype\n");
+			return -1;
+		}
+		ret = fprintf_fn(private, "changetype: %s\n", ldb_changetypes[i].name);
+		CHECK_RET;
+	}
+
 	for (i=0;i<msg->num_elements;i++) {
-		if (ldb_should_b64_encode(&msg->elements[i].value)) {
-			ret = fprintf_fn(private, "%s:: ", msg->elements[i].name);
-			CHECK_RET;
-			ret = base64_encode_f(fprintf_fn, private, 
-					      msg->elements[i].value.data, 
-					      msg->elements[i].value.length,
-					      strlen(msg->elements[i].name)+3);
-			CHECK_RET;
-			ret = fprintf_fn(private, "\n");
-			CHECK_RET;
-		} else {
-			ret = fprintf_fn(private, "%s: ", msg->elements[i].name);
-			CHECK_RET;
-			ret = fold_string(fprintf_fn, private,
-					  msg->elements[i].value.data,
-					  msg->elements[i].value.length,
-					  strlen(msg->elements[i].name)+2);
-			CHECK_RET;
-			ret = fprintf_fn(private, "\n");
-			CHECK_RET;
+		for (j=0;j<msg->elements[i].num_values;j++) {
+			if (ldb_should_b64_encode(&msg->elements[i].values[j])) {
+				ret = fprintf_fn(private, "%s:: ", 
+						 msg->elements[i].name);
+				CHECK_RET;
+				ret = base64_encode_f(fprintf_fn, private, 
+						      msg->elements[i].values[j].data, 
+						      msg->elements[i].values[j].length,
+						      strlen(msg->elements[i].name)+3);
+				CHECK_RET;
+				ret = fprintf_fn(private, "\n");
+				CHECK_RET;
+			} else {
+				ret = fprintf_fn(private, "%s: ", msg->elements[i].name);
+				CHECK_RET;
+				ret = fold_string(fprintf_fn, private,
+						  msg->elements[i].values[j].data,
+						  msg->elements[i].values[j].length,
+						  strlen(msg->elements[i].name)+2);
+				CHECK_RET;
+				ret = fprintf_fn(private, "\n");
+				CHECK_RET;
+			}
 		}
 	}
 	ret = fprintf_fn(private,"\n");
@@ -235,7 +270,7 @@ static char *next_chunk(int (*fgetc_fn)(void *), void *private)
 	int in_comment = 0;
 
 	while ((c = fgetc_fn(private)) != EOF) {
-		if (chunk_size == alloc_size) {
+		if (chunk_size+1 >= alloc_size) {
 			char *c2;
 			alloc_size += 1024;
 			c2 = realloc_p(chunk, char, alloc_size);
@@ -279,6 +314,10 @@ static char *next_chunk(int (*fgetc_fn)(void *), void *private)
 		chunk[chunk_size++] = c;
 	}
 
+	if (chunk) {
+		chunk[chunk_size] = 0;
+	}
+
 	return chunk;
 }
 
@@ -289,6 +328,13 @@ static int next_attr(char **s, char **attr, struct ldb_val *value)
 	char *p;
 	int base64_encoded = 0;
 
+	if (strncmp(*s, "-\n", 2) == 0) {
+		value->length = 0;
+		*attr = "-";
+		*s += 2;
+		return 0;
+	}
+
 	p = strchr(*s, ':');
 	if (!p) {
 		return -1;
@@ -336,26 +382,63 @@ static int next_attr(char **s, char **attr, struct ldb_val *value)
 /*
   free a message from a ldif_read
 */
-void ldif_read_free(struct ldb_message *msg)
+void ldif_read_free(struct ldb_ldif *ldif)
 {
+	struct ldb_message *msg = &ldif->msg;
+	int i;
+	for (i=0;i<msg->num_elements;i++) {
+		if (msg->elements[i].values) free(msg->elements[i].values);
+	}
 	if (msg->elements) free(msg->elements);
 	if (msg->private) free(msg->private);
-	free(msg);
+	free(ldif);
+}
+
+/*
+  add an empty element
+*/
+static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned flags)
+{
+	struct ldb_message_element *el2, *el;
+
+	el2 = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1);
+	if (!el2) {
+		errno = ENOMEM;
+		return -1;
+	}
+	
+	msg->elements = el2;
+
+	el = &msg->elements[msg->num_elements];
+	
+	el->name = name;
+	el->num_values = 0;
+	el->values = NULL;
+	el->flags = flags;
+
+	msg->num_elements++;
+
+	return 0;
 }
 
 /*
  read from a LDIF source, creating a ldb_message
 */
-struct ldb_message *ldif_read(int (*fgetc_fn)(void *), void *private)
+struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private)
 {
+	struct ldb_ldif *ldif;
 	struct ldb_message *msg;
 	char *attr=NULL, *chunk=NULL, *s;
 	struct ldb_val value;
+	unsigned flags = 0;
 
 	value.data = NULL;
 
-	msg = malloc_p(struct ldb_message);
-	if (!msg) return NULL;
+	ldif = malloc_p(struct ldb_ldif);
+	if (!ldif) return NULL;
+
+	ldif->changetype = LDB_CHANGETYPE_NONE;
+	msg = &ldif->msg;
 
 	msg->dn = NULL;
 	msg->elements = NULL;
@@ -383,22 +466,86 @@ struct ldb_message *ldif_read(int (*fgetc_fn)(void *), void *private)
 	msg->dn = value.data;
 
 	while (next_attr(&s, &attr, &value) == 0) {
-		msg->elements = realloc_p(msg->elements, 
-					  struct ldb_message_element, 
-					  msg->num_elements+1);
-		if (!msg->elements) {
-			goto failed;
+		struct ldb_message_element *el;
+		int empty = 0;
+
+		if (strcmp(attr, "changetype") == 0) {
+			int i;
+			for (i=0;ldb_changetypes[i].name;i++) {
+				if (strcmp((char *)value.data, ldb_changetypes[i].name) == 0) {
+					ldif->changetype = ldb_changetypes[i].changetype;
+					break;
+				}
+			}
+			if (!ldb_changetypes[i].name) {
+				fprintf(stderr,"Bad changetype '%s'\n",
+					(char *)value.data);
+			}
+			flags = 0;
+			continue;
+		}
+
+		if (strcmp(attr, "add") == 0) {
+			flags = LDB_FLAG_MOD_ADD;
+			empty = 1;
+		}
+		if (strcmp(attr, "delete") == 0) {
+			flags = LDB_FLAG_MOD_DELETE;
+			empty = 1;
+		}
+		if (strcmp(attr, "replace") == 0) {
+			flags = LDB_FLAG_MOD_REPLACE;
+			empty = 1;
+		}
+		if (strcmp(attr, "-") == 0) {
+			flags = 0;
+			continue;
+		}
+
+		if (empty) {
+			if (msg_add_empty(msg, (char *)value.data, flags) != 0) {
+				goto failed;
+			}
+			continue;
+		}
+		
+		el = &msg->elements[msg->num_elements-1];
+
+		if (msg->num_elements > 0 && strcmp(attr, el->name) == 0 &&
+		    flags == el->flags) {
+			/* its a continuation */
+			el->values = 
+				realloc_p(el->values, struct ldb_val, el->num_values+1);
+			if (!el->values) {
+				goto failed;
+			}
+			el->values[el->num_values] = value;
+			el->num_values++;
+		} else {
+			/* its a new attribute */
+			msg->elements = realloc_p(msg->elements, 
+						  struct ldb_message_element, 
+						  msg->num_elements+1);
+			if (!msg->elements) {
+				goto failed;
+			}
+			msg->elements[msg->num_elements].flags = flags;
+			msg->elements[msg->num_elements].name = attr;
+			el = &msg->elements[msg->num_elements];
+			el->values = malloc_p(struct ldb_val);
+			if (!el->values) {
+				goto failed;
+			}
+			el->num_values = 1;
+			el->values[0] = value;
+			msg->num_elements++;
 		}
-		msg->elements[msg->num_elements].flags = 0;
-		msg->elements[msg->num_elements].name = attr;
-		msg->elements[msg->num_elements].value = value;
-		msg->num_elements++;
 	}
 
-	return msg;
+	return ldif;
 
 failed:
-	if (msg) ldif_read_free(msg);
+	if (ldif) ldif_read_free(ldif);
 	return NULL;
 }
 
@@ -417,7 +564,7 @@ static int fgetc_file(void *private)
 	return fgetc(state->f);
 }
 
-struct ldb_message *ldif_read_file(FILE *f)
+struct ldb_ldif *ldif_read_file(FILE *f)
 {
 	struct ldif_read_file_state state;
 	state.f = f;
@@ -441,7 +588,7 @@ static int fgetc_string(void *private)
 	return EOF;
 }
 
-struct ldb_message *ldif_read_string(const char *s)
+struct ldb_ldif *ldif_read_string(const char *s)
 {
 	struct ldif_read_string_state state;
 	state.s = s;
@@ -468,9 +615,9 @@ static int fprintf_file(void *private, const char *fmt, ...)
 	return ret;
 }
 
-int ldif_write_file(FILE *f, const struct ldb_message *msg)
+int ldif_write_file(FILE *f, const struct ldb_ldif *ldif)
 {
 	struct ldif_write_file_state state;
 	state.f = f;
-	return ldif_write(fprintf_file, &state, msg);
+	return ldif_write(fprintf_file, &state, ldif);
 }
-- 
cgit 


From ac193579e7db00c7a2ea0aadaaf0d34c10dcf1a5 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 10 Apr 2004 20:18:22 +0000
Subject: r152: a quick airport commit ....

added ldbedit, a _really_ useful command

added ldbadd, ldbdel, ldbsearch and ldbmodify to build

solved lots of timezone issues, we now pass the torture tests with
client and server in different zones

fixed several build issues

I know this breaks the no-LDAP build. Wait till I arrive in San Jose for that
fix.
(This used to be commit af34710d4da1841653624fe304b1c8d812c0fdd9)
---
 source4/lib/ldb/common/ldb_ldif.c | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index b4c27c3369..5f2fccfebc 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -90,7 +90,7 @@ char *ldb_base64_encode(const char *buf, int len)
 {
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i;
-	unsigned char *d = (unsigned char *)buf;
+	const unsigned char *d = (const unsigned char *)buf;
 	int bytes = (len*8 + 5)/6;
 	char *out;
 
@@ -222,6 +222,23 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
+		if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
+			switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
+			case LDB_FLAG_MOD_ADD:
+				fprintf_fn(private, "add: %s\n", 
+					   msg->elements[i].name);
+				break;
+			case LDB_FLAG_MOD_DELETE:
+				fprintf_fn(private, "delete: %s\n", 
+					   msg->elements[i].name);
+				break;
+			case LDB_FLAG_MOD_REPLACE:
+				fprintf_fn(private, "replace: %s\n", 
+					   msg->elements[i].name);
+				break;
+			}
+		}
+
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			if (ldb_should_b64_encode(&msg->elements[i].values[j])) {
 				ret = fprintf_fn(private, "%s:: ", 
@@ -246,6 +263,9 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 				CHECK_RET;
 			}
 		}
+		if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
+			fprintf_fn(private, "-\n");
+		}
 	}
 	ret = fprintf_fn(private,"\n");
 	CHECK_RET;
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 5f2fccfebc..2eaee28eb6 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -410,7 +410,7 @@ void ldif_read_free(struct ldb_ldif *ldif)
 		if (msg->elements[i].values) free(msg->elements[i].values);
 	}
 	if (msg->elements) free(msg->elements);
-	if (msg->private) free(msg->private);
+	if (msg->private_data) free(msg->private_data);
 	free(ldif);
 }
 
@@ -444,7 +444,7 @@ static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned fla
 /*
  read from a LDIF source, creating a ldb_message
 */
-struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private)
+struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 {
 	struct ldb_ldif *ldif;
 	struct ldb_message *msg;
@@ -463,14 +463,14 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private)
 	msg->dn = NULL;
 	msg->elements = NULL;
 	msg->num_elements = 0;
-	msg->private = NULL;
+	msg->private_data = NULL;
 
-	chunk = next_chunk(fgetc_fn, private);
+	chunk = next_chunk(fgetc_fn, private_data);
 	if (!chunk) {
 		goto failed;
 	}
 
-	msg->private = chunk;
+	msg->private_data = chunk;
 	s = chunk;
 
 	if (next_attr(&s, &attr, &value) != 0) {
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 2eaee28eb6..fcf0150557 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -143,17 +143,17 @@ int ldb_should_b64_encode(const struct ldb_val *val)
 /*
   write a line folded string onto a file
 */
-static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *private,
+static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *private_data,
 			const char *buf, size_t length, int start_pos)
 {
 	int i;
 	int total=0, ret;
 
 	for (i=0;i<length;i++) {
-		ret = fprintf_fn(private, "%c", buf[i]);
+		ret = fprintf_fn(private_data, "%c", buf[i]);
 		CHECK_RET;
 		if (i != (length-1) && (i + start_pos) % 77 == 0) {
-			ret = fprintf_fn(private, "\n ");
+			ret = fprintf_fn(private_data, "\n ");
 			CHECK_RET;
 		}
 	}
@@ -164,7 +164,7 @@ static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *priva
 /*
   encode as base64 to a file
 */
-static int base64_encode_f(int (*fprintf_fn)(void *, const char *, ...), void *private,
+static int base64_encode_f(int (*fprintf_fn)(void *, const char *, ...), void *private_data,
 			   const char *buf, int len, int start_pos)
 {
 	char *b = ldb_base64_encode(buf, len);
@@ -174,7 +174,7 @@ static int base64_encode_f(int (*fprintf_fn)(void *, const char *, ...), void *p
 		return -1;
 	}
 
-	ret = fold_string(fprintf_fn, private, b, strlen(b), start_pos);
+	ret = fold_string(fprintf_fn, private_data, b, strlen(b), start_pos);
 
 	free(b);
 	return ret;
@@ -195,7 +195,7 @@ static const struct {
   write to ldif, using a caller supplied write method
 */
 int ldif_write(int (*fprintf_fn)(void *, const char *, ...), 
-	       void *private,
+	       void *private_data,
 	       const struct ldb_ldif *ldif)
 {
 	int i, j;
@@ -204,7 +204,7 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 
 	msg = &ldif->msg;
 
-	ret = fprintf_fn(private, "dn: %s\n", msg->dn);
+	ret = fprintf_fn(private_data, "dn: %s\n", msg->dn);
 	CHECK_RET;
 
 	if (ldif->changetype != LDB_CHANGETYPE_NONE) {
@@ -217,7 +217,7 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 			fprintf(stderr,"Invalid changetype\n");
 			return -1;
 		}
-		ret = fprintf_fn(private, "changetype: %s\n", ldb_changetypes[i].name);
+		ret = fprintf_fn(private_data, "changetype: %s\n", ldb_changetypes[i].name);
 		CHECK_RET;
 	}
 
@@ -225,15 +225,15 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 		if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
 			switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
 			case LDB_FLAG_MOD_ADD:
-				fprintf_fn(private, "add: %s\n", 
+				fprintf_fn(private_data, "add: %s\n", 
 					   msg->elements[i].name);
 				break;
 			case LDB_FLAG_MOD_DELETE:
-				fprintf_fn(private, "delete: %s\n", 
+				fprintf_fn(private_data, "delete: %s\n", 
 					   msg->elements[i].name);
 				break;
 			case LDB_FLAG_MOD_REPLACE:
-				fprintf_fn(private, "replace: %s\n", 
+				fprintf_fn(private_data, "replace: %s\n", 
 					   msg->elements[i].name);
 				break;
 			}
@@ -241,33 +241,33 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			if (ldb_should_b64_encode(&msg->elements[i].values[j])) {
-				ret = fprintf_fn(private, "%s:: ", 
+				ret = fprintf_fn(private_data, "%s:: ", 
 						 msg->elements[i].name);
 				CHECK_RET;
-				ret = base64_encode_f(fprintf_fn, private, 
+				ret = base64_encode_f(fprintf_fn, private_data, 
 						      msg->elements[i].values[j].data, 
 						      msg->elements[i].values[j].length,
 						      strlen(msg->elements[i].name)+3);
 				CHECK_RET;
-				ret = fprintf_fn(private, "\n");
+				ret = fprintf_fn(private_data, "\n");
 				CHECK_RET;
 			} else {
-				ret = fprintf_fn(private, "%s: ", msg->elements[i].name);
+				ret = fprintf_fn(private_data, "%s: ", msg->elements[i].name);
 				CHECK_RET;
-				ret = fold_string(fprintf_fn, private,
+				ret = fold_string(fprintf_fn, private_data,
 						  msg->elements[i].values[j].data,
 						  msg->elements[i].values[j].length,
 						  strlen(msg->elements[i].name)+2);
 				CHECK_RET;
-				ret = fprintf_fn(private, "\n");
+				ret = fprintf_fn(private_data, "\n");
 				CHECK_RET;
 			}
 		}
 		if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
-			fprintf_fn(private, "-\n");
+			fprintf_fn(private_data, "-\n");
 		}
 	}
-	ret = fprintf_fn(private,"\n");
+	ret = fprintf_fn(private_data,"\n");
 	CHECK_RET;
 
 	return total;
@@ -282,14 +282,14 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 
   caller frees
 */
-static char *next_chunk(int (*fgetc_fn)(void *), void *private)
+static char *next_chunk(int (*fgetc_fn)(void *), void *private_data)
 {
 	size_t alloc_size=0, chunk_size = 0;
 	char *chunk = NULL;
 	int c;
 	int in_comment = 0;
 
-	while ((c = fgetc_fn(private)) != EOF) {
+	while ((c = fgetc_fn(private_data)) != EOF) {
 		if (chunk_size+1 >= alloc_size) {
 			char *c2;
 			alloc_size += 1024;
@@ -578,9 +578,9 @@ struct ldif_read_file_state {
 	FILE *f;
 };
 
-static int fgetc_file(void *private)
+static int fgetc_file(void *private_data)
 {
-	struct ldif_read_file_state *state = private;
+	struct ldif_read_file_state *state = private_data;
 	return fgetc(state->f);
 }
 
@@ -599,9 +599,9 @@ struct ldif_read_string_state {
 	const char *s;
 };
 
-static int fgetc_string(void *private)
+static int fgetc_string(void *private_data)
 {
-	struct ldif_read_string_state *state = private;
+	struct ldif_read_string_state *state = private_data;
 	if (state->s[0] != 0) {
 		return *state->s++;
 	}
@@ -623,9 +623,9 @@ struct ldif_write_file_state {
 	FILE *f;
 };
 
-static int fprintf_file(void *private, const char *fmt, ...)
+static int fprintf_file(void *private_data, const char *fmt, ...)
 {
-	struct ldif_write_file_state *state = private;
+	struct ldif_write_file_state *state = private_data;
 	int ret;
 	va_list ap;
 
-- 
cgit 


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

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

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

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

 - cleaned up a number of const warnings

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

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

 - changed some variable names to avoid conflicts with C++
(This used to be commit f2bf06f25c2e6c744817711c7bedbd1d3b52f994)
---
 source4/lib/ldb/common/ldb_ldif.c | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index fcf0150557..1ca585ca80 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -407,6 +407,7 @@ void ldif_read_free(struct ldb_ldif *ldif)
 	struct ldb_message *msg = &ldif->msg;
 	int i;
 	for (i=0;i<msg->num_elements;i++) {
+		if (msg->elements[i].name) free(msg->elements[i].name);
 		if (msg->elements[i].values) free(msg->elements[i].values);
 	}
 	if (msg->elements) free(msg->elements);
@@ -431,11 +432,16 @@ static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned fla
 
 	el = &msg->elements[msg->num_elements];
 	
-	el->name = name;
+	el->name = strdup(name);
 	el->num_values = 0;
 	el->values = NULL;
 	el->flags = flags;
 
+	if (!el->name) {
+		errno = ENOMEM;
+		return -1;
+	}
+
 	msg->num_elements++;
 
 	return 0;
@@ -478,7 +484,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 	}
 	
 	/* first line must be a dn */
-	if (strcmp(attr, "dn") != 0) {
+	if (ldb_attr_cmp(attr, "dn") != 0) {
 		fprintf(stderr, "First line must be a dn not '%s'\n", attr);
 		goto failed;
 	}
@@ -489,10 +495,10 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 		struct ldb_message_element *el;
 		int empty = 0;
 
-		if (strcmp(attr, "changetype") == 0) {
+		if (ldb_attr_cmp(attr, "changetype") == 0) {
 			int i;
 			for (i=0;ldb_changetypes[i].name;i++) {
-				if (strcmp((char *)value.data, ldb_changetypes[i].name) == 0) {
+				if (ldb_attr_cmp((char *)value.data, ldb_changetypes[i].name) == 0) {
 					ldif->changetype = ldb_changetypes[i].changetype;
 					break;
 				}
@@ -505,19 +511,19 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 			continue;
 		}
 
-		if (strcmp(attr, "add") == 0) {
+		if (ldb_attr_cmp(attr, "add") == 0) {
 			flags = LDB_FLAG_MOD_ADD;
 			empty = 1;
 		}
-		if (strcmp(attr, "delete") == 0) {
+		if (ldb_attr_cmp(attr, "delete") == 0) {
 			flags = LDB_FLAG_MOD_DELETE;
 			empty = 1;
 		}
-		if (strcmp(attr, "replace") == 0) {
+		if (ldb_attr_cmp(attr, "replace") == 0) {
 			flags = LDB_FLAG_MOD_REPLACE;
 			empty = 1;
 		}
-		if (strcmp(attr, "-") == 0) {
+		if (ldb_attr_cmp(attr, "-") == 0) {
 			flags = 0;
 			continue;
 		}
@@ -531,7 +537,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 		
 		el = &msg->elements[msg->num_elements-1];
 
-		if (msg->num_elements > 0 && strcmp(attr, el->name) == 0 &&
+		if (msg->num_elements > 0 && ldb_attr_cmp(attr, el->name) == 0 &&
 		    flags == el->flags) {
 			/* its a continuation */
 			el->values = 
@@ -549,11 +555,11 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 			if (!msg->elements) {
 				goto failed;
 			}
-			msg->elements[msg->num_elements].flags = flags;
-			msg->elements[msg->num_elements].name = attr;
 			el = &msg->elements[msg->num_elements];
+			el->flags = flags;
+			el->name = strdup(attr);
 			el->values = malloc_p(struct ldb_val);
-			if (!el->values) {
+			if (!el->values || !el->name) {
 				goto failed;
 			}
 			el->num_values = 1;
-- 
cgit 


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

- made yet another attempt to make ldb const clean.

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

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 1ca585ca80..ef782e90e3 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -343,7 +343,7 @@ static char *next_chunk(int (*fgetc_fn)(void *), void *private_data)
 
 
 /* simple ldif attribute parser */
-static int next_attr(char **s, char **attr, struct ldb_val *value)
+static int next_attr(char **s, const char **attr, struct ldb_val *value)
 {
 	char *p;
 	int base64_encoded = 0;
@@ -454,7 +454,8 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 {
 	struct ldb_ldif *ldif;
 	struct ldb_message *msg;
-	char *attr=NULL, *chunk=NULL, *s;
+	const char *attr=NULL;
+	char *chunk=NULL, *s;
 	struct ldb_val value;
 	unsigned flags = 0;
 
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index ef782e90e3..451276c48d 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -86,7 +86,7 @@ static int base64_decode(char *s)
   encode as base64
   caller frees
 */
-char *ldb_base64_encode(const char *buf, int len)
+char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
 {
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i;
@@ -94,7 +94,7 @@ char *ldb_base64_encode(const char *buf, int len)
 	int bytes = (len*8 + 5)/6;
 	char *out;
 
-	out = malloc(bytes+2);
+	out = ldb_malloc(ldb, bytes+2);
 	if (!out) return NULL;
 
 	for (i=0;i<bytes;i++) {
@@ -164,10 +164,12 @@ static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *priva
 /*
   encode as base64 to a file
 */
-static int base64_encode_f(int (*fprintf_fn)(void *, const char *, ...), void *private_data,
+static int base64_encode_f(struct ldb_context *ldb,
+			   int (*fprintf_fn)(void *, const char *, ...), 
+			   void *private_data,
 			   const char *buf, int len, int start_pos)
 {
-	char *b = ldb_base64_encode(buf, len);
+	char *b = ldb_base64_encode(ldb, buf, len);
 	int ret;
 
 	if (!b) {
@@ -176,7 +178,7 @@ static int base64_encode_f(int (*fprintf_fn)(void *, const char *, ...), void *p
 
 	ret = fold_string(fprintf_fn, private_data, b, strlen(b), start_pos);
 
-	free(b);
+	ldb_free(ldb, b);
 	return ret;
 }
 
@@ -194,7 +196,8 @@ static const struct {
 /*
   write to ldif, using a caller supplied write method
 */
-int ldif_write(int (*fprintf_fn)(void *, const char *, ...), 
+int ldif_write(struct ldb_context *ldb,
+	       int (*fprintf_fn)(void *, const char *, ...), 
 	       void *private_data,
 	       const struct ldb_ldif *ldif)
 {
@@ -244,7 +247,7 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 				ret = fprintf_fn(private_data, "%s:: ", 
 						 msg->elements[i].name);
 				CHECK_RET;
-				ret = base64_encode_f(fprintf_fn, private_data, 
+				ret = base64_encode_f(ldb, fprintf_fn, private_data, 
 						      msg->elements[i].values[j].data, 
 						      msg->elements[i].values[j].length,
 						      strlen(msg->elements[i].name)+3);
@@ -282,7 +285,8 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...),
 
   caller frees
 */
-static char *next_chunk(int (*fgetc_fn)(void *), void *private_data)
+static char *next_chunk(struct ldb_context *ldb, 
+			int (*fgetc_fn)(void *), void *private_data)
 {
 	size_t alloc_size=0, chunk_size = 0;
 	char *chunk = NULL;
@@ -293,9 +297,9 @@ static char *next_chunk(int (*fgetc_fn)(void *), void *private_data)
 		if (chunk_size+1 >= alloc_size) {
 			char *c2;
 			alloc_size += 1024;
-			c2 = realloc_p(chunk, char, alloc_size);
+			c2 = ldb_realloc_p(ldb, chunk, char, alloc_size);
 			if (!c2) {
-				free(chunk);
+				ldb_free(ldb, chunk);
 				errno = ENOMEM;
 				return NULL;
 			}
@@ -402,27 +406,29 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 /*
   free a message from a ldif_read
 */
-void ldif_read_free(struct ldb_ldif *ldif)
+void ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif)
 {
 	struct ldb_message *msg = &ldif->msg;
 	int i;
 	for (i=0;i<msg->num_elements;i++) {
-		if (msg->elements[i].name) free(msg->elements[i].name);
-		if (msg->elements[i].values) free(msg->elements[i].values);
+		if (msg->elements[i].name) ldb_free(ldb, msg->elements[i].name);
+		if (msg->elements[i].values) ldb_free(ldb, msg->elements[i].values);
 	}
-	if (msg->elements) free(msg->elements);
-	if (msg->private_data) free(msg->private_data);
-	free(ldif);
+	if (msg->elements) ldb_free(ldb, msg->elements);
+	if (msg->private_data) ldb_free(ldb, msg->private_data);
+	ldb_free(ldb, ldif);
 }
 
 /*
   add an empty element
 */
-static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned flags)
+static int msg_add_empty(struct ldb_context *ldb,
+			 struct ldb_message *msg, const char *name, unsigned flags)
 {
 	struct ldb_message_element *el2, *el;
 
-	el2 = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1);
+	el2 = ldb_realloc_p(ldb, msg->elements, 
+			    struct ldb_message_element, msg->num_elements+1);
 	if (!el2) {
 		errno = ENOMEM;
 		return -1;
@@ -432,7 +438,7 @@ static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned fla
 
 	el = &msg->elements[msg->num_elements];
 	
-	el->name = strdup(name);
+	el->name = ldb_strdup(ldb, name);
 	el->num_values = 0;
 	el->values = NULL;
 	el->flags = flags;
@@ -450,7 +456,8 @@ static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned fla
 /*
  read from a LDIF source, creating a ldb_message
 */
-struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
+struct ldb_ldif *ldif_read(struct ldb_context *ldb,
+			   int (*fgetc_fn)(void *), void *private_data)
 {
 	struct ldb_ldif *ldif;
 	struct ldb_message *msg;
@@ -461,7 +468,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 
 	value.data = NULL;
 
-	ldif = malloc_p(struct ldb_ldif);
+	ldif = ldb_malloc_p(ldb, struct ldb_ldif);
 	if (!ldif) return NULL;
 
 	ldif->changetype = LDB_CHANGETYPE_NONE;
@@ -472,7 +479,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 	msg->num_elements = 0;
 	msg->private_data = NULL;
 
-	chunk = next_chunk(fgetc_fn, private_data);
+	chunk = next_chunk(ldb, fgetc_fn, private_data);
 	if (!chunk) {
 		goto failed;
 	}
@@ -530,7 +537,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 		}
 
 		if (empty) {
-			if (msg_add_empty(msg, (char *)value.data, flags) != 0) {
+			if (msg_add_empty(ldb, msg, (char *)value.data, flags) != 0) {
 				goto failed;
 			}
 			continue;
@@ -542,7 +549,8 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 		    flags == el->flags) {
 			/* its a continuation */
 			el->values = 
-				realloc_p(el->values, struct ldb_val, el->num_values+1);
+				ldb_realloc_p(ldb, el->values, 
+					      struct ldb_val, el->num_values+1);
 			if (!el->values) {
 				goto failed;
 			}
@@ -550,16 +558,16 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 			el->num_values++;
 		} else {
 			/* its a new attribute */
-			msg->elements = realloc_p(msg->elements, 
-						  struct ldb_message_element, 
-						  msg->num_elements+1);
+			msg->elements = ldb_realloc_p(ldb, msg->elements, 
+						      struct ldb_message_element, 
+						      msg->num_elements+1);
 			if (!msg->elements) {
 				goto failed;
 			}
 			el = &msg->elements[msg->num_elements];
 			el->flags = flags;
-			el->name = strdup(attr);
-			el->values = malloc_p(struct ldb_val);
+			el->name = ldb_strdup(ldb, attr);
+			el->values = ldb_malloc_p(ldb, struct ldb_val);
 			if (!el->values || !el->name) {
 				goto failed;
 			}
@@ -572,7 +580,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data)
 	return ldif;
 
 failed:
-	if (ldif) ldif_read_free(ldif);
+	if (ldif) ldif_read_free(ldb, ldif);
 	return NULL;
 }
 
@@ -591,11 +599,11 @@ static int fgetc_file(void *private_data)
 	return fgetc(state->f);
 }
 
-struct ldb_ldif *ldif_read_file(FILE *f)
+struct ldb_ldif *ldif_read_file(struct ldb_context *ldb, FILE *f)
 {
 	struct ldif_read_file_state state;
 	state.f = f;
-	return ldif_read(fgetc_file, &state);
+	return ldif_read(ldb, fgetc_file, &state);
 }
 
 
@@ -615,11 +623,11 @@ static int fgetc_string(void *private_data)
 	return EOF;
 }
 
-struct ldb_ldif *ldif_read_string(const char *s)
+struct ldb_ldif *ldif_read_string(struct ldb_context *ldb, const char *s)
 {
 	struct ldif_read_string_state state;
 	state.s = s;
-	return ldif_read(fgetc_string, &state);
+	return ldif_read(ldb, fgetc_string, &state);
 }
 
 
@@ -642,9 +650,9 @@ static int fprintf_file(void *private_data, const char *fmt, ...)
 	return ret;
 }
 
-int ldif_write_file(FILE *f, const struct ldb_ldif *ldif)
+int ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *ldif)
 {
 	struct ldif_write_file_state state;
 	state.f = f;
-	return ldif_write(fprintf_file, &state, ldif);
+	return ldif_write(ldb, fprintf_file, &state, ldif);
 }
-- 
cgit 


From 68293565de0b799dcc51e001dabf53adf88ee7ad Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 6 May 2004 09:55:05 +0000
Subject: r513: added a generic ldb debug system to allow the Samba debug
 functions to be cleanly interfaced to ldb (This used to be commit
 74b89d5f960d6b936751e3f057b4540eb80b79cd)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 451276c48d..513e2dd365 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -217,7 +217,8 @@ int ldif_write(struct ldb_context *ldb,
 			}
 		}
 		if (!ldb_changetypes[i].name) {
-			fprintf(stderr,"Invalid changetype\n");
+			ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Invalid ldif changetype %d\n",
+				  ldif->changetype);
 			return -1;
 		}
 		ret = fprintf_fn(private_data, "changetype: %s\n", ldb_changetypes[i].name);
@@ -493,7 +494,8 @@ struct ldb_ldif *ldif_read(struct ldb_context *ldb,
 	
 	/* first line must be a dn */
 	if (ldb_attr_cmp(attr, "dn") != 0) {
-		fprintf(stderr, "First line must be a dn not '%s'\n", attr);
+		ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: First line of ldif must be a dn not '%s'\n", 
+			  attr);
 		goto failed;
 	}
 
@@ -512,8 +514,8 @@ struct ldb_ldif *ldif_read(struct ldb_context *ldb,
 				}
 			}
 			if (!ldb_changetypes[i].name) {
-				fprintf(stderr,"Bad changetype '%s'\n",
-					(char *)value.data);
+				ldb_debug(ldb, LDB_DEBUG_ERROR, 
+					  "Error: Bad ldif changetype '%s'\n",(char *)value.data);
 			}
 			flags = 0;
 			continue;
-- 
cgit 


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

 - added better error reporting in ldbdel

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

 - allow search with "dn" as target attribute
(This used to be commit 36575396234e3d35dbd442c8f1ff54a17ae64e64)
---
 source4/lib/ldb/common/ldb_ldif.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 513e2dd365..c120ee5f4e 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -196,10 +196,10 @@ static const struct {
 /*
   write to ldif, using a caller supplied write method
 */
-int ldif_write(struct ldb_context *ldb,
-	       int (*fprintf_fn)(void *, const char *, ...), 
-	       void *private_data,
-	       const struct ldb_ldif *ldif)
+int ldb_ldif_write(struct ldb_context *ldb,
+		   int (*fprintf_fn)(void *, const char *, ...), 
+		   void *private_data,
+		   const struct ldb_ldif *ldif)
 {
 	int i, j;
 	int total=0, ret;
@@ -407,7 +407,7 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 /*
   free a message from a ldif_read
 */
-void ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif)
+void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif)
 {
 	struct ldb_message *msg = &ldif->msg;
 	int i;
@@ -457,8 +457,8 @@ static int msg_add_empty(struct ldb_context *ldb,
 /*
  read from a LDIF source, creating a ldb_message
 */
-struct ldb_ldif *ldif_read(struct ldb_context *ldb,
-			   int (*fgetc_fn)(void *), void *private_data)
+struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
+			       int (*fgetc_fn)(void *), void *private_data)
 {
 	struct ldb_ldif *ldif;
 	struct ldb_message *msg;
@@ -582,7 +582,7 @@ struct ldb_ldif *ldif_read(struct ldb_context *ldb,
 	return ldif;
 
 failed:
-	if (ldif) ldif_read_free(ldb, ldif);
+	if (ldif) ldb_ldif_read_free(ldb, ldif);
 	return NULL;
 }
 
@@ -601,11 +601,11 @@ static int fgetc_file(void *private_data)
 	return fgetc(state->f);
 }
 
-struct ldb_ldif *ldif_read_file(struct ldb_context *ldb, FILE *f)
+struct ldb_ldif *ldb_ldif_read_file(struct ldb_context *ldb, FILE *f)
 {
 	struct ldif_read_file_state state;
 	state.f = f;
-	return ldif_read(ldb, fgetc_file, &state);
+	return ldb_ldif_read(ldb, fgetc_file, &state);
 }
 
 
@@ -625,11 +625,11 @@ static int fgetc_string(void *private_data)
 	return EOF;
 }
 
-struct ldb_ldif *ldif_read_string(struct ldb_context *ldb, const char *s)
+struct ldb_ldif *ldb_ldif_read_string(struct ldb_context *ldb, const char *s)
 {
 	struct ldif_read_string_state state;
 	state.s = s;
-	return ldif_read(ldb, fgetc_string, &state);
+	return ldb_ldif_read(ldb, fgetc_string, &state);
 }
 
 
@@ -652,9 +652,9 @@ static int fprintf_file(void *private_data, const char *fmt, ...)
 	return ret;
 }
 
-int ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *ldif)
+int ldb_ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *ldif)
 {
 	struct ldif_write_file_state state;
 	state.f = f;
-	return ldif_write(ldb, fprintf_file, &state, ldif);
+	return ldb_ldif_write(ldb, fprintf_file, &state, ldif);
 }
-- 
cgit 


From 45e93c19ef95978f908f5b14962770510634cd3b Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 29 May 2004 08:11:46 +0000
Subject: r943: change samba4 to use 'uint8_t' instead of 'unsigned char'

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index c120ee5f4e..b08c616a05 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -47,7 +47,7 @@ static int base64_decode(char *s)
 {
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i, n;
-	unsigned char *d = (unsigned char *)s;
+	uint8_t *d = (uint8_t *)s;
 	char *p;
 
 	n=i=0;
@@ -90,7 +90,7 @@ char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
 {
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i;
-	const unsigned char *d = (const unsigned char *)buf;
+	const uint8_t *d = (const uint8_t *)buf;
 	int bytes = (len*8 + 5)/6;
 	char *out;
 
@@ -123,7 +123,7 @@ char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
 int ldb_should_b64_encode(const struct ldb_val *val)
 {
 	int i;
-	unsigned char *p = val->data;
+	uint8_t *p = val->data;
 
 	if (val->length == 0 || p[0] == ' ' || p[0] == ':') {
 		return 1;
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index b08c616a05..8c912f76d4 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -122,7 +122,7 @@ char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
 */
 int ldb_should_b64_encode(const struct ldb_val *val)
 {
-	int i;
+	unsigned int i;
 	uint8_t *p = val->data;
 
 	if (val->length == 0 || p[0] == ' ' || p[0] == ':') {
@@ -146,7 +146,7 @@ int ldb_should_b64_encode(const struct ldb_val *val)
 static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *private_data,
 			const char *buf, size_t length, int start_pos)
 {
-	int i;
+	unsigned int i;
 	int total=0, ret;
 
 	for (i=0;i<length;i++) {
@@ -201,7 +201,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 		   void *private_data,
 		   const struct ldb_ldif *ldif)
 {
-	int i, j;
+	unsigned int i, j;
 	int total=0, ret;
 	const struct ldb_message *msg;
 
@@ -410,7 +410,7 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif)
 {
 	struct ldb_message *msg = &ldif->msg;
-	int i;
+	unsigned int i;
 	for (i=0;i<msg->num_elements;i++) {
 		if (msg->elements[i].name) ldb_free(ldb, msg->elements[i].name);
 		if (msg->elements[i].values) ldb_free(ldb, msg->elements[i].values);
-- 
cgit 


From 5e869b4eabaf428b36b5bc158ab4047d25e3eb5b Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 25 Aug 2004 07:15:21 +0000
Subject: r2055: Add PRINTF_ATTRIBUTE to many more parts of the code, and a new
 --enable-developer warning for when they are missing.

Andrew Bartlett
(This used to be commit 8115e44d47bcd65edba08d10117180ae508cdbc1)
---
 source4/lib/ldb/common/ldb_ldif.c | 2 ++
 1 file changed, 2 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 8c912f76d4..c693d211a9 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -640,6 +640,8 @@ struct ldif_write_file_state {
 	FILE *f;
 };
 
+static int fprintf_file(void *private_data, const char *fmt, ...) PRINTF_ATTRIBUTE(2, 3);
+
 static int fprintf_file(void *private_data, const char *fmt, ...)
 {
 	struct ldif_write_file_state *state = private_data;
-- 
cgit 


From 26c6b4c70bd85d8030a96651f2a255a4d48fcda1 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 2 Nov 2004 01:42:45 +0000
Subject: r3449: more include file reduction

the ldb part isn't ideal, I will have to think of a better solution
(This used to be commit 6b1f86aea8427a8e957b1aeb0ec2f507297f07cb)
---
 source4/lib/ldb/common/ldb_ldif.c | 1 +
 1 file changed, 1 insertion(+)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index c693d211a9..01706304d9 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -37,6 +37,7 @@
 */
 
 #include "includes.h"
+#include <ctype.h>
 
 
 /*
-- 
cgit 


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

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

- make ldb_context and ldb_module private to the subsystem

- use ltdb_ prefix for all ldb_tdb functions

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 01706304d9..bd99468182 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -37,6 +37,8 @@
 */
 
 #include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
 #include <ctype.h>
 
 
-- 
cgit 


From 2ed4ff13d509218785d9941dc17219958ab04223 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 30 Nov 2004 02:15:43 +0000
Subject: r4010: fixed parsing of null attributes in the ldb ldif parser (This
 used to be commit b4fd76f78eadd8648ceed508766235e80702aa8f)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index bd99468182..94e15805a6 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -128,7 +128,11 @@ int ldb_should_b64_encode(const struct ldb_val *val)
 	unsigned int i;
 	uint8_t *p = val->data;
 
-	if (val->length == 0 || p[0] == ' ' || p[0] == ':') {
+	if (val->length == 0) {
+		return 0;
+	}
+
+	if (p[0] == ' ' || p[0] == ':') {
 		return 1;
 	}
 
@@ -377,7 +381,7 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 
 	*attr = *s;
 
-	while (isspace(*p)) {
+	while (*p == ' ' || *p == '\t') {
 		p++;
 	}
 
-- 
cgit 


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

- added gcov flags to Makefile.ldb

- expanded ldb test suite to get more coverage
(This used to be commit 0ab98f50a7e0fe15347a99e5c29a6590a87729a0)
---
 source4/lib/ldb/common/ldb_ldif.c | 52 +++++++++++++++++++--------------------
 1 file changed, 25 insertions(+), 27 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 94e15805a6..d20a2a3553 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -97,7 +97,7 @@ char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
 	int bytes = (len*8 + 5)/6;
 	char *out;
 
-	out = ldb_malloc(ldb, bytes+2);
+	out = talloc_array_p(ldb, char, bytes+2);
 	if (!out) return NULL;
 
 	for (i=0;i<bytes;i++) {
@@ -185,7 +185,7 @@ static int base64_encode_f(struct ldb_context *ldb,
 
 	ret = fold_string(fprintf_fn, private_data, b, strlen(b), start_pos);
 
-	ldb_free(ldb, b);
+	talloc_free(b);
 	return ret;
 }
 
@@ -212,7 +212,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 	int total=0, ret;
 	const struct ldb_message *msg;
 
-	msg = &ldif->msg;
+	msg = ldif->msg;
 
 	ret = fprintf_fn(private_data, "dn: %s\n", msg->dn);
 	CHECK_RET;
@@ -305,9 +305,9 @@ static char *next_chunk(struct ldb_context *ldb,
 		if (chunk_size+1 >= alloc_size) {
 			char *c2;
 			alloc_size += 1024;
-			c2 = ldb_realloc_p(ldb, chunk, char, alloc_size);
+			c2 = talloc_realloc_p(ldb, chunk, char, alloc_size);
 			if (!c2) {
-				ldb_free(ldb, chunk);
+				talloc_free(chunk);
 				errno = ENOMEM;
 				return NULL;
 			}
@@ -416,15 +416,7 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 */
 void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif)
 {
-	struct ldb_message *msg = &ldif->msg;
-	unsigned int i;
-	for (i=0;i<msg->num_elements;i++) {
-		if (msg->elements[i].name) ldb_free(ldb, msg->elements[i].name);
-		if (msg->elements[i].values) ldb_free(ldb, msg->elements[i].values);
-	}
-	if (msg->elements) ldb_free(ldb, msg->elements);
-	if (msg->private_data) ldb_free(ldb, msg->private_data);
-	ldb_free(ldb, ldif);
+	talloc_free(ldif);
 }
 
 /*
@@ -435,8 +427,8 @@ static int msg_add_empty(struct ldb_context *ldb,
 {
 	struct ldb_message_element *el2, *el;
 
-	el2 = ldb_realloc_p(ldb, msg->elements, 
-			    struct ldb_message_element, msg->num_elements+1);
+	el2 = talloc_realloc_p(msg, msg->elements, 
+			       struct ldb_message_element, msg->num_elements+1);
 	if (!el2) {
 		errno = ENOMEM;
 		return -1;
@@ -446,7 +438,7 @@ static int msg_add_empty(struct ldb_context *ldb,
 
 	el = &msg->elements[msg->num_elements];
 	
-	el->name = ldb_strdup(ldb, name);
+	el->name = talloc_strdup(msg->elements, name);
 	el->num_values = 0;
 	el->values = NULL;
 	el->flags = flags;
@@ -476,11 +468,17 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 
 	value.data = NULL;
 
-	ldif = ldb_malloc_p(ldb, struct ldb_ldif);
+	ldif = talloc_p(ldb, struct ldb_ldif);
 	if (!ldif) return NULL;
 
+	ldif->msg = talloc_p(ldif, struct ldb_message);
+	if (ldif->msg == NULL) {
+		talloc_free(ldif);
+		return NULL;
+	}
+
 	ldif->changetype = LDB_CHANGETYPE_NONE;
-	msg = &ldif->msg;
+	msg = ldif->msg;
 
 	msg->dn = NULL;
 	msg->elements = NULL;
@@ -558,8 +556,8 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		    flags == el->flags) {
 			/* its a continuation */
 			el->values = 
-				ldb_realloc_p(ldb, el->values, 
-					      struct ldb_val, el->num_values+1);
+				talloc_realloc_p(msg->elements, el->values, 
+						 struct ldb_val, el->num_values+1);
 			if (!el->values) {
 				goto failed;
 			}
@@ -567,16 +565,16 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			el->num_values++;
 		} else {
 			/* its a new attribute */
-			msg->elements = ldb_realloc_p(ldb, msg->elements, 
-						      struct ldb_message_element, 
-						      msg->num_elements+1);
+			msg->elements = talloc_realloc_p(ldif, msg->elements, 
+							 struct ldb_message_element, 
+							 msg->num_elements+1);
 			if (!msg->elements) {
 				goto failed;
 			}
 			el = &msg->elements[msg->num_elements];
 			el->flags = flags;
-			el->name = ldb_strdup(ldb, attr);
-			el->values = ldb_malloc_p(ldb, struct ldb_val);
+			el->name = talloc_strdup(msg->elements, attr);
+			el->values = talloc_p(msg->elements, struct ldb_val);
 			if (!el->values || !el->name) {
 				goto failed;
 			}
@@ -589,7 +587,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	return ldif;
 
 failed:
-	if (ldif) ldb_ldif_read_free(ldb, ldif);
+	talloc_free(ldif);
 	return NULL;
 }
 
-- 
cgit 


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

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

add and modify works correctly but we need a proper testsuite

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index d20a2a3553..546cf461f8 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -97,7 +97,7 @@ char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
 	int bytes = (len*8 + 5)/6;
 	char *out;
 
-	out = talloc_array_p(ldb, char, bytes+2);
+	out = talloc_array(ldb, char, bytes+2);
 	if (!out) return NULL;
 
 	for (i=0;i<bytes;i++) {
@@ -305,7 +305,7 @@ static char *next_chunk(struct ldb_context *ldb,
 		if (chunk_size+1 >= alloc_size) {
 			char *c2;
 			alloc_size += 1024;
-			c2 = talloc_realloc_p(ldb, chunk, char, alloc_size);
+			c2 = talloc_realloc(ldb, chunk, char, alloc_size);
 			if (!c2) {
 				talloc_free(chunk);
 				errno = ENOMEM;
@@ -427,7 +427,7 @@ static int msg_add_empty(struct ldb_context *ldb,
 {
 	struct ldb_message_element *el2, *el;
 
-	el2 = talloc_realloc_p(msg, msg->elements, 
+	el2 = talloc_realloc(msg, msg->elements, 
 			       struct ldb_message_element, msg->num_elements+1);
 	if (!el2) {
 		errno = ENOMEM;
@@ -468,10 +468,10 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 
 	value.data = NULL;
 
-	ldif = talloc_p(ldb, struct ldb_ldif);
+	ldif = talloc(ldb, struct ldb_ldif);
 	if (!ldif) return NULL;
 
-	ldif->msg = talloc_p(ldif, struct ldb_message);
+	ldif->msg = talloc(ldif, struct ldb_message);
 	if (ldif->msg == NULL) {
 		talloc_free(ldif);
 		return NULL;
@@ -556,7 +556,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		    flags == el->flags) {
 			/* its a continuation */
 			el->values = 
-				talloc_realloc_p(msg->elements, el->values, 
+				talloc_realloc(msg->elements, el->values, 
 						 struct ldb_val, el->num_values+1);
 			if (!el->values) {
 				goto failed;
@@ -565,7 +565,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			el->num_values++;
 		} else {
 			/* its a new attribute */
-			msg->elements = talloc_realloc_p(ldif, msg->elements, 
+			msg->elements = talloc_realloc(ldif, msg->elements, 
 							 struct ldb_message_element, 
 							 msg->num_elements+1);
 			if (!msg->elements) {
@@ -574,7 +574,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			el = &msg->elements[msg->num_elements];
 			el->flags = flags;
 			el->name = talloc_strdup(msg->elements, attr);
-			el->values = talloc_p(msg->elements, struct ldb_val);
+			el->values = talloc(msg->elements, struct ldb_val);
 			if (!el->values || !el->name) {
 				goto failed;
 			}
-- 
cgit 


From 814d5a5011038164dd55dd9e593989f69cedef0d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 19 Jun 2005 01:17:29 +0000
Subject: r7739: fixed an off by one bug in the base64 decoder for ldb ldif
 (This used to be commit fe2b77af2352f1964402a4286105916e990dc36f)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 546cf461f8..225fa3f3c9 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -71,6 +71,9 @@ static int base64_decode(char *s)
 		}
 		s++; i++;
 	}
+	if (bit_offset >= 3) {
+		n--;
+	}
 
 	if (*s && !p) {
 		/* the only termination allowed */
-- 
cgit 


From 56cc32800036472ebc29362d65e422c0b410e3fc Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 19 Jun 2005 01:31:27 +0000
Subject: r7740: get rid of our duplicate base64 routines (This used to be
 commit cf17f90a83cf04815544c5408eb56d00546b3e88)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 225fa3f3c9..9492aa3634 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -46,7 +46,7 @@
   this base64 decoder was taken from jitterbug (written by tridge).
   we might need to replace it with a new version
 */
-static int base64_decode(char *s)
+int ldb_base64_decode(char *s)
 {
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i, n;
@@ -92,7 +92,7 @@ static int base64_decode(char *s)
   encode as base64
   caller frees
 */
-char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
+char *ldb_base64_encode(void *mem_ctx, const char *buf, int len)
 {
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i;
@@ -100,7 +100,7 @@ char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len)
 	int bytes = (len*8 + 5)/6;
 	char *out;
 
-	out = talloc_array(ldb, char, bytes+2);
+	out = talloc_array(mem_ctx, char, bytes+2);
 	if (!out) return NULL;
 
 	for (i=0;i<bytes;i++) {
@@ -402,7 +402,7 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 	}
 
 	if (base64_encoded) {
-		int len = base64_decode(value->data);
+		int len = ldb_base64_decode(value->data);
 		if (len == -1) {
 			/* it wasn't valid base64 data */
 			return -1;
-- 
cgit 


From eb0a13025aa6d693c7e9fa213ef04fa58cf60e3e Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 21 Jun 2005 06:35:55 +0000
Subject: r7803: added support in ldb for callers to setup ldif read/write
 functions, so that ldbedit, ldbsearch etc can display nice human readable
 ldif, while storing the data as binary blobs. This will be used for storing
 NDR encoded objectSid and similar attributes, while making the command line
 interface sane (This used to be commit
 37e283089a846fc0608fef3981a3447300e33728)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 9492aa3634..88ef9fae45 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -41,6 +41,44 @@
 #include "ldb/include/ldb_private.h"
 #include <ctype.h>
 
+/*
+  default function for ldif read/write
+*/
+static int ldb_ldif_default(struct ldb_context *ldb, const struct ldb_val *in, 
+			    struct ldb_val *out)
+{
+	*out = *in;
+	return 0;
+}
+
+
+/*
+  return a function for reading an ldif encoded attributes into a ldb_val
+*/
+static ldb_ldif_handler_t ldb_ldif_read_fn(struct ldb_context *ldb, const char *attr)
+{
+	int i;
+	for (i=0;i<ldb->ldif_num_handlers;i++) {
+		if (strcmp(attr, ldb->ldif_handlers[i].attr) == 0) {
+			return ldb->ldif_handlers[i].read_fn;
+		}
+	}
+	return ldb_ldif_default;
+}
+
+/*
+  return a function for writing an ldif encoded attribute from a ldb_val
+*/
+static ldb_ldif_handler_t ldb_ldif_write_fn(struct ldb_context *ldb, const char *attr)
+{
+	int i;
+	for (i=0;i<ldb->ldif_num_handlers;i++) {
+		if (strcmp(attr, ldb->ldif_handlers[i].attr) == 0) {
+			return ldb->ldif_handlers[i].write_fn;
+		}
+	}
+	return ldb_ldif_default;
+}
 
 /*
   this base64 decoder was taken from jitterbug (written by tridge).
@@ -49,9 +87,9 @@
 int ldb_base64_decode(char *s)
 {
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-	int bit_offset, byte_offset, idx, i, n;
+	int bit_offset=0, byte_offset, idx, i, n;
 	uint8_t *d = (uint8_t *)s;
-	char *p;
+	char *p=NULL;
 
 	n=i=0;
 
@@ -254,13 +292,17 @@ int ldb_ldif_write(struct ldb_context *ldb,
 		}
 
 		for (j=0;j<msg->elements[i].num_values;j++) {
-			if (ldb_should_b64_encode(&msg->elements[i].values[j])) {
+			ldb_ldif_handler_t write_fn = ldb_ldif_write_fn(ldb, 
+								      msg->elements[i].name);
+			struct ldb_val v;
+			ret = write_fn(ldb, &msg->elements[i].values[j], &v);
+			CHECK_RET;
+			if (ldb_should_b64_encode(&v)) {
 				ret = fprintf_fn(private_data, "%s:: ", 
 						 msg->elements[i].name);
 				CHECK_RET;
 				ret = base64_encode_f(ldb, fprintf_fn, private_data, 
-						      msg->elements[i].values[j].data, 
-						      msg->elements[i].values[j].length,
+						      v.data, v.length,
 						      strlen(msg->elements[i].name)+3);
 				CHECK_RET;
 				ret = fprintf_fn(private_data, "\n");
@@ -269,13 +311,15 @@ int ldb_ldif_write(struct ldb_context *ldb,
 				ret = fprintf_fn(private_data, "%s: ", msg->elements[i].name);
 				CHECK_RET;
 				ret = fold_string(fprintf_fn, private_data,
-						  msg->elements[i].values[j].data,
-						  msg->elements[i].values[j].length,
+						  v.data, v.length,
 						  strlen(msg->elements[i].name)+2);
 				CHECK_RET;
 				ret = fprintf_fn(private_data, "\n");
 				CHECK_RET;
 			}
+			if (v.data != msg->elements[i].values[j].data) {
+				talloc_free(v.data);
+			}
 		}
 		if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
 			fprintf_fn(private_data, "-\n");
@@ -510,8 +554,9 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	msg->dn = value.data;
 
 	while (next_attr(&s, &attr, &value) == 0) {
+		ldb_ldif_handler_t read_fn;
 		struct ldb_message_element *el;
-		int empty = 0;
+		int ret, empty = 0;
 
 		if (ldb_attr_cmp(attr, "changetype") == 0) {
 			int i;
@@ -555,6 +600,8 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		
 		el = &msg->elements[msg->num_elements-1];
 
+		read_fn = ldb_ldif_read_fn(ldb, attr);
+
 		if (msg->num_elements > 0 && ldb_attr_cmp(attr, el->name) == 0 &&
 		    flags == el->flags) {
 			/* its a continuation */
@@ -564,7 +611,13 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			if (!el->values) {
 				goto failed;
 			}
-			el->values[el->num_values] = value;
+			ret = read_fn(ldb, &value, &el->values[el->num_values]);
+			if (ret != 0) {
+				goto failed;
+			}
+			if (value.data != el->values[el->num_values].data) {
+				talloc_steal(el->values, el->values[el->num_values].data);
+			}
 			el->num_values++;
 		} else {
 			/* its a new attribute */
@@ -582,7 +635,13 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 				goto failed;
 			}
 			el->num_values = 1;
-			el->values[0] = value;
+			ret = read_fn(ldb, &value, &el->values[0]);
+			if (ret != 0) {
+				goto failed;
+			}
+			if (value.data != el->values[0].data) {
+				talloc_steal(el->values, el->values[0].data);
+			}
 			msg->num_elements++;
 		}
 	}
-- 
cgit 


From 5be159f304411b58c417a979c819f9ab211a0337 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 21 Jun 2005 07:52:00 +0000
Subject: r7804: added the samba specific ldif handlers into the tree, but
 don't enable them just yet. I have tested them, and they work fine, but
 enabling them will break code in rpc_server/ and samdb, so we need to fix
 that first (This used to be commit 07d459406b4c63e49141e0e533e1274b4052abf9)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 88ef9fae45..94109ce224 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -41,6 +41,30 @@
 #include "ldb/include/ldb_private.h"
 #include <ctype.h>
 
+
+/*
+  add to the list of ldif handlers for this ldb context
+*/
+int ldb_ldif_add_handlers(struct ldb_context *ldb, 
+			  const struct ldb_ldif_handler *handlers, 
+			  unsigned num_handlers)
+{
+	struct ldb_ldif_handler *h;
+	h = talloc_realloc(ldb, ldb->ldif_handlers,
+			   struct ldb_ldif_handler,
+			   ldb->ldif_num_handlers + num_handlers);
+	if (h == NULL) {
+		ldb_oom(ldb);
+		return -1;
+	}
+	ldb->ldif_handlers = h;
+	memcpy(h + ldb->ldif_num_handlers, 
+	       handlers, sizeof(*h) * num_handlers);
+	ldb->ldif_num_handlers += num_handlers;
+	return 0;
+}
+			  
+
 /*
   default function for ldif read/write
 */
@@ -59,7 +83,7 @@ static ldb_ldif_handler_t ldb_ldif_read_fn(struct ldb_context *ldb, const char *
 {
 	int i;
 	for (i=0;i<ldb->ldif_num_handlers;i++) {
-		if (strcmp(attr, ldb->ldif_handlers[i].attr) == 0) {
+		if (ldb_attr_cmp(attr, ldb->ldif_handlers[i].attr) == 0) {
 			return ldb->ldif_handlers[i].read_fn;
 		}
 	}
@@ -73,7 +97,7 @@ static ldb_ldif_handler_t ldb_ldif_write_fn(struct ldb_context *ldb, const char
 {
 	int i;
 	for (i=0;i<ldb->ldif_num_handlers;i++) {
-		if (strcmp(attr, ldb->ldif_handlers[i].attr) == 0) {
+		if (ldb_attr_cmp(attr, ldb->ldif_handlers[i].attr) == 0) {
 			return ldb->ldif_handlers[i].write_fn;
 		}
 	}
-- 
cgit 


From 064d71c9d494835a8bfb76624e00d8330fc2523a Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Tue, 21 Jun 2005 11:14:54 +0000
Subject: r7805: add support to read binary files into attributes data like
 ldap tools does (This used to be commit
 38a14396262eeb279d67c2f0da06bfa0706a3be4)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 94109ce224..70dd2267b5 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -104,6 +104,62 @@ static ldb_ldif_handler_t ldb_ldif_write_fn(struct ldb_context *ldb, const char
 	return ldb_ldif_default;
 }
 
+/*
+  
+*/
+static int ldb_read_data_file(void *mem_ctx, struct ldb_val *value)
+{
+	struct stat statbuf;
+	char *buf;
+	int count, size, bytes;
+	int ret;
+	int f;
+
+	f = open(value->data, O_RDONLY);
+	if (f == -1) {
+		return -1;
+	}
+
+	if (fstat(f, &statbuf) != 0) {
+		ret = -1;
+		goto done;
+	}
+
+	if (statbuf.st_size == 0) {
+		ret = -1;
+		goto done;
+	}
+
+	value->data = talloc_size(mem_ctx, statbuf.st_size + 1);
+	if (value->data == NULL) {
+		ret = -1;
+		goto done;
+	}
+	value->data[statbuf.st_size] = 0;
+
+	count = 0;
+	size = statbuf.st_size;
+	buf = value->data;
+	while (count < statbuf.st_size) {
+		bytes = read(f, buf, size);
+		if (bytes == -1) {
+			talloc_free(value->data);
+			ret = -1;
+			goto done;
+		}
+		count += bytes;
+		buf += bytes;
+		size -= bytes;
+	}
+
+	value->length = statbuf.st_size;
+	ret = statbuf.st_size;
+
+done:
+	close(f);
+	return ret;
+}
+
 /*
   this base64 decoder was taken from jitterbug (written by tridge).
   we might need to replace it with a new version
@@ -426,10 +482,11 @@ static char *next_chunk(struct ldb_context *ldb,
 
 
 /* simple ldif attribute parser */
-static int next_attr(char **s, const char **attr, struct ldb_val *value)
+static int next_attr(void *mem_ctx, char **s, const char **attr, struct ldb_val *value)
 {
 	char *p;
 	int base64_encoded = 0;
+	int binary_file = 0;
 
 	if (strncmp(*s, "-\n", 2) == 0) {
 		value->length = 0;
@@ -450,6 +507,11 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 		p++;
 	}
 
+	if (*p == '<') {
+		binary_file = 1;
+		p++;
+	}
+
 	*attr = *s;
 
 	while (*p == ' ' || *p == '\t') {
@@ -478,6 +540,14 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value)
 		value->length = len;
 	}
 
+	if (binary_file) {
+		int len = ldb_read_data_file(mem_ctx, value);
+		if (len == -1) {
+			/* an error occured hile trying to retrieve the file */
+			return -1;
+		}
+	}
+
 	return 0;
 }
 
@@ -564,7 +634,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	msg->private_data = chunk;
 	s = chunk;
 
-	if (next_attr(&s, &attr, &value) != 0) {
+	if (next_attr(ldif, &s, &attr, &value) != 0) {
 		goto failed;
 	}
 	
@@ -577,7 +647,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 
 	msg->dn = value.data;
 
-	while (next_attr(&s, &attr, &value) == 0) {
+	while (next_attr(ldif, &s, &attr, &value) == 0) {
 		ldb_ldif_handler_t read_fn;
 		struct ldb_message_element *el;
 		int ret, empty = 0;
-- 
cgit 


From 062e0f83258b6c8d8fa48e42e157331de5ce4686 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 21 Jun 2005 13:18:09 +0000
Subject: r7808: fixed the build of ldb after the binary file support in ldif
 was added (This used to be commit 0a8c722c8017e20635223b2c5dfc58759478312c)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 70dd2267b5..f3bc5c6207 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -40,7 +40,9 @@
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_private.h"
 #include <ctype.h>
-
+#ifdef _SAMBA_BUILD_
+#include "system/filesys.h"
+#endif
 
 /*
   add to the list of ldif handlers for this ldb context
-- 
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_ldif.c | 78 +++++----------------------------------
 1 file changed, 9 insertions(+), 69 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index f3bc5c6207..deeb84b3c0 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -44,68 +44,6 @@
 #include "system/filesys.h"
 #endif
 
-/*
-  add to the list of ldif handlers for this ldb context
-*/
-int ldb_ldif_add_handlers(struct ldb_context *ldb, 
-			  const struct ldb_ldif_handler *handlers, 
-			  unsigned num_handlers)
-{
-	struct ldb_ldif_handler *h;
-	h = talloc_realloc(ldb, ldb->ldif_handlers,
-			   struct ldb_ldif_handler,
-			   ldb->ldif_num_handlers + num_handlers);
-	if (h == NULL) {
-		ldb_oom(ldb);
-		return -1;
-	}
-	ldb->ldif_handlers = h;
-	memcpy(h + ldb->ldif_num_handlers, 
-	       handlers, sizeof(*h) * num_handlers);
-	ldb->ldif_num_handlers += num_handlers;
-	return 0;
-}
-			  
-
-/*
-  default function for ldif read/write
-*/
-static int ldb_ldif_default(struct ldb_context *ldb, const struct ldb_val *in, 
-			    struct ldb_val *out)
-{
-	*out = *in;
-	return 0;
-}
-
-
-/*
-  return a function for reading an ldif encoded attributes into a ldb_val
-*/
-static ldb_ldif_handler_t ldb_ldif_read_fn(struct ldb_context *ldb, const char *attr)
-{
-	int i;
-	for (i=0;i<ldb->ldif_num_handlers;i++) {
-		if (ldb_attr_cmp(attr, ldb->ldif_handlers[i].attr) == 0) {
-			return ldb->ldif_handlers[i].read_fn;
-		}
-	}
-	return ldb_ldif_default;
-}
-
-/*
-  return a function for writing an ldif encoded attribute from a ldb_val
-*/
-static ldb_ldif_handler_t ldb_ldif_write_fn(struct ldb_context *ldb, const char *attr)
-{
-	int i;
-	for (i=0;i<ldb->ldif_num_handlers;i++) {
-		if (ldb_attr_cmp(attr, ldb->ldif_handlers[i].attr) == 0) {
-			return ldb->ldif_handlers[i].write_fn;
-		}
-	}
-	return ldb_ldif_default;
-}
-
 /*
   
 */
@@ -356,6 +294,10 @@ int ldb_ldif_write(struct ldb_context *ldb,
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
+		const struct ldb_attrib_handler *h;
+
+		h = ldb_attrib_handler(ldb, msg->elements[i].name);
+
 		if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
 			switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
 			case LDB_FLAG_MOD_ADD:
@@ -374,10 +316,8 @@ int ldb_ldif_write(struct ldb_context *ldb,
 		}
 
 		for (j=0;j<msg->elements[i].num_values;j++) {
-			ldb_ldif_handler_t write_fn = ldb_ldif_write_fn(ldb, 
-								      msg->elements[i].name);
 			struct ldb_val v;
-			ret = write_fn(ldb, &msg->elements[i].values[j], &v);
+			ret = h->ldif_write_fn(ldb, &msg->elements[i].values[j], &v);
 			CHECK_RET;
 			if (ldb_should_b64_encode(&v)) {
 				ret = fprintf_fn(private_data, "%s:: ", 
@@ -650,7 +590,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	msg->dn = value.data;
 
 	while (next_attr(ldif, &s, &attr, &value) == 0) {
-		ldb_ldif_handler_t read_fn;
+		const struct ldb_attrib_handler *h;		
 		struct ldb_message_element *el;
 		int ret, empty = 0;
 
@@ -696,7 +636,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		
 		el = &msg->elements[msg->num_elements-1];
 
-		read_fn = ldb_ldif_read_fn(ldb, attr);
+		h = ldb_attrib_handler(ldb, attr);
 
 		if (msg->num_elements > 0 && ldb_attr_cmp(attr, el->name) == 0 &&
 		    flags == el->flags) {
@@ -707,7 +647,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			if (!el->values) {
 				goto failed;
 			}
-			ret = read_fn(ldb, &value, &el->values[el->num_values]);
+			ret = h->ldif_read_fn(ldb, &value, &el->values[el->num_values]);
 			if (ret != 0) {
 				goto failed;
 			}
@@ -731,7 +671,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 				goto failed;
 			}
 			el->num_values = 1;
-			ret = read_fn(ldb, &value, &el->values[0]);
+			ret = h->ldif_read_fn(ldb, &value, &el->values[0]);
 			if (ret != 0) {
 				goto failed;
 			}
-- 
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_ldif.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index deeb84b3c0..79ec857cbd 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -317,7 +317,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			struct ldb_val v;
-			ret = h->ldif_write_fn(ldb, &msg->elements[i].values[j], &v);
+			ret = h->ldif_write_fn(ldb, ldb, &msg->elements[i].values[j], &v);
 			CHECK_RET;
 			if (ldb_should_b64_encode(&v)) {
 				ret = fprintf_fn(private_data, "%s:: ", 
@@ -647,7 +647,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			if (!el->values) {
 				goto failed;
 			}
-			ret = h->ldif_read_fn(ldb, &value, &el->values[el->num_values]);
+			ret = h->ldif_read_fn(ldb, ldif, &value, &el->values[el->num_values]);
 			if (ret != 0) {
 				goto failed;
 			}
@@ -671,7 +671,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 				goto failed;
 			}
 			el->num_values = 1;
-			ret = h->ldif_read_fn(ldb, &value, &el->values[0]);
+			ret = h->ldif_read_fn(ldb, ldif, &value, &el->values[0]);
 			if (ret != 0) {
 				goto failed;
 			}
-- 
cgit 


From 7c78ec0e145064696552d750eaaa70f00a0882e8 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 12 Jul 2005 05:56:06 +0000
Subject: r8342: allow ldb_ldif_read_string() to continue in the string, so you
 can read multiple records (This used to be commit
 4b11c00421b5152fd7d4be0be0db983bb310021d)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 79ec857cbd..463bae483b 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -728,11 +728,14 @@ static int fgetc_string(void *private_data)
 	return EOF;
 }
 
-struct ldb_ldif *ldb_ldif_read_string(struct ldb_context *ldb, const char *s)
+struct ldb_ldif *ldb_ldif_read_string(struct ldb_context *ldb, const char **s)
 {
 	struct ldif_read_string_state state;
-	state.s = s;
-	return ldb_ldif_read(ldb, fgetc_string, &state);
+	struct ldb_ldif *ldif;
+	state.s = *s;
+	ldif = ldb_ldif_read(ldb, fgetc_string, &state);
+	*s = state.s;
+	return ldif;
 }
 
 
-- 
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_ldif.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 463bae483b..6359c9a014 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -275,7 +275,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 
 	msg = ldif->msg;
 
-	ret = fprintf_fn(private_data, "dn: %s\n", msg->dn);
+	ret = fprintf_fn(private_data, "dn: %s\n", ldb_dn_linearize(msg->dn, msg->dn));
 	CHECK_RET;
 
 	if (ldif->changetype != LDB_CHANGETYPE_NONE) {
@@ -587,7 +587,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		goto failed;
 	}
 
-	msg->dn = value.data;
+	msg->dn = ldb_dn_explode(msg, value.data);
 
 	while (next_attr(ldif, &s, &attr, &value) == 0) {
 		const struct ldb_attrib_handler *h;		
-- 
cgit 


From 7fd36b79ebaff8821b3786725510b0d428631a0a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 27 Aug 2005 01:42:20 +0000
Subject: r9671: patch from Kai Blin fixing a bug in our base64 encoder (This
 used to be commit efa143cb3b4815fed7b037e05d591eadb828536b)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 6359c9a014..38866d7031 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -155,10 +155,10 @@ char *ldb_base64_encode(void *mem_ctx, const char *buf, int len)
 	const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 	int bit_offset, byte_offset, idx, i;
 	const uint8_t *d = (const uint8_t *)buf;
-	int bytes = (len*8 + 5)/6;
+	int bytes = (len*8 + 5)/6, pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0;
 	char *out;
 
-	out = talloc_array(mem_ctx, char, bytes+2);
+	out = talloc_array(mem_ctx, char, bytes+pad_bytes+1);
 	if (!out) return NULL;
 
 	for (i=0;i<bytes;i++) {
@@ -175,7 +175,8 @@ char *ldb_base64_encode(void *mem_ctx, const char *buf, int len)
 		out[i] = b64[idx];
 	}
 
-	out[i++] = '=';
+	for (;i<bytes+pad_bytes;i++)
+		out[i] = '=';
 	out[i] = 0;
 
 	return out;
-- 
cgit 


From c0293aa7159c8b5c9f1a1b13f64af08e5a55ad6a Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 30 Aug 2005 00:43:26 +0000
Subject: r9771: - Prevent ldb crash when a invalid DN is added - Don't
 silently drop records with empty attributes

tridge/simo: Could you please verify this patch is correct?
(This used to be commit 505c9b1d3d39475da141d3b3c156a7e5ba06790c)
---
 source4/lib/ldb/common/ldb_ldif.c | 6 ++++++
 1 file changed, 6 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 38866d7031..a5768b9796 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -590,6 +590,12 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 
 	msg->dn = ldb_dn_explode(msg, value.data);
 
+	if (msg->dn == NULL) {
+		ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Unable to parse dn '%s'\n", 
+				  value.data);
+		goto failed;
+	}
+
 	while (next_attr(ldif, &s, &attr, &value) == 0) {
 		const struct ldb_attrib_handler *h;		
 		struct ldb_message_element *el;
-- 
cgit 


From bb8f5c93ee3369e112d99d4d3497dc803abdbf76 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 18 Sep 2005 10:46:21 +0000
Subject: r10303: check no attribute is given empty (This used to be commit
 f0ad9495e45ee0d41ef8ca182984599c8e11cabb)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index a5768b9796..b268cca578 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -658,6 +658,11 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			if (ret != 0) {
 				goto failed;
 			}
+			if (value.length == 0) {
+				ldb_debug(ldb, LDB_DEBUG_ERROR,
+					  "Error: Attribute value cannot be empty for attribute '%s'\n", el->name);
+				goto failed;
+			}
 			if (value.data != el->values[el->num_values].data) {
 				talloc_steal(el->values, el->values[el->num_values].data);
 			}
-- 
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_ldif.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index b268cca578..7ba6a00147 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -55,7 +55,7 @@ static int ldb_read_data_file(void *mem_ctx, struct ldb_val *value)
 	int ret;
 	int f;
 
-	f = open(value->data, O_RDONLY);
+	f = open((const char *)value->data, O_RDONLY);
 	if (f == -1) {
 		return -1;
 	}
@@ -79,7 +79,7 @@ static int ldb_read_data_file(void *mem_ctx, struct ldb_val *value)
 
 	count = 0;
 	size = statbuf.st_size;
-	buf = value->data;
+	buf = (char *)value->data;
 	while (count < statbuf.st_size) {
 		bytes = read(f, buf, size);
 		if (bytes == -1) {
@@ -325,7 +325,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 						 msg->elements[i].name);
 				CHECK_RET;
 				ret = base64_encode_f(ldb, fprintf_fn, private_data, 
-						      v.data, v.length,
+						      (char *)v.data, v.length,
 						      strlen(msg->elements[i].name)+3);
 				CHECK_RET;
 				ret = fprintf_fn(private_data, "\n");
@@ -334,7 +334,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 				ret = fprintf_fn(private_data, "%s: ", msg->elements[i].name);
 				CHECK_RET;
 				ret = fold_string(fprintf_fn, private_data,
-						  v.data, v.length,
+						  (char *)v.data, v.length,
 						  strlen(msg->elements[i].name)+2);
 				CHECK_RET;
 				ret = fprintf_fn(private_data, "\n");
@@ -461,7 +461,7 @@ static int next_attr(void *mem_ctx, char **s, const char **attr, struct ldb_val
 		p++;
 	}
 
-	value->data = p;
+	value->data = (uint8_t *)p;
 
 	p = strchr(p, '\n');
 
@@ -475,7 +475,7 @@ static int next_attr(void *mem_ctx, char **s, const char **attr, struct ldb_val
 	}
 
 	if (base64_encoded) {
-		int len = ldb_base64_decode(value->data);
+		int len = ldb_base64_decode((char *)value->data);
 		if (len == -1) {
 			/* it wasn't valid base64 data */
 			return -1;
@@ -588,7 +588,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		goto failed;
 	}
 
-	msg->dn = ldb_dn_explode(msg, value.data);
+	msg->dn = ldb_dn_explode(msg, (char *)value.data);
 
 	if (msg->dn == NULL) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Unable to parse dn '%s'\n", 
-- 
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_ldif.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 7ba6a00147..53dadcc6fe 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -37,12 +37,7 @@
 */
 
 #include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_private.h"
-#include <ctype.h>
-#ifdef _SAMBA_BUILD_
-#include "system/filesys.h"
-#endif
+#include "ldb/include/includes.h"
 
 /*
   
-- 
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_ldif.c | 36 +-----------------------------------
 1 file changed, 1 insertion(+), 35 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 53dadcc6fe..7501e89222 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -498,40 +498,6 @@ void ldb_ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif)
 	talloc_free(ldif);
 }
 
-/*
-  add an empty element
-*/
-static int msg_add_empty(struct ldb_context *ldb,
-			 struct ldb_message *msg, const char *name, unsigned flags)
-{
-	struct ldb_message_element *el2, *el;
-
-	el2 = talloc_realloc(msg, msg->elements, 
-			       struct ldb_message_element, msg->num_elements+1);
-	if (!el2) {
-		errno = ENOMEM;
-		return -1;
-	}
-	
-	msg->elements = el2;
-
-	el = &msg->elements[msg->num_elements];
-	
-	el->name = talloc_strdup(msg->elements, name);
-	el->num_values = 0;
-	el->values = NULL;
-	el->flags = flags;
-
-	if (!el->name) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	msg->num_elements++;
-
-	return 0;
-}
-
 /*
  read from a LDIF source, creating a ldb_message
 */
@@ -630,7 +596,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		}
 
 		if (empty) {
-			if (msg_add_empty(ldb, msg, (char *)value.data, flags) != 0) {
+			if (ldb_msg_add_empty(msg, (char *)value.data, flags) != 0) {
 				goto failed;
 			}
 			continue;
-- 
cgit 


From 014f70008fcfdb631031c48aa9654ad5b42e62f9 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 6 Sep 2006 04:58:06 +0000
Subject: r18130: the move to system/ in libreplace broke some things ...
 should be happier now (This used to be commit
 18542f184f75074e56a9793a9e3b6c6d747bb9e6)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 7501e89222..593a895262 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -38,6 +38,7 @@
 
 #include "includes.h"
 #include "ldb/include/includes.h"
+#include "system/locale.h"
 
 /*
   
-- 
cgit 


From 0e9147029f0ca5b7e7d53235fe4bd81dd4fb1b3d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 14 Sep 2006 18:50:12 +0000
Subject: r18536: fixed the loading of external binary files from ldif into ldb
 (This used to be commit fbe13ed83e2f3508db6d77f4bd65a913ef12ff02)

---
 source4/lib/ldb/common/ldb_ldif.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 593a895262..c5084aaa6c 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -50,8 +50,14 @@ static int ldb_read_data_file(void *mem_ctx, struct ldb_val *value)
 	int count, size, bytes;
 	int ret;
 	int f;
+	const char *fname = (const char *)value->data;
 
-	f = open((const char *)value->data, O_RDONLY);
+	if (strncmp(fname, "file://", 7) != 0) {
+		return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+	}
+	fname += 7;
+
+	f = open(fname, O_RDONLY);
 	if (f == -1) {
 		return -1;
 	}
-- 
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_ldif.c | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index c5084aaa6c..0c31f25cc7 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -72,7 +72,7 @@ static int ldb_read_data_file(void *mem_ctx, struct ldb_val *value)
 		goto done;
 	}
 
-	value->data = talloc_size(mem_ctx, statbuf.st_size + 1);
+	value->data = (uint8_t *)talloc_size(mem_ctx, statbuf.st_size + 1);
 	if (value->data == NULL) {
 		ret = -1;
 		goto done;
@@ -680,7 +680,8 @@ struct ldif_read_file_state {
 
 static int fgetc_file(void *private_data)
 {
-	struct ldif_read_file_state *state = private_data;
+	struct ldif_read_file_state *state =
+		(struct ldif_read_file_state *)private_data;
 	return fgetc(state->f);
 }
 
@@ -701,7 +702,8 @@ struct ldif_read_string_state {
 
 static int fgetc_string(void *private_data)
 {
-	struct ldif_read_string_state *state = private_data;
+	struct ldif_read_string_state *state =
+		(struct ldif_read_string_state *)private_data;
 	if (state->s[0] != 0) {
 		return *state->s++;
 	}
@@ -730,7 +732,8 @@ static int fprintf_file(void *private_data, const char *fmt, ...) PRINTF_ATTRIBU
 
 static int fprintf_file(void *private_data, const char *fmt, ...)
 {
-	struct ldif_write_file_state *state = private_data;
+	struct ldif_write_file_state *state =
+		(struct ldif_write_file_state *)private_data;
 	int ret;
 	va_list ap;
 
-- 
cgit 


From 3cabd0dcae4dfa2af58e0d763e60b2b966cd93b1 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 16 Oct 2006 01:01:37 +0000
Subject: r19305: Potential memleak on the ldb_context if we don't use a temp
 mem context (This used to be commit c989dfbe18a2f700e952f478e258bd626c9eb2f5)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 0c31f25cc7..ed76ceec76 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -232,6 +232,8 @@ static int fold_string(int (*fprintf_fn)(void *, const char *, ...), void *priva
 	return total;
 }
 
+#undef CHECK_RET
+
 /*
   encode as base64 to a file
 */
@@ -264,6 +266,9 @@ static const struct {
 	{NULL, 0}
 };
 
+/* this macro is used to handle the return checking on fprintf_fn() */
+#define CHECK_RET do { if (ret < 0) { talloc_free(mem_ctx); return ret; } total += ret; } while (0)
+
 /*
   write to ldif, using a caller supplied write method
 */
@@ -272,10 +277,13 @@ int ldb_ldif_write(struct ldb_context *ldb,
 		   void *private_data,
 		   const struct ldb_ldif *ldif)
 {
+	TALLOC_CTX *mem_ctx;
 	unsigned int i, j;
 	int total=0, ret;
 	const struct ldb_message *msg;
 
+	mem_ctx = talloc_named_const(NULL, 0, "ldb_ldif_write");
+
 	msg = ldif->msg;
 
 	ret = fprintf_fn(private_data, "dn: %s\n", ldb_dn_linearize(msg->dn, msg->dn));
@@ -290,6 +298,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 		if (!ldb_changetypes[i].name) {
 			ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Invalid ldif changetype %d\n",
 				  ldif->changetype);
+			talloc_free(mem_ctx);
 			return -1;
 		}
 		ret = fprintf_fn(private_data, "changetype: %s\n", ldb_changetypes[i].name);
@@ -320,7 +329,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			struct ldb_val v;
-			ret = h->ldif_write_fn(ldb, ldb, &msg->elements[i].values[j], &v);
+			ret = h->ldif_write_fn(ldb, mem_ctx, &msg->elements[i].values[j], &v);
 			CHECK_RET;
 			if (ldb_should_b64_encode(&v)) {
 				ret = fprintf_fn(private_data, "%s:: ", 
-- 
cgit 


From 888458d434b24ad5669a5b3b148059fe05dfcb75 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 16 Oct 2006 09:28:39 +0000
Subject: r19323: fixed a leak in the ldif parse code (This used to be commit
 06387e1cf2d12a74e15a6cdf19e83a28c75cb5fd)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index ed76ceec76..4992eb01ad 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -550,6 +550,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	if (!chunk) {
 		goto failed;
 	}
+	talloc_steal(ldif, chunk);
 
 	msg->private_data = chunk;
 	s = chunk;
-- 
cgit 


From 7f833458ca0083654e34cbfde1c6c6510cab1826 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 25 Oct 2006 01:42:59 +0000
Subject: r19489: Change ldb_msg_add_value and ldb_msg_add_empty to take a
 foruth argument. This is a pointer to an element pointer. If it is not null
 it will be filled with the pointer of the manipulated element. Will avoid
 double searches on the elements list in some cases. (This used to be commit
 0fa5d4bc225b83e9f63ac6d75bffc4c08eb6b620)

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 4992eb01ad..135ce9eecd 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -613,7 +613,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		}
 
 		if (empty) {
-			if (ldb_msg_add_empty(msg, (char *)value.data, flags) != 0) {
+			if (ldb_msg_add_empty(msg, (char *)value.data, flags, NULL) != 0) {
 				goto failed;
 			}
 			continue;
-- 
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_ldif.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 135ce9eecd..50e9f5e590 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -566,9 +566,9 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		goto failed;
 	}
 
-	msg->dn = ldb_dn_explode(msg, (char *)value.data);
+	msg->dn = ldb_dn_new(msg, ldb, (char *)value.data);
 
-	if (msg->dn == NULL) {
+	if ( ! ldb_dn_validate(msg->dn)) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR, "Error: Unable to parse dn '%s'\n", 
 				  value.data);
 		goto failed;
-- 
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_ldif.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 50e9f5e590..86041a8b78 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -286,7 +286,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 
 	msg = ldif->msg;
 
-	ret = fprintf_fn(private_data, "dn: %s\n", ldb_dn_linearize(msg->dn, msg->dn));
+	ret = fprintf_fn(private_data, "dn: %s\n", ldb_dn_get_linearized(msg->dn));
 	CHECK_RET;
 
 	if (ldif->changetype != LDB_CHANGETYPE_NONE) {
-- 
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_ldif.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 86041a8b78..3b6783f803 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -306,9 +306,9 @@ int ldb_ldif_write(struct ldb_context *ldb,
 	}
 
 	for (i=0;i<msg->num_elements;i++) {
-		const struct ldb_attrib_handler *h;
+		const struct ldb_schema_attribute *a;
 
-		h = ldb_attrib_handler(ldb, msg->elements[i].name);
+		a = ldb_schema_attribute_by_name(ldb, msg->elements[i].name);
 
 		if (ldif->changetype == LDB_CHANGETYPE_MODIFY) {
 			switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
@@ -329,7 +329,7 @@ int ldb_ldif_write(struct ldb_context *ldb,
 
 		for (j=0;j<msg->elements[i].num_values;j++) {
 			struct ldb_val v;
-			ret = h->ldif_write_fn(ldb, mem_ctx, &msg->elements[i].values[j], &v);
+			ret = a->syntax->ldif_write_fn(ldb, mem_ctx, &msg->elements[i].values[j], &v);
 			CHECK_RET;
 			if (ldb_should_b64_encode(&v)) {
 				ret = fprintf_fn(private_data, "%s:: ", 
@@ -575,7 +575,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	}
 
 	while (next_attr(ldif, &s, &attr, &value) == 0) {
-		const struct ldb_attrib_handler *h;		
+		const struct ldb_schema_attribute *a;
 		struct ldb_message_element *el;
 		int ret, empty = 0;
 
@@ -621,7 +621,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 		
 		el = &msg->elements[msg->num_elements-1];
 
-		h = ldb_attrib_handler(ldb, attr);
+		a = ldb_schema_attribute_by_name(ldb, attr);
 
 		if (msg->num_elements > 0 && ldb_attr_cmp(attr, el->name) == 0 &&
 		    flags == el->flags) {
@@ -632,7 +632,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 			if (!el->values) {
 				goto failed;
 			}
-			ret = h->ldif_read_fn(ldb, ldif, &value, &el->values[el->num_values]);
+			ret = a->syntax->ldif_read_fn(ldb, ldif, &value, &el->values[el->num_values]);
 			if (ret != 0) {
 				goto failed;
 			}
@@ -661,7 +661,7 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 				goto failed;
 			}
 			el->num_values = 1;
-			ret = h->ldif_read_fn(ldb, ldif, &value, &el->values[0]);
+			ret = a->syntax->ldif_read_fn(ldb, ldif, &value, &el->values[0]);
 			if (ret != 0) {
 				goto failed;
 			}
-- 
cgit 


From a3c0f3035d338b5bf00ecd436cb0ebfcbdc7345d Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 15 Dec 2006 20:22:17 +0000
Subject: r20189: remove unused struct element

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 3b6783f803..572e677b44 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -544,7 +544,6 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	msg->dn = NULL;
 	msg->elements = NULL;
 	msg->num_elements = 0;
-	msg->private_data = NULL;
 
 	chunk = next_chunk(ldb, fgetc_fn, private_data);
 	if (!chunk) {
@@ -552,7 +551,6 @@ struct ldb_ldif *ldb_ldif_read(struct ldb_context *ldb,
 	}
 	talloc_steal(ldif, chunk);
 
-	msg->private_data = chunk;
 	s = chunk;
 
 	if (next_attr(ldif, &s, &attr, &value) != 0) {
-- 
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_ldif.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 572e677b44..6daeff7a90 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.c
@@ -36,8 +36,7 @@
   see RFC2849 for the LDIF format definition
 */
 
-#include "includes.h"
-#include "ldb/include/includes.h"
+#include "ldb_includes.h"
 #include "system/locale.h"
 
 /*
-- 
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_ldif.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

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

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

diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c
index 65b7edb117..fb93e17c6c 100644
--- a/source4/lib/ldb/common/ldb_ldif.c
+++ b/source4/lib/ldb/common/ldb_ldif.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