开源软件构建与测试

_service:tar_scm:libldb.spec Changed

_service Changed

_service:tar_scm:ldb-2.7.2.tar.asc Deleted

_service:tar_scm:ldb-2.7.2.tar.gz/ABI/ldb-2.7.1.sigs Deleted

@@ -1,291 +0,0 @@
-ldb_add: int (struct ldb_context *, const struct ldb_message *)
-ldb_any_comparison: int (struct ldb_context *, void *, ldb_attr_handler_t, const struct ldb_val *, const struct ldb_val *)
-ldb_asprintf_errstring: void (struct ldb_context *, const char *, ...)
-ldb_attr_casefold: char *(TALLOC_CTX *, const char *)
-ldb_attr_dn: int (const char *)
-ldb_attr_in_list: int (const char * const *, const char *)
-ldb_attr_list_copy: const char **(TALLOC_CTX *, const char * const *)
-ldb_attr_list_copy_add: const char **(TALLOC_CTX *, const char * const *, const char *)
-ldb_base64_decode: int (char *)
-ldb_base64_encode: char *(TALLOC_CTX *, const char *, int)
-ldb_binary_decode: struct ldb_val (TALLOC_CTX *, const char *)
-ldb_binary_encode: char *(TALLOC_CTX *, struct ldb_val)
-ldb_binary_encode_string: char *(TALLOC_CTX *, const char *)
-ldb_build_add_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_del_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_extended_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const char *, void *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_mod_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_rename_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_search_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, const char *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_search_req_ex: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, struct ldb_parse_tree *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_casefold: char *(struct ldb_context *, TALLOC_CTX *, const char *, size_t)
-ldb_casefold_default: char *(void *, TALLOC_CTX *, const char *, size_t)
-ldb_check_critical_controls: int (struct ldb_control **)
-ldb_comparison_binary: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
-ldb_comparison_fold: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
-ldb_connect: int (struct ldb_context *, const char *, unsigned int, const char **)
-ldb_control_to_string: char *(TALLOC_CTX *, const struct ldb_control *)
-ldb_controls_except_specified: struct ldb_control **(struct ldb_control **, TALLOC_CTX *, struct ldb_control *)
-ldb_debug: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
-ldb_debug_add: void (struct ldb_context *, const char *, ...)
-ldb_debug_end: void (struct ldb_context *, enum ldb_debug_level)
-ldb_debug_set: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
-ldb_delete: int (struct ldb_context *, struct ldb_dn *)
-ldb_dn_add_base: bool (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_add_base_fmt: bool (struct ldb_dn *, const char *, ...)
-ldb_dn_add_child: bool (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_add_child_fmt: bool (struct ldb_dn *, const char *, ...)
-ldb_dn_add_child_val: bool (struct ldb_dn *, const char *, struct ldb_val)
-ldb_dn_alloc_casefold: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_alloc_linearized: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_canonical_ex_string: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_canonical_string: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_check_local: bool (struct ldb_module *, struct ldb_dn *)
-ldb_dn_check_special: bool (struct ldb_dn *, const char *)
-ldb_dn_compare: int (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_compare_base: int (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_copy: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_escape_value: char *(TALLOC_CTX *, struct ldb_val)
-ldb_dn_extended_add_syntax: int (struct ldb_context *, unsigned int, const struct ldb_dn_extended_syntax *)
-ldb_dn_extended_filter: void (struct ldb_dn *, const char * const *)
-ldb_dn_extended_syntax_by_name: const struct ldb_dn_extended_syntax *(struct ldb_context *, const char *)
-ldb_dn_from_ldb_val: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const struct ldb_val *)
-ldb_dn_get_casefold: const char *(struct ldb_dn *)
-ldb_dn_get_comp_num: int (struct ldb_dn *)
-ldb_dn_get_component_name: const char *(struct ldb_dn *, unsigned int)
-ldb_dn_get_component_val: const struct ldb_val *(struct ldb_dn *, unsigned int)
-ldb_dn_get_extended_comp_num: int (struct ldb_dn *)
-ldb_dn_get_extended_component: const struct ldb_val *(struct ldb_dn *, const char *)
-ldb_dn_get_extended_linearized: char *(TALLOC_CTX *, struct ldb_dn *, int)
-ldb_dn_get_ldb_context: struct ldb_context *(struct ldb_dn *)
-ldb_dn_get_linearized: const char *(struct ldb_dn *)
-ldb_dn_get_parent: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_get_rdn_name: const char *(struct ldb_dn *)
-ldb_dn_get_rdn_val: const struct ldb_val *(struct ldb_dn *)
-ldb_dn_has_extended: bool (struct ldb_dn *)
-ldb_dn_is_null: bool (struct ldb_dn *)
-ldb_dn_is_special: bool (struct ldb_dn *)
-ldb_dn_is_valid: bool (struct ldb_dn *)
-ldb_dn_map_local: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
-ldb_dn_map_rebase_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
-ldb_dn_map_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
-ldb_dn_minimise: bool (struct ldb_dn *)
-ldb_dn_new: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *)
-ldb_dn_new_fmt: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *, ...)
-ldb_dn_remove_base_components: bool (struct ldb_dn *, unsigned int)
-ldb_dn_remove_child_components: bool (struct ldb_dn *, unsigned int)
-ldb_dn_remove_extended_components: void (struct ldb_dn *)
-ldb_dn_replace_components: bool (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_set_component: int (struct ldb_dn *, int, const char *, const struct ldb_val)
-ldb_dn_set_extended_component: int (struct ldb_dn *, const char *, const struct ldb_val *)
-ldb_dn_update_components: int (struct ldb_dn *, const struct ldb_dn *)
-ldb_dn_validate: bool (struct ldb_dn *)
-ldb_dump_results: void (struct ldb_context *, struct ldb_result *, FILE *)
-ldb_error_at: int (struct ldb_context *, int, const char *, const char *, int)
-ldb_errstring: const char *(struct ldb_context *)
-ldb_extended: int (struct ldb_context *, const char *, void *, struct ldb_result **)
-ldb_extended_default_callback: int (struct ldb_request *, struct ldb_reply *)
-ldb_filter_attrs: int (struct ldb_context *, const struct ldb_message *, const char * const *, struct ldb_message *)
-ldb_filter_from_tree: char *(TALLOC_CTX *, const struct ldb_parse_tree *)
-ldb_get_config_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_get_create_perms: unsigned int (struct ldb_context *)
-ldb_get_default_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_get_event_context: struct tevent_context *(struct ldb_context *)
-ldb_get_flags: unsigned int (struct ldb_context *)
-ldb_get_opaque: void *(struct ldb_context *, const char *)
-ldb_get_root_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_get_schema_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_global_init: int (void)
-ldb_handle_get_event_context: struct tevent_context *(struct ldb_handle *)
-ldb_handle_new: struct ldb_handle *(TALLOC_CTX *, struct ldb_context *)
-ldb_handle_use_global_event_context: void (struct ldb_handle *)
-ldb_handler_copy: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
-ldb_handler_fold: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
-ldb_init: struct ldb_context *(TALLOC_CTX *, struct tevent_context *)
-ldb_ldif_message_redacted_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
-ldb_ldif_message_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
-ldb_ldif_parse_modrdn: int (struct ldb_context *, const struct ldb_ldif *, TALLOC_CTX *, struct ldb_dn **, struct ldb_dn **, bool *, struct ldb_dn **, struct ldb_dn **)
-ldb_ldif_read: struct ldb_ldif *(struct ldb_context *, int (*)(void *), void *)
-ldb_ldif_read_file: struct ldb_ldif *(struct ldb_context *, FILE *)
-ldb_ldif_read_file_state: struct ldb_ldif *(struct ldb_context *, struct ldif_read_file_state *)
-ldb_ldif_read_free: void (struct ldb_context *, struct ldb_ldif *)
-ldb_ldif_read_string: struct ldb_ldif *(struct ldb_context *, const char **)
-ldb_ldif_write: int (struct ldb_context *, int (*)(void *, const char *, ...), void *, const struct ldb_ldif *)
-ldb_ldif_write_file: int (struct ldb_context *, FILE *, const struct ldb_ldif *)
-ldb_ldif_write_redacted_trace_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
-ldb_ldif_write_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
-ldb_load_modules: int (struct ldb_context *, const char **)
-ldb_map_add: int (struct ldb_module *, struct ldb_request *)
-ldb_map_delete: int (struct ldb_module *, struct ldb_request *)
-ldb_map_init: int (struct ldb_module *, const struct ldb_map_attribute *, const struct ldb_map_objectclass *, const char * const *, const char *, const char *)
-ldb_map_modify: int (struct ldb_module *, struct ldb_request *)
-ldb_map_rename: int (struct ldb_module *, struct ldb_request *)
-ldb_map_search: int (struct ldb_module *, struct ldb_request *)
-ldb_match_message: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, enum ldb_scope, bool *)
-ldb_match_msg: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope)
-ldb_match_msg_error: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope, bool *)
-ldb_match_msg_objectclass: int (const struct ldb_message *, const char *)
-ldb_mod_register_control: int (struct ldb_module *, const char *)
-ldb_modify: int (struct ldb_context *, const struct ldb_message *)
-ldb_modify_default_callback: int (struct ldb_request *, struct ldb_reply *)
-ldb_module_call_chain: char *(struct ldb_request *, TALLOC_CTX *)
-ldb_module_connect_backend: int (struct ldb_context *, const char *, const char **, struct ldb_module **)
-ldb_module_done: int (struct ldb_request *, struct ldb_control **, struct ldb_extended *, int)
-ldb_module_flags: uint32_t (struct ldb_context *)
-ldb_module_get_ctx: struct ldb_context *(struct ldb_module *)
-ldb_module_get_name: const char *(struct ldb_module *)
-ldb_module_get_ops: const struct ldb_module_ops *(struct ldb_module *)
-ldb_module_get_private: void *(struct ldb_module *)
-ldb_module_init_chain: int (struct ldb_context *, struct ldb_module *)
-ldb_module_load_list: int (struct ldb_context *, const char **, struct ldb_module *, struct ldb_module **)
-ldb_module_new: struct ldb_module *(TALLOC_CTX *, struct ldb_context *, const char *, const struct ldb_module_ops *)
-ldb_module_next: struct ldb_module *(struct ldb_module *)
-ldb_module_popt_options: struct poptOption **(struct ldb_context *)
-ldb_module_send_entry: int (struct ldb_request *, struct ldb_message *, struct ldb_control **)
-ldb_module_send_referral: int (struct ldb_request *, char *)
-ldb_module_set_next: void (struct ldb_module *, struct ldb_module *)
-ldb_module_set_private: void (struct ldb_module *, void *)
-ldb_modules_hook: int (struct ldb_context *, enum ldb_module_hook_type)
-ldb_modules_list_from_string: const char **(struct ldb_context *, TALLOC_CTX *, const char *)
-ldb_modules_load: int (const char *, const char *)
-ldb_msg_add: int (struct ldb_message *, const struct ldb_message_element *, int)
-ldb_msg_add_empty: int (struct ldb_message *, const char *, int, struct ldb_message_element **)
-ldb_msg_add_fmt: int (struct ldb_message *, const char *, const char *, ...)
-ldb_msg_add_linearized_dn: int (struct ldb_message *, const char *, struct ldb_dn *)
-ldb_msg_add_steal_string: int (struct ldb_message *, const char *, char *)
-ldb_msg_add_steal_value: int (struct ldb_message *, const char *, struct ldb_val *)
-ldb_msg_add_string: int (struct ldb_message *, const char *, const char *)
-ldb_msg_add_string_flags: int (struct ldb_message *, const char *, const char *, int)
-ldb_msg_add_value: int (struct ldb_message *, const char *, const struct ldb_val *, struct ldb_message_element **)
-ldb_msg_append_fmt: int (struct ldb_message *, int, const char *, const char *, ...)
-ldb_msg_append_linearized_dn: int (struct ldb_message *, const char *, struct ldb_dn *, int)
-ldb_msg_append_steal_string: int (struct ldb_message *, const char *, char *, int)
-ldb_msg_append_steal_value: int (struct ldb_message *, const char *, struct ldb_val *, int)
-ldb_msg_append_string: int (struct ldb_message *, const char *, const char *, int)
-ldb_msg_append_value: int (struct ldb_message *, const char *, const struct ldb_val *, int)
-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_add_value: int (TALLOC_CTX *, struct ldb_message_element *, const struct ldb_val *)
-ldb_msg_element_compare: int (struct ldb_message_element *, struct ldb_message_element *)
-ldb_msg_element_compare_name: int (struct ldb_message_element *, struct ldb_message_element *)
-ldb_msg_element_equal_ordered: bool (const struct ldb_message_element *, const struct ldb_message_element *)
-ldb_msg_find_attr_as_bool: int (const struct ldb_message *, const char *, int)
-ldb_msg_find_attr_as_dn: struct ldb_dn *(struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, const char *)
-ldb_msg_find_attr_as_double: double (const struct ldb_message *, const char *, double)
-ldb_msg_find_attr_as_int: int (const struct ldb_message *, const char *, int)
-ldb_msg_find_attr_as_int64: int64_t (const struct ldb_message *, const char *, int64_t)
-ldb_msg_find_attr_as_string: const char *(const struct ldb_message *, const char *, const char *)
-ldb_msg_find_attr_as_uint: unsigned int (const struct ldb_message *, const char *, unsigned int)
-ldb_msg_find_attr_as_uint64: uint64_t (const struct ldb_message *, const char *, uint64_t)
-ldb_msg_find_common_values: int (struct ldb_context *, TALLOC_CTX *, struct ldb_message_element *, struct ldb_message_element *, uint32_t)
-ldb_msg_find_duplicate_val: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message_element *, struct ldb_val **, uint32_t)
-ldb_msg_find_element: struct ldb_message_element *(const struct ldb_message *, const char *)
-ldb_msg_find_ldb_val: const struct ldb_val *(const struct ldb_message *, const char *)
-ldb_msg_find_val: struct ldb_val *(const struct ldb_message_element *, struct ldb_val *)
-ldb_msg_new: struct ldb_message *(TALLOC_CTX *)
-ldb_msg_normalize: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_message **)
-ldb_msg_remove_attr: void (struct ldb_message *, const char *)
-ldb_msg_remove_element: void (struct ldb_message *, struct ldb_message_element *)
-ldb_msg_rename_attr: int (struct ldb_message *, const char *, const char *)
-ldb_msg_sanity_check: int (struct ldb_context *, const struct ldb_message *)
-ldb_msg_sort_elements: void (struct ldb_message *)
-ldb_next_del_trans: int (struct ldb_module *)
-ldb_next_end_trans: int (struct ldb_module *)
-ldb_next_init: int (struct ldb_module *)

_service:tar_scm:ldb-2.7.2.tar.gz/ABI/ldb-2.7.2.sigs Deleted

@@ -1,301 +0,0 @@
-ldb_add: int (struct ldb_context *, const struct ldb_message *)
-ldb_any_comparison: int (struct ldb_context *, void *, ldb_attr_handler_t, const struct ldb_val *, const struct ldb_val *)
-ldb_asprintf_errstring: void (struct ldb_context *, const char *, ...)
-ldb_attr_casefold: char *(TALLOC_CTX *, const char *)
-ldb_attr_dn: int (const char *)
-ldb_attr_in_list: int (const char * const *, const char *)
-ldb_attr_list_copy: const char **(TALLOC_CTX *, const char * const *)
-ldb_attr_list_copy_add: const char **(TALLOC_CTX *, const char * const *, const char *)
-ldb_base64_decode: int (char *)
-ldb_base64_encode: char *(TALLOC_CTX *, const char *, int)
-ldb_binary_decode: struct ldb_val (TALLOC_CTX *, const char *)
-ldb_binary_encode: char *(TALLOC_CTX *, struct ldb_val)
-ldb_binary_encode_string: char *(TALLOC_CTX *, const char *)
-ldb_build_add_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_del_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_extended_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const char *, void *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_mod_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_rename_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_search_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, const char *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_build_search_req_ex: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, struct ldb_parse_tree *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
-ldb_casefold: char *(struct ldb_context *, TALLOC_CTX *, const char *, size_t)
-ldb_casefold_default: char *(void *, TALLOC_CTX *, const char *, size_t)
-ldb_check_critical_controls: int (struct ldb_control **)
-ldb_comparison_binary: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
-ldb_comparison_fold: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
-ldb_connect: int (struct ldb_context *, const char *, unsigned int, const char **)
-ldb_control_to_string: char *(TALLOC_CTX *, const struct ldb_control *)
-ldb_controls_except_specified: struct ldb_control **(struct ldb_control **, TALLOC_CTX *, struct ldb_control *)
-ldb_debug: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
-ldb_debug_add: void (struct ldb_context *, const char *, ...)
-ldb_debug_end: void (struct ldb_context *, enum ldb_debug_level)
-ldb_debug_set: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
-ldb_delete: int (struct ldb_context *, struct ldb_dn *)
-ldb_dn_add_base: bool (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_add_base_fmt: bool (struct ldb_dn *, const char *, ...)
-ldb_dn_add_child: bool (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_add_child_fmt: bool (struct ldb_dn *, const char *, ...)
-ldb_dn_add_child_val: bool (struct ldb_dn *, const char *, struct ldb_val)
-ldb_dn_alloc_casefold: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_alloc_linearized: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_canonical_ex_string: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_canonical_string: char *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_check_local: bool (struct ldb_module *, struct ldb_dn *)
-ldb_dn_check_special: bool (struct ldb_dn *, const char *)
-ldb_dn_compare: int (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_compare_base: int (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_copy: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_escape_value: char *(TALLOC_CTX *, struct ldb_val)
-ldb_dn_extended_add_syntax: int (struct ldb_context *, unsigned int, const struct ldb_dn_extended_syntax *)
-ldb_dn_extended_filter: void (struct ldb_dn *, const char * const *)
-ldb_dn_extended_syntax_by_name: const struct ldb_dn_extended_syntax *(struct ldb_context *, const char *)
-ldb_dn_from_ldb_val: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const struct ldb_val *)
-ldb_dn_get_casefold: const char *(struct ldb_dn *)
-ldb_dn_get_comp_num: int (struct ldb_dn *)
-ldb_dn_get_component_name: const char *(struct ldb_dn *, unsigned int)
-ldb_dn_get_component_val: const struct ldb_val *(struct ldb_dn *, unsigned int)
-ldb_dn_get_extended_comp_num: int (struct ldb_dn *)
-ldb_dn_get_extended_component: const struct ldb_val *(struct ldb_dn *, const char *)
-ldb_dn_get_extended_linearized: char *(TALLOC_CTX *, struct ldb_dn *, int)
-ldb_dn_get_ldb_context: struct ldb_context *(struct ldb_dn *)
-ldb_dn_get_linearized: const char *(struct ldb_dn *)
-ldb_dn_get_parent: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
-ldb_dn_get_rdn_name: const char *(struct ldb_dn *)
-ldb_dn_get_rdn_val: const struct ldb_val *(struct ldb_dn *)
-ldb_dn_has_extended: bool (struct ldb_dn *)
-ldb_dn_is_null: bool (struct ldb_dn *)
-ldb_dn_is_special: bool (struct ldb_dn *)
-ldb_dn_is_valid: bool (struct ldb_dn *)
-ldb_dn_map_local: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
-ldb_dn_map_rebase_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
-ldb_dn_map_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
-ldb_dn_minimise: bool (struct ldb_dn *)
-ldb_dn_new: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *)
-ldb_dn_new_fmt: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *, ...)
-ldb_dn_remove_base_components: bool (struct ldb_dn *, unsigned int)
-ldb_dn_remove_child_components: bool (struct ldb_dn *, unsigned int)
-ldb_dn_remove_extended_components: void (struct ldb_dn *)
-ldb_dn_replace_components: bool (struct ldb_dn *, struct ldb_dn *)
-ldb_dn_set_component: int (struct ldb_dn *, int, const char *, const struct ldb_val)
-ldb_dn_set_extended_component: int (struct ldb_dn *, const char *, const struct ldb_val *)
-ldb_dn_update_components: int (struct ldb_dn *, const struct ldb_dn *)
-ldb_dn_validate: bool (struct ldb_dn *)
-ldb_dump_results: void (struct ldb_context *, struct ldb_result *, FILE *)
-ldb_error_at: int (struct ldb_context *, int, const char *, const char *, int)
-ldb_errstring: const char *(struct ldb_context *)
-ldb_extended: int (struct ldb_context *, const char *, void *, struct ldb_result **)
-ldb_extended_default_callback: int (struct ldb_request *, struct ldb_reply *)
-ldb_filter_attrs: int (struct ldb_context *, const struct ldb_message *, const char * const *, struct ldb_message *)
-ldb_filter_attrs_in_place: int (struct ldb_message *, const char * const *)
-ldb_filter_from_tree: char *(TALLOC_CTX *, const struct ldb_parse_tree *)
-ldb_get_config_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_get_create_perms: unsigned int (struct ldb_context *)
-ldb_get_default_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_get_event_context: struct tevent_context *(struct ldb_context *)
-ldb_get_flags: unsigned int (struct ldb_context *)
-ldb_get_opaque: void *(struct ldb_context *, const char *)
-ldb_get_root_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_get_schema_basedn: struct ldb_dn *(struct ldb_context *)
-ldb_global_init: int (void)
-ldb_handle_get_event_context: struct tevent_context *(struct ldb_handle *)
-ldb_handle_new: struct ldb_handle *(TALLOC_CTX *, struct ldb_context *)
-ldb_handle_use_global_event_context: void (struct ldb_handle *)
-ldb_handler_copy: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
-ldb_handler_fold: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
-ldb_init: struct ldb_context *(TALLOC_CTX *, struct tevent_context *)
-ldb_ldif_message_redacted_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
-ldb_ldif_message_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
-ldb_ldif_parse_modrdn: int (struct ldb_context *, const struct ldb_ldif *, TALLOC_CTX *, struct ldb_dn **, struct ldb_dn **, bool *, struct ldb_dn **, struct ldb_dn **)
-ldb_ldif_read: struct ldb_ldif *(struct ldb_context *, int (*)(void *), void *)
-ldb_ldif_read_file: struct ldb_ldif *(struct ldb_context *, FILE *)
-ldb_ldif_read_file_state: struct ldb_ldif *(struct ldb_context *, struct ldif_read_file_state *)
-ldb_ldif_read_free: void (struct ldb_context *, struct ldb_ldif *)
-ldb_ldif_read_string: struct ldb_ldif *(struct ldb_context *, const char **)
-ldb_ldif_write: int (struct ldb_context *, int (*)(void *, const char *, ...), void *, const struct ldb_ldif *)
-ldb_ldif_write_file: int (struct ldb_context *, FILE *, const struct ldb_ldif *)
-ldb_ldif_write_redacted_trace_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
-ldb_ldif_write_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
-ldb_load_modules: int (struct ldb_context *, const char **)
-ldb_map_add: int (struct ldb_module *, struct ldb_request *)
-ldb_map_delete: int (struct ldb_module *, struct ldb_request *)
-ldb_map_init: int (struct ldb_module *, const struct ldb_map_attribute *, const struct ldb_map_objectclass *, const char * const *, const char *, const char *)
-ldb_map_modify: int (struct ldb_module *, struct ldb_request *)
-ldb_map_rename: int (struct ldb_module *, struct ldb_request *)
-ldb_map_search: int (struct ldb_module *, struct ldb_request *)
-ldb_match_message: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, enum ldb_scope, bool *)
-ldb_match_msg: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope)
-ldb_match_msg_error: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope, bool *)
-ldb_match_msg_objectclass: int (const struct ldb_message *, const char *)
-ldb_match_scope: int (struct ldb_context *, struct ldb_dn *, struct ldb_dn *, enum ldb_scope)
-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_distinguished_name: int (struct ldb_message *)
-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_string_flags: int (struct ldb_message *, const char *, const char *, int)
-ldb_msg_add_value: int (struct ldb_message *, const char *, const struct ldb_val *, struct ldb_message_element **)
-ldb_msg_append_fmt: int (struct ldb_message *, int, const char *, const char *, ...)
-ldb_msg_append_linearized_dn: int (struct ldb_message *, const char *, struct ldb_dn *, int)
-ldb_msg_append_steal_string: int (struct ldb_message *, const char *, char *, int)
-ldb_msg_append_steal_value: int (struct ldb_message *, const char *, struct ldb_val *, int)
-ldb_msg_append_string: int (struct ldb_message *, const char *, const char *, int)
-ldb_msg_append_value: int (struct ldb_message *, const char *, const struct ldb_val *, int)
-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_add_value: int (TALLOC_CTX *, struct ldb_message_element *, const struct ldb_val *)
-ldb_msg_element_compare: int (struct ldb_message_element *, struct ldb_message_element *)
-ldb_msg_element_compare_name: int (struct ldb_message_element *, struct ldb_message_element *)
-ldb_msg_element_equal_ordered: bool (const struct ldb_message_element *, const struct ldb_message_element *)
-ldb_msg_element_is_inaccessible: bool (const struct ldb_message_element *)
-ldb_msg_element_mark_inaccessible: void (struct ldb_message_element *)
-ldb_msg_elements_take_ownership: int (struct ldb_message *)
-ldb_msg_find_attr_as_bool: int (const struct ldb_message *, const char *, int)
-ldb_msg_find_attr_as_dn: struct ldb_dn *(struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, const char *)
-ldb_msg_find_attr_as_double: double (const struct ldb_message *, const char *, double)
-ldb_msg_find_attr_as_int: int (const struct ldb_message *, const char *, int)
-ldb_msg_find_attr_as_int64: int64_t (const struct ldb_message *, const char *, int64_t)
-ldb_msg_find_attr_as_string: const char *(const struct ldb_message *, const char *, const char *)
-ldb_msg_find_attr_as_uint: unsigned int (const struct ldb_message *, const char *, unsigned int)
-ldb_msg_find_attr_as_uint64: uint64_t (const struct ldb_message *, const char *, uint64_t)
-ldb_msg_find_common_values: int (struct ldb_context *, TALLOC_CTX *, struct ldb_message_element *, struct ldb_message_element *, uint32_t)
-ldb_msg_find_duplicate_val: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message_element *, struct ldb_val **, uint32_t)
-ldb_msg_find_element: struct ldb_message_element *(const struct ldb_message *, const char *)
-ldb_msg_find_ldb_val: const struct ldb_val *(const struct ldb_message *, const char *)
-ldb_msg_find_val: struct ldb_val *(const struct ldb_message_element *, struct ldb_val *)
-ldb_msg_new: struct ldb_message *(TALLOC_CTX *)
-ldb_msg_normalize: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_message **)
-ldb_msg_remove_attr: void (struct ldb_message *, const char *)
-ldb_msg_remove_element: void (struct ldb_message *, struct ldb_message_element *)

