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_msg.c | 133 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 133 insertions(+)
 create mode 100644 source4/lib/ldb/common/ldb_msg.c

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
new file mode 100644
index 0000000000..633cc91f2c
--- /dev/null
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -0,0 +1,133 @@
+/* 
+   ldb database library
+
+   Copyright (C) Andrew Tridgell  2004
+
+     ** NOTE! The following LGPL license applies to the ldb
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
+   
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/*
+ *  Name: ldb
+ *
+ *  Component: ldb message component utility functions
+ *
+ *  Description: functions for manipulating ldb_message structures
+ *
+ *  Author: Andrew Tridgell
+ */
+
+#include "includes.h"
+
+
+/*
+  find an element in a message by attribute name
+*/
+struct ldb_message_element *ldb_msg_find_element(const struct ldb_message *msg, 
+						 const char *attr_name)
+{
+	int i;
+	for (i=0;i<msg->num_elements;i++) {
+		if (strcmp(msg->elements[i].name, attr_name) == 0) {
+			return &msg->elements[i];
+		}
+	}
+	return NULL;
+}
+
+
+/*
+  find a value in an element
+*/
+struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el, 
+				 struct ldb_val *val)
+{
+	int i;
+	for (i=0;i<el->num_values;i++) {
+		if (ldb_val_equal(val, &el->values[i])) {
+			return &el->values[i];
+		}
+	}
+	return NULL;
+}
+
+
+/*
+  add an empty element to a message
+*/
+int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
+{
+	struct ldb_message_element *els;
+
+	els = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1);
+	if (!els) {
+		errno = ENOMEM;
+		return -1;
+	}
+
+	els[msg->num_elements].values = NULL;
+	els[msg->num_elements].num_values = 0;
+	els[msg->num_elements].flags = flags;
+	els[msg->num_elements].name = strdup(attr_name);
+	if (!els[msg->num_elements].name) {
+		return -1;
+	}
+
+	msg->elements = els;
+	msg->num_elements++;
+
+	return 0;
+}
+
+/*
+  add an empty element to a message
+*/
+int ldb_msg_add(struct ldb_message *msg, 
+		const struct ldb_message_element *el, 
+		int flags)
+{
+	if (ldb_msg_add_empty(msg, el->name, flags) != 0) {
+		return -1;
+	}
+
+	msg->elements[msg->num_elements-1] = *el;
+	msg->elements[msg->num_elements-1].flags = flags;
+
+	return 0;
+}
+
+/*
+  compare two ldb_message_element structures
+*/
+int ldb_msg_element_compare(struct ldb_message_element *el1, 
+			    struct ldb_message_element *el2)
+{
+	int i;
+
+	if (el1->num_values != el2->num_values) {
+		return el1->num_values - el2->num_values;
+	}
+
+	for (i=0;i<el1->num_values;i++) {
+		if (!ldb_msg_find_val(el2, &el1->values[i])) {
+			return -1;
+		}
+	}
+
+	return 0;
+}
-- 
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_msg.c | 71 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 69 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 633cc91f2c..8eb8a8c5ef 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -43,23 +43,40 @@ struct ldb_message_element *ldb_msg_find_element(const struct ldb_message *msg,
 {
 	int i;
 	for (i=0;i<msg->num_elements;i++) {
-		if (strcmp(msg->elements[i].name, attr_name) == 0) {
+		if (ldb_attr_cmp(msg->elements[i].name, attr_name) == 0) {
 			return &msg->elements[i];
 		}
 	}
 	return NULL;
 }
 
+/*
+  see if two ldb_val structures contain exactly the same data
+  return 1 for a match, 0 for a mis-match
+*/
+int ldb_val_equal_exact(const struct ldb_val *v1, const struct ldb_val *v2)
+{
+	if (v1->length != v2->length) return 0;
+
+	if (v1->length == 0) return 1;
+
+	if (memcmp(v1->data, v2->data, v1->length) == 0) {
+		return 1;
+	}
+
+	return 0;
+}
 
 /*
   find a value in an element
+  assumes case sensitive comparison
 */
 struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el, 
 				 struct ldb_val *val)
 {
 	int i;
 	for (i=0;i<el->num_values;i++) {
-		if (ldb_val_equal(val, &el->values[i])) {
+		if (ldb_val_equal_exact(val, &el->values[i])) {
 			return &el->values[i];
 		}
 	}
@@ -113,6 +130,7 @@ int ldb_msg_add(struct ldb_message *msg,
 
 /*
   compare two ldb_message_element structures
+  assumes case senistive comparison
 */
 int ldb_msg_element_compare(struct ldb_message_element *el1, 
 			    struct ldb_message_element *el2)
@@ -131,3 +149,52 @@ int ldb_msg_element_compare(struct ldb_message_element *el1,
 
 	return 0;
 }
+
+
+/*
+  convenience functions to return common types from a message
+  these return the first value if the attribute is multi-valued
+*/
+int ldb_msg_find_int(const struct ldb_message *msg, 
+		     const char *attr_name,
+		     int default_value)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
+	if (!el || el->num_values == 0) {
+		return default_value;
+	}
+	return strtol(el->values[0].data, NULL, 0);
+}
+
+unsigned int ldb_msg_find_uint(const struct ldb_message *msg, 
+			       const char *attr_name,
+			       int default_value)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
+	if (!el || el->num_values == 0) {
+		return default_value;
+	}
+	return strtoul(el->values[0].data, NULL, 0);
+}
+
+double ldb_msg_find_double(const struct ldb_message *msg, 
+			   const char *attr_name,
+			   double default_value)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
+	if (!el || el->num_values == 0) {
+		return default_value;
+	}
+	return strtod(el->values[0].data, NULL);
+}
+
+const char *ldb_msg_find_string(const struct ldb_message *msg, 
+				const char *attr_name,
+				const char *default_value)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
+	if (!el || el->num_values == 0) {
+		return default_value;
+	}
+	return el->values[0].data;
+}
-- 
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_msg.c | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 8eb8a8c5ef..5976db81b6 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -87,11 +87,13 @@ struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
 /*
   add an empty element to a message
 */
