#include "includes.h"
#include "ldb.h"
+#include "ldb_module.h"
#include "ldb_errors.h"
#include "libcli/security/security.h"
#include "librpc/gen_ndr/ndr_security.h"
ndr_print_struct_string(0,(ndr_print_fn_t)ndr_print_security_descriptor,"", sd)));
}
-int dsdb_get_sd_from_ldb_message(TALLOC_CTX *mem_ctx,
+int dsdb_get_sd_from_ldb_message(struct ldb_context *ldb,
+ TALLOC_CTX *mem_ctx,
struct ldb_message *acl_res,
struct security_descriptor **sd)
{
}
*sd = talloc(mem_ctx, struct security_descriptor);
if(!*sd) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ndr_err = ndr_pull_struct_blob(&sd_element->values[0], *sd, *sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return LDB_SUCCESS;
}
-int dsdb_check_access_on_dn_internal(struct ldb_result *acl_res,
+int dsdb_check_access_on_dn_internal(struct ldb_context *ldb,
+ struct ldb_result *acl_res,
TALLOC_CTX *mem_ctx,
struct security_token *token,
struct ldb_dn *dn,
uint32_t access_granted;
int ret;
- ret = dsdb_get_sd_from_ldb_message(mem_ctx, acl_res->msgs[0], &sd);
+ ret = dsdb_get_sd_from_ldb_message(ldb, mem_ctx, acl_res->msgs[0], &sd);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Theoretically we pass the check if the object has no sd */
if (!sd) {
sid = samdb_result_dom_sid(mem_ctx, acl_res->msgs[0], "objectSid");
if (guid) {
if (!insert_in_object_tree(mem_ctx, guid, access, &root, &new_node)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
status = sec_access_check_ds(sd, token,
struct auth_session_info *session_info
= (struct auth_session_info *)ldb_get_opaque(ldb, "sessionInfo");
if(!session_info) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_search(ldb, mem_ctx, &acl_res, dn, LDB_SCOPE_BASE, acl_attrs, NULL);
return ret;
}
- return dsdb_check_access_on_dn_internal(acl_res,
+ return dsdb_check_access_on_dn_internal(ldb, acl_res,
mem_ctx,
session_info->security_token,
dn,
#include "includes.h"
#include "events/events.h"
#include "ldb.h"
+#include "ldb_module.h"
#include "ldb_errors.h"
#include "../lib/util/util_ldb.h"
#include "../lib/crypto/crypto.h"
char *s = talloc_strdup(mem_ctx, str);
char *a = talloc_strdup(mem_ctx, attr_name);
if (s == NULL || a == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(sam_ldb);
}
return ldb_msg_add_string(msg, a, s);
}
sid,
(ndr_push_flags_fn_t)ndr_push_dom_sid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(sam_ldb);
}
return ldb_msg_add_value(msg, attr_name, &v, NULL);
}
v = talloc_strdup(mem_ctx, value);
if (v == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(sam_ldb);
}
val.data = (uint8_t *) v;
vals = talloc_realloc(msg, el->values, struct ldb_val,
el->num_values + 1);
if (vals == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(sam_ldb);
}
el->values = vals;
el->values[el->num_values] = val;
v = talloc_strdup(mem_ctx, value);
if (v == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(sam_ldb);
}
val.data = (uint8_t *) v;
vals = talloc_realloc(msg, el->values, struct ldb_val,
el->num_values + 1);
if (vals == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(sam_ldb);
}
el->values = vals;
el->values[el->num_values] = val;
struct ldb_val val;
val.data = talloc_memdup(mem_ctx, hash->hash, 16);
if (!val.data) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(sam_ldb);
}
val.length = 16;
return ldb_msg_add_value(msg, attr_name, &val, NULL);
/*
add a samr_Password array to a message
*/
-int samdb_msg_add_hashes(TALLOC_CTX *mem_ctx, struct ldb_message *msg,
+int samdb_msg_add_hashes(struct ldb_context *ldb,
+ TALLOC_CTX *mem_ctx, struct ldb_message *msg,
const char *attr_name, struct samr_Password *hashes,
unsigned int count)
{
val.data = talloc_array_size(mem_ctx, 16, count);
val.length = count*16;
if (!val.data) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0;i<count;i++) {
memcpy(i*16 + (char *)val.data, hashes[i].hash, 16);
const char *attrs[] = { NULL };
local_ctx = talloc_new(mem_ctx);
- if (local_ctx == NULL) return LDB_ERR_OPERATIONS_ERROR;
+ if (local_ctx == NULL) return ldb_oom(ldb);
while ((sdn = ldb_dn_get_parent(local_ctx, sdn))) {
ret = ldb_search(ldb, local_ctx, &res, sdn, LDB_SCOPE_BASE, attrs,
char *guid_str = GUID_string(mem_ctx, guid);
if (!guid_str) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = dsdb_search(ldb, mem_ctx, &res, NULL, LDB_SCOPE_SUBTREE, attrs,
char *sid_str = dom_sid_string(mem_ctx, sid);
if (!sid_str) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = dsdb_search(ldb, mem_ctx, &res, NULL, LDB_SCOPE_SUBTREE, attrs,
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_build_search_req(&req, ldb, tmp_ctx,
p_ctrl = talloc(req, struct dsdb_control_current_partition);
if (p_ctrl == NULL) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
p_ctrl->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
p_ctrl->dn = dn;
config_dn = ldb_get_config_basedn(sam_ctx);
if (!config_dn) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(sam_ctx);
}
ret = dsdb_search(sam_ctx, tmp_ctx, &res, config_dn, LDB_SCOPE_SUBTREE, attrs,
objectGUID = samdb_ntds_objectGUID(sam_ctx);
if (!objectGUID) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(sam_ctx);
}
ret = samdb_is_rodc(sam_ctx, objectGUID, am_rodc);
cached = talloc(sam_ctx, bool);
if (cached == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(sam_ctx);
}
*cached = *am_rodc;
ret = ldb_set_opaque(sam_ctx, "cache.am_rodc", cached);
if (ret != LDB_SUCCESS) {
talloc_free(cached);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(sam_ctx);
}
return LDB_SUCCESS;
wk_guid, ldb_dn_get_linearized(nc_root));
if (!wkguid_dn) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(samdb);
}
ret = dsdb_search_dn(samdb, tmp_ctx, &res, dn, attrs, DSDB_SEARCH_SHOW_DELETED);
tmp_ctx = talloc_new(samdb);
if (tmp_ctx == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(samdb);
}
ret = ldb_search(samdb, tmp_ctx, &root_res,
nc_dns = talloc_array(tmp_ctx, struct ldb_dn *, el->num_values);
if (!nc_dns) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(samdb);
}
for (i=0; i<el->num_values; i++) {
nc_dns[i] = ldb_dn_from_ldb_val(nc_dns, samdb, &el->values[i]);
if (nc_dns[i] == NULL) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(samdb);
}
}
}
dn = ldb_dn_copy(ldb, dn);
if (!dn) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* see MS-ADTS section 7.1.1.2.4.1.1. There doesn't appear to
be a wellknown GUID for this */
if (!ldb_dn_add_child_fmt(dn, "CN=Directory Service,CN=Windows NT,CN=Services")) {
talloc_free(dn);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
*lifetime = samdb_search_uint(ldb, dn, 180, dn, "tombstoneLifetime", "objectClass=nTDSService");
if (!our_invocation_id) {
DEBUG(0,(__location__ ": No invocationID on samdb - %s\n", ldb_errstring(samdb)));
talloc_free(*cursors);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(samdb);
}
ret = dsdb_load_partition_usn(samdb, dn, &highest_usn, NULL);
(*cursors) = talloc_realloc(mem_ctx, *cursors, struct drsuapi_DsReplicaCursor2, (*count)+1);
if (! *cursors) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(samdb);
}
(*cursors)[*count].source_dsa_invocation_id = *our_invocation_id;
*cursors = talloc_array(mem_ctx, struct drsuapi_DsReplicaCursor, *count);
if (*cursors == NULL) {
talloc_free(v2);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(samdb);
}
for (i=0; i<*count; i++) {
res = talloc_zero(mem_ctx, struct ldb_result);
if (!res) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_build_search_req(&req, ldb, res,
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (exp_fmt) {
if (!expression) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (exp_fmt) {
if (!expression) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = dsdb_search(ldb, tmp_ctx, &res, basedn, scope, attrs,
dsdb_flags, "%s", expression);
DEBUG(1,(__location__ ": Failed to find DSA objectGUID %s for sid %s\n",
GUID_string(tmp_ctx, dsa_guid), dom_sid_string(tmp_ctx, sid)));
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
dn = msg->dn;
if (!ldb_dn_remove_child_components(dn, 1)) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = dsdb_search_one(ldb, tmp_ctx, &msg, dn, LDB_SCOPE_BASE,
DEBUG(1,(__location__ ": Failed to find server record for DSA with objectGUID %s, sid %s\n",
GUID_string(tmp_ctx, dsa_guid), dom_sid_string(tmp_ctx, sid)));
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
account_dn = ldb_msg_find_attr_as_dn(ldb, tmp_ctx, msg, "serverReference");
DEBUG(1,(__location__ ": Failed to find account_dn for DSA with objectGUID %s, sid %s\n",
GUID_string(tmp_ctx, dsa_guid), dom_sid_string(tmp_ctx, sid)));
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
status = dsdb_get_extended_dn_sid(account_dn, &sid2, "SID");
DEBUG(1,(__location__ ": Failed to find SID for DSA with objectGUID %s, sid %s\n",
GUID_string(tmp_ctx, dsa_guid), dom_sid_string(tmp_ctx, sid)));
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (!dom_sid_equal(sid, &sid2)) {
dom_sid_string(tmp_ctx, sid),
dom_sid_string(tmp_ctx, &sid2)));
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
talloc_free(tmp_ctx);
*/
#include "includes.h"
+#include "ldb_module.h"
#include "dsdb/samdb/samdb.h"
#include "smbd/service.h"
#include "dsdb/repl/drepl_service.h"
server_dn = ldb_dn_get_parent(tmp_ctx, samdb_ntds_settings_dn(ldb));
if (!server_dn) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = samdb_reference_dn(ldb, tmp_ctx, server_dn, "serverReference", &machine_dn);
struct auth_session_info *session_info
= (struct auth_session_info *)ldb_get_opaque(ldb, "sessionInfo");
if(!session_info) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = dsdb_module_search_dn(module, mem_ctx, &acl_res, dn,
acl_attrs, DSDB_SEARCH_SHOW_DELETED);
DEBUG(10,("access_check: failed to find object %s\n", ldb_dn_get_linearized(dn)));
return ret;
}
- return dsdb_check_access_on_dn_internal(acl_res,
+ return dsdb_check_access_on_dn_internal(ldb, acl_res,
mem_ctx,
session_info->security_token,
dn,
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"acl_module_init: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
data = talloc(module, struct acl_private);
if (data == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data->password_attrs = NULL;
ldb_module_set_private(module, data);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = dsdb_module_search_dn(module, mem_ctx, &res,
data->password_attrs = talloc_array(data, const char *, password_attributes->num_values + 1);
if (!data->password_attrs) {
talloc_free(mem_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < password_attributes->num_values; i++) {
data->password_attrs[i] = (const char *)password_attributes->values[i].data;
return ret;
fail:
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
static int acl_check_access_on_class(struct ldb_module *module,
}
return ret;
fail:
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
static int acl_allowedAttributes(struct ldb_module *module,
mem_ctx = talloc_new(msg);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
oc_el = ldb_msg_find_element(sd_msg, "objectClass");
return LDB_SUCCESS;
}
- ret = dsdb_get_sd_from_ldb_message(mem_ctx, sd_msg, &sd);
+ ret = dsdb_get_sd_from_ldb_message(ldb_module_get_ctx(module), mem_ctx, sd_msg, &sd);
if (ret != LDB_SUCCESS) {
return ret;
const struct dsdb_attribute *attr = dsdb_attribute_by_lDAPDisplayName(schema,
attr_list[i]);
if (!attr) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* remove constructed attributes */
if (attr->systemFlags & DS_FLAG_ATTR_IS_CONSTRUCTED
ldb_msg_remove_attr(msg, "allowedChildClassesEffective");
oc_el = ldb_msg_find_element(sd_msg, "objectClass");
- ret = dsdb_get_sd_from_ldb_message(msg, sd_msg, &sd);
+ ret = dsdb_get_sd_from_ldb_message(ldb_module_get_ctx(module), msg, sd_msg, &sd);
if (ret != LDB_SUCCESS) {
return ret;
}
}
else {
/* Get the security descriptor from the message */
- ret = dsdb_get_sd_from_ldb_message(msg, sd_msg, &sd);
+ ret = dsdb_get_sd_from_ldb_message(ldb_module_get_ctx(module), msg, sd_msg, &sd);
if (ret != LDB_SUCCESS) {
return ret;
}
schema = dsdb_get_schema(ldb, req);
if (!schema) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
oc_el = ldb_msg_find_element(req->op.add.message, "objectClass");
}
member_el = ldb_msg_find_element(req->op.mod.message, "member");
if (!member_el) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* user can only remove oneself */
if (member_el->num_values == 0) {
msg = ldb_msg_copy_shallow(tmp_ctx, req->op.mod.message);
if (msg == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
for (l = passwordAttrs; *l != NULL; l++) {
while ((el = ldb_msg_find_element(msg, *l)) != NULL) {
goto fail;
}
- ret = dsdb_get_sd_from_ldb_message(tmp_ctx, acl_res->msgs[0], &sd);
+ ret = dsdb_get_sd_from_ldb_message(ldb, tmp_ctx, acl_res->msgs[0], &sd);
if (ret != LDB_SUCCESS) {
DEBUG(10, ("acl_modify: cannot get descriptor\n"));
goto fail;
schema = dsdb_get_schema(ldb, acl_res);
if (!schema) {
talloc_free(acl_res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
guid = get_oc_guid_from_message(module, schema, acl_res->msgs[0]);
if (!insert_in_object_tree(tmp_ctx, guid, SEC_ADS_WRITE_PROP,
&root, &new_node)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
};
guid = attribute_schemaid_guid_by_lDAPDisplayName(schema,
"name");
if (!insert_in_object_tree(tmp_ctx, guid, SEC_ADS_WRITE_PROP,
&new_node, &new_node)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
};
rdn_name = ldb_dn_get_rdn_name(req->op.rename.olddn);
if (rdn_name == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
guid = attribute_schemaid_guid_by_lDAPDisplayName(schema,
rdn_name);
if (!insert_in_object_tree(tmp_ctx, guid, SEC_ADS_WRITE_PROP,
&new_node, &new_node)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
};
- ret = dsdb_get_sd_from_ldb_message(req, acl_res->msgs[0], &sd);
+ ret = dsdb_get_sd_from_ldb_message(ldb, req, acl_res->msgs[0], &sd);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Theoretically we pass the check if the object has no sd */
if (!sd) {
ac = talloc_zero(req, struct acl_context);
if (ac == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data = talloc_get_type(ldb_module_get_private(module), struct acl_private);
struct ldb_val *match2 = talloc(mem_ctx, struct ldb_val);
*match2 = data_blob_const(match->data+1, match->length - 1);
if (match2 == NULL){
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
match = match2;
op = LDB_OP_EQUALITY;
/* Inject an 'or' with the current tree */
tree = make_parse_list(module, mem_ctx, LDB_OP_OR, tree, match_tree);
if (tree == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
} else {
tree = match_tree;
struct ldb_val *first_match = talloc(tree, struct ldb_val);
struct ldb_val *second_match = talloc(tree, struct ldb_val);
if (!first_match || !second_match) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
*first_match = data_blob_const(match->data, p-match->data);
*second_match = data_blob_const(p+1, match->length - (p-match->data) - 1);
first_split_filter = make_parse_list(module, ac, LDB_OP_AND, match_tree_1, match_tree_2);
if (first_split_filter == NULL){
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
match_tree_1 = make_match_tree(module, mem_ctx, op, "sn", first_match);
second_split_filter = make_parse_list(module, ac, LDB_OP_AND, match_tree_1, match_tree_2);
if (second_split_filter == NULL){
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
split_filters = make_parse_list(module, mem_ctx, LDB_OP_OR,
first_split_filter, second_split_filter);
if (split_filters == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (tree) {
ac = talloc(req, struct anr_context);
if (!ac) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ret = anr_replace_subtrees(ac, req->op.search.tree, "anr", &anr_tree);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (!ac->found_anr) {
ac, anr_search_callback,
req);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
talloc_steal(down_req, anr_tree);
schema = dsdb_get_schema(ldb, ac);
mem_ctx = talloc_new(ac);
if (mem_ctx == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
switch (ac->req->operation) {
case LDB_ADD:
msg = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
break;
default:
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
break;
default:
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ldb_debug(ldb, LDB_DEBUG_TRACE,"descriptor_change: %s\n", ldb_dn_get_linearized(dn));
ac = descriptor_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* If there isn't a parent, just go on to the add processing */
/* get copy of parent DN */
parent_dn = ldb_dn_get_parent(ac, dn);
if (parent_dn == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_build_search_req(&search_req, ldb,
ldb = ldb_module_get_ctx(module);
ac = descriptor_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_build_search_req_ex(&down_req, ldb, ac,
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"descriptor: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return ldb_next_init(module);
}
base_dn_filter = talloc_asprintf(req, "(objectSid=%s)",
ldb_binary_encode(req, *sid_val));
if (!base_dn_filter) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
base_dn_scope = LDB_SCOPE_SUBTREE;
base_dn_attrs = no_attr;
base_dn_filter = talloc_asprintf(req, "(objectGUID=%s)",
ldb_binary_encode(req, *guid_val));
if (!base_dn_filter) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
base_dn_scope = LDB_SCOPE_SUBTREE;
base_dn_attrs = no_attr;
wellknown_object = talloc_asprintf(req, "B:32:%s:", wkguid_dup);
if (!wellknown_object) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tail_str = p;
base_dn = ldb_dn_new(req, ldb_module_get_ctx(module), tail_str);
talloc_free(wkguid_dup);
if (!base_dn) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
base_dn_filter = talloc_strdup(req, "(objectClass=*)");
if (!base_dn_filter) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
base_dn_scope = LDB_SCOPE_BASE;
base_dn_attrs = wkattr;
ac = talloc_zero(req, struct extended_search_context);
if (ac == NULL) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ac->module = module;
ac, extended_base_callback,
req);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
if (all_partitions) {
*/
-static int fix_dn(struct ldb_dn *dn)
+static int fix_dn(struct ldb_context *ldb, struct ldb_dn *dn)
{
int i, ret;
char *upper_rdn_attr;
upper_rdn_attr = strupper_talloc(dn,
ldb_dn_get_component_name(dn, i));
if (!upper_rdn_attr) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* And replace it with CN=foo (we need the attribute in upper case */
}
if (p && p->normalise) {
- ret = fix_dn(ares->message->dn);
+ ret = fix_dn(ldb, ares->message->dn);
if (ret != LDB_SUCCESS) {
return ldb_module_done(ac->req, NULL, NULL, ret);
}
ares->message->dn);
}
if (ret != LDB_SUCCESS) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
}
}
if (p->normalise) {
- ret = fix_dn(dn);
+ ret = fix_dn(ldb, dn);
if (ret != LDB_SUCCESS) {
talloc_free(dsdb_dn);
return ldb_module_done(ac->req, NULL, NULL, ret);
ac = talloc_zero(req, struct extended_search_context);
if (ac == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
if (ac->remove_guid || ac->remove_sid) {
new_attrs = copy_attrs(ac, req->op.search.attrs);
if (new_attrs == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (ac->remove_guid) {
if (!add_attrs(ac, &new_attrs, "objectGUID"))
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (ac->remove_sid) {
if (!add_attrs(ac, &new_attrs, "objectSID"))
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
const_attrs = (const char * const *)new_attrs;
}
ldb_module_set_private(module, p);
if (!p) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
dn_format = talloc(p, struct dsdb_extended_dn_store_format);
if (!dn_format) {
talloc_free(p);
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
dn_format->store_extended_dn_in_ldb = true;
if (ret != LDB_SUCCESS) {
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;
+ return ldb_operr(ldb_module_get_ctx(module));
}
return ldb_next_init(module);
ldb_module_set_private(module, p);
if (!p) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
dn_format = talloc(p, struct dsdb_extended_dn_store_format);
if (!dn_format) {
talloc_free(p);
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
dn_format->store_extended_dn_in_ldb = false;
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"extended_dn_out: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_next_init(module);
= talloc_zero(p, struct dsdb_openldap_dereference_control);
if (!p->dereference_control) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (cur = schema->attributes; cur; cur = cur->next) {
= talloc_realloc(p, dereference_control->dereference,
struct dsdb_openldap_dereference *, i + 2);
if (!dereference_control) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
dereference_control->dereference[i] = talloc(dereference_control->dereference,
struct dsdb_openldap_dereference);
if (!dereference_control->dereference[i]) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
dereference_control->dereference[i]->source_attribute = cur->lDAPDisplayName;
dereference_control->dereference[i]->dereference_attribute = attrs;
os = talloc_zero(ac, struct extended_dn_replace_list);
if (!os) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ac->ldb);
}
os->ac = ac;
ac = extended_dn_context_init(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
if (!ac->schema) {
if (!ac->new_req) {
struct ldb_message *msg = ldb_msg_copy(ac, req->op.add.message);
if (!msg) {
- ldb_oom(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ret = ldb_build_add_req(&ac->new_req, ac->ldb, ac, msg, req->controls, ac, extended_final_callback, req);
ac = extended_dn_context_init(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
if (!ac->schema) {
struct ldb_message *msg = ldb_msg_copy(ac, req->op.mod.message);
if (!msg) {
talloc_free(ac);
- ldb_oom(ac->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ac->ldb);
}
ret = ldb_build_mod_req(&ac->new_req, ac->ldb, ac, msg, req->controls, ac, extended_final_callback, req);
* entries (lost+found, deleted objects) */
ac = talloc(req, struct it_context);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ac->req = req;
/* we have to copy the message as the caller might have it as a const */
msg = ldb_msg_copy_shallow(req, req->op.add.message);
if (msg == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/*
ret = ldb_msg_add_fmt(msg, "instanceType", "%u", instance_type);
if (ret != LDB_SUCCESS) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_build_add_req(&down_req, ldb, req,
mem_ctx = talloc_new(msg);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* To ensure that oc_el is valid, we must look for it after
ac = talloc(req, struct kludge_acl_context);
if (ac == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data = talloc_get_type(ldb_module_get_private(module), struct kludge_private_data);
data = talloc(module, struct kludge_private_data);
if (data == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data->password_attrs = NULL;
ldb_module_set_private(module, data);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_search(ldb, mem_ctx, &res,
data->password_attrs = talloc_array(data, const char *, password_attributes->num_values + 1);
if (!data->password_attrs) {
talloc_free(mem_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < password_attributes->num_values; i++) {
data->password_attrs[i] = (const char *)password_attributes->values[i].data;
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"lazy_commit: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return ldb_next_init(module);
if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
DEBUG(4,(__location__ ": Unable to parse GUID for dn %s\n",
ldb_dn_get_linearized(dn)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(ac->module));
}
ret = dsdb_find_guid_by_dn(ldb_module_get_ctx(ac->module), dn, guid);
os = talloc_zero(ac, struct la_op_store);
if (!os) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
os->op = op;
os->name = talloc_strdup(os, name);
if (!os->name) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* Do deletes before adds */
ac = linked_attributes_init(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (!ac->schema) {
ac = linked_attributes_init(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (!ac->schema) {
ac->rc = talloc_zero(ac, struct replace_context);
if (!ac->rc) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < req->op.mod.message->num_elements; i++) {
struct ldb_message_element,
ac->rc->num_elements +1);
if (!search_el) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->rc->el = search_el;
attrs = talloc_array(ac->rc, const char *, ac->rc->num_elements + 1);
if (!attrs) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i = 0; ac->rc && i < ac->rc->num_elements; i++) {
attrs[i] = ac->rc->el[i].name;
schema = dsdb_get_schema(ldb, res);
if (!schema) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
msg = res->msgs[0];
if (la_private == NULL) {
ldb_debug(ldb_module_get_ctx(ac->module), LDB_DEBUG_ERROR, __location__ ": No la_private transaction setup\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(ac->module));
}
talloc_steal(la_private, ac);
/* Create the modify request */
new_msg = ldb_msg_new(ac);
if (!new_msg) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = la_find_dn_target(module, ac, &op->guid, &new_msg->dn);
}
ret_el->values = talloc_array(new_msg, struct ldb_val, 1);
if (!ret_el->values) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret_el->num_values = 1;
if (op->op == LA_OP_ADD) {
talloc_free(la_private);
la_private = talloc(module, struct la_private);
if (la_private == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
la_private->la_list = NULL;
ldb_module_set_private(module, la_private);
/* From here, we assume we have password attributes to split off */
ac = lpdb_init_context(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
remote_message = ldb_msg_copy_shallow(remote_req, req->op.add.message);
if (remote_message == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Remove any password attributes from the remote message */
ac->local_message = ldb_msg_copy_shallow(ac, req->op.add.message);
if (ac->local_message == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Remove anything seen in the remote message from the local
PASSWORD_GUID_ATTR "=%s",
GUID_string(ac->local_message,
&objectGUID)))) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_build_add_req(&remote_req, ldb, ac,
/* From here, we assume we have password attributes to split off */
ac = lpdb_init_context(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
remote_message = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
if (remote_message == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Remove any password attributes from the remote message */
ac->local_message = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
if (ac->local_message == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Remove anything seen in the remote message from the local
/* From here, we assume we have password attributes to split off */
ac = lpdb_init_context(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_build_del_req(&remote_req, ldb, ac,
ac, lpdb_local_search_callback,
ac->req);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return ldb_next_request(ac->module, local_req);
ac = lpdb_init_context(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Remote search is for all attributes: if the remote LDAP server has these attributes, then it overrides the local database */
search_attrs = ldb_attr_list_copy_add(ac, req->op.search.attrs, "objectGUID");
ac->added_objectGUID = true;
if (!search_attrs) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
} else {
search_attrs = req->op.search.attrs;
search_attrs = ldb_attr_list_copy_add(ac, search_attrs, "objectClass");
ac->added_objectClass = true;
if (!search_attrs) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
} else {
mem_ctx = talloc_new(module);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
naming_dn = samdb_partitions_dn(ldb, mem_ctx);
naming_fsmo = talloc_zero(mem_ctx, struct dsdb_naming_fsmo);
if (!naming_fsmo) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ldb_module_set_private(module, naming_fsmo);
}
if (ldb_set_opaque(ldb, "dsdb_naming_fsmo", naming_fsmo) != LDB_SUCCESS) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
talloc_steal(module, naming_fsmo);
/* Now that we know it does not exist, we can try and create the partition */
ex_op = talloc(ac, struct dsdb_create_partition_exop);
if (ex_op == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ex_op->new_dn = ac->req->op.add.message->dn;
* record already exists */
ac = talloc(req, struct np_context);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ac->req = req;
for (i=0; i < objectclass_element->num_values; i++) {
current = talloc(mem_ctx, struct class_list);
if (!current) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
current->objectclass = dsdb_class_by_lDAPDisplayName_ldb_val(schema, &objectclass_element->values[i]);
if (!current->objectclass) {
CN=Admins,CN=Users,DC=samba,DC=example,DC=com
*/
-static int fix_dn(TALLOC_CTX *mem_ctx,
+static int fix_dn(struct ldb_context *ldb,
+ TALLOC_CTX *mem_ctx,
struct ldb_dn *newdn, struct ldb_dn *parent_dn,
struct ldb_dn **fixed_dn)
{
upper_rdn_attr = strupper_talloc(*fixed_dn,
ldb_dn_get_rdn_name(newdn));
if (!upper_rdn_attr) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Create a new child */
if (ldb_dn_add_child_fmt(*fixed_dn, "X=X") == false) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
val = ldb_dn_get_component_val(req->op.add.message->dn,
ldb_dn_get_comp_num(req->op.add.message->dn) - 1);
if (val == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
value = talloc_asprintf(req, "ldap://%s/%s", val->data,
ldb_dn_get_linearized(req->op.add.message->dn));
if (value == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
return ldb_module_send_referral(req, value);
ac = oc_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* If there isn't a parent, just go on to the add processing */
/* get copy of parent DN */
parent_dn = ldb_dn_get_parent(ac, ac->req->op.add.message->dn);
if (parent_dn == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_build_search_req(&search_req, ldb,
} else {
/* Fix up the DN to be in the standard form, taking
* particular care to match the parent DN */
- ret = fix_dn(msg,
+ ret = fix_dn(ldb, msg,
ac->req->op.add.message->dn,
ac->search_res->message->dn,
&msg->dn);
mem_ctx = talloc_new(ac);
if (mem_ctx == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (ac->schema != NULL) {
if (!objectclass_element) {
/* Where did it go? bail now... */
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = objectclass_sort(ac->module, ac->schema, mem_ctx,
objectclass_element, &sorted);
for (current = sorted; current; current = current->next) {
value = talloc_strdup(msg, current->objectclass->lDAPDisplayName);
if (value == NULL) {
- ldb_oom(ldb);
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_msg_add_string(msg, "objectClass", value);
if (ret != LDB_SUCCESS) {
value = talloc_strdup(msg, objectclass->defaultObjectCategory);
}
if (value == NULL) {
- ldb_oom(ldb);
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ldb_msg_add_string(msg, "objectCategory", value);
}
ac = oc_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Without schema, there isn't much to do here */
msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
if (msg == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* For now change everything except the objectclasses */
/* we should always have a valid entry when we enter here */
if (ac->search_res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
oc_el_entry = ldb_msg_find_element(ac->search_res->message,
"objectClass");
if (oc_el_entry == NULL) {
/* existing entry without a valid object class? */
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
oc_el_change = ldb_msg_find_element(ac->req->op.mod.message,
"objectClass");
if (oc_el_change == NULL) {
/* we should have an objectclass change operation */
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* use a new message structure */
msg = ldb_msg_new(ac);
if (msg == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
msg->dn = ac->req->op.mod.message->dn;
mem_ctx = talloc_new(ac);
if (mem_ctx == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
switch (oc_el_change->flags & LDB_FLAG_MOD_MASK) {
struct ldb_val,
oc_el_entry->num_values + 1);
if (vals == NULL) {
- ldb_oom(ldb);
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
oc_el_entry->values = vals;
oc_el_entry->values[oc_el_entry->num_values] =
oc_el_entry);
if (objectclass == NULL) {
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Merge the two message elements */
value = talloc_strdup(msg,
current->objectclass->lDAPDisplayName);
if (value == NULL) {
- ldb_oom(ldb);
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_msg_add_string(msg, "objectClass", value);
if (ret != LDB_SUCCESS) {
ac = oc_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
parent_dn = ldb_dn_get_parent(ac, req->op.rename.newdn);
"objectClass");
if (oc_el_entry == NULL) {
/* existing entry without a valid object class? */
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
objectclass = get_last_structural_class(ac->schema, oc_el_entry);
if (objectclass == NULL) {
/* existing entry without a valid object class? */
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
rdn_name = ldb_dn_get_rdn_name(ac->req->op.rename.newdn);
"objectClass");
if (oc_el_parent == NULL) {
/* existing entry without a valid object class? */
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
for (i=0; allowed_class == false && i < oc_el_parent->num_values; i++) {
/* Fix up the DN to be in the standard form, taking
* particular care to match the parent DN */
- ret = fix_dn(ac,
+ ret = fix_dn(ldb, ac,
ac->req->op.rename.newdn,
ac->search_res2->message->dn,
&fixed_dn);
ac = oc_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* this looks up the entry object for fetching some important
msg = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
}
if (msg == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* Check if attributes exist in the schema, if the values match,
ldb = ldb_module_get_ctx(ac->module);
if (ac->search_res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* We rely here on the preceeding "objectclass" LDB module which did
oc_element = ldb_msg_find_element(ac->search_res->message,
"objectClass");
if (oc_element == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
must_contain = dsdb_full_attribute_list(ac, ac->schema, oc_element,
found_must_contain = const_str_list(str_list_copy(ac, must_contain));
if ((must_contain == NULL) || (may_contain == NULL)
|| (found_must_contain == NULL)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Check if all specified attributes are valid in the given
attr = dsdb_attribute_by_lDAPDisplayName(ac->schema,
msg->elements[i].name);
if (attr == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Check if they're single-valued if this is requested */
ac = oc_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* without schema, there isn't much to do here */
ac = oc_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* without schema, there isn't much to do here */
ac = talloc(req, struct og_context);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ac->req = req;
msg = ldb_msg_copy_shallow(ac, req->op.add.message);
if (msg == NULL) {
talloc_free(down_req);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* a new GUID */
if (add_time_element(msg, "whenCreated", t) != 0 ||
add_time_element(msg, "whenChanged", t) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Get a sequence number from the backend */
if (ret == LDB_SUCCESS) {
if (add_uint64_element(msg, "uSNCreated", seq_num) != 0 ||
add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
ac = talloc(req, struct og_context);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ac->req = req;
/* we have to copy the message as the caller might have it as a const */
msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
if (msg == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (add_time_element(msg, "whenChanged", t) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Get a sequence number from the backend */
ret = ldb_sequence_number(ldb, LDB_SEQ_NEXT, &seq_num);
if (ret == LDB_SUCCESS) {
if (add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
char *canonicalName;
canonicalName = ldb_dn_canonical_string(msg, msg->dn);
if (canonicalName == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
return ldb_msg_add_steal_string(msg, "canonicalName", canonicalName);
}
status = auth_context_create_from_ldb(tmp_ctx, ldb, &auth_context);
if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MEMORY)) {
talloc_free(tmp_ctx);
- ldb_module_oom(module);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
} else if (!NT_STATUS_IS_OK(status)) {
ldb_set_errstring(ldb, "Cannot provide tokenGroups attribute, could not create authContext");
talloc_free(tmp_ctx);
status = auth_get_server_info_principal(tmp_ctx, auth_context, NULL, msg->dn, &server_info);
if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MEMORY)) {
talloc_free(tmp_ctx);
- ldb_module_oom(module);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
} else if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER)) {
/* Not a user, we have no tokenGroups */
talloc_free(tmp_ctx);
status = auth_generate_session_info(tmp_ctx, auth_context, server_info, 0, &session_info);
if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MEMORY)) {
talloc_free(tmp_ctx);
- ldb_module_oom(module);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
} else if (!NT_STATUS_IS_OK(status)) {
talloc_free(tmp_ctx);
ldb_asprintf_errstring(ldb, "Cannot provide tokenGroups attribute: auth_generate_session_info failed: %s", nt_errstr(status));
v = data_blob_dup_talloc(res, parent_guid);
if (!v.data) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ret = ldb_msg_add_steal_value(msg, "parentGUID", &v);
talloc_free(res);
ldb = ldb_module_get_ctx(module);
if (!ldb) {
DEBUG(4, (__location__ ": Failed to get ldb \n"));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
dn = ldb_dn_new(msg, ldb, (const char *)object_category->values[0].data);
if (!dn) {
DEBUG(4, (__location__ ": Failed to create dn from %s \n",
(const char *)object_category->values[0].data));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
val = ldb_dn_get_rdn_val(dn);
if (!val) {
DEBUG(4, (__location__ ": Failed to get rdn val from %s \n",
ldb_dn_get_linearized(dn)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (strequal((const char *)val->data, "NTDS-DSA")) {
if (!ldb_dn_add_child_fmt(server_dn, "CN=NTDS Settings")) {
DEBUG(4, (__location__ ": Failed to add child to %s \n",
ldb_dn_get_linearized(server_dn)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
ret = dsdb_module_search_dn(module, msg, &res, server_dn, attr_obj_cat, 0);
if (!object_class) {
DEBUG(4,(__location__ ": Can't get objectClass for %s \n",
ldb_dn_get_linearized(msg->dn)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
for (i=0; i<object_class->num_values; i++) {
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,(__location__ ": Failed to parse replPropertyMetaData for %s when trying to add msDS-KeyVersionNumber\n",
ldb_dn_get_linearized(msg->dn)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
if (omd->version != 1) {
ac = talloc(req, struct operational_context);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
: ac->attrs,
search_sub[i].extra_attr);
if (search_attrs2 == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* may be NULL, talloc_free() doesn't mind */
talloc_free(search_attrs);
if (!search_attrs) {
search_attrs = ldb_attr_list_copy(req, ac->attrs);
if (search_attrs == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
/* Despite the ldb_attr_list_copy_add, this is safe as that fn only adds to the end */
ac, operational_callback,
req);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* perform the search */
data = talloc_zero(ctx, struct operational_data);
if (!data) {
- ldb_module_oom(ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(ctx);
}
ldb_module_set_private(ctx, data);
struct part_request,
ac->num_requests + 1);
if (ac->part_req == NULL) {
- ldb_oom(ldb_module_get_ctx(ac->module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(ac->module));
}
switch (ac->req->operation) {
req->controls = talloc_memdup(req, ac->req->controls,
talloc_get_size(ac->req->controls));
if (req->controls == NULL) {
- ldb_oom(ldb_module_get_ctx(ac->module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(ac->module));
}
}
ac = partition_init_ctx(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
return partition_send_all(module, ac, req);
ac = partition_init_ctx(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
/* we need to add a control but we never touch the original request */
/* 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(ldb_module_get_ctx(module));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
/* Locate the options */
ac = partition_init_ctx(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
ldb = ldb_module_get_ctx(ac->module);
req->op.search.scope == LDB_SCOPE_ONELEVEL ? "??base" : "");
if (ref == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* Initialise the referrals list */
if (ac->referrals == NULL) {
ac->referrals = (const char **) str_list_make_empty(ac);
if (ac->referrals == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
talloc_free(ref);
if (ac->referrals == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
if (ldb_dn_compare_base(data->partitions[i]->ctrl->dn, req->op.search.base) == 0) {
/* Skip the lot if 'data' isn't here yet (initialisation) */
if (!data) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
backend = find_partition(data, req->op.rename.olddn, req);
if (data->in_transaction == 0) {
DEBUG(0,("partition del transaction mismatch\n"));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
data->in_transaction--;
struct ldb_seqnum_result *seqr;
res = talloc_zero(mem_ctx, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = type;
res = talloc_zero(req, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = seq->type;
res = talloc_zero(req, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
res = talloc_zero(req, struct ldb_result);
if (res == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq = talloc_zero(res, struct ldb_seqnum_request);
if (tseq == NULL) {
talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
tseq->type = LDB_SEQ_HIGHEST_TIMESTAMP;
ext = talloc_zero(req, struct ldb_extended);
if (!ext) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
seqr = talloc_zero(ext, struct ldb_seqnum_result);
if (seqr == NULL) {
talloc_free(ext);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ext->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
ext->data = seqr;
ac = partition_init_ctx(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
return partition_send_all(module, ac, req);
int i;
data->replicate = talloc_array(data, struct ldb_dn *, replicate_attributes->num_values + 1);
if (!data->replicate) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < replicate_attributes->num_values; i++) {
data->modules = talloc_array(data, struct partition_module *, modules_attributes->num_values + 1);
if (!data->modules) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < modules_attributes->num_values; i++) {
DATA_BLOB dn_blob;
data->modules[i] = talloc(data->modules, struct partition_module);
if (!data->modules[i]) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
dn_blob = modules_attributes->values[i];
} else {
data->modules[i]->dn = ldb_dn_from_ldb_val(data->modules[i], ldb, &dn_blob);
if (!data->modules[i]->dn || !ldb_dn_validate(data->modules[i]->dn)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
}
(*partition) = talloc(mem_ctx, struct dsdb_partition);
if (!*partition) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
(*partition)->ctrl = ctrl = talloc((*partition), struct dsdb_control_current_partition);
if (!ctrl) {
talloc_free(*partition);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* See if an LDAP backend has been specified */
ldb_asprintf_errstring(ldb,
"partition_init: unable to determine an relative path for partition: %s", filename);
talloc_free(*partition);
- return LDB_ERR_OPERATIONS_ERROR;
+ return LDB_ERR_OPERATIONS_ERROR;
}
(*partition)->backend_url = talloc_steal((*partition), backend_url);
/* This weirdness allows us to use ldb_next_request() in partition.c */
(*partition)->module = ldb_module_new(*partition, ldb, "partition_next", NULL);
if (!(*partition)->module) {
- ldb_oom(ldb);
talloc_free(*partition);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
(*partition)->module->next = talloc_steal((*partition)->module, module_chain);
req = talloc_zero(NULL, struct ldb_request);
if (req == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
req->operation = LDB_REQ_REGISTER_PARTITION;
req->handle = ldb_handle_new(req, ldb);
if (req->handle == NULL) {
talloc_free(req);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_request(ldb, req);
/* Add partition to list of partitions */
data->partitions = talloc_realloc(data, data->partitions, struct dsdb_partition *, i + 2);
if (!data->partitions) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data->partitions[i] = talloc_steal(data->partitions, partition);
data->partitions[i+1] = NULL;
mem_ctx = talloc_new(data);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = partition_primary_sequence_number(module, mem_ctx, LDB_SEQ_HIGHEST_SEQ, &seq);
new_partition = true;
mod_msg = ldb_msg_new(req);
if (!mod_msg) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
mod_msg->dn = ldb_dn_new(mod_msg, ldb, DSDB_PARTITION_DN);
const char *p, *sam_name;
sam_name = strrchr((const char *)ldb_get_opaque(ldb, "ldb_url"), '/');
if (!sam_name) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
sam_name++;
if (*p) {
escaped = rfc1738_escape_part(mod_msg, casefold_dn);
if (!escaped) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
filename = talloc_asprintf(mod_msg, "%s.d/%s.ldb", sam_name, escaped);
talloc_free(escaped);
}
if (!filename) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
partition_record = talloc_asprintf(mod_msg, "%s:%s", casefold_dn, filename);
struct partition_private_data *data;
if (!mem_ctx) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
data = talloc_zero(mem_ctx, struct partition_private_data);
if (data == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* When used from Samba4, this message is set by the samba4
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"partition: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID);
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"partition: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return ldb_next_init(module);
struct samr_Password,
io->ac->status->domain_data.pwdHistoryLength);
if (!io->g.nt_history) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i = 0; i < MIN(io->ac->status->domain_data.pwdHistoryLength-1,
struct samr_Password,
io->ac->status->domain_data.pwdHistoryLength);
if (!io->g.lm_history) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i = 0; i < MIN(io->ac->status->domain_data.pwdHistoryLength-1,
name = strlower_talloc(io->ac, io->u.sAMAccountName);
if (!name) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (name[strlen(name)-1] == '$') {
saltbody = talloc_asprintf(io->ac, "%s.%s", name,
io->ac->status->domain_data.dns_domain);
if (!saltbody) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
krb5_ret = krb5_make_principal(io->smb_krb5_context->krb5_context,
user_principal_name = talloc_strdup(io->ac, io->u.user_principal_name);
if (!user_principal_name) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
p = strchr(user_principal_name, '@');
salt.saltvalue.length);
krb5_free_salt(io->smb_krb5_context->krb5_context, salt);
if (!io->g.salt) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
salt.saltvalue.data = discard_const(io->g.salt);
salt.saltvalue.length = strlen(io->g.salt);
key.keyvalue.length);
krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
if (!io->g.aes_256.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/*
key.keyvalue.length);
krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
if (!io->g.aes_128.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/*
key.keyvalue.length);
krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
if (!io->g.des_md5.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/*
key.keyvalue.length);
krb5_free_keyblock_contents(io->smb_krb5_context->krb5_context, &key);
if (!io->g.des_crc.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
return LDB_SUCCESS;
struct package_PrimaryKerberosKey3,
pkb3->num_keys);
if (!pkb3->keys) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pkb3->keys[0].keytype = ENCTYPE_DES_CBC_MD5;
blob = strhex_to_data_blob(io->ac, old_scp->data);
if (!blob.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* TODO: use ndr_pull_struct_blob_all(), when the ndr layer handles it correct with relative pointers */
struct package_PrimaryKerberosKey4,
pkb4->num_keys);
if (!pkb4->keys) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pkb4->keys[0].iteration_count = 4096;
blob = strhex_to_data_blob(io->ac, old_scp->data);
if (!blob.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* TODO: use ndr_pull_struct_blob_all(), when the ndr layer handles it correct with relative pointers */
sAMAccountName = data_blob_string_const(io->u.sAMAccountName);
sAMAccountName_l = data_blob_string_const(strlower_talloc(io->ac, io->u.sAMAccountName));
if (!sAMAccountName_l.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
sAMAccountName_u = data_blob_string_const(strupper_talloc(io->ac, io->u.sAMAccountName));
if (!sAMAccountName_u.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* if the user doesn't have a userPrincipalName, create one (with lower case realm) */
io->u.sAMAccountName,
io->ac->status->domain_data.dns_domain);
if (!user_principal_name) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
userPrincipalName = data_blob_string_const(user_principal_name);
userPrincipalName_l = data_blob_string_const(strlower_talloc(io->ac, user_principal_name));
if (!userPrincipalName_l.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
userPrincipalName_u = data_blob_string_const(strupper_talloc(io->ac, user_principal_name));
if (!userPrincipalName_u.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
netbios_domain = data_blob_string_const(io->ac->status->domain_data.netbios_domain);
netbios_domain_l = data_blob_string_const(strlower_talloc(io->ac,
io->ac->status->domain_data.netbios_domain));
if (!netbios_domain_l.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
netbios_domain_u = data_blob_string_const(strupper_talloc(io->ac,
io->ac->status->domain_data.netbios_domain));
if (!netbios_domain_u.data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
dns_domain = data_blob_string_const(io->ac->status->domain_data.dns_domain);
pdb->hashes = talloc_array(io->ac, struct package_PrimaryWDigestHash,
pdb->num_hashes);
if (!pdb->hashes) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < ARRAY_SIZE(wdigest); i++) {
}
pknb_hexstr = data_blob_hex_string_upper(io->ac, &pknb_blob);
if (!pknb_hexstr) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pkn->name = "Primary:Kerberos-Newer-Keys";
pkn->reserved = 1;
}
pkb_hexstr = data_blob_hex_string_upper(io->ac, &pkb_blob);
if (!pkb_hexstr) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pk->name = "Primary:Kerberos";
pk->reserved = 1;
}
pdb_hexstr = data_blob_hex_string_upper(io->ac, &pdb_blob);
if (!pdb_hexstr) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pd->name = "Primary:WDigest";
pd->reserved = 1;
}
pcb_hexstr = data_blob_hex_string_upper(io->ac, &pcb_blob);
if (!pcb_hexstr) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pc->name = "Primary:CLEARTEXT";
pc->reserved = 1;
}
pb_hexstr = data_blob_hex_string_upper(io->ac, &pb_blob);
if (!pb_hexstr) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pp->name = "Packages";
pp->reserved = 2;
cleartext_utf16_blob = talloc(io->ac, struct ldb_val);
if (!cleartext_utf16_blob) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (!convert_string_talloc(io->ac,
CH_UTF8, CH_UTF16,
cleartext_utf8_blob = talloc(io->ac, struct ldb_val);
if (!cleartext_utf8_blob) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (!convert_string_talloc(io->ac,
CH_UTF16MUNGED, CH_UTF8,
nt_hash = talloc(io->ac, struct samr_Password);
if (!nt_hash) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
g->nt_hash = nt_hash;
lm_hash = talloc(io->ac, struct samr_Password);
if (!lm_hash) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* compute the new lm hash */
ldb_get_event_context(ldb),
(struct loadparm_context *)ldb_get_opaque(ldb, "loadparm"),
&io->smb_krb5_context) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
io->ac = ac;
*/
quoted_utf16_2 = talloc(io->ac, struct ldb_val);
if (quoted_utf16_2 == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
quoted_utf16_2->data = quoted_utf16->data + 2;
*/
old_quoted_utf16_2 = talloc(io->ac, struct ldb_val);
if (old_quoted_utf16_2 == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
old_quoted_utf16_2->data = old_quoted_utf16->data + 2;
}
} else {
/* this shouldn't happen */
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return LDB_SUCCESS;
ac = ph_init_context(module, req);
if (ac == NULL) {
DEBUG(0,(__location__ ": %s\n", ldb_errstring(ldb)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ph_apply_controls(ac);
return ret;
}
+ ldb = ldb_module_get_ctx(ac->module);
+
msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
if (msg == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* remove attributes that we just read into 'io' */
ldb_msg_remove_attr(msg, "dBCSPwd");
ldb_msg_remove_attr(msg, "pwdLastSet");
- ldb = ldb_module_get_ctx(ac->module);
-
ret = setup_password_fields(&io);
if (ret != LDB_SUCCESS) {
return ret;
}
}
if (io.g.nt_history_len > 0) {
- ret = samdb_msg_add_hashes(ac, msg,
+ ret = samdb_msg_add_hashes(ldb, ac, msg,
"ntPwdHistory",
io.g.nt_history,
io.g.nt_history_len);
}
}
if (io.g.lm_history_len > 0) {
- ret = samdb_msg_add_hashes(ac, msg,
+ ret = samdb_msg_add_hashes(ldb, ac, msg,
"lmPwdHistory",
io.g.lm_history,
io.g.lm_history_len);
ac = ph_init_context(module, req);
if (!ac) {
DEBUG(0,(__location__ ": %s\n", ldb_errstring(ldb)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ph_apply_controls(ac);
/* use a new message structure so that we can modify it */
msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
if (msg == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* - check for single-valued password attributes
/* use a new message structure so that we can modify it */
msg = ldb_msg_new(ac);
if (msg == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* modify dn */
discard_const_p(struct ldb_message, searched_msg),
&io.o.lm_hash, &io.o.nt_hash);
if (!NT_STATUS_IS_OK(status)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
io.o.nt_history_len = samdb_result_hashes(io.ac, searched_msg, "ntPwdHistory", &io.o.nt_history);
}
}
if (io.g.nt_history_len > 0) {
- ret = samdb_msg_add_hashes(ac, msg,
+ ret = samdb_msg_add_hashes(ldb, ac, msg,
"ntPwdHistory",
io.g.nt_history,
io.g.nt_history_len);
}
}
if (io.g.lm_history_len > 0) {
- ret = samdb_msg_add_hashes(ac, msg,
+ ret = samdb_msg_add_hashes(ldb, ac, msg,
"lmPwdHistory",
io.g.lm_history,
io.g.lm_history_len);
mem_ctx = talloc_new(module);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
pdc_dn = ldb_get_default_basedn(ldb);
pdc_fsmo = talloc_zero(mem_ctx, struct dsdb_pdc_fsmo);
if (!pdc_fsmo) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ldb_module_set_private(module, pdc_fsmo);
}
if (ldb_set_opaque(ldb, "dsdb_pdc_fsmo", pdc_fsmo) != LDB_SUCCESS) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
talloc_steal(module, pdc_fsmo);
talloc_free(proxy->newdn);
talloc_free(proxy->upstream);
proxy->upstream = NULL;
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
if (load_proxy_info(module) != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* see if the dn is within olddn */
ac = talloc(req, struct proxy_ctx);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
(size_t)(p - new_attrs[i]));
if (!new_attrs[i]) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
if (found_rr) {
ac = rr_init_context(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_build_search_req_ex(&down_req, ldb, ac,
case DRSUAPI_ATTRIBUTE_possSuperiors:
str = talloc_strndup(ldb, (char *)valp->data, valp->length);
if (!str) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
vo = dsdb_class_by_governsID_oid(schema, str);
talloc_free(str);
case DRSUAPI_ATTRIBUTE_mayContain:
str = talloc_strndup(ldb, (char *)valp->data, valp->length);
if (!str) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
va = dsdb_attribute_by_attributeID_oid(schema, str);
talloc_free(str);
case DRSUAPI_ATTRIBUTE_possSuperiors:
str = talloc_strndup(schema, (char *)valp->data, valp->length);
if (!str) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
vo = dsdb_class_by_governsID_oid(schema, str);
talloc_free(str);
case DRSUAPI_ATTRIBUTE_mayContain:
str = talloc_strndup(schema, (char *)valp->data, valp->length);
if (!str) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
va = dsdb_attribute_by_attributeID_oid(schema, str);
talloc_free(str);
ac = talloc(req, struct resolve_oids_context);
if (ac == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ac->req = req;
tree = ldb_parse_tree_copy_shallow(ac, req->op.search.tree);
if (!tree) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
schema = talloc_reference(tree, schema);
if (!schema) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = resolve_oids_parse_tree_replace(ldb, schema,
attrs2 = str_list_copy_const(ac,
discard_const_p(const char *, req->op.search.attrs));
if (req->op.search.attrs && !attrs2) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; attrs2 && attrs2[i]; i++) {
ac = talloc(req, struct resolve_oids_context);
if (ac == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ac->req = req;
msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
if (!msg) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (!talloc_reference(msg, schema)) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = resolve_oids_message_replace(ldb, schema, msg);
ac = talloc(req, struct resolve_oids_context);
if (ac == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
ac->req = req;
/* we have to copy the message as the caller might have it as a const */
msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
if (msg == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (!talloc_reference(msg, schema)) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = resolve_oids_message_replace(ldb, schema, msg);
server_dn = ldb_dn_get_parent(tmp_ctx, ntds_dn);
if (!server_dn) {
- ldb_module_oom(module);
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
ret = dsdb_module_reference_dn(module, tmp_ctx, server_dn, "serverReference", &machine_dn);
rid_set_dn = ldb_dn_copy(tmp_ctx, machine_dn);
if (rid_set_dn == NULL) {
- ldb_module_oom(module);
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
if (! ldb_dn_add_child_fmt(rid_set_dn, "CN=RID Set")) {
- ldb_module_oom(module);
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
/* grab a pool from the RID Manager object */
server_dn = ldb_dn_get_parent(tmp_ctx, ntds_dn);
if (!server_dn) {
- ldb_module_oom(module);
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
ret = dsdb_module_reference_dn(module, tmp_ctx, server_dn, "serverReference", &machine_dn);
server_dn = ldb_dn_get_parent(tmp_ctx, ntds_dn);
if (!server_dn) {
- ldb_module_oom(module);
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
ret = dsdb_module_reference_dn(module, tmp_ctx, server_dn, "serverReference", &machine_dn);
dn_string = talloc_strndup(tmp_ctx, (const char *)v->data, v->length);
if (dn_string == NULL) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
res = talloc_zero(tmp_ctx, struct ldb_result);
if (res == NULL) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
dn = ldb_dn_new(tmp_ctx, ldb, dn_string);
if (!ldb_dn_validate(dn)) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_build_search_req(&req2, ldb, tmp_ctx,
if (!res || res->count != 1) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
dn2 = res->msgs[0]->dn;
if (v->data == NULL) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
talloc_free(tmp_ctx);
return LDB_SUCCESS;
failed:
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/*
ac = rootdse_init_context(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* in our db we store the rootDSE with a DN of @ROOTDSE */
list = talloc_realloc(priv, priv->controls, char *, priv->num_controls + 1);
if (!list) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
list[priv->num_controls] = talloc_strdup(list, req->op.reg_control.oid);
if (!list[priv->num_controls]) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
priv->num_controls += 1;
list = talloc_realloc(priv, priv->partitions, struct ldb_dn *, priv->num_partitions + 1);
if (!list) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
list[priv->num_partitions] = ldb_dn_copy(list, req->op.reg_partition.dn);
if (!list[priv->num_partitions]) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
priv->num_partitions += 1;
data = talloc_zero(module, struct private_data);
if (data == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data->num_controls = 0;
mem_ctx = talloc_new(data);
if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* Now that the partitions are set up, do a search for:
if (domain_behaviour_version != -1) {
int *val = talloc(ldb, int);
if (!val) {
- ldb_oom(ldb);
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
*val = domain_behaviour_version;
ret = ldb_set_opaque(ldb, "domainFunctionality", val);
if (forest_behaviour_version != -1) {
int *val = talloc(ldb, int);
if (!val) {
- ldb_oom(ldb);
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
*val = forest_behaviour_version;
ret = ldb_set_opaque(ldb, "forestFunctionality", val);
if (domain_controller_behaviour_version != -1) {
int *val = talloc(ldb, int);
if (!val) {
- ldb_oom(ldb);
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
*val = domain_controller_behaviour_version;
ret = ldb_set_opaque(ldb,
ret = ldb_extended(ldb, DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID, schema_dn, &ext_res);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
talloc_free(ext_res);
(*sid) = talloc_asprintf(tmp_ctx, "%s-%d", sambaSID, rid);
if (!*sid) {
- ldb_module_oom(module);
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
ret = dsdb_module_constrainted_update_integer(module, msg->dn,
new_msg = ldb_msg_copy_shallow(req, req->op.add.message);
if (!new_msg) {
- ldb_module_oom(module);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
ret = samba3sid_next_sid(module, new_msg, &sid);
struct ldb_dn *rootdse_dn;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
if (!tmp_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
rootdse_dn = ldb_dn_new(tmp_ctx, ldb, "@ROOTDSE");
if (!rootdse_dn) {
talloc_free(tmp_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = dsdb_module_search_dn(module, tmp_ctx, &rootdse_res, rootdse_dn, rootdse_attrs, 0);
char *full_string;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
if (!tmp_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
if (backend_attr) {
}
if (!backend_full_list) {
talloc_free(tmp_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
backend_full_list = str_list_append_const(backend_full_list, backend_mod_list);
if (!backend_full_list) {
talloc_free(tmp_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
mod_list_string = str_list_join(tmp_ctx, backend_full_list, ',');
if (!mod_list_string) {
talloc_free(tmp_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
full_string = talloc_asprintf(tmp_ctx, "%s:%s", backend_dn, mod_list_string);
const char *backendType, *serverRole;
if (!tmp_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
samba_dsdb_dn = ldb_dn_new(tmp_ctx, ldb, "@SAMBA_DSDB");
if (!samba_dsdb_dn) {
talloc_free(tmp_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
#define CHECK_LDB_RET(check_ret) \
do { \
if (!final_module_list) { \
talloc_free(tmp_ctx); \
- ldb_oom(ldb); \
- return LDB_ERR_OPERATIONS_ERROR; \
+ return ldb_oom(ldb); \
} \
} while (0)
reverse_module_list = talloc_array(tmp_ctx, const char *, len+1);
if (!reverse_module_list) {
talloc_free(tmp_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < len; i++) {
reverse_module_list[i] = final_module_list[(len - 1) - i];
NULL };
if (!tmp_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* Now prepare the module chain. Oddly, we must give it to ldb_load_modules_list in REVERSE */
reverse_module_list = talloc_array(tmp_ctx, const char *, len+1);
if (!reverse_module_list) {
talloc_free(tmp_ctx);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
for (i=0; i < len; i++) {
reverse_module_list[i] = modules_list[(len - 1) - i];
step = talloc_zero(ac, struct samldb_step);
if (step == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(ac->module));
}
step->fn = fn;
ac->curstep = step;
} else {
if (ac->curstep == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(ac->module));
for (stepper = ac->curstep; stepper->next != NULL;
stepper = stepper->next);
stepper->next = step;
static int samldb_first_step(struct samldb_ctx *ac)
{
if (ac->steps == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(ac->module));
}
ac->curstep = ac->steps;
}
}
-static int samldb_generate_samAccountName(struct ldb_message *msg)
+static int samldb_generate_samAccountName(struct ldb_context *ldb, struct ldb_message *msg)
{
char *name;
(unsigned int)generate_random(),
(unsigned int)generate_random());
if (name == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
return ldb_msg_add_steal_string(msg, "samAccountName", name);
}
ldb = ldb_module_get_ctx(ac->module);
if (ldb_msg_find_element(ac->msg, "samAccountName") == NULL) {
- ret = samldb_generate_samAccountName(ac->msg);
+ ret = samldb_generate_samAccountName(ldb, ac->msg);
if (ret != LDB_SUCCESS) {
return ret;
}
name = ldb_msg_find_attr_as_string(ac->msg, "samAccountName", NULL);
if (name == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
filter = talloc_asprintf(ac, "samAccountName=%s",
ldb_binary_encode_string(ac, name));
if (filter == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_build_search_req(&req, ldb, ac,
ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
if (ac->sid == NULL) {
- ldb_module_oom(ac->module);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(ac->module);
}
if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return samldb_next_step(ac);
ldb = ldb_module_get_ctx(ac->module);
if (ac->sid == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
filter = talloc_asprintf(ac, "(objectSid=%s)",
ldap_encode_ndr_dom_sid(ac, ac->sid));
if (filter == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
ret = ldb_build_search_req(&req, ldb, ac,
ldb_get_default_basedn(ldb),
rid = samdb_result_uint(ac->msg, "primaryGroupID", ~0);
ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
if (ac->sid == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
ac->res_dn = NULL;
return samldb_next_step(ac);
__location__": Searching for msDS-IntId=%d failed - %s\n",
msds_intid,
ldb_errstring(ldb));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
id_exists = (ldb_res->count > 0);
}
if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
talloc_free(ac);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
}
ldb_debug_set(ldb, LDB_DEBUG_FATAL,
"samldb_schema_info_update: no dsdb_schema loaded");
DEBUG(0,(__location__ ": %s\n", ldb_errstring(ldb)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
werr = dsdb_module_schema_info_update(ac->module, schema, DSDB_FLAG_NEXT_MODULE);
"dsdb_module_schema_info_update failed with %s",
win_errstr(werr));
DEBUG(0,(__location__ ": %s\n", ldb_errstring(ldb)));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return LDB_SUCCESS;
sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
if (sid == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
prev_prim_group_dn = samdb_search_dn(ldb, ac, NULL, "(objectSID=%s)",
dom_sid_string(ac, sid));
if (prev_prim_group_dn == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* Finds out the DN of the new primary group */
sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
if (sid == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
new_prim_group_dn = samdb_search_dn(ldb, ac, NULL, "(objectSID=%s)",
* for them */
member_dn = ldb_dn_from_ldb_val(ac, ldb, &el->values[i]);
if (!ldb_dn_validate(member_dn)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
prim_group_rid = samdb_search_uint(ldb, ac, (uint32_t) -1,
sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb),
prim_group_rid);
if (sid == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
group_dn = samdb_search_dn(ldb, ac, NULL, "(objectSID=%s)",
dom_sid_string(ac, sid));
if (group_dn == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (ldb_dn_compare(group_dn, ac->msg->dn) == 0) {
}
status = dom_sid_split_rid(ac, sid, NULL, &rid);
if (!NT_STATUS_IS_OK(status)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (rid == 0) {
/* Special object (security principal?) */
"(&(primaryGroupID=%u)(objectClass=user))",
rid);
if (count < 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (count > 0) {
return LDB_ERR_ENTRY_ALREADY_EXISTS;
ac = samldb_ctx_init(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* build the new msg */
talloc_free(ac);
ldb_debug(ldb, LDB_DEBUG_FATAL,
"samldb_add: ldb_msg_copy failed!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
if (samdb_find_attribute(ldb, ac->msg,
ac = samldb_ctx_init(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* TODO: do not modify original request, create a new one */
ac = samldb_ctx_init(module, req);
if (ac == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
ret = samldb_prim_group_users_check(ac);
if (ret != LDB_SUCCESS) {
data = talloc(module, struct schema_data_private_data);
if (data == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data->schema_dn = schema_dn;
}
if (!oid) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
status = dsdb_schema_pfm_find_oid(schema->prefixmap, oid, NULL);
if (sclass->auxiliaryClass || sclass->systemAuxiliaryClass) {
char *ditcontentrule = schema_class_to_dITContentRule(msg, sclass, schema);
if (!ditcontentrule) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_msg_add_steal_string(msg, "dITContentRules", ditcontentrule);
if (ret != LDB_SUCCESS) {
for (attribute = schema->attributes; attribute; attribute = attribute->next) {
char *val = schema_attribute_to_extendedInfo(msg, attribute);
if (!val) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_msg_add_string(msg, "extendedAttributeInfo", val);
for (sclass = schema->classes; sclass; sclass = sclass->next) {
char *val = schema_class_to_extendedInfo(msg, sclass);
if (!val) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_msg_add_string(msg, "extendedClassInfo", val);
search_context = talloc(req, struct schema_data_search_data);
if (!search_context) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
search_context->module = module;
search_context->req = req;
search_context->schema = talloc_reference(search_context, schema);
if (!search_context->schema) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_build_search_req_ex(&down_req, ldb, search_context,
search_context, schema_data_search_callback,
req);
if (ret != LDB_SUCCESS) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return ldb_next_request(module, down_req);
tmp_ctx = talloc_new(module);
if (!tmp_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
/* we don't want to trace the schema load */
private_data = talloc_zero(module, struct schema_load_private_data);
if (private_data == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ldb_module_set_private(module, private_data);
in-situ */
new_tree = talloc(req, struct ldb_parse_tree);
if (!new_tree) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
new_tree->operation = LDB_OP_AND;
new_tree->u.list.num_elements = 2;
new_tree->u.list.elements = talloc_array(new_tree, struct ldb_parse_tree *, 2);
if (!new_tree->u.list.elements) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
new_tree->u.list.elements[0] = talloc(new_tree->u.list.elements, struct ldb_parse_tree);
new_tree->u.list.elements[0]->operation = LDB_OP_NOT;
new_tree->u.list.elements[0]->u.isnot.child =
talloc(new_tree->u.list.elements, struct ldb_parse_tree);
if (!new_tree->u.list.elements[0]->u.isnot.child) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
new_tree->u.list.elements[0]->u.isnot.child->operation = LDB_OP_EQUALITY;
new_tree->u.list.elements[0]->u.isnot.child->u.equality.attr = "isDeleted";
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"show_deleted: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return ldb_next_init(module);
ext = talloc_zero(req, struct ldb_extended);
if (!ext) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
seqr = talloc_zero(req, struct ldb_seqnum_result);
if (seqr == NULL) {
talloc_free(ext);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ext->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
ext->data = seqr;
if (ret != LDB_SUCCESS) {
ldb_debug(ldb, LDB_DEBUG_ERROR,
"subtree_delete: Unable to register control with rootdse!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
return ldb_next_init(module);
ldb = ldb_module_get_ctx(ac->module);
if (ac->current == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ret = ldb_build_rename_req(&req, ldb, ac->current,
ac = subren_ctx_init(module, req);
if (!ac) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
/* add this entry as the first to do */
ac->current = talloc_zero(ac, struct subren_msg_store);
if (ac->current == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->current->olddn = req->op.rename.olddn;
ac->current->newdn = req->op.rename.newdn;
filter = talloc_asprintf(data, "(&(dn=%s)(&(objectClass=kerberosSecret)(privateKeytab=*)))",
ldb_dn_get_linearized(dn));
if (!filter) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_search(ldb, data, &res,
item = talloc(data->changed_dns? (void *)data->changed_dns: (void *)data, struct dn_list);
if (!item) {
talloc_free(filter);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
item->creds = cli_credentials_init(item);
if (!item->creds) {
DEBUG(1, ("cli_credentials_init failed!"));
talloc_free(filter);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
cli_credentials_set_conf(item->creds, ldb_get_opaque(ldb, "loadparm"));
ac = update_kt_ctx_init(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ac->dn = req->op.add.message->dn;
ac = update_kt_ctx_init(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ac->dn = req->op.mod.message->dn;
ac = update_kt_ctx_init(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
ac->dn = req->op.del.dn;
ac = update_kt_ctx_init(module, req);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ac->dn = req->op.rename.newdn;
data = talloc(module, struct update_kt_private);
if (data == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
data->changed_dns = NULL;
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ret = ldb_build_search_req(&req, ldb_module_get_ctx(module), tmp_ctx,
if (!expression) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
} else {
expression = NULL;
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ret = ldb_build_search_req(&req, ldb_module_get_ctx(module), tmp_ctx,
status = dsdb_get_extended_dn_guid(res->msgs[0]->dn, guid, "GUID");
if (!NT_STATUS_IS_OK(status)) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
talloc_free(tmp_ctx);
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ret = ldb_build_mod_req(&mod_req, ldb, tmp_ctx,
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ret = ldb_build_rename_req(&req, ldb, tmp_ctx,
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb_module_get_ctx(module));
}
ret = ldb_build_add_req(&req, ldb, tmp_ctx,
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = ldb_build_del_req(&req, ldb, tmp_ctx,
el->values = &v1;
vstring = talloc_asprintf(msg, "%llu", (unsigned long long)old_val);
if (!vstring) {
- ldb_module_oom(module);
talloc_free(msg);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
v1 = data_blob_string_const(vstring);
el->values = &v2;
vstring = talloc_asprintf(msg, "%llu", (unsigned long long)new_val);
if (!vstring) {
- ldb_module_oom(module);
talloc_free(msg);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
v2 = data_blob_string_const(vstring);
res = talloc_zero(tmp_ctx, struct ldb_result);
if (!res) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
ret = ldb_build_search_req(&req, ldb, tmp_ctx,
p_ctrl = talloc(req, struct dsdb_control_current_partition);
if (p_ctrl == NULL) {
talloc_free(tmp_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
p_ctrl->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
p_ctrl->dn = dn;
msg = ldb_msg_new(module);
if (msg == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
msg->dn = ldb_dn_new(msg, ldb, "@REPLCHANGED");
if (msg->dn == NULL) {
talloc_free(msg);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb_module_get_ctx(module));
}
res = talloc_zero(msg, struct ldb_result);
if (!res) {
talloc_free(msg);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_oom(module);
}
ret = ldb_msg_add_fmt(msg, "uSNHighest", "%llu", (unsigned long long)uSN);
p_ctrl = talloc(msg, struct dsdb_control_current_partition);
if (p_ctrl == NULL) {
talloc_free(msg);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
p_ctrl->version = DSDB_CONTROL_CURRENT_PARTITION_VERSION;
p_ctrl->dn = dn;
}
if (s == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
attr->ldb_schema_attribute = a = talloc(attr, struct ldb_schema_attribute);
if (attr->ldb_schema_attribute == NULL) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
a->name = attr->lDAPDisplayName;
schema = dsdb_new_schema(mem_ctx);
if (!schema) {
dsdb_oom(error_string, mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
schema->base_dn = talloc_steal(schema, schema_res->msgs[0]->dn);
"schema_fsmo_init: dsdb_schema_info_blob_new() failed - %s",
win_errstr(status));
DEBUG(0,(__location__ ": %s\n", *error_string));
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
info_val = &info_val_default;
}
mem_ctx = talloc_new(ldb);
if (!mem_ctx) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
msg = ldb_msg_new(mem_ctx);
op_error:
talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
static int uint32_cmp(uint32_t c1, uint32_t c2)
failed:
dsdb_sorted_accessors_free(schema);
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
int dsdb_setup_schema_inversion(struct ldb_context *ldb, struct dsdb_schema *schema)
talloc_unlink(ldb, old_schema);
if (talloc_reference(ldb, schema) == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ret = dsdb_schema_set_attributes(ldb, schema, write_attributes);
if (ret == LDB_SUCCESS) {
/* Keep a reference to this schema, just incase the original copy is replaced */
if (talloc_reference(ldb, global_schema) == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
}
status = GUID_to_ndr_blob(&target_class->objectGUID, dn, &guid);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(dn);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_operr(ldb);
}
ldb_dn_set_extended_component(dn, "GUID", &guid);
git.samba.org / tridge / samba.git / commitdiff