_service:tar_scm:ldb-2.7.2.tar.gz/ABI/pyldb-util-2.7.1.sigs Deleted

_service:tar_scm:ldb-2.8.0.tar.asc Added

_service:tar_scm:ldb-2.8.0.tar.gz/ABI/ldb-2.8.0.sigs Added

@@ -0,0 +1,305 @@
+ldb_add: int (struct ldb_context *, const struct ldb_message *)
+ldb_any_comparison: int (struct ldb_context *, void *, ldb_attr_handler_t, const struct ldb_val *, const struct ldb_val *)
+ldb_asprintf_errstring: void (struct ldb_context *, const char *, ...)
+ldb_attr_casefold: char *(TALLOC_CTX *, const char *)
+ldb_attr_dn: int (const char *)
+ldb_attr_in_list: int (const char * const *, const char *)
+ldb_attr_list_copy: const char **(TALLOC_CTX *, const char * const *)
+ldb_attr_list_copy_add: const char **(TALLOC_CTX *, const char * const *, const char *)
+ldb_base64_decode: int (char *)
+ldb_base64_encode: char *(TALLOC_CTX *, const char *, int)
+ldb_binary_decode: struct ldb_val (TALLOC_CTX *, const char *)
+ldb_binary_encode: char *(TALLOC_CTX *, struct ldb_val)
+ldb_binary_encode_string: char *(TALLOC_CTX *, const char *)
+ldb_build_add_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
+ldb_build_del_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
+ldb_build_extended_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const char *, void *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
+ldb_build_mod_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
+ldb_build_rename_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, struct ldb_dn *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
+ldb_build_search_req: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, const char *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
+ldb_build_search_req_ex: int (struct ldb_request **, struct ldb_context *, TALLOC_CTX *, struct ldb_dn *, enum ldb_scope, struct ldb_parse_tree *, const char * const *, struct ldb_control **, void *, ldb_request_callback_t, struct ldb_request *)
+ldb_casefold: char *(struct ldb_context *, TALLOC_CTX *, const char *, size_t)
+ldb_casefold_default: char *(void *, TALLOC_CTX *, const char *, size_t)
+ldb_check_critical_controls: int (struct ldb_control **)
+ldb_comparison_binary: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
+ldb_comparison_fold: int (struct ldb_context *, void *, const struct ldb_val *, const struct ldb_val *)
+ldb_connect: int (struct ldb_context *, const char *, unsigned int, const char **)
+ldb_control_to_string: char *(TALLOC_CTX *, const struct ldb_control *)
+ldb_controls_except_specified: struct ldb_control **(struct ldb_control **, TALLOC_CTX *, struct ldb_control *)
+ldb_debug: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
+ldb_debug_add: void (struct ldb_context *, const char *, ...)
+ldb_debug_end: void (struct ldb_context *, enum ldb_debug_level)
+ldb_debug_set: void (struct ldb_context *, enum ldb_debug_level, const char *, ...)
+ldb_delete: int (struct ldb_context *, struct ldb_dn *)
+ldb_dn_add_base: bool (struct ldb_dn *, struct ldb_dn *)
+ldb_dn_add_base_fmt: bool (struct ldb_dn *, const char *, ...)
+ldb_dn_add_child: bool (struct ldb_dn *, struct ldb_dn *)
+ldb_dn_add_child_fmt: bool (struct ldb_dn *, const char *, ...)
+ldb_dn_add_child_val: bool (struct ldb_dn *, const char *, struct ldb_val)
+ldb_dn_alloc_casefold: char *(TALLOC_CTX *, struct ldb_dn *)
+ldb_dn_alloc_linearized: char *(TALLOC_CTX *, struct ldb_dn *)
+ldb_dn_canonical_ex_string: char *(TALLOC_CTX *, struct ldb_dn *)
+ldb_dn_canonical_string: char *(TALLOC_CTX *, struct ldb_dn *)
+ldb_dn_check_local: bool (struct ldb_module *, struct ldb_dn *)
+ldb_dn_check_special: bool (struct ldb_dn *, const char *)
+ldb_dn_compare: int (struct ldb_dn *, struct ldb_dn *)
+ldb_dn_compare_base: int (struct ldb_dn *, struct ldb_dn *)
+ldb_dn_copy: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
+ldb_dn_escape_value: char *(TALLOC_CTX *, struct ldb_val)
+ldb_dn_extended_add_syntax: int (struct ldb_context *, unsigned int, const struct ldb_dn_extended_syntax *)
+ldb_dn_extended_filter: void (struct ldb_dn *, const char * const *)
+ldb_dn_extended_syntax_by_name: const struct ldb_dn_extended_syntax *(struct ldb_context *, const char *)
+ldb_dn_from_ldb_val: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const struct ldb_val *)
+ldb_dn_get_casefold: const char *(struct ldb_dn *)
+ldb_dn_get_comp_num: int (struct ldb_dn *)
+ldb_dn_get_component_name: const char *(struct ldb_dn *, unsigned int)
+ldb_dn_get_component_val: const struct ldb_val *(struct ldb_dn *, unsigned int)
+ldb_dn_get_extended_comp_num: int (struct ldb_dn *)
+ldb_dn_get_extended_component: const struct ldb_val *(struct ldb_dn *, const char *)
+ldb_dn_get_extended_linearized: char *(TALLOC_CTX *, struct ldb_dn *, int)
+ldb_dn_get_ldb_context: struct ldb_context *(struct ldb_dn *)
+ldb_dn_get_linearized: const char *(struct ldb_dn *)
+ldb_dn_get_parent: struct ldb_dn *(TALLOC_CTX *, struct ldb_dn *)
+ldb_dn_get_rdn_name: const char *(struct ldb_dn *)
+ldb_dn_get_rdn_val: const struct ldb_val *(struct ldb_dn *)
+ldb_dn_has_extended: bool (struct ldb_dn *)
+ldb_dn_is_null: bool (struct ldb_dn *)
+ldb_dn_is_special: bool (struct ldb_dn *)
+ldb_dn_is_valid: bool (struct ldb_dn *)
+ldb_dn_map_local: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
+ldb_dn_map_rebase_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
+ldb_dn_map_remote: struct ldb_dn *(struct ldb_module *, void *, struct ldb_dn *)
+ldb_dn_minimise: bool (struct ldb_dn *)
+ldb_dn_new: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *)
+ldb_dn_new_fmt: struct ldb_dn *(TALLOC_CTX *, struct ldb_context *, const char *, ...)
+ldb_dn_remove_base_components: bool (struct ldb_dn *, unsigned int)
+ldb_dn_remove_child_components: bool (struct ldb_dn *, unsigned int)
+ldb_dn_remove_extended_components: void (struct ldb_dn *)
+ldb_dn_replace_components: bool (struct ldb_dn *, struct ldb_dn *)
+ldb_dn_set_component: int (struct ldb_dn *, int, const char *, const struct ldb_val)
+ldb_dn_set_extended_component: int (struct ldb_dn *, const char *, const struct ldb_val *)
+ldb_dn_update_components: int (struct ldb_dn *, const struct ldb_dn *)
+ldb_dn_validate: bool (struct ldb_dn *)
+ldb_dump_results: void (struct ldb_context *, struct ldb_result *, FILE *)
+ldb_error_at: int (struct ldb_context *, int, const char *, const char *, int)
+ldb_errstring: const char *(struct ldb_context *)
+ldb_extended: int (struct ldb_context *, const char *, void *, struct ldb_result **)
+ldb_extended_default_callback: int (struct ldb_request *, struct ldb_reply *)
+ldb_filter_attrs: int (struct ldb_context *, const struct ldb_message *, const char * const *, struct ldb_message *)
+ldb_filter_attrs_in_place: int (struct ldb_message *, const char * const *)
+ldb_filter_from_tree: char *(TALLOC_CTX *, const struct ldb_parse_tree *)
+ldb_get_config_basedn: struct ldb_dn *(struct ldb_context *)
+ldb_get_create_perms: unsigned int (struct ldb_context *)
+ldb_get_default_basedn: struct ldb_dn *(struct ldb_context *)
+ldb_get_event_context: struct tevent_context *(struct ldb_context *)
+ldb_get_flags: unsigned int (struct ldb_context *)
+ldb_get_opaque: void *(struct ldb_context *, const char *)
+ldb_get_root_basedn: struct ldb_dn *(struct ldb_context *)
+ldb_get_schema_basedn: struct ldb_dn *(struct ldb_context *)
+ldb_global_init: int (void)
+ldb_handle_get_event_context: struct tevent_context *(struct ldb_handle *)
+ldb_handle_new: struct ldb_handle *(TALLOC_CTX *, struct ldb_context *)
+ldb_handle_use_global_event_context: void (struct ldb_handle *)
+ldb_handler_copy: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
+ldb_handler_fold: int (struct ldb_context *, void *, const struct ldb_val *, struct ldb_val *)
+ldb_init: struct ldb_context *(TALLOC_CTX *, struct tevent_context *)
+ldb_ldif_message_redacted_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
+ldb_ldif_message_string: char *(struct ldb_context *, TALLOC_CTX *, enum ldb_changetype, const struct ldb_message *)
+ldb_ldif_parse_modrdn: int (struct ldb_context *, const struct ldb_ldif *, TALLOC_CTX *, struct ldb_dn **, struct ldb_dn **, bool *, struct ldb_dn **, struct ldb_dn **)
+ldb_ldif_read: struct ldb_ldif *(struct ldb_context *, int (*)(void *), void *)
+ldb_ldif_read_file: struct ldb_ldif *(struct ldb_context *, FILE *)
+ldb_ldif_read_file_state: struct ldb_ldif *(struct ldb_context *, struct ldif_read_file_state *)
+ldb_ldif_read_free: void (struct ldb_context *, struct ldb_ldif *)
+ldb_ldif_read_string: struct ldb_ldif *(struct ldb_context *, const char **)
+ldb_ldif_write: int (struct ldb_context *, int (*)(void *, const char *, ...), void *, const struct ldb_ldif *)
+ldb_ldif_write_file: int (struct ldb_context *, FILE *, const struct ldb_ldif *)
+ldb_ldif_write_redacted_trace_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
+ldb_ldif_write_string: char *(struct ldb_context *, TALLOC_CTX *, const struct ldb_ldif *)
+ldb_load_modules: int (struct ldb_context *, const char **)
+ldb_map_add: int (struct ldb_module *, struct ldb_request *)
+ldb_map_delete: int (struct ldb_module *, struct ldb_request *)
+ldb_map_init: int (struct ldb_module *, const struct ldb_map_attribute *, const struct ldb_map_objectclass *, const char * const *, const char *, const char *)
+ldb_map_modify: int (struct ldb_module *, struct ldb_request *)
+ldb_map_rename: int (struct ldb_module *, struct ldb_request *)
+ldb_map_search: int (struct ldb_module *, struct ldb_request *)
+ldb_match_message: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, enum ldb_scope, bool *)
+ldb_match_msg: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope)
+ldb_match_msg_error: int (struct ldb_context *, const struct ldb_message *, const struct ldb_parse_tree *, struct ldb_dn *, enum ldb_scope, bool *)
+ldb_match_msg_objectclass: int (const struct ldb_message *, const char *)
+ldb_match_scope: int (struct ldb_context *, struct ldb_dn *, struct ldb_dn *, enum ldb_scope)
+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_distinguished_name: int (struct ldb_message *)
+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_string_flags: int (struct ldb_message *, const char *, const char *, int)
+ldb_msg_add_value: int (struct ldb_message *, const char *, const struct ldb_val *, struct ldb_message_element **)
+ldb_msg_append_fmt: int (struct ldb_message *, int, const char *, const char *, ...)
+ldb_msg_append_linearized_dn: int (struct ldb_message *, const char *, struct ldb_dn *, int)
+ldb_msg_append_steal_string: int (struct ldb_message *, const char *, char *, int)
+ldb_msg_append_steal_value: int (struct ldb_message *, const char *, struct ldb_val *, int)
+ldb_msg_append_string: int (struct ldb_message *, const char *, const char *, int)
+ldb_msg_append_value: int (struct ldb_message *, const char *, const struct ldb_val *, int)
+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_add_value: int (TALLOC_CTX *, struct ldb_message_element *, const struct ldb_val *)
+ldb_msg_element_compare: int (struct ldb_message_element *, struct ldb_message_element *)
+ldb_msg_element_compare_name: int (struct ldb_message_element *, struct ldb_message_element *)
+ldb_msg_element_equal_ordered: bool (const struct ldb_message_element *, const struct ldb_message_element *)
+ldb_msg_element_is_inaccessible: bool (const struct ldb_message_element *)
+ldb_msg_element_mark_inaccessible: void (struct ldb_message_element *)
+ldb_msg_elements_take_ownership: int (struct ldb_message *)
+ldb_msg_find_attr_as_bool: int (const struct ldb_message *, const char *, int)
+ldb_msg_find_attr_as_dn: struct ldb_dn *(struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, const char *)
+ldb_msg_find_attr_as_double: double (const struct ldb_message *, const char *, double)
+ldb_msg_find_attr_as_int: int (const struct ldb_message *, const char *, int)
+ldb_msg_find_attr_as_int64: int64_t (const struct ldb_message *, const char *, int64_t)
+ldb_msg_find_attr_as_string: const char *(const struct ldb_message *, const char *, const char *)
+ldb_msg_find_attr_as_uint: unsigned int (const struct ldb_message *, const char *, unsigned int)
+ldb_msg_find_attr_as_uint64: uint64_t (const struct ldb_message *, const char *, uint64_t)
+ldb_msg_find_common_values: int (struct ldb_context *, TALLOC_CTX *, struct ldb_message_element *, struct ldb_message_element *, uint32_t)
+ldb_msg_find_duplicate_val: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message_element *, struct ldb_val **, uint32_t)
+ldb_msg_find_element: struct ldb_message_element *(const struct ldb_message *, const char *)
+ldb_msg_find_ldb_val: const struct ldb_val *(const struct ldb_message *, const char *)
+ldb_msg_find_val: struct ldb_val *(const struct ldb_message_element *, struct ldb_val *)
+ldb_msg_new: struct ldb_message *(TALLOC_CTX *)
+ldb_msg_normalize: int (struct ldb_context *, TALLOC_CTX *, const struct ldb_message *, struct ldb_message **)
+ldb_msg_remove_attr: void (struct ldb_message *, const char *)
+ldb_msg_remove_element: void (struct ldb_message *, struct ldb_message_element *)

_service:tar_scm:ldb-2.8.0.tar.gz/ABI/pyldb-util-2.8.0.sigs Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/examples/run_on_target.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/examples/run_on_target.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/configure_file.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/configure_file.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/pkgconfig.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/pkgconfig.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_abi.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_abi.py Changed

@@ -21,16 +21,16 @@
 def normalise_signature(sig):
     '''normalise a signature from gdb'''
     sig = sig.strip()
-    sig = re.sub('^\$0-9+\s=\s\{(.+)\}$', r'\1', sig)
-    sig = re.sub('^\$0-9+\s=\s\{(.+)\}(\s0x0-9a-f+\s<\w+>)+$', r'\1', sig)
-    sig = re.sub('^\$0-9+\s=\s(0x0-9a-f+)\s?(<\w+>)?$', r'\1', sig)
-    sig = re.sub('0x0-9a-f+', '0xXXXX', sig)
+    sig = re.sub(r'^\$0-9+\s=\s\{(.+)\}$', r'\1', sig)
+    sig = re.sub(r'^\$0-9+\s=\s\{(.+)\}(\s0x0-9a-f+\s<\w+>)+$', r'\1', sig)
+    sig = re.sub(r'^\$0-9+\s=\s(0x0-9a-f+)\s?(<\w+>)?$', r'\1', sig)
+    sig = re.sub(r'0x0-9a-f+', '0xXXXX', sig)
     sig = re.sub('", <incomplete sequence (\\\\a-z0-9+)>', r'\1"', sig)
 
     for t in abi_type_maps:
         # we need to cope with non-word characters in mapped types
         m = t
-        m = m.replace('*', '\*')
+        m = m.replace('*', r'\*')
         if m-1.isalnum() or m-1 == '_':
             m += '\\b'
         if m0.isalnum() or m0 == '_':
@@ -41,8 +41,9 @@
 
 def normalise_varargs(sig):
     '''cope with older versions of gdb'''
-    sig = re.sub(',\s\.\.\.', '', sig)
-    return sig
+    sig = re.sub(r',\s\.\.\.', '', sig)
+    # Make sure we compare bytes and not strings
+    return bytes(sig, encoding='utf-8').decode('unicode_escape')
 
 
 def parse_sigs(sigs, abi_match):

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_autoconf.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_autoconf.py Changed

@@ -364,7 +364,7 @@
     return False
 
 @conf
-def CHECK_VALUEOF(conf, v, headers=None, define=None):
+def CHECK_VALUEOF(conf, v, headers=None, define=None, lib=None):
     '''check the value of a variable/define'''
     ret = True
     v_define = define
@@ -376,6 +376,7 @@
                   execute=True,
                   define_ret=True,
                   quote=False,
+                  lib=lib,
                   headers=headers,
                   local_include=False,
                   msg="Checking value of %s" % v):
@@ -830,8 +831,10 @@
     if (Options.options.address_sanitizer or
         Options.options.undefined_sanitizer):
         conf.ADD_CFLAGS('-g -O1', testflags=True)
-    if Options.options.address_sanitizer:
+    if (Options.options.address_sanitizer
+       or Options.options.memory_sanitizer):
         conf.ADD_CFLAGS('-fno-omit-frame-pointer', testflags=True)
+    if Options.options.address_sanitizer:
         conf.ADD_CFLAGS('-fsanitize=address', testflags=True)
         conf.ADD_LDFLAGS('-fsanitize=address', testflags=True)
         conf.env'ADDRESS_SANITIZER' = True
@@ -842,6 +845,13 @@
         conf.ADD_LDFLAGS('-fsanitize=undefined', testflags=True)
         conf.env'UNDEFINED_SANITIZER' = True
 
+    # MemorySanitizer is only available if you build with clang
+    if Options.options.memory_sanitizer:
+        conf.ADD_CFLAGS('-g -O2', testflags=True)
+        conf.ADD_CFLAGS('-fsanitize=memory', testflags=True)
+        conf.ADD_CFLAGS('-fsanitize-memory-track-origins=2', testflags=True)
+        conf.ADD_LDFLAGS('-fsanitize=memory')
+        conf.env'MEMORY_SANITIZER' = True
 
     # Let people pass an additional ADDITIONAL_{CFLAGS,LDFLAGS}
     # environment variables which are only used the for final build.
@@ -883,10 +893,12 @@
             conf.envname = conf.env'PREFIX' + default
 
 @conf
-def ADD_NAMED_CFLAGS(conf, name, flags, testflags=False, prereq_flags=):
+def ADD_NAMED_CFLAGS(conf, name, flags, testflags=False, prereq_flags=None):
     '''add some CFLAGS to the command line
        optionally set testflags to ensure all the flags work
     '''
+    if prereq_flags is None:
+        prereq_flags = 
     prereq_flags = TO_LIST(prereq_flags)
     if testflags:
         ok_flags=
@@ -899,10 +911,12 @@
     conf.envname.extend(TO_LIST(flags))
 
 @conf
-def ADD_CFLAGS(conf, flags, testflags=False, prereq_flags=):
+def ADD_CFLAGS(conf, flags, testflags=False, prereq_flags=None):
     '''add some CFLAGS to the command line
        optionally set testflags to ensure all the flags work
     '''
+    if prereq_flags is None:
+        prereq_flags = 
     ADD_NAMED_CFLAGS(conf, 'EXTRA_CFLAGS', flags, testflags=testflags,
                      prereq_flags=prereq_flags)
 
@@ -969,7 +983,7 @@
     '''enable/disable cache of configure results'''
     if enable:
         # when -C is chosen, we will use a private cache and will
-        # not look into system includes. This roughtly matches what
+        # not look into system includes. This roughly matches what
         # autoconf does with -C
         cache_path = os.path.join(conf.bldnode.abspath(), '.confcache')
         mkdir_p(cache_path)
@@ -986,7 +1000,9 @@
 
 @conf
 def SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS(conf):
-    if Options.options.address_sanitizer or Options.options.enable_libfuzzer:
+    if (Options.options.address_sanitizer
+       or Options.options.memory_sanitizer
+       or Options.options.enable_libfuzzer):
         # Sanitizers can rely on symbols undefined at library link time and the
         # symbols used for fuzzers are only defined by compiler wrappers.
         return

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_bundled.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_bundled.py Changed

@@ -57,7 +57,7 @@
 
 
 def minimum_library_version(conf, libname, default):
