ldb: controls marshalling/unmarshalling improvement

Add a function to marshall a control to a string
Refactor the code of ldb_control_parse_strings to allow to extract the
core code into ldb_control_parse_from_string so that this function can
be called for just 1 string

4 files changed, 930 insertions, 623 deletions

diff --git a/source4/lib/ldb/ABI/ldb-1.0.2.sigs b/source4/lib/ldb/ABI/ldb-1.0.2.sigs
new file mode 100644
index 0000000000..c13ac873d2
--- /dev/null
+++ b/source4/lib/ldb/ABI/ldb-1.0.2.sigs
@@ -0,0 +1,250 @@
+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_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_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_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_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_new: struct ldb_handle *(TALLOC_CTX *, struct ldb_context *)
+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_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
+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_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_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_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_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_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_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_find: const char *(struct ldb_context *, const char **, const char *)
+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_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_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_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_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_remove: void (struct ldb_context *, const char *)
+ldb_schema_attribute_set_override_handler: void (struct ldb_context *, ldb_attribute_handler_override_fn_t, void *)
+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_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_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_to_time: int (const struct ldb_val *, time_t *)
+ldb_valid_attr_name: int (const char *)
+ldb_wait: int (struct ldb_handle *, enum ldb_wait_type)
diff --git a/source4/lib/ldb/common/ldb_controls.c b/source4/lib/ldb/common/ldb_controls.c
index f3770b0526..8c72250abf 100644
--- a/source4/lib/ldb/common/ldb_controls.c
+++ b/source4/lib/ldb/common/ldb_controls.c
@@ -257,6 +257,120 @@ int ldb_request_replace_control(struct ldb_request *req, const char *oid, bool c
 }
 
 /*
+ * Return a control as string
+ * the project (ie. name:value1:value2:...:valuen
+ * The string didn't include the criticity of the critical flag
+ */
+char *ldb_control_to_string(TALLOC_CTX *mem_ctx, const struct ldb_control *control)
+{
+	char *res = NULL;
+
+	if (strcmp(control->oid, LDB_CONTROL_PAGED_RESULTS_OID) == 0) {
+		struct ldb_paged_control *rep_control = talloc_get_type(control->data, struct ldb_paged_control);
+		char *cookie;
+
+		cookie = ldb_base64_encode(mem_ctx, rep_control->cookie, rep_control->cookie_len);
+		if (cookie == NULL) {
+			return NULL;
+		}
+		if (cookie[0] != '\0') {
+			res = talloc_asprintf(mem_ctx, "%s:%d:%s",
+						LDB_CONTROL_PAGED_RESULTS_NAME,
+						control->critical,
+						cookie);
+
+			talloc_free(cookie);
+		} else {
+			res = talloc_asprintf(mem_ctx, "%s:%d",
+						LDB_CONTROL_PAGED_RESULTS_NAME,
+						control->critical);
+		}
+		return res;
+	}
+
+	if (strcmp(control->oid, LDB_CONTROL_VLV_RESP_OID) == 0) {
+		struct ldb_vlv_resp_control *rep_control = talloc_get_type(control->data,
+								struct ldb_vlv_resp_control);
+
+		res = talloc_asprintf(mem_ctx, "%s:%d:%d:%d:%d:%d:%s",
+						LDB_CONTROL_VLV_RESP_NAME,
+						control->critical,
+						rep_control->targetPosition,
+						rep_control->contentCount,
+						rep_control->vlv_result,
+						rep_control->ctxid_len,
+						rep_control->contextId);
+
+		return res;
+	}
+
+	if (strcmp(control->oid, LDB_CONTROL_SORT_RESP_OID) == 0) {
+		struct ldb_sort_resp_control *rep_control = talloc_get_type(control->data,
+								struct ldb_sort_resp_control);
+
+		res = talloc_asprintf(mem_ctx, "%s:%d:%d:%s",
+					LDB_CONTROL_SORT_RESP_NAME,
+					control->critical,
+					rep_control->result,
+					rep_control->attr_desc);
+
+		return res;
+	}
+
+	if (strcmp(control->oid, LDB_CONTROL_ASQ_OID) == 0) {
+		struct ldb_asq_control *rep_control = talloc_get_type(control->data,
+								struct ldb_asq_control);
+
+		res = talloc_asprintf(mem_ctx, "%s:%d:%d",
+					LDB_CONTROL_SORT_RESP_NAME,
+					control->critical,
+					rep_control->result);
+
+		return res;
+	}
+
+	if (strcmp(control->oid, LDB_CONTROL_DIRSYNC_OID) == 0) {
+		char *cookie;
+		struct ldb_dirsync_control *rep_control = talloc_get_type(control->data,
+								struct ldb_dirsync_control);
+
+		cookie = ldb_base64_encode(mem_ctx, rep_control->cookie,
+				rep_control->cookie_len);
+		if (cookie == NULL) {
+			return NULL;
+		}
+		res = talloc_asprintf(mem_ctx, "%s:%d:%d:%d:%s",
+					LDB_CONTROL_DIRSYNC_NAME,
+					control->critical,
+					rep_control->flags,
+					rep_control->max_attributes,
+					cookie);
+
+		talloc_free(cookie);
+		return res;
+	}
+
+	/*
+	 * From here we don't know the control
+	 */
+	if (control->data == NULL) {
+		/*
+		 * We don't know the control but there is no real data attached to it
+		 * so we can represent it with local_oid:oid:criticity
+		 */
+		res = talloc_asprintf(mem_ctx, "local_oid:%s:%d",
+					control->oid,
+					control->critical);
+		return res;
+	}
+
+		res = talloc_asprintf(mem_ctx, "unknown oid:%s",
+					control->oid);
+	return res;
+}
+
+
+/*
  * A little trick to allow to use constants defined in headers rather than
  * hardwritten in the file hardwritten in the file
  * sizeof will return the \0 char as well so it will take the place of ":" in the
@@ -264,718 +378,642 @@ int ldb_request_replace_control(struct ldb_request *req, const char *oid, bool c
  */
 #define LDB_CONTROL_CMP(control, NAME) strncmp(control, NAME ":", sizeof(NAME))
 
