lib ldb: format rename ldb_kv_private

Tidy up the code format after the rename of ltdb_private to
ldb_kv_private

Signed-off-by: Gary Lockyer <gary@catalyst.net.nz>
Reviewed-by: Andrew Bartlett <abartlet@samba.org>

7 files changed, 329 insertions, 251 deletions

diff --git a/lib/ldb/ldb_mdb/ldb_mdb.c b/lib/ldb/ldb_mdb/ldb_mdb.c
index 34e9e1e4aaa..3e523ba2e85 100644
--- a/lib/ldb/ldb_mdb/ldb_mdb.c
+++ b/lib/ldb/ldb_mdb/ldb_mdb.c
@@ -92,7 +92,6 @@ static int lmdb_error_at(struct ldb_context *ldb,
 	return ldb_err;
 }
 
-
 static bool lmdb_transaction_active(struct ldb_kv_private *ldb_kv)
 {
 	return ldb_kv->lmdb_private->txlist != NULL;
@@ -150,7 +149,8 @@ static MDB_txn *get_current_txn(struct lmdb_private *lmdb)
 
 static int lmdb_store(struct ldb_kv_private *ldb_kv,
 		      struct ldb_val key,
-		      struct ldb_val data, int flags)
+		      struct ldb_val data,
+		      int flags)
 {
 	struct lmdb_private *lmdb = ldb_kv->lmdb_private;
 	MDB_val mdb_key;
@@ -368,8 +368,10 @@ done:
 }
 
 /* Handles only a single record */