-    '''allow override of mininum system library version'''
+    '''allow override of minimum system library version'''
 
     minlist = Options.options.MINIMUM_LIBRARY_VERSION
     if not minlist:
@@ -104,12 +104,14 @@
 
 @conf
 def CHECK_BUNDLED_SYSTEM_PKG(conf, libname, minversion='0.0.0',
-        maxversion=None, version_blacklist=,
+        maxversion=None, version_blacklist=None,
         onlyif=None, implied_deps=None, pkg=None):
     '''check if a library is available as a system library.
 
     This only tries using pkg-config
     '''
+    if version_blacklist is None:
+        version_blacklist = 
     return conf.CHECK_BUNDLED_SYSTEM(libname,
                                      minversion=minversion,
                                      maxversion=maxversion,
@@ -120,7 +122,7 @@
 
 @conf
 def CHECK_BUNDLED_SYSTEM(conf, libname, minversion='0.0.0',
-                         maxversion=None, version_blacklist=,
+                         maxversion=None, version_blacklist=None,
                          checkfunctions=None, headers=None, checkcode=None,
                          onlyif=None, implied_deps=None,
                          require_headers=True, pkg=None, set_target=True):
@@ -129,6 +131,8 @@
     tries by testing for a specified function in the specified lib
     '''
     # We always do a logic validation of 'onlyif' first
+    if version_blacklist is None:
+        version_blacklist = 
     missing = 
     if onlyif:
         for l in samba_utils.TO_LIST(onlyif):

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_conftests.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_conftests.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_git.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_git.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_headers.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_headers.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_third_party.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_third_party.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_utils.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_utils.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_version.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_version.py Changed

@@ -235,22 +235,22 @@
 def samba_version_file(version_file, path, env=None, is_install=True):
     '''Parse the version information from a VERSION file'''
 
-    f = open(version_file, 'r')
-    version_dict = {}
-    for line in f:
-        line = line.strip()
-        if line == '':
-            continue
-        if line.startswith("#"):
-            continue
-        try:
-            split_line = line.split("=")
-            if split_line1 != "":
-                value = split_line1.strip('"')
-                version_dictsplit_line0 = value
-        except:
-            print("Failed to parse line %s from %s" % (line, version_file))
-            raise
+    with open(version_file, 'r') as f:
+        version_dict = {}
+        for line in f:
+            line = line.strip()
+            if line == '':
+                continue
+            if line.startswith("#"):
+                continue
+            try:
+                split_line = line.split("=")
+                if split_line1 != "":
+                    value = split_line1.strip('"')
+                    version_dictsplit_line0 = value
+            except:
+                print("Failed to parse line %s from %s" % (line, version_file))
+                raise
 
     return SambaVersion(version_dict, path, env=env, is_install=is_install)

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/samba_waf18.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/samba_waf18.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/symbols.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/symbols.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/wafsamba.py -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/wafsamba.py Changed

_service:tar_scm:ldb-2.7.2.tar.gz/buildtools/wafsamba/wscript -> _service:tar_scm:ldb-2.8.0.tar.gz/buildtools/wafsamba/wscript Changed

@@ -118,7 +118,7 @@
                    action="store_true", dest='disable_rpath_private_install', default=False)
     gr.add_option('--nonshared-binary',
                    help=(
-f'''Disable use of shared libaries internal to {Context.g_module.APPNAME} for the listed binaries.
+f'''Disable use of shared libraries internal to {Context.g_module.APPNAME} for the listed binaries.
 
 The resulting binaries are 'statically linked' with regard to components provided by
 {Context.g_module.APPNAME}, but remain dynamically linked to (eg) libc.so and libgnutls.so
@@ -189,6 +189,11 @@
         action="store_true",
         dest='undefined_sanitizer',
         default=False)
+    gr.add_option('--memory-sanitizer',
+        help=("Enable memory behaviour sanitizer compile and linker flags"),
+        action="store_true",
+        dest='memory_sanitizer',
+        default=False)
     gr.add_option('--enable-libfuzzer',
                   help=("Build fuzzing binaries (use ADDITIONAL_CFLAGS to specify compiler options for libFuzzer or use CC=honggfuzz/hfuzz-cc)"),
                   action="store_true", dest='enable_libfuzzer', default=False)
@@ -373,7 +378,7 @@
     conf.CHECK_CODE('printf("hello world")',
                     define='HAVE_SIMPLE_C_PROG',
                     mandatory=True,
-                    execute=True,
+                    execute=not conf.env.CROSS_COMPILE,
                     headers='stdio.h',
                     msg='Checking simple C program')
 
@@ -523,7 +528,8 @@
             strict=True,
             msg='Checking for __attribute__')
 
-    # Solaris by defauls uses draft versions of some functions unless you set _POSIX_PTHREAD_SEMANTICS
+    # Solaris by default uses draft versions of some functions unless you set
+    # _POSIX_PTHREAD_SEMANTICS
     if sys.platform.startswith('sunos'):
         conf.DEFINE('_POSIX_PTHREAD_SEMANTICS', 1)
 
@@ -705,11 +711,6 @@
                     define="HAVE_VA_COPY",
                     msg="Checking for va_copy")
 
-    conf.CHECK_CODE('''
-                    #define eprintf(...) fprintf(stderr, __VA_ARGS__)
-                    eprintf("bla", "bar")
-                    ''', define='HAVE__VA_ARGS__MACRO')
-
     conf.env.enable_fuzzing = False
 
     conf.env.enable_libfuzzer = Options.options.enable_libfuzzer
@@ -719,11 +720,6 @@
         conf.DEFINE('FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION', 1)
         conf.env.FUZZ_TARGET_LDFLAGS = Options.options.FUZZ_TARGET_LDFLAGS
 
-    # Create a symlink of the compile db for clangd
-    symlink(os.path.join(conf.bldnode.abspath(), 'default/compile_commands.json'),
-            os.path.join(conf.srcnode.abspath(), 'compile_commands.json'),
-            force=True)
-
     conf.SAMBA_BUILD_ENV()

_service:tar_scm:ldb-2.7.2.tar.gz/common/attrib_handlers.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/attrib_handlers.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/common/ldb.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/ldb.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/common/ldb_controls.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/ldb_controls.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/common/ldb_ldif.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/ldb_ldif.c Changed

@@ -343,7 +343,7 @@
 		}
 
 		if (in_trace && secret_attributes && ldb_attr_in_list(secret_attributes, msg->elementsi.name)) {
-			/* Deliberatly skip printing this password */
+			/* Deliberately skip printing this password */
 			ret = fprintf_fn(private_data, "# %s::: REDACTED SECRET ATTRIBUTE\n",
 					 msg->elementsi.name);
 			CHECK_RET;
@@ -584,6 +584,7 @@
 			  struct ldb_dn **_newdn)
 {
 	struct ldb_message *msg = ldif->msg;
+	struct ldb_val _newrdn_val = {};
 	struct ldb_val *newrdn_val = NULL;
 	struct ldb_val *deleteoldrdn_val = NULL;
 	struct ldb_val *newsuperior_val = NULL;
@@ -667,6 +668,25 @@
 		goto err_op;
 	}
 
+	if (newrdn_val->length != 0 && strchr((const char *)newrdn_val->data, '=') == NULL) {
+		const char *rdn_name = ldb_dn_get_rdn_name(olddn);
+		char *new_rdn = NULL;
+
+		new_rdn = talloc_asprintf(tmp_ctx,
+					  "%s=%s",
+					  rdn_name,
+					  (const char *)newrdn_val->data);
+		if (new_rdn == NULL) {
+			ldb_debug(ldb, LDB_DEBUG_ERROR,
+				  "Error: failed to allocate '%s=%s'",
+				  rdn_name, (char *)newrdn_val->data);
+			goto err_op;
+		}
+		_newrdn_val.data = (uint8_t *)new_rdn;
+		_newrdn_val.length = strlen(new_rdn);
+		newrdn_val = &_newrdn_val;
+	}
+
 	newrdn = ldb_dn_from_ldb_val(tmp_ctx, ldb, newrdn_val);
 	if (!ldb_dn_validate(newrdn)) {
 		ldb_debug(ldb, LDB_DEBUG_ERROR,
@@ -858,12 +878,12 @@
 			continue;
 		}
 
-		el = &msg->elementsmsg->num_elements-1;
-
 		a = ldb_schema_attribute_by_name(ldb, attr);
+		el = (msg->num_elements > 0
+		      ? &msg->elementsmsg->num_elements - 1
+		      : NULL);
 
-		if (msg->num_elements > 0 && ldb_attr_cmp(attr, el->name) == 0 &&
-		    flags == el->flags) {
+		if (el && ldb_attr_cmp(attr, el->name) == 0 && flags == el->flags) {
 			/* its a continuation */
 			el->values =
 				talloc_realloc(msg->elements, el->values,

_service:tar_scm:ldb-2.7.2.tar.gz/common/ldb_match.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/ldb_match.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/common/ldb_msg.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/ldb_msg.c Changed

@@ -58,7 +58,7 @@
 
 /*
   see if two ldb_val structures contain exactly the same data
-  return 1 for a match, 0 for a mis-match
+  return 1 for a match, 0 for a mismatch
 */
 int ldb_val_equal_exact(const struct ldb_val *v1, const struct ldb_val *v2)
 {
@@ -569,8 +569,6 @@
 
 /*
   add a DN element to a message
-  WARNING: this uses the linearized string from the dn, and does not
-  copy the string.
 */
 int ldb_msg_add_linearized_dn(struct ldb_message *msg, const char *attr_name,
 			      struct ldb_dn *dn)
@@ -703,8 +701,6 @@
 
 /*
   append a DN element to a message
-  WARNING: this uses the linearized string from the dn, and does not
-  copy the string.
 */
 int ldb_msg_append_linearized_dn(struct ldb_message *msg, const char *attr_name,
 				 struct ldb_dn *dn, int flags)
@@ -903,64 +899,82 @@
 				   const char *attr_name,
 				   int64_t default_value)
 {
+	int64_t val = 0;
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	int ret = ldb_val_as_int64(v, &val);
+	return ret ? default_value : val;
+}
+
+int ldb_val_as_int64(const struct ldb_val *v, int64_t *val)
+{
 	char bufsizeof("-9223372036854775808");
 	char *end = NULL;
-	int64_t ret;
+	int64_t result;
 
 	if (!v || !v->data) {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ZERO_STRUCT(buf);
 	if (v->length >= sizeof(buf)) {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	memcpy(buf, v->data, v->length);
 	errno = 0;
-	ret = (int64_t) strtoll(buf, &end, 10);
+	result = (int64_t) strtoll(buf, &end, 10);
 	if (errno != 0) {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	if (end && end0 != '\0') {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	return ret;
+
+	*val = result;
+	return LDB_SUCCESS;
 }
 
 uint64_t ldb_msg_find_attr_as_uint64(const struct ldb_message *msg,
 				     const char *attr_name,
 				     uint64_t default_value)
 {
+	uint64_t val = 0;
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	int ret = ldb_val_as_uint64(v, &val);
+	return ret ? default_value : val;
+}
+
+int ldb_val_as_uint64(const struct ldb_val *v, uint64_t *val)
+{
 	char bufsizeof("-9223372036854775808");
 	char *end = NULL;
-	uint64_t ret;
+	uint64_t result;
 
 	if (!v || !v->data) {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	ZERO_STRUCT(buf);
 	if (v->length >= sizeof(buf)) {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 
 	memcpy(buf, v->data, v->length);
 	errno = 0;
-	ret = (uint64_t) strtoll(buf, &end, 10);
+	result = (uint64_t) strtoll(buf, &end, 10);
 	if (errno != 0) {
 		errno = 0;
-		ret = (uint64_t) strtoull(buf, &end, 10);
+		result = (uint64_t) strtoull(buf, &end, 10);
 		if (errno != 0) {
-			return default_value;
+			return LDB_ERR_OPERATIONS_ERROR;
 		}
 	}
 	if (end && end0 != '\0') {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
-	return ret;
+
+	*val = result;
+	return LDB_SUCCESS;
 }
 
 double ldb_msg_find_attr_as_double(const struct ldb_message *msg,
@@ -996,17 +1010,26 @@
 			      const char *attr_name,
 			      int default_value)
 {
+	bool val = false;
 	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	int ret = ldb_val_as_bool(v, &val);
+	return ret ? default_value : val;
+}
+
+int ldb_val_as_bool(const struct ldb_val *v, bool *val)
+{
 	if (!v || !v->data) {
-		return default_value;
+		return LDB_ERR_OPERATIONS_ERROR;
 	}
 	if (v->length == 5 && strncasecmp((const char *)v->data, "FALSE", 5) == 0) {
-		return 0;
+		*val = false;
+		return LDB_SUCCESS;
 	}
 	if (v->length == 4 && strncasecmp((const char *)v->data, "TRUE", 4) == 0) {
-		return 1;
+		*val = true;
+		return LDB_SUCCESS;
 	}
-	return default_value;
+	return LDB_ERR_OPERATIONS_ERROR;
 }
 
 const char *ldb_msg_find_attr_as_string(const struct ldb_message *msg,
@@ -1028,10 +1051,16 @@
 				       const struct ldb_message *msg,
 				       const char *attr_name)
 {
+	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
+	return ldb_val_as_dn(ldb, mem_ctx, v);
+}
+
+struct ldb_dn *ldb_val_as_dn(struct ldb_context *ldb,
+			     TALLOC_CTX *mem_ctx,
+			     const struct ldb_val *v)
+{
 	struct ldb_dn *res_dn;
-	const struct ldb_val *v;
 
-	v = ldb_msg_find_ldb_val(msg, attr_name);
 	if (!v || !v->data) {
 		return NULL;
 	}
@@ -1490,11 +1519,18 @@
 */
 void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
 {
-	struct ldb_message_element *el;
+	unsigned int i;
+	unsigned int num_del = 0;
 
-	while ((el = ldb_msg_find_element(msg, attr)) != NULL) {
-		ldb_msg_remove_element(msg, el);
+	for (i = 0; i < msg->num_elements; ++i) {
+		if (ldb_attr_cmp(msg->elementsi.name, attr) == 0) {
+			++num_del;
+		} else if (num_del) {
+			msg->elementsi - num_del = msg->elementsi;
+		}
 	}
+
+	msg->num_elements -= num_del;
 }
 
 /* Reallocate elements to drop any excess capacity. */
@@ -1526,7 +1562,7 @@
 		return NULL;
 	}

_service:tar_scm:ldb-2.7.2.tar.gz/common/ldb_pack.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/ldb_pack.c Changed

@@ -122,7 +122,7 @@
 	size += dn_len;
 
 	/*
-	 * First calcuate the buffer size we need, and check for
+	 * First calculate the buffer size we need, and check for
 	 * overflows
 	 */
 	for (i=0;i<message->num_elements;i++) {
@@ -610,6 +610,7 @@
 	}
 
 	if (flags & LDB_UNPACK_DATA_FLAG_NO_ATTRS) {
+		message->num_elements = 0;
 		return 0;
 	}
 	
@@ -785,7 +786,7 @@
 	p += U32_LEN;
 
 	/* First fields are fixed: num_elements, DN length */
-	if (p + U32_LEN * 2 > end_p) {
+	if (U32_LEN * 2 > end_p - p) {
 		errno = EIO;
 		goto failed;
 	}
@@ -796,7 +797,7 @@
 	len = PULL_LE_U32(p, 0);
 	p += U32_LEN;
 
-	if (p + len + NULL_PAD_BYTE_LEN > end_p) {
+	if (len + NULL_PAD_BYTE_LEN > end_p - p) {
 		errno = EIO;
 		goto failed;
 	}
@@ -825,7 +826,7 @@
 	len = PULL_LE_U32(p, 0) + NULL_PAD_BYTE_LEN;
 	p += U32_LEN;
 
-	if (p + len > end_p) {
+	if (len > end_p - p) {
 		errno = EIO;
 		goto failed;
 	}
@@ -838,6 +839,7 @@
 	}
 
 	if (flags & LDB_UNPACK_DATA_FLAG_NO_ATTRS) {
+		message->num_elements = 0;
 		return 0;
 	}
 
@@ -890,10 +892,10 @@
 		struct ldb_message_element *element = NULL;
 
 		/* Sanity check: minimum element size */
-		if (p + (U32_LEN * 2) + /* attr name len, num values */
+		if ((U32_LEN * 2) + /* attr name len, num values */
 			(U8_LEN * 2) + /* value length width, one val length */
 			(NULL_PAD_BYTE_LEN * 2) /* null for attr name + val */
-			> value_section_p) {
+			> value_section_p - p) {
 			errno = EIO;
 			goto failed;
 		}
@@ -914,7 +916,7 @@
 		 * val_len_width is the width specifier
 		 * for the variable length encoding
 		 */
-		if (p + U32_LEN + U8_LEN > value_section_p) {
+		if (U32_LEN + U8_LEN > value_section_p - p) {
 			errno = EIO;
 			goto failed;
 		}
@@ -954,8 +956,8 @@
 		val_len_width = *p;
 		p += U8_LEN;
 
-		if (p + val_len_width * element->num_values >
-		    value_section_p) {
+		if (val_len_width * element->num_values >
+		    value_section_p - p) {
 			errno = EIO;
 			goto failed;
 		}
@@ -992,7 +994,7 @@
 				errno = EIO;
 				goto failed;
 			}
-			if (q + len + NULL_PAD_BYTE_LEN > end_p) {
+			if (len + NULL_PAD_BYTE_LEN > end_p - q) {
 				errno = EIO;
 				goto failed;
 			}

_service:tar_scm:ldb-2.7.2.tar.gz/common/ldb_parse.c -> _service:tar_scm:ldb-2.8.0.tar.gz/common/ldb_parse.c Changed

@@ -799,27 +799,27 @@
 		ret = s;
 		return ret;
 	case LDB_OP_GREATER:
-		s = ldb_binary_encode(mem_ctx, tree->u.equality.value);
+		s = ldb_binary_encode(mem_ctx, tree->u.comparison.value);
 		if (s == NULL) return NULL;
 		ret = talloc_asprintf(mem_ctx, "(%s>=%s)", 
-				      tree->u.equality.attr, s);
+				      tree->u.comparison.attr, s);
 		talloc_free(s);
 		return ret;
 	case LDB_OP_LESS:
-		s = ldb_binary_encode(mem_ctx, tree->u.equality.value);
+		s = ldb_binary_encode(mem_ctx, tree->u.comparison.value);
 		if (s == NULL) return NULL;
 		ret = talloc_asprintf(mem_ctx, "(%s<=%s)", 
-				      tree->u.equality.attr, s);
+				      tree->u.comparison.attr, s);
 		talloc_free(s);
 		return ret;
 	case LDB_OP_PRESENT:
 		ret = talloc_asprintf(mem_ctx, "(%s=*)", tree->u.present.attr);
 		return ret;
 	case LDB_OP_APPROX:
-		s = ldb_binary_encode(mem_ctx, tree->u.equality.value);
+		s = ldb_binary_encode(mem_ctx, tree->u.comparison.value);
 		if (s == NULL) return NULL;
 		ret = talloc_asprintf(mem_ctx, "(%s~=%s)", 
-				      tree->u.equality.attr, s);
+				      tree->u.comparison.attr, s);
 		talloc_free(s);
 		return ret;
 	case LDB_OP_EXTENDED:
@@ -895,11 +895,15 @@
 	struct parse_tree_attr_replace_ctx *ctx = private_context;
 	switch (tree->operation) {
 	case LDB_OP_EQUALITY:
+		if (ldb_attr_cmp(tree->u.equality.attr, ctx->attr) == 0) {
+			tree->u.equality.attr = ctx->replace;
+		}
+		break;
 	case LDB_OP_GREATER:
 	case LDB_OP_LESS:
 	case LDB_OP_APPROX:
-		if (ldb_attr_cmp(tree->u.equality.attr, ctx->attr) == 0) {
-			tree->u.equality.attr = ctx->replace;
+		if (ldb_attr_cmp(tree->u.comparison.attr, ctx->attr) == 0) {
+			tree->u.comparison.attr = ctx->replace;
 		}
 		break;
 	case LDB_OP_SUBSTRING:

_service:tar_scm:ldb-2.7.2.tar.gz/include/dlinklist.h -> _service:tar_scm:ldb-2.8.0.tar.gz/include/dlinklist.h Changed

_service:tar_scm:ldb-2.7.2.tar.gz/include/ldb.h -> _service:tar_scm:ldb-2.8.0.tar.gz/include/ldb.h Changed

@@ -155,16 +155,16 @@
 #define LDB_FLAG_INTERNAL_MASK 0xFFFFFFF0
 
 /**
-  OID for logic AND comaprison.
+  OID for logic AND comparison.
 
-  This is the well known object ID for a logical AND comparitor.
+  This is the well known object ID for a logical AND comparator.
 */
 #define LDB_OID_COMPARATOR_AND  "1.2.840.113556.1.4.803"
 
 /**
   OID for logic OR comparison.
 
-  This is the well known object ID for a logical OR comparitor.
+  This is the well known object ID for a logical OR comparator.
 */
 #define LDB_OID_COMPARATOR_OR   "1.2.840.113556.1.4.804"
 
@@ -817,6 +817,11 @@
 */
 #define LDB_EXTENDED_DYNAMIC_OID	"1.3.6.1.4.1.1466.101.119.1"
 
+/**
+   OID for RFC4532 "Who Am I" extended operation
+*/
+#define LDB_EXTENDED_WHOAMI_OID		"1.3.6.1.4.1.4203.1.11.3"
+
 struct ldb_sd_flags_control {
 	/*
 	 * request the owner	0x00000001
@@ -1185,8 +1190,8 @@
   \param attrs the search attributes for the query (pass NULL if none required)
   \param controls an array of controls
   \param context the callback function context
-  \param the callback function to handle the async replies
-  \param the parent request if any
+  \param callback the callback function to handle the async replies
+  \param parent the parent request if any
 
   \return result code (LDB_SUCCESS on success, or a failure code)
 */
@@ -1224,8 +1229,8 @@
   \param message contains the entry to be added
   \param controls an array of controls
   \param context the callback function context
-  \param the callback function to handle the async replies
-  \param the parent request if any
+  \param callback the callback function to handle the async replies
+  \param parent the parent request if any
 
   \return result code (LDB_SUCCESS on success, or a failure code)
 */
@@ -1248,8 +1253,8 @@
   \param message contains the entry to be modified
   \param controls an array of controls
   \param context the callback function context
-  \param the callback function to handle the async replies
-  \param the parent request if any
+  \param callback the callback function to handle the async replies
+  \param parent the parent request if any
 
   \return result code (LDB_SUCCESS on success, or a failure code)
 */
@@ -1272,8 +1277,8 @@
   \param dn the DN to be deleted
   \param controls an array of controls
   \param context the callback function context
-  \param the callback function to handle the async replies
-  \param the parent request if any
+  \param callback the callback function to handle the async replies
+  \param parent the parent request if any
 
   \return result code (LDB_SUCCESS on success, or a failure code)
 */
@@ -1297,8 +1302,8 @@
   \param newdn the new DN
   \param controls an array of controls
   \param context the callback function context
-  \param the callback function to handle the async replies
-  \param the parent request if any
+  \param callback the callback function to handle the async replies
+  \param parent the parent request if any
 
   \return result code (LDB_SUCCESS on success, or a failure code)
 */
@@ -1470,8 +1475,8 @@
   it needs to be NULL or a valid talloc pointer! talloc_get_type() will be used on it
   \param controls an array of controls
   \param context the callback function context
-  \param the callback function to handle the async replies
-  \param the parent request if any
+  \param callback the callback function to handle the async replies
+  \param parent the parent request if any
 
   \return result code (LDB_SUCCESS on success, or a failure code)
 */
@@ -2343,7 +2348,7 @@
 */
 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
+   Convert an array of string representation of a control into an array of ldb_control structures
 
    \param ldb LDB context
    \param mem_ctx TALLOC context to return result on, and to allocate error_string on

_service:tar_scm:ldb-2.7.2.tar.gz/include/ldb_module.h -> _service:tar_scm:ldb-2.8.0.tar.gz/include/ldb_module.h Changed

@@ -39,7 +39,7 @@
 
 /*
  * Versions before 1.2.0 doesn't define these values
- * so we assime 1.1.29 (which was used in Samba 4.6)
+ * so we assume 1.1.29 (which was used in Samba 4.6)
  *
  * See https://bugzilla.samba.org/show_bug.cgi?id=12859
  */
@@ -103,8 +103,8 @@
 #define LDB_FLAG_INTERNAL_SHARED_VALUES 0x200
 
 /*
- * this attribute has been access checked. We know the user has the right to
- * view it. Used internally in Samba aclread module.
+ * this attribute has been access checked. Used internally in Samba aclread
+ * module.
  */
 #define LDB_FLAG_INTERNAL_ACCESS_CHECKED 0x400
 
@@ -629,4 +629,12 @@
  *
  */
 const char **ldb_options_get(struct ldb_context *ldb);
+
+struct ldb_dn *ldb_val_as_dn(struct ldb_context *ldb,
+			     TALLOC_CTX *mem_ctx,
+			     const struct ldb_val *v);
+int ldb_val_as_int64(const struct ldb_val *v, int64_t *val);
+int ldb_val_as_uint64(const struct ldb_val *v, uint64_t *val);
+int ldb_val_as_bool(const struct ldb_val *v, bool *val);
+
 #endif

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_key_value/ldb_kv.c -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_key_value/ldb_kv.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_key_value/ldb_kv.h -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_key_value/ldb_kv.h Changed

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_key_value/ldb_kv_cache.c -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_key_value/ldb_kv_cache.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_key_value/ldb_kv_index.c -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_key_value/ldb_kv_index.c Changed

@@ -62,7 +62,7 @@
 (This allows a scope BASE search to directly find the record via
 a simple casefold of the DN).
 
-The original mixed-case DN is stored in the entry iself.
+The original mixed-case DN is stored in the entry itself.
 
 
 The new 'GUID index' format is:
@@ -72,7 +72,7 @@
 @IDXVERSION: 3
 @IDX: <binary GUID><binary GUID>...
 
-The binary guid is 16 bytes, as bytes and not expanded as hexidecimal
+The binary guid is 16 bytes, as bytes and not expanded as hexadecimal
 or pretty-printed.  The GUID is chosen from the message to be stored
 by the @IDXGUID attribute on @INDEXLIST.
 
@@ -84,7 +84,7 @@
 GUID=<binary GUID>
 
 This allows a very quick translation between the fixed-length index
-values and the TDB key, while seperating entries from other data
+values and the TDB key, while separating entries from other data
 in the TDB, should they be unlucky enough to start with the bytes of
 the 'DN=' prefix.
 
@@ -1148,7 +1148,7 @@
 		}
 		talloc_free(vstr);
 	} else {
-		/* Only need two seperators */
+		/* Only need two separators */
 		num_separators = 2;
 
 		/*
@@ -1197,7 +1197,7 @@
 
 	if ((ldb_kv->cache->GUID_index_attribute != NULL) &&
 	    (ldb_attr_cmp(attr, ldb_kv->cache->GUID_index_attribute) == 0)) {
-		/* Implicity covered, this is the index key */
+		/* Implicitly covered, this is the index key */
 		return false;
 	}
 	if (ldb->schema.index_handler_override) {
@@ -2496,7 +2496,7 @@
 		ret = ldb_module_send_entry(ac->req, msg, NULL);
 		if (ret != LDB_SUCCESS) {
 			/* Regardless of success or failure, the msg
-			 * is the callbacks responsiblity, and should
+			 * is the callbacks responsibility, and should
 			 * not be talloc_free()'ed */
 			ac->request_terminated = true;
 			talloc_free(keys);
@@ -2916,7 +2916,7 @@
 	}
 
 	/* overallocate the list a bit, to reduce the number of
-	 * realloc trigered copies */
+	 * realloc triggered copies */
 	alloc_len = ((list->count+1)+7) & ~7;
 	list->dn = talloc_realloc(list, list->dn, struct ldb_val, alloc_len);
 	if (list->dn == NULL) {

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_key_value/ldb_kv_search.c -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_key_value/ldb_kv_search.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_map/ldb_map_outbound.c -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_map/ldb_map_outbound.c Changed

@@ -546,6 +546,7 @@
 /* Collect a list of attributes required to match a given parse tree. */
 static int ldb_parse_tree_collect_attrs(struct ldb_module *module, void *mem_ctx, const char ***attrs, const struct ldb_parse_tree *tree)
 {
+	const char *attr = NULL;
 	const char **new_attrs;
 	unsigned int i;
 	int ret;
@@ -570,7 +571,11 @@
 		return ldb_parse_tree_collect_attrs(module, mem_ctx, attrs, tree->u.isnot.child);
 
 	default:			/* single attribute in tree */
-		new_attrs = ldb_attr_list_copy_add(mem_ctx, *attrs, tree->u.equality.attr);
+		attr = ldb_parse_tree_get_attr(tree);
+		new_attrs = ldb_attr_list_copy_add(mem_ctx, *attrs, attr);
+		if (new_attrs == NULL) {
+			return ldb_module_oom(module);
+		}
 		talloc_free(*attrs);
 		*attrs = new_attrs;
 		return 0;
@@ -1154,7 +1159,7 @@
 	}
 
 	/* TODO: How can we be sure about which partition we are
-	 *	 targetting when there is no search base? */
+	 *	 targeting when there is no search base? */
 
 	/* Prepare context and handle */
 	ac = map_init_context(module, req);
@@ -1266,7 +1271,7 @@
 
 		/* if we have no local db, then we can just return the reply to
 		 * the upper layer, otherwise we must save it and process it
-		 * when all replies ahve been gathered */
+		 * when all replies have been gathered */
 		if ( ! map_check_local_db(ac->module)) {
 			ret = map_return_entry(ac, ares);
 		} else {

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_map/ldb_map_private.h -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_map/ldb_map_private.h Changed

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_mdb/ldb_mdb.c -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_mdb/ldb_mdb.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/ldb_sqlite3/ldb_sqlite3.c -> _service:tar_scm:ldb-2.8.0.tar.gz/ldb_sqlite3/ldb_sqlite3.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/replace/inet_ntop.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/replace/inet_ntop.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/replace/replace.h -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/replace/replace.h Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/replace/snprintf.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/replace/snprintf.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/replace/strptime.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/replace/strptime.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/replace/system/wscript_configure -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/replace/system/wscript_configure Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/replace/wscript -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/replace/wscript Changed

@@ -114,7 +114,7 @@
     conf.CHECK_HEADERS('xfs/libxfs.h netgroup.h')
 
     conf.CHECK_HEADERS('valgrind.h valgrind/valgrind.h')
-    conf.CHECK_HEADERS('valgrind/memcheck.h valgrind/helgrind.h')
+    conf.CHECK_HEADERS('valgrind/memcheck.h valgrind/helgrind.h valgrind/callgrind.h')
     conf.CHECK_HEADERS('nss_common.h nsswitch.h ns_api.h')
     conf.CHECK_HEADERS('sys/extattr.h sys/ea.h sys/proplist.h sys/cdefs.h')
     conf.CHECK_HEADERS('utmp.h utmpx.h lastlog.h')
@@ -131,6 +131,9 @@
     if conf.CHECK_CFLAGS('-Wno-strict-overflow'):
         conf.define('HAVE_WNO_STRICT_OVERFLOW', '1')
 
+    if conf.CHECK_CFLAGS('-Wno-unused-but-set-variable'):
+        conf.define('HAVE_WNO_UNUSED_BUT_SET_VARIABLE', '1')
+
     if conf.CHECK_CFLAGS('-Wuse-after-free=1'):
         conf.define('HAVE_WUSE_AFTER_FREE_1', '1')
 
@@ -181,6 +184,10 @@
     conf.CHECK_TYPE('blkcnt_t', 'long', headers='sys/types.h sys/stat.h unistd.h')
 
     conf.CHECK_SIZEOF('bool char int "long long" long short size_t ssize_t')
+    sizeof_int = conf.env"SIZEOF_INT"
+    if sizeof_int < 4:
+        conf.fatal(f"Samba won't work with int of size {sizeof_int} (requires >= 4)")
+
     conf.CHECK_SIZEOF('int8_t uint8_t int16_t uint16_t int32_t uint32_t int64_t uint64_t')
     conf.CHECK_SIZEOF('void*', define='SIZEOF_VOID_P')
     conf.CHECK_SIZEOF('off_t dev_t ino_t time_t')
@@ -480,7 +487,7 @@
     conf.CHECK_FUNCS('gai_strerror get_current_dir_name')
     conf.CHECK_FUNCS('timegm getifaddrs freeifaddrs mmap setgroups syscall setsid')
     conf.CHECK_FUNCS('getgrent_r getgrgid_r getgrnam_r getgrouplist getpagesize')
-    conf.CHECK_FUNCS('getpwent_r getpwnam_r getpwuid_r epoll_create')
+    conf.CHECK_FUNCS('getpwent_r getpwnam_r getpwuid_r epoll_create1')
     conf.CHECK_FUNCS('getprogname')
     if not conf.CHECK_FUNCS('copy_file_range'):
         conf.CHECK_CODE('''
@@ -703,7 +710,7 @@
     conf.CHECK_DECLS('getgrent_r getpwent_r', reverse=True, headers='pwd.h grp.h')
     conf.CHECK_DECLS('pread pwrite setenv setresgid setresuid', reverse=True)
 
-    if conf.CONFIG_SET('HAVE_EPOLL_CREATE') and conf.CONFIG_SET('HAVE_SYS_EPOLL_H'):
+    if conf.CONFIG_SET('HAVE_EPOLL_CREATE1') and conf.CONFIG_SET('HAVE_SYS_EPOLL_H'):
         conf.DEFINE('HAVE_EPOLL', 1)
 
     if conf.CHECK_FUNCS('eventfd', headers='sys/eventfd.h'):

_service:tar_scm:ldb-2.7.2.tar.gz/lib/replace/xattr.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/replace/xattr.c Changed

@@ -1,4 +1,4 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    replacement routines for xattr implementations
    Copyright (C) Jeremy Allison  1998-2005
@@ -10,7 +10,7 @@
      ** NOTE! The following LGPL license applies to the replace
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
-   
+
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
@@ -42,7 +42,7 @@
 #endif
 
 /**************************************************************************
- Wrappers for extented attribute calls. Based on the Linux package with
+ Wrappers for extended attribute calls. Based on the Linux package with
  support for IRIX and (Net|Free)BSD also. Expand as other systems have them.
 ****************************************************************************/
 
@@ -196,7 +196,7 @@
         int space;
 	const char *name;
 	size_t len;
-} 
+}
 extattr = {
 	{ EXTATTR_NAMESPACE_SYSTEM, EXTATTR_PREFIX("system.") },
         { EXTATTR_NAMESPACE_USER, EXTATTR_PREFIX("user.") },
@@ -233,7 +233,7 @@
 				errno = ENOSYS;
 				return -1;
 		}