-/* Parse controls from the format used on the command line and in ejs */
-struct ldb_control **ldb_parse_control_strings(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char **control_strings)
+/* Parse one string and return associated control if parsing is successful*/
+struct ldb_control *ldb_parse_control_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *control_strings)
 {
-	unsigned int i;
-	struct ldb_control **ctrl;
-
+	struct ldb_control *ctrl;
 	char *error_string = NULL;
 
-	if (control_strings == NULL || control_strings[0] == NULL)
+	if (!(ctrl = talloc(mem_ctx, struct ldb_control))) {
+		ldb_oom(ldb);
 		return NULL;
+	}
 
-	for (i = 0; control_strings[i]; i++);
+	if (LDB_CONTROL_CMP(control_strings,
+				LDB_CONTROL_VLV_REQ_NAME) == 0) {
+		struct ldb_vlv_req_control *control;
+		const char *p;
+		char attr[1024];
+		char ctxid[1024];
+		int crit, bc, ac, os, cc, ret;
+
+		attr[0] = '\0';
+		ctxid[0] = '\0';
+		p = &(control_strings[sizeof(LDB_CONTROL_VLV_REQ_NAME)]);
+		ret = sscanf(p, "%d:%d:%d:%d:%d:%1023[^$]", &crit, &bc, &ac, &os, &cc, ctxid);
+		if (ret < 5) {
+			ret = sscanf(p, "%d:%d:%d:%1023[^:]:%1023[^$]", &crit, &bc, &ac, attr, ctxid);
+		}
+			
+		if ((ret < 4) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b):bc(n):ac(n):<os(n):cc(n)|attr(s)>[:ctxid(o)]\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, s = string, o = b64 binary blob");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
+		ctrl->oid = LDB_CONTROL_VLV_REQ_OID;
+		ctrl->critical = crit;
+		if (!(control = talloc(ctrl,
+					struct ldb_vlv_req_control))) {
+			ldb_oom(ldb);
+			return NULL;
+		}
+		control->beforeCount = bc;
+		control->afterCount = ac;
+		if (attr[0]) {
+			control->type = 1;
+			control->match.gtOrEq.value = talloc_strdup(control, attr);
+			control->match.gtOrEq.value_len = strlen(attr);
+		} else {
+			control->type = 0;
+			control->match.byOffset.offset = os;
+			control->match.byOffset.contentCount = cc;
+		}
+		if (ctxid[0]) {
+			control->ctxid_len = ldb_base64_decode(ctxid);
+			control->contextId = (char *)talloc_memdup(control, ctxid, control->ctxid_len);
+		} else {
+			control->ctxid_len = 0;
+			control->contextId = NULL;
+		}
+		ctrl->data = control;
 
-	ctrl = talloc_array(mem_ctx, struct ldb_control *, i + 1);
+		return ctrl;
+	}
 
-	for (i = 0; control_strings[i]; i++) {
-		if (LDB_CONTROL_CMP(control_strings[i],
-					LDB_CONTROL_VLV_REQ_NAME) == 0) {
-			struct ldb_vlv_req_control *control;
-			const char *p;
-			char attr[1024];
-			char ctxid[1024];
-			int crit, bc, ac, os, cc, ret;
-
-			attr[0] = '\0';
-			ctxid[0] = '\0';
-			p = &(control_strings[i][sizeof(LDB_CONTROL_VLV_REQ_NAME)]);
-			ret = sscanf(p, "%d:%d:%d:%d:%d:%1023[^$]", &crit, &bc, &ac, &os, &cc, ctxid);
-			if (ret < 5) {
-				ret = sscanf(p, "%d:%d:%d:%1023[^:]:%1023[^$]", &crit, &bc, &ac, attr, ctxid);
-			}
-			       
-			if ((ret < 4) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b):bc(n):ac(n):<os(n):cc(n)|attr(s)>[:ctxid(o)]\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, s = string, o = b64 binary blob");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
-			if (!(ctrl[i] = talloc(ctrl, struct ldb_control))) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_VLV_REQ_OID;
-			ctrl[i]->critical = crit;
-			if (!(control = talloc(ctrl[i],
-					       struct ldb_vlv_req_control))) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			control->beforeCount = bc;
-			control->afterCount = ac;
-			if (attr[0]) {
-				control->type = 1;
-				control->match.gtOrEq.value = talloc_strdup(control, attr);
-				control->match.gtOrEq.value_len = strlen(attr);
-			} else {
-				control->type = 0;
-				control->match.byOffset.offset = os;
-				control->match.byOffset.contentCount = cc;
-			}
-			if (ctxid[0]) {
-				control->ctxid_len = ldb_base64_decode(ctxid);
-				control->contextId = (char *)talloc_memdup(control, ctxid, control->ctxid_len);
-			} else {
-				control->ctxid_len = 0;
-				control->contextId = NULL;
-			}
-			ctrl[i]->data = control;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_DIRSYNC_NAME) == 0) {
+		struct ldb_dirsync_control *control;
+		const char *p;
+		char cookie[1024];
+		int crit, flags, max_attrs, ret;
+		
+		cookie[0] = '\0';
+		p = &(control_strings[sizeof(LDB_CONTROL_DIRSYNC_NAME)]);
+		ret = sscanf(p, "%d:%d:%d:%1023[^$]", &crit, &flags, &max_attrs, cookie);
+
+		if ((ret < 3) || (crit < 0) || (crit > 1) || (flags < 0) || (max_attrs < 0)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid dirsync control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b):flags(n):max_attrs(n)[:cookie(o)]\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, o = b64 binary blob");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			continue;
+		/* w2k3 seems to ignore the parameter,
+			* but w2k sends a wrong cookie when this value is to small
+			* this would cause looping forever, while getting
+			* the same data and same cookie forever
+			*/
+		if (max_attrs == 0) max_attrs = 0x0FFFFFFF;
+
+		ctrl->oid = LDB_CONTROL_DIRSYNC_OID;
+		ctrl->critical = crit;
+		control = talloc(ctrl, struct ldb_dirsync_control);
+		control->flags = flags;
+		control->max_attributes = max_attrs;
+		if (*cookie) {
+			control->cookie_len = ldb_base64_decode(cookie);
+			control->cookie = (char *)talloc_memdup(control, cookie, control->cookie_len);
+		} else {
+			control->cookie = NULL;
+			control->cookie_len = 0;
 		}
+		ctrl->data = control;
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_DIRSYNC_NAME) == 0) {
-			struct ldb_dirsync_control *control;
-			const char *p;
-			char cookie[1024];
-			int crit, flags, max_attrs, ret;
-		       
-			cookie[0] = '\0';
-			p = &(control_strings[i][sizeof(LDB_CONTROL_DIRSYNC_NAME)]);
-			ret = sscanf(p, "%d:%d:%d:%1023[^$]", &crit, &flags, &max_attrs, cookie);
+		return ctrl;
+	}
 
