return ldb_next_request(module, req);
}
-static const struct ldb_module_ops anr_ops = {
+const struct ldb_module_ops ldb_anr_module_ops = {
.name = "anr",
.search = anr_search
};
-
-int ldb_anr_init(void)
-{
- return ldb_register_module(&anr_ops);
-}
-
return ldb_next_init(module);
}
-static const struct ldb_module_ops dsdb_cache_ops = {
+const struct ldb_module_ops ldb_dsdb_cache_module_ops = {
.name = "dsdb_cache",
.init_context = dsdb_cache_init
};
-
-int dsdb_cache_module_init(void)
-{
- return ldb_register_module(&dsdb_cache_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops extended_dn_ops = {
+const struct ldb_module_ops ldb_extended_dn_module_ops = {
.name = "extended_dn",
.search = extended_search,
.init_context = extended_init
};
-
-int ldb_extended_dn_init(void)
-{
- return ldb_register_module(&extended_dn_ops);
-}
return ret;
}
-static const struct ldb_module_ops instancetype_ops = {
+const struct ldb_module_ops ldb_instancetype_module_ops = {
.name = "instancetype",
.add = instancetype_add,
};
-
-
-int ldb_instancetype_init(void)
-{
- return ldb_register_module(&instancetype_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops kludge_acl_ops = {
+const struct ldb_module_ops ldb_kludge_acl_module_ops = {
.name = "kludge_acl",
.search = kludge_acl_search,
.add = kludge_acl_change,
.extended = kludge_acl_change,
.init_context = kludge_acl_init
};
-
-int ldb_kludge_acl_init(void)
-{
- return ldb_register_module(&kludge_acl_ops);
-}
}
}
-static const struct ldb_module_ops linked_attributes_ops = {
+const struct ldb_module_ops ldb_linked_attributes_module_ops = {
.name = "linked_attributes",
.add = linked_attributes_add,
.modify = linked_attributes_modify,
.rename = linked_attributes_rename,
.wait = linked_attributes_wait,
};
-
-int ldb_linked_attributes_init(void)
-{
- return ldb_register_module(&linked_attributes_ops);
-}
}
}
-static const struct ldb_module_ops local_password_ops = {
+const struct ldb_module_ops ldb_local_password_module_ops = {
.name = "local_password",
.add = local_password_add,
.modify = local_password_modify,
.search = local_password_search,
.wait = local_password_wait
};
-
-
-int local_password_module_init(void)
-{
- return ldb_register_module(&local_password_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops naming_fsmo_ops = {
+const struct ldb_module_ops ldb_naming_fsmo_module_ops = {
.name = "naming_fsmo",
.init_context = naming_fsmo_init
};
-
-int naming_fsmo_module_init(void)
-{
- return ldb_register_module(&naming_fsmo_ops);
-}
}
-static const struct ldb_module_ops normalise_ops = {
+const struct ldb_module_ops ldb_normalise_module_ops = {
.name = "normalise",
.search = normalise_search,
};
-
-int ldb_normalise_init(void)
-{
- return ldb_register_module(&normalise_ops);
-}
}
}
-static const struct ldb_module_ops objectclass_ops = {
+const struct ldb_module_ops ldb_objectclass_module_ops = {
.name = "objectclass",
.add = objectclass_add,
.modify = objectclass_modify,
.rename = objectclass_rename,
.wait = objectclass_wait
};
-
-int ldb_objectclass_init(void)
-{
- return ldb_register_module(&objectclass_ops);
-}
-
return ret;
}
-static const struct ldb_module_ops objectguid_ops = {
+const struct ldb_module_ops ldb_objectguid_module_ops = {
.name = "objectguid",
.add = objectguid_add,
.modify = objectguid_modify,
};
-
-
-int objectguid_module_init(void)
-{
- return ldb_register_module(&objectguid_ops);
-}
}
}
-static const struct ldb_module_ops partition_ops = {
+const struct ldb_module_ops ldb_partition_module_ops = {
.name = "partition",
.init_context = partition_init,
.search = partition_search,
.del_transaction = partition_del_trans,
.wait = partition_wait
};
-
-int ldb_partition_init(void)
-{
- return ldb_register_module(&partition_ops);
-}
}
}
-static const struct ldb_module_ops password_hash_ops = {
+const struct ldb_module_ops ldb_password_hash_module_ops = {
.name = "password_hash",
.add = password_hash_add,
.modify = password_hash_modify,
.wait = password_hash_wait
};
-
-
-int password_hash_module_init(void)
-{
- return ldb_register_module(&password_hash_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops pdc_fsmo_ops = {
+const struct ldb_module_ops ldb_pdc_fsmo_module_ops = {
.name = "pdc_fsmo",
.init_context = pdc_fsmo_init
};
-
-int pdc_fsmo_module_init(void)
-{
- return ldb_register_module(&pdc_fsmo_ops);
-}
}
}
-static const struct ldb_module_ops proxy_ops = {
+const struct ldb_module_ops ldb_proxy_module_ops = {
.name = "proxy",
.request = proxy_request
};
-
-int proxy_module_init(void)
-{
- return ldb_register_module(&proxy_ops);
-}
return ldb_next_request(module, req);
}
-static const struct ldb_module_ops rr_ops = {
+const struct ldb_module_ops ldb_ranged_results_module_ops = {
.name = "ranged_results",
.search = rr_search,
};
-
-int ldb_ranged_results_init(void)
-{
- return ldb_register_module(&rr_ops);
-}
}
}
-static const struct ldb_module_ops replmd_ops = {
+const struct ldb_module_ops ldb_repl_meta_data_module_ops = {
.name = "repl_meta_data",
.add = replmd_add,
.modify = replmd_modify,
.extended = replmd_extended,
.wait = replmd_wait
};
-
-int repl_meta_data_module_init(void)
-{
- return ldb_register_module(&replmd_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops rootdse_ops = {
+const struct ldb_module_ops ldb_rootdse_module_ops = {
.name = "rootdse",
.init_context = rootdse_init,
.search = rootdse_search,
.request = rootdse_request
};
-
-int rootdse_module_init(void)
-{
- return ldb_register_module(&rootdse_ops);
-}
-
return ldb_next_init(module);
}
-static struct ldb_module_ops samba3sam_ops = {
+const struct ldb_module_ops ldb_samba3sam_module_ops = {
+ LDB_MAP_OPS
.name = "samba3sam",
.init_context = samba3sam_init,
};
-
-/* the init function */
-int ldb_samba3sam_module_init(void)
-{
- struct ldb_module_ops ops = ldb_map_get_ops();
- samba3sam_ops.add = ops.add;
- samba3sam_ops.modify = ops.modify;
- samba3sam_ops.del = ops.del;
- samba3sam_ops.rename = ops.rename;
- samba3sam_ops.search = ops.search;
- samba3sam_ops.wait = ops.wait;
-
- return ldb_register_module(&samba3sam_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops samldb_ops = {
+const struct ldb_module_ops ldb_samldb_module_ops = {
.name = "samldb",
.init_context = samldb_init,
.add = samldb_add,
};
-
-
-int samldb_module_init(void)
-{
- return ldb_register_module(&samldb_ops);
-}
return LDB_SUCCESS;
}
-static const struct ldb_module_ops schema_ops = {
+const struct ldb_module_ops ldb_schema_module_ops = {
.name = "schema",
.init_context = schema_init,
.add = schema_add,
.rename = schema_rename,
.wait = schema_wait
};
-
-int ldb_schema_init(void)
-{
- return ldb_register_module(&schema_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops schema_fsmo_ops = {
+const struct ldb_module_ops ldb_schema_fsmo_module_ops = {
.name = "schema_fsmo",
.init_context = schema_fsmo_init
};
-
-int schema_fsmo_module_init(void)
-{
- return ldb_register_module(&schema_fsmo_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops show_deleted_ops = {
+const struct ldb_module_ops ldb_show_deleted_module_ops = {
.name = "show_deleted",
.search = show_deleted_search,
.init_context = show_deleted_init
};
-
-int ldb_show_deleted_init(void)
-{
- return ldb_register_module(&show_deleted_ops);
-}
return LDB_SUCCESS;
}
-static struct ldb_module_ops entryuuid_ops = {
+const struct ldb_module_ops ldb_entryuuid_module_ops = {
.name = "entryuuid",
.init_context = entryuuid_init,
- .sequence_number = entryuuid_sequence_number
+ .sequence_number = entryuuid_sequence_number,
+ LDB_MAP_OPS
};
-static struct ldb_module_ops nsuniqueid_ops = {
+const struct ldb_module_ops ldb_nsuniqueid_module_ops = {
.name = "nsuniqueid",
.init_context = nsuniqueid_init,
- .sequence_number = entryuuid_sequence_number
+ .sequence_number = entryuuid_sequence_number,
+ LDB_MAP_OPS
};
-
-/* the init function */
-int ldb_simple_ldap_map_module_init(void)
-{
- int ret;
- struct ldb_module_ops ops = ldb_map_get_ops();
- entryuuid_ops.add = ops.add;
- entryuuid_ops.modify = ops.modify;
- entryuuid_ops.del = ops.del;
- entryuuid_ops.rename = ops.rename;
- entryuuid_ops.search = ops.search;
- entryuuid_ops.wait = ops.wait;
- ret = ldb_register_module(&entryuuid_ops);
-
- if (ret) {
- return ret;
- }
-
- nsuniqueid_ops.add = ops.add;
- nsuniqueid_ops.modify = ops.modify;
- nsuniqueid_ops.del = ops.del;
- nsuniqueid_ops.rename = ops.rename;
- nsuniqueid_ops.search = ops.search;
- nsuniqueid_ops.wait = ops.wait;
- ret = ldb_register_module(&nsuniqueid_ops);
-
- return ret;
-}
}
}
-static const struct ldb_module_ops subtree_delete_ops = {
+const struct ldb_module_ops ldb_subtree_delete_module_ops = {
.name = "subtree_delete",
.del = subtree_delete,
.wait = subtree_delete_wait,
};
-
-int ldb_subtree_delete_init(void)
-{
- return ldb_register_module(&subtree_delete_ops);
-}
}
}
-static const struct ldb_module_ops subtree_rename_ops = {
+const struct ldb_module_ops ldb_subtree_rename_module_ops = {
.name = "subtree_rename",
.rename = subtree_rename,
.wait = subtree_rename_wait,
};
-
-int ldb_subtree_rename_init(void)
-{
- return ldb_register_module(&subtree_rename_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops update_kt_ops = {
+const struct ldb_module_ops ldb_update_keytab_module_ops = {
.name = "update_keytab",
.init_context = update_kt_init,
.add = update_kt_add,
.end_transaction = update_kt_end_trans,
.del_transaction = update_kt_del_trans,
};
-
-int ldb_update_kt_init(void)
-{
- return ldb_register_module(&update_kt_ops);
-}
}
/* Wait for pending requests to finish. */
-static int map_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+int map_wait(struct ldb_handle *handle, enum ldb_wait_type type)
{
if (type == LDB_WAIT_ALL) {
return map_wait_all(handle);
/* Module initialization
* ===================== */
-/* Provided module operations */
-static const struct ldb_module_ops map_ops = {
- .name = "ldb_map",
- .add = map_add,
- .modify = map_modify,
- .del = map_delete,
- .rename = map_rename,
- .search = map_search,
- .wait = map_wait,
-};
/* Builtin mappings for DNs and objectClasses */
static const struct ldb_map_attribute builtin_attribute_maps[] = {
return LDB_SUCCESS;
}
-/* Copy the list of provided module operations. */
-_PUBLIC_ struct ldb_module_ops ldb_map_get_ops(void)
-{
- return map_ops;
-}
-
/* Initialize global private data. */
_PUBLIC_ int ldb_map_init(struct ldb_module *module, const struct ldb_map_attribute *attrs,
const struct ldb_map_objectclass *ocls,
return LDB_SUCCESS;
}
-
-/* Usage note for initialization of this module:
- *
- * ldb_map is meant to be used from a different module that sets up
- * the mappings and gets registered in ldb.
- *
- * 'ldb_map_init' initializes the private data of this module and
- * stores the attribute and objectClass maps in there. It also looks
- * up the '@MAP' special DN so requests can be redirected to the
- * remote partition.
- *
- * This function should be called from the 'init_context' op of the
- * module using ldb_map.
- *
- * 'ldb_map_get_ops' returns a copy of ldb_maps module operations.
- *
- * It should be called from the initialize function of the using
- * module, which should then override the 'init_context' op with a
- * function making the appropriate calls to 'ldb_map_init'.
- */
const char *add_objectclass,
const char *name);
-/* get copy of map_ops */
-struct ldb_module_ops
-ldb_map_get_ops(void);
+int map_add(struct ldb_module *module, struct ldb_request *req);
+int map_search(struct ldb_module *module, struct ldb_request *req);
+int map_rename(struct ldb_module *module, struct ldb_request *req);
+int map_delete(struct ldb_module *module, struct ldb_request *req);
+int map_modify(struct ldb_module *module, struct ldb_request *req);
+int map_wait(struct ldb_handle *handle, enum ldb_wait_type type);
+
+#define LDB_MAP_OPS \
+ .add = map_add, \
+ .modify = map_modify, \
+ .del = map_delete, \
+ .rename = map_rename, \
+ .search = map_search, \
+ .wait = map_wait,
#endif /* __LDB_MAP_H__ */
/* The following definitions come from lib/ldb/modules/ldb_map_inbound.c */
int map_add_do_remote(struct ldb_handle *handle);
int map_add_do_local(struct ldb_handle *handle);
-int map_add(struct ldb_module *module, struct ldb_request *req);
int map_modify_do_remote(struct ldb_handle *handle);
int map_modify_do_local(struct ldb_handle *handle);
-int map_modify(struct ldb_module *module, struct ldb_request *req);
int map_delete_do_remote(struct ldb_handle *handle);
int map_delete_do_local(struct ldb_handle *handle);
-int map_delete(struct ldb_module *module, struct ldb_request *req);
int map_rename_do_remote(struct ldb_handle *handle);
int map_rename_do_fixup(struct ldb_handle *handle);
int map_rename_do_local(struct ldb_handle *handle);
-int map_rename(struct ldb_module *module, struct ldb_request *req);
-
-/* The following definitions come from lib/ldb/modules/ldb_map_outbound.c */
-int map_search(struct ldb_module *module, struct ldb_request *req);
return ldb_next_init(module);
}
-
-static const struct ldb_module_ops asq_ops = {
+const struct ldb_module_ops ldb_asq_module_ops = {
.name = "asq",
.search = asq_search,
.wait = asq_wait,
.init_context = asq_init
};
-
-int ldb_asq_init(void)
-{
- return ldb_register_module(&asq_ops);
-}
return ldb_next_init(ctx);
}
-static const struct ldb_module_ops operational_ops = {
+const struct ldb_module_ops ldb_operational_module_ops = {
.name = "operational",
.search = operational_search,
.init_context = operational_init
};
-
-int ldb_operational_init(void)
-{
- return ldb_register_module(&operational_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops paged_ops = {
+const struct ldb_module_ops ldb_paged_results_module_ops = {
.name = "paged_results",
.search = paged_search,
.wait = paged_wait,
.init_context = paged_request_init
};
-
-int ldb_paged_results_init(void)
-{
- return ldb_register_module(&paged_ops);
-}
-
return ldb_next_init(module);
}
-static const struct ldb_module_ops ps_ops = {
+const struct ldb_module_ops ldb_pages_searches_module_ops = {
.name = "paged_searches",
.search = ps_search,
.wait = ps_wait,
.init_context = ps_init
};
-
-int ldb_paged_searches_init(void)
-{
- return ldb_register_module(&ps_ops);
-}
-
return rdn_name_wait_once(handle);
}
-static const struct ldb_module_ops rdn_name_ops = {
+const struct ldb_module_ops ldb_rdn_name_module_ops = {
.name = "rdn_name",
.add = rdn_name_add,
.rename = rdn_name_rename,
.wait = rdn_name_wait
};
-
-
-int ldb_rdn_name_init(void)
-{
- return ldb_register_module(&rdn_name_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops skel_ops = {
+const struct ldb_module_ops ldb_skel_module_ops = {
.name = "skel",
.init_context = skel_init,
.search = skel_search,
.end_transaction = skel_end_trans,
.del_transaction = skel_del_trans,
};
-
-int ldb_skel_init(void)
-{
- return ldb_register_module(&skel_ops);
-}
return ldb_next_init(module);
}
-static const struct ldb_module_ops server_sort_ops = {
+const struct ldb_module_ops ldb_server_sort_module_ops = {
.name = "server_sort",
.search = server_sort_search,
.wait = server_sort_wait,
.init_context = server_sort_init
};
-
-int ldb_sort_init(void)
-{
- return ldb_register_module(&server_sort_ops);
-}
return LDB_ERR_OTHER;
}
-static const struct ldb_module_ops wins_ldb_ops = {
+const struct ldb_module_ops ldb_wins_ldb_module_ops = {
.name = "wins_ldb",
.add = wins_ldb_verify,
.modify = wins_ldb_verify,
.init_context = wins_ldb_init
};
-
-
-/* the init function */
-int wins_ldb_module_init(void)
-{
- return ldb_register_module(&wins_ldb_ops);
-}