-		/* Some error happend. Errno should be set by the previous call */
+		/* Some error happened. Errno should be set by the previous call */
 		if(list_size < 0)
 			return -1;
 		/* No attributes */
@@ -245,7 +245,7 @@
 		   problem with the emulation.
 		*/
 		if(list == NULL) {
-			/* Take the worse case of one char attribute names - 
+			/* Take the worse case of one char attribute names -
 			   two bytes per name plus one more for sanity.
 			*/
 			total_size += list_size + (list_size/2 + 1)*extattrt.len;

_service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/ABI/pytalloc-util-2.4.1.sigs Added

_service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/ABI/talloc-2.4.1.sigs Added

@@ -0,0 +1,66 @@
+_talloc: void *(const void *, size_t)
+_talloc_array: void *(const void *, size_t, unsigned int, const char *)
+_talloc_free: int (void *, const char *)
+_talloc_get_type_abort: void *(const void *, const char *, const char *)
+_talloc_memdup: void *(const void *, const void *, size_t, const char *)
+_talloc_move: void *(const void *, const void *)
+_talloc_pooled_object: void *(const void *, size_t, const char *, unsigned int, size_t)
+_talloc_realloc: void *(const void *, void *, size_t, const char *)
+_talloc_realloc_array: void *(const void *, void *, size_t, unsigned int, const char *)
+_talloc_reference_loc: void *(const void *, const void *, const char *)
+_talloc_set_destructor: void (const void *, int (*)(void *))
+_talloc_steal_loc: void *(const void *, const void *, const char *)
+_talloc_zero: void *(const void *, size_t, const char *)
+_talloc_zero_array: void *(const void *, size_t, unsigned int, const char *)
+talloc_asprintf: char *(const void *, const char *, ...)
+talloc_asprintf_addbuf: void (char **, const char *, ...)
+talloc_asprintf_append: char *(char *, const char *, ...)
+talloc_asprintf_append_buffer: char *(char *, const char *, ...)
+talloc_autofree_context: void *(void)
+talloc_check_name: void *(const void *, const char *)
+talloc_disable_null_tracking: void (void)
+talloc_enable_leak_report: void (void)
+talloc_enable_leak_report_full: void (void)
+talloc_enable_null_tracking: void (void)
+talloc_enable_null_tracking_no_autofree: void (void)
+talloc_find_parent_byname: void *(const void *, const char *)
+talloc_free_children: void (void *)
+talloc_get_name: const char *(const void *)
+talloc_get_size: size_t (const void *)
+talloc_increase_ref_count: int (const void *)
+talloc_init: void *(const char *, ...)
+talloc_is_parent: int (const void *, const void *)
+talloc_named: void *(const void *, size_t, const char *, ...)
+talloc_named_const: void *(const void *, size_t, const char *)
+talloc_parent: void *(const void *)
+talloc_parent_name: const char *(const void *)
+talloc_pool: void *(const void *, size_t)
+talloc_realloc_fn: void *(const void *, void *, size_t)
+talloc_reference_count: size_t (const void *)
+talloc_reparent: void *(const void *, const void *, const void *)
+talloc_report: void (const void *, FILE *)
+talloc_report_depth_cb: void (const void *, int, int, void (*)(const void *, int, int, int, void *), void *)
+talloc_report_depth_file: void (const void *, int, int, FILE *)
+talloc_report_full: void (const void *, FILE *)
+talloc_set_abort_fn: void (void (*)(const char *))
+talloc_set_log_fn: void (void (*)(const char *))
+talloc_set_log_stderr: void (void)
+talloc_set_memlimit: int (const void *, size_t)
+talloc_set_name: const char *(const void *, const char *, ...)
+talloc_set_name_const: void (const void *, const char *)
+talloc_show_parents: void (const void *, FILE *)
+talloc_strdup: char *(const void *, const char *)
+talloc_strdup_append: char *(char *, const char *)
+talloc_strdup_append_buffer: char *(char *, const char *)
+talloc_strndup: char *(const void *, const char *, size_t)
+talloc_strndup_append: char *(char *, const char *, size_t)
+talloc_strndup_append_buffer: char *(char *, const char *, size_t)
+talloc_test_get_magic: int (void)
+talloc_total_blocks: size_t (const void *)
+talloc_total_size: size_t (const void *)
+talloc_unlink: int (const void *, void *)
+talloc_vasprintf: char *(const void *, const char *, va_list)
+talloc_vasprintf_append: char *(char *, const char *, va_list)
+talloc_vasprintf_append_buffer: char *(char *, const char *, va_list)
+talloc_version_major: int (void)
+talloc_version_minor: int (void)

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/Makefile -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/Makefile Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/pytalloc.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/pytalloc.c Changed

@@ -101,9 +101,9 @@
 }
 
 /**
- * Default (but only slightly more useful than the default) implementation of cmp.
+ * Default objects do not support ordered comparisons, but talloc
+ * objects do, sorting by pointers clustered by type.
  */
-#if PY_MAJOR_VERSION >= 3
 static PyObject *pytalloc_default_richcmp(PyObject *obj1, PyObject *obj2, int op)
 {
 	void *ptr1;
@@ -131,17 +131,6 @@
 	Py_INCREF(Py_NotImplemented);
 	return Py_NotImplemented;
 }
-#else
-static int pytalloc_default_cmp(PyObject *_obj1, PyObject *_obj2)
-{
-	pytalloc_Object *obj1 = (pytalloc_Object *)_obj1,
-					 *obj2 = (pytalloc_Object *)_obj2;
-	if (obj1->ob_type != obj2->ob_type)
-		return ((char *)obj1->ob_type - (char *)obj2->ob_type);
-
-	return ((char *)pytalloc_get_ptr(obj1) - (char *)pytalloc_get_ptr(obj2));
-}
-#endif
 
 static PyTypeObject TallocObject_Type = {
 	.tp_name = "talloc.Object",
@@ -150,11 +139,7 @@
 	.tp_dealloc = (destructor)pytalloc_dealloc,
 	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 	.tp_repr = pytalloc_default_repr,
-#if PY_MAJOR_VERSION >= 3
 	.tp_richcompare = pytalloc_default_richcmp,
-#else
-	.tp_compare = pytalloc_default_cmp,
-#endif
 };
 
 /**
@@ -181,9 +166,9 @@
 }
 
 /**
- * Default (but only slightly more useful than the default) implementation of cmp.
+ * Default objects do not support ordered comparisons, but talloc
+ * objects do, sorting by pointers clustered by type.
  */
-#if PY_MAJOR_VERSION >= 3
 static PyObject *pytalloc_base_default_richcmp(PyObject *obj1, PyObject *obj2, int op)
 {
 	void *ptr1;
@@ -211,17 +196,6 @@
 	Py_INCREF(Py_NotImplemented);
 	return Py_NotImplemented;
 }
-#else
-static int pytalloc_base_default_cmp(PyObject *_obj1, PyObject *_obj2)
-{
-	pytalloc_BaseObject *obj1 = (pytalloc_BaseObject *)_obj1,
-					 *obj2 = (pytalloc_BaseObject *)_obj2;
-	if (obj1->ob_type != obj2->ob_type)
-		return ((char *)obj1->ob_type - (char *)obj2->ob_type);
-
-	return ((char *)pytalloc_get_ptr(obj1) - (char *)pytalloc_get_ptr(obj2));
-}
-#endif
 
 static PyTypeObject TallocBaseObject_Type = {
 	.tp_name = "talloc.BaseObject",
@@ -230,11 +204,7 @@
 	.tp_dealloc = (destructor)pytalloc_base_dealloc,
 	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 	.tp_repr = pytalloc_base_default_repr,
-#if PY_MAJOR_VERSION >= 3
 	.tp_richcompare = pytalloc_base_default_richcmp,
-#else
-	.tp_compare = pytalloc_base_default_cmp,
-#endif
 };
 
 static PyTypeObject TallocGenericObject_Type = {
@@ -247,7 +217,6 @@
 
 #define MODULE_DOC PyDoc_STR("Python wrapping of talloc-maintained objects.")
 
-#if PY_MAJOR_VERSION >= 3
 static struct PyModuleDef moduledef = {
     PyModuleDef_HEAD_INIT,
     .m_name = "talloc",
@@ -255,7 +224,6 @@
     .m_size = -1,
     .m_methods = talloc_methods,
 };
-#endif
 
 static PyObject *module_init(void);
 static PyObject *module_init(void)
@@ -271,11 +239,7 @@
 	if (PyType_Ready(&TallocGenericObject_Type) < 0)
 		return NULL;
 
-#if PY_MAJOR_VERSION >= 3
 	m = PyModule_Create(&moduledef);
-#else
-	m = Py_InitModule3("talloc", talloc_methods, MODULE_DOC);
-#endif
 	if (m == NULL)
 		return NULL;
 
@@ -298,16 +262,8 @@
 	return NULL;
 }
 
-#if PY_MAJOR_VERSION >= 3
 PyMODINIT_FUNC PyInit_talloc(void);
 PyMODINIT_FUNC PyInit_talloc(void)
 {
 	return module_init();
 }
-#else
-void inittalloc(void);
-void inittalloc(void)
-{
-	module_init();
-}
-#endif

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/pytalloc_guide.txt -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/pytalloc_guide.txt Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/pytalloc_util.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/pytalloc_util.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/talloc.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/talloc.c Changed

@@ -146,7 +146,7 @@
 } while (0)
 
 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
-/* Mark the whole chunk as not accessable */
+/* Mark the whole chunk as not accessible */
 #define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { \
 	size_t _flen = TC_HDR_SIZE + (_tc)->size; \
 	char *_fptr = (char *)(_tc); \
@@ -171,7 +171,7 @@
 } while (0)
 
 #if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
-/* Mark the unused bytes not accessable */
+/* Mark the unused bytes not accessible */
 #define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
 	size_t _flen = (_tc)->size - (_new_size); \
 	char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
@@ -661,7 +661,7 @@
 	return tc_next_chunk(tc);
 }
 