-static int lmdb_parse_record(struct ldb_kv_private *ldb_kv, struct ldb_val key,
-			     int (*parser)(struct ldb_val key, struct ldb_val data,
+static int lmdb_parse_record(struct ldb_kv_private *ldb_kv,
+			     struct ldb_val key,
+			     int (*parser)(struct ldb_val key,
+					   struct ldb_val data,
 					   void *private_data),
 			     void *ctx)
 {
@@ -417,7 +419,8 @@ static int lmdb_parse_record(struct ldb_kv_private *ldb_kv, struct ldb_val key,
 static int lmdb_lock_read(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	struct lmdb_private *lmdb = ldb_kv->lmdb_private;
 	pid_t pid = getpid();
 
@@ -451,9 +454,11 @@ static int lmdb_lock_read(struct ldb_module *module)
 static int lmdb_unlock_read(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 
-	if (lmdb_transaction_active(ldb_kv) == false && ldb_kv->read_lock_count == 1) {
+	if (lmdb_transaction_active(ldb_kv) == false &&
+	    ldb_kv->read_lock_count == 1) {
 		struct lmdb_private *lmdb = ldb_kv->lmdb_private;
 		mdb_txn_commit(lmdb->read_txn);
 		lmdb->read_txn = NULL;
@@ -554,7 +559,7 @@ static const char *lmdb_errorstr(struct ldb_kv_private *ldb_kv)
 	return mdb_strerror(ldb_kv->lmdb_private->error);
 }
 
-static const char * lmdb_name(struct ldb_kv_private *ldb_kv)
+static const char *lmdb_name(struct ldb_kv_private *ldb_kv)
 {
 	return "lmdb";
 }
diff --git a/lib/ldb/ldb_tdb/ldb_cache.c b/lib/ldb/ldb_tdb/ldb_cache.c
index 1a07f99e843..6c61e590709 100644
--- a/lib/ldb/ldb_tdb/ldb_cache.c
+++ b/lib/ldb/ldb_tdb/ldb_cache.c
@@ -248,11 +248,12 @@ static int ldb_kv_index_load(struct ldb_module *module,
 		 * supplying its own attribute handling
 		 */
 		ldb_kv->cache->attribute_indexes = true;
-		ldb_kv->cache->one_level_indexes = ldb->schema.one_level_indexes;
-		ldb_kv->cache->GUID_index_attribute
-			= ldb->schema.GUID_index_attribute;
-		ldb_kv->cache->GUID_index_dn_component
-			= ldb->schema.GUID_index_dn_component;
+		ldb_kv->cache->one_level_indexes =
+		    ldb->schema.one_level_indexes;
+		ldb_kv->cache->GUID_index_attribute =
+		    ldb->schema.GUID_index_attribute;
+		ldb_kv->cache->GUID_index_dn_component =
+		    ldb->schema.GUID_index_dn_component;
 		return 0;
 	}
 
@@ -282,22 +283,21 @@ static int ldb_kv_index_load(struct ldb_module *module,
 		return -1;
 	}
 
-	if (ldb_msg_find_element(ldb_kv->cache->indexlist, LTDB_IDXONE) != NULL) {
+	if (ldb_msg_find_element(ldb_kv->cache->indexlist, LTDB_IDXONE) !=
+	    NULL) {
 		ldb_kv->cache->one_level_indexes = true;
 	}
-	if (ldb_msg_find_element(ldb_kv->cache->indexlist, LTDB_IDXATTR) != NULL) {
+	if (ldb_msg_find_element(ldb_kv->cache->indexlist, LTDB_IDXATTR) !=
+	    NULL) {
 		ldb_kv->cache->attribute_indexes = true;
 	}
-	ldb_kv->cache->GUID_index_attribute
-		= ldb_msg_find_attr_as_string(ldb_kv->cache->indexlist,
-					      LTDB_IDXGUID, NULL);
-	ldb_kv->cache->GUID_index_dn_component
-		= ldb_msg_find_attr_as_string(ldb_kv->cache->indexlist,
-					      LTDB_IDX_DN_GUID, NULL);
+	ldb_kv->cache->GUID_index_attribute = ldb_msg_find_attr_as_string(
+	    ldb_kv->cache->indexlist, LTDB_IDXGUID, NULL);
+	ldb_kv->cache->GUID_index_dn_component = ldb_msg_find_attr_as_string(
+	    ldb_kv->cache->indexlist, LTDB_IDX_DN_GUID, NULL);
 
-	lmdb_subdb_version
-		= ldb_msg_find_attr_as_int(ldb_kv->cache->indexlist,
-					   LTDB_IDX_LMDB_SUBDB, 0);
+	lmdb_subdb_version = ldb_msg_find_attr_as_int(
+	    ldb_kv->cache->indexlist, LTDB_IDX_LMDB_SUBDB, 0);
 
 	if (lmdb_subdb_version != 0) {
 		ldb_set_errstring(ldb,
@@ -319,7 +319,8 @@ static int ldb_kv_baseinfo_init(struct ldb_module *module)
 {
 	struct ldb_context *ldb;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	struct ldb_message *msg;
 	struct ldb_message_element el;
 	struct ldb_val val;
@@ -375,7 +376,8 @@ failed:
 static void ldb_kv_cache_free(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 
 	ldb_kv->sequence_number = 0;
 	talloc_free(ldb_kv->cache);
@@ -399,7 +401,8 @@ int ldb_kv_cache_load(struct ldb_module *module)
 {
 	struct ldb_context *ldb;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	struct ldb_dn *baseinfo_dn = NULL, *options_dn = NULL;
 	uint64_t seq;
 	struct ldb_message *baseinfo = NULL, *options = NULL;
@@ -416,7 +419,8 @@ int ldb_kv_cache_load(struct ldb_module *module)
 
 	if (ldb_kv->cache == NULL) {
 		ldb_kv->cache = talloc_zero(ldb_kv, struct ltdb_cache);
-		if (ldb_kv->cache == NULL) goto failed;
+		if (ldb_kv->cache == NULL)
+			goto failed;
 	}
 
 	baseinfo = ldb_msg_new(ldb_kv->cache);
@@ -487,12 +491,10 @@ int ldb_kv_cache_load(struct ldb_module *module)
 	
 	/* set flags if they do exist */
 	if (r == LDB_SUCCESS) {
-		ldb_kv->check_base = ldb_msg_find_attr_as_bool(options,
-							     LTDB_CHECK_BASE,
-							     false);
-		ldb_kv->disallow_dn_filter = ldb_msg_find_attr_as_bool(options,
-								     LTDB_DISALLOW_DN_FILTER,
-								     false);
+		ldb_kv->check_base =
+		    ldb_msg_find_attr_as_bool(options, LTDB_CHECK_BASE, false);
+		ldb_kv->disallow_dn_filter = ldb_msg_find_attr_as_bool(
+		    options, LTDB_DISALLOW_DN_FILTER, false);
 	} else {
 		ldb_kv->check_base = false;
 		ldb_kv->disallow_dn_filter = false;
@@ -527,8 +529,8 @@ int ldb_kv_cache_load(struct ldb_module *module)
 		 * Now the attributes are loaded, set the guid_index_syntax.
 		 * This can't fail, it will return a default at worst
 		 */
-		a = ldb_schema_attribute_by_name(ldb,
-						 ldb_kv->cache->GUID_index_attribute);
+		a = ldb_schema_attribute_by_name(
+		    ldb, ldb_kv->cache->GUID_index_attribute);
 		ldb_kv->GUID_index_syntax = a->syntax;
 	}
 
@@ -566,7 +568,8 @@ int ldb_kv_increase_sequence_number(struct ldb_module *module)
 {
 	struct ldb_context *ldb;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	struct ldb_message *msg;
 	struct ldb_message_element el[2];
 	struct ldb_val val;
@@ -583,7 +586,7 @@ int ldb_kv_increase_sequence_number(struct ldb_module *module)
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
-	s = talloc_asprintf(msg, "%llu", ldb_kv->sequence_number+1);
+	s = talloc_asprintf(msg, "%llu", ldb_kv->sequence_number + 1);
 	if (!s) {
 		talloc_free(msg);
 		errno = ENOMEM;
diff --git a/lib/ldb/ldb_tdb/ldb_index.c b/lib/ldb/ldb_tdb/ldb_index.c
index e0a5b62827c..1c3a7a00f09 100644
--- a/lib/ldb/ldb_tdb/ldb_index.c
+++ b/lib/ldb/ldb_tdb/ldb_index.c
@@ -191,7 +191,7 @@ static void ldb_kv_dn_list_sort(struct ldb_kv_private *ldb_kv,
 
 static unsigned ldb_kv_max_key_length(struct ldb_kv_private *ldb_kv)
 {
-	if (ldb_kv->max_key_length == 0){
+	if (ldb_kv->max_key_length == 0) {
 		return UINT_MAX;
 	}
 	return ldb_kv->max_key_length;
@@ -200,7 +200,8 @@ static unsigned ldb_kv_max_key_length(struct ldb_kv_private *ldb_kv)
 /* enable the idxptr mode when transactions start */
 int ldb_kv_index_transaction_start(struct ldb_module *module)
 {
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	ldb_kv->idxptr = talloc_zero(ldb_kv, struct ltdb_idxptr);
 	if (ldb_kv->idxptr == NULL) {
 		return ldb_oom(ldb_module_get_ctx(module));
@@ -294,8 +295,8 @@ static int ldb_kv_dn_list_find_msg(struct ldb_kv_private *ldb_kv,
 		v.data = discard_const_p(unsigned char, dn_str);
 		v.length = strlen(dn_str);
 	} else {
-		key_val = ldb_msg_find_ldb_val(msg,
-					       ldb_kv->cache->GUID_index_attribute);
+		key_val = ldb_msg_find_ldb_val(
+		    msg, ldb_kv->cache->GUID_index_attribute);
 		if (key_val == NULL) {
 			return -1;
 		}
@@ -359,8 +360,7 @@ static int ldb_kv_dn_list_load(struct ldb_module *module,
 	list->count = 0;
 
 	/* see if we have any in-memory index entries */
-	if (ldb_kv->idxptr == NULL ||
-	    ldb_kv->idxptr->itdb == NULL) {
+	if (ldb_kv->idxptr == NULL || ldb_kv->idxptr->itdb == NULL) {
 		goto normal_index;
 	}
 
@@ -513,7 +513,8 @@ int ldb_kv_key_dn_from_idx(struct ldb_module *module,
 				       "against %s for %s: too many "
 				       "values (%u > 1)",
 				       ldb_kv->cache->GUID_index_attribute,
-				       dn_str, list->count);
+				       dn_str,
+				       list->count);
 		TALLOC_FREE(list);
 		return LDB_ERR_CONSTRAINT_VIOLATION;
 	}
@@ -546,7 +547,8 @@ int ldb_kv_key_dn_from_idx(struct ldb_module *module,
 				return ret;
 			}
 
-			ret = ldb_kv_search_key(module, ldb_kv, key, rec, flags);
+			ret =
+			    ldb_kv_search_key(module, ldb_kv, key, rec, flags);
 			if (key.dptr != guid_key) {
 				TALLOC_FREE(key.dptr);
 			}
@@ -704,7 +706,8 @@ static int ldb_kv_dn_list_store(struct ldb_module *module,
 				struct ldb_dn *dn,
 				struct dn_list *list)
 {
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	TDB_DATA rec, key;
 	int ret;
 	struct dn_list *list2;
@@ -714,7 +717,8 @@ static int ldb_kv_dn_list_store(struct ldb_module *module,
 	}
 
 	if (ldb_kv->idxptr->itdb == NULL) {
-		ldb_kv->idxptr->itdb = tdb_open(NULL, 1000, TDB_INTERNAL, O_RDWR, 0);
+		ldb_kv->idxptr->itdb =
+		    tdb_open(NULL, 1000, TDB_INTERNAL, O_RDWR, 0);
 		if (ldb_kv->idxptr->itdb == NULL) {
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
@@ -770,7 +774,8 @@ static int ldb_kv_index_traverse_store(struct tdb_context *tdb,
 				       void *state)
 {
 	struct ldb_module *module = state;
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	struct ldb_dn *dn;
 	struct ldb_context *ldb = ldb_module_get_ctx(module);
 	struct ldb_val v;
@@ -792,7 +797,8 @@ static int ldb_kv_index_traverse_store(struct tdb_context *tdb,
 		return -1;
 	}
 
-	ldb_kv->idxptr->error = ldb_kv_dn_list_store_full(module, ldb_kv, dn, list);
+	ldb_kv->idxptr->error =
+	    ldb_kv_dn_list_store_full(module, ldb_kv, dn, list);
 	talloc_free(dn);
 	if (ldb_kv->idxptr->error != 0) {
 		return -1;
@@ -803,7 +809,8 @@ static int ldb_kv_index_traverse_store(struct tdb_context *tdb,
 /* cleanup the idxptr mode when transaction commits */
 int ldb_kv_index_transaction_commit(struct ldb_module *module)
 {
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	int ret;
 
 	struct ldb_context *ldb = ldb_module_get_ctx(module);
@@ -832,7 +839,8 @@ int ldb_kv_index_transaction_commit(struct ldb_module *module)
 /* cleanup the idxptr mode when transaction cancels */
 int ldb_kv_index_transaction_cancel(struct ldb_module *module)
 {
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	if (ldb_kv->idxptr && ldb_kv->idxptr->itdb) {
 		tdb_close(ldb_kv->idxptr->itdb);
 	}
@@ -1041,8 +1049,7 @@ static bool ldb_kv_is_indexed(struct ldb_module *module,
 	struct ldb_message_element *el;
 
 	if ((ldb_kv->cache->GUID_index_attribute != NULL) &&
-	    (ldb_attr_cmp(attr,
-			  ldb_kv->cache->GUID_index_attribute) == 0)) {
+	    (ldb_attr_cmp(attr, ldb_kv->cache->GUID_index_attribute) == 0)) {
 		/* Implicity covered, this is the index key */
 		return false;
 	}
@@ -1136,10 +1143,10 @@ static int ldb_kv_index_dn_simple(struct ldb_module *module,
 	return ret;
 }
 
-
 static bool list_union(struct ldb_context *ldb,
 		       struct ldb_kv_private *ldb_kv,
-		       struct dn_list *list, struct dn_list *list2);
+		       struct dn_list *list,
+		       struct dn_list *list2);
 
 /*
   return a list of dn's that might match a leaf indexed search
@@ -1205,10 +1212,8 @@ static int ldb_kv_index_dn_leaf(struct ldb_module *module,
 		 * ensure we get the index in binary, rather
 		 * than a string
 		 */
-		ret = ldb_kv->GUID_index_syntax->canonicalise_fn(ldb,
-							       list->dn,
-							       &tree->u.equality.value,
-							       &list->dn[0]);
+		ret = ldb_kv->GUID_index_syntax->canonicalise_fn(
+		    ldb, list->dn, &tree->u.equality.value, &list->dn[0]);
 		if (ret != LDB_SUCCESS) {
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
@@ -1226,7 +1231,8 @@ static int ldb_kv_index_dn_leaf(struct ldb_module *module,
 */
 static bool list_intersect(struct ldb_context *ldb,
 			   struct ldb_kv_private *ldb_kv,
-			   struct dn_list *list, const struct dn_list *list2)
+			   struct dn_list *list,
+			   const struct dn_list *list2)
 {
 	const struct dn_list *short_list, *long_list;
 	struct dn_list *list3;
@@ -1306,7 +1312,8 @@ static bool list_intersect(struct ldb_context *ldb,
 */
 static bool list_union(struct ldb_context *ldb,
 		       struct ldb_kv_private *ldb_kv,
-		       struct dn_list *list, struct dn_list *list2)
+		       struct dn_list *list,
+		       struct dn_list *list2)
 {
 	struct ldb_val *dn3;
 	unsigned int i = 0, j = 0, k = 0;
@@ -1468,7 +1475,8 @@ static bool ldb_kv_index_unique(struct ldb_context *ldb,
 {
 	const struct ldb_schema_attribute *a;
 	if (ldb_kv->cache->GUID_index_attribute != NULL) {
-		if (ldb_attr_cmp(attr, ldb_kv->cache->GUID_index_attribute) == 0) {
+		if (ldb_attr_cmp(attr, ldb_kv->cache->GUID_index_attribute) ==
+		    0) {
 			return true;
 		}
 	}
@@ -1508,7 +1516,8 @@ static int ldb_kv_index_dn_and(struct ldb_module *module,
 		int ret;
 
 		if (subtree->operation != LDB_OP_EQUALITY ||
-		    !ldb_kv_index_unique(ldb, ldb_kv, subtree->u.equality.attr)) {
+		    !ldb_kv_index_unique(
+			ldb, ldb_kv, subtree->u.equality.attr)) {
 			continue;
 		}
 
@@ -1560,8 +1569,7 @@ static int ldb_kv_index_dn_and(struct ldb_module *module,
 			list->dn = list2->dn;
 			list->count = list2->count;
 			found = true;
-		} else if (!list_intersect(ldb, ldb_kv,
-					   list, list2)) {
+		} else if (!list_intersect(ldb, ldb_kv, list, list2)) {
 			talloc_free(list2);
 			return LDB_ERR_OPERATIONS_ERROR;
 		}
@@ -1666,8 +1674,8 @@ static int ldb_kv_index_dn_base_dn(struct ldb_module *module,
 	}
 
 	if (ldb_kv->cache->GUID_index_dn_component != NULL) {
-		guid_val = ldb_dn_get_extended_component(base_dn,
-							 ldb_kv->cache->GUID_index_dn_component);
+		guid_val = ldb_dn_get_extended_component(
+		    base_dn, ldb_kv->cache->GUID_index_dn_component);
 	}
 
 	if (guid_val != NULL) {
@@ -1865,9 +1873,9 @@ static int ldb_kv_index_filter(struct ldb_kv_private *ldb_kv,
 		 *
 		 * LDB_SCOPE_BASE is not passed in by our only caller.
 		 */
-		if (ac->scope == LDB_SCOPE_ONELEVEL
-		    && ldb_kv->cache->one_level_indexes
-		    && scope_one_truncation == KEY_NOT_TRUNCATED) {
+		if (ac->scope == LDB_SCOPE_ONELEVEL &&
+		    ldb_kv->cache->one_level_indexes &&
+		    scope_one_truncation == KEY_NOT_TRUNCATED) {
 			ret = ldb_match_message(ldb, msg, ac->tree,
 						ac->scope, &matched);
 		} else {
@@ -1916,7 +1924,8 @@ static int ldb_kv_index_filter(struct ldb_kv_private *ldb_kv,
 /*
   sort a DN list
  */
-static void ldb_kv_dn_list_sort(struct ldb_kv_private *ltdb, struct dn_list *list)
+static void ldb_kv_dn_list_sort(struct ldb_kv_private *ltdb,
+				struct dn_list *list)
 {
 	if (list->count < 2) {
 		return;
@@ -1939,7 +1948,8 @@ static void ldb_kv_dn_list_sort(struct ldb_kv_private *ltdb, struct dn_list *lis
 int ldb_kv_search_indexed(struct ldb_kv_context *ac, uint32_t *match_count)
 {
 	struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(ac->module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(ac->module), struct ldb_kv_private);
 	struct dn_list *dn_list;
 	int ret;
 	enum ldb_scope index_scope;
@@ -1947,8 +1957,7 @@ int ldb_kv_search_indexed(struct ldb_kv_context *ac, uint32_t *match_count)
 
 	/* see if indexing is enabled */
 	if (!ldb_kv->cache->attribute_indexes &&
-	    !ldb_kv->cache->one_level_indexes &&
-	    ac->scope != LDB_SCOPE_BASE) {
+	    !ldb_kv->cache->one_level_indexes && ac->scope != LDB_SCOPE_BASE) {
 		/* fallback to a full search */
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
@@ -1984,8 +1993,11 @@ int ldb_kv_search_indexed(struct ldb_kv_context *ac, uint32_t *match_count)
 		 * the tree, we must ensure we strictly intersect with
 		 * this list, as we trust the ONELEVEL index
 		 */
-		ret = ldb_kv_index_dn_one(
-		    ac->module, ldb_kv, ac->base, dn_list, &scope_one_truncation);
+		ret = ldb_kv_index_dn_one(ac->module,
+					  ldb_kv,
+					  ac->base,
+					  dn_list,
+					  &scope_one_truncation);
 		if (ret != LDB_SUCCESS) {
 			talloc_free(dn_list);
 			return ret;
@@ -2026,7 +2038,8 @@ int ldb_kv_search_indexed(struct ldb_kv_context *ac, uint32_t *match_count)
 			ret = ldb_kv_index_dn(
 			    ac->module, ldb_kv, ac->tree, idx_one_tree_list);
 			if (ret == LDB_SUCCESS) {
-				if (!list_intersect(ldb, ldb_kv,
+				if (!list_intersect(ldb,
+						    ldb_kv,
 						    dn_list,
 						    idx_one_tree_list)) {
 					talloc_free(idx_one_tree_list);
@@ -2130,12 +2143,12 @@ static int ldb_kv_index_add1(struct ldb_module *module,
 		(el->flags & LDB_FLAG_INTERNAL_FORCE_UNIQUE_INDEX)))) {
 
 		ldb_asprintf_errstring(
-			ldb,
-			__location__ ": unique index key on %s in %s, "
-			"exceeds maximum key length of %u (encoded).",
-			el->name,
-			ldb_dn_get_linearized(msg->dn),
-			ldb_kv->max_key_length);
+		    ldb,
+		    __location__ ": unique index key on %s in %s, "
+				 "exceeds maximum key length of %u (encoded).",
+		    el->name,
+		    ldb_dn_get_linearized(msg->dn),
+		    ldb_kv->max_key_length);
 		talloc_free(list);
 		return LDB_ERR_CONSTRAINT_VIOLATION;
 	}
@@ -2191,7 +2204,8 @@ static int ldb_kv_index_add1(struct ldb_module *module,
 				return ret;
 			}
 
-			ret = ldb_kv_search_key(module, ldb_kv, key, rec, flags);
+			ret =
+			    ldb_kv_search_key(module, ldb_kv, key, rec, flags);
 			if (key.dptr != guid_key) {
 				TALLOC_FREE(key.dptr);
 			}
@@ -2251,15 +2265,15 @@ static int ldb_kv_index_add1(struct ldb_module *module,
 				  ldb_dn_get_linearized(dn_key));
 		} else {
 			/* This can't fail, gives a default at worst */
-			const struct ldb_schema_attribute *attr
-				= ldb_schema_attribute_by_name(
-					ldb,
-					ldb_kv->cache->GUID_index_attribute);
+			const struct ldb_schema_attribute *attr =
+			    ldb_schema_attribute_by_name(
+				ldb, ldb_kv->cache->GUID_index_attribute);
 			struct ldb_val v;
 			ret = attr->syntax->ldif_write_fn(ldb, list,
 							  &list->dn[0], &v);
 			if (ret == LDB_SUCCESS) {
-				ldb_debug(ldb, LDB_DEBUG_WARNING,
+				ldb_debug(ldb,
+					  LDB_DEBUG_WARNING,
 					  __location__
 					  ": unique index violation on %s in "
 					  "%s, conficts with %s %*.*s in %s",
@@ -2302,8 +2316,8 @@ static int ldb_kv_index_add1(struct ldb_module *module,
 	} else {
 		const struct ldb_val *key_val;
 		struct ldb_val *exact = NULL, *next = NULL;
-		key_val = ldb_msg_find_ldb_val(msg,
-					       ldb_kv->cache->GUID_index_attribute);
+		key_val = ldb_msg_find_ldb_val(
+		    msg, ldb_kv->cache->GUID_index_attribute);
 		if (key_val == NULL) {
 			talloc_free(list);
 			return ldb_module_operr(module);
@@ -2326,15 +2340,15 @@ static int ldb_kv_index_add1(struct ldb_module *module,
 		 */
 		if (exact != NULL && truncation == KEY_NOT_TRUNCATED) {
 			/* This can't fail, gives a default at worst */
-			const struct ldb_schema_attribute *attr
-				= ldb_schema_attribute_by_name(
-					ldb,
-					ldb_kv->cache->GUID_index_attribute);
+			const struct ldb_schema_attribute *attr =
+			    ldb_schema_attribute_by_name(
+				ldb, ldb_kv->cache->GUID_index_attribute);
 			struct ldb_val v;
 			ret = attr->syntax->ldif_write_fn(ldb, list,
 							  exact, &v);
 			if (ret == LDB_SUCCESS) {
-				ldb_debug(ldb, LDB_DEBUG_WARNING,
+				ldb_debug(ldb,
+					  LDB_DEBUG_WARNING,
 					  __location__
 					  ": duplicate attribute value in %s "
 					  "for index on %s, "
@@ -2457,10 +2471,9 @@ static int ldb_kv_modify_index_dn(struct ldb_module *module,
 	if (val.data == NULL) {
 		const char *dn_str = ldb_dn_get_linearized(dn);
 		ldb_asprintf_errstring(ldb_module_get_ctx(module),
-				       __location__
-				       ": Failed to modify %s "
-				       "against %s in %s: failed "
-				       "to get casefold DN",
+				       __location__ ": Failed to modify %s "
+						    "against %s in %s: failed "
+						    "to get casefold DN",
 				       index,
 				       ldb_kv->cache->GUID_index_attribute,
 				       dn_str);
@@ -2482,12 +2495,12 @@ static int ldb_kv_modify_index_dn(struct ldb_module *module,
 		struct ldb_context *ldb = ldb_module_get_ctx(module);
 		const char *dn_str = ldb_dn_get_linearized(dn);
 		ldb_asprintf_errstring(ldb,
-				       __location__
-				       ": Failed to modify %s "
-				       "against %s in %s - %s",
+				       __location__ ": Failed to modify %s "
+						    "against %s in %s - %s",
 				       index,
 				       ldb_kv->cache->GUID_index_attribute,
-				       dn_str, ldb_errstring(ldb));
+				       dn_str,
+				       ldb_errstring(ldb));
 		return ret;
 	}
 	return ret;
@@ -2500,8 +2513,8 @@ static int ldb_kv_index_onelevel(struct ldb_module *module,
 				 const struct ldb_message *msg,
 				 int add)
 {
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module),
-						    struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	struct ldb_dn *pdn;
 	int ret;
 
@@ -2514,7 +2527,8 @@ static int ldb_kv_index_onelevel(struct ldb_module *module,
 	if (pdn == NULL) {
 		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	ret = ldb_kv_modify_index_dn(module, ldb_kv, msg, pdn, LTDB_IDXONE, add);
+	ret =
+	    ldb_kv_modify_index_dn(module, ldb_kv, msg, pdn, LTDB_IDXONE, add);
 
 	talloc_free(pdn);
 
@@ -2529,16 +2543,16 @@ static int ldb_kv_write_index_dn_guid(struct ldb_module *module,
 				      int add)
 {
 	int ret;
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module),
-						    struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 
 	/* We index for DN only if using a GUID index */
 	if (ldb_kv->cache->GUID_index_attribute == NULL) {
 		return LDB_SUCCESS;
 	}
 
-	ret =
-	    ldb_kv_modify_index_dn(module, ldb_kv, msg, msg->dn, LTDB_IDXDN, add);
+	ret = ldb_kv_modify_index_dn(
+	    module, ldb_kv, msg, msg->dn, LTDB_IDXDN, add);
 
 	if (ret == LDB_ERR_CONSTRAINT_VIOLATION) {
 		ldb_asprintf_errstring(ldb_module_get_ctx(module),
@@ -2744,7 +2758,8 @@ int ldb_kv_index_del_element(struct ldb_module *module,
 int ldb_kv_index_delete(struct ldb_module *module,
 			const struct ldb_message *msg)
 {
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	int ret;
 	unsigned int i;
 
@@ -2787,7 +2802,10 @@ int ldb_kv_index_delete(struct ldb_module *module,
   commit, which in turn greatly reduces DB churn as we will likely
   be able to do a direct update into the old record.
 */
-static int delete_index(struct ldb_kv_private *ldb_kv, struct ldb_val key, struct ldb_val data, void *state)
+static int delete_index(struct ldb_kv_private *ldb_kv,
+			struct ldb_val key,
+			struct ldb_val data,
+			void *state)
 {
 	struct ldb_module *module = state;
 	const char *dnstr = "DN=" LTDB_INDEX ":";
@@ -2829,7 +2847,10 @@ static int delete_index(struct ldb_kv_private *ldb_kv, struct ldb_val key, struc
 /*
   traversal function that adds @INDEX records during a re index TODO wrong comment
 */
-static int re_key(struct ldb_kv_private *ldb_kv, struct ldb_val ldb_key, struct ldb_val val, void *state)
+static int re_key(struct ldb_kv_private *ldb_kv,
+		  struct ldb_val ldb_key,
+		  struct ldb_val val,
+		  void *state)
 {
 	struct ldb_context *ldb;
 	struct ldb_kv_reindex_context *ctx =
@@ -2902,7 +2923,8 @@ static int re_key(struct ldb_kv_private *ldb_kv, struct ldb_val ldb_key, struct
 			.data = key2.dptr,
 			.length = key2.dsize
 		};
-		ldb_kv->kv_ops->update_in_iterate(ldb_kv, ldb_key, ldb_key2, val, ctx);
+		ldb_kv->kv_ops->update_in_iterate(
+		    ldb_kv, ldb_key, ldb_key2, val, ctx);
 	}
 	talloc_free(key2.dptr);
 
@@ -2921,7 +2943,10 @@ static int re_key(struct ldb_kv_private *ldb_kv, struct ldb_val ldb_key, struct
 /*
   traversal function that adds @INDEX records during a re index
 */
-static int re_index(struct ldb_kv_private *ldb_kv, struct ldb_val ldb_key, struct ldb_val val, void *state)
+static int re_index(struct ldb_kv_private *ldb_kv,
+		    struct ldb_val ldb_key,
+		    struct ldb_val val,
+		    void *state)
 {
 	struct ldb_context *ldb;
 	struct ldb_kv_reindex_context *ctx =
@@ -3010,7 +3035,8 @@ static int re_index(struct ldb_kv_private *ldb_kv, struct ldb_val ldb_key, struc
 */
 int ldb_kv_reindex(struct ldb_module *module)
 {
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 	int ret;
 	struct ldb_kv_reindex_context ctx;
 
@@ -3087,7 +3113,8 @@ int ldb_kv_reindex(struct ldb_module *module)
 
 	if (ctx.count > 10000) {
 		ldb_debug(ldb_module_get_ctx(module),
-			  LDB_DEBUG_WARNING, "Reindexing: re_index successful on %s, "
+			  LDB_DEBUG_WARNING,
+			  "Reindexing: re_index successful on %s, "
 			  "final index write-out will be in transaction commit",
 			  ldb_kv->kv_ops->name(ldb_kv));
 	}
diff --git a/lib/ldb/ldb_tdb/ldb_search.c b/lib/ldb/ldb_tdb/ldb_search.c
index fd8b64ef1b7..b3eafeb7533 100644
--- a/lib/ldb/ldb_tdb/ldb_search.c
+++ b/lib/ldb/ldb_tdb/ldb_search.c
@@ -289,7 +289,8 @@ int ldb_kv_search_dn1(struct ldb_module *module,
 		      unsigned int unpack_flags)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	int ret;
 	uint8_t guid_key[LTDB_GUID_KEY_SIZE];
 	TDB_DATA tdb_key = {
@@ -299,7 +300,7 @@ int ldb_kv_search_dn1(struct ldb_module *module,
 	TALLOC_CTX *tdb_key_ctx = NULL;
 
 	if (ldb_kv->cache->GUID_index_attribute == NULL ||
-		ldb_dn_is_special(dn)) {
+	    ldb_dn_is_special(dn)) {
 
 		tdb_key_ctx = talloc_new(msg);
 		if (!tdb_key_ctx) {
@@ -493,7 +494,10 @@ failed:
 /*
   search function for a non-indexed search
  */
-static int search_func(struct ldb_kv_private *ldb_kv, struct ldb_val key, struct ldb_val val, void *state)
+static int search_func(struct ldb_kv_private *ldb_kv,
+		       struct ldb_val key,
+		       struct ldb_val val,
+		       void *state)
 {
 	struct ldb_context *ldb;
 	struct ldb_kv_context *ac;
@@ -583,7 +587,8 @@ static int search_func(struct ldb_kv_private *ldb_kv, struct ldb_val key, struct
 static int ldb_kv_search_full(struct ldb_kv_context *ctx)
 {
 	void *data = ldb_module_get_private(ctx->module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	int ret;
 
 	ctx->error = LDB_SUCCESS;
@@ -708,7 +713,8 @@ int ldb_kv_search(struct ldb_kv_context *ctx)
 	struct ldb_module *module = ctx->module;
 	struct ldb_request *req = ctx->req;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	int ret;
 
 	ldb = ldb_module_get_ctx(module);
@@ -811,7 +817,8 @@ int ldb_kv_search(struct ldb_kv_context *ctx)
 		 * callback error */
 		if ( ! ctx->request_terminated && ret != LDB_SUCCESS) {
 			/* Not indexed, so we need to do a full scan */
-			if (ldb_kv->warn_unindexed || ldb_kv->disable_full_db_scan) {
+			if (ldb_kv->warn_unindexed ||
+			    ldb_kv->disable_full_db_scan) {
 				/* useful for debugging when slow performance
 				 * is caused by unindexed searches */
 				char *expression = ldb_filter_from_tree(ctx, ctx->tree);
diff --git a/lib/ldb/ldb_tdb/ldb_tdb.c b/lib/ldb/ldb_tdb/ldb_tdb.c
index c1f5fa3488e..b963123bfda 100644
--- a/lib/ldb/ldb_tdb/ldb_tdb.c
+++ b/lib/ldb/ldb_tdb/ldb_tdb.c
@@ -97,18 +97,19 @@ int ltdb_err_map(enum TDB_ERROR tdb_code)
 static int ltdb_lock_read(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	int tdb_ret = 0;
 	int ret;
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -138,19 +139,21 @@ static int ltdb_lock_read(struct ldb_module *module)
 static int ltdb_unlock_read(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
-	if (!tdb_transaction_active(ldb_kv->tdb) && ldb_kv->read_lock_count == 1) {
+	if (!tdb_transaction_active(ldb_kv->tdb) &&
+	    ldb_kv->read_lock_count == 1) {
 		tdb_unlockall_read(ldb_kv->tdb);
 		ldb_kv->read_lock_count--;
 		return 0;
@@ -310,7 +313,8 @@ TDB_DATA ldb_kv_key_msg(struct ldb_module *module,
 			const struct ldb_message *msg)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	TDB_DATA key;
 	const struct ldb_val *guid_val;
 	int ret;
@@ -323,8 +327,8 @@ TDB_DATA ldb_kv_key_msg(struct ldb_module *module,
 		return ldb_kv_key_dn(module, mem_ctx, msg->dn);
 	}
 
-	guid_val = ldb_msg_find_ldb_val(msg,
-				       ldb_kv->cache->GUID_index_attribute);
+	guid_val =
+	    ldb_msg_find_ldb_val(msg, ldb_kv->cache->GUID_index_attribute);
 	if (guid_val == NULL) {
 		ldb_asprintf_errstring(ldb_module_get_ctx(module),
 				       "Did not find GUID attribute %s "
@@ -399,7 +403,8 @@ static int ldb_kv_check_special_dn(struct ldb_module *module,
 static int ldb_kv_modified(struct ldb_module *module, struct ldb_dn *dn)
 {
 	int ret = LDB_SUCCESS;
-	struct ldb_kv_private *ldb_kv = talloc_get_type(ldb_module_get_private(module), struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv = talloc_get_type(
+	    ldb_module_get_private(module), struct ldb_kv_private);
 
 	/* only allow modifies inside a transaction, otherwise the
 	 * ldb is unsafe */
@@ -414,8 +419,10 @@ static int ldb_kv_modified(struct ldb_module *module, struct ldb_dn *dn)
 	{
 		if (ldb_kv->warn_reindex) {
 			ldb_debug(ldb_module_get_ctx(module),
-				LDB_DEBUG_ERROR, "Reindexing %s due to modification on %s",
-				ldb_kv->kv_ops->name(ldb_kv), ldb_dn_get_linearized(dn));
+				  LDB_DEBUG_ERROR,
+				  "Reindexing %s due to modification on %s",
+				  ldb_kv->kv_ops->name(ldb_kv),
+				  ldb_dn_get_linearized(dn));
 		}
 		ret = ldb_kv_reindex(module);
 	}
@@ -479,7 +486,8 @@ int ldb_kv_store(struct ldb_module *module,
 		 int flgs)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	TDB_DATA tdb_key;
 	struct ldb_val ldb_key;
 	struct ldb_val ldb_data;
@@ -520,9 +528,8 @@ int ldb_kv_store(struct ldb_module *module,
 		 * LDB_ERR_ENTRY_ALREADY_EXISTS means the DN, not
 		 * the GUID, so re-map
 		 */
-		if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS
-		    && !is_special
-		    && ldb_kv->cache->GUID_index_attribute != NULL) {
+		if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS && !is_special &&
+		    ldb_kv->cache->GUID_index_attribute != NULL) {
 			ret = LDB_ERR_CONSTRAINT_VIOLATION;
 		}
 		goto done;
@@ -676,13 +683,13 @@ static int ldb_kv_add(struct ldb_kv_context *ctx)
 	struct ldb_module *module = ctx->module;
 	struct ldb_request *req = ctx->req;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	int ret = LDB_SUCCESS;
 
 	if (ldb_kv->max_key_length != 0 &&
 	    ldb_kv->cache->GUID_index_attribute == NULL &&
-	    !ldb_dn_is_special(req->op.add.message->dn))
-	{
+	    !ldb_dn_is_special(req->op.add.message->dn)) {
 		ldb_set_errstring(ldb_module_get_ctx(module),
 				  "Must operate ldb_mdb in GUID "
 				  "index mode, but " LTDB_IDXGUID " not set.");
@@ -726,7 +733,8 @@ int ldb_kv_delete_noindex(struct ldb_module *module,
 			  const struct ldb_message *msg)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	struct ldb_val ldb_key;
 	TDB_DATA tdb_key;
 	int ret;
@@ -750,7 +758,7 @@ int ldb_kv_delete_noindex(struct ldb_module *module,
 	ldb_key.data = tdb_key.dptr;
 	ldb_key.length = tdb_key.dsize;
 
-	ret = ldb_kv->kv_ops->delete(ldb_kv, ldb_key);
+	ret = ldb_kv->kv_ops->delete (ldb_kv, ldb_key);
 	TALLOC_FREE(tdb_key_ctx);
 
 	if (ret != 0) {
@@ -899,11 +907,11 @@ static int ldb_kv_msg_delete_attribute(struct ldb_module *module,
 	struct ldb_message_element *el;
 	bool is_special = ldb_dn_is_special(msg->dn);
 
-	if (!is_special
-	    && ldb_kv->cache->GUID_index_attribute != NULL
-	    && ldb_attr_cmp(name, ldb_kv->cache->GUID_index_attribute) == 0) {
+	if (!is_special && ldb_kv->cache->GUID_index_attribute != NULL &&
+	    ldb_attr_cmp(name, ldb_kv->cache->GUID_index_attribute) == 0) {
 		struct ldb_context *ldb = ldb_module_get_ctx(module);
-		ldb_asprintf_errstring(ldb, "Must not modify GUID "
+		ldb_asprintf_errstring(ldb,
+				       "Must not modify GUID "
 				       "attribute %s (used as DB index)",
 				       ldb_kv->cache->GUID_index_attribute);
 		return LDB_ERR_CONSTRAINT_VIOLATION;
@@ -974,7 +982,8 @@ static int ldb_kv_msg_delete_element(struct ldb_module *module,
 				    module, ldb_kv, msg, name);
 			}
 
-			ret = ldb_kv_index_del_value(module, ldb_kv, msg, el, i);
+			ret =
+			    ldb_kv_index_del_value(module, ldb_kv, msg, el, i);
 			if (ret != LDB_SUCCESS) {
 				return ret;
 			}
@@ -1011,7 +1020,8 @@ int ldb_kv_modify_internal(struct ldb_module *module,
 {
 	struct ldb_context *ldb = ldb_module_get_ctx(module);
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	struct ldb_message *msg2;
 	unsigned int i, j;
 	int ret = LDB_SUCCESS, idx;
@@ -1255,7 +1265,8 @@ int ldb_kv_modify_internal(struct ldb_module *module,
 				goto done;
 			}
 
-			ret = ldb_kv_index_add_element(module, ldb_kv, msg2, el);
+			ret =
+			    ldb_kv_index_add_element(module, ldb_kv, msg2, el);
 			if (ret != LDB_SUCCESS) {
 				goto done;
 			}
@@ -1272,7 +1283,10 @@ int ldb_kv_modify_internal(struct ldb_module *module,
 			if (msg->elements[i].num_values == 0) {
 				/* Delete the whole attribute */
 				ret = ldb_kv_msg_delete_attribute(
-				    module, ldb_kv, msg2, msg->elements[i].name);
+				    module,
+				    ldb_kv,
+				    msg2,
+				    msg->elements[i].name);
 				if (ret == LDB_ERR_NO_SUCH_ATTRIBUTE &&
 				    control_permissive) {
 					ret = LDB_SUCCESS;
@@ -1364,7 +1378,8 @@ static int ldb_kv_rename(struct ldb_kv_context *ctx)
 {
 	struct ldb_module *module = ctx->module;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	struct ldb_request *req = ctx->req;
 	struct ldb_message *msg;
 	int ret = LDB_SUCCESS;
@@ -1476,12 +1491,12 @@ static int ltdb_transaction_start(struct ldb_kv_private *ldb_kv)
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(ldb_kv->module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -1493,12 +1508,12 @@ static int ltdb_transaction_cancel(struct ldb_kv_private *ldb_kv)
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(ldb_kv->module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -1510,12 +1525,12 @@ static int ltdb_transaction_prepare_commit(struct ldb_kv_private *ldb_kv)
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(ldb_kv->module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -1527,12 +1542,12 @@ static int ltdb_transaction_commit(struct ldb_kv_private *ldb_kv)
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(ldb_kv->module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -1542,17 +1557,18 @@ static int ltdb_transaction_commit(struct ldb_kv_private *ldb_kv)
 static int ldb_kv_start_trans(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(ldb_kv->module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(ldb_kv->module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -1582,16 +1598,17 @@ static int ldb_kv_prepare_commit(struct ldb_module *module)
 {
 	int ret;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	pid_t pid = getpid();
 
 	if (ldb_kv->pid != pid) {
-		ldb_asprintf_errstring(
-			ldb_module_get_ctx(module),
-			__location__": Reusing ldb opend by pid %d in "
-			"process %d\n",
-			ldb_kv->pid,
-			pid);
+		ldb_asprintf_errstring(ldb_module_get_ctx(module),
+				       __location__
+				       ": Reusing ldb opend by pid %d in "
+				       "process %d\n",
+				       ldb_kv->pid,
+				       pid);
 		return LDB_ERR_PROTOCOL_ERROR;
 	}
 
@@ -1646,7 +1663,8 @@ static int ldb_kv_end_trans(struct ldb_module *module)
 {
 	int ret;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 
 	if (!ldb_kv->prepared_commit) {
 		ret = ldb_kv_prepare_commit(module);
@@ -1659,10 +1677,11 @@ static int ldb_kv_end_trans(struct ldb_module *module)
 
 	if (ldb_kv->kv_ops->finish_write(ldb_kv) != 0) {
 		ret = ldb_kv->kv_ops->error(ldb_kv);
-		ldb_asprintf_errstring(ldb_module_get_ctx(module),
-				       "Failure during tdb_transaction_commit(): %s -> %s",
-				       ldb_kv->kv_ops->errorstr(ldb_kv),
-				       ldb_strerror(ret));
+		ldb_asprintf_errstring(
+		    ldb_module_get_ctx(module),
+		    "Failure during tdb_transaction_commit(): %s -> %s",
+		    ldb_kv->kv_ops->errorstr(ldb_kv),
+		    ldb_strerror(ret));
 		return ret;
 	}
 
@@ -1672,7 +1691,8 @@ static int ldb_kv_end_trans(struct ldb_module *module)
 static int ldb_kv_del_trans(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 
 	if (ldb_kv_index_transaction_cancel(module) != 0) {
 		ldb_kv->kv_ops->abort_write(ldb_kv);
@@ -1693,7 +1713,8 @@ static int ldb_kv_sequence_number(struct ldb_kv_context *ctx,
 	struct ldb_module *module = ctx->module;
 	struct ldb_request *req = ctx->req;
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	TALLOC_CTX *tmp_ctx = NULL;
 	struct ldb_seqnum_request *seq;
 	struct ldb_seqnum_result *res;
@@ -1903,10 +1924,7 @@ static int ltdb_traverse_fn(struct ldb_kv_private *ldb_kv,
 			    void *ctx)
 {
 	struct kv_ctx kv_ctx = {
-		.kv_traverse_fn = fn,
-		.ctx = ctx,
-		.ldb_kv = ldb_kv
-	};
+	    .kv_traverse_fn = fn, .ctx = ctx, .ldb_kv = ldb_kv};
 	if (tdb_transaction_active(ldb_kv->tdb)) {
 		return tdb_traverse(
 		    ldb_kv->tdb, ltdb_traverse_fn_wrapper, &kv_ctx);
@@ -1944,12 +1962,15 @@ static int ltdb_update_in_iterate(struct ldb_kv_private *ldb_kv,
 
 	tdb_ret = tdb_delete(ldb_kv->tdb, key);
 	if (tdb_ret != 0) {
-		ldb_debug(ldb, LDB_DEBUG_ERROR,
+		ldb_debug(ldb,
+			  LDB_DEBUG_ERROR,
 			  "Failed to delete %*.*s "
 			  "for rekey as %*.*s: %s",
-			  (int)key.dsize, (int)key.dsize,
+			  (int)key.dsize,
+			  (int)key.dsize,
 			  (const char *)key.dptr,
-			  (int)key2.dsize, (int)key2.dsize,
+			  (int)key2.dsize,
+			  (int)key2.dsize,
 			  (const char *)key.dptr,
 			  tdb_errorstr(ldb_kv->tdb));
 		ctx->error = ltdb_err_map(tdb_error(ldb_kv->tdb));
@@ -1957,11 +1978,14 @@ static int ltdb_update_in_iterate(struct ldb_kv_private *ldb_kv,
 	}
 	tdb_ret = tdb_store(ldb_kv->tdb, key2, data, 0);
 	if (tdb_ret != 0) {
-		ldb_debug(ldb, LDB_DEBUG_ERROR,
+		ldb_debug(ldb,
+			  LDB_DEBUG_ERROR,
 			  "Failed to rekey %*.*s as %*.*s: %s",
-			  (int)key.dsize, (int)key.dsize,
+			  (int)key.dsize,
+			  (int)key.dsize,
 			  (const char *)key.dptr,
-			  (int)key2.dsize, (int)key2.dsize,
+			  (int)key2.dsize,
+			  (int)key2.dsize,
 			  (const char *)key.dptr,
 			  tdb_errorstr(ldb_kv->tdb));
 		ctx->error = ltdb_err_map(tdb_error(ldb_kv->tdb));
@@ -1994,11 +2018,7 @@ static int ltdb_parse_record(struct ldb_kv_private *ldb_kv,
 					   void *private_data),
 			     void *ctx)
 {
-	struct kv_ctx kv_ctx = {
-		.parser = parser,
-		.ctx = ctx,
-		.ldb_kv = ldb_kv
-	};
+	struct kv_ctx kv_ctx = {.parser = parser, .ctx = ctx, .ldb_kv = ldb_kv};
 	TDB_DATA key = {
 		.dptr = ldb_key.data,
 		.dsize = ldb_key.length
@@ -2209,14 +2229,16 @@ static int ldb_kv_init_rootdse(struct ldb_module *module)
 static int ldb_kv_lock_read(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	return ldb_kv->kv_ops->lock_read(module);
 }
 
 static int ldb_kv_unlock_read(struct ldb_module *module)
 {
 	void *data = ldb_module_get_private(module);
-	struct ldb_kv_private *ldb_kv = talloc_get_type(data, struct ldb_kv_private);
+	struct ldb_kv_private *ldb_kv =
+	    talloc_get_type(data, struct ldb_kv_private);
 	return ldb_kv->kv_ops->unlock_read(module);
 }
 
@@ -2385,9 +2407,13 @@ int ltdb_connect(struct ldb_context *ldb, const char *url,
 
 	errno = 0;
 	/* note that we use quite a large default hash size */
-	ldb_kv->tdb = ltdb_wrap_open(ldb_kv, path, 10000,
-				   tdb_flags, open_flags,
-				   ldb_get_create_perms(ldb), ldb);
+	ldb_kv->tdb = ltdb_wrap_open(ldb_kv,
+				     path,
+				     10000,
+				     tdb_flags,
+				     open_flags,
+				     ldb_get_create_perms(ldb),
+				     ldb);
 	if (!ldb_kv->tdb) {
 		ldb_asprintf_errstring(ldb,
 				       "Unable to open tdb '%s': %s", path, strerror(errno));
diff --git a/lib/ldb/ldb_tdb/ldb_tdb.h b/lib/ldb/ldb_tdb/ldb_tdb.h
index 930405d0f63..ae9ce1fc6ee 100644
--- a/lib/ldb/ldb_tdb/ldb_tdb.h
+++ b/lib/ldb/ldb_tdb/ldb_tdb.h
@@ -6,19 +6,30 @@
 
 struct ldb_kv_private;
 typedef int (*ldb_kv_traverse_fn)(struct ldb_kv_private *ldb_kv,
-				  struct ldb_val key, struct ldb_val data,
+				  struct ldb_val key,
+				  struct ldb_val data,
 				  void *ctx);
 
 struct kv_db_ops {
-	int (*store)(struct ldb_kv_private *ldb_kv, struct ldb_val key, struct ldb_val data, int flags);
+	int (*store)(struct ldb_kv_private *ldb_kv,
+		     struct ldb_val key,
+		     struct ldb_val data,
+		     int flags);
 	int (*delete)(struct ldb_kv_private *ldb_kv, struct ldb_val key);
-	int (*iterate)(struct ldb_kv_private *ldb_kv, ldb_kv_traverse_fn fn, void *ctx);
-	int (*update_in_iterate)(struct ldb_kv_private *ldb_kv, struct ldb_val key,
-				 struct ldb_val key2, struct ldb_val data, void *ctx);
-	int (*fetch_and_parse)(struct ldb_kv_private *ldb_kv, struct ldb_val key,
-                               int (*parser)(struct ldb_val key, struct ldb_val data,
-                                             void *private_data),
-                               void *ctx);
+	int (*iterate)(struct ldb_kv_private *ldb_kv,
+		       ldb_kv_traverse_fn fn,
+		       void *ctx);
+	int (*update_in_iterate)(struct ldb_kv_private *ldb_kv,
+				 struct ldb_val key,
+				 struct ldb_val key2,
+				 struct ldb_val data,
+				 void *ctx);
+	int (*fetch_and_parse)(struct ldb_kv_private *ldb_kv,
+			       struct ldb_val key,
+			       int (*parser)(struct ldb_val key,
+					     struct ldb_val data,
+					     void *private_data),
+			       void *ctx);
 	int (*lock_read)(struct ldb_module *);
 	int (*unlock_read)(struct ldb_module *);
 	int (*begin_write)(struct ldb_kv_private *);
@@ -26,8 +37,8 @@ struct kv_db_ops {
 	int (*abort_write)(struct ldb_kv_private *);
 	int (*finish_write)(struct ldb_kv_private *);
 	int (*error)(struct ldb_kv_private *ldb_kv);
-	const char * (*errorstr)(struct ldb_kv_private *ldb_kv);
-	const char * (*name)(struct ldb_kv_private *ldb_kv);
+	const char *(*errorstr)(struct ldb_kv_private *ldb_kv);
+	const char *(*name)(struct ldb_kv_private *ldb_kv);
 	bool (*has_changed)(struct ldb_kv_private *ldb_kv);
 	bool (*transaction_active)(struct ldb_kv_private *ldb_kv);
 };
diff --git a/lib/ldb/tests/ldb_kv_ops_test.c b/lib/ldb/tests/ldb_kv_ops_test.c
index 74aaf03fde2..36ea3bf45d5 100644
--- a/lib/ldb/tests/ldb_kv_ops_test.c
+++ b/lib/ldb/tests/ldb_kv_ops_test.c
@@ -390,7 +390,7 @@ static void test_delete(void **state)
 	/*
 	 * Now delete it.
 	 */
-	ret = ldb_kv->kv_ops->delete(ldb_kv, key);
+	ret = ldb_kv->kv_ops->delete (ldb_kv, key);
 	assert_int_equal(ret, 0);
 
 	/*
@@ -551,7 +551,7 @@ static void test_transaction_abort_delete(void **state)
 	/*
 	 * Now delete it.
 	 */
-	ret = ldb_kv->kv_ops->delete(ldb_kv, key);
+	ret = ldb_kv->kv_ops->delete (ldb_kv, key);
 	assert_int_equal(ret, 0);
 
 	/*
@@ -680,7 +680,7 @@ static void test_delete_outside_transaction(void **state)
 	/*
 	 * Now attempt to delete a record
 	 */
-	ret = ldb_kv->kv_ops->delete(ldb_kv, key);
+	ret = ldb_kv->kv_ops->delete (ldb_kv, key);
 	assert_int_equal(ret, LDB_ERR_PROTOCOL_ERROR);
 
 	/*
@@ -701,7 +701,8 @@ static void test_delete_outside_transaction(void **state)
 static int traverse_fn(struct ldb_kv_private *ldb_kv,
 		       struct ldb_val key,
 		       struct ldb_val data,
-		       void *ctx) {
+		       void *ctx)
+{
 
 	int *visits = ctx;
 	int i;
@@ -792,7 +793,8 @@ struct update_context {
 static int update_fn(struct ldb_kv_private *ldb_kv,
 		     struct ldb_val key,
 		     struct ldb_val data,
-		     void *ctx) {
+		     void *ctx)
+{
 
 	struct ldb_val new_key;
 	struct ldb_module *module = NULL;
@@ -815,11 +817,8 @@ static int update_fn(struct ldb_kv_private *ldb_kv,
 		new_key.length  = key.length;
 		new_key.data[0] = 'K';
 
-		ret = ldb_kv->kv_ops->update_in_iterate(ldb_kv,
-						      key,
-						      new_key,
-						      data,
-						      &module);
+		ret = ldb_kv->kv_ops->update_in_iterate(
+		    ldb_kv, key, new_key, data, &module);
 	}
 	TALLOC_FREE(tmp_ctx);
 	return ret;
@@ -1484,7 +1483,7 @@ static void test_delete_transaction_isolation(void **state)
 	key.data = (uint8_t *)talloc_strdup(tmp_ctx, KEY2);
 	key.length = strlen(KEY2) + 1;
 
-	ret = ldb_kv->kv_ops->delete(ldb_kv, key);
+	ret = ldb_kv->kv_ops->delete (ldb_kv, key);
 	assert_int_equal(ret, 0);
 	/*
 	 * Signal the child process