-			if ((ret < 3) || (crit < 0) || (crit > 1) || (flags < 0) || (max_attrs < 0)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid dirsync control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b):flags(n):max_attrs(n)[:cookie(o)]\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, o = b64 binary blob");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_ASQ_NAME) == 0) {
+		struct ldb_asq_control *control;
+		const char *p;
+		char attr[256];
+		int crit, ret;
+
+		attr[0] = '\0';
+		p = &(control_strings[sizeof(LDB_CONTROL_ASQ_NAME)]);
+		ret = sscanf(p, "%d:%255[^$]", &crit, attr);
+		if ((ret != 2) || (crit < 0) || (crit > 1) || (attr[0] == '\0')) {
+			error_string = talloc_asprintf(mem_ctx, "invalid asq control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b):attr(s)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			/* w2k3 seems to ignore the parameter,
-			 * but w2k sends a wrong cookie when this value is to small
-			 * this would cause looping forever, while getting
-			 * the same data and same cookie forever
-			 */
-			if (max_attrs == 0) max_attrs = 0x0FFFFFFF;
-
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			ctrl[i]->oid = LDB_CONTROL_DIRSYNC_OID;
-			ctrl[i]->critical = crit;
-			control = talloc(ctrl[i], struct ldb_dirsync_control);
-			control->flags = flags;
-			control->max_attributes = max_attrs;
-			if (*cookie) {
-				control->cookie_len = ldb_base64_decode(cookie);
-				control->cookie = (char *)talloc_memdup(control, cookie, control->cookie_len);
-			} else {
-				control->cookie = NULL;
-				control->cookie_len = 0;
-			}
-			ctrl[i]->data = control;
+		ctrl->oid = LDB_CONTROL_ASQ_OID;
+		ctrl->critical = crit;
+		control = talloc(ctrl, struct ldb_asq_control);
+		control->request = 1;
+		control->source_attribute = talloc_strdup(control, attr);
+		control->src_attr_len = strlen(attr);
+		ctrl->data = control;
 
-			continue;
-		}
+		return ctrl;
+	}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_ASQ_NAME) == 0) {
-			struct ldb_asq_control *control;
-			const char *p;
-			char attr[256];
-			int crit, ret;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_EXTENDED_DN_NAME) == 0) {
+		struct ldb_extended_dn_control *control;
+		const char *p;
+		int crit, type, ret;
 
-			attr[0] = '\0';
-			p = &(control_strings[i][sizeof(LDB_CONTROL_ASQ_NAME)]);
-			ret = sscanf(p, "%d:%255[^$]", &crit, attr);
-			if ((ret != 2) || (crit < 0) || (crit > 1) || (attr[0] == '\0')) {
-				error_string = talloc_asprintf(mem_ctx, "invalid asq control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b):attr(s)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+		p = &(control_strings[sizeof(LDB_CONTROL_EXTENDED_DN_NAME)]);
+		ret = sscanf(p, "%d:%d", &crit, &type);
+		if ((ret != 2) || (crit < 0) || (crit > 1) || (type < 0) || (type > 1)) {
+			ret = sscanf(p, "%d", &crit);
+			if ((ret != 1) || (crit < 0) || (crit > 1)) {
+				error_string = talloc_asprintf(mem_ctx, "invalid extended_dn control syntax\n");
+				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)[:type(i)]\n");
+				error_string = talloc_asprintf_append(error_string, "   note: b = boolean\n");
+				error_string = talloc_asprintf_append(error_string, "         i = integer\n");
+				error_string = talloc_asprintf_append(error_string, "   valid values are: 0 - hexadecimal representation\n");
+				error_string = talloc_asprintf_append(error_string, "                     1 - normal string representation");
 				ldb_set_errstring(ldb, error_string);
 				talloc_free(error_string);
 				return NULL;
 			}
+			control = NULL;
+		} else {
+			control = talloc(ctrl, struct ldb_extended_dn_control);
+			control->type = type;
+		}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_ASQ_OID;
-			ctrl[i]->critical = crit;
-			control = talloc(ctrl[i], struct ldb_asq_control);
-			control->request = 1;
-			control->source_attribute = talloc_strdup(control, attr);
-			control->src_attr_len = strlen(attr);
-			ctrl[i]->data = control;
-
-			continue;
-		}
-
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_EXTENDED_DN_NAME) == 0) {
-			struct ldb_extended_dn_control *control;
-			const char *p;
-			int crit, type, ret;
-
-			p = &(control_strings[i][sizeof(LDB_CONTROL_EXTENDED_DN_NAME)]);
-			ret = sscanf(p, "%d:%d", &crit, &type);
-			if ((ret != 2) || (crit < 0) || (crit > 1) || (type < 0) || (type > 1)) {
-				ret = sscanf(p, "%d", &crit);
-				if ((ret != 1) || (crit < 0) || (crit > 1)) {
-					error_string = talloc_asprintf(mem_ctx, "invalid extended_dn control syntax\n");
-					error_string = talloc_asprintf_append(error_string, " syntax: crit(b)[:type(i)]\n");
-					error_string = talloc_asprintf_append(error_string, "   note: b = boolean\n");
-					error_string = talloc_asprintf_append(error_string, "         i = integer\n");
-					error_string = talloc_asprintf_append(error_string, "   valid values are: 0 - hexadecimal representation\n");
-					error_string = talloc_asprintf_append(error_string, "                     1 - normal string representation");
-					ldb_set_errstring(ldb, error_string);
-					talloc_free(error_string);
-					return NULL;
-				}
-				control = NULL;
-			} else {
-				control = talloc(ctrl, struct ldb_extended_dn_control);
-				control->type = type;
-			}
+		ctrl->oid = LDB_CONTROL_EXTENDED_DN_OID;
+		ctrl->critical = crit;
+		ctrl->data = talloc_steal(ctrl, control);
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_EXTENDED_DN_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = talloc_steal(ctrl[i], control);
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SD_FLAGS_NAME) == 0) {
+		struct ldb_sd_flags_control *control;
+		const char *p;
+		int crit, ret;
+		unsigned secinfo_flags;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_SD_FLAGS_NAME)]);
+		ret = sscanf(p, "%d:%u", &crit, &secinfo_flags);
+		if ((ret != 2) || (crit < 0) || (crit > 1) || (secinfo_flags < 0) || (secinfo_flags > 0xF)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid sd_flags control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b):secinfo_flags(n)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_SD_FLAGS_NAME) == 0) {
-			struct ldb_sd_flags_control *control;
-			const char *p;
-			int crit, ret;
-			unsigned secinfo_flags;
+		ctrl->oid = LDB_CONTROL_SD_FLAGS_OID;
+		ctrl->critical = crit;
+		control = talloc(ctrl, struct ldb_sd_flags_control);
+		control->secinfo_flags = secinfo_flags;
+		ctrl->data = control;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_SD_FLAGS_NAME)]);
-			ret = sscanf(p, "%d:%u", &crit, &secinfo_flags);
-			if ((ret != 2) || (crit < 0) || (crit > 1) || (secinfo_flags < 0) || (secinfo_flags > 0xF)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid sd_flags control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b):secinfo_flags(n)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		return ctrl;
+	}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_SD_FLAGS_OID;
-			ctrl[i]->critical = crit;
-			control = talloc(ctrl[i], struct ldb_sd_flags_control);
-			control->secinfo_flags = secinfo_flags;
-			ctrl[i]->data = control;
-
-			continue;
-		}
-
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_SEARCH_OPTIONS_NAME) == 0) {
-			struct ldb_search_options_control *control;
-			const char *p;
-			int crit, ret;
-			unsigned search_options;
-
-			p = &(control_strings[i][sizeof(LDB_CONTROL_SEARCH_OPTIONS_NAME)]);
-			ret = sscanf(p, "%d:%u", &crit, &search_options);
-			if ((ret != 2) || (crit < 0) || (crit > 1) || (search_options < 0) || (search_options > 0xF)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid search_options control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b):search_options(n)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SEARCH_OPTIONS_NAME) == 0) {
+		struct ldb_search_options_control *control;
+		const char *p;
+		int crit, ret;
+		unsigned search_options;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_SEARCH_OPTIONS_NAME)]);
+		ret = sscanf(p, "%d:%u", &crit, &search_options);
+		if ((ret != 2) || (crit < 0) || (crit > 1) || (search_options < 0) || (search_options > 0xF)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid search_options control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b):search_options(n)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_SEARCH_OPTIONS_OID;
-			ctrl[i]->critical = crit;
-			control = talloc(ctrl[i], struct ldb_search_options_control);
-			control->search_options = search_options;
-			ctrl[i]->data = control;
+		ctrl->oid = LDB_CONTROL_SEARCH_OPTIONS_OID;
+		ctrl->critical = crit;
+		control = talloc(ctrl, struct ldb_search_options_control);
+		control->search_options = search_options;
+		ctrl->data = control;
 