-/* Mark the whole remaining pool as not accessable */
+/* Mark the whole remaining pool as not accessible */
 static inline void tc_invalidate_pool(struct talloc_pool_hdr *pool_hdr)
 {
 	size_t flen = tc_pool_space_left(pool_hdr);
@@ -2598,7 +2598,6 @@
 	struct talloc_chunk *tc = NULL;
 	char buf1024;
 
-	/* this call looks strange, but it makes it work on older solaris boxes */
 	va_copy(ap2, ap);
 	vlen = vsnprintf(buf, sizeof(buf), fmt, ap2);
 	va_end(ap2);
@@ -2662,6 +2661,7 @@
 	char c;
 
 	va_copy(ap2, ap);
+	/* this call looks strange, but it makes it work on older solaris boxes */
 	alen = vsnprintf(&c, 1, fmt, ap2);
 	va_end(ap2);
 
@@ -2678,9 +2678,7 @@
 	s = talloc_realloc(NULL, s, char, slen + alen + 1);
 	if (!s) return NULL;
 
-	va_copy(ap2, ap);
-	vsnprintf(s + slen, alen + 1, fmt, ap2);
-	va_end(ap2);
+	vsnprintf(s + slen, alen + 1, fmt, ap);
 
 	_tc_set_name_const(talloc_chunk_from_ptr(s), s);
 	return s;

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/talloc.h -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/talloc.h Changed

@@ -666,6 +666,19 @@
 _PUBLIC_ const char *talloc_parent_name(const void *ptr);
 
 /**
+ * @brief Get the size of a talloc chunk.
+ *
+ * This function lets you know the amount of memory allocated so far by
+ * this context. It does NOT account for subcontext memory.
+ * This can be used to calculate the size of an array.
+ *
+ * @paramin  ctx      The talloc chunk.
+ *
+ * @return              The size of the talloc chunk.
+ */
+_PUBLIC_ size_t talloc_get_size(const void *ctx);
+
+/**
  * @brief Get the total size of a talloc chunk including its children.
  *
  * The function returns the total size in bytes used by this pointer and all
@@ -1071,19 +1084,6 @@
 _PUBLIC_ void *talloc_autofree_context(void) _DEPRECATED_;
 
 /**
- * @brief Get the size of a talloc chunk.
- *
- * This function lets you know the amount of memory allocated so far by
- * this context. It does NOT account for subcontext memory.
- * This can be used to calculate the size of an array.
- *
- * @paramin  ctx      The talloc chunk.
- *
- * @return              The size of the talloc chunk.
- */
-_PUBLIC_ size_t talloc_get_size(const void *ctx);
-
-/**
  * @brief Show the parentage of a context.
  *
  * @paramin  context            The talloc context to look at.

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/test_pytalloc.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/test_pytalloc.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/talloc/wscript -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/talloc/wscript Changed

_service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/ABI/tdb-1.4.9.sigs Added

@@ -0,0 +1,73 @@
+tdb_add_flags: void (struct tdb_context *, unsigned int)
+tdb_append: int (struct tdb_context *, TDB_DATA, TDB_DATA)
+tdb_chainlock: int (struct tdb_context *, TDB_DATA)
+tdb_chainlock_mark: int (struct tdb_context *, TDB_DATA)
+tdb_chainlock_nonblock: int (struct tdb_context *, TDB_DATA)
+tdb_chainlock_read: int (struct tdb_context *, TDB_DATA)
+tdb_chainlock_read_nonblock: int (struct tdb_context *, TDB_DATA)
+tdb_chainlock_unmark: int (struct tdb_context *, TDB_DATA)
+tdb_chainunlock: int (struct tdb_context *, TDB_DATA)
+tdb_chainunlock_read: int (struct tdb_context *, TDB_DATA)
+tdb_check: int (struct tdb_context *, int (*)(TDB_DATA, TDB_DATA, void *), void *)
+tdb_close: int (struct tdb_context *)
+tdb_delete: int (struct tdb_context *, TDB_DATA)
+tdb_dump_all: void (struct tdb_context *)
+tdb_enable_seqnum: void (struct tdb_context *)
+tdb_error: enum TDB_ERROR (struct tdb_context *)
+tdb_errorstr: const char *(struct tdb_context *)
+tdb_exists: int (struct tdb_context *, TDB_DATA)
+tdb_fd: int (struct tdb_context *)
+tdb_fetch: TDB_DATA (struct tdb_context *, TDB_DATA)
+tdb_firstkey: TDB_DATA (struct tdb_context *)
+tdb_freelist_size: int (struct tdb_context *)
+tdb_get_flags: int (struct tdb_context *)
+tdb_get_logging_private: void *(struct tdb_context *)
+tdb_get_seqnum: int (struct tdb_context *)
+tdb_hash_size: int (struct tdb_context *)
+tdb_increment_seqnum_nonblock: void (struct tdb_context *)
+tdb_jenkins_hash: unsigned int (TDB_DATA *)
+tdb_lock_nonblock: int (struct tdb_context *, int, int)
+tdb_lockall: int (struct tdb_context *)
+tdb_lockall_mark: int (struct tdb_context *)
+tdb_lockall_nonblock: int (struct tdb_context *)
+tdb_lockall_read: int (struct tdb_context *)
+tdb_lockall_read_nonblock: int (struct tdb_context *)
+tdb_lockall_unmark: int (struct tdb_context *)
+tdb_log_fn: tdb_log_func (struct tdb_context *)
+tdb_map_size: size_t (struct tdb_context *)
+tdb_name: const char *(struct tdb_context *)
+tdb_nextkey: TDB_DATA (struct tdb_context *, TDB_DATA)
+tdb_null: dptr = 0xXXXX, dsize = 0
+tdb_open: struct tdb_context *(const char *, int, int, int, mode_t)
+tdb_open_ex: struct tdb_context *(const char *, int, int, int, mode_t, const struct tdb_logging_context *, tdb_hash_func)
+tdb_parse_record: int (struct tdb_context *, TDB_DATA, int (*)(TDB_DATA, TDB_DATA, void *), void *)
+tdb_printfreelist: int (struct tdb_context *)
+tdb_remove_flags: void (struct tdb_context *, unsigned int)
+tdb_reopen: int (struct tdb_context *)
+tdb_reopen_all: int (int)
+tdb_repack: int (struct tdb_context *)
+tdb_rescue: int (struct tdb_context *, void (*)(TDB_DATA, TDB_DATA, void *), void *)
+tdb_runtime_check_for_robust_mutexes: bool (void)
+tdb_set_logging_function: void (struct tdb_context *, const struct tdb_logging_context *)
+tdb_set_max_dead: void (struct tdb_context *, int)
+tdb_setalarm_sigptr: void (struct tdb_context *, volatile sig_atomic_t *)
+tdb_store: int (struct tdb_context *, TDB_DATA, TDB_DATA, int)
+tdb_storev: int (struct tdb_context *, TDB_DATA, const TDB_DATA *, int, int)
+tdb_summary: char *(struct tdb_context *)
+tdb_transaction_active: bool (struct tdb_context *)
+tdb_transaction_cancel: int (struct tdb_context *)
+tdb_transaction_commit: int (struct tdb_context *)
+tdb_transaction_prepare_commit: int (struct tdb_context *)
+tdb_transaction_start: int (struct tdb_context *)
+tdb_transaction_start_nonblock: int (struct tdb_context *)
+tdb_transaction_write_lock_mark: int (struct tdb_context *)
+tdb_transaction_write_lock_unmark: int (struct tdb_context *)
+tdb_traverse: int (struct tdb_context *, tdb_traverse_func, void *)
+tdb_traverse_chain: int (struct tdb_context *, unsigned int, tdb_traverse_func, void *)
+tdb_traverse_key_chain: int (struct tdb_context *, TDB_DATA, tdb_traverse_func, void *)
+tdb_traverse_read: int (struct tdb_context *, tdb_traverse_func, void *)
+tdb_unlock: int (struct tdb_context *, int, int)
+tdb_unlockall: int (struct tdb_context *)
+tdb_unlockall_read: int (struct tdb_context *)
+tdb_validate_freelist: int (struct tdb_context *, int *)
+tdb_wipe_all: int (struct tdb_context *)

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/Makefile -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/Makefile Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/common/lock.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/common/lock.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/common/mutex.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/common/mutex.c Changed

@@ -454,7 +454,7 @@
 
 	/*
 	 * Our only caller tdb_allrecord_upgrade()
-	 * garantees that we already own the allrecord lock.
+	 * guarantees that we already own the allrecord lock.
 	 *
 	 * Which means m->allrecord_mutex is still locked by us.
 	 */
@@ -502,7 +502,7 @@
 
 	/*
 	 * Our only caller tdb_allrecord_upgrade() (in the error case)
-	 * garantees that we already own the allrecord lock.
+	 * guarantees that we already own the allrecord lock.
 	 *
 	 * Which means m->allrecord_mutex is still locked by us.
 	 */
@@ -531,7 +531,7 @@
 	/*
 	 * Our only callers tdb_allrecord_unlock() and
 	 * tdb_allrecord_lock() (in the error path)
-	 * garantee that we already own the allrecord lock.
+	 * guarantee that we already own the allrecord lock.
 	 *
 	 * Which means m->allrecord_mutex is still locked by us.
 	 */
@@ -982,7 +982,7 @@
 	 * tdb_robust_mutex_pid to -1. This is ok as this code path is only
 	 * called once per process.
 	 *
-	 * Leaving our signal handler avoids races with other threads potentialy
+	 * Leaving our signal handler avoids races with other threads potentially
 	 * setting up their SIGCHLD handlers.
 	 *
 	 * The worst thing that can happen is that the other newer signal

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/common/open.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/common/open.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/common/transaction.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/common/transaction.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/common/traverse.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/common/traverse.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/docs/mutex.txt -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/docs/mutex.txt Changed

@@ -15,7 +15,7 @@
 The external locking API of tdb also allows one to lock the complete database, and
 ctdb uses this facility to freeze databases during a recovery. While the
 so-called allrecord lock is held, all linked lists and all individual records
-are frozen alltogether. Tdb achieves this by locking the complete file range
+are frozen altogether. Tdb achieves this by locking the complete file range
 with a single fcntl lock. Individual 1-byte locks for the linked lists
 conflict with this. Access to records is prevented by the one large fnctl byte
 range lock.
@@ -73,7 +73,7 @@
 shared between processes in a common shared memory area.
 
 The process shared posix mutexes have the potential to replace fcntl locking
-to coordinate mmap access for tdbs. However, they are missing the criticial
+to coordinate mmap access for tdbs. However, they are missing the critical
 auto-cleanup property that fcntl provides when a process dies. A process that
 dies hard while holding a shared mutex has no chance to clean up the protected
 data structures and unlock the shared mutex. Thus with a pure process shared

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/pytdb.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/pytdb.c Changed

@@ -31,10 +31,6 @@
 /* Include tdb headers */
 #include <tdb.h>
 
-#if PY_MAJOR_VERSION >= 3
-#define Py_TPFLAGS_HAVE_ITER 0
-#endif
-
 /* discard signature of 'func' in favour of 'target_sig' */
 #define PY_DISCARD_FUNC_SIG(target_sig, func) (target_sig)(void(*)(void))func
 
@@ -337,26 +333,6 @@
 	return 0;
 }
 
-#if PY_MAJOR_VERSION < 3
-static PyObject *obj_has_key(PyTdbObject *self, PyObject *args)
-{
-	int ret;
-	PyObject *py_key;
-	PyErr_TDB_RAISE_IF_CLOSED(self);
-
-	if (!PyArg_ParseTuple(args, "O", &py_key))
-		return NULL;
-
-	ret = obj_contains(self, py_key);
-	if (ret == -1)
-		return NULL;
-	if (ret)
-		Py_RETURN_TRUE;
-	Py_RETURN_FALSE;
-
-}
-#endif
-
 static PyObject *obj_store(PyTdbObject *self, PyObject *args)
 {
 	TDB_DATA key, value;
@@ -474,7 +450,7 @@
 
 static void tdb_iter_dealloc(PyTdbIteratorObject *self)
 {
-	Py_DECREF(self->iteratee);
+	Py_CLEAR(self->iteratee);
 	PyObject_Del(self);
 }
 
@@ -566,21 +542,13 @@
 		"Return the next key in this database." },
 	{ "delete", (PyCFunction)obj_delete, METH_VARARGS, "S.delete(key) -> None\n"
 		"Delete an entry." },
-#if PY_MAJOR_VERSION < 3
-	{ "has_key", (PyCFunction)obj_has_key, METH_VARARGS, "S.has_key(key) -> None\n"
-		"Check whether key exists in this database." },
-#endif
 	{ "store", (PyCFunction)obj_store, METH_VARARGS, "S.store(key, data, flag=REPLACE) -> None"
 		"Store data." },
 	{ "storev", (PyCFunction)obj_storev, METH_VARARGS, "S.storev(key, data, flag=REPLACE) -> None"
 		"Store several data." },
 	{ "add_flags", (PyCFunction)obj_add_flags, METH_VARARGS, "S.add_flags(flags) -> None" },
 	{ "remove_flags", (PyCFunction)obj_remove_flags, METH_VARARGS, "S.remove_flags(flags) -> None" },
-#if PY_MAJOR_VERSION >= 3
 	{ "keys", (PyCFunction)tdb_object_iter, METH_NOARGS, "S.keys() -> iterator" },
-#else
-	{ "iterkeys", (PyCFunction)tdb_object_iter, METH_NOARGS, "S.iterkeys() -> iterator" },
-#endif
 	{ "clear", (PyCFunction)obj_clear, METH_NOARGS, "S.clear() -> None\n"
 		"Wipe the entire database." },
 	{ "repack", (PyCFunction)obj_repack, METH_NOARGS, "S.repack() -> None\n"
@@ -784,7 +752,7 @@
 	.tp_dealloc = (destructor)tdb_object_dealloc,
 	.tp_as_mapping = &tdb_object_mapping,
 	.tp_as_sequence = &tdb_object_seq,
-	.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_ITER,
+	.tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 	.tp_iter = PY_DISCARD_FUNC_SIG(getiterfunc,tdb_object_iter),
 };
 
@@ -801,7 +769,6 @@
 
 #define MODULE_DOC "simple key-value database that supports multiple writers."
 
-#if PY_MAJOR_VERSION >= 3
 static struct PyModuleDef moduledef = {
     PyModuleDef_HEAD_INIT,
     .m_name = "tdb",
@@ -809,7 +776,6 @@
     .m_size = -1,
     .m_methods = tdb_methods,
 };
-#endif
 
 PyObject* module_init(void);
 PyObject* module_init(void)
@@ -822,11 +788,7 @@
 	if (PyType_Ready(&PyTdbIterator) < 0)
 		return NULL;
 
-#if PY_MAJOR_VERSION >= 3
 	m = PyModule_Create(&moduledef);
-#else
-	m = Py_InitModule3("tdb", tdb_methods, MODULE_DOC);
-#endif
 	if (m == NULL)
 		return NULL;
 
@@ -861,16 +823,8 @@
 }
 
 
-#if PY_MAJOR_VERSION >= 3
 PyMODINIT_FUNC PyInit_tdb(void);
 PyMODINIT_FUNC PyInit_tdb(void)
 {
     return module_init();
 }
-#else
-void inittdb(void);
-void inittdb(void)
-{
-    module_init();
-}
-#endif

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/test/lock-tracking.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/test/lock-tracking.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tdb/wscript -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tdb/wscript Changed

_service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/ABI/tevent-0.15.0.sigs Added

@@ -0,0 +1,167 @@
+__tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *, const char *)
+_tevent_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
+_tevent_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
+_tevent_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
+_tevent_context_pop_use: void (struct tevent_context *, const char *)
+_tevent_context_push_use: bool (struct tevent_context *, const char *)
+_tevent_context_wrapper_create: struct tevent_context *(struct tevent_context *, TALLOC_CTX *, const struct tevent_wrapper_ops *, void *, size_t, const char *, const char *)
+_tevent_create_immediate: struct tevent_immediate *(TALLOC_CTX *, const char *)
+_tevent_loop_once: int (struct tevent_context *, const char *)
+_tevent_loop_until: int (struct tevent_context *, bool (*)(void *), void *, const char *)
+_tevent_loop_wait: int (struct tevent_context *, const char *)
+_tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, const char *, void *)
+_tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, const char *, void *)
+_tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, const char *, void *)
+_tevent_queue_create: struct tevent_queue *(TALLOC_CTX *, const char *, const char *)
+_tevent_req_callback_data: void *(struct tevent_req *)
+_tevent_req_cancel: bool (struct tevent_req *, const char *)
+_tevent_req_create: struct tevent_req *(TALLOC_CTX *, void *, size_t, const char *, const char *)
+_tevent_req_data: void *(struct tevent_req *)
+_tevent_req_done: void (struct tevent_req *, const char *)
+_tevent_req_error: bool (struct tevent_req *, uint64_t, const char *)
+_tevent_req_nomem: bool (const void *, struct tevent_req *, const char *)
+_tevent_req_notify_callback: void (struct tevent_req *, const char *)
+_tevent_req_oom: void (struct tevent_req *, const char *)
+_tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, const char *, void *)
+_tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn, const char *)
+_tevent_req_set_cleanup_fn: void (struct tevent_req *, tevent_req_cleanup_fn, const char *)
+_tevent_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
+_tevent_thread_call_depth_reset_from_req: void (struct tevent_req *, const char *)
+_tevent_threaded_schedule_immediate: void (struct tevent_threaded_context *, struct tevent_immediate *, tevent_immediate_handler_t, void *, const char *, const char *)
+tevent_abort: void (struct tevent_context *, const char *)
+tevent_backend_list: const char **(TALLOC_CTX *)
+tevent_cached_getpid: pid_t (void)
+tevent_cleanup_pending_signal_handlers: void (struct tevent_signal *)
+tevent_common_add_fd: struct tevent_fd *(struct tevent_context *, TALLOC_CTX *, int, uint16_t, tevent_fd_handler_t, void *, const char *, const char *)
+tevent_common_add_signal: struct tevent_signal *(struct tevent_context *, TALLOC_CTX *, int, int, tevent_signal_handler_t, void *, const char *, const char *)
+tevent_common_add_timer: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
+tevent_common_add_timer_v2: struct tevent_timer *(struct tevent_context *, TALLOC_CTX *, struct timeval, tevent_timer_handler_t, void *, const char *, const char *)
+tevent_common_check_double_free: void (TALLOC_CTX *, const char *)
+tevent_common_check_signal: int (struct tevent_context *)
+tevent_common_context_destructor: int (struct tevent_context *)
+tevent_common_fd_destructor: int (struct tevent_fd *)
+tevent_common_fd_get_flags: uint16_t (struct tevent_fd *)
+tevent_common_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
+tevent_common_fd_set_flags: void (struct tevent_fd *, uint16_t)
+tevent_common_have_events: bool (struct tevent_context *)
+tevent_common_invoke_fd_handler: int (struct tevent_fd *, uint16_t, bool *)
+tevent_common_invoke_immediate_handler: int (struct tevent_immediate *, bool *)
+tevent_common_invoke_signal_handler: int (struct tevent_signal *, int, int, void *, bool *)
+tevent_common_invoke_timer_handler: int (struct tevent_timer *, struct timeval, bool *)
+tevent_common_loop_immediate: bool (struct tevent_context *)
+tevent_common_loop_timer_delay: struct timeval (struct tevent_context *)
+tevent_common_loop_wait: int (struct tevent_context *, const char *)
+tevent_common_schedule_immediate: void (struct tevent_immediate *, struct tevent_context *, tevent_immediate_handler_t, void *, const char *, const char *)
+tevent_common_threaded_activate_immediate: void (struct tevent_context *)
+tevent_common_wakeup: int (struct tevent_context *)
+tevent_common_wakeup_fd: int (int)
+tevent_common_wakeup_init: int (struct tevent_context *)
+tevent_context_init: struct tevent_context *(TALLOC_CTX *)
+tevent_context_init_byname: struct tevent_context *(TALLOC_CTX *, const char *)
+tevent_context_init_ops: struct tevent_context *(TALLOC_CTX *, const struct tevent_ops *, void *)
+tevent_context_is_wrapper: bool (struct tevent_context *)
+tevent_context_same_loop: bool (struct tevent_context *, struct tevent_context *)
+tevent_debug: void (struct tevent_context *, enum tevent_debug_level, const char *, ...)
+tevent_fd_get_flags: uint16_t (struct tevent_fd *)
+tevent_fd_get_tag: uint64_t (const struct tevent_fd *)
+tevent_fd_set_auto_close: void (struct tevent_fd *)
+tevent_fd_set_close_fn: void (struct tevent_fd *, tevent_fd_close_fn_t)
+tevent_fd_set_flags: void (struct tevent_fd *, uint16_t)
+tevent_fd_set_tag: void (struct tevent_fd *, uint64_t)
+tevent_find_ops_byname: const struct tevent_ops *(const char *)
+tevent_get_trace_callback: void (struct tevent_context *, tevent_trace_callback_t *, void *)
+tevent_get_trace_fd_callback: void (struct tevent_context *, tevent_trace_fd_callback_t *, void *)
+tevent_get_trace_immediate_callback: void (struct tevent_context *, tevent_trace_immediate_callback_t *, void *)
+tevent_get_trace_queue_callback: void (struct tevent_context *, tevent_trace_queue_callback_t *, void *)
+tevent_get_trace_signal_callback: void (struct tevent_context *, tevent_trace_signal_callback_t *, void *)
+tevent_get_trace_timer_callback: void (struct tevent_context *, tevent_trace_timer_callback_t *, void *)
+tevent_immediate_get_tag: uint64_t (const struct tevent_immediate *)
+tevent_immediate_set_tag: void (struct tevent_immediate *, uint64_t)
+tevent_loop_allow_nesting: void (struct tevent_context *)
+tevent_loop_set_nesting_hook: void (struct tevent_context *, tevent_nesting_hook, void *)
+tevent_num_signals: size_t (void)
+tevent_queue_add: bool (struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
+tevent_queue_add_entry: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
+tevent_queue_add_optimize_empty: struct tevent_queue_entry *(struct tevent_queue *, struct tevent_context *, struct tevent_req *, tevent_queue_trigger_fn_t, void *)
+tevent_queue_entry_get_tag: uint64_t (const struct tevent_queue_entry *)
+tevent_queue_entry_set_tag: void (struct tevent_queue_entry *, uint64_t)
+tevent_queue_entry_untrigger: void (struct tevent_queue_entry *)
+tevent_queue_length: size_t (struct tevent_queue *)
+tevent_queue_running: bool (struct tevent_queue *)
+tevent_queue_start: void (struct tevent_queue *)
+tevent_queue_stop: void (struct tevent_queue *)
+tevent_queue_wait_recv: bool (struct tevent_req *)
+tevent_queue_wait_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct tevent_queue *)
+tevent_re_initialise: int (struct tevent_context *)
+tevent_register_backend: bool (const char *, const struct tevent_ops *)
+tevent_req_default_print: char *(struct tevent_req *, TALLOC_CTX *)
+tevent_req_defer_callback: void (struct tevent_req *, struct tevent_context *)
+tevent_req_get_profile: const struct tevent_req_profile *(struct tevent_req *)
+tevent_req_is_error: bool (struct tevent_req *, enum tevent_req_state *, uint64_t *)
+tevent_req_is_in_progress: bool (struct tevent_req *)
+tevent_req_move_profile: struct tevent_req_profile *(struct tevent_req *, TALLOC_CTX *)
+tevent_req_poll: bool (struct tevent_req *, struct tevent_context *)
+tevent_req_post: struct tevent_req *(struct tevent_req *, struct tevent_context *)
+tevent_req_print: char *(TALLOC_CTX *, struct tevent_req *)
+tevent_req_profile_append_sub: void (struct tevent_req_profile *, struct tevent_req_profile **)
+tevent_req_profile_create: struct tevent_req_profile *(TALLOC_CTX *)
+tevent_req_profile_get_name: void (const struct tevent_req_profile *, const char **)
+tevent_req_profile_get_start: void (const struct tevent_req_profile *, const char **, struct timeval *)
+tevent_req_profile_get_status: void (const struct tevent_req_profile *, pid_t *, enum tevent_req_state *, uint64_t *)
+tevent_req_profile_get_stop: void (const struct tevent_req_profile *, const char **, struct timeval *)
+tevent_req_profile_get_subprofiles: const struct tevent_req_profile *(const struct tevent_req_profile *)
+tevent_req_profile_next: const struct tevent_req_profile *(const struct tevent_req_profile *)
+tevent_req_profile_set_name: bool (struct tevent_req_profile *, const char *)
+tevent_req_profile_set_start: bool (struct tevent_req_profile *, const char *, struct timeval)
+tevent_req_profile_set_status: void (struct tevent_req_profile *, pid_t, enum tevent_req_state, uint64_t)
+tevent_req_profile_set_stop: bool (struct tevent_req_profile *, const char *, struct timeval)
+tevent_req_received: void (struct tevent_req *)
+tevent_req_reset_endtime: void (struct tevent_req *)
+tevent_req_set_callback: void (struct tevent_req *, tevent_req_fn, void *)
+tevent_req_set_cancel_fn: void (struct tevent_req *, tevent_req_cancel_fn)
+tevent_req_set_cleanup_fn: void (struct tevent_req *, tevent_req_cleanup_fn)
+tevent_req_set_endtime: bool (struct tevent_req *, struct tevent_context *, struct timeval)
+tevent_req_set_print_fn: void (struct tevent_req *, tevent_req_print_fn)
+tevent_req_set_profile: bool (struct tevent_req *)
+tevent_sa_info_queue_count: size_t (void)
+tevent_set_abort_fn: void (void (*)(const char *))
+tevent_set_debug: int (struct tevent_context *, void (*)(void *, enum tevent_debug_level, const char *, va_list), void *)
+tevent_set_debug_stderr: int (struct tevent_context *)
+tevent_set_default_backend: void (const char *)
+tevent_set_max_debug_level: enum tevent_debug_level (struct tevent_context *, enum tevent_debug_level)
+tevent_set_trace_callback: void (struct tevent_context *, tevent_trace_callback_t, void *)
+tevent_set_trace_fd_callback: void (struct tevent_context *, tevent_trace_fd_callback_t, void *)
+tevent_set_trace_immediate_callback: void (struct tevent_context *, tevent_trace_immediate_callback_t, void *)
+tevent_set_trace_queue_callback: void (struct tevent_context *, tevent_trace_queue_callback_t, void *)
+tevent_set_trace_signal_callback: void (struct tevent_context *, tevent_trace_signal_callback_t, void *)
+tevent_set_trace_timer_callback: void (struct tevent_context *, tevent_trace_timer_callback_t, void *)
+tevent_signal_get_tag: uint64_t (const struct tevent_signal *)
+tevent_signal_set_tag: void (struct tevent_signal *, uint64_t)
+tevent_signal_support: bool (struct tevent_context *)
+tevent_thread_call_depth_activate: void (size_t *)
+tevent_thread_call_depth_deactivate: void (void)
+tevent_thread_call_depth_reset_from_req: void (struct tevent_req *)
+tevent_thread_call_depth_set_callback: void (tevent_call_depth_callback_t, void *)
+tevent_thread_call_depth_start: void (struct tevent_req *)
+tevent_thread_proxy_create: struct tevent_thread_proxy *(struct tevent_context *)
+tevent_thread_proxy_schedule: void (struct tevent_thread_proxy *, struct tevent_immediate **, tevent_immediate_handler_t, void *)
+tevent_threaded_context_create: struct tevent_threaded_context *(TALLOC_CTX *, struct tevent_context *)
+tevent_timer_get_tag: uint64_t (const struct tevent_timer *)
+tevent_timer_set_tag: void (struct tevent_timer *, uint64_t)
+tevent_timeval_add: struct timeval (const struct timeval *, uint32_t, uint32_t)
+tevent_timeval_compare: int (const struct timeval *, const struct timeval *)
+tevent_timeval_current: struct timeval (void)
+tevent_timeval_current_ofs: struct timeval (uint32_t, uint32_t)
+tevent_timeval_is_zero: bool (const struct timeval *)
+tevent_timeval_set: struct timeval (uint32_t, uint32_t)
+tevent_timeval_until: struct timeval (const struct timeval *, const struct timeval *)
+tevent_timeval_zero: struct timeval (void)
+tevent_trace_fd_callback: void (struct tevent_context *, struct tevent_fd *, enum tevent_event_trace_point)
+tevent_trace_immediate_callback: void (struct tevent_context *, struct tevent_immediate *, enum tevent_event_trace_point)
+tevent_trace_point_callback: void (struct tevent_context *, enum tevent_trace_point)
+tevent_trace_queue_callback: void (struct tevent_context *, struct tevent_queue_entry *, enum tevent_event_trace_point)
+tevent_trace_signal_callback: void (struct tevent_context *, struct tevent_signal *, enum tevent_event_trace_point)
+tevent_trace_timer_callback: void (struct tevent_context *, struct tevent_timer *, enum tevent_event_trace_point)
+tevent_update_timer: void (struct tevent_timer *, struct timeval)
+tevent_wakeup_recv: bool (struct tevent_req *)
+tevent_wakeup_send: struct tevent_req *(TALLOC_CTX *, struct tevent_context *, struct timeval)

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/doc/tevent_events.dox -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/doc/tevent_events.dox Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/doc/tevent_queue.dox -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/doc/tevent_queue.dox Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/doxy.config -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/doxy.config Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/pytevent.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/pytevent.c Changed

