Attachment 15822 Details for Bug 14270 – patch for Samba 4.11 (cherry-picked from master patch, plus new ldb release)

[patch] patch for Samba 4.11 (cherry-picked from master patch, plus new ldb release)

v4-11-one-level-ldb.patch (text/plain), 51.01 KB, created by Andrew Bartlett on 2020-02-25 21:43:26 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Andrew Bartlett

Created: 2020-02-25 21:43:26 UTC

Size: 51.01 KB

patch

obsolete

>From 3d17a7ceb10351e0da22383d6875d3d2fe2d081f Mon Sep 17 00:00:00 2001
>From: Andrew Bartlett <abartlet@samba.org>
>Date: Mon, 10 Feb 2020 14:08:29 +1300
>Subject: [PATCH 1/6] ldb: Add tests for one-level indexes in conjunction with
> other indexes
>
>BUG: https://bugzilla.samba.org/show_bug.cgi?id=14270
>
>Signed-off-by: Andrew Bartlett <abartlet@samba.org>
>Reviewed-by: Stefan Metzmacher <metze@samba.org>
>(cherry picked from commit 17bd63dbea7f6e6358f81f0ac5b9392b2321bb32)
>---
> lib/ldb/tests/python/api.py | 251 ++++++++++++++++++++++++++++++++++++
> 1 file changed, 251 insertions(+)
>
>diff --git a/lib/ldb/tests/python/api.py b/lib/ldb/tests/python/api.py
>index 4d55566a4ac..1440a383c45 100755
>--- a/lib/ldb/tests/python/api.py
>+++ b/lib/ldb/tests/python/api.py
>@@ -774,6 +774,49 @@ class SearchTests(LdbBaseTest):
>         # instead use just the 16 bytes raw, which we just keep
>         # to printable chars here for ease of handling.
> 
>+        self.l.add({"dn": "DC=ORG",
>+                    "name": b"org",
>+                    "objectUUID": b"0000000000abcdef"})
>+        self.l.add({"dn": "DC=EXAMPLE,DC=ORG",
>+                    "name": b"org",
>+                    "objectUUID": b"0000000001abcdef"})
>+        self.l.add({"dn": "OU=OU1,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #1",
>+                    "x": "y", "y": "a",
>+                    "objectUUID": b"0023456789abcde3"})
>+        self.l.add({"dn": "OU=OU2,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #2",
>+                    "x": "y", "y": "a",
>+                    "objectUUID": b"0023456789abcde4"})
>+        self.l.add({"dn": "OU=OU3,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #3",
>+                    "x": "y", "y": "a",
>+                    "objectUUID": b"0023456789abcde5"})
>+        self.l.add({"dn": "OU=OU4,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #4",
>+                    "x": "z", "y": "b",
>+                    "objectUUID": b"0023456789abcde6"})
>+        self.l.add({"dn": "OU=OU5,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #5",
>+                    "x": "y", "y": "a",
>+                    "objectUUID": b"0023456789abcde7"})
>+        self.l.add({"dn": "OU=OU6,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #6",
>+                    "x": "y", "y": "a",
>+                    "objectUUID": b"0023456789abcde8"})
>+        self.l.add({"dn": "OU=OU7,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #7",
>+                    "x": "y", "y": "c",
>+                    "objectUUID": b"0023456789abcde9"})
>+        self.l.add({"dn": "OU=OU8,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #8",
>+                    "x": "y", "y": "b",
>+                    "objectUUID": b"0023456789abcde0"})
>+        self.l.add({"dn": "OU=OU9,DC=EXAMPLE,DC=ORG",
>+                    "name": b"OU #9",
>+                    "x": "y", "y": "a",
>+                    "objectUUID": b"0023456789abcdea"})
>+
>         self.l.add({"dn": "DC=SAMBA,DC=ORG",
>                     "name": b"samba.org",
>                     "objectUUID": b"0123456789abcdef"})
>@@ -1165,6 +1208,86 @@ class SearchTests(LdbBaseTest):
>                               expression="(@IDXONE=DC=SAMBA,DC=ORG)")
>         self.assertEqual(len(res11), 0)
> 
>+    def test_onelevel_and_or(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=z)(y=b))(x=x)(y=c))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_and_or2(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(x=x)(y=c)(|(x=z)(y=b)))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_and_or3(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(ou=ou11)(ou=ou10))(|(x=y)(y=b)(y=c)))")
>+        self.assertEqual(len(res11), 2)
>+
>+    def test_onelevel_and_or4(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=y)(y=b)(y=c))(|(ou=ou11)(ou=ou10)))")
>+        self.assertEqual(len(res11), 2)
>+
>+    def test_onelevel_and_or5(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=y)(y=b)(y=c))(ou=ou11))")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_onelevel_or_and(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(|(x=x)(y=c)(&(x=z)(y=b)))")
>+        self.assertEqual(len(res11), 10)
>+
>+    def test_onelevel_large_and_unique(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(ou=ou10)(y=a))")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_onelevel_and_none(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(ou=ouX)(y=a))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_and_idx_record(self):
>+        """Testing a search against the index record"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(@IDXDN=DC=SAMBA,DC=ORG)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_and_idxone_record(self):
>+        """Testing a search against the index record"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(@IDXONE=DC=SAMBA,DC=ORG)")
>+        self.assertEqual(len(res11), 0)
>+
>     def test_subtree_unindexable(self):
>         """Testing a search"""
> 
>@@ -1184,6 +1307,134 @@ class SearchTests(LdbBaseTest):
>             self.assertEqual(enum, ldb.ERR_INAPPROPRIATE_MATCHING)
>             self.assertIn(estr, "ldb FULL SEARCH disabled")
> 
>+    def test_onelevel_only_and_or(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=z)(y=b))(x=x)(y=c))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_and_or2(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(x=x)(y=c)(|(x=z)(y=b)))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_and_or3(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(ou=ou11)(ou=ou10))(|(x=y)(y=b)(y=c)))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_and_or4(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=y)(y=b)(y=c))(|(ou=ou11)(ou=ou10)))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_and_or5(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=y)(y=b)(y=c))(ou=ou11))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_or_and(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(|(x=x)(y=c)(&(x=z)(y=b)))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_large_and_unique(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(ou=ou10)(y=a))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_and_none(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(ou=ouX)(y=a))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_small_and_or(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=z)(y=b))(x=x)(y=c))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_small_and_or2(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(x=x)(y=c)(|(x=z)(y=b)))")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_small_and_or3(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(ou=ou1)(ou=ou2))(|(x=y)(y=b)(y=c)))")
>+        self.assertEqual(len(res11), 2)
>+
>+    def test_onelevel_small_and_or4(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=y)(y=b)(y=c))(|(ou=ou1)(ou=ou2)))")
>+        self.assertEqual(len(res11), 2)
>+
>+    def test_onelevel_small_and_or5(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(|(x=y)(y=b)(y=c))(ou=ou1))")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_onelevel_small_or_and(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(|(x=x)(y=c)(&(x=z)(y=b)))")
>+        self.assertEqual(len(res11), 2)
>+
>+    def test_onelevel_small_large_and_unique(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(ou=ou9)(y=a))")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_onelevel_small_and_none(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(&(ou=ouX)(y=a))")
>+        self.assertEqual(len(res11), 0)
>+
>     def test_subtree_unindexable_presence(self):
>         """Testing a search"""
> 
>-- 
>2.17.1
>
>
>From baf5eb662a7c4f1513f3093f94b52558d13541cc Mon Sep 17 00:00:00 2001
>From: Andrew Bartlett <abartlet@samba.org>
>Date: Wed, 12 Feb 2020 11:45:36 +1300
>Subject: [PATCH 2/6] ldb: Add tests aimed at the SCOPE_ONELEVEL particular
>
>BUG: https://bugzilla.samba.org/show_bug.cgi?id=14270
>
>Signed-off-by: Andrew Bartlett <abartlet@samba.org>
>Reviewed-by: Stefan Metzmacher <metze@samba.org>
>(cherry picked from commit 167676973b7f1db563da04d54e8ce5668034081c)
>---
> lib/ldb/tests/python/api.py | 171 ++++++++++++++++++++++++++++++++++++
> 1 file changed, 171 insertions(+)
>
>diff --git a/lib/ldb/tests/python/api.py b/lib/ldb/tests/python/api.py
>index 1440a383c45..66034d03013 100755
>--- a/lib/ldb/tests/python/api.py
>+++ b/lib/ldb/tests/python/api.py
>@@ -817,6 +817,17 @@ class SearchTests(LdbBaseTest):
>                     "x": "y", "y": "a",
>                     "objectUUID": b"0023456789abcdea"})
> 
>+        self.l.add({"dn": "DC=EXAMPLE,DC=COM",
>+                    "name": b"org",
>+                    "objectUUID": b"0000000011abcdef"})
>+
>+        self.l.add({"dn": "DC=EXAMPLE,DC=NET",
>+                    "name": b"org",
>+                    "objectUUID": b"0000000021abcdef"})
>+
>+        self.l.add({"dn": "OU=UNIQUE,DC=EXAMPLE,DC=NET",
>+                    "objectUUID": b"0000000022abcdef"})
>+
>         self.l.add({"dn": "DC=SAMBA,DC=ORG",
>                     "name": b"samba.org",
>                     "objectUUID": b"0123456789abcdef"})
>@@ -1184,6 +1195,86 @@ class SearchTests(LdbBaseTest):
>                               expression="(&(ou=ou10)(y=a))")
>         self.assertEqual(len(res11), 1)
> 
>+    def test_subtree_unique(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_subtree_unique_elsewhere(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_subtree_unique_elsewhere2(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=COM",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_subtree_unique_elsewhere2(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=NET",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_subtree_unique_elsewhere3(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_subtree_unique_elsewhere4(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_subtree_unique_elsewhere5(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=COM",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_subtree_unique_elsewhere6(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_subtree_unique_here(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="OU=UNIQUE,DC=EXAMPLE,DC=NET",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_subtree_unique(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_SUBTREE,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 1)
>+
>     def test_subtree_and_none(self):
>         """Testing a search"""
> 
>@@ -1264,6 +1355,62 @@ class SearchTests(LdbBaseTest):
>                               expression="(&(ou=ou10)(y=a))")
>         self.assertEqual(len(res11), 1)
> 
>+    def test_onelevel_unique(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_onelevel_unique_elsewhere(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_unique_elsewhere2(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=COM",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_unique_elsewhere2(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=NET",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 1)
>+
>+    def test_onelevel_unique_elsewhere3(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_unique_elsewhere5(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=COM",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_unique_here(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="OU=UNIQUE,DC=EXAMPLE,DC=NET",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>     def test_onelevel_and_none(self):
>         """Testing a search"""
> 
>@@ -1363,6 +1510,22 @@ class SearchTests(LdbBaseTest):
>                               expression="(&(ou=ou10)(y=a))")
>         self.assertEqual(len(res11), 0)
> 
>+    def test_onelevel_only_unique(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 0)
>+
>+    def test_onelevel_only_unique2(self):
>+        """Testing a search"""
>+
>+        res11 = self.l.search(base="DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>     def test_onelevel_only_and_none(self):
>         """Testing a search (showing that onelevel is not subtree)"""
> 
>@@ -1427,6 +1590,14 @@ class SearchTests(LdbBaseTest):
>                               expression="(&(ou=ou9)(y=a))")
>         self.assertEqual(len(res11), 1)
> 
>+    def test_onelevel_small_unique_elsewhere(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=ou10)")
>+        self.assertEqual(len(res11), 0)
>+
>     def test_onelevel_small_and_none(self):
>         """Testing a search (showing that onelevel is not subtree)"""
> 
>-- 
>2.17.1
>
>
>From 6f80eb53b8ea783bfeb55f4e3718ca769296d027 Mon Sep 17 00:00:00 2001
>From: Andrew Bartlett <abartlet@samba.org>
>Date: Wed, 12 Feb 2020 13:44:44 +1300
>Subject: [PATCH 3/6] ldb: Ensure @IDXONE modes is tested in ldb.python
> (apy.py) tests
>
>Signed-off-by: Andrew Bartlett <abartlet@samba.org>
>Reviewed-by: Stefan Metzmacher <metze@samba.org>
>(cherry picked from commit ec34a7095705592279647c5046a000e0bf052d1a)
>---
> lib/ldb/tests/python/api.py | 69 ++++++++++++++++++++++++++++++++++++-
> 1 file changed, 68 insertions(+), 1 deletion(-)
>
>diff --git a/lib/ldb/tests/python/api.py b/lib/ldb/tests/python/api.py
>index 66034d03013..a7c1f359529 100755
>--- a/lib/ldb/tests/python/api.py
>+++ b/lib/ldb/tests/python/api.py
>@@ -1011,6 +1011,38 @@ class SearchTests(LdbBaseTest):
>             enum = err.args[0]
>             self.assertEqual(enum, ldb.ERR_NO_SUCH_OBJECT)
> 
>+    def test_subtree(self):
>+        """Testing a search"""
>+
>+        try:
>+            res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                                  scope=ldb.SCOPE_SUBTREE)
>+            if hasattr(self, 'IDXCHECK'):
>+                self.fail()
>+        except ldb.LdbError as err:
>+            enum = err.args[0]
>+            estr = err.args[1]
>+            self.assertEqual(enum, ldb.ERR_INAPPROPRIATE_MATCHING)
>+            self.assertIn(estr, "ldb FULL SEARCH disabled")
>+        else:
>+            self.assertEqual(len(res11), 25)
>+
>+    def test_subtree2(self):
>+        """Testing a search"""
>+
>+        try:
>+            res11 = self.l.search(base="DC=ORG",
>+                                  scope=ldb.SCOPE_SUBTREE)
>+            if hasattr(self, 'IDXCHECK'):
>+                self.fail()
>+        except ldb.LdbError as err:
>+            enum = err.args[0]
>+            estr = err.args[1]
>+            self.assertEqual(enum, ldb.ERR_INAPPROPRIATE_MATCHING)
>+            self.assertIn(estr, "ldb FULL SEARCH disabled")
>+        else:
>+            self.assertEqual(len(res11), 36)
>+
>     def test_subtree_and(self):
>         """Testing a search"""
> 
>@@ -1299,6 +1331,41 @@ class SearchTests(LdbBaseTest):
>                               expression="(@IDXONE=DC=SAMBA,DC=ORG)")
>         self.assertEqual(len(res11), 0)
> 
>+    def test_onelevel(self):
>+        """Testing a search"""
>+
>+        try:
>+            res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                                  scope=ldb.SCOPE_ONELEVEL)
>+            if hasattr(self, 'IDXCHECK') \
>+               and not hasattr(self, 'IDXONE'):
>+                self.fail()
>+        except ldb.LdbError as err:
>+            enum = err.args[0]
>+            estr = err.args[1]
>+            self.assertEqual(enum, ldb.ERR_INAPPROPRIATE_MATCHING)
>+            self.assertIn(estr, "ldb FULL SEARCH disabled")
>+        else:
>+            self.assertEqual(len(res11), 24)
>+
>+    def test_onelevel2(self):
>+        """Testing a search"""
>+
>+        try:
>+            res11 = self.l.search(base="DC=EXAMPLE,DC=ORG",
>+                                  scope=ldb.SCOPE_ONELEVEL)
>+            if hasattr(self, 'IDXCHECK') \
>+               and not hasattr(self, 'IDXONE'):
>+                self.fail()
>+                self.fail()
>+        except ldb.LdbError as err:
>+            enum = err.args[0]
>+            estr = err.args[1]
>+            self.assertEqual(enum, ldb.ERR_INAPPROPRIATE_MATCHING)
>+            self.assertIn(estr, "ldb FULL SEARCH disabled")
>+        else:
>+            self.assertEqual(len(res11), 9)
>+
>     def test_onelevel_and_or(self):
>         """Testing a search"""
> 
>@@ -1914,7 +1981,6 @@ class GUIDIndexedSearchTests(SearchTests):
>         super(GUIDIndexedSearchTests, self).setUp()
> 
>         self.IDXGUID = True
>-        self.IDXONE = True
> 
> 
> class GUIDIndexedDNFilterSearchTests(SearchTests):
>@@ -1943,6 +2009,7 @@ class GUIDAndOneLevelIndexedSearchTests(SearchTests):
>     def setUp(self):
>         self.index = {"dn": "@INDEXLIST",
>                       "@IDXATTR": [b"x", b"y", b"ou"],
>+                      "@IDXONE": [b"1"],
>                       "@IDXGUID": [b"objectUUID"],
>                       "@IDX_DN_GUID": [b"GUID"]}
>         super(GUIDAndOneLevelIndexedSearchTests, self).setUp()
>-- 
>2.17.1
>
>
>From e927719fa1ce881a73c2d381a9f0dc0f25bfc551 Mon Sep 17 00:00:00 2001
>From: Andrew Bartlett <abartlet@samba.org>
>Date: Fri, 7 Feb 2020 16:56:13 +1300
>Subject: [PATCH 4/6] ldb: Fix search with scope ONE and small result sets
>MIME-Version: 1.0
>Content-Type: text/plain; charset=UTF-8
>Content-Transfer-Encoding: 8bit
>
>This changes the LDB behaviour in the combination of a SCOPE_ONE search and
>an index returning less than 10 results.
>
>After b6b5b5fe355fee2a4096e9214831cb88c7a2a4c6 the list->strict flag
>became set to false in all cases, rather than being left to the
>value set by the caller.
>
>This changes the ldb_kv_index_dn_one() code to force strict
>mode on success instead.
>
>Thanks to Marcus GranÃ©r, ICEYE Oy for reporting.
>
>BUG: https://bugzilla.samba.org/show_bug.cgi?id=14270
>
>Signed-off-by: Andrew Bartlett <abartlet@samba.org>
>Reviewed-by: Stefan Metzmacher <metze@samba.org>
>(cherry picked from commit 3c7261c43da491b57f50e0e64d7050d85c6b973e)
>---
> lib/ldb/ldb_key_value/ldb_kv_index.c | 21 ++++++++++++---------
> 1 file changed, 12 insertions(+), 9 deletions(-)
>
>diff --git a/lib/ldb/ldb_key_value/ldb_kv_index.c b/lib/ldb/ldb_key_value/ldb_kv_index.c
>index 0853b28fe40..8e756c1a8e5 100644
>--- a/lib/ldb/ldb_key_value/ldb_kv_index.c
>+++ b/lib/ldb/ldb_key_value/ldb_kv_index.c
>@@ -2113,16 +2113,19 @@ static int ldb_kv_index_dn_one(struct ldb_module *module,
> 			       struct dn_list *list,
> 			       enum key_truncation *truncation)
> {
>-	/*
>-	 * Ensure we do not shortcut on intersection for this list.
>-	 * We must never be lazy and return an entry not in this
>-	 * list.  This allows the index for
>-	 * SCOPE_ONELEVEL to be trusted.
>-	 */
>-
>-	list->strict = true;
>-	return ldb_kv_index_dn_attr(
>+	int ret = ldb_kv_index_dn_attr(
> 	    module, ldb_kv, LDB_KV_IDXONE, parent_dn, list, truncation);
>+	if (ret == LDB_SUCCESS) {
>+		/*
>+		 * Ensure we do not shortcut on intersection for this
>+		 * list.  We must never be lazy and return an entry
>+		 * not in this list.  This allows the index for
>+		 * SCOPE_ONELEVEL to be trusted.
>+		 */
>+
>+		list->strict = true;
>+	}
>+	return ret;
> }
> 
> /*
>-- 
>2.17.1
>
>
>From 4306618fce1fb9bf325cb16bfa8b1256072ca83e Mon Sep 17 00:00:00 2001
>From: Andrew Bartlett <abartlet@samba.org>
>Date: Wed, 12 Feb 2020 16:28:01 +1300
>Subject: [PATCH 5/6] ldb: Add tests aimed at the SCOPE_ONELEVEL bug in
> particular
>
>BUG: https://bugzilla.samba.org/show_bug.cgi?id=14270
>
>Signed-off-by: Andrew Bartlett <abartlet@samba.org>
>Reviewed-by: Stefan Metzmacher <metze@samba.org>
>(cherry picked from commit 0b8ab0200805127e36eeb2affe561f3aee59604a)
>---
> lib/ldb/tests/python/api.py | 8 ++++++++
> 1 file changed, 8 insertions(+)
>
>diff --git a/lib/ldb/tests/python/api.py b/lib/ldb/tests/python/api.py
>index a7c1f359529..1d3d765e607 100755
>--- a/lib/ldb/tests/python/api.py
>+++ b/lib/ldb/tests/python/api.py
>@@ -1462,6 +1462,14 @@ class SearchTests(LdbBaseTest):
>                               expression="(ou=unique)")
>         self.assertEqual(len(res11), 0)
> 
>+    def test_onelevel_unique_elsewhere4(self):
>+        """Testing a search (showing that onelevel is not subtree)"""
>+
>+        res11 = self.l.search(base="DC=SAMBA,DC=ORG",
>+                              scope=ldb.SCOPE_ONELEVEL,
>+                              expression="(ou=unique)")
>+        self.assertEqual(len(res11), 0)
>+
>     def test_onelevel_unique_elsewhere5(self):
>         """Testing a search (showing that onelevel is not subtree)"""
> 
>-- 
>2.17.1
>
>
>From 994985381ca627dd99618f05eeadce7a2ac52509 Mon Sep 17 00:00:00 2001
>From: Andrew Bartlett <abartlet@samba.org>
>Date: Wed, 26 Feb 2020 10:29:20 +1300
>Subject: [PATCH 6/6] ldb: version 2.1.1
>
> * Bug 14270:
>   Samba 4.11 and later give incorrect results for SCOPE_ONE searches
>
>Signed-off-by: Andrew Bartlett <abartlet@samba.org>
>---
> lib/ldb/ABI/ldb-2.0.9.sigs        | 283 ++++++++++++++++++++++++++++++
> lib/ldb/ABI/pyldb-util-2.0.9.sigs |   2 +
> lib/ldb/wscript                   |   2 +-
> 3 files changed, 286 insertions(+), 1 deletion(-)
> create mode 100644 lib/ldb/ABI/ldb-2.0.9.sigs
> create mode 100644 lib/ldb/ABI/pyldb-util-2.0.9.sigs
>
>diff --git a/lib/ldb/ABI/ldb-2.0.9.sigs b/lib/ldb/ABI/ldb-2.0.9.sigs
>new file mode 100644
>index 00000000000..5049dc64ce1
>--- /dev/null
>+++ b/lib/ldb/ABI/ldb-2.0.9.sigs
>@@ -0,0 +1,283 @@
>+ldb_add: int (struct ldb_context *, const struct ldb_message *)
>+ldb_any_comparison: int (struct ldb_context *, void *, ldb_attr_handler_t, const struct ldb_val *, const struct ldb_val *)
>+ldb_asprintf_errstring: void (struct ldb_context *, const char *, ...)
>+ldb_attr_casefold: char *(TALLOC_CTX *, const char *)
>+ldb_attr_dn: int (const char *)
>+ldb_attr_in_list: int (const char * const *, const char *)
>+ldb_attr_list_copy: const char **(TALLOC_CTX *, const char * const *)
>+ldb_attr_list_copy_add: const char **(TALLOC_CTX *, const char * const *, const char *)
>+ldb_base64_decode: int (char *)
>+ldb_base64_encode: char *(TALLOC_CTX *, const char *, int)
>+ldb_binary_decode: struct ldb_val (TALLOC_CTX *, const char *)
>+ldb_binary_encode: char *(TALLOC_CTX *, struct ldb_val)
>+ldb_binary_encode_string: char *(TALLOC_CTX *, const char *)
>+ldb_build_add_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
>+ldb_build_del_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
>+ldb_build_extended_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const char *, void *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
>+ldb_build_mod_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
>+ldb_build_rename_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
>+ldb_build_search_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, const char *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
>+ldb_build_search_req_ex: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, struct ldb_parse_tree *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
>+ldb_casefold: char *(struct ldb_context *, TALLOC_CTX *, const char *, size_t)
>+ldb_casefold_default: char *(void *, TALLOC_CTX *, const char *, size_t)
>+ldb_check_critical_controls: int (struct ldb_control **)
>+ldb_comparison_binary: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
>+ldb_comparison_fold: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
>+ldb_connect: int (struct ldb_context *, const char *, unsigned int, const char **)
>+ldb_control_to_string: char *(TALLOC_CTX *, const struct ldb_control *)
>+ldb_controls_except_specified: struct ldb_control **(struct ldb_control **, TALLOC_CTX *, struct ldb_control *)
>+ldb_debug: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
>+ldb_debug_add: void (struct ldb_context *, const char *, ...)
>+ldb_debug_end: void (struct ldb_context *, enum ldb_debug_level)
>+ldb_debug_set: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
>+ldb_delete: int (struct ldb_context *, struct ldb_dn *)
>+ldb_dn_add_base: bool (struct ldb_dn *, struct ldb_dn *)
>+ldb_dn_add_base_fmt: bool (struct ldb_dn *, const char *, ...)
>+ldb_dn_add_child: bool (struct ldb_dn *, struct ldb_dn *)
>+ldb_dn_add_child_fmt: bool (struct ldb_dn *, const char *, ...)
>+ldb_dn_add_child_val: bool (struct ldb_dn *, const char *, struct ldb_val)
>+ldb_dn_alloc_casefold: char *(TALLOC_CTX *, struct ldb_dn *)
>+ldb_dn_alloc_linearized: char *(TALLOC_CTX *, struct ldb_dn *)
>+ldb_dn_canonical_ex_string: char *(TALLOC_CTX *, struct ldb_dn *)
>+ldb_dn_canonical_string: char *(TALLOC_CTX *, struct ldb_dn *)
>+ldb_dn_check_local: bool (struct ldb_module *, struct ldb_dn *)
>+ldb_dn_check_special: bool (struct ldb_dn *, const char *)
>+ldb_dn_compare: int (struct ldb_dn *, struct ldb_dn *)
>+ldb_dn_compare_base: int (struct ldb_dn *, struct ldb_dn *)
>+ldb_dn_copy: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
>+ldb_dn_escape_value: char *(TALLOC_CTX *, struct ldb_val)
>+ldb_dn_extended_add_syntax: int (struct ldb_context *, unsigned int, const struct ldb_dn_extended_syntax *)
>+ldb_dn_extended_filter: void (struct ldb_dn *, const char * const *)
>+ldb_dn_extended_syntax_by_name: const struct ldb_dn_extended_syntax *(struct ldb_context *, const char *)
>+ldb_dn_from_ldb_val: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const struct ldb_val *)
>+ldb_dn_get_casefold: const char *(struct ldb_dn *)
>+ldb_dn_get_comp_num: int (struct ldb_dn *)
>+ldb_dn_get_component_name: const char *(struct ldb_dn *, unsigned int)
>+ldb_dn_get_component_val: const struct ldb_val *(struct ldb_dn *, unsigned int)
>+ldb_dn_get_extended_comp_num: int (struct ldb_dn *)
>+ldb_dn_get_extended_component: const struct ldb_val *(struct ldb_dn *, const char *)
>+ldb_dn_get_extended_linearized: char *(TALLOC_CTX *, struct ldb_dn *, int)
>+ldb_dn_get_ldb_context: struct ldb_context *(struct ldb_dn *)
>+ldb_dn_get_linearized: const char *(struct ldb_dn *)
>+ldb_dn_get_parent: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
>+ldb_dn_get_rdn_name: const char *(struct ldb_dn *)
>+ldb_dn_get_rdn_val: const struct ldb_val *(struct ldb_dn *)
>+ldb_dn_has_extended: bool (struct ldb_dn *)
>+ldb_dn_is_null: bool (struct ldb_dn *)
>+ldb_dn_is_special: bool (struct ldb_dn *)
>+ldb_dn_is_valid: bool (struct ldb_dn *)
>+ldb_dn_map_local: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
>+ldb_dn_map_rebase_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
>+ldb_dn_map_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
>+ldb_dn_minimise: bool (struct ldb_dn *)
>+ldb_dn_new: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *)
>+ldb_dn_new_fmt: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *, ...)
>+ldb_dn_remove_base_components: bool (struct ldb_dn *, unsigned int)
>+ldb_dn_remove_child_components: bool (struct ldb_dn *, unsigned int)
>+ldb_dn_remove_extended_components: void (struct ldb_dn *)
>+ldb_dn_replace_components: bool (struct ldb_dn *, struct ldb_dn *)
>+ldb_dn_set_component: int (struct ldb_dn *, int, const char *, const struct ldb_val)
>+ldb_dn_set_extended_component: int (struct ldb_dn *, const char *, const struct ldb_val *)
>+ldb_dn_update_components: int (struct ldb_dn *, const struct ldb_dn *)
>+ldb_dn_validate: bool (struct ldb_dn *)
>+ldb_dump_results: void (struct ldb_context *, struct ldb_result *, FILE *)
>+ldb_error_at: int (struct ldb_context *, int, const char *, const char *, int)
>+ldb_errstring: const char *(struct ldb_context *)
>+ldb_extended: int (struct ldb_context *, const char *, void *, struct ldb_result **)
>+ldb_extended_default_callback: int (struct ldb_request *, struct ldb_reply *)
>+ldb_filter_attrs: int (struct ldb_context *, const struct ldb_message *, const char * const *, struct ldb_message *)
>+ldb_filter_from_tree: char *(TALLOC_CTX *, const struct ldb_parse_tree *)
>+ldb_get_config_basedn: struct ldb_dn *(struct ldb_context *)
>+ldb_get_create_perms: unsigned int (struct ldb_context *)
>+ldb_get_default_basedn: struct ldb_dn *(struct ldb_context *)
>+ldb_get_event_context: struct tevent_context *(struct ldb_context *)
>+ldb_get_flags: unsigned int (struct ldb_context *)
>+ldb_get_opaque: void *(struct ldb_context *, const char *)
>+ldb_get_root_basedn: struct ldb_dn *(struct ldb_context *)
>+ldb_get_schema_basedn: struct ldb_dn *(struct ldb_context *)
>+ldb_global_init: int (void)
>+ldb_handle_get_event_context: struct tevent_context *(struct ldb_handle *)
>+ldb_handle_new: struct ldb_handle *(TALLOC_CTX *, struct ldb_context *)
>+ldb_handle_use_global_event_context: void (struct ldb_handle *)
>+ldb_handler_copy: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
>+ldb_handler_fold: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
>+ldb_init: struct ldb_context *(TALLOC_CTX *, struct tevent_context *)
>+ldb_ldif_message_redacted_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
>+ldb_ldif_message_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
>+ldb_ldif_parse_modrdn: int (struct ldb_context *, const struct ldb_ldif *, TALLOC_CTX *, struct ldb_dn **, struct ldb_dn **, bool *, struct ldb_dn **, struct ldb_dn **)
>+ldb_ldif_read: struct ldb_ldif *(struct ldb_context *, int (*)(void *), void *)
>+ldb_ldif_read_file: struct ldb_ldif *(struct ldb_context *, FILE *)
>+ldb_ldif_read_file_state: struct ldb_ldif *(struct ldb_context *, struct ldif_read_file_state *)
>+ldb_ldif_read_free: void (struct ldb_context *, struct ldb_ldif *)
>+ldb_ldif_read_string: struct ldb_ldif *(struct ldb_context *, const char **)
>+ldb_ldif_write: int (struct ldb_context *, int (*)(void *, const char *, ...), void *, const struct ldb_ldif *)
>+ldb_ldif_write_file: int (struct ldb_context *, FILE *, const struct ldb_ldif *)
>+ldb_ldif_write_redacted_trace_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
>+ldb_ldif_write_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
>+ldb_load_modules: int (struct ldb_context *, const char **)
>+ldb_map_add: int (struct ldb_module *, struct ldb_request *)
>+ldb_map_delete: int (struct ldb_module *, struct ldb_request *)
>+ldb_map_init: int (struct ldb_module *, const struct ldb_map_attribute *, const struct ldb_map_objectclass *, const char * const *, const char *, const char *)
>+ldb_map_modify: int (struct ldb_module *, struct ldb_request *)
>+ldb_map_rename: int (struct ldb_module *, struct ldb_request *)
>+ldb_map_search: int (struct ldb_module *, struct ldb_request *)
>+ldb_match_message: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, enum ldb_scope, bool *)
>+ldb_match_msg: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope)
>+ldb_match_msg_error: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope, bool *)
>+ldb_match_msg_objectclass: int (const struct ldb_message *, const char *)
>+ldb_mod_register_control: int (struct ldb_module *, const char *)
>+ldb_modify: int (struct ldb_context *, const struct ldb_message *)
>+ldb_modify_default_callback: int (struct ldb_request *, struct ldb_reply *)
>+ldb_module_call_chain: char *(struct ldb_request *, TALLOC_CTX *)
>+ldb_module_connect_backend: int (struct ldb_context *, const char *, const char **, struct ldb_module **)
>+ldb_module_done: int (struct ldb_request *, struct ldb_control **, struct ldb_extended *, int)
>+ldb_module_flags: uint32_t (struct ldb_context *)
>+ldb_module_get_ctx: struct ldb_context *(struct ldb_module *)
>+ldb_module_get_name: const char *(struct ldb_module *)
>+ldb_module_get_ops: const struct ldb_module_ops *(struct ldb_module *)
>+ldb_module_get_private: void *(struct ldb_module *)
>+ldb_module_init_chain: int (struct ldb_context *, struct ldb_module *)
>+ldb_module_load_list: int (struct ldb_context *, const char **, struct ldb_module *, struct ldb_module **)
>+ldb_module_new: struct ldb_module *(TALLOC_CTX *, struct ldb_context *, const char *, const struct ldb_module_ops *)
>+ldb_module_next: struct ldb_module *(struct ldb_module *)
>+ldb_module_popt_options: struct poptOption **(struct ldb_context *)
>+ldb_module_send_entry: int (struct ldb_request *, struct ldb_message *, struct ldb_control **)
>+ldb_module_send_referral: int (struct ldb_request *, char *)
>+ldb_module_set_next: void (struct ldb_module *, struct ldb_module *)
>+ldb_module_set_private: void (struct ldb_module *, void *)
>+ldb_modules_hook: int (struct ldb_context *, enum ldb_module_hook_type)
>+ldb_modules_list_from_string: const char **(struct ldb_context *, TALLOC_CTX *, const char *)
>+ldb_modules_load: int (const char *, const char *)
>+ldb_msg_add: int (struct ldb_message *, const struct ldb_message_element *, int)
>+ldb_msg_add_empty: int (struct ldb_message *, const char *, int, struct ldb_message_element **)
>+ldb_msg_add_fmt: int (struct ldb_message *, const char *, const char *, ...)
>+ldb_msg_add_linearized_dn: int (struct ldb_message *, const char *, struct ldb_dn *)
>+ldb_msg_add_steal_string: int (struct ldb_message *, const char *, char *)
>+ldb_msg_add_steal_value: int (struct ldb_message *, const char *, struct ldb_val *)
>+ldb_msg_add_string: int (struct ldb_message *, const char *, const char *)
>+ldb_msg_add_value: int (struct ldb_message *, const char *, const struct ldb_val *, struct ldb_message_element **)
>+ldb_msg_canonicalize: struct ldb_message *(struct ldb_context *, const struct ldb_message *)
>+ldb_msg_check_string_attribute: int (const struct ldb_message *, const char *, const char *)
>+ldb_msg_copy: struct ldb_message *(TALLOC_CTX *, const struct ldb_message *)
>+ldb_msg_copy_attr: int (struct ldb_message *, const char *, const char *)
>+ldb_msg_copy_shallow: struct ldb_message *(TALLOC_CTX *, const struct ldb_message *)
>+ldb_msg_diff: struct ldb_message *(struct ldb_context *, struct ldb_message *, struct ldb_message *)
>+ldb_msg_difference: int (struct ldb_context *, TALLOC_CTX *, struct ldb_message *, struct ldb_message *, struct ldb_message **)
>+ldb_msg_element_compare: int (struct ldb_message_element *, struct ldb_message_element *)
>+ldb_msg_element_compare_name: int (struct ldb_message_element *, struct ldb_message_element *)
>+ldb_msg_element_equal_ordered: bool (const struct ldb_message_element *, const struct ldb_message_element *)
>+ldb_msg_find_attr_as_bool: int (const struct ldb_message *, const char *, int)
>+ldb_msg_find_attr_as_dn: struct ldb_dn *(struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, const char *)
>+ldb_msg_find_attr_as_double: double (const struct ldb_message *, const char *, double)
>+ldb_msg_find_attr_as_int: int (const struct ldb_message *, const char *, int)
>+ldb_msg_find_attr_as_int64: int64_t (const struct ldb_message *, const char *, int64_t)
>+ldb_msg_find_attr_as_string: const char *(const struct ldb_message *, const char *, const char *)
>+ldb_msg_find_attr_as_uint: unsigned int (const struct ldb_message *, const char *, unsigned int)
>+ldb_msg_find_attr_as_uint64: uint64_t (const struct ldb_message *, const char *, uint64_t)
>+ldb_msg_find_common_values: int (struct ldb_context *, TALLOC_CTX *, struct ldb_message_element *, struct ldb_message_element *, uint32_t)
>+ldb_msg_find_duplicate_val: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message_element *, struct ldb_val **, uint32_t)
>+ldb_msg_find_element: struct ldb_message_element *(const struct ldb_message *, const char *)
>+ldb_msg_find_ldb_val: const struct ldb_val *(const struct ldb_message *, const char *)
>+ldb_msg_find_val: struct ldb_val *(const struct ldb_message_element *, struct ldb_val *)
>+ldb_msg_new: struct ldb_message *(TALLOC_CTX *)
>+ldb_msg_normalize: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_message **)
>+ldb_msg_remove_attr: void (struct ldb_message *, const char *)
>+ldb_msg_remove_element: void (struct ldb_message *, struct ldb_message_element *)
>+ldb_msg_rename_attr: int (struct ldb_message *, const char *, const char *)
>+ldb_msg_sanity_check: int (struct ldb_context *, const struct ldb_message *)
>+ldb_msg_sort_elements: void (struct ldb_message *)
>+ldb_next_del_trans: int (struct ldb_module *)
>+ldb_next_end_trans: int (struct ldb_module *)
>+ldb_next_init: int (struct ldb_module *)
>+ldb_next_prepare_commit: int (struct ldb_module *)
>+ldb_next_read_lock: int (struct ldb_module *)
>+ldb_next_read_unlock: int (struct ldb_module *)
>+ldb_next_remote_request: int (struct ldb_module *, struct ldb_request *)
>+ldb_next_request: int (struct ldb_module *, struct ldb_request *)
>+ldb_next_start_trans: int (struct ldb_module *)
>+ldb_op_default_callback: int (struct ldb_request *, struct ldb_reply *)
>+ldb_options_copy: const char **(TALLOC_CTX *, const char **)
>+ldb_options_find: const char *(struct ldb_context *, const char **, const char *)
>+ldb_options_get: const char **(struct ldb_context *)
>+ldb_pack_data: int (struct ldb_context *, const struct ldb_message *, struct ldb_val *, uint32_t)
>+ldb_parse_control_from_string: struct ldb_control *(struct ldb_context *, TALLOC_CTX *, const char *)
>+ldb_parse_control_strings: struct ldb_control **(struct ldb_context *, TALLOC_CTX *, const char **)
>+ldb_parse_tree: struct ldb_parse_tree *(TALLOC_CTX *, const char *)
>+ldb_parse_tree_attr_replace: void (struct ldb_parse_tree *, const char *, const char *)
>+ldb_parse_tree_copy_shallow: struct ldb_parse_tree *(TALLOC_CTX *, const struct ldb_parse_tree *)
>+ldb_parse_tree_walk: int (struct ldb_parse_tree *, int (*)(struct ldb_parse_tree *, void *), void *)
>+ldb_qsort: void (void * const, size_t, size_t, void *, ldb_qsort_cmp_fn_t)
>+ldb_register_backend: int (const char *, ldb_connect_fn, bool)
>+ldb_register_extended_match_rule: int (struct ldb_context *, const struct ldb_extended_match_rule *)
>+ldb_register_hook: int (ldb_hook_fn)
>+ldb_register_module: int (const struct ldb_module_ops *)
>+ldb_rename: int (struct ldb_context *, struct ldb_dn *, struct ldb_dn *)
>+ldb_reply_add_control: int (struct ldb_reply *, const char *, bool, void *)
>+ldb_reply_get_control: struct ldb_control *(struct ldb_reply *, const char *)
>+ldb_req_get_custom_flags: uint32_t (struct ldb_request *)
>+ldb_req_is_untrusted: bool (struct ldb_request *)
>+ldb_req_location: const char *(struct ldb_request *)
>+ldb_req_mark_trusted: void (struct ldb_request *)
>+ldb_req_mark_untrusted: void (struct ldb_request *)
>+ldb_req_set_custom_flags: void (struct ldb_request *, uint32_t)
>+ldb_req_set_location: void (struct ldb_request *, const char *)
>+ldb_request: int (struct ldb_context *, struct ldb_request *)
>+ldb_request_add_control: int (struct ldb_request *, const char *, bool, void *)
>+ldb_request_done: int (struct ldb_request *, int)
>+ldb_request_get_control: struct ldb_control *(struct ldb_request *, const char *)
>+ldb_request_get_status: int (struct ldb_request *)
>+ldb_request_replace_control: int (struct ldb_request *, const char *, bool, void *)
>+ldb_request_set_state: void (struct ldb_request *, int)
>+ldb_reset_err_string: void (struct ldb_context *)
>+ldb_save_controls: int (struct ldb_control *, struct ldb_request *, struct ldb_control ***)
>+ldb_schema_attribute_add: int (struct ldb_context *, const char *, unsigned int, const char *)
>+ldb_schema_attribute_add_with_syntax: int (struct ldb_context *, const char *, unsigned int, const struct ldb_schema_syntax *)
>+ldb_schema_attribute_by_name: const struct ldb_schema_attribute *(struct ldb_context *, const char *)
>+ldb_schema_attribute_fill_with_syntax: int (struct ldb_context *, TALLOC_CTX *, const char *, unsigned int, const struct ldb_schema_syntax *, struct ldb_schema_attribute *)
>+ldb_schema_attribute_remove: void (struct ldb_context *, const char *)
>+ldb_schema_attribute_remove_flagged: void (struct ldb_context *, unsigned int)
>+ldb_schema_attribute_set_override_handler: void (struct ldb_context *, ldb_attribute_handler_override_fn_t, void *)
>+ldb_schema_set_override_GUID_index: void (struct ldb_context *, const char *, const char *)
>+ldb_schema_set_override_indexlist: void (struct ldb_context *, bool)
>+ldb_search: int (struct ldb_context *, TALLOC_CTX *, struct ldb_result **, struct ldb_dn *, enum ldb_scope, const char * const *, const char *, ...)
>+ldb_search_default_callback: int (struct ldb_request *, struct ldb_reply *)
>+ldb_sequence_number: int (struct ldb_context *, enum ldb_sequence_type, uint64_t *)
>+ldb_set_create_perms: void (struct ldb_context *, unsigned int)
>+ldb_set_debug: int (struct ldb_context *, void (*)(void *, enum ldb_debug_level, const char *, va_list), void *)
>+ldb_set_debug_stderr: int (struct ldb_context *)
>+ldb_set_default_dns: void (struct ldb_context *)
>+ldb_set_errstring: void (struct ldb_context *, const char *)
>+ldb_set_event_context: void (struct ldb_context *, struct tevent_context *)
>+ldb_set_flags: void (struct ldb_context *, unsigned int)
>+ldb_set_modules_dir: void (struct ldb_context *, const char *)
>+ldb_set_opaque: int (struct ldb_context *, const char *, void *)
>+ldb_set_require_private_event_context: void (struct ldb_context *)
>+ldb_set_timeout: int (struct ldb_context *, struct ldb_request *, int)
>+ldb_set_timeout_from_prev_req: int (struct ldb_context *, struct ldb_request *, struct ldb_request *)
>+ldb_set_utf8_default: void (struct ldb_context *)
>+ldb_set_utf8_fns: void (struct ldb_context *, void *, char *(*)(void *, void *, const char *, size_t))
>+ldb_setup_wellknown_attributes: int (struct ldb_context *)
>+ldb_should_b64_encode: int (struct ldb_context *, const struct ldb_val *)
>+ldb_standard_syntax_by_name: const struct ldb_schema_syntax *(struct ldb_context *, const char *)
>+ldb_strerror: const char *(int)
>+ldb_string_to_time: time_t (const char *)
>+ldb_string_utc_to_time: time_t (const char *)
>+ldb_timestring: char *(TALLOC_CTX *, time_t)
>+ldb_timestring_utc: char *(TALLOC_CTX *, time_t)
>+ldb_transaction_cancel: int (struct ldb_context *)
>+ldb_transaction_cancel_noerr: int (struct ldb_context *)
>+ldb_transaction_commit: int (struct ldb_context *)
>+ldb_transaction_prepare_commit: int (struct ldb_context *)
>+ldb_transaction_start: int (struct ldb_context *)
>+ldb_unpack_data: int (struct ldb_context *, const struct ldb_val *, struct ldb_message *)
>+ldb_unpack_data_flags: int (struct ldb_context *, const struct ldb_val *, struct ldb_message *, unsigned int)
>+ldb_unpack_get_format: int (const struct ldb_val *, uint32_t *)
>+ldb_val_dup: struct ldb_val (TALLOC_CTX *, const struct ldb_val *)
>+ldb_val_equal_exact: int (const struct ldb_val *, const struct ldb_val *)
>+ldb_val_map_local: struct ldb_val (struct ldb_module *, void *, const struct ldb_map_attribute *, const struct ldb_val *)
>+ldb_val_map_remote: struct ldb_val (struct ldb_module *, void *, const struct ldb_map_attribute *, const struct ldb_val *)
>+ldb_val_string_cmp: int (const struct ldb_val *, const char *)
>+ldb_val_to_time: int (const struct ldb_val *, time_t *)
>+ldb_valid_attr_name: int (const char *)
>+ldb_vdebug: void (struct ldb_context *, enum ldb_debug_level, const char *, va_list)
>+ldb_wait: int (struct ldb_handle *, enum ldb_wait_type)
>diff --git a/lib/ldb/ABI/pyldb-util-2.0.9.sigs b/lib/ldb/ABI/pyldb-util-2.0.9.sigs
>new file mode 100644
>index 00000000000..74d6719d2bc
>--- /dev/null
>+++ b/lib/ldb/ABI/pyldb-util-2.0.9.sigs
>@@ -0,0 +1,2 @@
>+pyldb_Dn_FromDn: PyObject *(struct ldb_dn *)
>+pyldb_Object_AsDn: bool (TALLOC_CTX *, PyObject *, struct ldb_context *, struct ldb_dn **)
>diff --git a/lib/ldb/wscript b/lib/ldb/wscript
>index 5b5c42d1431..c3f2f42b8c1 100644
>--- a/lib/ldb/wscript
>+++ b/lib/ldb/wscript
>@@ -1,7 +1,7 @@
> #!/usr/bin/env python
> 
> APPNAME = 'ldb'
>-VERSION = '2.0.8'
>+VERSION = '2.0.9'
> 
> import sys, os
> 
>-- 
>2.17.1
>

Flags:

metze: review-

Actions: View

Attachments on bug 14270: 15820 | 15821 | 15822