sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-15 23:24:37 +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 "ldb/include/ldb.h"
#include "ldb/include/ldb_errors.h"
#include "ldb/include/ldb_private.h"
#include "ldb/include/ldb_module.h"
/* search */
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,
el->values[i].length);
if (!valstr) {
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);
}
@ -134,10 +134,10 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
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);
if (!ac->basedn) {
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);
}
@ -152,7 +152,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
if (!ac->basedn) {
const char *str = talloc_asprintf(req, "Base-DN '%s' not found",
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,
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) {
case LDB_SEARCH:
ret = ldb_build_search_req_ex(&down_req,
ac->module->ldb, ac->req,
ldb_module_get_ctx(ac->module), ac->req,
ac->basedn,
ac->req->op.search.scope,
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);
if (!add_msg) {
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);
}
@ -181,7 +181,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
add_msg->dn = ac->basedn;
ret = ldb_build_add_req(&down_req,
ac->module->ldb, ac->req,
ldb_module_get_ctx(ac->module), ac->req,
add_msg,
ac->req->controls,
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);
if (!mod_msg) {
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);
}
@ -200,7 +200,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
mod_msg->dn = ac->basedn;
ret = ldb_build_mod_req(&down_req,
ac->module->ldb, ac->req,
ldb_module_get_ctx(ac->module), ac->req,
mod_msg,
ac->req->controls,
ac, extended_final_callback,
@ -209,7 +209,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
}
case LDB_DELETE:
ret = ldb_build_del_req(&down_req,
ac->module->ldb, ac->req,
ldb_module_get_ctx(ac->module), ac->req,
ac->basedn,
ac->req->controls,
ac, extended_final_callback,
@ -217,7 +217,7 @@ static int extended_base_callback(struct ldb_request *req, struct ldb_reply *are
break;
case LDB_RENAME:
ret = ldb_build_rename_req(&down_req,
ac->module->ldb, ac->req,
ldb_module_get_ctx(ac->module), ac->req,
ac->basedn,
ac->req->op.rename.newdn,
ac->req->controls,
@ -269,11 +269,11 @@ static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req
if (sid_val) {
/* 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)",
ldb_binary_encode(req, *sid_val));
if (!base_dn_filter) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
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) {
/* 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)",
ldb_binary_encode(req, *guid_val));
if (!base_dn_filter) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
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);
if (!wellknown_object) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
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);
if (!base_dn) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
base_dn_filter = talloc_strdup(req, "(objectClass=*)");
if (!base_dn_filter) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
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);
if (ac == NULL) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
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 */
ret = ldb_build_search_req(&down_req,
module->ldb, ac,
ldb_module_get_ctx(module), ac,
base_dn,
base_dn_scope,
base_dn_filter,

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

@ -34,7 +34,7 @@
#include "includes.h"
#include "ldb/include/ldb.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/ndr/libndr.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;
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) {
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) {
/* for each record returned post-process to add any derived
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->remove_sid);
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));
}
if (ret != LDB_SUCCESS) {
ldb_oom(ac->module->ldb);
ldb_oom(ldb_module_get_ctx(ac->module));
return LDB_ERR_OPERATIONS_ERROR;
}
}
@ -329,7 +329,7 @@ static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
* correct case */
msg->elements[i].name = talloc_strdup(msg->elements, attribute->lDAPDisplayName);
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);
}
}
@ -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++) {
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)) {
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));
}
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);
}
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;
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 */
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) {
extended_ctrl = talloc_get_type(storage_format_control->data, struct ldb_extended_dn_control);
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;
}
}
ac = talloc_zero(req, struct extended_search_context);
if (ac == NULL) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
ac->module = module;
ac->schema = dsdb_get_schema(module->ldb);
ac->schema = dsdb_get_schema(ldb_module_get_ctx(module));
ac->req = req;
ac->inject = 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) {
new_attrs = copy_attrs(ac, req->op.search.attrs);
if (new_attrs == NULL) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
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,
module->ldb, ac,
ldb_module_get_ctx(module), ac,
req->op.search.base,
req->op.search.scope,
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);
module->private_data = p;
ldb_module_set_private(module, p);
if (!p) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
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);
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");
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)
{
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_attribute *cur;
struct dsdb_schema *schema;
module->private_data = p = talloc_zero(module, struct extended_dn_out_private);
ldb_module_set_private(module, p);
if (!p) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
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);
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");
return LDB_ERR_OPERATIONS_ERROR;
}
@ -596,7 +596,7 @@ static int extended_dn_out_dereference_init(struct ldb_module *module)
return ret;
}
schema = dsdb_get_schema(module->ldb);
schema = dsdb_get_schema(ldb_module_get_ctx(module));
if (!schema) {
/* No schema on this DB (yet) */
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);
if (!p->dereference_control) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
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,
struct dsdb_openldap_dereference *, i + 2);
if (!dereference_control) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
dereference_control->dereference[i] = talloc(dereference_control->dereference,
struct dsdb_openldap_dereference);
if (!dereference_control->dereference[i]) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return LDB_ERR_OPERATIONS_ERROR;
}
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 "ldb/include/ldb.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 "dsdb/samdb/samdb.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);
if (ac == NULL) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
return NULL;
}
ac->schema = dsdb_get_schema(module->ldb);
ac->schema = dsdb_get_schema(ldb_module_get_ctx(module));
ac->module = module;
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) {
/* 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) {
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->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)) {
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);
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
* processing */
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,
ac->req);
@ -311,11 +311,11 @@ static int extended_dn_add(struct ldb_module *module, struct ldb_request *req)
if (!ac->new_req) {
struct ldb_message *msg = ldb_msg_copy(ac, req->op.add.message);
if (!msg) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
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) {
return ret;
}
@ -384,11 +384,11 @@ static int extended_dn_modify(struct ldb_module *module, struct ldb_request *req
if (!ac->new_req) {
struct ldb_message *msg = ldb_msg_copy(ac, req->op.mod.message);
if (!msg) {
ldb_oom(module->ldb);
ldb_oom(ldb_module_get_ctx(module));
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) {
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];
/* 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++) {
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)) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"could not parse attribute %s as a DN", el->name);
return LDB_ERR_INVALID_DN_SYNTAX;
}

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

@ -34,6 +34,9 @@
*/
#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 "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);
if (ac == NULL) {
ldb_set_errstring(module->ldb, "Out of Memory");
ldb_set_errstring(ldb_module_get_ctx(module), "Out of Memory");
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 { \
PARTITION_FIND_OP_NOERROR(module, op); \
if (module == NULL) { \
ldb_asprintf_errstring(module->ldb, \
ldb_asprintf_errstring(ldb_module_get_ctx(module), \
"Unable to find backend operation for " #op ); \
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) {
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 */
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"error in module %s: %s (%d)",
module->ops->name,
ldb_strerror(ret), ret);
@ -183,7 +186,7 @@ static int partition_req_callback(struct ldb_request *req,
case LDB_REPLY_ENTRY:
if (ac->req->operation != LDB_SEARCH) {
ldb_set_errstring(ac->module->ldb,
ldb_set_errstring(ldb_module_get_ctx(ac->module),
"partition_req_callback:"
" Unsupported reply type for this request");
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 ! */
if (ares->response) {
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:"
" Unknown extended reply, "
"only supports START_TLS");
@ -245,13 +248,13 @@ static int partition_prep_request(struct partition_context *ac,
struct part_request,
ac->num_requests + 1);
if (ac->part_req == NULL) {
ldb_oom(ac->module->ldb);
ldb_oom(ldb_module_get_ctx(ac->module));
return LDB_ERR_OPERATIONS_ERROR;
}
switch (ac->req->operation) {
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->req->op.search.base,
ac->req->op.search.scope,
@ -262,28 +265,28 @@ static int partition_prep_request(struct partition_context *ac,
ac->req);
break;
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->controls,
ac, partition_req_callback,
ac->req);
break;
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->controls,
ac, partition_req_callback,
ac->req);
break;
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->controls,
ac, partition_req_callback,
ac->req);
break;
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.newdn,
ac->req->controls,
@ -291,7 +294,7 @@ static int partition_prep_request(struct partition_context *ac,
ac->req);
break;
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->req->op.extended.oid,
ac->req->op.extended.data,
@ -300,7 +303,7 @@ static int partition_prep_request(struct partition_context *ac,
ac->req);
break;
default:
ldb_set_errstring(ac->module->ldb,
ldb_set_errstring(ldb_module_get_ctx(ac->module),
"Unsupported request type!");
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,
talloc_get_size(ac->req->controls));
if (req->controls == NULL) {
ldb_oom(ac->module->ldb);
ldb_oom(ldb_module_get_ctx(ac->module));
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 */
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;
}
@ -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 */
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;
}
}
@ -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 */
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;
}
}
@ -607,7 +610,7 @@ static int partition_rename(struct ldb_module *module, struct ldb_request *req)
}
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",
ldb_dn_get_linearized(req->op.rename.olddn),
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);
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;
}
@ -713,7 +716,7 @@ static int partition_end_trans(struct ldb_module *module)
if (ret != LDB_SUCCESS) {
/* this should only be happening if we had a serious
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;
}
}
@ -781,7 +784,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
}
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,
tseq,
NULL,
@ -819,7 +822,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
}
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,
tseq,
NULL,
@ -874,7 +877,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
}
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,
tseq,
NULL,
@ -918,7 +921,7 @@ static int partition_sequence_number(struct ldb_module *module, struct ldb_reque
}
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,
tseq,
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);
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;
}
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);
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);
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;
}
@ -1131,8 +1134,8 @@ static int partition_init(struct ldb_module *module)
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_search(module->ldb, mem_ctx, &res,
ldb_dn_new(mem_ctx, module->ldb, "@PARTITION"),
ret = ldb_search(ldb_module_get_ctx(module), mem_ctx, &res,
ldb_dn_new(mem_ctx, ldb_module_get_ctx(module), "@PARTITION"),
LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx);
@ -1152,7 +1155,7 @@ static int partition_init(struct ldb_module *module)
partition_attributes = ldb_msg_find_element(msg, "partition");
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);
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 *p = strchr(base, ':');
if (!p) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition record (missing ':'): %s", base);
talloc_free(mem_ctx);
@ -1174,7 +1177,7 @@ static int partition_init(struct ldb_module *module)
p[0] = '\0';
p++;
if (!p[0]) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition record (missing backend database): %s", base);
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]->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) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: invalid DN in partition record: %s", base);
talloc_free(mem_ctx);
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],
p);
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);
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) {
talloc_free(mem_ctx);
return ret;
@ -1219,7 +1222,7 @@ static int partition_init(struct ldb_module *module)
struct ldb_request *req;
req = talloc_zero(mem_ctx, struct ldb_request);
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);
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->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) {
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_request(module->ldb, req);
ret = ldb_request(ldb_module_get_ctx(module), req);
if (ret == LDB_SUCCESS) {
ret = ldb_wait(req->handle, LDB_WAIT_ALL);
}
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);
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++) {
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])) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid DN in partition replicate record: %s",
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 *p = strchr(base, ':');
if (!p) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition module record (missing ':'): %s", base);
talloc_free(mem_ctx);
@ -1295,17 +1298,17 @@ static int partition_init(struct ldb_module *module)
p[0] = '\0';
p++;
if (!p[0]) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition module record (missing backend database): %s", base);
talloc_free(mem_ctx);
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);
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)) {
talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
@ -1319,28 +1322,28 @@ static int partition_init(struct ldb_module *module)
}
if (!partition) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"invalid form for partition module record (no such partition): %s", base);
talloc_free(mem_ctx);
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) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"loading backend for %s failed: %s",
base, ldb_errstring(module->ldb));
base, ldb_errstring(ldb_module_get_ctx(module)));
talloc_free(mem_ctx);
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) {
ldb_asprintf_errstring(module->ldb,
ldb_asprintf_errstring(ldb_module_get_ctx(module),
"partition_init: "
"initialising backend for %s failed: %s",
base, ldb_errstring(module->ldb));
base, ldb_errstring(ldb_module_get_ctx(module)));
talloc_free(mem_ctx);
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);
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");
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID);
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");
return LDB_ERR_OPERATIONS_ERROR;
}

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

@ -23,7 +23,8 @@
*/
#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 "dsdb/samdb/samdb.h"
#include "librpc/gen_ndr/ndr_security.h"