@@ -26,9 +26,6 @@
 #include "replace.h"
 #include <tevent.h>
 
-#if PY_MAJOR_VERSION >= 3
-#define PyLong_FromLong PyLong_FromLong
-#endif
 
 /* discard signature of 'func' in favour of 'target_sig' */
 #define PY_DISCARD_FUNC_SIG(target_sig, func) (target_sig)(void(*)(void))func
@@ -244,7 +241,7 @@
 	if (self->timer) {
 		talloc_free(self->timer);
 	}
-	Py_DECREF(self->callback);
+	Py_CLEAR(self->callback);
 	PyObject_Del(self);
 }
 
@@ -285,7 +282,7 @@
 static int TeventTimer_Object_ref_destructor(struct TeventTimer_Object_ref *ref)
 {
 	ref->obj->timer = NULL;
-	Py_DECREF(ref->obj);
+	Py_CLEAR(ref->obj);
 	return 0;
 }
 
@@ -736,7 +733,6 @@
 
 #define MODULE_DOC PyDoc_STR("Python wrapping of talloc-maintained objects.")
 
-#if PY_MAJOR_VERSION >= 3
 static struct PyModuleDef moduledef = {
 	PyModuleDef_HEAD_INIT,
 	.m_name = "_tevent",
@@ -744,7 +740,6 @@
 	.m_size = -1,
 	.m_methods = tevent_methods,
 };
-#endif
 
 PyObject * module_init(void);
 PyObject * module_init(void)
@@ -769,11 +764,7 @@
 	if (PyType_Ready(&TeventFd_Type) < 0)
 		return NULL;
 
-#if PY_MAJOR_VERSION >= 3
 	m = PyModule_Create(&moduledef);
-#else
-	m = Py_InitModule3("_tevent", tevent_methods, MODULE_DOC);
-#endif
 	if (m == NULL)
 		return NULL;
 
@@ -800,16 +791,8 @@
 	return m;
 }
 
-#if PY_MAJOR_VERSION >= 3
 PyMODINIT_FUNC PyInit__tevent(void);
 PyMODINIT_FUNC PyInit__tevent(void)
 {
 	return module_init();
 }
-#else
-void init_tevent(void);
-void init_tevent(void)
-{
-	module_init();
-}
-#endif

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/testsuite.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/testsuite.c Changed

@@ -261,6 +261,112 @@
 	return true;
 }
 
+static void fde_handler_do_read(struct tevent_context *ev_ctx, struct tevent_fd *f,
+			uint16_t flags, void *private_data)
+{
+	int *fd = (int *)private_data;
+	char c = 0;
+
+	do_read(fd0, &c, 1);
+	fde_count++;
+}
+
+static void fde_handler_do_write(struct tevent_context *ev_ctx, struct tevent_fd *f,
+			uint16_t flags, void *private_data)
+{
+	int *fd = (int *)private_data;
+	char c = 0;
+
+	do_write(fd1, &c, 1);
+}
+
+static void fde_handler_ignore(struct tevent_context *ev_ctx, struct tevent_fd *f,
+			uint16_t flags, void *private_data)
+{
+}
+
+static bool test_fd_speedX(struct torture_context *test,
+			   const void *test_data,
+			   size_t additional_fdes)
+{
+	struct tevent_context *ev_ctx = NULL;
+	int fd2 = { -1, -1 };
+	const char *backend = (const char *)test_data;
+	struct tevent_fd *fde_read = NULL;
+	struct tevent_fd *fde_write = NULL;
+	int finished=0;
+	struct timeval t;
+	size_t i;
+	int ret;
+
+	ev_ctx = test_tevent_context_init_byname(test, backend);
+	if (ev_ctx == NULL) {
+		torture_comment(test, "event backend '%s' not supported\n", backend);
+		return true;
+	}
+
+	torture_comment(test, "backend '%s' - test_fd_speed%zu\n",
+			backend, 1 + additional_fdes);
+
+	/* reset globals */
+	fde_count = 0;
+
+	/* create a pipe */
+	ret = pipe(fd);
+	torture_assert_int_equal(test, ret, 0, "pipe failed");
+
+	fde_read = tevent_add_fd(ev_ctx, ev_ctx, fd0, TEVENT_FD_READ,
+				 fde_handler_do_read, fd);
+
+	fde_write = tevent_add_fd(ev_ctx, ev_ctx, fd1, TEVENT_FD_WRITE,
+				  fde_handler_do_write, fd);
+
+	for (i = 0; i < additional_fdes; i++) {
+		tevent_add_fd(ev_ctx, ev_ctx, fd0, TEVENT_FD_WRITE,
+			      fde_handler_ignore, fd);
+		tevent_add_fd(ev_ctx, ev_ctx, fd1, TEVENT_FD_READ,
+			      fde_handler_ignore, fd);
+	}
+
+	tevent_fd_set_auto_close(fde_read);
+	tevent_fd_set_auto_close(fde_write);
+
+	tevent_add_timer(ev_ctx, ev_ctx, timeval_current_ofs(600,0),
+			 finished_handler, &finished);
+
+	t = timeval_current();
+	while (!finished && fde_count < 1000000) {
+		errno = 0;
+		if (tevent_loop_once(ev_ctx) == -1) {
+			TALLOC_FREE(ev_ctx);
+			torture_fail(test, talloc_asprintf(test, "Failed event loop %s\n", strerror(errno)));
+			return false;
+		}
+	}
+
+	talloc_free(fde_read);
+	talloc_free(fde_write);
+
+	torture_comment(test, "Got %.2f pipe events\n", (double)fde_count);
+	torture_comment(test, "Got %.2f pipe events/sec\n", fde_count/timeval_elapsed(&t));
+
+	talloc_free(ev_ctx);
+
+	return true;
+}
+
+static bool test_fd_speed1(struct torture_context *test,
+			   const void *test_data)
+{
+	return test_fd_speedX(test, test_data, 0);
+}
+
+static bool test_fd_speed2(struct torture_context *test,
+			   const void *test_data)
+{
+	return test_fd_speedX(test, test_data, 1);
+}
+
 struct test_event_fd1_state {
 	struct torture_context *tctx;
 	const char *backend;
@@ -1091,7 +1197,7 @@
 	 * signal handlers have highest priority in tevent, so this signal
 	 * handler will always be started before the other handlers
 	 * below. Freeing the (wrapper) event context here tests that the
-	 * wrapper implementation correclty handles the wrapper ev going away
+	 * wrapper implementation correctly handles the wrapper ev going away
 	 * with pending events.
 	 */
 	talloc_free(ev);
@@ -1866,6 +1972,14 @@
 					       test_event_context,
 					       (const void *)listi);
 		torture_suite_add_simple_tcase_const(backend_suite,
+					       "fd_speed1",
+					       test_fd_speed1,
+					       (const void *)listi);
+		torture_suite_add_simple_tcase_const(backend_suite,
+					       "fd_speed2",
+					       test_fd_speed2,
+					       (const void *)listi);
+		torture_suite_add_simple_tcase_const(backend_suite,
 					       "fd1",
 					       test_event_fd1,
 					       (const void *)listi);

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent.h -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent.h Changed

@@ -39,6 +39,15 @@
 #define __has_attribute(x) 0
 #endif
 
+#ifdef TEVENT_DEPRECATED
+#ifndef _DEPRECATED_
+#if __has_attribute(deprecated) || (__GNUC__ >= 3)
+#define _DEPRECATED_ __attribute__ ((deprecated))
+#else
+#define _DEPRECATED_
+#endif
+#endif
+#endif
 
 struct tevent_context;
 struct tevent_ops;
@@ -615,6 +624,18 @@
 /**
  * Set destination for tevent debug messages
  *
+ * As of version 0.15.0 the invocation of
+ * the debug function for indiviual messages
+ * is limited by the current max_debug_level,
+ * which means TEVENT_DEBUG_TRACE messages
+ * are not passed by default:
+ *
+ * - tevent_set_debug() with debug == NULL implies
+ *   tevent_set_max_debug_level(ev, TEVENT_DEBUG_FATAL).
+ *
+ * - tevent_set_debug() with debug != NULL implies
+ *   tevent_set_max_debug_level(ev, TEVENT_DEBUG_WARNING).
+ *
  * @paramin ev        Event context to debug
  * @paramin debug     Function to handle output printing
  * @paramin context   The context to pass to the debug function.
@@ -622,12 +643,30 @@
  * @return Always returns 0 as of version 0.9.8
  *
  * @note Default is to emit no debug messages
+ *
+ * @see tevent_set_max_debug_level()
  */
 int tevent_set_debug(struct tevent_context *ev,
 		     tevent_debug_fn debug,
 		     void *context);
 
 /**
+ * Set maximum debug level for tevent debug messages
+ *
+ * @paramin ev         Event context to debug
+ * @paramin max_level  Function to handle output printing
+ *
+ * @return The former max level is returned.
+ *
+ * @see tevent_set_debug()
+ *
+ * @note Available as of tevent 0.15.0
+ */
+enum tevent_debug_level
+tevent_set_max_debug_level(struct tevent_context *ev,
+			   enum tevent_debug_level max_level);
+
+/**
  * Designate stderr for debug message output
  *
  * @paramin ev     Event context to debug
@@ -1010,6 +1049,13 @@
  *                      callback.
  */
 void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt);
+void _tevent_req_set_callback(struct tevent_req *req,
+			      tevent_req_fn fn,
+			      const char *fn_name,
+			      void *pvt);
+
+#define tevent_req_set_callback(req, fn, pvt) \
+	_tevent_req_set_callback(req, fn, #fn, pvt)
 
 #ifdef DOXYGEN
 /**
@@ -1166,6 +1212,11 @@
  * @paramin  fn       A pointer to the cancel function.
  */
 void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn);
+void _tevent_req_set_cancel_fn(struct tevent_req *req,
+			       tevent_req_cancel_fn fn,
+			       const char *fn_name);
+#define tevent_req_set_cancel_fn(req, fn) \
+	_tevent_req_set_cancel_fn(req, fn, #fn)
 
 #ifdef DOXYGEN
 /**
@@ -1227,6 +1278,11 @@
  * @paramin  fn       A pointer to the cancel function.
  */
 void tevent_req_set_cleanup_fn(struct tevent_req *req, tevent_req_cleanup_fn fn);
+void _tevent_req_set_cleanup_fn(struct tevent_req *req,
+				tevent_req_cleanup_fn fn,
+				const char *fn_name);
+#define tevent_req_set_cleanup_fn(req, fn) \
+	_tevent_req_set_cleanup_fn(req, fn, #fn)
 
 #ifdef DOXYGEN
 /**
@@ -1262,9 +1318,20 @@
 				      const char *type,
 				      const char *location);
 
+struct tevent_req *__tevent_req_create(TALLOC_CTX *mem_ctx,
+				       void *pstate,
+				       size_t state_size,
+				       const char *type,
+				       const char *func,
+				       const char *location);
+
 #define tevent_req_create(_mem_ctx, _pstate, _type) \
-	_tevent_req_create((_mem_ctx), (_pstate), sizeof(_type), \
-			   #_type, __location__)
+	__tevent_req_create((_mem_ctx),             \
+			    (_pstate),              \
+			    sizeof(_type),          \
+			    #_type,                 \
+			    __func__,               \
+			    __location__)
 #endif
 
 /**
@@ -2029,10 +2096,9 @@
  *
  * Part 1: activation/deactivation
  *
- * tevent_thread_call_depth_activate(), tevent_thread_call_depth_deactivate()
- *
- * Activating registers external size_t variable that will be maintained with
- * the current call depth.
+ * void tevent_thread_call_depth_set_callback(f, private_data)
+ * Register a callback that can track 'call depth' and 'request flow'
+ * NULL as a function callback means deactivation.
  *
  * Part 2: Mark the request (and its subrequests) to be tracked
  *
@@ -2047,7 +2113,7 @@
  *
  * tevent_thread_call_depth_reset_from_req(struct tevent_req *req)
  *
- * If the call depth is used for trace indentation, it might be usefull to
+ * If the call depth is used for trace indentation, it might be useful to
  * reset the external variable to the call depth of currently processed tevent
  * request, since the ext. variable can be changed after return from a function
  * call that has created subrequests.
@@ -2060,34 +2126,62 @@
  * @{
  */
 
+enum tevent_thread_call_depth_cmd {
+	TEVENT_CALL_FLOW_REQ_RESET,
+	TEVENT_CALL_FLOW_REQ_CREATE,
+	TEVENT_CALL_FLOW_REQ_CANCEL,
+	TEVENT_CALL_FLOW_REQ_CLEANUP,
+	TEVENT_CALL_FLOW_REQ_NOTIFY_CB,
+	TEVENT_CALL_FLOW_REQ_QUEUE_ENTER,
+	TEVENT_CALL_FLOW_REQ_QUEUE_TRIGGER,
+	TEVENT_CALL_FLOW_REQ_QUEUE_LEAVE,
+};
+
+typedef void (*tevent_call_depth_callback_t)(
+	void *private_data,
+	enum tevent_thread_call_depth_cmd cmd,
+	struct tevent_req *req,
+	size_t depth,
+	const char *fname);
+
+struct tevent_thread_call_depth_state {
+	tevent_call_depth_callback_t cb;
+	void *cb_private;
+};
+
+extern __thread struct tevent_thread_call_depth_state
+	tevent_thread_call_depth_state_g;
+
 /**
- * Activate call depth tracking and register external variable that will
- * be updated to the call epth of currenty processed tevent request.
+ * Register callback function for request/subrequest call depth / flow tracking.
  *
- * @paramin  ptr   Address of external variable
+ * @paramin  f  External call depth and flow handling function
  */
-void tevent_thread_call_depth_activate(size_t *ptr);
+void tevent_thread_call_depth_set_callback(tevent_call_depth_callback_t f,
+					   void *private_data);
 
-/**
- * Deactivate call depth tracking. Can be used in the child process,
- * after fork.
- */
-void tevent_thread_call_depth_deactivate(void);
+#ifdef TEVENT_DEPRECATED
 
-/**

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_debug.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_debug.c Changed

@@ -23,9 +23,12 @@
 */
 
 #include "replace.h"
+#define TEVENT_DEPRECATED
 #include "tevent.h"
 #include "tevent_internal.h"
 
+#undef tevent_thread_call_depth_reset_from_req
+
 /********************************************************************
  * Debug wrapper functions, modeled (with lot's of code copied as is)
  * after the ev debug wrapper functions
@@ -47,12 +50,31 @@
 		errno = EINVAL;
 		return -1;
 	}
-
+	if (debug != NULL) {
+		/*
+		 * tevent_set_max_debug_level(ev, TEVENT_DEBUG_TRACE)
+		 * can be used to get full tracing, but we can to
+		 * avoid overhead by default.
+		 */
+		ev->debug_ops.max_level = TEVENT_DEBUG_WARNING;
+	} else {
+		ev->debug_ops.max_level = TEVENT_DEBUG_FATAL;
+	}
 	ev->debug_ops.debug = debug;
 	ev->debug_ops.context = context;
 	return 0;
 }
 
+enum tevent_debug_level
+tevent_set_max_debug_level(struct tevent_context *ev,
+			   enum tevent_debug_level max_level)
+{
+	enum tevent_debug_level old_level;
+	old_level = ev->debug_ops.max_level;
+	ev->debug_ops.max_level = max_level;
+	return old_level;
+}
+
 /*
   debug function for ev_set_debug_stderr
 */
@@ -96,6 +118,9 @@
 	if (ev->wrapper.glue != NULL) {
 		ev = tevent_wrapper_main_ev(ev);
 	}
+	if (level > ev->debug_ops.max_level) {
+		return;
+	}
 	if (ev->debug_ops.debug == NULL) {
 		return;
 	}
@@ -293,40 +318,54 @@
 	}
 }
 
-static __thread size_t *tevent_thread_call_depth_ptr = NULL;
+_PRIVATE_ __thread
+struct tevent_thread_call_depth_state tevent_thread_call_depth_state_g;
 
 void tevent_thread_call_depth_activate(size_t *ptr)
 {
-	tevent_thread_call_depth_ptr = ptr;
-	*tevent_thread_call_depth_ptr = 0;
 }
 
 void tevent_thread_call_depth_deactivate(void)
 {
-	/* Reset the previous storage */
-	if (tevent_thread_call_depth_ptr != NULL) {
-		*tevent_thread_call_depth_ptr = 0;
-	}
-	tevent_thread_call_depth_ptr = NULL;
 }
 
 void tevent_thread_call_depth_start(struct tevent_req *req)
 {
-	if (tevent_thread_call_depth_ptr != NULL) {
-		*tevent_thread_call_depth_ptr = req->internal.call_depth = 1;
-	}
 }
 
 void tevent_thread_call_depth_reset_from_req(struct tevent_req *req)
 {
-	if (tevent_thread_call_depth_ptr != NULL) {
-		*tevent_thread_call_depth_ptr = req->internal.call_depth;
+	_tevent_thread_call_depth_reset_from_req(req, NULL);
+}
+
+void _tevent_thread_call_depth_reset_from_req(struct tevent_req *req,
+					     const char *fname)
+{
+	if (tevent_thread_call_depth_state_g.cb != NULL) {
+		tevent_thread_call_depth_state_g.cb(
+			tevent_thread_call_depth_state_g.cb_private,
+			TEVENT_CALL_FLOW_REQ_RESET,
+			req,
+			req->internal.call_depth,
+			fname);
 	}
 }
 
-_PRIVATE_ void tevent_thread_call_depth_set(size_t depth)
+void tevent_thread_call_depth_set_callback(tevent_call_depth_callback_t f,
+					   void *private_data)
 {
-	if (tevent_thread_call_depth_ptr != NULL) {
-		*tevent_thread_call_depth_ptr = depth;
+	/* In case of deactivation, make sure that call depth is set to 0 */
+	if (tevent_thread_call_depth_state_g.cb != NULL) {
+		tevent_thread_call_depth_state_g.cb(
+			tevent_thread_call_depth_state_g.cb_private,
+			TEVENT_CALL_FLOW_REQ_RESET,
+			NULL,
+			0,
+			"tevent_thread_call_depth_set_callback");
 	}
+	tevent_thread_call_depth_state_g = (struct tevent_thread_call_depth_state)
+	{
+		.cb = f,
+		.cb_private = private_data,
+	};
 }

_service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_dlinklist.h Added

@@ -0,0 +1,177 @@
+/*
+   Unix SMB/CIFS implementation.
+   some simple double linked list macros
+
+   Copyright (C) Andrew Tridgell 1998-2010
+
+     ** NOTE! The following LGPL license applies to this file (*dlinklist.h).
+     ** This does NOT imply that all of Samba is released under the LGPL
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* To use these macros you must have a structure containing a next and
+   prev pointer */
+
+#ifndef _DLINKLIST_H
+#define _DLINKLIST_H
+
+/*
+  February 2010 - changed list format to have a prev pointer from the
+  list head. This makes DLIST_ADD_END() O(1) even though we only have
+  one list pointer.
+
+  The scheme is as follows:
+
+     1) with no entries in the list:
+          list_head == NULL
+
+     2) with 1 entry in the list:
+          list_head->next == NULL
+          list_head->prev == list_head
+
+     3) with 2 entries in the list:
+          list_head->next == element2
+          list_head->prev == element2
+	  element2->prev == list_head
+	  element2->next == NULL
+
+     4) with N entries in the list:
+          list_head->next == element2
+          list_head->prev == elementN
+	  elementN->prev == element{N-1}
+	  elementN->next == NULL
+
+  This allows us to find the tail of the list by using
+  list_head->prev, which means we can add to the end of the list in
+  O(1) time
+ */
+
+
+/*
+   add an element at the front of a list
+*/
+#define DLIST_ADD(list, p) \
+do { \
+        if (!(list)) { \
+		(p)->prev = (list) = (p);  \
+		(p)->next = NULL; \
+	} else { \
+		(p)->prev = (list)->prev; \
+		(list)->prev = (p); \
+		(p)->next = (list); \
+		(list) = (p); \
+	} \
+} while (0)
+
+/*
+   remove an element from a list
+   Note that the element doesn't have to be in the list. If it
+   isn't then this is a no-op
+*/
+#define DLIST_REMOVE(list, p) \
+do { \
+	if ((p) == (list)) { \
+		if ((p)->next) (p)->next->prev = (p)->prev; \
+		(list) = (p)->next; \
+	} else if ((p)->prev && (list) && (p) == (list)->prev) {	\
+		(p)->prev->next = NULL; \
+		(list)->prev = (p)->prev; \
+	} else { \
+		if ((p)->prev) (p)->prev->next = (p)->next; \
+		if ((p)->next) (p)->next->prev = (p)->prev; \
+	} \
+	if ((p) != (list)) (p)->next = (p)->prev = NULL;	\
+} while (0)
+
+/*
+   find the head of the list given any element in it.
+   Note that this costs O(N), so you should avoid this macro
+   if at all possible!
+*/
+#define DLIST_HEAD(p, result_head) \
+do { \
+       (result_head) = (p); \
+       while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
+} while(0)
+
+/* return the last element in the list */
+#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
+
+/* return the previous element in the list. */
+#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
+
+/* insert 'p' after the given element 'el' in a list. If el is NULL then
+   this is the same as a DLIST_ADD() */
+#define DLIST_ADD_AFTER(list, p, el) \
+do { \
+        if (!(list) || !(el)) { \
+		DLIST_ADD(list, p); \
+	} else { \
+		(p)->prev = (el);   \
+		(p)->next = (el)->next;		\
+		(el)->next = (p);		\
+		if ((p)->next) (p)->next->prev = (p);	\
+		if ((list)->prev == (el)) (list)->prev = (p); \
+	}\
+} while (0)
+
+
+/*
+   add to the end of a list.
+*/
+#define DLIST_ADD_END(list, p) \
+do { \
+	if (!(list)) { \
+		DLIST_ADD(list, p); \
+	} else { \
+		DLIST_ADD_AFTER(list, p, (list)->prev); \
+	} \
+} while (0)
+
+/* promote an element to the front of a list */
+#define DLIST_PROMOTE(list, p) \
+do { \
+          DLIST_REMOVE(list, p); \
+          DLIST_ADD(list, p); \
+} while (0)
+
+/*
+   demote an element to the end of a list.
+*/
+#define DLIST_DEMOTE(list, p) \
+do { \
+	DLIST_REMOVE(list, p); \
+	DLIST_ADD_END(list, p); \
+} while (0)
+
+/*
+   concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list.
+*/
+#define DLIST_CONCATENATE(list1, list2) \
+do { \
+	if (!(list1)) { \
+		(list1) = (list2); \
+	} else { \
+		(list1)->prev->next = (list2); \
+		if (list2) { \
+			void *_tmplist = (void *)(list1)->prev; \
+			(list1)->prev = (list2)->prev; \
+			(list2)->prev = _tmplist; \
+		} \
+	} \
+} while (0)
+
+#endif /* _DLINKLIST_H */

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_epoll.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_epoll.c Changed

@@ -36,7 +36,7 @@
 	/* a pointer back to the generic event_context */
 	struct tevent_context *ev;
 
-	/* when using epoll this is the handle from epoll_create */
+	/* when using epoll this is the handle from epoll_create1(2) */
 	int epoll_fd;
 
 	pid_t pid;
@@ -53,11 +53,11 @@
 
 #ifdef TEST_PANIC_FALLBACK
 
-static int epoll_create_panic_fallback(struct epoll_event_context *epoll_ev,
-				       int size)
+static int epoll_create1_panic_fallback(struct epoll_event_context *epoll_ev,
+					int flags)
 {
 	if (epoll_ev->panic_fallback == NULL) {
-		return epoll_create(size);
+		return epoll_create1(flags);
 	}
 
 	/* 50% of the time, fail... */
@@ -66,7 +66,7 @@
 		return -1;
 	}
 
-	return epoll_create(size);
+	return epoll_create1(flags);
 }
 
 static int epoll_ctl_panic_fallback(struct epoll_event_context *epoll_ev,
@@ -105,8 +105,8 @@
 	return epoll_wait(epfd, events, maxevents, timeout);
 }
 
-#define epoll_create(_size) \
-	epoll_create_panic_fallback(epoll_ev, _size)
+#define epoll_create1(_flags) \
+	epoll_create1_panic_fallback(epoll_ev, _flags)
 #define epoll_ctl(_epfd, _op, _fd, _event) \
 	epoll_ctl_panic_fallback(epoll_ev,_epfd, _op, _fd, _event)
 #define epoll_wait(_epfd, _events, _maxevents, _timeout) \
@@ -194,18 +194,14 @@
 */
 static int epoll_init_ctx(struct epoll_event_context *epoll_ev)
 {
-	epoll_ev->epoll_fd = epoll_create(64);
+	epoll_ev->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 	if (epoll_ev->epoll_fd == -1) {
 		tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
-			     "Failed to create epoll handle.\n");
+			     "Failed to create epoll handle (%s).\n",
+			     strerror(errno));
 		return -1;
 	}
 
