sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-28 17:47:29 +03:00
Code

s4: dsdb Avoid using the internal ldb_private.h header

Browse Source 
This job is not complete (the partition module remains a unfinished
task), but now we do use the private ldb headers much less.

Andrew Bartlett
This commit is contained in:
Andrew Bartlett 2009-06-30 15:12:29 +10:00
parent 89a074b784
commit 49e5b83aa9
5 changed files with 122 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
source4/dsdb/samdb/ldb_modules/extended_dn_in.c
View File

@ -32,7 +32,7 @@
#include "includes.h" #include "includes.h"
#include "ldb/include/ldb.h" #include "ldb/include/ldb.h"
#include "ldb/include/ldb_errors.h" #include "ldb/include/ldb_errors.h"
#include "ldb/include/ldb_private.h" #include "ldb/include/ldb_module.h"
/* search */ /* search */
struct extended_search_context { struct extended_search_context {
@ -116,7 +116,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
(const char *)el->values[i].data, (const char *)el->values[i].data,
el->values[i].length); el->values[i].length);
if (!valstr) { if (!valstr) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return ldb_module_done(ac->req, NULL, NULL, return ldb_module_done(ac->req, NULL, NULL,
LDB_ERR_OPERATIONS_ERROR); LDB_ERR_OPERATIONS_ERROR);
} }
@ -134,10 +134,10 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
break; break;
} }
ac->basedn = ldb_dn_new(ac, ac->module->ldb, found); ac->basedn = ldb_dn_new(ac, ldb_module_get_ctx(ac->module), found);
talloc_free(valstr); talloc_free(valstr);
if (!ac->basedn) { if (!ac->basedn) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return ldb_module_done(ac->req, NULL, NULL, return ldb_module_done(ac->req, NULL, NULL,
LDB_ERR_OPERATIONS_ERROR); LDB_ERR_OPERATIONS_ERROR);
} }
@ -152,7 +152,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
if (!ac->basedn) { if (!ac->basedn) {
const char *str = talloc_asprintf(req, "Base-DN '%s' not found", const char *str = talloc_asprintf(req, "Base-DN '%s' not found",
ldb_dn_get_linearized(ac->req->op.search.base)); ldb_dn_get_linearized(ac->req->op.search.base));
ldb_set_errstring(ac->module->ldb, str); ldb_set_errstring(ldb_module_get_ctx(ac->module), str);
return ldb_module_done(ac->req, NULL, NULL, return ldb_module_done(ac->req, NULL, NULL,
LDB_ERR_NO_SUCH_OBJECT); LDB_ERR_NO_SUCH_OBJECT);
} }
@ -160,7 +160,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
switch (ac->req->operation) { switch (ac->req->operation) {
case LDB_SEARCH: case LDB_SEARCH:
ret = ldb_build_search_req_ex(&down_req, ret = ldb_build_search_req_ex(&down_req,
ac->module->ldb, ac->req, ldb_module_get_ctx(ac->module), ac->req,
ac->basedn, ac->basedn,
ac->req->op.search.scope, ac->req->op.search.scope,
ac->req->op.search.tree, ac->req->op.search.tree,
@ -173,7 +173,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
{ {
struct ldb_message *add_msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message); struct ldb_message *add_msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
if (!add_msg) { if (!add_msg) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return ldb_module_done(ac->req, NULL, NULL, return ldb_module_done(ac->req, NULL, NULL,
LDB_ERR_OPERATIONS_ERROR); LDB_ERR_OPERATIONS_ERROR);
} }
@ -181,7 +181,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
add_msg->dn = ac->basedn; add_msg->dn = ac->basedn;
ret = ldb_build_add_req(&down_req, ret = ldb_build_add_req(&down_req,
ac->module->ldb, ac->req, ldb_module_get_ctx(ac->module), ac->req,
add_msg, add_msg,
ac->req->controls, ac->req->controls,
ac, extended_final_callback, ac, extended_final_callback,
@ -192,7 +192,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
{ {
struct ldb_message *mod_msg = ldb_msg_copy_shallow(ac, ac->req->op.mod.message); struct ldb_message *mod_msg = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
if (!mod_msg) { if (!mod_msg) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return ldb_module_done(ac->req, NULL, NULL, return ldb_module_done(ac->req, NULL, NULL,
LDB_ERR_OPERATIONS_ERROR); LDB_ERR_OPERATIONS_ERROR);
} }
@ -200,7 +200,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
mod_msg->dn = ac->basedn; mod_msg->dn = ac->basedn;
ret = ldb_build_mod_req(&down_req, ret = ldb_build_mod_req(&down_req,
ac->module->ldb, ac->req, ldb_module_get_ctx(ac->module), ac->req,
mod_msg, mod_msg,
ac->req->controls, ac->req->controls,
ac, extended_final_callback, ac, extended_final_callback,
@ -209,7 +209,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
} }
case LDB_DELETE: case LDB_DELETE:
ret = ldb_build_del_req(&down_req, ret = ldb_build_del_req(&down_req,
ac->module->ldb, ac->req, ldb_module_get_ctx(ac->module), ac->req,
ac->basedn, ac->basedn,
ac->req->controls, ac->req->controls,
ac, extended_final_callback, ac, extended_final_callback,
@ -217,7 +217,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
break; break;
case LDB_RENAME: case LDB_RENAME:
ret = ldb_build_rename_req(&down_req, ret = ldb_build_rename_req(&down_req,
ac->module->ldb, ac->req, ldb_module_get_ctx(ac->module), ac->req,
ac->basedn, ac->basedn,
ac->req->op.rename.newdn, ac->req->op.rename.newdn,
ac->req->controls, ac->req->controls,
@ -269,11 +269,11 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
if (sid_val) { if (sid_val) {
/* TODO: do a search over all partitions */ /* TODO: do a search over all partitions */
base_dn = ldb_get_default_basedn(module->ldb); base_dn = ldb_get_default_basedn(ldb_module_get_ctx(module));
base_dn_filter = talloc_asprintf(req, "(objectSid=%s)", base_dn_filter = talloc_asprintf(req, "(objectSid=%s)",
ldb_binary_encode(req, *sid_val)); ldb_binary_encode(req, *sid_val));
if (!base_dn_filter) { if (!base_dn_filter) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
base_dn_scope = LDB_SCOPE_SUBTREE; base_dn_scope = LDB_SCOPE_SUBTREE;
@ -282,11 +282,11 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
} else if (guid_val) { } else if (guid_val) {
/* TODO: do a search over all partitions */ /* TODO: do a search over all partitions */
base_dn = ldb_get_default_basedn(module->ldb); base_dn = ldb_get_default_basedn(ldb_module_get_ctx(module));
base_dn_filter = talloc_asprintf(req, "(objectGUID=%s)", base_dn_filter = talloc_asprintf(req, "(objectGUID=%s)",
ldb_binary_encode(req, *guid_val)); ldb_binary_encode(req, *guid_val));
if (!base_dn_filter) { if (!base_dn_filter) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
base_dn_scope = LDB_SCOPE_SUBTREE; base_dn_scope = LDB_SCOPE_SUBTREE;
@ -310,21 +310,21 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
wellknown_object = talloc_asprintf(req, "B:32:%s:", wkguid_dup); wellknown_object = talloc_asprintf(req, "B:32:%s:", wkguid_dup);
if (!wellknown_object) { if (!wellknown_object) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
tail_str = p; tail_str = p;
base_dn = ldb_dn_new(req, module->ldb, tail_str); base_dn = ldb_dn_new(req, ldb_module_get_ctx(module), tail_str);
talloc_free(wkguid_dup); talloc_free(wkguid_dup);
if (!base_dn) { if (!base_dn) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
base_dn_filter = talloc_strdup(req, "(objectClass=*)"); base_dn_filter = talloc_strdup(req, "(objectClass=*)");
if (!base_dn_filter) { if (!base_dn_filter) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
base_dn_scope = LDB_SCOPE_BASE; base_dn_scope = LDB_SCOPE_BASE;
@ -335,7 +335,7 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
ac = talloc_zero(req, struct extended_search_context); ac = talloc_zero(req, struct extended_search_context);
if (ac == NULL) { if (ac == NULL) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -348,7 +348,7 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
* GUID) then search for that, so we can proceed with the original operation */ * GUID) then search for that, so we can proceed with the original operation */
ret = ldb_build_search_req(&down_req, ret = ldb_build_search_req(&down_req,
module->ldb, ac, ldb_module_get_ctx(module), ac,
base_dn, base_dn,
base_dn_scope, base_dn_scope,
base_dn_filter, base_dn_filter,

48
source4/dsdb/samdb/ldb_modules/extended_dn_out.c
View File

@ -34,7 +34,7 @@
#include "includes.h" #include "includes.h"
#include "ldb/include/ldb.h" #include "ldb/include/ldb.h"
#include "ldb/include/ldb_errors.h" #include "ldb/include/ldb_errors.h"
#include "ldb/include/ldb_private.h" #include "ldb/include/ldb_module.h"
#include "librpc/gen_ndr/ndr_misc.h" #include "librpc/gen_ndr/ndr_misc.h"
#include "librpc/ndr/libndr.h" #include "librpc/ndr/libndr.h"
#include "dsdb/samdb/samdb.h" #include "dsdb/samdb/samdb.h"
@ -249,7 +249,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
struct extended_dn_out_private *p; struct extended_dn_out_private *p;
ac = talloc_get_type(req->context, struct extended_search_context); ac = talloc_get_type(req->context, struct extended_search_context);
p = talloc_get_type(ac->module->private_data, struct extended_dn_out_private); p = talloc_get_type(ldb_module_get_private(ac->module), struct extended_dn_out_private);
if (!ares) { if (!ares) {
return ldb_module_done(ac->req, NULL, NULL, return ldb_module_done(ac->req, NULL, NULL,
@ -281,7 +281,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
if (ac->inject) { if (ac->inject) {
/* for each record returned post-process to add any derived /* for each record returned post-process to add any derived
attributes that have been asked for */ attributes that have been asked for */
ret = inject_extended_dn_out(ares, ac->module->ldb, ret = inject_extended_dn_out(ares, ldb_module_get_ctx(ac->module),
ac->extended_type, ac->remove_guid, ac->extended_type, ac->remove_guid,
ac->remove_sid); ac->remove_sid);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
@ -301,7 +301,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
ldb_dn_get_linearized(ares->message->dn)); ldb_dn_get_linearized(ares->message->dn));
} }
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
} }
@ -329,7 +329,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
* correct case */ * correct case */
msg->elements[i].name = talloc_strdup(msg->elements, attribute->lDAPDisplayName); msg->elements[i].name = talloc_strdup(msg->elements, attribute->lDAPDisplayName);
if (!msg->elements[i].name) { if (!msg->elements[i].name) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR); return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
} }
} }
@ -346,7 +346,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
for (j = 0; j < msg->elements[i].num_values; j++) { for (j = 0; j < msg->elements[i].num_values; j++) {
const char *dn_str; const char *dn_str;
struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, ac->module->ldb, &msg->elements[i].values[j]); struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, ldb_module_get_ctx(ac->module), &msg->elements[i].values[j]);
if (!dn || !ldb_dn_validate(dn)) { if (!dn || !ldb_dn_validate(dn)) {
return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_INVALID_DN_SYNTAX); return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_INVALID_DN_SYNTAX);
} }
@ -385,7 +385,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
dn, ac->extended_type)); dn, ac->extended_type));
} }
if (!dn_str) { if (!dn_str) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR); return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
} }
msg->elements[i].values[j] = data_blob_string_const(dn_str); msg->elements[i].values[j] = data_blob_string_const(dn_str);
@ -408,7 +408,7 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
const char * const *const_attrs; const char * const *const_attrs;
int ret; int ret;
struct extended_dn_out_private *p = talloc_get_type(module->private_data, struct extended_dn_out_private); struct extended_dn_out_private *p = talloc_get_type(ldb_module_get_private(module), struct extended_dn_out_private);
/* check if there's an extended dn control */ /* check if there's an extended dn control */
control = ldb_request_get_control(req, LDB_CONTROL_EXTENDED_DN_OID); control = ldb_request_get_control(req, LDB_CONTROL_EXTENDED_DN_OID);
@ -426,19 +426,19 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
if (!control && storage_format_control && storage_format_control->data) { if (!control && storage_format_control && storage_format_control->data) {
extended_ctrl = talloc_get_type(storage_format_control->data, struct ldb_extended_dn_control); extended_ctrl = talloc_get_type(storage_format_control->data, struct ldb_extended_dn_control);
if (!extended_ctrl) { if (!extended_ctrl) {
ldb_set_errstring(module->ldb, "extended_dn_out: extended_ctrl was of the wrong data type"); ldb_set_errstring(ldb_module_get_ctx(module), "extended_dn_out: extended_ctrl was of the wrong data type");
return LDB_ERR_PROTOCOL_ERROR; return LDB_ERR_PROTOCOL_ERROR;
} }
} }
ac = talloc_zero(req, struct extended_search_context); ac = talloc_zero(req, struct extended_search_context);
if (ac == NULL) { if (ac == NULL) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
ac->module = module; ac->module = module;
ac->schema = dsdb_get_schema(module->ldb); ac->schema = dsdb_get_schema(ldb_module_get_ctx(module));
ac->req = req; ac->req = req;
ac->inject = false; ac->inject = false;
ac->remove_guid = false; ac->remove_guid = false;
@ -469,7 +469,7 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
if (ac->remove_guid || ac->remove_sid) { if (ac->remove_guid || ac->remove_sid) {
new_attrs = copy_attrs(ac, req->op.search.attrs); new_attrs = copy_attrs(ac, req->op.search.attrs);
if (new_attrs == NULL) { if (new_attrs == NULL) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -487,7 +487,7 @@ static int extended_dn_out_search(struct ldb_module *module, struct ldb_request
} }
ret = ldb_build_search_req_ex(&down_req, ret = ldb_build_search_req_ex(&down_req,
module->ldb, ac, ldb_module_get_ctx(module), ac,
req->op.search.base, req->op.search.base,
req->op.search.scope, req->op.search.scope,
req->op.search.tree, req->op.search.tree,
@ -541,10 +541,10 @@ static int extended_dn_out_ldb_init(struct ldb_module *module)
struct extended_dn_out_private *p = talloc(module, struct extended_dn_out_private); struct extended_dn_out_private *p = talloc(module, struct extended_dn_out_private);
module->private_data = p; ldb_module_set_private(module, p);
if (!p) { if (!p) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -553,7 +553,7 @@ static int extended_dn_out_ldb_init(struct ldb_module *module)
ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID); ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
"extended_dn_out: Unable to register control with rootdse!\n"); "extended_dn_out: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -564,16 +564,16 @@ static int extended_dn_out_ldb_init(struct ldb_module *module)
static int extended_dn_out_dereference_init(struct ldb_module *module) static int extended_dn_out_dereference_init(struct ldb_module *module)
{ {
int ret, i = 0; int ret, i = 0;
struct extended_dn_out_private *p; struct extended_dn_out_private *p = talloc_zero(module, struct extended_dn_out_private);
struct dsdb_openldap_dereference_control *dereference_control; struct dsdb_openldap_dereference_control *dereference_control;
struct dsdb_attribute *cur; struct dsdb_attribute *cur;
struct dsdb_schema *schema; struct dsdb_schema *schema;
module->private_data = p = talloc_zero(module, struct extended_dn_out_private); ldb_module_set_private(module, p);
if (!p) { if (!p) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -585,7 +585,7 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID); ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
"extended_dn_out: Unable to register control with rootdse!\n"); "extended_dn_out: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -596,7 +596,7 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
return ret; return ret;
} }
schema = dsdb_get_schema(module->ldb); schema = dsdb_get_schema(ldb_module_get_ctx(module));
if (!schema) { if (!schema) {
/* No schema on this DB (yet) */ /* No schema on this DB (yet) */
return LDB_SUCCESS; return LDB_SUCCESS;
@ -606,7 +606,7 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
= talloc_zero(p, struct dsdb_openldap_dereference_control); = talloc_zero(p, struct dsdb_openldap_dereference_control);
if (!p->dereference_control) { if (!p->dereference_control) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -624,13 +624,13 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
= talloc_realloc(p, dereference_control->dereference, = talloc_realloc(p, dereference_control->dereference,
struct dsdb_openldap_dereference *, i + 2); struct dsdb_openldap_dereference *, i + 2);
if (!dereference_control) { if (!dereference_control) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
dereference_control->dereference[i] = talloc(dereference_control->dereference, dereference_control->dereference[i] = talloc(dereference_control->dereference,
struct dsdb_openldap_dereference); struct dsdb_openldap_dereference);
if (!dereference_control->dereference[i]) { if (!dereference_control->dereference[i]) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
dereference_control->dereference[i]->source_attribute = cur->lDAPDisplayName; dereference_control->dereference[i]->source_attribute = cur->lDAPDisplayName;

26
source4/dsdb/samdb/ldb_modules/extended_dn_store.c
View File

@ -38,7 +38,7 @@
#include "includes.h" #include "includes.h"
#include "ldb/include/ldb.h" #include "ldb/include/ldb.h"
#include "ldb/include/ldb_errors.h" #include "ldb/include/ldb_errors.h"
#include "ldb/include/ldb_private.h" #include "ldb/include/ldb_module.h"
#include "librpc/gen_ndr/ndr_misc.h" #include "librpc/gen_ndr/ndr_misc.h"
#include "dsdb/samdb/samdb.h" #include "dsdb/samdb/samdb.h"
#include "libcli/security/security.h" #include "libcli/security/security.h"
@ -73,11 +73,11 @@ static struct extended_dn_context *extended_dn_context_init(struct ldb_module *m
ac = talloc_zero(req, struct extended_dn_context); ac = talloc_zero(req, struct extended_dn_context);
if (ac == NULL) { if (ac == NULL) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return NULL; return NULL;
} }
ac->schema = dsdb_get_schema(module->ldb); ac->schema = dsdb_get_schema(ldb_module_get_ctx(module));
ac->module = module; ac->module = module;
ac->req = req; ac->req = req;
@ -127,7 +127,7 @@ static int extended_replace_dn(struct ldb_request *req, struct ldb_reply *ares)
if (ares->error == LDB_ERR_NO_SUCH_OBJECT) { if (ares->error == LDB_ERR_NO_SUCH_OBJECT) {
/* Don't worry too much about dangling references */ /* Don't worry too much about dangling references */
ldb_reset_err_string(os->ac->module->ldb); ldb_reset_err_string(ldb_module_get_ctx(os->ac->module));
if (os->next) { if (os->next) {
struct extended_dn_replace_list *next; struct extended_dn_replace_list *next;
@ -228,10 +228,10 @@ static int extended_store_replace(struct extended_dn_context *ac,
os->mem_ctx = callback_mem_ctx; os->mem_ctx = callback_mem_ctx;
os->dn = ldb_dn_from_ldb_val(os, ac->module->ldb, plain_dn); os->dn = ldb_dn_from_ldb_val(os, ldb_module_get_ctx(ac->module), plain_dn);
if (!os->dn || !ldb_dn_validate(os->dn)) { if (!os->dn || !ldb_dn_validate(os->dn)) {
talloc_free(os); talloc_free(os);
ldb_asprintf_errstring(ac->module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(ac->module),
"could not parse %.*s as a DN", (int)plain_dn->length, plain_dn->data); "could not parse %.*s as a DN", (int)plain_dn->length, plain_dn->data);
return LDB_ERR_INVALID_DN_SYNTAX; return LDB_ERR_INVALID_DN_SYNTAX;
} }
@ -243,7 +243,7 @@ static int extended_store_replace(struct extended_dn_context *ac,
* module in the stack will convert this into a normal DN for * module in the stack will convert this into a normal DN for
* processing */ * processing */
ret = ldb_build_search_req(&os->search_req, ret = ldb_build_search_req(&os->search_req,
ac->module->ldb, os, os->dn, LDB_SCOPE_BASE, NULL, ldb_module_get_ctx(ac->module), os, os->dn, LDB_SCOPE_BASE, NULL,
attrs, NULL, os, extended_replace_dn, attrs, NULL, os, extended_replace_dn,
ac->req); ac->req);
@ -311,11 +311,11 @@ static int extended_dn_add(struct ldb_module *module, struct ldb_request *req)
if (!ac->new_req) { if (!ac->new_req) {
struct ldb_message *msg = ldb_msg_copy(ac, req->op.add.message); struct ldb_message *msg = ldb_msg_copy(ac, req->op.add.message);
if (!msg) { if (!msg) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
ret = ldb_build_add_req(&ac->new_req, module->ldb, ac, msg, req->controls, ac, extended_final_callback, req); ret = ldb_build_add_req(&ac->new_req, ldb_module_get_ctx(module), ac, msg, req->controls, ac, extended_final_callback, req);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
return ret; return ret;
} }
@ -384,11 +384,11 @@ static int extended_dn_modify(struct ldb_module *module, struct ldb_request *req
if (!ac->new_req) { if (!ac->new_req) {
struct ldb_message *msg = ldb_msg_copy(ac, req->op.mod.message); struct ldb_message *msg = ldb_msg_copy(ac, req->op.mod.message);
if (!msg) { if (!msg) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
ret = ldb_build_mod_req(&ac->new_req, module->ldb, ac, msg, req->controls, ac, extended_final_callback, req); ret = ldb_build_mod_req(&ac->new_req, ldb_module_get_ctx(module), ac, msg, req->controls, ac, extended_final_callback, req);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
return ret; return ret;
} }
@ -397,9 +397,9 @@ static int extended_dn_modify(struct ldb_module *module, struct ldb_request *req
el = &ac->new_req->op.mod.message->elements[i]; el = &ac->new_req->op.mod.message->elements[i];
/* For each value being added, we need to setup the lookups to fill in the extended DN */ /* For each value being added, we need to setup the lookups to fill in the extended DN */
for (j = 0; j < el->num_values; j++) { for (j = 0; j < el->num_values; j++) {
struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, module->ldb, &el->values[j]); struct ldb_dn *dn = ldb_dn_from_ldb_val(ac, ldb_module_get_ctx(module), &el->values[j]);
if (!dn || !ldb_dn_validate(dn)) { if (!dn || !ldb_dn_validate(dn)) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"could not parse attribute %s as a DN", el->name); "could not parse attribute %s as a DN", el->name);
return LDB_ERR_INVALID_DN_SYNTAX; return LDB_ERR_INVALID_DN_SYNTAX;
} }

119
source4/dsdb/samdb/ldb_modules/partition.c
View File

@ -34,6 +34,9 @@
*/ */
#include "includes.h" #include "includes.h"
#include "lib/ldb/include/ldb.h"
#include "lib/ldb/include/ldb_errors.h"
#include "lib/ldb/include/ldb_module.h"
#include "lib/ldb/include/ldb_private.h" #include "lib/ldb/include/ldb_private.h"
#include "dsdb/samdb/samdb.h" #include "dsdb/samdb/samdb.h"
@ -63,7 +66,7 @@ static struct partition_context *partition_init_ctx(struct ldb_module *module, s
ac = talloc_zero(req, struct partition_context); ac = talloc_zero(req, struct partition_context);
if (ac == NULL) { if (ac == NULL) {
ldb_set_errstring(module->ldb, "Out of Memory"); ldb_set_errstring(ldb_module_get_ctx(module), "Out of Memory");
return NULL; return NULL;
} }
@ -80,7 +83,7 @@ static struct partition_context *partition_init_ctx(struct ldb_module *module, s
#define PARTITION_FIND_OP(module, op) do { \ #define PARTITION_FIND_OP(module, op) do { \
PARTITION_FIND_OP_NOERROR(module, op); \ PARTITION_FIND_OP_NOERROR(module, op); \
if (module == NULL) { \ if (module == NULL) { \
ldb_asprintf_errstring(module->ldb, \ ldb_asprintf_errstring(ldb_module_get_ctx(module), \
"Unable to find backend operation for " #op ); \ "Unable to find backend operation for " #op ); \
return LDB_ERR_OPERATIONS_ERROR; \ return LDB_ERR_OPERATIONS_ERROR; \
} \ } \
@ -126,9 +129,9 @@ static int partition_request(struct ldb_module *module, struct ldb_request *requ
if (ret == LDB_SUCCESS) { if (ret == LDB_SUCCESS) {
return ret; return ret;
} }
if (!ldb_errstring(module->ldb)) { if (!ldb_errstring(ldb_module_get_ctx(module))) {
/* Set a default error string, to place the blame somewhere */ /* Set a default error string, to place the blame somewhere */
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"error in module %s: %s (%d)", "error in module %s: %s (%d)",
module->ops->name, module->ops->name,
ldb_strerror(ret), ret); ldb_strerror(ret), ret);
@ -183,7 +186,7 @@ static int partition_req_callback(struct ldb_request *req,
case LDB_REPLY_ENTRY: case LDB_REPLY_ENTRY:
if (ac->req->operation != LDB_SEARCH) { if (ac->req->operation != LDB_SEARCH) {
ldb_set_errstring(ac->module->ldb, ldb_set_errstring(ldb_module_get_ctx(ac->module),
"partition_req_callback:" "partition_req_callback:"
" Unsupported reply type for this request"); " Unsupported reply type for this request");
return ldb_module_done(ac->req, NULL, NULL, return ldb_module_done(ac->req, NULL, NULL,
@ -199,7 +202,7 @@ static int partition_req_callback(struct ldb_request *req,
/* FIXME: check for ares->response, replmd does not fill it ! */ /* FIXME: check for ares->response, replmd does not fill it ! */
if (ares->response) { if (ares->response) {
if (strcmp(ares->response->oid, LDB_EXTENDED_START_TLS_OID) != 0) { if (strcmp(ares->response->oid, LDB_EXTENDED_START_TLS_OID) != 0) {
ldb_set_errstring(ac->module->ldb, ldb_set_errstring(ldb_module_get_ctx(ac->module),
"partition_req_callback:" "partition_req_callback:"
" Unknown extended reply, " " Unknown extended reply, "
"only supports START_TLS"); "only supports START_TLS");
@ -245,13 +248,13 @@ static int partition_prep_request(struct partition_context *ac,
struct part_request, struct part_request,
ac->num_requests + 1); ac->num_requests + 1);
if (ac->part_req == NULL) { if (ac->part_req == NULL) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
switch (ac->req->operation) { switch (ac->req->operation) {
case LDB_SEARCH: case LDB_SEARCH:
ret = ldb_build_search_req_ex(&req, ac->module->ldb, ret = ldb_build_search_req_ex(&req, ldb_module_get_ctx(ac->module),
ac->part_req, ac->part_req,
ac->req->op.search.base, ac->req->op.search.base,
ac->req->op.search.scope, ac->req->op.search.scope,
@ -262,28 +265,28 @@ static int partition_prep_request(struct partition_context *ac,
ac->req); ac->req);
break; break;
case LDB_ADD: case LDB_ADD:
ret = ldb_build_add_req(&req, ac->module->ldb, ac->part_req, ret = ldb_build_add_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.add.message, ac->req->op.add.message,
ac->req->controls, ac->req->controls,
ac, partition_req_callback, ac, partition_req_callback,
ac->req); ac->req);
break; break;
case LDB_MODIFY: case LDB_MODIFY:
ret = ldb_build_mod_req(&req, ac->module->ldb, ac->part_req, ret = ldb_build_mod_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.mod.message, ac->req->op.mod.message,
ac->req->controls, ac->req->controls,
ac, partition_req_callback, ac, partition_req_callback,
ac->req); ac->req);
break; break;
case LDB_DELETE: case LDB_DELETE:
ret = ldb_build_del_req(&req, ac->module->ldb, ac->part_req, ret = ldb_build_del_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.del.dn, ac->req->op.del.dn,
ac->req->controls, ac->req->controls,
ac, partition_req_callback, ac, partition_req_callback,
ac->req); ac->req);
break; break;
case LDB_RENAME: case LDB_RENAME:
ret = ldb_build_rename_req(&req, ac->module->ldb, ac->part_req, ret = ldb_build_rename_req(&req, ldb_module_get_ctx(ac->module), ac->part_req,
ac->req->op.rename.olddn, ac->req->op.rename.olddn,
ac->req->op.rename.newdn, ac->req->op.rename.newdn,
ac->req->controls, ac->req->controls,
@ -291,7 +294,7 @@ static int partition_prep_request(struct partition_context *ac,
ac->req); ac->req);
break; break;
case LDB_EXTENDED: case LDB_EXTENDED:
ret = ldb_build_extended_req(&req, ac->module->ldb, ret = ldb_build_extended_req(&req, ldb_module_get_ctx(ac->module),
ac->part_req, ac->part_req,
ac->req->op.extended.oid, ac->req->op.extended.oid,
ac->req->op.extended.data, ac->req->op.extended.data,
@ -300,7 +303,7 @@ static int partition_prep_request(struct partition_context *ac,
ac->req); ac->req);
break; break;
default: default:
ldb_set_errstring(ac->module->ldb, ldb_set_errstring(ldb_module_get_ctx(ac->module),
"Unsupported request type!"); "Unsupported request type!");
ret = LDB_ERR_UNWILLING_TO_PERFORM; ret = LDB_ERR_UNWILLING_TO_PERFORM;
} }
@ -315,7 +318,7 @@ static int partition_prep_request(struct partition_context *ac,
req->controls = talloc_memdup(req, ac->req->controls, req->controls = talloc_memdup(req, ac->req->controls,
talloc_get_size(ac->req->controls)); talloc_get_size(ac->req->controls));
if (req->controls == NULL) { if (req->controls == NULL) {
ldb_oom(ac->module->ldb); ldb_oom(ldb_module_get_ctx(ac->module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
} }
@ -467,7 +470,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
/* Remove the domain_scope control, so we don't confuse a backend server */ /* Remove the domain_scope control, so we don't confuse a backend server */
if (domain_scope_control && !save_controls(domain_scope_control, req, &saved_controls)) { if (domain_scope_control && !save_controls(domain_scope_control, req, &saved_controls)) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -491,7 +494,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
/* Remove search control, so we don't confuse a backend server */ /* Remove search control, so we don't confuse a backend server */
if (search_control && !save_controls(search_control, req, &saved_controls)) { if (search_control && !save_controls(search_control, req, &saved_controls)) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
} }
@ -558,7 +561,7 @@ static int partition_search(struct ldb_module *module, struct ldb_request *req)
/* Remove search control, so we don't confuse a backend server */ /* Remove search control, so we don't confuse a backend server */
if (search_control && !save_controls(search_control, req, &saved_controls)) { if (search_control && !save_controls(search_control, req, &saved_controls)) {
ldb_oom(module->ldb); ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
} }
@ -607,7 +610,7 @@ static int partition_rename(struct ldb_module *module, struct ldb_request *req)
} }
if (backend != backend2) { if (backend != backend2) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"Cannot rename from %s in %s to %s in %s: %s", "Cannot rename from %s in %s to %s in %s: %s",
ldb_dn_get_linearized(req->op.rename.olddn), ldb_dn_get_linearized(req->op.rename.olddn),
ldb_dn_get_linearized(backend->dn), ldb_dn_get_linearized(backend->dn),
@ -681,7 +684,7 @@ static int partition_end_trans(struct ldb_module *module)
PARTITION_FIND_OP(next_del, del_transaction); PARTITION_FIND_OP(next_del, del_transaction);
if (next_end != next_prepare || next_del != next_end) { if (next_end != next_prepare || next_del != next_end) {
ldb_asprintf_errstring(module->ldb, "ERROR: Mismatch between prepare and commit ops in ldb module"); ldb_asprintf_errstring(ldb_module_get_ctx(module), "ERROR: Mismatch between prepare and commit ops in ldb module");
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -713,7 +716,7 @@ static int partition_end_trans(struct ldb_module *module)
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
/* this should only be happening if we had a serious /* this should only be happening if we had a serious
OS or hardware error */ OS or hardware error */
ldb_asprintf_errstring(module->ldb, "ERROR: partition commit error"); ldb_asprintf_errstring(ldb_module_get_ctx(module), "ERROR: partition commit error");
final_ret = ret; final_ret = ret;
} }
} }
@ -781,7 +784,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
} }
tseq->type = seq->type; tseq->type = seq->type;
ret = ldb_build_extended_req(&treq, module->ldb, res, ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
LDB_EXTENDED_SEQUENCE_NUMBER, LDB_EXTENDED_SEQUENCE_NUMBER,
tseq, tseq,
NULL, NULL,
@ -819,7 +822,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
} }
tseq->type = seq->type; tseq->type = seq->type;
ret = ldb_build_extended_req(&treq, module->ldb, res, ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
LDB_EXTENDED_SEQUENCE_NUMBER, LDB_EXTENDED_SEQUENCE_NUMBER,
tseq, tseq,
NULL, NULL,
@ -874,7 +877,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
} }
tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP; tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
ret = ldb_build_extended_req(&treq, module->ldb, res, ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
LDB_EXTENDED_SEQUENCE_NUMBER, LDB_EXTENDED_SEQUENCE_NUMBER,
tseq, tseq,
NULL, NULL,
@ -918,7 +921,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
} }
tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP; tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
ret = ldb_build_extended_req(&treq, module->ldb, res, ret = ldb_build_extended_req(&treq, ldb_module_get_ctx(module), res,
LDB_EXTENDED_SEQUENCE_NUMBER, LDB_EXTENDED_SEQUENCE_NUMBER,
tseq, tseq,
NULL, NULL,
@ -1008,12 +1011,12 @@ static int partition_extended_replicated_objects(struct ldb_module *module, stru
ext = talloc_get_type(req->op.extended.data, struct dsdb_extended_replicated_objects); ext = talloc_get_type(req->op.extended.data, struct dsdb_extended_replicated_objects);
if (!ext) { if (!ext) {
ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: invalid extended data\n"); ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended_replicated_objects: invalid extended data\n");
return LDB_ERR_PROTOCOL_ERROR; return LDB_ERR_PROTOCOL_ERROR;
} }
if (ext->version != DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION) { if (ext->version != DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION) {
ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended_replicated_objects: extended data invalid version [%u != %u]\n", ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended_replicated_objects: extended data invalid version [%u != %u]\n",
ext->version, DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION); ext->version, DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION);
return LDB_ERR_PROTOCOL_ERROR; return LDB_ERR_PROTOCOL_ERROR;
} }
@ -1031,7 +1034,7 @@ static int partition_extended_schema_update_now(struct ldb_module *module, struc
schema_dn = talloc_get_type(req->op.extended.data, struct ldb_dn); schema_dn = talloc_get_type(req->op.extended.data, struct ldb_dn);
if (!schema_dn) { if (!schema_dn) {
ldb_debug(module->ldb, LDB_DEBUG_FATAL, "partition_extended: invalid extended data\n"); ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_FATAL, "partition_extended: invalid extended data\n");
return LDB_ERR_PROTOCOL_ERROR; return LDB_ERR_PROTOCOL_ERROR;
} }
@ -1131,8 +1134,8 @@ static int partition_init(struct ldb_module *module)
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
ret = ldb_search(module->ldb, mem_ctx, &res, ret = ldb_search(ldb_module_get_ctx(module), mem_ctx, &res,
ldb_dn_new(mem_ctx, module->ldb, "@PARTITION"), ldb_dn_new(mem_ctx, ldb_module_get_ctx(module), "@PARTITION"),
LDB_SCOPE_BASE, attrs, NULL); LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx); talloc_free(mem_ctx);
@ -1152,7 +1155,7 @@ static int partition_init(struct ldb_module *module)
partition_attributes = ldb_msg_find_element(msg, "partition"); partition_attributes = ldb_msg_find_element(msg, "partition");
if (!partition_attributes) { if (!partition_attributes) {
ldb_set_errstring(module->ldb, "partition_init: no partitions specified"); ldb_set_errstring(ldb_module_get_ctx(module), "partition_init: no partitions specified");
talloc_free(mem_ctx); talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION; return LDB_ERR_CONSTRAINT_VIOLATION;
} }
@ -1165,7 +1168,7 @@ static int partition_init(struct ldb_module *module)
char *base = talloc_strdup(data->partitions, (char *)partition_attributes->values[i].data); char *base = talloc_strdup(data->partitions, (char *)partition_attributes->values[i].data);
char *p = strchr(base, ':'); char *p = strchr(base, ':');
if (!p) { if (!p) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"invalid form for partition record (missing ':'): %s", base); "invalid form for partition record (missing ':'): %s", base);
talloc_free(mem_ctx); talloc_free(mem_ctx);
@ -1174,7 +1177,7 @@ static int partition_init(struct ldb_module *module)
p[0] = '\0'; p[0] = '\0';
p++; p++;
if (!p[0]) { if (!p[0]) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"invalid form for partition record (missing backend database): %s", base); "invalid form for partition record (missing backend database): %s", base);
talloc_free(mem_ctx); talloc_free(mem_ctx);
@ -1187,23 +1190,23 @@ static int partition_init(struct ldb_module *module)
} }
data->partitions[i]->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION; data->partitions[i]->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
data->partitions[i]->dn = ldb_dn_new(data->partitions[i], module->ldb, base); data->partitions[i]->dn = ldb_dn_new(data->partitions[i], ldb_module_get_ctx(module), base);
if (!data->partitions[i]->dn) { if (!data->partitions[i]->dn) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: invalid DN in partition record: %s", base); "partition_init: invalid DN in partition record: %s", base);
talloc_free(mem_ctx); talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION; return LDB_ERR_CONSTRAINT_VIOLATION;
} }
data->partitions[i]->backend = samdb_relative_path(module->ldb, data->partitions[i]->backend = samdb_relative_path(ldb_module_get_ctx(module),
data->partitions[i], data->partitions[i],
p); p);
if (!data->partitions[i]->backend) { if (!data->partitions[i]->backend) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: unable to determine an relative path for partition: %s", base); "partition_init: unable to determine an relative path for partition: %s", base);
talloc_free(mem_ctx); talloc_free(mem_ctx);
} }
ret = ldb_connect_backend(module->ldb, data->partitions[i]->backend, NULL, &data->partitions[i]->module); ret = ldb_connect_backend(ldb_module_get_ctx(module), data->partitions[i]->backend, NULL, &data->partitions[i]->module);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx); talloc_free(mem_ctx);
return ret; return ret;
@ -1219,7 +1222,7 @@ static int partition_init(struct ldb_module *module)
struct ldb_request *req; struct ldb_request *req;
req = talloc_zero(mem_ctx, struct ldb_request); req = talloc_zero(mem_ctx, struct ldb_request);
if (req == NULL) { if (req == NULL) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Out of memory!\n"); ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "partition: Out of memory!\n");
talloc_free(mem_ctx); talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
@ -1228,19 +1231,19 @@ static int partition_init(struct ldb_module *module)
req->op.reg_partition.dn = data->partitions[i]->dn; req->op.reg_partition.dn = data->partitions[i]->dn;
req->callback = ldb_op_default_callback; req->callback = ldb_op_default_callback;
ldb_set_timeout(module->ldb, req, 0); ldb_set_timeout(ldb_module_get_ctx(module), req, 0);
req->handle = ldb_handle_new(req, module->ldb); req->handle = ldb_handle_new(req, ldb_module_get_ctx(module));
if (req->handle == NULL) { if (req->handle == NULL) {
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
ret = ldb_request(module->ldb, req); ret = ldb_request(ldb_module_get_ctx(module), req);
if (ret == LDB_SUCCESS) { if (ret == LDB_SUCCESS) {
ret = ldb_wait(req->handle, LDB_WAIT_ALL); ret = ldb_wait(req->handle, LDB_WAIT_ALL);
} }
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n"); ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n");
talloc_free(mem_ctx); talloc_free(mem_ctx);
return LDB_ERR_OTHER; return LDB_ERR_OTHER;
} }
@ -1258,9 +1261,9 @@ static int partition_init(struct ldb_module *module)
} }
for (i=0; i < replicate_attributes->num_values; i++) { for (i=0; i < replicate_attributes->num_values; i++) {
data->replicate[i] = ldb_dn_from_ldb_val(data->replicate, module->ldb, &replicate_attributes->values[i]); data->replicate[i] = ldb_dn_from_ldb_val(data->replicate, ldb_module_get_ctx(module), &replicate_attributes->values[i]);
if (!ldb_dn_validate(data->replicate[i])) { if (!ldb_dn_validate(data->replicate[i])) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"invalid DN in partition replicate record: %s", "invalid DN in partition replicate record: %s",
replicate_attributes->values[i].data); replicate_attributes->values[i].data);
@ -1286,7 +1289,7 @@ static int partition_init(struct ldb_module *module)
char *base = talloc_strdup(data->partitions, (char *)modules_attributes->values[i].data); char *base = talloc_strdup(data->partitions, (char *)modules_attributes->values[i].data);
char *p = strchr(base, ':'); char *p = strchr(base, ':');
if (!p) { if (!p) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"invalid form for partition module record (missing ':'): %s", base); "invalid form for partition module record (missing ':'): %s", base);
talloc_free(mem_ctx); talloc_free(mem_ctx);
@ -1295,17 +1298,17 @@ static int partition_init(struct ldb_module *module)
p[0] = '\0'; p[0] = '\0';
p++; p++;
if (!p[0]) { if (!p[0]) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"invalid form for partition module record (missing backend database): %s", base); "invalid form for partition module record (missing backend database): %s", base);
talloc_free(mem_ctx); talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION; return LDB_ERR_CONSTRAINT_VIOLATION;
} }
modules = ldb_modules_list_from_string(module->ldb, mem_ctx, modules = ldb_modules_list_from_string(ldb_module_get_ctx(module), mem_ctx,
p); p);
base_dn = ldb_dn_new(mem_ctx, module->ldb, base); base_dn = ldb_dn_new(mem_ctx, ldb_module_get_ctx(module), base);
if (!ldb_dn_validate(base_dn)) { if (!ldb_dn_validate(base_dn)) {
talloc_free(mem_ctx); talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
@ -1319,28 +1322,28 @@ static int partition_init(struct ldb_module *module)
} }
if (!partition) { if (!partition) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"invalid form for partition module record (no such partition): %s", base); "invalid form for partition module record (no such partition): %s", base);
talloc_free(mem_ctx); talloc_free(mem_ctx);
return LDB_ERR_CONSTRAINT_VIOLATION; return LDB_ERR_CONSTRAINT_VIOLATION;
} }
ret = ldb_load_modules_list(module->ldb, modules, partition->module, &partition->module); ret = ldb_load_modules_list(ldb_module_get_ctx(module), modules, partition->module, &partition->module);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"loading backend for %s failed: %s", "loading backend for %s failed: %s",
base, ldb_errstring(module->ldb)); base, ldb_errstring(ldb_module_get_ctx(module)));
talloc_free(mem_ctx); talloc_free(mem_ctx);
return ret; return ret;
} }
ret = ldb_init_module_chain(module->ldb, partition->module); ret = ldb_init_module_chain(ldb_module_get_ctx(module), partition->module);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_asprintf_errstring(module->ldb, ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: " "partition_init: "
"initialising backend for %s failed: %s", "initialising backend for %s failed: %s",
base, ldb_errstring(module->ldb)); base, ldb_errstring(ldb_module_get_ctx(module)));
talloc_free(mem_ctx); talloc_free(mem_ctx);
return ret; return ret;
} }
@ -1349,14 +1352,14 @@ static int partition_init(struct ldb_module *module)
ret = ldb_mod_register_control(module, LDB_CONTROL_DOMAIN_SCOPE_OID); ret = ldb_mod_register_control(module, LDB_CONTROL_DOMAIN_SCOPE_OID);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
"partition: Unable to register control with rootdse!\n"); "partition: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }
ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID); ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID);
if (ret != LDB_SUCCESS) { if (ret != LDB_SUCCESS) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, ldb_debug(ldb_module_get_ctx(module), LDB_DEBUG_ERROR,
"partition: Unable to register control with rootdse!\n"); "partition: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR; return LDB_ERR_OPERATIONS_ERROR;
} }

3
source4/lib/ldb-samba/ldif_handlers.c
View File

@ -23,7 +23,8 @@
*/ */
#include "includes.h" #include "includes.h"
#include "lib/ldb/include/ldb_private.h" #include "lib/ldb/include/ldb.h"
#include "lib/ldb/include/ldb_module.h"
#include "ldb_handlers.h" #include "ldb_handlers.h"
#include "dsdb/samdb/samdb.h" #include "dsdb/samdb/samdb.h"
#include "librpc/gen_ndr/ndr_security.h" #include "librpc/gen_ndr/ndr_security.h"