-int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
+int ldb_msg_add_empty(struct ldb_context *ldb,
+		      struct ldb_message *msg, const char *attr_name, int flags)
 {
 	struct ldb_message_element *els;
 
-	els = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1);
+	els = ldb_realloc_p(ldb, msg->elements, 
+			    struct ldb_message_element, msg->num_elements+1);
 	if (!els) {
 		errno = ENOMEM;
 		return -1;
@@ -100,7 +102,7 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 	els[msg->num_elements].values = NULL;
 	els[msg->num_elements].num_values = 0;
 	els[msg->num_elements].flags = flags;
-	els[msg->num_elements].name = strdup(attr_name);
+	els[msg->num_elements].name = ldb_strdup(ldb, attr_name);
 	if (!els[msg->num_elements].name) {
 		return -1;
 	}
@@ -114,11 +116,12 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 /*
   add an empty element to a message
 */
-int ldb_msg_add(struct ldb_message *msg, 
+int ldb_msg_add(struct ldb_context *ldb,
+		struct ldb_message *msg, 
 		const struct ldb_message_element *el, 
 		int flags)
 {
-	if (ldb_msg_add_empty(msg, el->name, flags) != 0) {
+	if (ldb_msg_add_empty(ldb, msg, el->name, flags) != 0) {
 		return -1;
 	}
 
-- 
cgit 


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

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

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

 - added some more ldb_msg_*() utilities
(This used to be commit 62b4ec367d170330d837b0f1fe5cd13205a53b59)
---
 source4/lib/ldb/common/ldb_msg.c | 47 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 5976db81b6..01f32751e1 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -131,6 +131,53 @@ int ldb_msg_add(struct ldb_context *ldb,
 	return 0;
 }
 
+/*
+  add a value to a message
+*/
+int ldb_msg_add_value(struct ldb_context *ldb,
+		      struct ldb_message *msg, 
+		      char *attr_name,
+		      struct ldb_val *val)
+{
+	struct ldb_message_element *el;
+	struct ldb_val *vals;
+
+	el = ldb_msg_find_element(msg, attr_name);
+	if (!el) {
+		ldb_msg_add_empty(ldb, msg, attr_name, 0);
+		el = ldb_msg_find_element(msg, attr_name);
+	}
+	if (!el) {
+		return -1;
+	}
+
+	vals = ldb_realloc_p(ldb, el->values, struct ldb_val, el->num_values+1);
+	if (!vals) {
+		errno = ENOMEM;
+		return -1;
+	}
+	el->values = vals;
+	el->values[el->num_values] = *val;
+	el->num_values++;
+
+	return 0;
+}
+
+
+/*
+  add a string element to a message
+*/
+int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg, 
+		       char *attr_name, char *str)
+{
+	struct ldb_val val;
+
+	val.data = str;
+	val.length = strlen(str);
+
+	return ldb_msg_add_value(ldb, msg, attr_name, &val);
+}
+
 /*
   compare two ldb_message_element structures
   assumes case senistive comparison
-- 
cgit 


From 54a695f7edf7c40a92391aa94ddbbd2db8b11ec3 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 9 May 2004 09:39:47 +0000
Subject: r601: added the server code for all the samr_SetUserInfo and
 samr_QueryUserInfo levels except for the password set levels.

This means that a large part of the RPC-SAMR torture test now runs correctly against Samba4
(This used to be commit ec0a51898f543578e755207d81ed5c1524861c64)
---
 source4/lib/ldb/common/ldb_msg.c | 36 ++++++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 14 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 01f32751e1..59d480a33a 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -136,7 +136,7 @@ int ldb_msg_add(struct ldb_context *ldb,
 */
 int ldb_msg_add_value(struct ldb_context *ldb,
 		      struct ldb_message *msg, 
-		      char *attr_name,
+		      const char *attr_name,
 		      struct ldb_val *val)
 {
 	struct ldb_message_element *el;
@@ -200,51 +200,59 @@ int ldb_msg_element_compare(struct ldb_message_element *el1,
 	return 0;
 }
 
-
 /*
   convenience functions to return common types from a message
   these return the first value if the attribute is multi-valued
 */
+const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, const char *attr_name)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
+	if (!el || el->num_values == 0) {
+		return NULL;
+	}
+	return &el->values[0];
+}
+
 int ldb_msg_find_int(const struct ldb_message *msg, 
 		     const char *attr_name,
 		     int default_value)
 {
-	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
-	if (!el || el->num_values == 0) {
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtol(el->values[0].data, NULL, 0);
+	return strtol(v->data, NULL, 0);
 }
 
 unsigned int ldb_msg_find_uint(const struct ldb_message *msg, 
 			       const char *attr_name,
 			       int default_value)
 {
-	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
-	if (!el || el->num_values == 0) {
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtoul(el->values[0].data, NULL, 0);
+	return strtoul(v->data, NULL, 0);
 }
 
 double ldb_msg_find_double(const struct ldb_message *msg, 
 			   const char *attr_name,
 			   double default_value)
 {
-	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
-	if (!el || el->num_values == 0) {
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtod(el->values[0].data, NULL);
+	return strtod(v->data, NULL);
 }
 
 const char *ldb_msg_find_string(const struct ldb_message *msg, 
 				const char *attr_name,
 				const char *default_value)
 {
-	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
-	if (!el || el->num_values == 0) {
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
 		return default_value;
 	}
-	return el->values[0].data;
+	return v->data;
 }
-- 
cgit 


From 579c13da43d5b40ac6d6c1436399fbc1d8dfd054 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 25 May 2004 13:57:39 +0000
Subject: r873: converted samba4 to use real 64 bit integers instead of
 structures. This was suggested by metze recently.

I checked on the build farm and all the machines we have support 64
bit ints, and support the LL suffix for 64 bit constants. I suspect
some won't support strtoll() and related functions, so we will
probably need replacements for those.
(This used to be commit 9a9244a1c66654c12abe4379661cba83a73c4c21)
---
 source4/lib/ldb/common/ldb_msg.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 59d480a33a..055569b0ee 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -235,6 +235,28 @@ unsigned int ldb_msg_find_uint(const struct ldb_message *msg,
 	return strtoul(v->data, NULL, 0);
 }
 
+int64_t ldb_msg_find_int64(const struct ldb_message *msg, 
+			   const char *attr_name,
+			   int64_t default_value)
+{
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
+		return default_value;
+	}
+	return strtoll(v->data, NULL, 0);
+}
+
+uint64_t ldb_msg_find_uint64(const struct ldb_message *msg, 
+			     const char *attr_name,
+			     uint64_t default_value)
+{
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
+		return default_value;
+	}
+	return strtoull(v->data, NULL, 0);
+}
+
 double ldb_msg_find_double(const struct ldb_message *msg, 
 			   const char *attr_name,
 			   double default_value)
-- 
cgit 


From b553acce4b426e1a2e4fda3a9acbfbf41003154a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 5 Jun 2004 01:30:27 +0000
Subject: r1018: fix a const and unsigned int problem in ldb (This used to be
 commit 3d52ca93731ad67c14ac42f627e3feb1a964b29a)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 055569b0ee..0d5b47f920 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -168,7 +168,7 @@ int ldb_msg_add_value(struct ldb_context *ldb,
   add a string element to a message
 */
 int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg, 
-		       char *attr_name, char *str)
+		       const char *attr_name, char *str)
 {
 	struct ldb_val val;
 
@@ -226,7 +226,7 @@ int ldb_msg_find_int(const struct ldb_message *msg,
 
 unsigned int ldb_msg_find_uint(const struct ldb_message *msg, 
 			       const char *attr_name,
-			       int default_value)
+			       unsigned int default_value)
 {
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
-- 
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_msg.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 0d5b47f920..170a7ae5e4 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -41,7 +41,7 @@
 struct ldb_message_element *ldb_msg_find_element(const struct ldb_message *msg, 
 						 const char *attr_name)
 {
-	int i;
+	unsigned int i;
 	for (i=0;i<msg->num_elements;i++) {
 		if (ldb_attr_cmp(msg->elements[i].name, attr_name) == 0) {
 			return &msg->elements[i];
@@ -74,7 +74,7 @@ int ldb_val_equal_exact(const struct ldb_val *v1, const struct ldb_val *v2)
 struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el, 
 				 struct ldb_val *val)
 {
-	int i;
+	unsigned int i;
 	for (i=0;i<el->num_values;i++) {
 		if (ldb_val_equal_exact(val, &el->values[i])) {
 			return &el->values[i];
@@ -185,7 +185,7 @@ int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg,
 int ldb_msg_element_compare(struct ldb_message_element *el1, 
 			    struct ldb_message_element *el2)
 {
-	int i;
+	unsigned int i;
 
 	if (el1->num_values != el2->num_values) {
 		return el1->num_values - el2->num_values;
-- 
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_msg.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 170a7ae5e4..18859c86dd 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -33,6 +33,8 @@
  */
 
 #include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_private.h"
 
 
 /*
@@ -83,6 +85,31 @@ struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
 	return NULL;
 }
 
+/*
+  duplicate a ldb_val structure
+*/
+struct ldb_val ldb_val_dup(struct ldb_context *ldb,
+			   const struct ldb_val *v)
+{
+	struct ldb_val v2;
+	v2.length = v->length;
+	if (v->length == 0) {
+		v2.data = NULL;
+		return v2;
+	}
+
+	/* the +1 is to cope with buggy C library routines like strndup
+	   that look one byte beyond */
+	v2.data = ldb_malloc(ldb, v->length+1);
+	if (!v2.data) {
+		v2.length = 0;
+		return v2;
+	}
+
+	memcpy(v2.data, v->data, v->length);
+	((char *)v2.data)[v->length] = 0;
+	return v2;
+}
 
 /*
   add an empty element to a message
-- 
cgit 


From 09c1b9cbe5175636bcf4b606edfd0022bd9cfd6b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 31 Dec 2004 03:51:42 +0000
Subject: r4427: - added ldb_msg_*() functions for sorting, comparing and
 copying messages

- added a ldb_msg_canonicalize() function that fixes a record to not have any duplicate
  elements

- changed ldbedit to use ldb_msg_canonicalize(). This fixes a bug when you rename multiple
  elements in a record in one edit
(This used to be commit f006e724400843419c8b6155cbeae1876983855e)
---
 source4/lib/ldb/common/ldb_msg.c | 134 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 134 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 18859c86dd..3865e7afa9 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -227,6 +227,16 @@ int ldb_msg_element_compare(struct ldb_message_element *el1,
 	return 0;
 }
 
+/*
+  compare two ldb_message_element structures
+  comparing by element name
+*/
+int ldb_msg_element_compare_name(struct ldb_message_element *el1, 
+				 struct ldb_message_element *el2)
+{
+	return ldb_attr_cmp(el1->name, el2->name);
+}
+
 /*
   convenience functions to return common types from a message
   these return the first value if the attribute is multi-valued
@@ -305,3 +315,127 @@ const char *ldb_msg_find_string(const struct ldb_message *msg,
 	}
 	return v->data;
 }
+
+
+/*
+  sort the elements of a message by name
+*/
+void ldb_msg_sort_elements(struct ldb_message *msg)
+{
+	qsort(msg->elements, msg->num_elements, sizeof(struct ldb_message_element), 
+	      (comparison_fn_t)ldb_msg_element_compare_name);
+}
+
+
+/*
+  free a message created using ldb_msg_copy
+*/
+void ldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
+{
+	int i, j;
+
+	for (i=0;i<msg->num_elements;i++) {
+		struct ldb_message_element *el = &msg->elements[i];
+		for (j=0;j<el->num_values;j++) {
+			ldb_free(ldb, el->values[j].data);
+		}
+		if (el->values) ldb_free(ldb, el->values);
+		ldb_free(ldb, el->name);
+	}
+	if (msg->elements) ldb_free(ldb, msg->elements);
+	ldb_free(ldb, msg->dn);
+	ldb_free(ldb, msg);
+}
+
+/*
+  copy a message, allocating new memory for all parts
+*/
+struct ldb_message *ldb_msg_copy(struct ldb_context *ldb, 
+				 const struct ldb_message *msg)
+{
+	struct ldb_message *msg2;
+	int i, j;
+
+	msg2 = ldb_malloc_p(ldb, struct ldb_message);
+	if (msg2 == NULL) return NULL;
+
+	msg2->elements = NULL;
+	msg2->num_elements = 0;
+	msg2->private_data = NULL;
+
+	msg2->dn = ldb_strdup(ldb, msg->dn);
+	if (msg2->dn == NULL) goto failed;
+
+	msg2->elements = ldb_malloc_array_p(ldb, struct ldb_message_element, msg->num_elements);
+	if (msg2->elements == NULL) goto failed;
+
+	for (i=0;i<msg->num_elements;i++) {
+		struct ldb_message_element *el1 = &msg->elements[i];
+		struct ldb_message_element *el2 = &msg2->elements[i];
+
+		el2->flags = el1->flags;
+		el2->num_values = 0;
+		el2->values = NULL;
+		el2->name = ldb_strdup(ldb, el1->name);
+		if (el2->name == NULL) goto failed;
+		el2->values = ldb_malloc_array_p(ldb, struct ldb_val, el1->num_values);
+		for (j=0;j<el1->num_values;j++) {
+			el2->values[j] = ldb_val_dup(ldb, &el1->values[j]);
+			if (el2->values[j].data == NULL &&
+			    el1->values[j].length != 0) {
+				goto failed;
+			}
+			el2->num_values++;
+		}
+
+		msg2->num_elements++;
+	}
+
+	return msg2;
+
+failed:
+	ldb_msg_free(ldb, msg2);
+	return NULL;
+}
+
+
+/*
+  canonicalise a message, merging elements of the same name
+*/
+struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb, 
+					 const struct ldb_message *msg)
+{
+	int i;
+	struct ldb_message *msg2;
+
+	msg2 = ldb_msg_copy(ldb, msg);
+	if (msg2 == NULL) return NULL;
+
+	ldb_msg_sort_elements(msg2);
+
+	for (i=1;i<msg2->num_elements;i++) {
+		struct ldb_message_element *el1 = &msg2->elements[i-1];
+		struct ldb_message_element *el2 = &msg2->elements[i];
+		if (ldb_msg_element_compare_name(el1, el2) == 0) {
+			el1->values = ldb_realloc_p(ldb, el1->values, struct ldb_val, 
+						    el1->num_values + el2->num_values);
+			if (el1->values == NULL) {
+				return NULL;
+			}
+			memcpy(el1->values + el1->num_values,
+			       el2->values,
+			       sizeof(struct ldb_val) * el2->num_values);
+			el1->num_values += el2->num_values;
+			ldb_free(ldb, el2->name);
+			ldb_free(ldb, el2->values);
+			if (i+1<msg2->num_elements) {
+				memmove(el2, el2+1, sizeof(struct ldb_message_element) * 
+					(msg2->num_elements - (i+1)));
+			}
+			msg2->num_elements--;
+			i--;
+		}
+	}
+
+	return msg2;
+}
-- 
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_msg.c | 54 +++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 29 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 3865e7afa9..89f8feb3c0 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -36,6 +36,13 @@
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_private.h"
 
+/*
+  create a new ldb_message in a given memory context (NULL for top level)
+*/
+struct ldb_message *ldb_msg_new(void *mem_ctx)
+{
+	return talloc_zero_p(mem_ctx, struct ldb_message);
+}
 
 /*
   find an element in a message by attribute name
@@ -88,7 +95,7 @@ struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
 /*
   duplicate a ldb_val structure
 */
-struct ldb_val ldb_val_dup(struct ldb_context *ldb,
+struct ldb_val ldb_val_dup(TALLOC_CTX *mem_ctx, 
 			   const struct ldb_val *v)
 {
 	struct ldb_val v2;
@@ -100,7 +107,7 @@ struct ldb_val ldb_val_dup(struct ldb_context *ldb,
 
 	/* the +1 is to cope with buggy C library routines like strndup
 	   that look one byte beyond */
-	v2.data = ldb_malloc(ldb, v->length+1);
+	v2.data = talloc_array_p(mem_ctx, char, v->length+1);
 	if (!v2.data) {
 		v2.length = 0;
 		return v2;
@@ -119,8 +126,8 @@ int ldb_msg_add_empty(struct ldb_context *ldb,
 {
 	struct ldb_message_element *els;
 
-	els = ldb_realloc_p(ldb, msg->elements, 
-			    struct ldb_message_element, msg->num_elements+1);
+	els = talloc_realloc_p(msg, msg->elements, 
+			       struct ldb_message_element, msg->num_elements+1);
 	if (!els) {
 		errno = ENOMEM;
 		return -1;
@@ -129,7 +136,7 @@ int ldb_msg_add_empty(struct ldb_context *ldb,
 	els[msg->num_elements].values = NULL;
 	els[msg->num_elements].num_values = 0;
 	els[msg->num_elements].flags = flags;
-	els[msg->num_elements].name = ldb_strdup(ldb, attr_name);
+	els[msg->num_elements].name = talloc_strdup(els, attr_name);
 	if (!els[msg->num_elements].name) {
 		return -1;
 	}
@@ -178,7 +185,7 @@ int ldb_msg_add_value(struct ldb_context *ldb,
 		return -1;
 	}
 
-	vals = ldb_realloc_p(ldb, el->values, struct ldb_val, el->num_values+1);
+	vals = talloc_realloc_p(msg, el->values, struct ldb_val, el->num_values+1);
 	if (!vals) {
 		errno = ENOMEM;
 		return -1;
@@ -332,19 +339,7 @@ void ldb_msg_sort_elements(struct ldb_message *msg)
 */
 void ldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
 {
-	int i, j;
-
-	for (i=0;i<msg->num_elements;i++) {
-		struct ldb_message_element *el = &msg->elements[i];
-		for (j=0;j<el->num_values;j++) {
-			ldb_free(ldb, el->values[j].data);
-		}
-		if (el->values) ldb_free(ldb, el->values);
-		ldb_free(ldb, el->name);
-	}
-	if (msg->elements) ldb_free(ldb, msg->elements);
-	ldb_free(ldb, msg->dn);
-	ldb_free(ldb, msg);
+	talloc_free(msg);
 }
 
 /*
@@ -356,17 +351,17 @@ struct ldb_message *ldb_msg_copy(struct ldb_context *ldb,
 	struct ldb_message *msg2;
 	int i, j;
 
-	msg2 = ldb_malloc_p(ldb, struct ldb_message);
+	msg2 = talloc_p(ldb, struct ldb_message);
 	if (msg2 == NULL) return NULL;
 
 	msg2->elements = NULL;
 	msg2->num_elements = 0;
 	msg2->private_data = NULL;
 
-	msg2->dn = ldb_strdup(ldb, msg->dn);
+	msg2->dn = talloc_strdup(msg2, msg->dn);
 	if (msg2->dn == NULL) goto failed;
 
-	msg2->elements = ldb_malloc_array_p(ldb, struct ldb_message_element, msg->num_elements);
+	msg2->elements = talloc_array_p(msg2, struct ldb_message_element, msg->num_elements);
 	if (msg2->elements == NULL) goto failed;
 
 	for (i=0;i<msg->num_elements;i++) {
@@ -376,15 +371,16 @@ struct ldb_message *ldb_msg_copy(struct ldb_context *ldb,
 		el2->flags = el1->flags;
 		el2->num_values = 0;
 		el2->values = NULL;
-		el2->name = ldb_strdup(ldb, el1->name);
+		el2->name = talloc_strdup(msg2->elements, el1->name);
 		if (el2->name == NULL) goto failed;
-		el2->values = ldb_malloc_array_p(ldb, struct ldb_val, el1->num_values);
+		el2->values = talloc_array_p(msg2->elements, struct ldb_val, el1->num_values);
 		for (j=0;j<el1->num_values;j++) {
 			el2->values[j] = ldb_val_dup(ldb, &el1->values[j]);
 			if (el2->values[j].data == NULL &&
 			    el1->values[j].length != 0) {
 				goto failed;
 			}
+			el2->values[j].data = talloc_steal(el2->values, el2->values[j].data);
 			el2->num_values++;
 		}
 
@@ -394,7 +390,7 @@ struct ldb_message *ldb_msg_copy(struct ldb_context *ldb,
 	return msg2;
 
 failed:
-	ldb_msg_free(ldb, msg2);
+	talloc_free(msg2);
 	return NULL;
 }
 
@@ -417,8 +413,8 @@ struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
 		struct ldb_message_element *el1 = &msg2->elements[i-1];
 		struct ldb_message_element *el2 = &msg2->elements[i];
 		if (ldb_msg_element_compare_name(el1, el2) == 0) {
-			el1->values = ldb_realloc_p(ldb, el1->values, struct ldb_val, 
-						    el1->num_values + el2->num_values);
+			el1->values = talloc_realloc_p(msg2->elements, el1->values, struct ldb_val, 
+						       el1->num_values + el2->num_values);
 			if (el1->values == NULL) {
 				return NULL;
 			}
@@ -426,8 +422,8 @@ struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
 			       el2->values,
 			       sizeof(struct ldb_val) * el2->num_values);
 			el1->num_values += el2->num_values;
-			ldb_free(ldb, el2->name);
-			ldb_free(ldb, el2->values);
+			talloc_free(el2->name);
+			talloc_free(el2->values);
 			if (i+1<msg2->num_elements) {
 				memmove(el2, el2+1, sizeof(struct ldb_message_element) * 
 					(msg2->num_elements - (i+1)));
-- 
cgit 


From cec158231b5618a9a93e478b6b60914305508086 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 11 Jan 2005 13:52:29 +0000
Subject: r4678: Add some const to LDB.

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 89f8feb3c0..416590f462 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -171,7 +171,7 @@ int ldb_msg_add(struct ldb_context *ldb,
 int ldb_msg_add_value(struct ldb_context *ldb,
 		      struct ldb_message *msg, 
 		      const char *attr_name,
-		      struct ldb_val *val)
+		      const struct ldb_val *val)
 {
 	struct ldb_message_element *el;
 	struct ldb_val *vals;
-- 
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_msg.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 416590f462..5ab2088744 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -41,7 +41,7 @@
 */
 struct ldb_message *ldb_msg_new(void *mem_ctx)
 {
-	return talloc_zero_p(mem_ctx, struct ldb_message);
+	return talloc_zero(mem_ctx, struct ldb_message);
 }
 
 /*
@@ -107,7 +107,7 @@ struct ldb_val ldb_val_dup(TALLOC_CTX *mem_ctx,
 
 	/* the +1 is to cope with buggy C library routines like strndup
 	   that look one byte beyond */
-	v2.data = talloc_array_p(mem_ctx, char, v->length+1);
+	v2.data = talloc_array(mem_ctx, char, v->length+1);
 	if (!v2.data) {
 		v2.length = 0;
 		return v2;
@@ -126,7 +126,7 @@ int ldb_msg_add_empty(struct ldb_context *ldb,
 {
 	struct ldb_message_element *els;
 
-	els = talloc_realloc_p(msg, msg->elements, 
+	els = talloc_realloc(msg, msg->elements, 
 			       struct ldb_message_element, msg->num_elements+1);
 	if (!els) {
 		errno = ENOMEM;
@@ -185,7 +185,7 @@ int ldb_msg_add_value(struct ldb_context *ldb,
 		return -1;
 	}
 
-	vals = talloc_realloc_p(msg, el->values, struct ldb_val, el->num_values+1);
+	vals = talloc_realloc(msg, el->values, struct ldb_val, el->num_values+1);
 	if (!vals) {
 		errno = ENOMEM;
 		return -1;
@@ -351,7 +351,7 @@ struct ldb_message *ldb_msg_copy(struct ldb_context *ldb,
 	struct ldb_message *msg2;
 	int i, j;
 
-	msg2 = talloc_p(ldb, struct ldb_message);
+	msg2 = talloc(ldb, struct ldb_message);
 	if (msg2 == NULL) return NULL;
 
 	msg2->elements = NULL;
@@ -361,7 +361,7 @@ struct ldb_message *ldb_msg_copy(struct ldb_context *ldb,
 	msg2->dn = talloc_strdup(msg2, msg->dn);
 	if (msg2->dn == NULL) goto failed;
 
-	msg2->elements = talloc_array_p(msg2, struct ldb_message_element, msg->num_elements);
+	msg2->elements = talloc_array(msg2, struct ldb_message_element, msg->num_elements);
 	if (msg2->elements == NULL) goto failed;
 
 	for (i=0;i<msg->num_elements;i++) {
@@ -373,7 +373,7 @@ struct ldb_message *ldb_msg_copy(struct ldb_context *ldb,
 		el2->values = NULL;
 		el2->name = talloc_strdup(msg2->elements, el1->name);
 		if (el2->name == NULL) goto failed;
-		el2->values = talloc_array_p(msg2->elements, struct ldb_val, el1->num_values);
+		el2->values = talloc_array(msg2->elements, struct ldb_val, el1->num_values);
 		for (j=0;j<el1->num_values;j++) {
 			el2->values[j] = ldb_val_dup(ldb, &el1->values[j]);
 			if (el2->values[j].data == NULL &&
@@ -413,7 +413,7 @@ struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
 		struct ldb_message_element *el1 = &msg2->elements[i-1];
 		struct ldb_message_element *el2 = &msg2->elements[i];
 		if (ldb_msg_element_compare_name(el1, el2) == 0) {
-			el1->values = talloc_realloc_p(msg2->elements, el1->values, struct ldb_val, 
+			el1->values = talloc_realloc(msg2->elements, el1->values, struct ldb_val, 
 						       el1->num_values + el2->num_values);
 			if (el1->values == NULL) {
 				return NULL;
-- 
cgit 


From ea2209e3db4dc1a6d455e01d5339b0b981c361b1 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Sat, 29 Jan 2005 04:04:38 +0000
Subject: r5092: Add a bit more const - moving it further into the LDB layer.

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 5ab2088744..3ef25e566f 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -202,11 +202,11 @@ int ldb_msg_add_value(struct ldb_context *ldb,
   add a string element to a message
 */
 int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg, 
-		       const char *attr_name, char *str)
+		       const char *attr_name, const char *str)
 {
 	struct ldb_val val;
 
-	val.data = str;
+	val.data = discard_const_p(char, str);
 	val.length = strlen(str);
 
 	return ldb_msg_add_value(ldb, msg, attr_name, &val);
-- 
cgit 


From ff4797a9e4b01fe8cc9421e911371677433d070c Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 12 Feb 2005 11:30:33 +0000
Subject: r5357: added ldb_msg_add_fmt(), for creating formatted ldb record
 values (This used to be commit 18fb48204f4c0e22ea7e61575b3f174f30ff035c)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 3ef25e566f..b145565a84 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -212,6 +212,28 @@ int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg,
 	return ldb_msg_add_value(ldb, msg, attr_name, &val);
 }
 
+/*
+  add a printf formatted element to a message
+*/
+int ldb_msg_add_fmt(struct ldb_context *ldb, struct ldb_message *msg, 
+		    const char *attr_name, const char *fmt, ...)
+{
+	struct ldb_val val;
+	va_list ap;
+	char *str;
+
+	va_start(ap, fmt);
+	str = talloc_vasprintf(msg, fmt, ap);
+	va_end(ap);
+
+	if (str == NULL) return -1;
+
+	val.data   = str;
+	val.length = strlen(str);
+
+	return ldb_msg_add_value(ldb, msg, attr_name, &val);
+}
+
 /*
   compare two ldb_message_element structures
   assumes case senistive comparison
-- 
cgit 


From 2f9e1650f9fe5a17a1f8d29f1ae4b04c33a91190 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 5 Mar 2005 21:59:48 +0000
Subject: r5665: the data within el2->values can still be used at this point,
 so don't free (This used to be commit
 12d03f96637b9298e0cbc7ee544ca97fffcab9f8)

---
 source4/lib/ldb/common/ldb_msg.c | 1 -
 1 file changed, 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index b145565a84..4c903cf936 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -445,7 +445,6 @@ struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
 			       sizeof(struct ldb_val) * el2->num_values);
 			el1->num_values += el2->num_values;
 			talloc_free(el2->name);
-			talloc_free(el2->values);
 			if (i+1<msg2->num_elements) {
 				memmove(el2, el2+1, sizeof(struct ldb_message_element) * 
 					(msg2->num_elements - (i+1)));
-- 
cgit 


From 9a9cf9e0753c7cf040feecf670c0986a17c16dce Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 16 May 2005 22:31:45 +0000
Subject: r6833: split out the routine that calculates the diff between two ldb
 messages from ldbedit, so other progs can use it. (This used to be commit
 fa4f33558af3c65ff31424c01db16cb9d427503d)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 4c903cf936..7a6dea049a 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -456,3 +456,58 @@ struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
 
 	return msg2;
 }
+
+
+/*
+  return a ldb_message representing the differences between msg1 and msg2. If you
+  then use this in a ldb_modify() call it can be used to save edits to a message
+*/
+struct ldb_message *ldb_msg_diff(struct ldb_context *ldb, 
+				 struct ldb_message *msg1,
+				 struct ldb_message *msg2)
+{
+	struct ldb_message *mod;
+	struct ldb_message_element *el;
+	unsigned int i;
+
+	mod = ldb_msg_new(ldb);
+
+	mod->dn = msg1->dn;
+	mod->num_elements = 0;
+	mod->elements = NULL;
+
+	msg2 = ldb_msg_canonicalize(ldb, msg2);
+	if (msg2 == NULL) {
+		return NULL;
+	}
+	
+	/* look in msg2 to find elements that need to be added
+	   or modified */
+	for (i=0;i<msg2->num_elements;i++) {
+		el = ldb_msg_find_element(msg1, msg2->elements[i].name);
+
+		if (el && ldb_msg_element_compare(el, &msg2->elements[i]) == 0) {
+			continue;
+		}
+
+		if (ldb_msg_add(ldb, mod, 
+				&msg2->elements[i],
+				el?LDB_FLAG_MOD_REPLACE:LDB_FLAG_MOD_ADD) != 0) {
+			return NULL;
+		}
+	}
+
+	/* look in msg1 to find elements that need to be deleted */
+	for (i=0;i<msg1->num_elements;i++) {
+		el = ldb_msg_find_element(msg2, msg1->elements[i].name);
+		if (!el) {
+			if (ldb_msg_add_empty(ldb, mod, 
+					      msg1->elements[i].name,
+					      LDB_FLAG_MOD_DELETE) != 0) {
+				return NULL;
+			}
+		}
+	}
+
+	return mod;
+}
-- 
cgit 


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

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

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

- moved to C99 structure initialisation in ldb

- switched ldap server to using ldb_search_bytree()
(This used to be commit 96620ab2ee5d440bbbc51c1bc0cad9977770f897)
---
 source4/lib/ldb/common/ldb_msg.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 7a6dea049a..8d921b989b 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -95,8 +95,7 @@ struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el,
 /*
   duplicate a ldb_val structure
 */
-struct ldb_val ldb_val_dup(TALLOC_CTX *mem_ctx, 
-			   const struct ldb_val *v)
+struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v)
 {
 	struct ldb_val v2;
 	v2.length = v->length;
-- 
cgit 


From 93e03bd27215a54d79ca996941468d1c33099ff3 Mon Sep 17 00:00:00 2001
From: Derrell Lipman <derrell@samba.org>
Date: Wed, 15 Jun 2005 02:45:11 +0000
Subject: r7602: fix some compiler warnings (This used to be commit
 ce9966e091d36f66d409ac6f7b5e462c9dc37325)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 8d921b989b..295c74c90d 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -443,7 +443,7 @@ struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
 			       el2->values,
 			       sizeof(struct ldb_val) * el2->num_values);
 			el1->num_values += el2->num_values;
-			talloc_free(el2->name);
+			talloc_free(discard_const_p(char, el2->name));
 			if (i+1<msg2->num_elements) {
 				memmove(el2, el2+1, sizeof(struct ldb_message_element) * 
 					(msg2->num_elements - (i+1)));
-- 
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_msg.c | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 295c74c90d..197c42ddb5 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -344,7 +344,6 @@ const char *ldb_msg_find_string(const struct ldb_message *msg,
 	return v->data;
 }
 
-
 /*
   sort the elements of a message by name
 */
@@ -354,32 +353,23 @@ void ldb_msg_sort_elements(struct ldb_message *msg)
 	      (comparison_fn_t)ldb_msg_element_compare_name);
 }
 
-
-/*
-  free a message created using ldb_msg_copy
-*/
-void ldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
-{
-	talloc_free(msg);
-}
-
 /*
   copy a message, allocating new memory for all parts
 */
-struct ldb_message *ldb_msg_copy(struct ldb_context *ldb, 
+struct ldb_message *ldb_msg_copy(TALLOC_CTX *mem_ctx, 
 				 const struct ldb_message *msg)
 {
 	struct ldb_message *msg2;
 	int i, j;
 
-	msg2 = talloc(ldb, struct ldb_message);
+	msg2 = talloc(mem_ctx, struct ldb_message);
 	if (msg2 == NULL) return NULL;
 
 	msg2->elements = NULL;
 	msg2->num_elements = 0;
 	msg2->private_data = NULL;
 
-	msg2->dn = talloc_strdup(msg2, msg->dn);
+	msg2->dn = ldb_dn_copy(msg2, msg->dn);
 	if (msg2->dn == NULL) goto failed;
 
 	msg2->elements = talloc_array(msg2, struct ldb_message_element, msg->num_elements);
@@ -396,12 +386,11 @@ struct ldb_message *ldb_msg_copy(struct ldb_context *ldb,
 		if (el2->name == NULL) goto failed;
 		el2->values = talloc_array(msg2->elements, struct ldb_val, el1->num_values);
 		for (j=0;j<el1->num_values;j++) {
-			el2->values[j] = ldb_val_dup(ldb, &el1->values[j]);
+			el2->values[j] = ldb_val_dup(el2->values, &el1->values[j]);
 			if (el2->values[j].data == NULL &&
 			    el1->values[j].length != 0) {
 				goto failed;
 			}
-			el2->values[j].data = talloc_steal(el2->values, el2->values[j].data);
 			el2->num_values++;
 		}
 
-- 
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_msg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 197c42ddb5..f65c944eab 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -99,7 +99,7 @@ struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v)
 {
 	struct ldb_val v2;
 	v2.length = v->length;
-	if (v->length == 0) {
+	if (v->data == NULL) {
 		v2.data = NULL;
 		return v2;
 	}
-- 
cgit 


From 46a8d809376cab59c579c654b0de5105727a9585 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 18 Sep 2005 10:47:03 +0000
Subject: r10304: check for basic ldb_message sanity and return appropriate
 LDB_ERR_ value (This used to be commit
 610f5646f0816820ac9342e81d46d139e26cc918)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index f65c944eab..2773237b36 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -34,6 +34,7 @@
 
 #include "includes.h"
 #include "ldb/include/ldb.h"
+#include "ldb/include/ldb_errors.h"
 #include "ldb/include/ldb_private.h"
 
 /*
@@ -499,3 +500,32 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
 
 	return mod;
 }
+
+int ldb_msg_sanity_check(const struct ldb_message *msg)
+{
+	int i, j;
+
+	/* basic check on DN */
+	if (msg->dn == NULL) {
+		/* TODO: return also an error string */
+		return LDB_ERR_INVALID_DN_SYNTAX;
+	}
+	if (msg->dn->comp_num == 0) {
+		/* root dse has empty dn */
+		/* TODO: return also an error string */
+		return LDB_ERR_ENTRY_ALREADY_EXISTS;
+	}
+
+	/* basic syntax checks */
+	for (i = 0; i < msg->num_elements; i++) {
+		for (j = 0; j < msg->elements[i].num_values; j++) {
+			if (msg->elements[i].values[j].length == 0) {
+				/* an attribute cannot be empty */
+				/* TODO: return also an error string */
+				return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+			}
+		}
+	}
+
+	return LDB_ERR_SUCCESS;
+}
-- 
cgit 


From cb9d4c670724d281c5de008ffa43ac30c186d6e7 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Mon, 19 Sep 2005 09:57:39 +0000
Subject: r10312: fix compiler warning

metze
(This used to be commit 3309a0f4d90f01e1f6182b797e2bfe3f8380e59c)
---
 source4/lib/ldb/common/ldb_msg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 2773237b36..1b26d7833b 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -206,7 +206,7 @@ int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg,
 {
 	struct ldb_val val;
 
-	val.data = discard_const_p(char, str);
+	val.data = discard_const_p(uint8_t, str);
 	val.length = strlen(str);
 
 	return ldb_msg_add_value(ldb, msg, attr_name, &val);
-- 
cgit 


From 63b43dd12fb579aaaccedd07aaa630cb1cd7aa88 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 24 Sep 2005 15:42:15 +0000
Subject: r10477: expose transactions outside ldb and change the API once more
 do not autostart transactions on ldb operations if a transaction is already
 in place test transactions on winsdb

all my tests passes so far
tridge please confirm this is ok for you
(This used to be commit c2bb2a36bdbe0ec7519697a9a9ba7526a0defac2)
---
 source4/lib/ldb/common/ldb_msg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 1b26d7833b..c2f40f308a 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -527,5 +527,5 @@ int ldb_msg_sanity_check(const struct ldb_message *msg)
 		}
 	}
 
-	return LDB_ERR_SUCCESS;
+	return LDB_SUCCESS;
 }
-- 
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_msg.c | 111 +++++++++++++++++++++++++++++++--------
 1 file changed, 88 insertions(+), 23 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index c2f40f308a..01941f5728 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -107,7 +107,7 @@ struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v)
 
 	/* the +1 is to cope with buggy C library routines like strndup
 	   that look one byte beyond */
-	v2.data = talloc_array(mem_ctx, char, v->length+1);
+	v2.data = talloc_array(mem_ctx, uint8_t, v->length+1);
 	if (!v2.data) {
 		v2.length = 0;
 		return v2;
@@ -121,13 +121,12 @@ struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v)
 /*
   add an empty element to a message
 */
-int ldb_msg_add_empty(struct ldb_context *ldb,
-		      struct ldb_message *msg, const char *attr_name, int flags)
+int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 {
 	struct ldb_message_element *els;
 
 	els = talloc_realloc(msg, msg->elements, 
-			       struct ldb_message_element, msg->num_elements+1);
+			     struct ldb_message_element, msg->num_elements+1);
 	if (!els) {
 		errno = ENOMEM;
 		return -1;
@@ -150,12 +149,11 @@ int ldb_msg_add_empty(struct ldb_context *ldb,
 /*
   add an empty element to a message
 */
-int ldb_msg_add(struct ldb_context *ldb,
-		struct ldb_message *msg, 
+int ldb_msg_add(struct ldb_message *msg, 
 		const struct ldb_message_element *el, 
 		int flags)
 {
-	if (ldb_msg_add_empty(ldb, msg, el->name, flags) != 0) {
+	if (ldb_msg_add_empty(msg, el->name, flags) != 0) {
 		return -1;
 	}
 
@@ -168,8 +166,7 @@ int ldb_msg_add(struct ldb_context *ldb,
 /*
   add a value to a message
 */
-int ldb_msg_add_value(struct ldb_context *ldb,
-		      struct ldb_message *msg, 
+int ldb_msg_add_value(struct ldb_message *msg, 
 		      const char *attr_name,
 		      const struct ldb_val *val)
 {
@@ -178,7 +175,7 @@ int ldb_msg_add_value(struct ldb_context *ldb,
 
 	el = ldb_msg_find_element(msg, attr_name);
 	if (!el) {
-		ldb_msg_add_empty(ldb, msg, attr_name, 0);
+		ldb_msg_add_empty(msg, attr_name, 0);
 		el = ldb_msg_find_element(msg, attr_name);
 	}
 	if (!el) {
@@ -201,7 +198,7 @@ int ldb_msg_add_value(struct ldb_context *ldb,
 /*
   add a string element to a message
 */
-int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg, 
+int ldb_msg_add_string(struct ldb_message *msg, 
 		       const char *attr_name, const char *str)
 {
 	struct ldb_val val;
@@ -209,13 +206,13 @@ int ldb_msg_add_string(struct ldb_context *ldb, struct ldb_message *msg,
 	val.data = discard_const_p(uint8_t, str);
 	val.length = strlen(str);
 
-	return ldb_msg_add_value(ldb, msg, attr_name, &val);
+	return ldb_msg_add_value(msg, attr_name, &val);
 }
 
 /*
   add a printf formatted element to a message
 */
-int ldb_msg_add_fmt(struct ldb_context *ldb, struct ldb_message *msg, 
+int ldb_msg_add_fmt(struct ldb_message *msg, 
 		    const char *attr_name, const char *fmt, ...)
 {
 	struct ldb_val val;
@@ -228,10 +225,10 @@ int ldb_msg_add_fmt(struct ldb_context *ldb, struct ldb_message *msg,
 
 	if (str == NULL) return -1;
 
-	val.data   = str;
+	val.data   = (uint8_t *)str;
 	val.length = strlen(str);
 
-	return ldb_msg_add_value(ldb, msg, attr_name, &val);
+	return ldb_msg_add_value(msg, attr_name, &val);
 }
 
 /*
@@ -287,7 +284,7 @@ int ldb_msg_find_int(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtol(v->data, NULL, 0);
+	return strtol((const char *)v->data, NULL, 0);
 }
 
 unsigned int ldb_msg_find_uint(const struct ldb_message *msg, 
@@ -298,7 +295,7 @@ unsigned int ldb_msg_find_uint(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtoul(v->data, NULL, 0);
+	return strtoul((const char *)v->data, NULL, 0);
 }
 
 int64_t ldb_msg_find_int64(const struct ldb_message *msg, 
@@ -309,7 +306,7 @@ int64_t ldb_msg_find_int64(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtoll(v->data, NULL, 0);
+	return strtoll((const char *)v->data, NULL, 0);
 }
 
 uint64_t ldb_msg_find_uint64(const struct ldb_message *msg, 
@@ -320,7 +317,7 @@ uint64_t ldb_msg_find_uint64(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtoull(v->data, NULL, 0);
+	return strtoull((const char *)v->data, NULL, 0);
 }
 
 double ldb_msg_find_double(const struct ldb_message *msg, 
@@ -331,7 +328,7 @@ double ldb_msg_find_double(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	return strtod(v->data, NULL);
+	return strtod((const char *)v->data, NULL);
 }
 
 const char *ldb_msg_find_string(const struct ldb_message *msg, 
@@ -342,7 +339,7 @@ const char *ldb_msg_find_string(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	return v->data;
+	return (const char *)v->data;
 }
 
 /*
@@ -479,7 +476,7 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
 			continue;
 		}
 
-		if (ldb_msg_add(ldb, mod, 
+		if (ldb_msg_add(mod, 
 				&msg2->elements[i],
 				el?LDB_FLAG_MOD_REPLACE:LDB_FLAG_MOD_ADD) != 0) {
 			return NULL;
@@ -490,7 +487,7 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
 	for (i=0;i<msg1->num_elements;i++) {
 		el = ldb_msg_find_element(msg2, msg1->elements[i].name);
 		if (!el) {
-			if (ldb_msg_add_empty(ldb, mod, 
+			if (ldb_msg_add_empty(mod, 
 					      msg1->elements[i].name,
 					      LDB_FLAG_MOD_DELETE) != 0) {
 				return NULL;
@@ -529,3 +526,71 @@ int ldb_msg_sanity_check(const struct ldb_message *msg)
 
 	return LDB_SUCCESS;
 }
+
+
+
+
+/*
+  copy an attribute list. This only copies the array, not the elements
+  (ie. the elements are left as the same pointers)
+*/
+const char **ldb_attr_list_copy(TALLOC_CTX *mem_ctx, const char * const *attrs)
+{
+	const char **ret;
+	int i;
+	for (i=0;attrs[i];i++) /* noop */ ;
+	ret = talloc_array(mem_ctx, const char *, i+1);
+	if (ret == NULL) {
+		return NULL;
+	}
+	for (i=0;attrs[i];i++) {
+		ret[i] = attrs[i];
+	}
+	ret[i] = attrs[i];
+	return ret;
+}
+
+
+/*
+  return 1 if an attribute is in a list of attributes, or 0 otherwise
+*/
+int ldb_attr_in_list(const char * const *attrs, const char *attr)
+{
+	int i;
+	for (i=0;attrs[i];i++) {
+		if (ldb_attr_cmp(attrs[i], attr) == 0) {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+
+/*
+  rename the specified attribute in a search result
+*/
+void ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *replace)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
+	if (el != NULL) {
+		el->name = replace;
+	}
+}
+
+
+/*
+  copy the specified attribute in a search result to a new attribute
+*/
+int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *replace)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
+	if (el == NULL) {
+		return 0;
+	}
+	if (ldb_msg_add(msg, el, 0) != 0) {
+		return -1;
+	}
+	ldb_msg_rename_attr(msg, attr, replace);
+	return 0;
+}
+
-- 
cgit 


From 33da2fabe6c3b1e20a955d72e1ebd0e850751df0 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 12 Oct 2005 06:30:47 +0000
Subject: r10914: moved the ldap time string functions into ldb so they can be
 used by the time attribute handling functions (This used to be commit
 93c296d52718e77f8b702e1721b548eaadc56c76)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 01941f5728..2aef7acc42 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -36,6 +36,7 @@
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_errors.h"
 #include "ldb/include/ldb_private.h"
+#include <time.h>
 
 /*
   create a new ldb_message in a given memory context (NULL for top level)
@@ -594,3 +595,45 @@ int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *rep
 	return 0;
 }
 
+
+/*
+  return a LDAP formatted time string
+*/
+char *ldb_timestring(TALLOC_CTX *mem_ctx, time_t t)
+{
+	struct tm *tm = gmtime(&t);
+
+	if (!tm) {
+		return NULL;
+	}
+
+	/* formatted like: 20040408072012.0Z */
+	return talloc_asprintf(mem_ctx, 
+			       "%04u%02u%02u%02u%02u%02u.0Z",
+			       tm->tm_year+1900, tm->tm_mon+1,
+			       tm->tm_mday, tm->tm_hour, tm->tm_min,
+			       tm->tm_sec);
+}
+
+
+/*
+  convert a LDAP time string to a time_t. Return 0 if unable to convert
+*/
+time_t ldb_string_to_time(const char *s)
+{
+	struct tm tm;
+	
+	if (s == NULL) return 0;
+	
+	ZERO_STRUCT(tm);
+	if (sscanf(s, "%04u%02u%02u%02u%02u%02u.0Z", 
+		   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, 
+		   &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
+		return 0;
+	}
+	tm.tm_year -= 1900;
+	tm.tm_mon -= 1;
+	
+	return timegm(&tm);
+}
+
-- 
cgit 


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

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

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

- enabled the UTC time attribute syntaxes in the operational module
(This used to be commit 61e8b010223ac6a0573185008f3719ba29574688)
---
 source4/lib/ldb/common/ldb_msg.c | 71 +++++++++++++++++++++++++---------------
 1 file changed, 44 insertions(+), 27 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 2aef7acc42..1c7ae3920a 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -353,47 +353,64 @@ void ldb_msg_sort_elements(struct ldb_message *msg)
 }
 
 /*
-  copy a message, allocating new memory for all parts
+  shallow copy a message - copying only the elements array so that the caller
+  can safely add new elements without changing the message
 */
-struct ldb_message *ldb_msg_copy(TALLOC_CTX *mem_ctx, 
-				 const struct ldb_message *msg)
+struct ldb_message *ldb_msg_copy_shallow(TALLOC_CTX *mem_ctx, 
+					 const struct ldb_message *msg)
 {
 	struct ldb_message *msg2;
-	int i, j;
+	int i;
 
 	msg2 = talloc(mem_ctx, struct ldb_message);
 	if (msg2 == NULL) return NULL;
 
-	msg2->elements = NULL;
-	msg2->num_elements = 0;
+	*msg2 = *msg;
 	msg2->private_data = NULL;
 
-	msg2->dn = ldb_dn_copy(msg2, msg->dn);
-	if (msg2->dn == NULL) goto failed;
-
-	msg2->elements = talloc_array(msg2, struct ldb_message_element, msg->num_elements);
+	msg2->elements = talloc_array(msg2, struct ldb_message_element, 
+				      msg2->num_elements);
 	if (msg2->elements == NULL) goto failed;
 
-	for (i=0;i<msg->num_elements;i++) {
-		struct ldb_message_element *el1 = &msg->elements[i];
-		struct ldb_message_element *el2 = &msg2->elements[i];
+	for (i=0;i<msg2->num_elements;i++) {
+		msg2->elements[i] = msg->elements[i];
+	}
+
+	return msg2;
 
-		el2->flags = el1->flags;
-		el2->num_values = 0;
-		el2->values = NULL;
-		el2->name = talloc_strdup(msg2->elements, el1->name);
-		if (el2->name == NULL) goto failed;
-		el2->values = talloc_array(msg2->elements, struct ldb_val, el1->num_values);
-		for (j=0;j<el1->num_values;j++) {
-			el2->values[j] = ldb_val_dup(el2->values, &el1->values[j]);
-			if (el2->values[j].data == NULL &&
-			    el1->values[j].length != 0) {
+failed:
+	talloc_free(msg2);
+	return NULL;
+}
+
+
+/*
+  copy a message, allocating new memory for all parts
+*/
+struct ldb_message *ldb_msg_copy(TALLOC_CTX *mem_ctx, 
+				 const struct ldb_message *msg)
+{
+	struct ldb_message *msg2;
+	int i, j;
+
+	msg2 = ldb_msg_copy_shallow(mem_ctx, msg);
+	if (msg2 == NULL) return NULL;
+
+	msg2->dn = ldb_dn_copy(msg2, msg2->dn);
+	if (msg2->dn == NULL) goto failed;
+
+	for (i=0;i<msg2->num_elements;i++) {
+		struct ldb_message_element *el = &msg2->elements[i];
+		struct ldb_val *values = el->values;
+		el->name = talloc_strdup(msg2->elements, el->name);
+		if (el->name == NULL) goto failed;
+		el->values = talloc_array(msg2->elements, struct ldb_val, el->num_values);
+		for (j=0;j<el->num_values;j++) {
+			el->values[j] = ldb_val_dup(el->values, &values[j]);
+			if (el->values[j].data == NULL && values[j].length != 0) {
 				goto failed;
 			}
-			el2->num_values++;
 		}
-
-		msg2->num_elements++;
 	}
 
 	return msg2;
@@ -626,7 +643,7 @@ time_t ldb_string_to_time(const char *s)
 	if (s == NULL) return 0;
 	
 	ZERO_STRUCT(tm);
-	if (sscanf(s, "%04u%02u%02u%02u%02u%02u.0Z", 
+	if (sscanf(s, "%04u%02u%02u%02u%02u%02u", 
 		   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, 
 		   &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
 		return 0;
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 1c7ae3920a..a72a4616fb 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -587,12 +587,17 @@ int ldb_attr_in_list(const char * const *attrs, const char *attr)
 /*
   rename the specified attribute in a search result
 */
-void ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *replace)
+int ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *replace)
 {
 	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
-	if (el != NULL) {
-		el->name = replace;
+	if (el == NULL) {
+		return 0;
+	}
+	el->name = talloc_strdup(msg->elements, replace);
+	if (el->name == NULL) {
+		return -1;
 	}
+	return 0;
 }
 
 
@@ -608,8 +613,7 @@ int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *rep
 	if (ldb_msg_add(msg, el, 0) != 0) {
 		return -1;
 	}
-	ldb_msg_rename_attr(msg, attr, replace);
-	return 0;
+	return ldb_msg_rename_attr(msg, attr, replace);
 }
 
 
-- 
cgit 


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

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

- fixed some more ldb warnings
(This used to be commit e9e4d81b6976549db8a7668572a5da466fbec4a9)
---
 source4/lib/ldb/common/ldb_msg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index a72a4616fb..977f68144b 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -646,7 +646,7 @@ time_t ldb_string_to_time(const char *s)
 	
 	if (s == NULL) return 0;
 	
-	ZERO_STRUCT(tm);
+	memset(&tm, 0, sizeof(tm));
 	if (sscanf(s, "%04u%02u%02u%02u%02u%02u", 
 		   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, 
 		   &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 977f68144b..f4a49e47ce 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -617,6 +617,19 @@ int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *rep
 }
 
 
+/*
+  remove the specified attribute in a search result
+*/
+void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
+	int n = (el - msg->elements);
+	if (n != msg->num_elements-1) {
+		memmove(el, el+1, ((msg->num_elements-1) - n)*sizeof(*el));
+	}
+	msg->num_elements--;
+}
+
 /*
   return a LDAP formatted time string
 */
-- 
cgit 


From 7b090b06bf494bcc9bbd080ec2f8761659d8cc6b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 9 Dec 2005 23:40:14 +0000
Subject: r12157: ldb_dump_results() is useful to call from within gdb, so you
 can see a set of results (This used to be commit
 2be62eb2dde9250f8bfe3a3272851e152a1d6b68)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index f4a49e47ce..269599818c 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -671,3 +671,20 @@ time_t ldb_string_to_time(const char *s)
 	return timegm(&tm);
 }
 
+
+/*
+  dump a set of results to a file. Useful from within gdb
+*/
+void ldb_dump_results(struct ldb_context *ldb, struct ldb_result *result, FILE *f)
+{
+	int i;
+
+	for (i = 0; i < result->count; i++) {
+		struct ldb_ldif ldif;
+		fprintf(f, "# record %d\n", i+1);
+		ldif.changetype = LDB_CHANGETYPE_NONE;
+		ldif.msg = result->msgs[i];
+		ldb_ldif_write_file(ldb, f, &ldif);
+	}
+}
+
-- 
cgit 


From a8eec313549905724a8186a1a4c14480658e2967 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Fri, 6 Jan 2006 21:04:32 +0000
Subject: r12746: An initial version of the kludge_acls module.

This should be replaced with real ACLs, which tridge is working on.
In the meantime, the rules are very simple:

- SYSTEM and Administrators can read all.

- Users and anonymous cannot read passwords, can read everything else

- list of 'password' attributes is hard-coded

Most of the difficult work in this was fighting with the C/js
interface to add a system_session() all, as it still doesn't get on
with me :-)

Andrew Bartlett
(This used to be commit be9d0cae8989429ef47a713d8f0a82f12966fc78)
---
 source4/lib/ldb/common/ldb_msg.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 269599818c..deb32133c1 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -623,11 +623,13 @@ int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *rep
 void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
 {
 	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
-	int n = (el - msg->elements);
-	if (n != msg->num_elements-1) {
-		memmove(el, el+1, ((msg->num_elements-1) - n)*sizeof(*el));
+	if (el) {
+		int n = (el - msg->elements);
+		if (n != msg->num_elements-1) {
+			memmove(el, el+1, ((msg->num_elements-1) - n)*sizeof(*el));
+		}
+		msg->num_elements--;
 	}
-	msg->num_elements--;
 }
 
 /*
-- 
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_msg.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index deb32133c1..513a4de1f8 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -33,10 +33,7 @@
  */
 
 #include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
-#include <time.h>
+#include "ldb/include/includes.h"
 
 /*
   create a new ldb_message in a given memory context (NULL for top level)
-- 
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_msg.c | 5 +++++
 1 file changed, 5 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 513a4de1f8..497d2cb0d5 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -123,6 +123,10 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 {
 	struct ldb_message_element *els;
 
+	if (! ldb_valid_attr_name(attr_name)) {
+		return -1;
+	}
+
 	els = talloc_realloc(msg, msg->elements, 
 			     struct ldb_message_element, msg->num_elements+1);
 	if (!els) {
@@ -135,6 +139,7 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 	els[msg->num_elements].flags = flags;
 	els[msg->num_elements].name = talloc_strdup(els, attr_name);
 	if (!els[msg->num_elements].name) {
+		errno = ENOMEM;
 		return -1;
 	}
 
-- 
cgit 


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

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

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

Andrew Bartlett
(This used to be commit 424df1bb369fddcfd358cf26dd0da9d3851d181e)
---
 source4/lib/ldb/common/ldb_msg.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 497d2cb0d5..8c59518296 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -198,6 +198,24 @@ int ldb_msg_add_value(struct ldb_message *msg,
 }
 
 
+/*
+  add a value to a message, stealing it into the 'right' place
+*/
+int ldb_msg_add_steal_value(struct ldb_message *msg, 
+			    const char *attr_name,
+			    struct ldb_val *val)
+{
+	int ret;
+	ret = ldb_msg_add_value(msg, attr_name, val);
+	if (ret == LDB_SUCCESS) {
+		struct ldb_message_element *el;
+		el = ldb_msg_find_element(msg, attr_name);
+		talloc_steal(el->values, val->data);
+	}
+	return ret;
+}
+
+
 /*
   add a string element to a message
 */
@@ -212,6 +230,20 @@ int ldb_msg_add_string(struct ldb_message *msg,
 	return ldb_msg_add_value(msg, attr_name, &val);
 }
 
+/*
+  add a string element to a message, stealing it into the 'right' place
+*/
+int ldb_msg_add_steal_string(struct ldb_message *msg, 
+			     const char *attr_name, char *str)
+{
+	struct ldb_val val;
+
+	val.data = (uint8_t *)str;
+	val.length = strlen(str);
+
+	return ldb_msg_add_steal_value(msg, attr_name, &val);
+}
+
 /*
   add a printf formatted element to a message
 */
-- 
cgit 


From af03a9b8fbe32d9c7a2bcd1d4cb377b44894d666 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 3 Mar 2006 02:29:48 +0000
Subject: r13803: fixed two errors found with 'make valgrindtest' (This used to
 be commit 4257fd91ceca34dd868a9168efc28b6cb63f0357)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 8c59518296..f76d7e8dd9 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -263,7 +263,7 @@ int ldb_msg_add_fmt(struct ldb_message *msg,
 	val.data   = (uint8_t *)str;
 	val.length = strlen(str);
 
-	return ldb_msg_add_value(msg, attr_name, &val);
+	return ldb_msg_add_steal_value(msg, attr_name, &val);
 }
 
 /*
-- 
cgit 


From aa7a02d45fefad3640f273b1d3bfe535a1e6b88c Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 13 May 2006 21:08:37 +0000
Subject: r15582: Commit some forgotten stuff that have been setting on my
 private tree fro long (This used to be commit
 7c050b541e98cd442a0c9ed0ddadb3e573cd1304)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index f76d7e8dd9..b09f2ce6ed 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -724,3 +724,20 @@ void ldb_dump_results(struct ldb_context *ldb, struct ldb_result *result, FILE *
 	}
 }
 
+int ldb_msg_check_string_attribute(const struct ldb_message *msg, const char *name, const char *value)
+{
+	struct ldb_message_element *el;
+	struct ldb_val val;
+	
+	el = ldb_msg_find_element(msg, name);
+	if (el == NULL)
+		return 0;
+
+	val.data = discard_const(value);
+	val.length = strlen(value) + 1;
+
+	if (ldb_msg_find_val(el, &val))
+		return 1;
+
+	return 0;
+}
-- 
cgit 


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

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index b09f2ce6ed..bae17e7046 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -734,7 +734,7 @@ int ldb_msg_check_string_attribute(const struct ldb_message *msg, const char *na
 		return 0;
 
 	val.data = discard_const(value);
-	val.length = strlen(value) + 1;
+	val.length = strlen(value);
 
 	if (ldb_msg_find_val(el, &val))
 		return 1;
-- 
cgit 


From 44e6f21393ea6f2531c6d1e789a0a01582bc6dca Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 6 Jul 2006 05:08:30 +0000
Subject: r16825: Make ldb_sainity_check() set an error string.  This makes it
 much easier to chase down what modules or application code gets wrong.

Ensure not to leave memory allocated on failure in ldb_search()

Andrew Bartlett
(This used to be commit 0828739951ed879640f8ed6e4700d8ca6b8221b8)
---
 source4/lib/ldb/common/ldb_msg.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index bae17e7046..797d050975 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -550,18 +550,20 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
 	return mod;
 }
 
-int ldb_msg_sanity_check(const struct ldb_message *msg)
+int ldb_msg_sanity_check(struct ldb_context *ldb, 
+			 const struct ldb_message *msg)
 {
 	int i, j;
 
 	/* basic check on DN */
 	if (msg->dn == NULL) {
 		/* TODO: return also an error string */
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "ldb message lacks a DN!"));
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 	if (msg->dn->comp_num == 0) {
 		/* root dse has empty dn */
-		/* TODO: return also an error string */
+		ldb_set_errstring(ldb, talloc_strdup(ldb, "DN on new ldb message is '' (not permitted)!"));
 		return LDB_ERR_ENTRY_ALREADY_EXISTS;
 	}
 
@@ -569,8 +571,13 @@ int ldb_msg_sanity_check(const struct ldb_message *msg)
 	for (i = 0; i < msg->num_elements; i++) {
 		for (j = 0; j < msg->elements[i].num_values; j++) {
 			if (msg->elements[i].values[j].length == 0) {
+				TALLOC_CTX *mem_ctx = talloc_new(ldb);
 				/* an attribute cannot be empty */
 				/* TODO: return also an error string */
+				ldb_set_errstring(ldb, talloc_asprintf(mem_ctx, "Element %s has empty attribute in ldb message (%s)!",
+								       msg->elements[i].name, 
+								       ldb_dn_linearize(mem_ctx, msg->dn)));
+				talloc_free(mem_ctx);
 				return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
 			}
 		}
-- 
cgit 


From 09b861f45ba2354edee85ccc966e3b3ee62e02e0 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Sat, 29 Jul 2006 01:23:50 +0000
Subject: r17301: Add a new function to copy a list of attributes, while adding
 one to the end.

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 797d050975..254775cfbc 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -610,6 +610,28 @@ const char **ldb_attr_list_copy(TALLOC_CTX *mem_ctx, const char * const *attrs)
 }
 
 
+/*
+  copy an attribute list. This only copies the array, not the elements
+  (ie. the elements are left as the same pointers)
+*/
+const char **ldb_attr_list_copy_add(TALLOC_CTX *mem_ctx, const char * const *attrs, const char *new_attr)
+{
+	const char **ret;
+	int i;
+	for (i=0;attrs[i];i++) /* noop */ ;
+	ret = talloc_array(mem_ctx, const char *, i+2);
+	if (ret == NULL) {
+		return NULL;
+	}
+	for (i=0;attrs[i];i++) {
+		ret[i] = attrs[i];
+	}
+	ret[i] = new_attr;
+	ret[i+1] = NULL;
+	return ret;
+}
+
+
 /*
   return 1 if an attribute is in a list of attributes, or 0 otherwise
 */
-- 
cgit 


From 39018ab9022d8bd2cc58a52cf4834c5ce7c5455f Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sat, 12 Aug 2006 15:20:06 +0000
Subject: r17503: Add a useful function to search for a DN (This used to be
 commit 8c6efd7b55e4ad45e1bd10519a1b91285a4e0347)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 254775cfbc..2fe9e39e68 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -377,6 +377,19 @@ const char *ldb_msg_find_string(const struct ldb_message *msg,
 	return (const char *)v->data;
 }
 
+struct ldb_dn *ldb_msg_find_dn(void *mem_ctx,
+				const struct ldb_message *msg,
+				const char *attr_name)
+{
+	const struct ldb_val *v;
+
+	v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
+		return NULL;
+	}
+	return ldb_dn_explode(mem_ctx, (const char *)v->data);
+}
+
 /*
   sort the elements of a message by name
 */
-- 
cgit 


From faed8175063b16df94d5332581baf1af0562bb09 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 13 Aug 2006 07:33:57 +0000
Subject: r17514: Simplify the way to set ldb errors and add another helper
 function to set them. (This used to be commit
 260868bae56194fcb98d55afc22fc66d96a303df)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 2fe9e39e68..b0dc74bdb5 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -571,12 +571,12 @@ int ldb_msg_sanity_check(struct ldb_context *ldb,
 	/* basic check on DN */
 	if (msg->dn == NULL) {
 		/* TODO: return also an error string */
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "ldb message lacks a DN!"));
+		ldb_set_errstring(ldb, "ldb message lacks a DN!");
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
 	if (msg->dn->comp_num == 0) {
 		/* root dse has empty dn */
-		ldb_set_errstring(ldb, talloc_strdup(ldb, "DN on new ldb message is '' (not permitted)!"));
+		ldb_set_errstring(ldb, "DN on new ldb message is '' (not permitted)!");
 		return LDB_ERR_ENTRY_ALREADY_EXISTS;
 	}
 
@@ -587,9 +587,9 @@ int ldb_msg_sanity_check(struct ldb_context *ldb,
 				TALLOC_CTX *mem_ctx = talloc_new(ldb);
 				/* an attribute cannot be empty */
 				/* TODO: return also an error string */
-				ldb_set_errstring(ldb, talloc_asprintf(mem_ctx, "Element %s has empty attribute in ldb message (%s)!",
-								       msg->elements[i].name, 
-								       ldb_dn_linearize(mem_ctx, msg->dn)));
+				ldb_asprintf_errstring(ldb, "Element %s has empty attribute in ldb message (%s)!",
+							    msg->elements[i].name, 
+							    ldb_dn_linearize(mem_ctx, msg->dn));
 				talloc_free(mem_ctx);
 				return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
 			}
-- 
cgit 


From a23b63a8e54db7d0ec98ad95cdca11dd4d039e17 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 13 Aug 2006 08:00:36 +0000
Subject: r17516: Change helper function names to make more clear what they are
 meant to do (This used to be commit ad75cf869550af66119d0293503024d41d834e02)

---
 source4/lib/ldb/common/ldb_msg.c | 42 ++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index b0dc74bdb5..2cbfc2467a 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -311,9 +311,9 @@ const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, const
 	return &el->values[0];
 }
 
-int ldb_msg_find_int(const struct ldb_message *msg, 
-		     const char *attr_name,
-		     int default_value)
+int ldb_msg_find_attr_as_int(const struct ldb_message *msg, 
+			     const char *attr_name,
+			     int default_value)
 {
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
@@ -322,9 +322,9 @@ int ldb_msg_find_int(const struct ldb_message *msg,
 	return strtol((const char *)v->data, NULL, 0);
 }
 
-unsigned int ldb_msg_find_uint(const struct ldb_message *msg, 
-			       const char *attr_name,
-			       unsigned int default_value)
+unsigned int ldb_msg_find_attr_as_uint(const struct ldb_message *msg, 
+				       const char *attr_name,
+				       unsigned int default_value)
 {
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
@@ -333,9 +333,9 @@ unsigned int ldb_msg_find_uint(const struct ldb_message *msg,
 	return strtoul((const char *)v->data, NULL, 0);
 }
 
-int64_t ldb_msg_find_int64(const struct ldb_message *msg, 
-			   const char *attr_name,
-			   int64_t default_value)
+int64_t ldb_msg_find_attr_as_int64(const struct ldb_message *msg, 
+				   const char *attr_name,
+				   int64_t default_value)
 {
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
@@ -344,9 +344,9 @@ int64_t ldb_msg_find_int64(const struct ldb_message *msg,
 	return strtoll((const char *)v->data, NULL, 0);
 }
 
-uint64_t ldb_msg_find_uint64(const struct ldb_message *msg, 
-			     const char *attr_name,
-			     uint64_t default_value)
+uint64_t ldb_msg_find_attr_as_uint64(const struct ldb_message *msg, 
+				     const char *attr_name,
+				     uint64_t default_value)
 {
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
@@ -355,9 +355,9 @@ uint64_t ldb_msg_find_uint64(const struct ldb_message *msg,
 	return strtoull((const char *)v->data, NULL, 0);
 }
 
-double ldb_msg_find_double(const struct ldb_message *msg, 
-			   const char *attr_name,
-			   double default_value)
+double ldb_msg_find_attr_as_double(const struct ldb_message *msg, 
+				   const char *attr_name,
+				   double default_value)
 {
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
@@ -366,9 +366,9 @@ double ldb_msg_find_double(const struct ldb_message *msg,
 	return strtod((const char *)v->data, NULL);
 }
 
-const char *ldb_msg_find_string(const struct ldb_message *msg, 
-				const char *attr_name,
-				const char *default_value)
+const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg, 
+					const char *attr_name,
+					const char *default_value)
 {
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
@@ -377,9 +377,9 @@ const char *ldb_msg_find_string(const struct ldb_message *msg,
 	return (const char *)v->data;
 }
 
-struct ldb_dn *ldb_msg_find_dn(void *mem_ctx,
-				const struct ldb_message *msg,
-				const char *attr_name)
+struct ldb_dn *ldb_msg_find_attr_as_dn(void *mem_ctx,
+				       const struct ldb_message *msg,
+				       const char *attr_name)
 {
 	const struct ldb_val *v;
 
-- 
cgit 


From 7de75a991bda653497a0989de93608310b55894a Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 17 Aug 2006 08:31:19 +0000
Subject: r17580: Add a new tools to convert back from AD-like schema to
 OpenLDAP.

Add attribute syntax mapping to the existing OpenLDAP -> AD tool.

Andrew Bartlett
(This used to be commit ba1c652bae700a82acde166e70035d61c320e233)
---
 source4/lib/ldb/common/ldb_msg.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 2cbfc2467a..d40dcde010 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -366,6 +366,23 @@ double ldb_msg_find_attr_as_double(const struct ldb_message *msg,
 	return strtod((const char *)v->data, NULL);
 }
 
+int ldb_msg_find_attr_as_bool(const struct ldb_message *msg, 
+			      const char *attr_name,
+			      int default_value)
+{
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	if (!v || !v->data) {
+		return default_value;
+	}
+	if (strcasecmp(v->data, "FALSE") == 0) {
+		return 0;
+	}
+	if (strcasecmp(v->data, "TRUE") == 0) {
+		return 1;
+	}
+	return default_value;
+}
+
 const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg, 
 					const char *attr_name,
 					const char *default_value)
-- 
cgit 


From 02515a76137e271d5a42c683bcda6c5a5db3a0db Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 22 Aug 2006 18:51:46 +0000
Subject: r17714: fix compiler warnings

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index d40dcde010..b42c4fe602 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -374,10 +374,10 @@ int ldb_msg_find_attr_as_bool(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	if (strcasecmp(v->data, "FALSE") == 0) {
+	if (strcasecmp((const char *)v->data, "FALSE") == 0) {
 		return 0;
 	}
-	if (strcasecmp(v->data, "TRUE") == 0) {
+	if (strcasecmp((const char *)v->data, "TRUE") == 0) {
 		return 1;
 	}
 	return default_value;
-- 
cgit 


From d0ef5aad1747974608138056132f4c4a515081cd Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 27 Aug 2006 23:32:14 +0000
Subject: r17859: Fix some return values (This used to be commit
 5b4fc48c49bada2711e356c557ba5f45e34396f6)

---
 source4/lib/ldb/common/ldb_msg.c | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index b42c4fe602..52c6b82484 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -124,14 +124,14 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 	struct ldb_message_element *els;
 
 	if (! ldb_valid_attr_name(attr_name)) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	els = talloc_realloc(msg, msg->elements, 
 			     struct ldb_message_element, msg->num_elements+1);
 	if (!els) {
 		errno = ENOMEM;
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	els[msg->num_elements].values = NULL;
@@ -140,13 +140,13 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 	els[msg->num_elements].name = talloc_strdup(els, attr_name);
 	if (!els[msg->num_elements].name) {
 		errno = ENOMEM;
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	msg->elements = els;
 	msg->num_elements++;
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 /*
@@ -157,13 +157,13 @@ int ldb_msg_add(struct ldb_message *msg,
 		int flags)
 {
 	if (ldb_msg_add_empty(msg, el->name, flags) != 0) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	msg->elements[msg->num_elements-1] = *el;
 	msg->elements[msg->num_elements-1].flags = flags;
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 /*
@@ -182,19 +182,19 @@ int ldb_msg_add_value(struct ldb_message *msg,
 		el = ldb_msg_find_element(msg, attr_name);
 	}
 	if (!el) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	vals = talloc_realloc(msg, el->values, struct ldb_val, el->num_values+1);
 	if (!vals) {
 		errno = ENOMEM;
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	el->values = vals;
 	el->values[el->num_values] = *val;
 	el->num_values++;
 
-	return 0;
+	return LDB_SUCCESS;
 }
 
 
@@ -258,7 +258,7 @@ int ldb_msg_add_fmt(struct ldb_message *msg,
 	str = talloc_vasprintf(msg, fmt, ap);
 	va_end(ap);
 
-	if (str == NULL) return -1;
+	if (str == NULL) return LDB_ERR_OPERATIONS_ERROR;
 
 	val.data   = (uint8_t *)str;
 	val.length = strlen(str);
@@ -684,13 +684,13 @@ int ldb_msg_rename_attr(struct ldb_message *msg, const char *attr, const char *r
 {
 	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
 	if (el == NULL) {
-		return 0;
+		return LDB_SUCCESS;
 	}
 	el->name = talloc_strdup(msg->elements, replace);
 	if (el->name == NULL) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	return 0;
+	return LDB_SUCCESS;
 }
 
 
@@ -701,10 +701,10 @@ int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *rep
 {
 	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
 	if (el == NULL) {
-		return 0;
+		return LDB_SUCCESS;
 	}
 	if (ldb_msg_add(msg, el, 0) != 0) {
-		return -1;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	return ldb_msg_rename_attr(msg, attr, replace);
 }
-- 
cgit 


From df83913eb1b154a07f7da85fa9d6903c0a8a08b9 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 25 Sep 2006 02:56:20 +0000
Subject: r18881: remove wrong check and statement. to manipulate rootDSE we
 use ldb_dn_new() as base and that has 0 elements. (This used to be commit
 3e131177dae3536c07632fe09e7ebe877bcd9332)

---
 source4/lib/ldb/common/ldb_msg.c | 5 -----
 1 file changed, 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 52c6b82484..92c537a8fa 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -591,11 +591,6 @@ int ldb_msg_sanity_check(struct ldb_context *ldb,
 		ldb_set_errstring(ldb, "ldb message lacks a DN!");
 		return LDB_ERR_INVALID_DN_SYNTAX;
 	}
-	if (msg->dn->comp_num == 0) {
-		/* root dse has empty dn */
-		ldb_set_errstring(ldb, "DN on new ldb message is '' (not permitted)!");
-		return LDB_ERR_ENTRY_ALREADY_EXISTS;
-	}
 
 	/* basic syntax checks */
 	for (i = 0; i < msg->num_elements; i++) {
-- 
cgit 


From 26ece8f69772a0991a7299cdef8403a9ad1ad48a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 26 Sep 2006 01:21:34 +0000
Subject: r18910: Change ldb_msg_add_string() to not actually add an attribute
 if the string is zero length. This allows callers to not have to worry about
 creating an invalid ldap attribute.

See extensive discussion on samba-technical list :-)
(This used to be commit 7a1db8c2a432b9ab59b29ee1bfce6c8fe8e981a2)
---
 source4/lib/ldb/common/ldb_msg.c | 5 +++++
 1 file changed, 5 insertions(+)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 92c537a8fa..9fbb2cdf3e 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -227,6 +227,11 @@ int ldb_msg_add_string(struct ldb_message *msg,
 	val.data = discard_const_p(uint8_t, str);
 	val.length = strlen(str);
 
+	if (val.length == 0) {
+		/* allow empty strings as non-existant attributes */
+		return LDB_SUCCESS;
+	}
+
 	return ldb_msg_add_value(msg, attr_name, &val);
 }
 
-- 
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_msg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 9fbb2cdf3e..7e001f9180 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -792,7 +792,7 @@ int ldb_msg_check_string_attribute(const struct ldb_message *msg, const char *na
 	if (el == NULL)
 		return 0;
 
-	val.data = discard_const(value);
+	val.data = discard_const_p(uint8_t, value);
 	val.length = strlen(value);
 
 	if (ldb_msg_find_val(el, &val))
-- 
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_msg.c | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 7e001f9180..da8ab4994f 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -119,7 +119,10 @@ struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v)
 /*
   add an empty element to a message
 */
-int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
+int ldb_msg_add_empty(	struct ldb_message *msg,
+			const char *attr_name,
+			int flags,
+			struct ldb_message_element **return_el)
 {
 	struct ldb_message_element *els;
 
@@ -146,6 +149,10 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags)
 	msg->elements = els;
 	msg->num_elements++;
 
+	if (return_el) {
+		*return_el = &els[msg->num_elements-1];
+	}
+
 	return LDB_SUCCESS;
 }
 
@@ -156,7 +163,7 @@ int ldb_msg_add(struct ldb_message *msg,
 		const struct ldb_message_element *el, 
 		int flags)
 {
-	if (ldb_msg_add_empty(msg, el->name, flags) != 0) {
+	if (ldb_msg_add_empty(msg, el->name, flags, NULL) != 0) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
@@ -171,15 +178,15 @@ int ldb_msg_add(struct ldb_message *msg,
 */
 int ldb_msg_add_value(struct ldb_message *msg, 
 		      const char *attr_name,
-		      const struct ldb_val *val)
+		      const struct ldb_val *val,
+		      struct ldb_message_element **return_el)
 {
 	struct ldb_message_element *el;
 	struct ldb_val *vals;
 
 	el = ldb_msg_find_element(msg, attr_name);
 	if (!el) {
-		ldb_msg_add_empty(msg, attr_name, 0);
-		el = ldb_msg_find_element(msg, attr_name);
+		ldb_msg_add_empty(msg, attr_name, 0, &el);
 	}
 	if (!el) {
 		return LDB_ERR_OPERATIONS_ERROR;
@@ -194,6 +201,10 @@ int ldb_msg_add_value(struct ldb_message *msg,
 	el->values[el->num_values] = *val;
 	el->num_values++;
 
+	if (return_el) {
+		*return_el = el;
+	}
+
 	return LDB_SUCCESS;
 }
 
@@ -206,10 +217,10 @@ int ldb_msg_add_steal_value(struct ldb_message *msg,
 			    struct ldb_val *val)
 {
 	int ret;
-	ret = ldb_msg_add_value(msg, attr_name, val);
+	struct ldb_message_element *el;
+
+	ret = ldb_msg_add_value(msg, attr_name, val, &el);
 	if (ret == LDB_SUCCESS) {
-		struct ldb_message_element *el;
-		el = ldb_msg_find_element(msg, attr_name);
 		talloc_steal(el->values, val->data);
 	}
 	return ret;
@@ -232,7 +243,7 @@ int ldb_msg_add_string(struct ldb_message *msg,
 		return LDB_SUCCESS;
 	}
 
-	return ldb_msg_add_value(msg, attr_name, &val);
+	return ldb_msg_add_value(msg, attr_name, &val, NULL);
 }
 
 /*
@@ -576,7 +587,7 @@ struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
 		if (!el) {
 			if (ldb_msg_add_empty(mod, 
 					      msg1->elements[i].name,
-					      LDB_FLAG_MOD_DELETE) != 0) {
+					      LDB_FLAG_MOD_DELETE, NULL) != 0) {
 				return NULL;
 			}
 		}
-- 
cgit 


From cc22f65d7b31518ae11beb4e06aca8c9d91883f1 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Wed, 25 Oct 2006 01:59:07 +0000
Subject: r19490: better to check the return result (This used to be commit
 abdc4edbb8f8b8234bad1be05fa92b3f3bc8876c)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index da8ab4994f..9cb4cf5ed0 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -183,13 +183,14 @@ int ldb_msg_add_value(struct ldb_message *msg,
 {
 	struct ldb_message_element *el;
 	struct ldb_val *vals;
+	int ret;
 
 	el = ldb_msg_find_element(msg, attr_name);
 	if (!el) {
-		ldb_msg_add_empty(msg, attr_name, 0, &el);
-	}
-	if (!el) {
-		return LDB_ERR_OPERATIONS_ERROR;
+		ret = ldb_msg_add_empty(msg, attr_name, 0, &el);
+		if (ret != LDB_SUCCESS) {
+			return ret;
+		}
 	}
 
 	vals = talloc_realloc(msg, el->values, struct ldb_val, el->num_values+1);
-- 
cgit 


From adae413042e15e7228bcc25321913b38ae61358a Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 16 Nov 2006 09:16:17 +0000
Subject: r19731: Modify the ldb_map infrustructure to always map from
 requested attributes to backend (remote) attributes.

We can't do a reverse mapping safely where the remote attribute may be
a source for multiple local attributes.  (We end up with the wrong
attributes returned).

In doing this, I've modified the samba3sam.js test to be more
realistic, and fixed some failures in the handling of primaryGroupID.

I've added a new (private) helper function ldb_msg_remove_element() to
avoid a double lookup of the element name.

I've also re-formatted many of the function headers, to fit into
standard editor widths.

Andrew Bartlett
(This used to be commit 186766e3095e71ba716c69e681592e217a3bc420)
---
 source4/lib/ldb/common/ldb_msg.c | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 9cb4cf5ed0..65d1ecacb7 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -654,7 +654,7 @@ const char **ldb_attr_list_copy(TALLOC_CTX *mem_ctx, const char * const *attrs)
 
 /*
   copy an attribute list. This only copies the array, not the elements
-  (ie. the elements are left as the same pointers)
+  (ie. the elements are left as the same pointers).  The new attribute is added to the list.
 */
 const char **ldb_attr_list_copy_add(TALLOC_CTX *mem_ctx, const char * const *attrs, const char *new_attr)
 {
@@ -737,6 +737,18 @@ void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
 	}
 }
 
+/*
+  remove the specified element in a search result
+*/
+void ldb_msg_remove_element(struct ldb_message *msg, struct ldb_message_element *el)
+{
+	int n = (el - msg->elements);
+	if (n != msg->num_elements-1) {
+		memmove(el, el+1, ((msg->num_elements-1) - n)*sizeof(*el));
+	}
+	msg->num_elements--;
+}
+
 /*
   return a LDAP formatted time string
 */
-- 
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_msg.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 65d1ecacb7..2768786b83 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -126,6 +126,7 @@ int ldb_msg_add_empty(	struct ldb_message *msg,
 {
 	struct ldb_message_element *els;
 
+	/* FIXME: we should probably leave this to the schema module to check */
 	if (! ldb_valid_attr_name(attr_name)) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -411,17 +412,24 @@ const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg,
 	return (const char *)v->data;
 }
 
-struct ldb_dn *ldb_msg_find_attr_as_dn(void *mem_ctx,
+struct ldb_dn *ldb_msg_find_attr_as_dn(struct ldb_context *ldb,
+				       void *mem_ctx,
 				       const struct ldb_message *msg,
 				       const char *attr_name)
 {
+	struct ldb_dn *res_dn;
 	const struct ldb_val *v;
 
 	v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
 		return NULL;
 	}
-	return ldb_dn_explode(mem_ctx, (const char *)v->data);
+	res_dn = ldb_dn_new(mem_ctx, ldb, (const char *)v->data);
+	if ( ! ldb_dn_validate(res_dn)) {
+		talloc_free(res_dn);
+		return NULL;
+	}
+	return res_dn;
 }
 
 /*
-- 
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_msg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 2768786b83..e9ba66aff5 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -626,7 +626,7 @@ int ldb_msg_sanity_check(struct ldb_context *ldb,
 				/* TODO: return also an error string */
 				ldb_asprintf_errstring(ldb, "Element %s has empty attribute in ldb message (%s)!",
 							    msg->elements[i].name, 
-							    ldb_dn_linearize(mem_ctx, msg->dn));
+							    ldb_dn_get_linearized(msg->dn));
 				talloc_free(mem_ctx);
 				return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
 			}
-- 
cgit 


From 8ec78bcbbf38963f69a7f81afee438eb08d55b52 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Sun, 26 Nov 2006 21:49:25 +0000
Subject: r19909: Make this one double as fast (This used to be commit
 67b88e49b896f1d783619b8f96554adaeabe80df)

---
 source4/lib/ldb/common/ldb_msg.c | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index e9ba66aff5..0f7a214023 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -763,17 +763,29 @@ void ldb_msg_remove_element(struct ldb_message *msg, struct ldb_message_element
 char *ldb_timestring(TALLOC_CTX *mem_ctx, time_t t)
 {
 	struct tm *tm = gmtime(&t);
+	char *ts;
+	int r;
 
 	if (!tm) {
 		return NULL;
 	}
 
+	/* we now excatly how long this string will be */
+	ts = talloc_array(mem_ctx, char, 18);
+
 	/* formatted like: 20040408072012.0Z */
-	return talloc_asprintf(mem_ctx, 
-			       "%04u%02u%02u%02u%02u%02u.0Z",
-			       tm->tm_year+1900, tm->tm_mon+1,
-			       tm->tm_mday, tm->tm_hour, tm->tm_min,
-			       tm->tm_sec);
+	r = snprintf(ts, 18,
+			"%04u%02u%02u%02u%02u%02u.0Z",
+			tm->tm_year+1900, tm->tm_mon+1,
+			tm->tm_mday, tm->tm_hour, tm->tm_min,
+			tm->tm_sec);
+
+	if (r != 17) {
+		talloc_free(ts);
+		return NULL;
+	}
+
+	return ts;
 }
 
 
-- 
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_msg.c | 1 -
 1 file changed, 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 0f7a214023..9efd3d4d52 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -455,7 +455,6 @@ struct ldb_message *ldb_msg_copy_shallow(TALLOC_CTX *mem_ctx,
 	if (msg2 == NULL) return NULL;
 
 	*msg2 = *msg;
-	msg2->private_data = NULL;
 
 	msg2->elements = talloc_array(msg2, struct ldb_message_element, 
 				      msg2->num_elements);
-- 
cgit 


From 71bc79caab7f9510151b31846755cc4db7b81ec0 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 2 Jan 2007 10:59:38 +0000
Subject: r20462: add functions to handle UTCTime strings

metze
(This used to be commit 49c7da812c290e23bb65b98a2710fb90c4a0ece2)
---
 source4/lib/ldb/common/ldb_msg.c | 59 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 56 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 9efd3d4d52..bed3647d3a 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -757,7 +757,7 @@ void ldb_msg_remove_element(struct ldb_message *msg, struct ldb_message_element
 }
 
 /*
-  return a LDAP formatted time string
+  return a LDAP formatted GeneralizedTime string
 */
 char *ldb_timestring(TALLOC_CTX *mem_ctx, time_t t)
 {
@@ -787,9 +787,8 @@ char *ldb_timestring(TALLOC_CTX *mem_ctx, time_t t)
 	return ts;
 }
 
-
 /*
-  convert a LDAP time string to a time_t. Return 0 if unable to convert
+  convert a LDAP GeneralizedTime string to a time_t. Return 0 if unable to convert
 */
 time_t ldb_string_to_time(const char *s)
 {
@@ -809,6 +808,60 @@ time_t ldb_string_to_time(const char *s)
 	return timegm(&tm);
 }
 
+/*
+  return a LDAP formatted UTCTime string
+*/
+char *ldb_timestring_utc(TALLOC_CTX *mem_ctx, time_t t)
+{
+	struct tm *tm = gmtime(&t);
+	char *ts;
+	int r;
+
+	if (!tm) {
+		return NULL;
+	}
+
+	/* we now excatly how long this string will be */
+	ts = talloc_array(mem_ctx, char, 14);
+
+	/* formatted like: 20040408072012.0Z => 040408072012Z */
+	r = snprintf(ts, 14,
+			"%02u%02u%02u%02u%02u%02uZ",
+			(tm->tm_year+1900)%100, tm->tm_mon+1,
+			tm->tm_mday, tm->tm_hour, tm->tm_min,
+			tm->tm_sec);
+
+	if (r != 13) {
+		talloc_free(ts);
+		return NULL;
+	}
+
+	return ts;
+}
+
+/*
+  convert a LDAP UTCTime string to a time_t. Return 0 if unable to convert
+*/
+time_t ldb_string_utc_to_time(const char *s)
+{
+	struct tm tm;
+	
+	if (s == NULL) return 0;
+	
+	memset(&tm, 0, sizeof(tm));
+	if (sscanf(s, "%02u%02u%02u%02u%02u%02u", 
+		   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, 
+		   &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
+		return 0;
+	}
+	if (tm.tm_year < 50) {
+		tm.tm_year += 100;
+	}
+	tm.tm_mon -= 1;
+	
+	return timegm(&tm);
+}
+
 
 /*
   dump a set of results to a file. Useful from within gdb
-- 
cgit 


From 7dd80e872dacacf95d16b0460119296275a18ab0 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 13 Jan 2007 15:03:00 +0000
Subject: r20731: we need the complex memmove() handling for removing an
 attribute only in one place

metze
(This used to be commit dfdfdd6cefeac2974a4b3425a49e3dd93ad7e952)
---
 source4/lib/ldb/common/ldb_msg.c | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index bed3647d3a..077446f8ca 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -728,22 +728,6 @@ int ldb_msg_copy_attr(struct ldb_message *msg, const char *attr, const char *rep
 	return ldb_msg_rename_attr(msg, attr, replace);
 }
 
-
-/*
-  remove the specified attribute in a search result
-*/
-void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
-{
-	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
-	if (el) {
-		int n = (el - msg->elements);
-		if (n != msg->num_elements-1) {
-			memmove(el, el+1, ((msg->num_elements-1) - n)*sizeof(*el));
-		}
-		msg->num_elements--;
-	}
-}
-
 /*
   remove the specified element in a search result
 */
@@ -756,6 +740,18 @@ void ldb_msg_remove_element(struct ldb_message *msg, struct ldb_message_element
 	msg->num_elements--;
 }
 
+
+/*
+  remove the specified attribute in a search result
+*/
+void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
+{
+	struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
+	if (el) {
+		ldb_msg_remove_element(msg, el);
+	}
+}
+
 /*
   return a LDAP formatted GeneralizedTime string
 */
-- 
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_msg.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 077446f8ca..1d02fb0f3e 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -32,8 +32,7 @@
  *  Author: Andrew Tridgell
  */
 
-#include "includes.h"
-#include "ldb/include/includes.h"
+#include "ldb_includes.h"
 
 /*
   create a new ldb_message in a given memory context (NULL for top level)
-- 
cgit 


From e9d19477e43b65f91bd152f5249b684dbefa5cc6 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Thu, 21 Jun 2007 10:18:20 +0000
Subject: r23560: - Activate metze's schema modules (from metze's
 schema-loading-13 patch). - samba3sam.js: rework the samba3sam test to not
 use objectCategory,   as it's has special rules (dnsName a simple match) -
 ldap.js: Test the ordering of the objectClass attributes for the baseDN -
 schema_init.c: Load the mayContain and mustContain (and system...) attributes
 when   reading the schema from ldb - To make the schema load not suck in
 terms of performance, write the   schema into a static global variable -
 ldif_handlers.c: Match objectCategory for equality and canonicolisation  
 based on the loaded schema, not simple tring manipuation - ldb_msg.c: don't
 duplicate attributes when adding attributes to a list - kludge_acl.c: return
 allowedAttributesEffective based on schema results   and privilages

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 1d02fb0f3e..d0dd252e47 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -666,7 +666,15 @@ const char **ldb_attr_list_copy_add(TALLOC_CTX *mem_ctx, const char * const *att
 {
 	const char **ret;
 	int i;
-	for (i=0;attrs[i];i++) /* noop */ ;
+	bool found = false;
+	for (i=0;attrs[i];i++) {
+		if (ldb_attr_cmp(attrs[i], new_attr) == 0) {
+			found = true;
+		}
+	}
+	if (found) {
+		return ldb_attr_list_copy(mem_ctx, attrs);
+	}
 	ret = talloc_array(mem_ctx, const char *, i+2);
 	if (ret == NULL) {
 		return NULL;
@@ -686,7 +694,7 @@ const char **ldb_attr_list_copy_add(TALLOC_CTX *mem_ctx, const char * const *att
 int ldb_attr_in_list(const char * const *attrs, const char *attr)
 {
 	int i;
-	for (i=0;attrs[i];i++) {
+	for (i=0;attrs && attrs[i];i++) {
 		if (ldb_attr_cmp(attrs[i], attr) == 0) {
 			return 1;
 		}
-- 
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_msg.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

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

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

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


From b7f9e85db13c8a6959b7c391efdaa3c723d2772e Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Mon, 23 Jul 2007 01:46:39 +0000
Subject: r23993: Attempt to fix bug #4808, reported by mwallnoefer@yahoo.de. 
 The issue is that when we all ldb_msg_add_empty(), we might realloc() the
 msg->elements array.  We need to ensure the source pointer (when copying an
 element from the same msg) is still valid, or the data copied.

Andrew Bartlett
(This used to be commit 0fbea30577233d00e7c6cdd4faaece0f99fc57b1)
---
 source4/lib/ldb/common/ldb_msg.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 69a2ab749b..e9c04df55a 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -162,11 +162,14 @@ int ldb_msg_add(struct ldb_message *msg,
 		const struct ldb_message_element *el, 
 		int flags)
 {
+	/* We have to copy this, just in case *el is a pointer into
+	 * what ldb_msg_add_empty() is about to realloc() */
+	struct ldb_message_element el_copy = *el;
 	if (ldb_msg_add_empty(msg, el->name, flags, NULL) != 0) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	msg->elements[msg->num_elements-1] = *el;
+	msg->elements[msg->num_elements-1] = el_copy;
 	msg->elements[msg->num_elements-1].flags = flags;
 
 	return LDB_SUCCESS;
-- 
cgit 


From 0d5c5cb3721cacf5305a91a008394c710f684588 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 6 Nov 2007 03:47:41 +0100
Subject: r25857: Indent (This used to be commit
 f42690a90c2f76e7fc130ebbdbd0f93fefacfad6)

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

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index e9c04df55a..528d1d54f1 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -321,7 +321,8 @@ int ldb_msg_element_compare_name(struct ldb_message_element *el1,
   convenience functions to return common types from a message
   these return the first value if the attribute is multi-valued
 */
-const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, const char *attr_name)
+const struct ldb_val *ldb_msg_find_ldb_val(const struct ldb_message *msg, 
+					   const char *attr_name)
 {
 	struct ldb_message_element *el = ldb_msg_find_element(msg, attr_name);
 	if (!el || el->num_values == 0) {
-- 
cgit 


From 131c40a421c5f09a4526d3d7924ebdf2b11b2ee6 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 19 Dec 2007 00:39:27 +0100
Subject: r26529: Indeed, this belongs in the schema module. Ranged results
 need to use

an attribute with ';' in the name.

Andrew Bartlett
(This used to be commit f4023b176eabfb3282fe9b999eac8db55a095ab0)
---
 source4/lib/ldb/common/ldb_msg.c | 5 -----
 1 file changed, 5 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index 528d1d54f1..c1ea9db56b 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -124,11 +124,6 @@ int ldb_msg_add_empty(	struct ldb_message *msg,
 {
 	struct ldb_message_element *els;
 
-	/* FIXME: we should probably leave this to the schema module to check */
-	if (! ldb_valid_attr_name(attr_name)) {
-		return LDB_ERR_OPERATIONS_ERROR;
-	}
-
 	els = talloc_realloc(msg, msg->elements, 
 			     struct ldb_message_element, msg->num_elements+1);
 	if (!els) {
-- 
cgit 


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

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

Andrew Bartlett
(This used to be commit 5805a9a8f35fd90fa4f718f73534817fa3bbdfd2)
---
 source4/lib/ldb/common/ldb_msg.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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

diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c
index c1ea9db56b..2f5fe1d18c 100644
--- a/source4/lib/ldb/common/ldb_msg.c
+++ b/source4/lib/ldb/common/ldb_msg.c
@@ -389,10 +389,10 @@ int ldb_msg_find_attr_as_bool(const struct ldb_message *msg,
 	if (!v || !v->data) {
 		return default_value;
 	}
-	if (strcasecmp((const char *)v->data, "FALSE") == 0) {
+	if (v->length == 5 && strncasecmp((const char *)v->data, "FALSE", 5) == 0) {
 		return 0;
 	}
-	if (strcasecmp((const char *)v->data, "TRUE") == 0) {
+	if (v->length == 4 && strncasecmp((const char *)v->data, "TRUE", 4) == 0) {
 		return 1;
 	}
 	return default_value;
@@ -421,7 +421,7 @@ struct ldb_dn *ldb_msg_find_attr_as_dn(struct ldb_context *ldb,
 	if (!v || !v->data) {
 		return NULL;
 	}
-	res_dn = ldb_dn_new(mem_ctx, ldb, (const char *)v->data);
+	res_dn = ldb_dn_from_ldb_val(mem_ctx, ldb, v);
 	if ( ! ldb_dn_validate(res_dn)) {
 		talloc_free(res_dn);
 		return NULL;
-- 
cgit