-	if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
-		tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
-			     "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
-	}
-
 	epoll_ev->pid = tevent_cached_getpid();
 	talloc_set_destructor(epoll_ev, epoll_ctx_destructor);
 
@@ -231,21 +227,18 @@
 	}
 
 	close(epoll_ev->epoll_fd);
-	epoll_ev->epoll_fd = epoll_create(64);
+	epoll_ev->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 	if (epoll_ev->epoll_fd == -1) {
 		epoll_panic(epoll_ev, "epoll_create() failed", false);
 		return;
 	}
 
-	if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
-		tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
-			     "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
-	}
-
 	epoll_ev->pid = pid;
 	epoll_ev->panic_state = &panic_triggered;
 	for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
 		fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+	}
+	for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
 		epoll_update_event(epoll_ev, fde);
 
 		if (panic_triggered) {
@@ -457,7 +450,7 @@
 		 * This can happen after a epoll_check_reopen
 		 * within epoll_event_fd_destructor.
 		 */
-		tevent_debug(epoll_ev->ev, TEVENT_DEBUG_TRACE,
+		TEVENT_DEBUG(epoll_ev->ev, TEVENT_DEBUG_TRACE,
 			     "EPOLL_CTL_DEL ignoring ENOENT for fd%d\n",
 			     fde->fd);
 		return;
@@ -809,9 +802,11 @@
 	}
 
 	epoll_ev->panic_state = &panic_triggered;
-	epoll_check_reopen(epoll_ev);
-	if (panic_triggered) {
-		return tevent_common_fd_destructor(fde);
+	if (epoll_ev->pid != tevent_cached_getpid()) {
+		epoll_check_reopen(epoll_ev);
+		if (panic_triggered) {
+			return tevent_common_fd_destructor(fde);
+		}
 	}
 
 	if (mpx_fde != NULL) {
@@ -848,6 +843,7 @@
 		struct epoll_event_context);
 	struct tevent_fd *fde;
 	bool panic_triggered = false;
+	pid_t old_pid = epoll_ev->pid;
 
 	fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
 				   handler, private_data,
@@ -856,14 +852,18 @@
 
 	talloc_set_destructor(fde, epoll_event_fd_destructor);
 
-	epoll_ev->panic_state = &panic_triggered;
-	epoll_check_reopen(epoll_ev);
-	if (panic_triggered) {
-		return fde;
+	if (epoll_ev->pid != tevent_cached_getpid()) {
+		epoll_ev->panic_state = &panic_triggered;
+		epoll_check_reopen(epoll_ev);
+		if (panic_triggered) {
+			return fde;
+		}
+		epoll_ev->panic_state = NULL;
 	}
-	epoll_ev->panic_state = NULL;
 
-	epoll_update_event(epoll_ev, fde);
+	if (epoll_ev->pid == old_pid) {
+		epoll_update_event(epoll_ev, fde);
+	}
 
 	return fde;
 }
@@ -876,23 +876,29 @@
 	struct tevent_context *ev;
 	struct epoll_event_context *epoll_ev;
 	bool panic_triggered = false;
+	pid_t old_pid;
 
 	if (fde->flags == flags) return;
 
 	ev = fde->event_ctx;
 	epoll_ev = talloc_get_type_abort(ev->additional_data,
 					 struct epoll_event_context);
+	old_pid = epoll_ev->pid;
 
 	fde->flags = flags;
 
-	epoll_ev->panic_state = &panic_triggered;
-	epoll_check_reopen(epoll_ev);
-	if (panic_triggered) {
-		return;
+	if (epoll_ev->pid != tevent_cached_getpid()) {
+		epoll_ev->panic_state = &panic_triggered;
+		epoll_check_reopen(epoll_ev);
+		if (panic_triggered) {
+			return;
+		}
+		epoll_ev->panic_state = NULL;
 	}
-	epoll_ev->panic_state = NULL;
 
-	epoll_update_event(epoll_ev, fde);
+	if (epoll_ev->pid == old_pid) {
+		epoll_update_event(epoll_ev, fde);
+	}
 }
 
 /*
@@ -925,15 +931,17 @@
 		return 0;
 	}
 
-	epoll_ev->panic_state = &panic_triggered;
-	epoll_ev->panic_force_replay = true;
-	epoll_check_reopen(epoll_ev);
-	if (panic_triggered) {
-		errno = EINVAL;
-		return -1;
+	if (epoll_ev->pid != tevent_cached_getpid()) {
+		epoll_ev->panic_state = &panic_triggered;
+		epoll_ev->panic_force_replay = true;
+		epoll_check_reopen(epoll_ev);
+		if (panic_triggered) {
+			errno = EINVAL;

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_fd.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_fd.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_immediate.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_immediate.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_internal.h -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_internal.h Changed

@@ -44,6 +44,10 @@
 		 * @brief Private data for the completion function
 		 */
 		void *private_data;
+		/**
+		 * @brief  The completion function name, for flow tracing.
+		 */
+		const char *fn_name;
 	} async;
 
 	/**
@@ -71,7 +75,10 @@
 	 * that is called when the tevent_req_cancel() function
 	 * was called.
 	 */
-	tevent_req_cancel_fn private_cancel;
+	struct {
+		tevent_req_cancel_fn fn;
+		const char *fn_name;
+	} private_cancel;
 
 	/**
 	 * @brief A function to cleanup the request
@@ -82,6 +89,7 @@
 	 */
 	struct {
 		tevent_req_cleanup_fn fn;
+		const char *fn_name;
 		enum tevent_req_state state;
 	} private_cleanup;
 
@@ -280,6 +288,7 @@
 };
 
 struct tevent_debug_ops {
+	enum tevent_debug_level max_level;
 	void (*debug)(void *context, enum tevent_debug_level level,
 		      const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
 	void *context;
@@ -287,6 +296,13 @@
 
 void tevent_debug(struct tevent_context *ev, enum tevent_debug_level level,
 		  const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
+#define TEVENT_DEBUG(__ev, __level, __fmt, ...) do { \
+	if (unlikely((__ev) != NULL && \
+		     (__level) <= (__ev)->debug_ops.max_level)) \
+	{ \
+		tevent_debug((__ev), (__level), (__fmt), __VA_ARGS__); \
+	} \
+} while(0)
 
 void tevent_abort(struct tevent_context *ev, const char *reason);
 
@@ -403,6 +419,14 @@
 int tevent_common_loop_wait(struct tevent_context *ev,
 			    const char *location);
 
+struct tevent_common_fd_buf {
+	char buf128;
+};
+
+const char *tevent_common_fd_str(struct tevent_common_fd_buf *buf,
+				 const char *description,
+				 const struct tevent_fd *fde);
+
 int tevent_common_fd_destructor(struct tevent_fd *fde);
 struct tevent_fd *tevent_common_add_fd(struct tevent_context *ev,
 				       TALLOC_CTX *mem_ctx,
@@ -499,7 +523,21 @@
 					       bool replay));
 #endif
 
-void tevent_thread_call_depth_set(size_t depth);
+static inline void tevent_thread_call_depth_notify(
+			enum tevent_thread_call_depth_cmd cmd,
+			struct tevent_req *req,
+			size_t depth,
+			const char *fname)
+{
+	if (tevent_thread_call_depth_state_g.cb != NULL) {
+		tevent_thread_call_depth_state_g.cb(
+			tevent_thread_call_depth_state_g.cb_private,
+			cmd,
+			req,
+			depth,
+			fname);
+	}
+}
 
 void tevent_trace_point_callback(struct tevent_context *ev,
 				 enum tevent_trace_point);

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_queue.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_queue.c Changed

@@ -27,6 +27,10 @@
 #include "tevent_internal.h"
 #include "tevent_util.h"
 
+#undef tevent_queue_add
+#undef tevent_queue_add_entry
+#undef tevent_queue_add_optimize_empty
+
 struct tevent_queue_entry {
 	struct tevent_queue_entry *prev, *next;
 	struct tevent_queue *queue;
@@ -37,6 +41,7 @@
 	struct tevent_context *ev;
 
 	tevent_queue_trigger_fn_t trigger;
+	const char *trigger_name;
 	void *private_data;
 	uint64_t tag;
 };
@@ -65,6 +70,10 @@
 	}
 
 	tevent_trace_queue_callback(q->list->ev, e, TEVENT_EVENT_TRACE_DETACH);
+	tevent_thread_call_depth_notify(TEVENT_CALL_FLOW_REQ_QUEUE_LEAVE,
+					q->list->req,
+					q->list->req->internal.call_depth,
+					e->trigger_name);
 	DLIST_REMOVE(q->list, e);
 	q->length--;
 
@@ -150,7 +159,10 @@
 	tevent_trace_queue_callback(ev, q->list,
 				    TEVENT_EVENT_TRACE_BEFORE_HANDLER);
 	/* Set the call depth of the request coming from the queue. */
-	tevent_thread_call_depth_set(q->list->req->internal.call_depth);
+	tevent_thread_call_depth_notify(TEVENT_CALL_FLOW_REQ_QUEUE_TRIGGER,
+					q->list->req,
+					q->list->req->internal.call_depth,
+					q->list->trigger_name);
 	q->list->triggered = true;
 	q->list->trigger(q->list->req, q->list->private_data);
 }
@@ -166,6 +178,7 @@
 					struct tevent_context *ev,
 					struct tevent_req *req,
 					tevent_queue_trigger_fn_t trigger,
+					const char *trigger_name,
 					void *private_data,
 					bool allow_direct)
 {
@@ -187,6 +200,7 @@
 	e->req = req;
 	e->ev = ev;
 	e->trigger = trigger;
+	e->trigger_name = trigger_name;
 	e->private_data = private_data;
 
 	if (queue->length > 0) {
@@ -211,6 +225,10 @@
 	queue->length++;
 	talloc_set_destructor(e, tevent_queue_entry_destructor);
 	tevent_trace_queue_callback(ev, e, TEVENT_EVENT_TRACE_ATTACH);
+	tevent_thread_call_depth_notify(TEVENT_CALL_FLOW_REQ_QUEUE_ENTER,
+					req,
+					req->internal.call_depth,
+					e->trigger_name);
 
 	if (!queue->running) {
 		return e;
@@ -249,10 +267,21 @@
 		      tevent_queue_trigger_fn_t trigger,
 		      void *private_data)
 {
+	return _tevent_queue_add(queue, ev, req, trigger, NULL, private_data);
+}
+
+bool _tevent_queue_add(struct tevent_queue *queue,
+		      struct tevent_context *ev,
+		      struct tevent_req *req,
+		      tevent_queue_trigger_fn_t trigger,
+		      const char* trigger_name,
+		      void *private_data)
+{
 	struct tevent_queue_entry *e;
 
 	e = tevent_queue_add_internal(queue, ev, req,
-				      trigger, private_data, false);
+				      trigger, trigger_name,
+				      private_data, false);
 	if (e == NULL) {
 		return false;
 	}
@@ -267,8 +296,22 @@
 					tevent_queue_trigger_fn_t trigger,
 					void *private_data)
 {
+	return _tevent_queue_add_entry(queue, ev, req,
+				       trigger, NULL,
+				       private_data);
+}
+
+struct tevent_queue_entry *_tevent_queue_add_entry(
+					struct tevent_queue *queue,
+					struct tevent_context *ev,
+					struct tevent_req *req,
+					tevent_queue_trigger_fn_t trigger,
+					const char* trigger_name,
+					void *private_data)
+{
 	return tevent_queue_add_internal(queue, ev, req,
-					 trigger, private_data, false);
+					 trigger, trigger_name,
+					 private_data, false);
 }
 
 struct tevent_queue_entry *tevent_queue_add_optimize_empty(
@@ -278,8 +321,22 @@
 					tevent_queue_trigger_fn_t trigger,
 					void *private_data)
 {
+	return _tevent_queue_add_optimize_empty(queue, ev, req,
+						trigger, NULL,
+						private_data);
+}
+
+struct tevent_queue_entry *_tevent_queue_add_optimize_empty(
+					struct tevent_queue *queue,
+					struct tevent_context *ev,
+					struct tevent_req *req,
+					tevent_queue_trigger_fn_t trigger,
+					const char* trigger_name,
+					void *private_data)
+{
 	return tevent_queue_add_internal(queue, ev, req,
-					 trigger, private_data, true);
+					 trigger, trigger_name,
+					 private_data, true);
 }
 
 void tevent_queue_entry_untrigger(struct tevent_queue_entry *entry)
@@ -354,8 +411,9 @@
 		return NULL;
 	}
 