-			continue;
-		}
+		return ctrl;
+	}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_BYPASS_OPERATIONAL_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_BYPASS_OPERATIONAL_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_BYPASS_OPERATIONAL_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid bypassopreational control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_BYPASS_OPERATIONAL_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid bypassopreational control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		ctrl->oid = LDB_CONTROL_BYPASS_OPERATIONAL_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_BYPASS_OPERATIONAL_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_RELAX_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_RELAX_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid relax control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_RELAX_NAME) == 0) {
-			const char *p;
-			int crit, ret;
-
-			p = &(control_strings[i][sizeof(LDB_CONTROL_RELAX_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid relax control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		ctrl->oid = LDB_CONTROL_RELAX_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_RELAX_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_RECALCULATE_SD_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_RECALCULATE_SD_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid recalculate_sd control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_RECALCULATE_SD_NAME) == 0) {
-			const char *p;
-			int crit, ret;
-
-			p = &(control_strings[i][sizeof(LDB_CONTROL_RECALCULATE_SD_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid recalculate_sd control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		ctrl->oid = LDB_CONTROL_RECALCULATE_SD_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_RECALCULATE_SD_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_DOMAIN_SCOPE_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_DOMAIN_SCOPE_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid domain_scope control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_DOMAIN_SCOPE_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+		ctrl->oid = LDB_CONTROL_DOMAIN_SCOPE_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_DOMAIN_SCOPE_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid domain_scope control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		return ctrl;
+	}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_DOMAIN_SCOPE_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
-
-			continue;
-		}
-
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_PAGED_RESULTS_NAME) == 0) {
-			struct ldb_paged_control *control;
-			const char *p;
-			int crit, size, ret;
-		       
-			p = &(control_strings[i][sizeof(LDB_CONTROL_PAGED_RESULTS_NAME)]);
-			ret = sscanf(p, "%d:%d", &crit, &size);
-			if ((ret != 2) || (crit < 0) || (crit > 1) || (size < 0)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid paged_results control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b):size(n)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_PAGED_RESULTS_NAME) == 0) {
+		struct ldb_paged_control *control;
+		const char *p;
+		int crit, size, ret;
+		
+		p = &(control_strings[sizeof(LDB_CONTROL_PAGED_RESULTS_NAME)]);
+		ret = sscanf(p, "%d:%d", &crit, &size);
+		if ((ret != 2) || (crit < 0) || (crit > 1) || (size < 0)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid paged_results control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b):size(n)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
-			ctrl[i]->critical = crit;
-			control = talloc(ctrl[i], struct ldb_paged_control);
-			control->size = size;
-			control->cookie = NULL;
-			control->cookie_len = 0;
-			ctrl[i]->data = control;
-
-			continue;
-		}
-
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_SERVER_SORT_NAME) == 0) {
-			struct ldb_server_sort_control **control;
-			const char *p;
-			char attr[256];
-			char rule[128];
-			int crit, rev, ret;
-
-			attr[0] = '\0';
-			rule[0] = '\0';
-			p = &(control_strings[i][sizeof(LDB_CONTROL_SERVER_SORT_NAME)]);
-			ret = sscanf(p, "%d:%d:%255[^:]:%127[^:]", &crit, &rev, attr, rule);
-			if ((ret < 3) || (crit < 0) || (crit > 1) || (rev < 0 ) || (rev > 1) ||attr[0] == '\0') {
-				error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b):rev(b):attr(s)[:rule(s)]\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_SERVER_SORT_OID;
-			ctrl[i]->critical = crit;
-			control = talloc_array(ctrl[i], struct ldb_server_sort_control *, 2);
-			control[0] = talloc(control, struct ldb_server_sort_control);
-			control[0]->attributeName = talloc_strdup(control, attr);
-			if (rule[0])
-				control[0]->orderingRule = talloc_strdup(control, rule);
-			else
-				control[0]->orderingRule = NULL;
-			control[0]->reverse = rev;
-			control[1] = NULL;
-			ctrl[i]->data = control;
-
-			continue;
-		}
-
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_NOTIFICATION_NAME) == 0) {
-			const char *p;
-			int crit, ret;
-
-			p = &(control_strings[i][sizeof(LDB_CONTROL_NOTIFICATION_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid notification control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		ctrl->oid = LDB_CONTROL_PAGED_RESULTS_OID;
+		ctrl->critical = crit;
+		control = talloc(ctrl, struct ldb_paged_control);
+		control->size = size;
+		control->cookie = NULL;
+		control->cookie_len = 0;
+		ctrl->data = control;
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_NOTIFICATION_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SERVER_SORT_NAME) == 0) {
+		struct ldb_server_sort_control **control;
+		const char *p;
+		char attr[256];
+		char rule[128];
+		int crit, rev, ret;
+
+		attr[0] = '\0';
+		rule[0] = '\0';
+		p = &(control_strings[sizeof(LDB_CONTROL_SERVER_SORT_NAME)]);
+		ret = sscanf(p, "%d:%d:%255[^:]:%127[^:]", &crit, &rev, attr, rule);
+		if ((ret < 3) || (crit < 0) || (crit > 1) || (rev < 0 ) || (rev > 1) ||attr[0] == '\0') {
+			error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b):rev(b):attr(s)[:rule(s)]\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
+		ctrl->oid = LDB_CONTROL_SERVER_SORT_OID;
+		ctrl->critical = crit;
+		control = talloc_array(ctrl, struct ldb_server_sort_control *, 2);
+		control[0] = talloc(control, struct ldb_server_sort_control);
+		control[0]->attributeName = talloc_strdup(control, attr);
+		if (rule[0])
+			control[0]->orderingRule = talloc_strdup(control, rule);
+		else
+			control[0]->orderingRule = NULL;
+		control[0]->reverse = rev;
+		control[1] = NULL;
+		ctrl->data = control;
+
+		return ctrl;
+	}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_TREE_DELETE_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_NOTIFICATION_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_NOTIFICATION_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid notification control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_TREE_DELETE_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid tree_delete control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		ctrl->oid = LDB_CONTROL_NOTIFICATION_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_TREE_DELETE_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_TREE_DELETE_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_TREE_DELETE_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid tree_delete control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_SHOW_DELETED_NAME) == 0) {
-			const char *p;
-			int crit, ret;
-
-			p = &(control_strings[i][sizeof(LDB_CONTROL_SHOW_DELETED_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid show_deleted control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		ctrl->oid = LDB_CONTROL_TREE_DELETE_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_SHOW_DELETED_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SHOW_DELETED_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_SHOW_DELETED_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid show_deleted control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_SHOW_DEACTIVATED_LINK_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+		ctrl->oid = LDB_CONTROL_SHOW_DELETED_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_SHOW_DEACTIVATED_LINK_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid show_deactivated_link control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
-
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_SHOW_DEACTIVATED_LINK_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SHOW_DEACTIVATED_LINK_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_SHOW_DEACTIVATED_LINK_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid show_deactivated_link control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_SHOW_RECYCLED_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+		ctrl->oid = LDB_CONTROL_SHOW_DEACTIVATED_LINK_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_SHOW_RECYCLED_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid show_recycled control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
-
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_SHOW_RECYCLED_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SHOW_RECYCLED_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_SHOW_RECYCLED_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid show_recycled control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_PERMISSIVE_MODIFY_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+		ctrl->oid = LDB_CONTROL_SHOW_RECYCLED_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_PERMISSIVE_MODIFY_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid permissive_modify control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		return ctrl;
+	}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_PERMISSIVE_MODIFY_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_PERMISSIVE_MODIFY_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_PERMISSIVE_MODIFY_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid permissive_modify control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
+
+		ctrl->oid = LDB_CONTROL_PERMISSIVE_MODIFY_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			continue;
+		return ctrl;
+	}
+
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_REVEAL_INTERNALS_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_REVEAL_INTERNALS_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid reveal_internals control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_REVEAL_INTERNALS_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+		ctrl->oid = LDB_CONTROL_REVEAL_INTERNALS;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_REVEAL_INTERNALS_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid reveal_internals control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		return ctrl;
+	}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_REVEAL_INTERNALS;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+	if (strncmp(control_strings, "local_oid:", 10) == 0) {
+		const char *p;
+		int crit = 0, ret = 0;
+		char oid[256];
+
+		oid[0] = '\0';
+		p = &(control_strings[10]);
+		ret = sscanf(p, "%64[^:]:%d", oid, &crit);
+
+		if ((ret != 2) || strlen(oid) == 0 || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid local_oid control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: oid(s):crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			continue;
+		ctrl->oid = talloc_strdup(ctrl, oid);
+		if (!ctrl->oid) {
+			ldb_oom(ldb);
+			return NULL;
 		}
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-		if (strncmp(control_strings[i], "local_oid:", 10) == 0) {
-			const char *p;
-			int crit = 0, ret = 0;
-			char oid[256];
+		return ctrl;
+	}
 
-			oid[0] = '\0';
-			p = &(control_strings[i][10]);
-			ret = sscanf(p, "%64[^:]:%d", oid, &crit);
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_RODC_DCPROMO_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_RODC_DCPROMO_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid rodc_join control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
+		}
 
-			if ((ret != 2) || strlen(oid) == 0 || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid local_oid control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: oid(s):crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		ctrl->oid = LDB_CONTROL_RODC_DCPROMO_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = talloc_strdup(ctrl[i], oid);
-			if (!ctrl[i]->oid) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+		return ctrl;
+	}
 
-			continue;
+	if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_PROVISION_NAME) == 0) {
+		const char *p;
+		int crit, ret;
+
+		p = &(control_strings[sizeof(LDB_CONTROL_PROVISION_NAME)]);
+		ret = sscanf(p, "%d", &crit);
+		if ((ret != 1) || (crit < 0) || (crit > 1)) {
+			error_string = talloc_asprintf(mem_ctx, "invalid provision control syntax\n");
+			error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+			error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+			ldb_set_errstring(ldb, error_string);
+			talloc_free(error_string);
+			return NULL;
 		}
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_RODC_DCPROMO_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+		ctrl->oid = LDB_CONTROL_PROVISION_OID;
+		ctrl->critical = crit;
+		ctrl->data = NULL;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_RODC_DCPROMO_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid rodc_join control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+		return ctrl;
+	}
+	/*
+	 * When no matching control has been found.
+	 */
+	return NULL;
+}
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_RODC_DCPROMO_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+/*
+ * A little trick to allow to use constants defined in headers rather than
+ * hardwritten in the file hardwritten in the file
+ * sizeof will return the \0 char as well so it will take the place of ":" in the
+ * length of the string
+ */
+#define LDB_CONTROL_CMP(control, NAME) strncmp(control, NAME ":", sizeof(NAME))
 
-			continue;
-		}
+/* Parse controls from the format used on the command line and in ejs */
+struct ldb_control **ldb_parse_control_strings(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char **control_strings)
+{
+	unsigned int i;
+	struct ldb_control **ctrl;
 
-		if (LDB_CONTROL_CMP(control_strings[i], LDB_CONTROL_PROVISION_NAME) == 0) {
-			const char *p;
-			int crit, ret;
+	if (control_strings == NULL || control_strings[0] == NULL)
+		return NULL;
 
-			p = &(control_strings[i][sizeof(LDB_CONTROL_PROVISION_NAME)]);
-			ret = sscanf(p, "%d", &crit);
-			if ((ret != 1) || (crit < 0) || (crit > 1)) {
-				error_string = talloc_asprintf(mem_ctx, "invalid provision control syntax\n");
-				error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
-				error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
-				ldb_set_errstring(ldb, error_string);
-				talloc_free(error_string);
-				return NULL;
-			}
+	for (i = 0; control_strings[i]; i++);
 
-			ctrl[i] = talloc(ctrl, struct ldb_control);
-			if (!ctrl[i]) {
-				ldb_oom(ldb);
-				return NULL;
-			}
-			ctrl[i]->oid = LDB_CONTROL_PROVISION_OID;
-			ctrl[i]->critical = crit;
-			ctrl[i]->data = NULL;
+	ctrl = talloc_array(mem_ctx, struct ldb_control *, i + 1);
 
-			continue;
+	ldb_reset_err_string(ldb);
+	for (i = 0; control_strings[i]; i++) {
+		ctrl[i] = ldb_parse_control_from_string(ldb, ctrl, control_strings[i]);
+		if (ctrl[i] == NULL) {
+			if( ldb_errstring == NULL ) {
+				/* no controls matched, throw an error */
+				ldb_asprintf_errstring(ldb, "Invalid control name: '%s'", control_strings[i]);
+			}
+			talloc_free(ctrl);
+			return NULL;
 		}
-
-		/* no controls matched, throw an error */
-		ldb_asprintf_errstring(ldb, "Invalid control name: '%s'", control_strings[i]);
-		return NULL;
 	}
 
 	ctrl[i] = NULL;
diff --git a/source4/lib/ldb/include/ldb.h b/source4/lib/ldb/include/ldb.h
index b52921f4fa..81f1a73168 100644
--- a/source4/lib/ldb/include/ldb.h
+++ b/source4/lib/ldb/include/ldb.h
@@ -2163,6 +2163,25 @@ do { \
 
 
 /**
+   Convert a control into its string representation.
+   
+   \param mem_ctx TALLOC context to return result on, and to allocate error_string on
+   \param control A struct ldb_control to convert
+
+   \return string representation of the control 
+*/
+char* ldb_control_to_string(TALLOC_CTX *mem_ctx, const struct ldb_control *control);
+/**
+   Convert a string representing a control into a ldb_control structure 
+   
+   \param ldb LDB context
+   \param mem_ctx TALLOC context to return result on, and to allocate error_string on
+   \param control_strings A string-formatted control
+
+   \return a ldb_control element
+*/
+struct ldb_control *ldb_parse_control_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *control_strings);
+/**
    Convert an array of string represention of a control into an array of ldb_control structures 
    
    \param ldb LDB context
diff --git a/source4/lib/ldb/wscript b/source4/lib/ldb/wscript
index 69d8725179..a0b92d57d6 100755
--- a/source4/lib/ldb/wscript
+++ b/source4/lib/ldb/wscript
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 APPNAME = 'ldb'
-VERSION = '1.0.1'
+VERSION = '1.0.2'
 
 blddir = 'bin'