-	ok = tevent_queue_add(queue, ev, req,
+	ok = _tevent_queue_add(queue, ev, req,
 			      tevent_queue_wait_trigger,
+			      "tevent_queue_wait_trigger",
 			      NULL);
 	if (!ok) {
 		tevent_req_oom(req);

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_req.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_req.c Changed

@@ -27,6 +27,10 @@
 #include "tevent_internal.h"
 #include "tevent_util.h"
 
+#undef tevent_req_set_callback
+#undef tevent_req_set_cancel_fn
+#undef tevent_req_set_cleanup_fn
+
 char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 {
 	return talloc_asprintf(mem_ctx,
@@ -64,6 +68,21 @@
 				    const char *type,
 				    const char *location)
 {
+	return __tevent_req_create(mem_ctx,
+				   pdata,
+				   data_size,
+				   type,
+				   NULL,
+				   location);
+}
+
+struct tevent_req *__tevent_req_create(TALLOC_CTX *mem_ctx,
+				       void *pdata,
+				       size_t data_size,
+				       const char *type,
+				       const char *func,
+				       const char *location)
+{
 	struct tevent_req *req;
 	struct tevent_req *parent;
 	void **ppdata = (void **)pdata;
@@ -122,10 +141,13 @@
 	*ppdata = data;
 
 	/* Initially, talloc_zero_size() sets internal.call_depth to 0 */
-	if (parent != NULL && parent->internal.call_depth > 0) {
+	if (parent != NULL) {
 		req->internal.call_depth = parent->internal.call_depth + 1;
-		tevent_thread_call_depth_set(req->internal.call_depth);
 	}
+	tevent_thread_call_depth_notify(TEVENT_CALL_FLOW_REQ_CREATE,
+					req,
+					req->internal.call_depth,
+					func);
 
 	return req;
 }
@@ -146,18 +168,18 @@
 	}
 	if (req->async.fn != NULL) {
 		/* Calling back the parent code, decrement the call depth. */
-		tevent_thread_call_depth_set(req->internal.call_depth > 0 ?
-					     req->internal.call_depth - 1 : 0);
+		size_t new_depth = req->internal.call_depth > 0 ?
+				   req->internal.call_depth - 1 : 0;
+		tevent_thread_call_depth_notify(TEVENT_CALL_FLOW_REQ_NOTIFY_CB,
+						req,
+						new_depth,
+						req->async.fn_name);
 		req->async.fn(req);
 	}
 }
 
 static void tevent_req_cleanup(struct tevent_req *req)
 {
-	if (req->private_cleanup.fn == NULL) {
-		return;
-	}
-
 	if (req->private_cleanup.state >= req->internal.state) {
 		/*
 		 * Don't call the cleanup_function multiple times for the same
@@ -166,6 +188,15 @@
 		return;
 	}
 
+	tevent_thread_call_depth_notify(TEVENT_CALL_FLOW_REQ_CLEANUP,
+					req,
+					req->internal.call_depth,
+					req->private_cleanup.fn_name);
+
+	if (req->private_cleanup.fn == NULL) {
+		return;
+	}
+
 	req->private_cleanup.state = req->internal.state;
 	req->private_cleanup.fn(req, req->internal.state);
 }
@@ -289,7 +320,8 @@
 	talloc_set_destructor(req, NULL);
 
 	req->private_print = NULL;
-	req->private_cancel = NULL;
+	req->private_cancel.fn = NULL;
+	req->private_cancel.fn_name = NULL;
 
 	TALLOC_FREE(req->internal.trigger);
 	TALLOC_FREE(req->internal.timer);
@@ -366,7 +398,16 @@
 
 void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt)
 {
+	return _tevent_req_set_callback(req, fn, NULL, pvt);
+}
+
+void _tevent_req_set_callback(struct tevent_req *req,
+			      tevent_req_fn fn,
+			      const char *fn_name,
+			      void *pvt)
+{
 	req->async.fn = fn;
+	req->async.fn_name = fn_name;
 	req->async.private_data = pvt;
 }
 
@@ -387,22 +428,43 @@
 
 void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn)
 {
-	req->private_cancel = fn;
+	_tevent_req_set_cancel_fn(req, fn, NULL);
+}
+
+void _tevent_req_set_cancel_fn(struct tevent_req *req,
+			       tevent_req_cancel_fn fn,
+			       const char *fn_name)
+{
+	req->private_cancel.fn = fn;
+	req->private_cancel.fn_name = fn != NULL ? fn_name : NULL;
 }
 
 bool _tevent_req_cancel(struct tevent_req *req, const char *location)
 {
-	if (req->private_cancel == NULL) {
+	tevent_thread_call_depth_notify(TEVENT_CALL_FLOW_REQ_CANCEL,
+					req,
+					req->internal.call_depth,
+					req->private_cancel.fn_name);
+
+	if (req->private_cancel.fn == NULL) {
 		return false;
 	}
 
-	return req->private_cancel(req);
+	return req->private_cancel.fn(req);
 }
 
 void tevent_req_set_cleanup_fn(struct tevent_req *req, tevent_req_cleanup_fn fn)
 {
+	_tevent_req_set_cleanup_fn(req, fn, NULL);
+}
+
+void _tevent_req_set_cleanup_fn(struct tevent_req *req,
+				tevent_req_cleanup_fn fn,
+				const char *fn_name)
+{
 	req->private_cleanup.state = req->internal.state;
 	req->private_cleanup.fn = fn;
+	req->private_cleanup.fn_name = fn != NULL ? fn_name : NULL;
 }
 
 static int tevent_req_profile_destructor(struct tevent_req_profile *p);

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_threads.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_threads.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_timed.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_timed.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_util.h -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_util.h Changed

@@ -1,183 +1,28 @@
 /*
    Unix SMB/CIFS implementation.
 
-   Copyright (C) Andrew Tridgell 1998-2010
+   Copyright (C) Andrew Tridgell 2005
    Copyright (C) Jelmer Vernooij 2005
 
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* To use these macros you must have a structure containing a next and
-   prev pointer */
-
-#ifndef _DLINKLIST_H
-#define _DLINKLIST_H
-
-/*
-  February 2010 - changed list format to have a prev pointer from the
-  list head. This makes DLIST_ADD_END() O(1) even though we only have
-  one list pointer.
-
-  The scheme is as follows:
-
-     1) with no entries in the list:
-          list_head == NULL
-
-     2) with 1 entry in the list:
-          list_head->next == NULL
-          list_head->prev == list_head
-
-     3) with 2 entries in the list:
-          list_head->next == element2
-          list_head->prev == element2
-	  element2->prev == list_head
-	  element2->next == NULL
-
-     4) with N entries in the list:
-          list_head->next == element2
-          list_head->prev == elementN
-	  elementN->prev == element{N-1}
-	  elementN->next == NULL
-
-  This allows us to find the tail of the list by using
-  list_head->prev, which means we can add to the end of the list in
-  O(1) time
- */
-
-
-/*
-   add an element at the front of a list
-*/
-#define DLIST_ADD(list, p) \
-do { \
-        if (!(list)) { \
-		(p)->prev = (list) = (p);  \
-		(p)->next = NULL; \
-	} else { \
-		(p)->prev = (list)->prev; \
-		(list)->prev = (p); \
-		(p)->next = (list); \
-		(list) = (p); \
-	} \
-} while (0)
-
-/*
-   remove an element from a list
-   Note that the element doesn't have to be in the list. If it
-   isn't then this is a no-op
-*/
-#define DLIST_REMOVE(list, p) \
-do { \
-	if ((p) == (list)) { \
-		if ((p)->next) (p)->next->prev = (p)->prev; \
-		(list) = (p)->next; \
-	} else if ((p)->prev && (list) && (p) == (list)->prev) {	\
-		(p)->prev->next = NULL; \
-		(list)->prev = (p)->prev; \
-	} else { \
-		if ((p)->prev) (p)->prev->next = (p)->next; \
-		if ((p)->next) (p)->next->prev = (p)->prev; \
-	} \
-	if ((p) != (list)) (p)->next = (p)->prev = NULL;	\
-} while (0)
-
-/*
-   find the head of the list given any element in it.
-   Note that this costs O(N), so you should avoid this macro
-   if at all possible!
-*/
-#define DLIST_HEAD(p, result_head) \
-do { \
-       (result_head) = (p); \
-       while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
-} while(0)
-
-/* return the last element in the list */
-#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
-
-/* return the previous element in the list. */
-#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
-
-/* insert 'p' after the given element 'el' in a list. If el is NULL then
-   this is the same as a DLIST_ADD() */
-#define DLIST_ADD_AFTER(list, p, el) \
-do { \
-        if (!(list) || !(el)) { \
-		DLIST_ADD(list, p); \
-	} else { \
-		(p)->prev = (el);   \
-		(p)->next = (el)->next;		\
-		(el)->next = (p);		\
-		if ((p)->next) (p)->next->prev = (p);	\
-		if ((list)->prev == (el)) (list)->prev = (p); \
-	}\
-} while (0)
+     ** NOTE! The following LGPL license applies to the tevent
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
 
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
 
-/*
-   add to the end of a list.
-*/
-#define DLIST_ADD_END(list, p) \
-do { \
-	if (!(list)) { \
-		DLIST_ADD(list, p); \
-	} else { \
-		DLIST_ADD_AFTER(list, p, (list)->prev); \
-	} \
-} while (0)
-
-/* promote an element to the front of a list */
-#define DLIST_PROMOTE(list, p) \
-do { \
-          DLIST_REMOVE(list, p); \
-          DLIST_ADD(list, p); \
-} while (0)
-
-/*
-   demote an element to the end of a list.
-*/
-#define DLIST_DEMOTE(list, p) \
-do { \
-	DLIST_REMOVE(list, p); \
-	DLIST_ADD_END(list, p); \
-} while (0)
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
 
-/*
-   concatenate two lists - putting all elements of the 2nd list at the
-   end of the first list.
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
-#define DLIST_CONCATENATE(list1, list2) \
-do { \
-	if (!(list1)) { \
-		(list1) = (list2); \
-	} else { \
-		(list1)->prev->next = (list2); \
-		if (list2) { \
-			void *_tmplist = (void *)(list1)->prev; \
-			(list1)->prev = (list2)->prev; \
-			(list2)->prev = _tmplist; \
-		} \
-	} \
-} while (0)
-
-#endif /* _DLINKLIST_H */
 
 int ev_set_blocking(int fd, bool set);
 bool ev_set_close_on_exec(int fd);
 
-/* Defined here so we can build against older talloc versions that don't
- * have this define yet. */
-#ifndef TALLOC_FREE
-#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
-#endif
+#include "tevent_dlinklist.h"

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/tevent_wrapper.c -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/tevent_wrapper.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/lib/tevent/wscript -> _service:tar_scm:ldb-2.8.0.tar.gz/lib/tevent/wscript Changed

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 APPNAME = 'tevent'
-VERSION = '0.14.1'
+VERSION = '0.15.0'
 
 import sys, os
 
@@ -51,7 +51,7 @@
                 conf.CHECK_BUNDLED_SYSTEM_PYTHON('pytevent', 'tevent', minversion=VERSION):
                 conf.define('USING_SYSTEM_PYTEVENT', 1)
 
-    if conf.CHECK_FUNCS('epoll_create', headers='sys/epoll.h'):
+    if conf.CHECK_FUNCS('epoll_create1', headers='sys/epoll.h'):
         conf.DEFINE('HAVE_EPOLL', 1)
 
     tevent_num_signals = 64
@@ -110,7 +110,7 @@
                           enabled= not bld.CONFIG_SET('USING_SYSTEM_TEVENT'),
                           includes='.',
                           abi_directory='ABI',
-                          abi_match='tevent_* _tevent_*',
+                          abi_match='tevent_* _tevent_* __tevent_*',
                           vnum=VERSION,
                           public_headers=('' if private_library else 'tevent.h'),
                           public_headers_install=not private_library,

_service:tar_scm:ldb-2.7.2.tar.gz/man/ldb.3.xml -> _service:tar_scm:ldb-2.8.0.tar.gz/man/ldb.3.xml Changed

_service:tar_scm:ldb-2.7.2.tar.gz/nssldb/README.txt -> _service:tar_scm:ldb-2.8.0.tar.gz/nssldb/README.txt Changed

_service:tar_scm:ldb-2.7.2.tar.gz/pyldb.c -> _service:tar_scm:ldb-2.8.0.tar.gz/pyldb.c Changed

@@ -84,8 +84,6 @@
 						      const char *attr_name);
 static PyTypeObject PyLdbBytesType;
 
-#if PY_MAJOR_VERSION >= 3
-
 #define PYARG_STR_UNI "es"
 
 static PyObject *PyLdbBytes_FromStringAndSize(const char *msg, int size)
@@ -97,12 +95,6 @@
 	Py_DECREF(args);
 	return result;
 }
-#else
-#define PyLdbBytes_FromStringAndSize PyString_FromStringAndSize
-
-#define PYARG_STR_UNI "et"
-
-#endif
 
 static PyObject *richcmp(int cmp_val, int op)
 {
@@ -616,12 +608,23 @@
 	struct ldb_dn *dn = pyldb_Dn_AS_DN((PyObject *)self);
 	struct ldb_dn *parent;
 	PyLdbDnObject *py_ret;
-	TALLOC_CTX *mem_ctx = talloc_new(NULL);
+	TALLOC_CTX *mem_ctx = NULL;
+
+	if (ldb_dn_get_comp_num(dn) < 1) {
+		Py_RETURN_NONE;
+	}
+
+	mem_ctx = talloc_new(NULL);
+	if (mem_ctx == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
 
 	parent = ldb_dn_get_parent(mem_ctx, dn);
 	if (parent == NULL) {
+		PyErr_NoMemory();
 		talloc_free(mem_ctx);
-		Py_RETURN_NONE;
+		return NULL;
 	}
 
 	py_ret = (PyLdbDnObject *)PyLdbDn.tp_alloc(&PyLdbDn, 0);
@@ -996,7 +999,9 @@
 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
 {
 	PyObject *fn = (PyObject *)context;
-	PyObject_CallFunction(fn, discard_const_p(char, "(i,O)"), level, PyUnicode_FromFormatV(fmt, ap));
+	PyObject *result = NULL;
+	result = PyObject_CallFunction(fn, discard_const_p(char, "(i,O)"), level, PyUnicode_FromFormatV(fmt, ap));
+	Py_XDECREF(result);
 }
 
 static PyObject *py_ldb_debug_func;
@@ -1299,6 +1304,11 @@
 			return NULL;
 		}
 		parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
+		if (controls0 != NULL && parsed_controls == NULL) {
+			talloc_free(mem_ctx);
+			PyErr_SetLdbError(PyExc_LdbError, LDB_ERR_OPERATIONS_ERROR, ldb_ctx);
+			return NULL;
+		}
 		talloc_free(controls);
 	}
 
@@ -1448,6 +1458,11 @@
 			return NULL;
 		}
 		parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
+		if (controls0 != NULL && parsed_controls == NULL) {
+			talloc_free(mem_ctx);
+			PyErr_SetLdbError(PyExc_LdbError, LDB_ERR_OPERATIONS_ERROR, ldb_ctx);
+			return NULL;
+		}
 		talloc_free(controls);
 	}
 
@@ -1541,6 +1556,11 @@
 			return NULL;
 		}
 		parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
+		if (controls0 != NULL && parsed_controls == NULL) {
+			talloc_free(mem_ctx);
+			PyErr_SetLdbError(PyExc_LdbError, LDB_ERR_OPERATIONS_ERROR, ldb_ctx);
+			return NULL;
+		}
 		talloc_free(controls);
 	}
 
@@ -1619,6 +1639,11 @@
 			return NULL;
 		}
 		parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
+		if (controls0 != NULL && parsed_controls == NULL) {
+			talloc_free(mem_ctx);
+			PyErr_SetLdbError(PyExc_LdbError, LDB_ERR_OPERATIONS_ERROR, ldb_ctx);
+			return NULL;
+		}
 		talloc_free(controls);
 	}
 
@@ -1697,20 +1722,97 @@
 	Py_RETURN_NONE;
 }
 
-static PyObject *ldb_ldif_to_pyobject(struct ldb_ldif *ldif)
+static PyObject *ldb_ldif_to_pyobject(struct ldb_context *ldb, struct ldb_ldif *ldif)
 {
+	PyObject *obj = NULL;
+	PyObject *result = NULL;
+
 	if (ldif == NULL) {
 		Py_RETURN_NONE;
-	} else {
-	/* We don't want this attached to the 'ldb' any more */
-		PyObject *obj = PyLdbMessage_FromMessage(ldif->msg);
-		PyObject *result =
-			Py_BuildValue(discard_const_p(char, "(iO)"),
-				      ldif->changetype,
-				      obj);
-		Py_CLEAR(obj);
-		return result;
 	}
+
+	switch (ldif->changetype) {
+	case LDB_CHANGETYPE_NONE:
+	case LDB_CHANGETYPE_ADD:
+		obj = PyLdbMessage_FromMessage(ldif->msg);
+		break;
+	case LDB_CHANGETYPE_MODIFY:
+		obj = PyLdbMessage_FromMessage(ldif->msg);
+		break;
+	case LDB_CHANGETYPE_DELETE:
+		if (ldif->msg->num_elements != 0) {
+			PyErr_Format(PyExc_ValueError,
+				     "CHANGETYPE(DELETE) with num_elements=%u",
+				     ldif->msg->num_elements);
+			return NULL;
+		}
+		obj = pyldb_Dn_FromDn(ldif->msg->dn);
+		break;
+	case LDB_CHANGETYPE_MODRDN: {
+		struct ldb_dn *olddn = NULL;
+		PyObject *olddn_obj = NULL;
+		bool deleteoldrdn = false;
+		PyObject *deleteoldrdn_obj = NULL;
+		struct ldb_dn *newdn = NULL;
+		PyObject *newdn_obj = NULL;
+		int ret;
+
+		ret = ldb_ldif_parse_modrdn(ldb,
+					    ldif,
+					    ldif,
+					    &olddn,
+					    NULL,
+					    &deleteoldrdn,
+					    NULL,
+					    &newdn);
+		if (ret != LDB_SUCCESS) {
+			PyErr_Format(PyExc_ValueError,
+				     "ldb_ldif_parse_modrdn() failed");
+			return NULL;
+		}
+
+		olddn_obj = pyldb_Dn_FromDn(olddn);
+		if (olddn_obj == NULL) {
+			return NULL;
+		}
+		if (deleteoldrdn) {
+			deleteoldrdn_obj = Py_True;
+		} else {
+			deleteoldrdn_obj = Py_False;
+		}
+		newdn_obj = pyldb_Dn_FromDn(newdn);
+		if (newdn_obj == NULL) {
+			deleteoldrdn_obj = NULL;
+			Py_CLEAR(olddn_obj);
+			return NULL;
+		}
+
+		obj = Py_BuildValue(discard_const_p(char, "{s:O,s:O,s:O}"),
+				    "olddn", olddn_obj,
+				    "deleteoldrdn", deleteoldrdn_obj,
+				    "newdn", newdn_obj);
+		Py_CLEAR(olddn_obj);
+		deleteoldrdn_obj = NULL;
+		Py_CLEAR(newdn_obj);
+		}
+		break;
+	default:
+		PyErr_Format(PyExc_NotImplementedError,
+			     "Unsupported LDB_CHANGETYPE(%u)",
+			     ldif->changetype);
+		return NULL;

_service:tar_scm:ldb-2.7.2.tar.gz/tests/ldb_filter_attrs_in_place_test.c -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/ldb_filter_attrs_in_place_test.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/tests/ldb_filter_attrs_test.c -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/ldb_filter_attrs_test.c Changed

@@ -53,7 +53,7 @@
  *
  * This test checks the current behaviour of the function, however
  * this is not in a public ABI and many of the tested behaviours are
- * not ideal.  If the behaviour is deliberatly improved, this test
+ * not ideal.  If the behaviour is deliberately improved, this test
  * should be updated without worry to the new better behaviour.
  *
  * In particular the test is particularly to ensure the current
@@ -199,7 +199,7 @@
 
 	struct ldb_message *filtered_msg = ldb_msg_new(ctx);
 
-	/* deliberatly the other order */
+	/* deliberately the other order */
 	const char *attrs = {"bar", "foo", NULL};
 
 	char value1 = "The value.......end";
@@ -274,7 +274,7 @@
 
 	struct ldb_message *filtered_msg = ldb_msg_new(ctx);
 
-	/* deliberatly the other order */
+	/* deliberately the other order */
 	const char *attrs = {"bar", NULL};
 
 	char value1 = "The value.......end";
@@ -343,7 +343,7 @@
 
 	struct ldb_message *filtered_msg = ldb_msg_new(ctx);
 
-	/* deliberatly the other order */
+	/* deliberately the other order */
 	const char *attrs = {"bar", NULL};
 
 	char value1 = "The value.......end";
@@ -661,7 +661,7 @@
 	assert_string_equal(ldb_msg_find_attr_as_string(filtered_msg,
 							"foo",
 							NULL),
-			    value);
+			    (const char *)value);
 }
 
 /*
@@ -730,17 +730,17 @@
 	assert_string_equal(ldb_msg_find_attr_as_string(filtered_msg,
 							"foo",
 							NULL),
-			    value1);
+			    (const char *)value1);
 	assert_string_equal(ldb_msg_find_attr_as_string(filtered_msg,
 							"bar",
 							NULL),
-			    value2);
+			    (const char *)value2);
 }
 
 /*
  * Test against a record with only one attribute, matching the * in
  * the list, but without the DN being pre-filled.  Fails due to need
- * to contstruct the distinguishedName
+ * to construct the distinguishedName
  */
 static void test_filter_attrs_one_attr_matched_star_no_dn(void **state)
 {
@@ -829,7 +829,7 @@
 	assert_string_equal(ldb_msg_find_attr_as_string(filtered_msg,
 							"foo",
 							NULL),
-			    value);
+			    (const char *)value);
 }
 
 /*
@@ -878,7 +878,7 @@
 	assert_ptr_equal(filtered_msg->dn, in.dn);
 	assert_string_equal(filtered_msg->elements0.name, "distinguishedName");
 	assert_int_equal(filtered_msg->elements0.num_values, 1);
-	assert_string_equal(filtered_msg->elements0.values0.data,
+	assert_string_equal((const char *)filtered_msg->elements0.values0.data,
 			    ldb_dn_get_linearized(in.dn));
 }

_service:tar_scm:ldb-2.7.2.tar.gz/tests/ldb_kv_ops_test.c -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/ldb_kv_ops_test.c Changed

@@ -37,9 +37,9 @@
  * A KV module is expected to have the following behaviour
  *
  * - A transaction must be open to perform any read, write or delete operation
- * - Writes and Deletes should not be visible until a transaction is commited
+ * - Writes and Deletes should not be visible until a transaction is committed
  * - Nested transactions are not permitted
- * - transactions can be rolled back and commited.
+ * - transactions can be rolled back and committed.
  * - supports iteration over all records in the database
  * - supports the update_in_iterate operation allowing entries to be
  *   re-keyed.
@@ -1075,7 +1075,7 @@
 	const char *VAL2 = "VALUE02";
 
 	/*
-	 * Pipes etc to co-ordinate the processes
+	 * Pipes etc to coordinate the processes
 	 */
 	int to_child2;
 	int to_parent2;
@@ -1222,7 +1222,7 @@
 		}
 
 		/*
-		 * Wait for the transaction to be commited
+		 * Wait for the transaction to be committed
 		 */
 		ret = read(to_child0, buf, 2);
 		if (ret != 2) {
@@ -1392,7 +1392,7 @@
 	const char *VAL2 = "VALUE02";
 
 	/*
-	 * Pipes etc to co-ordinate the processes
+	 * Pipes etc to coordinate the processes
 	 */
 	int to_child2;
 	int to_parent2;
@@ -1550,7 +1550,7 @@
 		}
 
 		/*
-		 * Wait for the transaction to be commited
+		 * Wait for the transaction to be committed
 		 */
 		ret = read(to_child0, buf, 2);
 		if (ret != 2) {

_service:tar_scm:ldb-2.7.2.tar.gz/tests/ldb_lmdb_free_list_test.c -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/ldb_lmdb_free_list_test.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/tests/ldb_mod_op_test.c -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/ldb_mod_op_test.c Changed

@@ -152,7 +152,7 @@
 		"supersecret: password\n"
 		"binary:: //8=\n"
 		"\n";
-	
+
 	struct ldb_message *msg = get_test_ldb_message(test_ctx,
 						       test_ctx->ldb);
 
@@ -182,13 +182,13 @@
 		"supersecret",
 		NULL
 	};
-	
+
 	struct ldb_message *msg = ldb_msg_new(test_ctx);
 
 	ldb_set_opaque(test_ctx->ldb,
 		       LDB_SECRET_ATTRIBUTE_LIST_OPAQUE,
 		       secret_attrs);
-	
+
 	assert_non_null(msg);
 
 	msg->dn = ldb_dn_new(msg, test_ctx->ldb, "dc=samba,dc=org");
@@ -924,12 +924,12 @@
 	el = ldb_msg_find_element(res->msgs0, "cn");
 	assert_non_null(el);
 	assert_int_equal(el->num_values, 1);
-	assert_string_equal(el->values0.data, "test_mod_cn");
+	assert_string_equal((const char *)el->values0.data, "test_mod_cn");
 
 	el = ldb_msg_find_element(res->msgs0, "name");
 	assert_non_null(el);
 	assert_int_equal(el->num_values, 1);
-	assert_string_equal(el->values0.data, "test_mod_name");
+	assert_string_equal((const char *)el->values0.data, "test_mod_name");
 }
 
 static void test_ldb_modify_extend_key(void **state)
@@ -952,8 +952,8 @@
 	el = ldb_msg_find_element(res->msgs0, "cn");
 	assert_non_null(el);
 	assert_int_equal(el->num_values, 2);
-	assert_string_equal(el->values0.data, "test_mod_cn");
-	assert_string_equal(el->values1.data, "test_mod_cn2");
+	assert_string_equal((const char *)el->values0.data, "test_mod_cn");
+	assert_string_equal((const char *)el->values1.data, "test_mod_cn2");
 }
 
 static void test_ldb_modify_add_key_noval(void **state)
@@ -1009,7 +1009,7 @@
 	el = ldb_msg_find_element(res->msgs0, "cn");
 	assert_non_null(el);
 	assert_int_equal(el->num_values, 1);
-	assert_string_equal(el->values0.data, new_cn);
+	assert_string_equal((const char *)el->values0.data, new_cn);
 }
 
 static void test_ldb_modify_replace_noexist_key(void **state)
@@ -1032,12 +1032,12 @@
 	el = ldb_msg_find_element(res->msgs0, "cn");
 	assert_non_null(el);
 	assert_int_equal(el->num_values, 1);
-	assert_string_equal(el->values0.data, "test_mod_cn");
+	assert_string_equal((const char *)el->values0.data, "test_mod_cn");
 
 	el = ldb_msg_find_element(res->msgs0, mod_kvs0.key);
 	assert_non_null(el);
 	assert_int_equal(el->num_values, 1);
-	assert_string_equal(el->values0.data, mod_kvs0.val);
+	assert_string_equal((const char *)el->values0.data, mod_kvs0.val);
 }
 
 static void test_ldb_modify_replace_zero_vals(void **state)
@@ -1232,7 +1232,7 @@
 
 	assert_int_equal(el->num_values, nvals);
 	for (i = 0; i < nvals; i++) {
-		assert_string_equal(el->valuesi.data,
+		assert_string_equal((const char *)el->valuesi.data,
 				    valsi);
 	}
 }
@@ -2599,7 +2599,7 @@
 	msg = ldb_msg_new(tmp_ctx);
 	assert_non_null(msg);
 
-	/* We deliberatly use ou= not cn= here */
+	/* We deliberately use ou= not cn= here */
 	msg->dn = ldb_dn_new_fmt(msg,
 				 ctx->test_ctx->ldb,
 				 "ou=test_search_cn_extra,%s",

_service:tar_scm:ldb-2.7.2.tar.gz/tests/python/api.py -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/python/api.py Changed

@@ -2110,7 +2110,7 @@
                         "name": b"Admins",
                         "x": "z", "y": "a",
                         "objectUUID": b"0123456789abcde2"})
-            self.fail("Should have failed adding dupliate entry")
+            self.fail("Should have failed adding duplicate entry")
         except ldb.LdbError as err:
             enum = err.args0
             self.assertEqual(enum, ldb.ERR_ENTRY_ALREADY_EXISTS)
@@ -2304,7 +2304,7 @@
                         "name": b"Admins",
                         "x": "z", "y": "a",
                         "objectUUID": b"0123456789abcdef"})
-            self.fail("Should have failed adding dupliate GUID")
+            self.fail("Should have failed adding duplicate GUID")
         except ldb.LdbError as err:
             enum = err.args0
             self.assertEqual(enum, ldb.ERR_CONSTRAINT_VIOLATION)
@@ -2319,7 +2319,7 @@
                         "name": b"Admins",
                         "x": "z", "y": "a",
                         "objectUUID": b"a123456789abcdef"})
-            self.fail("Should have failed adding dupliate GUID")
+            self.fail("Should have failed adding duplicate GUID")
         except ldb.LdbError as err:
             enum = err.args0
             self.assertEqual(enum, ldb.ERR_ENTRY_ALREADY_EXISTS)
@@ -2334,7 +2334,7 @@
                         "name": b"Admins",
                         "x": "z", "y": "a",
                         "objectUUID": b"aaa3456789abcdef"})
-            self.fail("Should have failed adding dupliate DN")
+            self.fail("Should have failed adding duplicate DN")
         except ldb.LdbError as err:
             enum = err.args0
             self.assertEqual(enum, ldb.ERR_ENTRY_ALREADY_EXISTS)

_service:tar_scm:ldb-2.7.2.tar.gz/tests/test.ldif -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/test.ldif Changed

_service:tar_scm:ldb-2.7.2.tar.gz/tests/test_ldb_dn.c -> _service:tar_scm:ldb-2.8.0.tar.gz/tests/test_ldb_dn.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/tools/ldbutil.c -> _service:tar_scm:ldb-2.8.0.tar.gz/tools/ldbutil.c Changed

_service:tar_scm:ldb-2.7.2.tar.gz/wscript -> _service:tar_scm:ldb-2.8.0.tar.gz/wscript Changed

Changes of Revision 3