From 98b303e2ebf0814856759499a99c40d5cd4f9f00 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 24 Aug 2005 22:06:26 +0000 Subject: r9595: Add ldb map module (This used to be commit e0a0d3f092d601a22b7549a0278735e66239b301) --- source4/lib/ldb/ldb_map/ldb_map.c | 238 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 238 insertions(+) create mode 100644 source4/lib/ldb/ldb_map/ldb_map.c (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c new file mode 100644 index 0000000000..39bab2c4c6 --- /dev/null +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -0,0 +1,238 @@ +/* + ldb database library - map backend + + Copyright (C) Jelmer Vernooij 2005 + + ** NOTE! The following LGPL license applies to the ldb + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include "includes.h" +#include "lib/ldb/include/ldb.h" +#include "lib/ldb/include/ldb_private.h" +#include "lib/ldb/ldb_map/ldb_map.h" + +struct map_private { + struct ldb_map_mappings *mappings; +}; + +static struct ldb_dn *ldb_map_dn(struct ldb_module *module, const struct ldb_dn *dn) +{ + /* FIXME */ + return NULL; +} + +static char *ldb_map_expression(struct ldb_module *module, const char *expr) +{ + /* FIXME */ + return NULL; +} + +static const char **ldb_map_attrs(struct ldb_module *module, const char *const attrs[]) +{ + /* FIXME */ + return NULL; +} + +static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const struct ldb_message *mi) +{ + /* FIXME */ + return NULL; +} + +static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mi) +{ + /* FIXME */ + return NULL; +} + +/* + rename a record +*/ +static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn) +{ + struct ldb_dn *n_olddn, *n_newdn; + int ret; + + n_olddn = ldb_map_dn(module, olddn); + n_newdn = ldb_map_dn(module, newdn); + + ret = ldb_next_rename_record(module, n_olddn, n_newdn); + + talloc_free(n_olddn); + talloc_free(n_newdn); + + return ret; +} + +/* + delete a record +*/ +static int map_delete(struct ldb_module *module, const struct ldb_dn *dn) +{ + struct ldb_dn *newdn; + int ret; + + newdn = ldb_map_dn(module, dn); + + ret = ldb_next_delete_record(module, newdn); + + talloc_free(newdn); + + return ret; +} + + +/* + search for matching records +*/ +static int map_search(struct ldb_module *module, const struct ldb_dn *base, + enum ldb_scope scope, const char *expression, + const char * const *attrs, struct ldb_message ***res) +{ + char *newexpr; + int ret; + const char **newattrs; + struct ldb_dn *new_base; + struct ldb_message **newres; + int i; + + newexpr = ldb_map_expression(module, expression); + newattrs = ldb_map_attrs(module, attrs); + new_base = ldb_map_dn(module, base); + + ret = ldb_next_search(module, new_base, scope, newexpr, newattrs, &newres); + + talloc_free(new_base); + talloc_free(newexpr); + talloc_free(newattrs); + + for (i = 0; i < ret; i++) { + *res[i] = ldb_map_message_incoming(module, newres[i]); + talloc_free(newres[i]); + } + + return ret; +} + +/* + add a record +*/ +static int map_add(struct ldb_module *module, const struct ldb_message *msg) +{ + struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg); + int ret; + + ret = ldb_next_add_record(module, nmsg); + + talloc_free(nmsg); + + return ret; +} + + +/* + search for matching records using a ldb_parse_tree +*/ +static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base, + enum ldb_scope scope, struct ldb_parse_tree *tree, + const char * const *attrs, struct ldb_message ***res) +{ + struct map_private *privdat = module->private_data; + char *expression; + int ret; + + expression = ldb_filter_from_tree(privdat, tree); + if (expression == NULL) { + return -1; + } + ret = map_search(module, base, scope, expression, attrs, res); + talloc_free(expression); + return ret; +} + +/* + modify a record +*/ +static int map_modify(struct ldb_module *module, const struct ldb_message *msg) +{ + struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg); + int ret; + + ret = ldb_next_modify_record(module, nmsg); + + talloc_free(nmsg); + + return ret; +} + +static int map_lock(struct ldb_module *module, const char *lockname) +{ + return ldb_next_named_lock(module, lockname); +} + +static int map_unlock(struct ldb_module *module, const char *lockname) +{ + return ldb_next_named_unlock(module, lockname); +} + +/* + return extended error information +*/ +static const char *map_errstring(struct ldb_module *module) +{ + return ldb_next_errstring(module); +} + +static const struct ldb_module_ops map_ops = { + .name = "map", + .search = map_search, + .search_bytree = map_search_bytree, + .add_record = map_add, + .modify_record = map_modify, + .delete_record = map_delete, + .rename_record = map_rename, + .named_lock = map_lock, + .named_unlock = map_unlock, + .errstring = map_errstring +}; + +/* the init function */ +struct ldb_module *ldb_map_init(struct ldb_context *ldb, struct ldb_map_mappings *mappings, const char *options[]) +{ + struct ldb_module *ctx; + struct map_private *data; + + ctx = talloc(ldb, struct ldb_module); + if (!ctx) + return NULL; + + data = talloc(ctx, struct map_private); + if (!data) { + talloc_free(ctx); + return NULL; + } + + data->mappings = mappings; + ctx->private_data = data; + ctx->ldb = ldb; + ctx->prev = ctx->next = NULL; + ctx->ops = &map_ops; + + return ctx; +} -- cgit From 9bf5e494f7ccbb2a9587dce961a99fa07392bf97 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 25 Aug 2005 15:25:22 +0000 Subject: r9616: Finish ldb_map module (still needs a lot of testing though...) Add initial mapping table for ldb_samba3. Contains most attributes. (This used to be commit b73441b04d048919e95ee7f7bcae330c4dafefe7) --- source4/lib/ldb/ldb_map/ldb_map.c | 450 ++++++++++++++++++++++++++++++++++---- 1 file changed, 405 insertions(+), 45 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 39bab2c4c6..4006ccbbd7 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -27,38 +27,391 @@ #include "lib/ldb/include/ldb_private.h" #include "lib/ldb/ldb_map/ldb_map.h" +/* TODO: + * - objectclass hint in ldb_map_attribute + * for use when multiple remote attributes (independant of each other) + * map to one local attribute. E.g.: (uid, gidNumber) -> unixName + */ + struct map_private { - struct ldb_map_mappings *mappings; + const struct ldb_map_mappings *mappings; + const char *last_err_string; }; -static struct ldb_dn *ldb_map_dn(struct ldb_module *module, const struct ldb_dn *dn) +/* find an attribute by the local name */ +static const struct ldb_map_attribute *map_find_attr_local(struct ldb_module *module, const char *attr) { - /* FIXME */ + struct map_private *privdat = module->private_data; + int i; + for (i = 0; privdat->mappings->attribute_maps[i]; i++) { + if (!strcmp(privdat->mappings->attribute_maps[i]->local_name, attr)) + return privdat->mappings->attribute_maps[i]; + } + return NULL; } -static char *ldb_map_expression(struct ldb_module *module, const char *expr) +/* find an attribute by the remote name */ +static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_module *module, const char *attr) { - /* FIXME */ + struct map_private *privdat = module->private_data; + int i; + for (i = 0; privdat->mappings->attribute_maps[i]; i++) { + if (privdat->mappings->attribute_maps[i]->type != MAP_RENAME && + privdat->mappings->attribute_maps[i]->type != MAP_CONVERT) + continue; + + if (!strcmp(privdat->mappings->attribute_maps[i]->u.rename.remote_name, attr)) + return privdat->mappings->attribute_maps[i]; + } + return NULL; } +static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, const struct ldb_parse_tree *tree) +{ + int i; + const struct ldb_map_attribute *attr; + struct ldb_parse_tree *new_tree = talloc_memdup(module, tree, sizeof(*tree)); + + /* Find attr in question and: + * - if it has a convert_operator function, run that + * - otherwise, replace attr name with required[0] */ + + if (tree->operation == LDB_OP_AND || + tree->operation == LDB_OP_OR) { + for (i = 0; i < tree->u.list.num_elements; i++) { + new_tree->u.list.elements[i] = ldb_map_parse_tree(module, tree->u.list.elements[i]); + } + + return new_tree; + } + + if (tree->operation == LDB_OP_NOT) { + new_tree->u.isnot.child = ldb_map_parse_tree(module, tree->u.isnot.child); + return new_tree; + } + + /* tree->operation is LDB_OP_EQUALITY, LDB_OP_SUBSTRING, LDB_OP_GREATER, + * LDB_OP_LESS, LDB_OP_APPROX, LDB_OP_PRESENT or LDB_OP_EXTENDED + * + * (all have attr as the first element) + */ + + attr = map_find_attr_local(module, tree->u.equality.attr); + + if (!attr) { + DEBUG(0, ("Unable to find local attribute '%s', leaving as is", tree->u.equality.attr)); + return new_tree; + } + + if (attr->type == MAP_IGNORE) + return NULL; + + if (attr->convert_operator) { + /* Run convert_operator */ + talloc_free(new_tree); + new_tree = attr->convert_operator(module, tree); + } else { + new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name); + } + + return new_tree; +} + +/* Remote DN -> Local DN */ +static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_dn *dn) +{ + struct ldb_dn *newdn; + int i; + + newdn = talloc_memdup(module, dn, sizeof(*dn)); + if (!newdn) + return NULL; + + newdn->components = talloc_memdup(newdn, dn->components, sizeof(struct ldb_dn_component) * newdn->comp_num); + + if (!newdn->components) + return NULL; + + /* For each rdn, map the attribute name and possibly the + * complete rdn */ + + for (i = 0; i < dn->comp_num; i++) { + const struct ldb_map_attribute *attr = map_find_attr_remote(module, dn->components[i].name); + + /* Unknown attribute - leave this dn as is and hope the best... */ + if (!attr) + continue; + + if (attr->type == MAP_IGNORE) { + DEBUG(0, ("Local MAP_IGNORE attribute '%s' used in DN!", dn->components[i].name)); + talloc_free(newdn); + return NULL; + } + + if (attr->type == MAP_GENERATE) { + DEBUG(0, ("Local MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); + talloc_free(newdn); + + return NULL; + } + + if (attr->type == MAP_CONVERT) { + struct ldb_message_element elm, *newelm; + struct ldb_val vals[1] = { dn->components[i].value }; + elm.flags = 0; + elm.name = attr->u.convert.remote_name; + elm.num_values = 1; + elm.values = vals; + + newelm = attr->u.convert.convert_remote(module, attr->local_name, &elm); + + newdn->components[i].name = talloc_strdup(module, newelm->name); + newdn->components[i].value = newelm->values[0]; + } else if (attr->type == MAP_RENAME) { + newdn->components[i].name = talloc_strdup(module, attr->local_name); + } + } + return newdn; +} + +/* Local DN -> Remote DN */ +static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_dn *dn) +{ struct ldb_dn *newdn; + int i; + struct ldb_parse_tree eqtree, *new_eqtree; + + newdn = talloc_memdup(module, dn, sizeof(*dn)); + if (!newdn) + return NULL; + + newdn->components = talloc_memdup(newdn, dn->components, sizeof(struct ldb_dn_component) * newdn->comp_num); + + if (!newdn->components) + return NULL; + + /* For each rdn, map the attribute name and possibly the + * complete rdn using an equality convert_operator call */ + + for (i = 0; i < dn->comp_num; i++) { + const struct ldb_map_attribute *attr = map_find_attr_local(module, dn->components[i].name); + + /* Unknown attribute - leave this dn as is and hope the best... */ + if (!attr) + continue; + + if (attr->type == MAP_IGNORE) { + DEBUG(0, ("Local MAP_IGNORE attribute '%s' used in DN!", dn->components[i].name)); + talloc_free(newdn); + return NULL; + } + + if (attr->type == MAP_GENERATE) { + DEBUG(0, ("Local MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); + talloc_free(newdn); + + return NULL; + } + + /* Simple rename/convert only */ + if (attr->convert_operator) { + /* Fancy stuff */ + eqtree.operation = LDB_OP_EQUALITY; + eqtree.u.equality.attr = dn->components[i].name; + eqtree.u.equality.value = dn->components[i].value; + + new_eqtree = ldb_map_parse_tree(module, &eqtree); + + /* Silently continue for now */ + if (!new_eqtree) { + DEBUG(0, ("Unable to convert RDN for attribute %s\n", dn->components[i].name)); + continue; + } + + newdn->components[i].name = new_eqtree->u.equality.attr; + newdn->components[i].value = new_eqtree->u.equality.value; + } else if (attr->type == MAP_CONVERT) { + struct ldb_message_element elm, *newelm; + struct ldb_val vals[1] = { dn->components[i].value }; + elm.flags = 0; + elm.name = attr->local_name; + elm.num_values = 1; + elm.values = vals; + + newelm = attr->u.convert.convert_local(module, attr->u.convert.remote_name, &elm); + + newdn->components[i].name = talloc_strdup(module, newelm->name); + newdn->components[i].value = newelm->values[0]; + } else if (attr->type == MAP_RENAME) { + newdn->components[i].name = talloc_strdup(module, attr->u.rename.remote_name); + } + } + + return newdn; +} + + + +/* Loop over ldb_map_attribute array and add remote_names */ static const char **ldb_map_attrs(struct ldb_module *module, const char *const attrs[]) { - /* FIXME */ + int i; + const char **ret; + int ar_size = 0, last_element = 0; + + /* Start with good guess of number of elements */ + for (i = 0; attrs[i]; i++); + + ret = talloc_array(module, const char *, i); + ar_size = i; + + for (i = 0; attrs[i]; i++) { + int j; + const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]); + + if (!attr) { + DEBUG(0, ("Local attribute '%s' does not have a definition!\n", attrs[i])); + continue; + } + + switch (attr->type) + { + case MAP_IGNORE: break; + case MAP_KEEP: + if (last_element >= ar_size) { + ret = talloc_realloc(module, ret, const char *, ar_size+1); + ar_size++; + } + ret[last_element] = attr->local_name; + last_element++; + break; + + case MAP_RENAME: + case MAP_CONVERT: + if (last_element >= ar_size) { + ret = talloc_realloc(module, ret, const char *, ar_size+1); + ar_size++; + } + ret[last_element] = attr->u.rename.remote_name; + last_element++; + break; + + case MAP_GENERATE: + /* Add remote_names[] for this attribute to the list of + * attributes to request from the remote server */ + for (j = 0; attr->u.generate.remote_names[j]; j++) { + if (last_element >= ar_size) { + ret = talloc_realloc(module, ret, const char *, ar_size+1); + ar_size++; + } + ret[last_element] = attr->u.generate.remote_names[j]; + last_element++; + } + break; + } + } + return NULL; } -static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const struct ldb_message *mi) +static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi) { - /* FIXME */ - return NULL; + int i; + struct ldb_message *msg = talloc_zero(module, struct ldb_message); + struct ldb_message_element *elm, *oldelm; + + msg->dn = map_remote_dn(module, mi->dn); + + /* Loop over attrs, find in ldb_map_attribute array and + * run generate() */ + + for (i = 0; attrs[i]; i++) { + const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]); + + if (!attr) { + DEBUG(0, ("Unable to find local attribute '%s' when generating incoming message", attrs[i])); + continue; + } + + switch (attr->type) { + case MAP_IGNORE:break; + case MAP_RENAME: + oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); + elm = talloc_memdup(msg, oldelm, sizeof(*oldelm)); + elm->name = talloc_strdup(elm, attr->local_name); + + ldb_msg_add(module->ldb, msg, elm, 0); + break; + + case MAP_CONVERT: + oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); + elm = attr->u.convert.convert_local(msg, attr->local_name, oldelm); + + ldb_msg_add(module->ldb, msg, elm, 0); + break; + + case MAP_KEEP: + ldb_msg_add(module->ldb, msg, ldb_msg_find_element(mi, attr->local_name), 0); + break; + + case MAP_GENERATE: + elm = attr->u.generate.generate_local(msg, attr->local_name, mi); + ldb_msg_add(module->ldb, msg, elm, 0); + break; + default: + DEBUG(0, ("Unknown attr->type for %s", attr->local_name)); + break; + } + } + + return msg; } -static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mi) +static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo) { - /* FIXME */ - return NULL; + struct ldb_message *msg = talloc_zero(module, struct ldb_message); + struct ldb_message_element *elm; + int i; + + msg->private_data = mo->private_data; + + msg->dn = map_local_dn(module, mo->dn); + + /* Loop over mi and call generate_remote for each attribute */ + for (i = 0; i < mo->num_elements; i++) { + const struct ldb_map_attribute *attr = map_find_attr_local(module, mo->elements[i].name); + + if (!attr) { + DEBUG(0, ("Undefined local attribute '%s', ignoring\n", mo->elements[i].name)); + continue; + } + + switch (attr->type) { + case MAP_IGNORE: break; + case MAP_RENAME: + elm = talloc_memdup(msg, &msg->elements[i], sizeof(*elm)); + elm->name = talloc_strdup(elm, attr->u.rename.remote_name); + + ldb_msg_add(module->ldb, msg, elm, 0); + break; + + case MAP_CONVERT: + elm = attr->u.convert.convert_remote(msg, attr->local_name, &msg->elements[i]); + ldb_msg_add(module->ldb, msg, elm, 0); + break; + + case MAP_KEEP: + ldb_msg_add(module->ldb, msg, &msg->elements[i], 0); + break; + + case MAP_GENERATE: + attr->u.generate.generate_remote(attr->local_name, mo, msg); + break; + } + } + + return msg; } /* @@ -69,8 +422,8 @@ static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, con struct ldb_dn *n_olddn, *n_newdn; int ret; - n_olddn = ldb_map_dn(module, olddn); - n_newdn = ldb_map_dn(module, newdn); + n_olddn = map_local_dn(module, olddn); + n_newdn = map_local_dn(module, newdn); ret = ldb_next_rename_record(module, n_olddn, n_newdn); @@ -88,7 +441,7 @@ static int map_delete(struct ldb_module *module, const struct ldb_dn *dn) struct ldb_dn *newdn; int ret; - newdn = ldb_map_dn(module, dn); + newdn = map_local_dn(module, dn); ret = ldb_next_delete_record(module, newdn); @@ -97,38 +450,58 @@ static int map_delete(struct ldb_module *module, const struct ldb_dn *dn) return ret; } - /* - search for matching records + search for matching records using a ldb_parse_tree */ -static int map_search(struct ldb_module *module, const struct ldb_dn *base, - enum ldb_scope scope, const char *expression, - const char * const *attrs, struct ldb_message ***res) +static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base, + enum ldb_scope scope, struct ldb_parse_tree *tree, + const char * const *attrs, struct ldb_message ***res) { - char *newexpr; int ret; const char **newattrs; + struct ldb_parse_tree *new_tree; struct ldb_dn *new_base; struct ldb_message **newres; int i; - newexpr = ldb_map_expression(module, expression); + new_tree = ldb_map_parse_tree(module, tree); newattrs = ldb_map_attrs(module, attrs); - new_base = ldb_map_dn(module, base); + new_base = map_local_dn(module, base); - ret = ldb_next_search(module, new_base, scope, newexpr, newattrs, &newres); + ret = ldb_next_search_bytree(module, new_base, scope, new_tree, newattrs, &newres); talloc_free(new_base); - talloc_free(newexpr); + talloc_free(new_tree); talloc_free(newattrs); for (i = 0; i < ret; i++) { - *res[i] = ldb_map_message_incoming(module, newres[i]); + *res[i] = ldb_map_message_incoming(module, attrs, newres[i]); talloc_free(newres[i]); } return ret; } +/* + search for matching records +*/ +static int map_search(struct ldb_module *module, const struct ldb_dn *base, + enum ldb_scope scope, const char *expression, + const char * const *attrs, struct ldb_message ***res) +{ + struct map_private *map = module->private_data; + struct ldb_parse_tree *tree; + int ret; + + tree = ldb_parse_tree(map, expression); + if (tree == NULL) { + map->last_err_string = "expression parse failed"; + return -1; + } + + ret = map_search_bytree(module, base, scope, tree, attrs, res); + talloc_free(tree); + return ret; +} /* add a record @@ -146,25 +519,7 @@ static int map_add(struct ldb_module *module, const struct ldb_message *msg) } -/* - search for matching records using a ldb_parse_tree -*/ -static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base, - enum ldb_scope scope, struct ldb_parse_tree *tree, - const char * const *attrs, struct ldb_message ***res) -{ - struct map_private *privdat = module->private_data; - char *expression; - int ret; - expression = ldb_filter_from_tree(privdat, tree); - if (expression == NULL) { - return -1; - } - ret = map_search(module, base, scope, expression, attrs, res); - talloc_free(expression); - return ret; -} /* modify a record @@ -196,6 +551,11 @@ static int map_unlock(struct ldb_module *module, const char *lockname) */ static const char *map_errstring(struct ldb_module *module) { + struct map_private *map = module->private_data; + + if (map->last_err_string) + return map->last_err_string; + return ldb_next_errstring(module); } @@ -213,7 +573,7 @@ static const struct ldb_module_ops map_ops = { }; /* the init function */ -struct ldb_module *ldb_map_init(struct ldb_context *ldb, struct ldb_map_mappings *mappings, const char *options[]) +struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_mappings *mappings, const char *options[]) { struct ldb_module *ctx; struct map_private *data; -- cgit From 02779b745fa5caceecbb480f1949a6e44f5da972 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 27 Aug 2005 02:10:28 +0000 Subject: r9672: Fix build for compilers that don't like undefined-length arrays at the end of structs... (This used to be commit c2211df586337ff68bb805801959147065040c01) --- source4/lib/ldb/ldb_map/ldb_map.c | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 4006ccbbd7..dea3c24e37 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -34,7 +34,8 @@ */ struct map_private { - const struct ldb_map_mappings *mappings; + const struct ldb_map_attribute *attribute_maps; + const struct ldb_map_objectclass *objectclass_maps; const char *last_err_string; }; @@ -43,9 +44,9 @@ static const struct ldb_map_attribute *map_find_attr_local(struct ldb_module *mo { struct map_private *privdat = module->private_data; int i; - for (i = 0; privdat->mappings->attribute_maps[i]; i++) { - if (!strcmp(privdat->mappings->attribute_maps[i]->local_name, attr)) - return privdat->mappings->attribute_maps[i]; + for (i = 0; privdat->attribute_maps[i].local_name; i++) { + if (!strcmp(privdat->attribute_maps[i].local_name, attr)) + return &privdat->attribute_maps[i]; } return NULL; @@ -56,13 +57,13 @@ static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_module *m { struct map_private *privdat = module->private_data; int i; - for (i = 0; privdat->mappings->attribute_maps[i]; i++) { - if (privdat->mappings->attribute_maps[i]->type != MAP_RENAME && - privdat->mappings->attribute_maps[i]->type != MAP_CONVERT) + for (i = 0; privdat->attribute_maps[i].local_name; i++) { + if (privdat->attribute_maps[i].type != MAP_RENAME && + privdat->attribute_maps[i].type != MAP_CONVERT) continue; - if (!strcmp(privdat->mappings->attribute_maps[i]->u.rename.remote_name, attr)) - return privdat->mappings->attribute_maps[i]; + if (!strcmp(privdat->attribute_maps[i].u.rename.remote_name, attr)) + return &privdat->attribute_maps[i]; } return NULL; @@ -573,7 +574,7 @@ static const struct ldb_module_ops map_ops = { }; /* the init function */ -struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_mappings *mappings, const char *options[]) +struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_attribute *attrs, const struct ldb_map_objectclass *ocls, const char *options[]) { struct ldb_module *ctx; struct map_private *data; @@ -588,7 +589,8 @@ struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_ma return NULL; } - data->mappings = mappings; + data->attribute_maps = attrs; + data->objectclass_maps = ocls; ctx->private_data = data; ctx->ldb = ldb; ctx->prev = ctx->next = NULL; -- cgit From 7e3838dd2d8647e9c621a08c61a2a22ef1d94bb2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 27 Aug 2005 15:13:15 +0000 Subject: r9685: Add tests for samba3sam mapping module Fix a couple of bugs Move samba3sam backend to lib/ldb/ Remove some more unused parameters (This used to be commit 7f864d446d6af7cfd9fb8dbc496a29b36ec57ce9) --- source4/lib/ldb/ldb_map/ldb_map.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index dea3c24e37..2082abe79a 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -126,6 +126,9 @@ static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_ struct ldb_dn *newdn; int i; + if (dn == NULL) + return NULL; + newdn = talloc_memdup(module, dn, sizeof(*dn)); if (!newdn) return NULL; @@ -183,6 +186,9 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d int i; struct ldb_parse_tree eqtree, *new_eqtree; + if (dn == NULL) + return NULL; + newdn = talloc_memdup(module, dn, sizeof(*dn)); if (!newdn) return NULL; @@ -252,8 +258,6 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d return newdn; } - - /* Loop over ldb_map_attribute array and add remote_names */ static const char **ldb_map_attrs(struct ldb_module *module, const char *const attrs[]) { @@ -261,6 +265,9 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a const char **ret; int ar_size = 0, last_element = 0; + if (attrs == NULL) + return NULL; + /* Start with good guess of number of elements */ for (i = 0; attrs[i]; i++); -- cgit From e8635da74d4b55b51c1be4fb090a86f8b8a64e78 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 27 Aug 2005 16:33:42 +0000 Subject: r9686: Another round of bugfixes. Works somewhat now, when running under valgrind ;-) (This used to be commit 786379064f0ed779b965330fb3b74deaca75ce99) --- source4/lib/ldb/ldb_map/ldb_map.c | 74 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 69 insertions(+), 5 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 2082abe79a..89c6934f5c 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -73,7 +73,12 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, cons { int i; const struct ldb_map_attribute *attr; - struct ldb_parse_tree *new_tree = talloc_memdup(module, tree, sizeof(*tree)); + struct ldb_parse_tree *new_tree; + + if (tree == NULL) + return NULL; + + new_tree = talloc_memdup(module, tree, sizeof(*tree)); /* Find attr in question and: * - if it has a convert_operator function, run that @@ -102,7 +107,7 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, cons attr = map_find_attr_local(module, tree->u.equality.attr); if (!attr) { - DEBUG(0, ("Unable to find local attribute '%s', leaving as is", tree->u.equality.attr)); + DEBUG(0, ("Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr)); return new_tree; } @@ -323,22 +328,77 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a return NULL; } +static const char **available_local_attributes(struct ldb_module *module, const struct ldb_message *msg) +{ + struct map_private *map = module->private_data; + int i, j; + int count = 0; + const char **ret = talloc_array(module, const char *, 1); + + ret[0] = NULL; + + for (i = 0; map->attribute_maps[i].local_name; i++) { + BOOL avail = False; + const struct ldb_map_attribute *attr = &map->attribute_maps[i]; + + /* If all remote attributes for this attribute are present, add the + * local one to the list */ + + switch (attr->type) { + case MAP_IGNORE: break; + case MAP_KEEP: + avail = (ldb_msg_find_ldb_val(msg, attr->local_name) != NULL); + break; + + case MAP_RENAME: + case MAP_CONVERT: + avail = (ldb_msg_find_ldb_val(msg, attr->u.rename.remote_name) != NULL); + break; + + case MAP_GENERATE: + avail = True; + for (j = 0; attr->u.generate.remote_names[j]; j++) { + avail &= (ldb_msg_find_ldb_val(msg, attr->u.generate.remote_names[j]) != NULL); + } + break; + } + + if (!avail) + continue; + + ret = talloc_realloc(module, ret, const char *, count+2); + ret[count] = attr->local_name; + ret[count+1] = NULL; + count++; + } + + return ret; +} + static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi) { int i; struct ldb_message *msg = talloc_zero(module, struct ldb_message); struct ldb_message_element *elm, *oldelm; + const char **newattrs = NULL; msg->dn = map_remote_dn(module, mi->dn); /* Loop over attrs, find in ldb_map_attribute array and * run generate() */ + if (attrs == NULL) { + /* Generate list of the local attributes that /can/ be generated + * using the specific remote attributes */ + + attrs = newattrs = available_local_attributes(module, mi); + } + for (i = 0; attrs[i]; i++) { const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]); if (!attr) { - DEBUG(0, ("Unable to find local attribute '%s' when generating incoming message", attrs[i])); + DEBUG(0, ("Unable to find local attribute '%s' when generating incoming message\n", attrs[i])); continue; } @@ -373,6 +433,8 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c } } + talloc_free(newattrs); + return msg; } @@ -482,8 +544,10 @@ static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *bas talloc_free(new_tree); talloc_free(newattrs); + *res = talloc_array(module, struct ldb_message *, ret); + for (i = 0; i < ret; i++) { - *res[i] = ldb_map_message_incoming(module, attrs, newres[i]); + (*res)[i] = ldb_map_message_incoming(module, attrs, newres[i]); talloc_free(newres[i]); } @@ -500,7 +564,7 @@ static int map_search(struct ldb_module *module, const struct ldb_dn *base, struct ldb_parse_tree *tree; int ret; - tree = ldb_parse_tree(map, expression); + tree = ldb_parse_tree(NULL, expression); if (tree == NULL) { map->last_err_string = "expression parse failed"; return -1; -- cgit From afb62ee775c3e5b56d786f8246df4a56002b133f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 27 Aug 2005 18:30:00 +0000 Subject: r9689: valgrind-clean now. Editing works now mostly, you just lose half of your database every time you do it... (This used to be commit 40ea2af427911d9a3e65ca9ebed438e9a0a83af8) --- source4/lib/ldb/ldb_map/ldb_map.c | 144 +++++++++++++++++++++++--------------- 1 file changed, 89 insertions(+), 55 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 89c6934f5c..d2eea49877 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -69,7 +69,7 @@ static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_module *m return NULL; } -static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, const struct ldb_parse_tree *tree) +static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_parse_tree *tree) { int i; const struct ldb_map_attribute *attr; @@ -78,7 +78,7 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, cons if (tree == NULL) return NULL; - new_tree = talloc_memdup(module, tree, sizeof(*tree)); + new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); /* Find attr in question and: * - if it has a convert_operator function, run that @@ -86,15 +86,16 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, cons if (tree->operation == LDB_OP_AND || tree->operation == LDB_OP_OR) { - for (i = 0; i < tree->u.list.num_elements; i++) { - new_tree->u.list.elements[i] = ldb_map_parse_tree(module, tree->u.list.elements[i]); + new_tree->u.list.elements = talloc_array(new_tree, struct ldb_parse_tree *, tree->u.list.num_elements); + for (i = 0; i < new_tree->u.list.num_elements; i++) { + new_tree->u.list.elements[i] = ldb_map_parse_tree(module, new_tree, tree->u.list.elements[i]); } return new_tree; } if (tree->operation == LDB_OP_NOT) { - new_tree->u.isnot.child = ldb_map_parse_tree(module, tree->u.isnot.child); + new_tree->u.isnot.child = ldb_map_parse_tree(module, new_tree, tree->u.isnot.child); return new_tree; } @@ -104,6 +105,19 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, cons * (all have attr as the first element) */ + if (new_tree->operation == LDB_OP_EQUALITY) { + new_tree->u.equality.value = ldb_val_dup(new_tree, &tree->u.equality.value); + } else if (new_tree->operation == LDB_OP_SUBSTRING) { + new_tree->u.substring.chunks = NULL; /* FIXME! */ + } else if (new_tree->operation == LDB_OP_LESS || + new_tree->operation == LDB_OP_GREATER || + new_tree->operation == LDB_OP_APPROX) { + new_tree->u.comparison.value = ldb_val_dup(new_tree, &tree->u.comparison.value); + } else if (new_tree->operation == LDB_OP_EXTENDED) { + new_tree->u.extended.value = ldb_val_dup(new_tree, &tree->u.extended.value); + new_tree->u.extended.rule_id = talloc_strdup(new_tree, tree->u.extended.rule_id); + } + attr = map_find_attr_local(module, tree->u.equality.attr); if (!attr) { @@ -111,17 +125,21 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, cons return new_tree; } - if (attr->type == MAP_IGNORE) + if (attr->type == MAP_IGNORE) { + talloc_free(new_tree); return NULL; + } if (attr->convert_operator) { /* Run convert_operator */ talloc_free(new_tree); new_tree = attr->convert_operator(module, tree); + + return new_tree; } else { new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name); } - + return new_tree; } @@ -138,7 +156,7 @@ static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_ if (!newdn) return NULL; - newdn->components = talloc_memdup(newdn, dn->components, sizeof(struct ldb_dn_component) * newdn->comp_num); + newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num); if (!newdn->components) return NULL; @@ -150,25 +168,17 @@ static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_ const struct ldb_map_attribute *attr = map_find_attr_remote(module, dn->components[i].name); /* Unknown attribute - leave this dn as is and hope the best... */ - if (!attr) - continue; - - if (attr->type == MAP_IGNORE) { - DEBUG(0, ("Local MAP_IGNORE attribute '%s' used in DN!", dn->components[i].name)); - talloc_free(newdn); - return NULL; - } - - if (attr->type == MAP_GENERATE) { - DEBUG(0, ("Local MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); + if (!attr || attr->type == MAP_KEEP) { + newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); + newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); + } else if (attr->type == MAP_IGNORE || attr->type == MAP_GENERATE) { + DEBUG(0, ("Local MAP_IGNORE or MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); talloc_free(newdn); - return NULL; - } - - if (attr->type == MAP_CONVERT) { + } else if (attr->type == MAP_CONVERT) { struct ldb_message_element elm, *newelm; struct ldb_val vals[1] = { dn->components[i].value }; + elm.flags = 0; elm.name = attr->u.convert.remote_name; elm.num_values = 1; @@ -176,10 +186,13 @@ static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_ newelm = attr->u.convert.convert_remote(module, attr->local_name, &elm); - newdn->components[i].name = talloc_strdup(module, newelm->name); - newdn->components[i].value = newelm->values[0]; + newdn->components[i].name = talloc_strdup(newdn->components, newelm->name); + newdn->components[i].value = ldb_val_dup(newdn->components, &newelm->values[0]); + + talloc_free(newelm); } else if (attr->type == MAP_RENAME) { - newdn->components[i].name = talloc_strdup(module, attr->local_name); + newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name); + newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); } } return newdn; @@ -198,7 +211,7 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d if (!newdn) return NULL; - newdn->components = talloc_memdup(newdn, dn->components, sizeof(struct ldb_dn_component) * newdn->comp_num); + newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num); if (!newdn->components) return NULL; @@ -210,22 +223,16 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d const struct ldb_map_attribute *attr = map_find_attr_local(module, dn->components[i].name); /* Unknown attribute - leave this dn as is and hope the best... */ - if (!attr) + if (!attr || attr->type == MAP_KEEP) { + newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); + newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); continue; - - if (attr->type == MAP_IGNORE) { - DEBUG(0, ("Local MAP_IGNORE attribute '%s' used in DN!", dn->components[i].name)); + } else if (attr->type == MAP_IGNORE || attr->type == MAP_GENERATE) { + DEBUG(0, ("Local MAP_IGNORE/MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); talloc_free(newdn); return NULL; } - if (attr->type == MAP_GENERATE) { - DEBUG(0, ("Local MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); - talloc_free(newdn); - - return NULL; - } - /* Simple rename/convert only */ if (attr->convert_operator) { /* Fancy stuff */ @@ -233,7 +240,7 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d eqtree.u.equality.attr = dn->components[i].name; eqtree.u.equality.value = dn->components[i].value; - new_eqtree = ldb_map_parse_tree(module, &eqtree); + new_eqtree = ldb_map_parse_tree(module, newdn, &eqtree); /* Silently continue for now */ if (!new_eqtree) { @@ -241,8 +248,10 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d continue; } - newdn->components[i].name = new_eqtree->u.equality.attr; - newdn->components[i].value = new_eqtree->u.equality.value; + newdn->components[i].name = talloc_strdup(newdn->components, new_eqtree->u.equality.attr); + newdn->components[i].value = ldb_val_dup(newdn->components, &new_eqtree->u.equality.value); + + talloc_free(new_eqtree); } else if (attr->type == MAP_CONVERT) { struct ldb_message_element elm, *newelm; struct ldb_val vals[1] = { dn->components[i].value }; @@ -253,10 +262,13 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d newelm = attr->u.convert.convert_local(module, attr->u.convert.remote_name, &elm); - newdn->components[i].name = talloc_strdup(module, newelm->name); - newdn->components[i].value = newelm->values[0]; + newdn->components[i].name = talloc_strdup(newdn->components, newelm->name); + newdn->components[i].value = ldb_val_dup(newdn->components, &newelm->values[0]); + + talloc_free(newelm); } else if (attr->type == MAP_RENAME) { - newdn->components[i].name = talloc_strdup(module, attr->u.rename.remote_name); + newdn->components[i].name = talloc_strdup(newdn->components, attr->u.rename.remote_name); + newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); } } @@ -406,26 +418,37 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c case MAP_IGNORE:break; case MAP_RENAME: oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); - elm = talloc_memdup(msg, oldelm, sizeof(*oldelm)); + + elm = talloc(msg, struct ldb_message_element); elm->name = talloc_strdup(elm, attr->local_name); + elm->num_values = oldelm->num_values; + elm->values = talloc_reference(elm, oldelm->values); - ldb_msg_add(module->ldb, msg, elm, 0); + ldb_msg_add(module->ldb, msg, elm, oldelm->flags); break; case MAP_CONVERT: oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); elm = attr->u.convert.convert_local(msg, attr->local_name, oldelm); - ldb_msg_add(module->ldb, msg, elm, 0); + ldb_msg_add(module->ldb, msg, elm, elm->flags); break; case MAP_KEEP: - ldb_msg_add(module->ldb, msg, ldb_msg_find_element(mi, attr->local_name), 0); + oldelm = ldb_msg_find_element(mi, attr->local_name); + + elm = talloc(msg, struct ldb_message_element); + + elm->num_values = oldelm->num_values; + elm->values = talloc_reference(elm, oldelm->values); + elm->name = talloc_strdup(elm, oldelm->name); + + ldb_msg_add(module->ldb, msg, elm, oldelm->flags); break; case MAP_GENERATE: elm = attr->u.generate.generate_local(msg, attr->local_name, mi); - ldb_msg_add(module->ldb, msg, elm, 0); + ldb_msg_add(module->ldb, msg, elm, elm->flags); break; default: DEBUG(0, ("Unknown attr->type for %s", attr->local_name)); @@ -460,19 +483,28 @@ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, c switch (attr->type) { case MAP_IGNORE: break; case MAP_RENAME: - elm = talloc_memdup(msg, &msg->elements[i], sizeof(*elm)); + elm = talloc(msg, struct ldb_message_element); + elm->name = talloc_strdup(elm, attr->u.rename.remote_name); + elm->num_values = mo->elements[i].num_values; + elm->values = talloc_reference(elm, mo->elements[i].values); - ldb_msg_add(module->ldb, msg, elm, 0); + ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags); break; case MAP_CONVERT: - elm = attr->u.convert.convert_remote(msg, attr->local_name, &msg->elements[i]); - ldb_msg_add(module->ldb, msg, elm, 0); + elm = attr->u.convert.convert_remote(msg, attr->local_name, &mo->elements[i]); + ldb_msg_add(module->ldb, msg, elm, elm->flags); break; case MAP_KEEP: - ldb_msg_add(module->ldb, msg, &msg->elements[i], 0); + elm = talloc(msg, struct ldb_message_element); + + elm->num_values = mo->elements[i].num_values; + elm->values = talloc_reference(elm, mo->elements[i].values); + elm->name = talloc_strdup(elm, mo->elements[i].name); + + ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags); break; case MAP_GENERATE: @@ -534,7 +566,7 @@ static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *bas struct ldb_message **newres; int i; - new_tree = ldb_map_parse_tree(module, tree); + new_tree = ldb_map_parse_tree(module, module, tree); newattrs = ldb_map_attrs(module, attrs); new_base = map_local_dn(module, base); @@ -660,6 +692,8 @@ struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_at return NULL; } + data->last_err_string = NULL; + data->attribute_maps = attrs; data->objectclass_maps = ocls; ctx->private_data = data; -- cgit From e1269bafe8449f2417d7c666bf0f95af5d7a005f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 27 Aug 2005 19:46:28 +0000 Subject: r9690: Extend test + fix several bugs (This used to be commit 0cff0e03fca0ddccaff3b463aadba63d29e061a9) --- source4/lib/ldb/ldb_map/ldb_map.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index d2eea49877..d2bbea7c7a 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -120,8 +120,9 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL attr = map_find_attr_local(module, tree->u.equality.attr); - if (!attr) { + if (!attr || attr->type == MAP_KEEP) { DEBUG(0, ("Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr)); + new_tree->u.equality.attr = talloc_strdup(new_tree, tree->u.equality.attr); return new_tree; } @@ -387,6 +388,7 @@ static const char **available_local_attributes(struct ldb_module *module, const return ret; } +/* Used for search */ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi) { int i; @@ -418,6 +420,7 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c case MAP_IGNORE:break; case MAP_RENAME: oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); + if (!oldelm) continue; elm = talloc(msg, struct ldb_message_element); elm->name = talloc_strdup(elm, attr->local_name); @@ -429,14 +432,18 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c case MAP_CONVERT: oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); - elm = attr->u.convert.convert_local(msg, attr->local_name, oldelm); + if (!oldelm) continue; + + elm = attr->u.convert.convert_remote(msg, attr->local_name, oldelm); + if (!elm) continue; ldb_msg_add(module->ldb, msg, elm, elm->flags); break; case MAP_KEEP: oldelm = ldb_msg_find_element(mi, attr->local_name); - + if (!oldelm) continue; + elm = talloc(msg, struct ldb_message_element); elm->num_values = oldelm->num_values; @@ -448,6 +455,8 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c case MAP_GENERATE: elm = attr->u.generate.generate_local(msg, attr->local_name, mi); + if (!elm) continue; + ldb_msg_add(module->ldb, msg, elm, elm->flags); break; default: @@ -461,6 +470,7 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c return msg; } +/* Used for add, modify */ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo) { struct ldb_message *msg = talloc_zero(module, struct ldb_message); @@ -493,7 +503,7 @@ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, c break; case MAP_CONVERT: - elm = attr->u.convert.convert_remote(msg, attr->local_name, &mo->elements[i]); + elm = attr->u.convert.convert_local(msg, attr->u.convert.remote_name, &mo->elements[i]); ldb_msg_add(module->ldb, msg, elm, elm->flags); break; -- cgit From 95ed275dbbff7c1e3a58a3d0c5408087ef9a0432 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 27 Aug 2005 23:47:17 +0000 Subject: r9698: Fix a bit of memory management More minor bugfixes Support mapping objectclasses and do mapping on 'dn' field as well (not just msg->dn) (This used to be commit b7b079167d5c6616f7c5c4afb7dd80c15707cfd9) --- source4/lib/ldb/ldb_map/ldb_map.c | 442 ++++++++++++++++++++++++++------------ 1 file changed, 305 insertions(+), 137 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index d2bbea7c7a..5ae4a435d8 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -31,21 +31,24 @@ * - objectclass hint in ldb_map_attribute * for use when multiple remote attributes (independant of each other) * map to one local attribute. E.g.: (uid, gidNumber) -> unixName + * (use MAP_GENERATE instead ?) */ +static const struct ldb_map_attribute builtin_attribute_maps[]; + struct map_private { - const struct ldb_map_attribute *attribute_maps; - const struct ldb_map_objectclass *objectclass_maps; + struct ldb_map_context context; const char *last_err_string; }; + /* find an attribute by the local name */ -static const struct ldb_map_attribute *map_find_attr_local(struct ldb_module *module, const char *attr) +static const struct ldb_map_attribute *map_find_attr_local(struct ldb_map_context *privdat, const char *attr) { - struct map_private *privdat = module->private_data; int i; + for (i = 0; privdat->attribute_maps[i].local_name; i++) { - if (!strcmp(privdat->attribute_maps[i].local_name, attr)) + if (!ldb_attr_cmp(privdat->attribute_maps[i].local_name, attr)) return &privdat->attribute_maps[i]; } @@ -53,17 +56,26 @@ static const struct ldb_map_attribute *map_find_attr_local(struct ldb_module *mo } /* find an attribute by the remote name */ -static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_module *module, const char *attr) +static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_map_context *privdat, const char *attr) { - struct map_private *privdat = module->private_data; int i; + for (i = 0; privdat->attribute_maps[i].local_name; i++) { - if (privdat->attribute_maps[i].type != MAP_RENAME && - privdat->attribute_maps[i].type != MAP_CONVERT) + if (privdat->attribute_maps[i].type == MAP_IGNORE) + continue; + + if (privdat->attribute_maps[i].type == MAP_GENERATE) continue; - if (!strcmp(privdat->attribute_maps[i].u.rename.remote_name, attr)) + if (privdat->attribute_maps[i].type == MAP_KEEP && + ldb_attr_cmp(privdat->attribute_maps[i].local_name, attr) == 0) return &privdat->attribute_maps[i]; + + if ((privdat->attribute_maps[i].type == MAP_RENAME || + privdat->attribute_maps[i].type == MAP_CONVERT) && + ldb_attr_cmp(privdat->attribute_maps[i].u.rename.remote_name, attr) == 0) + return &privdat->attribute_maps[i]; + } return NULL; @@ -74,11 +86,13 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL int i; const struct ldb_map_attribute *attr; struct ldb_parse_tree *new_tree; + enum ldb_map_attr_type map_type; + struct ldb_val value, newvalue; + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; if (tree == NULL) return NULL; - new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); /* Find attr in question and: * - if it has a convert_operator function, run that @@ -86,6 +100,8 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL if (tree->operation == LDB_OP_AND || tree->operation == LDB_OP_OR) { + + new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); new_tree->u.list.elements = talloc_array(new_tree, struct ldb_parse_tree *, tree->u.list.num_elements); for (i = 0; i < new_tree->u.list.num_elements; i++) { new_tree->u.list.elements[i] = ldb_map_parse_tree(module, new_tree, tree->u.list.elements[i]); @@ -95,6 +111,7 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL } if (tree->operation == LDB_OP_NOT) { + new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); new_tree->u.isnot.child = ldb_map_parse_tree(module, new_tree, tree->u.isnot.child); return new_tree; } @@ -105,47 +122,74 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL * (all have attr as the first element) */ - if (new_tree->operation == LDB_OP_EQUALITY) { - new_tree->u.equality.value = ldb_val_dup(new_tree, &tree->u.equality.value); - } else if (new_tree->operation == LDB_OP_SUBSTRING) { - new_tree->u.substring.chunks = NULL; /* FIXME! */ - } else if (new_tree->operation == LDB_OP_LESS || - new_tree->operation == LDB_OP_GREATER || - new_tree->operation == LDB_OP_APPROX) { - new_tree->u.comparison.value = ldb_val_dup(new_tree, &tree->u.comparison.value); - } else if (new_tree->operation == LDB_OP_EXTENDED) { - new_tree->u.extended.value = ldb_val_dup(new_tree, &tree->u.extended.value); - new_tree->u.extended.rule_id = talloc_strdup(new_tree, tree->u.extended.rule_id); - } - - attr = map_find_attr_local(module, tree->u.equality.attr); + attr = map_find_attr_local(privdat, tree->u.equality.attr); - if (!attr || attr->type == MAP_KEEP) { + if (!attr) { DEBUG(0, ("Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr)); - new_tree->u.equality.attr = talloc_strdup(new_tree, tree->u.equality.attr); - return new_tree; + map_type = MAP_KEEP; + } else { + map_type = attr->type; } - if (attr->type == MAP_IGNORE) { - talloc_free(new_tree); + if (attr && attr->convert_operator) { + /* Run convert_operator */ + return attr->convert_operator(privdat, module, tree); + } + + if (map_type == MAP_IGNORE) + return NULL; + + if (map_type == MAP_GENERATE) { + DEBUG(0, ("Can't do conversion for MAP_GENERATE in map_parse_tree without convert_operator for '%s'\n", tree->u.equality.attr)); return NULL; } - if (attr->convert_operator) { - /* Run convert_operator */ - talloc_free(new_tree); - new_tree = attr->convert_operator(module, tree); + if (tree->operation == LDB_OP_EQUALITY) { + value = tree->u.equality.value; + } else if (tree->operation == LDB_OP_LESS || tree->operation == LDB_OP_GREATER || + tree->operation == LDB_OP_APPROX) { + value = tree->u.comparison.value; + } else if (tree->operation == LDB_OP_EXTENDED) { + value = tree->u.extended.value; + } + + new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); + if (map_type == MAP_KEEP) { + new_tree->u.equality.attr = talloc_strdup(new_tree, tree->u.equality.attr); + } else { /* MAP_RENAME / MAP_CONVERT */ + new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name); + } + + if (new_tree->operation == LDB_OP_PRESENT) + return new_tree; + + if (new_tree->operation == LDB_OP_SUBSTRING) { + new_tree->u.substring.chunks = NULL; /* FIXME! */ return new_tree; + } + + if (map_type == MAP_CONVERT) { + newvalue = attr->u.convert.convert_local(privdat, new_tree, &value); } else { - new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name); + newvalue = ldb_val_dup(new_tree, &value); + } + + if (new_tree->operation == LDB_OP_EQUALITY) { + new_tree->u.equality.value = newvalue; + } else if (new_tree->operation == LDB_OP_LESS || new_tree->operation == LDB_OP_GREATER || + new_tree->operation == LDB_OP_APPROX) { + new_tree->u.comparison.value = newvalue; + } else if (new_tree->operation == LDB_OP_EXTENDED) { + new_tree->u.extended.value = newvalue; + new_tree->u.extended.rule_id = talloc_strdup(new_tree, tree->u.extended.rule_id); } return new_tree; } /* Remote DN -> Local DN */ -static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_dn *dn) +static struct ldb_dn *map_remote_dn(struct ldb_map_context *privdat, TALLOC_CTX *ctx, const struct ldb_dn *dn) { struct ldb_dn *newdn; int i; @@ -153,7 +197,7 @@ static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_ if (dn == NULL) return NULL; - newdn = talloc_memdup(module, dn, sizeof(*dn)); + newdn = talloc_memdup(ctx, dn, sizeof(*dn)); if (!newdn) return NULL; @@ -166,49 +210,49 @@ static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_ * complete rdn */ for (i = 0; i < dn->comp_num; i++) { - const struct ldb_map_attribute *attr = map_find_attr_remote(module, dn->components[i].name); + const struct ldb_map_attribute *attr = map_find_attr_remote(privdat, dn->components[i].name); + enum ldb_map_attr_type map_type; /* Unknown attribute - leave this dn as is and hope the best... */ - if (!attr || attr->type == MAP_KEEP) { - newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); - newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); - } else if (attr->type == MAP_IGNORE || attr->type == MAP_GENERATE) { + if (!attr) map_type = MAP_KEEP; + else map_type = attr->type; + + switch (map_type) { + case MAP_IGNORE: + case MAP_GENERATE: DEBUG(0, ("Local MAP_IGNORE or MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); talloc_free(newdn); return NULL; - } else if (attr->type == MAP_CONVERT) { - struct ldb_message_element elm, *newelm; - struct ldb_val vals[1] = { dn->components[i].value }; - - elm.flags = 0; - elm.name = attr->u.convert.remote_name; - elm.num_values = 1; - elm.values = vals; - - newelm = attr->u.convert.convert_remote(module, attr->local_name, &elm); - - newdn->components[i].name = talloc_strdup(newdn->components, newelm->name); - newdn->components[i].value = ldb_val_dup(newdn->components, &newelm->values[0]); - talloc_free(newelm); - } else if (attr->type == MAP_RENAME) { + case MAP_KEEP: + newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); + newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); + break; + + case MAP_CONVERT: + newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name); + newdn->components[i].value = attr->u.convert.convert_remote(privdat, ctx, &dn->components[i].value); + break; + + case MAP_RENAME: newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name); newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); + break; } } return newdn; } /* Local DN -> Remote DN */ -static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_dn *dn) -{ struct ldb_dn *newdn; +static struct ldb_dn *map_local_dn(struct ldb_map_context *privdat, TALLOC_CTX *ctx, const struct ldb_dn *dn) +{ + struct ldb_dn *newdn; int i; - struct ldb_parse_tree eqtree, *new_eqtree; if (dn == NULL) return NULL; - newdn = talloc_memdup(module, dn, sizeof(*dn)); + newdn = talloc_memdup(ctx, dn, sizeof(*dn)); if (!newdn) return NULL; @@ -221,55 +265,34 @@ static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_d * complete rdn using an equality convert_operator call */ for (i = 0; i < dn->comp_num; i++) { - const struct ldb_map_attribute *attr = map_find_attr_local(module, dn->components[i].name); + const struct ldb_map_attribute *attr = map_find_attr_local(privdat, dn->components[i].name); + enum ldb_map_attr_type map_type; /* Unknown attribute - leave this dn as is and hope the best... */ - if (!attr || attr->type == MAP_KEEP) { - newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); - newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); - continue; - } else if (attr->type == MAP_IGNORE || attr->type == MAP_GENERATE) { + if (!attr) map_type = MAP_KEEP; else map_type = attr->type; + + switch (map_type) + { + case MAP_IGNORE: + case MAP_GENERATE: DEBUG(0, ("Local MAP_IGNORE/MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); talloc_free(newdn); return NULL; - } - - /* Simple rename/convert only */ - if (attr->convert_operator) { - /* Fancy stuff */ - eqtree.operation = LDB_OP_EQUALITY; - eqtree.u.equality.attr = dn->components[i].name; - eqtree.u.equality.value = dn->components[i].value; - new_eqtree = ldb_map_parse_tree(module, newdn, &eqtree); - - /* Silently continue for now */ - if (!new_eqtree) { - DEBUG(0, ("Unable to convert RDN for attribute %s\n", dn->components[i].name)); - continue; - } - - newdn->components[i].name = talloc_strdup(newdn->components, new_eqtree->u.equality.attr); - newdn->components[i].value = ldb_val_dup(newdn->components, &new_eqtree->u.equality.value); - - talloc_free(new_eqtree); - } else if (attr->type == MAP_CONVERT) { - struct ldb_message_element elm, *newelm; - struct ldb_val vals[1] = { dn->components[i].value }; - elm.flags = 0; - elm.name = attr->local_name; - elm.num_values = 1; - elm.values = vals; - - newelm = attr->u.convert.convert_local(module, attr->u.convert.remote_name, &elm); - - newdn->components[i].name = talloc_strdup(newdn->components, newelm->name); - newdn->components[i].value = ldb_val_dup(newdn->components, &newelm->values[0]); + case MAP_CONVERT: + newdn->components[i].name = talloc_strdup(newdn->components, attr->u.convert.remote_name); + newdn->components[i].value = attr->u.convert.convert_local(privdat, newdn->components, &dn->components[i].value); + break; + + case MAP_RENAME: + newdn->components[i].name = talloc_strdup(newdn->components, attr->u.rename.remote_name); + newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); + break; - talloc_free(newelm); - } else if (attr->type == MAP_RENAME) { - newdn->components[i].name = talloc_strdup(newdn->components, attr->u.rename.remote_name); - newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); + case MAP_KEEP: + newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); + newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); + continue; } } @@ -282,6 +305,7 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a int i; const char **ret; int ar_size = 0, last_element = 0; + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; if (attrs == NULL) return NULL; @@ -294,14 +318,15 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a for (i = 0; attrs[i]; i++) { int j; - const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]); + const struct ldb_map_attribute *attr = map_find_attr_local(privdat, attrs[i]); + enum ldb_map_attr_type map_type; if (!attr) { DEBUG(0, ("Local attribute '%s' does not have a definition!\n", attrs[i])); - continue; - } + map_type = MAP_IGNORE; + } else map_type = attr->type; - switch (attr->type) + switch (map_type) { case MAP_IGNORE: break; case MAP_KEEP: @@ -337,22 +362,29 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a break; } } + + if (last_element >= ar_size) { + ret = talloc_realloc(module, ret, const char *, ar_size+1); + ar_size++; + } - return NULL; + ret[last_element] = NULL; + + return ret; } static const char **available_local_attributes(struct ldb_module *module, const struct ldb_message *msg) { - struct map_private *map = module->private_data; + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; int i, j; int count = 0; const char **ret = talloc_array(module, const char *, 1); ret[0] = NULL; - for (i = 0; map->attribute_maps[i].local_name; i++) { + for (i = 0; privdat->attribute_maps[i].local_name; i++) { BOOL avail = False; - const struct ldb_map_attribute *attr = &map->attribute_maps[i]; + const struct ldb_map_attribute *attr = &privdat->attribute_maps[i]; /* If all remote attributes for this attribute are present, add the * local one to the list */ @@ -391,12 +423,13 @@ static const char **available_local_attributes(struct ldb_module *module, const /* Used for search */ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi) { - int i; + int i, j; struct ldb_message *msg = talloc_zero(module, struct ldb_message); struct ldb_message_element *elm, *oldelm; + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; const char **newattrs = NULL; - msg->dn = map_remote_dn(module, mi->dn); + msg->dn = map_remote_dn(privdat, module, mi->dn); /* Loop over attrs, find in ldb_map_attribute array and * run generate() */ @@ -409,14 +442,15 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c } for (i = 0; attrs[i]; i++) { - const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]); + const struct ldb_map_attribute *attr = map_find_attr_local(privdat, attrs[i]); + enum ldb_map_attr_type map_type; if (!attr) { DEBUG(0, ("Unable to find local attribute '%s' when generating incoming message\n", attrs[i])); - continue; - } + map_type = MAP_IGNORE; + } else map_type = attr->type; - switch (attr->type) { + switch (map_type) { case MAP_IGNORE:break; case MAP_RENAME: oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); @@ -434,10 +468,15 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); if (!oldelm) continue; - elm = attr->u.convert.convert_remote(msg, attr->local_name, oldelm); - if (!elm) continue; + elm = talloc(msg, struct ldb_message_element); + elm->name = talloc_strdup(elm, attr->local_name); + elm->num_values = oldelm->num_values; + elm->values = talloc_array(elm, struct ldb_val, elm->num_values); - ldb_msg_add(module->ldb, msg, elm, elm->flags); + for (j = 0; j < oldelm->num_values; j++) + elm->values[j] = attr->u.convert.convert_remote(privdat, elm, &oldelm->values[j]); + + ldb_msg_add(module->ldb, msg, elm, oldelm->flags); break; case MAP_KEEP: @@ -454,7 +493,7 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c break; case MAP_GENERATE: - elm = attr->u.generate.generate_local(msg, attr->local_name, mi); + elm = attr->u.generate.generate_local(privdat, msg, attr->local_name, mi); if (!elm) continue; ldb_msg_add(module->ldb, msg, elm, elm->flags); @@ -473,24 +512,27 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c /* Used for add, modify */ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo) { + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; struct ldb_message *msg = talloc_zero(module, struct ldb_message); struct ldb_message_element *elm; - int i; + int i,j; msg->private_data = mo->private_data; - msg->dn = map_local_dn(module, mo->dn); + msg->dn = map_local_dn(privdat, module, mo->dn); /* Loop over mi and call generate_remote for each attribute */ for (i = 0; i < mo->num_elements; i++) { - const struct ldb_map_attribute *attr = map_find_attr_local(module, mo->elements[i].name); + const struct ldb_map_attribute *attr = map_find_attr_local(privdat, mo->elements[i].name); + enum ldb_map_attr_type map_type; if (!attr) { DEBUG(0, ("Undefined local attribute '%s', ignoring\n", mo->elements[i].name)); + map_type = MAP_IGNORE; continue; - } + } else map_type = attr->type; - switch (attr->type) { + switch (map_type) { case MAP_IGNORE: break; case MAP_RENAME: elm = talloc(msg, struct ldb_message_element); @@ -503,8 +545,17 @@ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, c break; case MAP_CONVERT: - elm = attr->u.convert.convert_local(msg, attr->u.convert.remote_name, &mo->elements[i]); - ldb_msg_add(module->ldb, msg, elm, elm->flags); + elm = talloc(msg, struct ldb_message_element); + + elm->name = talloc_strdup(elm, attr->u.rename.remote_name); + elm->num_values = mo->elements[i].num_values; + elm->values = talloc_array(elm, struct ldb_val, elm->num_values); + + for (j = 0; j < elm->num_values; j++) { + elm->values[j] = attr->u.convert.convert_local(privdat, msg, &mo->elements[i].values[j]); + } + + ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags); break; case MAP_KEEP: @@ -518,7 +569,7 @@ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, c break; case MAP_GENERATE: - attr->u.generate.generate_remote(attr->local_name, mo, msg); + attr->u.generate.generate_remote(privdat, attr->local_name, mo, msg); break; } } @@ -531,11 +582,12 @@ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, c */ static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn) { + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; struct ldb_dn *n_olddn, *n_newdn; int ret; - n_olddn = map_local_dn(module, olddn); - n_newdn = map_local_dn(module, newdn); + n_olddn = map_local_dn(privdat, module, olddn); + n_newdn = map_local_dn(privdat, module, newdn); ret = ldb_next_rename_record(module, n_olddn, n_newdn); @@ -550,10 +602,11 @@ static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, con */ static int map_delete(struct ldb_module *module, const struct ldb_dn *dn) { + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; struct ldb_dn *newdn; int ret; - newdn = map_local_dn(module, dn); + newdn = map_local_dn(privdat, module, dn); ret = ldb_next_delete_record(module, newdn); @@ -574,11 +627,12 @@ static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *bas struct ldb_parse_tree *new_tree; struct ldb_dn *new_base; struct ldb_message **newres; + struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; int i; new_tree = ldb_map_parse_tree(module, module, tree); newattrs = ldb_map_attrs(module, attrs); - new_base = map_local_dn(module, base); + new_base = map_local_dn(privdat, module, base); ret = ldb_next_search_bytree(module, new_base, scope, new_tree, newattrs, &newres); @@ -633,8 +687,6 @@ static int map_add(struct ldb_module *module, const struct ldb_message *msg) } - - /* modify a record */ @@ -689,6 +741,7 @@ static const struct ldb_module_ops map_ops = { /* the init function */ struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_attribute *attrs, const struct ldb_map_objectclass *ocls, const char *options[]) { + int i, j; struct ldb_module *ctx; struct map_private *data; @@ -704,8 +757,26 @@ struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_at data->last_err_string = NULL; - data->attribute_maps = attrs; - data->objectclass_maps = ocls; + /* Get list of attribute maps */ + j = 0; + data->context.attribute_maps = NULL; + + for (i = 0; attrs[i].local_name; i++) { + data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1); + data->context.attribute_maps[j] = attrs[i]; + j++; + } + + for (i = 0; builtin_attribute_maps[i].local_name; i++) { + data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1); + data->context.attribute_maps[j] = builtin_attribute_maps[i]; + j++; + } + + data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1); + ZERO_STRUCT(data->context.attribute_maps[j].local_name); + + data->context.objectclass_maps = ocls; ctx->private_data = data; ctx->ldb = ldb; ctx->prev = ctx->next = NULL; @@ -713,3 +784,100 @@ struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_at return ctx; } + +static struct ldb_val map_convert_local_dn(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) +{ + struct ldb_dn *dn, *newdn;; + struct ldb_val *newval; + + dn = ldb_dn_explode(ctx, (char *)val->data); + + newdn = map_local_dn(map, ctx, dn); + + talloc_free(dn); + + newval = talloc(ctx, struct ldb_val); + newval->data = (uint8_t *)ldb_dn_linearize(ctx, newdn); + newval->length = strlen((char *)newval->data); + + talloc_free(newdn); + + return *newval; +} + +static struct ldb_val map_convert_remote_dn(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) +{ + struct ldb_dn *dn, *newdn;; + struct ldb_val *newval; + + dn = ldb_dn_explode(ctx, (char *)val->data); + + newdn = map_remote_dn(map, ctx, dn); + + talloc_free(dn); + + newval = talloc(ctx, struct ldb_val); + newval->data = (uint8_t *)ldb_dn_linearize(ctx, newdn); + newval->length = strlen((char *)newval->data); + + talloc_free(newdn); + + return *newval; +} + +static struct ldb_val map_convert_local_objectclass(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) +{ + int i; + + for (i = 0; map->objectclass_maps[i].local_name; i++) { + if (!strcmp(map->objectclass_maps[i].local_name, (char *)val->data)) { + struct ldb_val newval; + newval.data = (uint8_t*)talloc_strdup(ctx, map->objectclass_maps[i].remote_name); + newval.length = strlen((char *)newval.data); + + return ldb_val_dup(ctx, &newval); + } + } + + DEBUG(1, ("Unable to map local object class '%s'\n", (char *)val->data)); + return ldb_val_dup(ctx, val); +} + +static struct ldb_val map_convert_remote_objectclass(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) +{ + int i; + + for (i = 0; map->objectclass_maps[i].remote_name; i++) { + if (!strcmp(map->objectclass_maps[i].remote_name, (char *)val->data)) { + struct ldb_val newval; + newval.data = (uint8_t*)talloc_strdup(ctx, map->objectclass_maps[i].local_name); + newval.length = strlen((char *)newval.data); + + return ldb_val_dup(ctx, &newval); + } + } + + DEBUG(1, ("Unable to map remote object class '%s'\n", (char *)val->data)); + return ldb_val_dup(ctx, val); +} + +static const struct ldb_map_attribute builtin_attribute_maps[] = { + { + .local_name = "dn", + .type = MAP_CONVERT, + .u.convert.remote_name = "dn", + .u.convert.convert_local = map_convert_local_dn, + .u.convert.convert_remote = map_convert_remote_dn, + }, + { + .local_name = "objectclass", + .type = MAP_CONVERT, + .u.convert.remote_name = "objectclass", + .u.convert.convert_local = map_convert_local_objectclass, + .u.convert.convert_remote = map_convert_remote_objectclass, + }, + { + .local_name = NULL, + } +}; + -- cgit From d6cd54fb0a1c3ac51479d1fdcff91893c27ef9d7 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 28 Aug 2005 22:17:07 +0000 Subject: r9718: Work a bit on the SWAT interface (This used to be commit b1844905d2c1ca26aef0ccba799ff16383348fc1) --- source4/lib/ldb/ldb_map/ldb_map.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 5ae4a435d8..1a8ea2afc4 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -136,8 +136,10 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL return attr->convert_operator(privdat, module, tree); } - if (map_type == MAP_IGNORE) + if (map_type == MAP_IGNORE) { + DEBUG(0, ("Search on ignored attribute '%s'!\n", tree->u.equality.attr)); return NULL; + } if (map_type == MAP_GENERATE) { DEBUG(0, ("Can't do conversion for MAP_GENERATE in map_parse_tree without convert_operator for '%s'\n", tree->u.equality.attr)); -- cgit From 0a72d9a5f7c8705a68b03e2f391603252d896342 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 29 Aug 2005 15:54:10 +0000 Subject: r9744: - [upgrade.js] Start working on smb.conf conversion. - [ldb_map] Support storing non-mappable data in a fallback LDB (This used to be commit 435e4c6389b9d9b545beec8036289620ee5883db) --- source4/lib/ldb/ldb_map/ldb_map.c | 315 +++++++++++++++++++++++++++++++++----- 1 file changed, 273 insertions(+), 42 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 1a8ea2afc4..79d3c26f90 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -34,6 +34,22 @@ * (use MAP_GENERATE instead ?) */ +/* + - special attribute 'isMapped' + - add/modify + - split up ldb_message into fallback and mapped parts if is_mappable + - search: + - search local one for not isMapped entries + - remove remote attributes from ldb_parse_tree + - search remote one + - per record, search local one for additional data (by dn) + - test if (full expression) is now true + - delete + - delete both + - rename + - rename locally and remotely +*/ + static const struct ldb_map_attribute builtin_attribute_maps[]; struct map_private { @@ -41,6 +57,16 @@ struct map_private { const char *last_err_string; }; +static struct ldb_map_context *map_get_privdat(struct ldb_module *module) +{ + return &((struct map_private *)module->private_data)->context; +} + +static BOOL map_is_mappable(struct ldb_map_context *privdat, const struct ldb_message *msg) +{ + /* FIXME */ + return True; +} /* find an attribute by the local name */ static const struct ldb_map_attribute *map_find_attr_local(struct ldb_map_context *privdat, const char *attr) @@ -88,7 +114,7 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL struct ldb_parse_tree *new_tree; enum ldb_map_attr_type map_type; struct ldb_val value, newvalue; - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + struct ldb_map_context *privdat = map_get_privdat(module); if (tree == NULL) return NULL; @@ -103,16 +129,31 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); new_tree->u.list.elements = talloc_array(new_tree, struct ldb_parse_tree *, tree->u.list.num_elements); - for (i = 0; i < new_tree->u.list.num_elements; i++) { - new_tree->u.list.elements[i] = ldb_map_parse_tree(module, new_tree, tree->u.list.elements[i]); + new_tree->u.list.num_elements = 0; + for (i = 0; i < tree->u.list.num_elements; i++) { + struct ldb_parse_tree *child = ldb_map_parse_tree(module, new_tree, tree->u.list.elements[i]); + + if (child) { + new_tree->u.list.elements[i] = child; + new_tree->u.list.num_elements++; + } } return new_tree; } if (tree->operation == LDB_OP_NOT) { + struct ldb_parse_tree *child; + new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); - new_tree->u.isnot.child = ldb_map_parse_tree(module, new_tree, tree->u.isnot.child); + child = ldb_map_parse_tree(module, new_tree, tree->u.isnot.child); + + if (!child) { + talloc_free(new_tree); + return NULL; + } + + new_tree->u.isnot.child = child; return new_tree; } @@ -125,7 +166,7 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL attr = map_find_attr_local(privdat, tree->u.equality.attr); if (!attr) { - DEBUG(0, ("Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr)); + ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr); map_type = MAP_KEEP; } else { map_type = attr->type; @@ -137,12 +178,12 @@ static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALL } if (map_type == MAP_IGNORE) { - DEBUG(0, ("Search on ignored attribute '%s'!\n", tree->u.equality.attr)); + ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Search on ignored attribute '%s'\n", tree->u.equality.attr); return NULL; } if (map_type == MAP_GENERATE) { - DEBUG(0, ("Can't do conversion for MAP_GENERATE in map_parse_tree without convert_operator for '%s'\n", tree->u.equality.attr)); + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Can't do conversion for MAP_GENERATE in map_parse_tree without convert_operator for '%s'\n", tree->u.equality.attr); return NULL; } @@ -307,7 +348,7 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a int i; const char **ret; int ar_size = 0, last_element = 0; - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + struct ldb_map_context *privdat = map_get_privdat(module); if (attrs == NULL) return NULL; @@ -324,7 +365,7 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a enum ldb_map_attr_type map_type; if (!attr) { - DEBUG(0, ("Local attribute '%s' does not have a definition!\n", attrs[i])); + ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Local attribute '%s' does not have a definition!\n", attrs[i]); map_type = MAP_IGNORE; } else map_type = attr->type; @@ -377,7 +418,7 @@ static const char **ldb_map_attrs(struct ldb_module *module, const char *const a static const char **available_local_attributes(struct ldb_module *module, const struct ldb_message *msg) { - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + struct ldb_map_context *privdat = map_get_privdat(module); int i, j; int count = 0; const char **ret = talloc_array(module, const char *, 1); @@ -428,11 +469,13 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c int i, j; struct ldb_message *msg = talloc_zero(module, struct ldb_message); struct ldb_message_element *elm, *oldelm; - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + struct ldb_map_context *privdat = map_get_privdat(module); const char **newattrs = NULL; msg->dn = map_remote_dn(privdat, module, mi->dn); + ldb_msg_add_string(module->ldb, msg, "mappedFromDn", ldb_dn_linearize(msg, mi->dn)); + /* Loop over attrs, find in ldb_map_attribute array and * run generate() */ @@ -448,7 +491,7 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c enum ldb_map_attr_type map_type; if (!attr) { - DEBUG(0, ("Unable to find local attribute '%s' when generating incoming message\n", attrs[i])); + ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Unable to find local attribute '%s' when generating incoming message\n", attrs[i]); map_type = MAP_IGNORE; } else map_type = attr->type; @@ -501,7 +544,7 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c ldb_msg_add(module->ldb, msg, elm, elm->flags); break; default: - DEBUG(0, ("Unknown attr->type for %s", attr->local_name)); + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Unknown attr->type for %s", attr->local_name); break; } } @@ -512,13 +555,18 @@ static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, c } /* Used for add, modify */ -static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo) +static int ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo, struct ldb_message **fb, struct ldb_message **mp) { - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + struct ldb_map_context *privdat = map_get_privdat(module); struct ldb_message *msg = talloc_zero(module, struct ldb_message); struct ldb_message_element *elm; int i,j; - + + *fb = talloc_zero(module, struct ldb_message); + (*fb)->dn = talloc_reference(*fb, mo->dn); + + *mp = msg; + msg->private_data = mo->private_data; msg->dn = map_local_dn(privdat, module, mo->dn); @@ -529,13 +577,21 @@ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, c enum ldb_map_attr_type map_type; if (!attr) { - DEBUG(0, ("Undefined local attribute '%s', ignoring\n", mo->elements[i].name)); + ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Undefined local attribute '%s', ignoring\n", mo->elements[i].name); map_type = MAP_IGNORE; continue; } else map_type = attr->type; switch (map_type) { - case MAP_IGNORE: break; + case MAP_IGNORE: /* Add to fallback message */ + elm = talloc(*fb, struct ldb_message_element); + + elm->num_values = mo->elements[i].num_values; + elm->values = talloc_reference(elm, mo->elements[i].values); + elm->name = talloc_strdup(elm, mo->elements[i].name); + + ldb_msg_add(module->ldb, *fb, elm, mo->elements[i].flags); + break; case MAP_RENAME: elm = talloc(msg, struct ldb_message_element); @@ -576,22 +632,25 @@ static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, c } } - return msg; + return 0; } + /* rename a record */ static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn) { - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + struct ldb_map_context *privdat = map_get_privdat(module); struct ldb_dn *n_olddn, *n_newdn; int ret; + + ret = ldb_next_rename_record(module, olddn, newdn); n_olddn = map_local_dn(privdat, module, olddn); n_newdn = map_local_dn(privdat, module, newdn); - ret = ldb_next_rename_record(module, n_olddn, n_newdn); + ret = ldb_rename(privdat->mapped_ldb, n_olddn, n_newdn); talloc_free(n_olddn); talloc_free(n_newdn); @@ -604,53 +663,149 @@ static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, con */ static int map_delete(struct ldb_module *module, const struct ldb_dn *dn) { - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + struct ldb_map_context *privdat = map_get_privdat(module); struct ldb_dn *newdn; int ret; + ret = ldb_next_delete_record(module, dn); + newdn = map_local_dn(privdat, module, dn); - ret = ldb_next_delete_record(module, newdn); + ret = ldb_delete(privdat->mapped_ldb, newdn); talloc_free(newdn); return ret; } -/* - search for matching records using a ldb_parse_tree -*/ -static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base, +/* search fallback database */ +static int map_search_bytree_fb(struct ldb_module *module, const struct ldb_dn *base, enum ldb_scope scope, struct ldb_parse_tree *tree, const char * const *attrs, struct ldb_message ***res) { int ret; - const char **newattrs; + struct ldb_parse_tree t_and, t_not, t_present, *childs[2]; + + t_present.operation = LDB_OP_PRESENT; + t_present.u.present.attr = talloc_strdup(NULL, "isMapped"); + + t_not.operation = LDB_OP_NOT; + t_not.u.isnot.child = &t_present; + + childs[0] = &t_not; + childs[1] = tree; + t_and.operation = LDB_OP_AND; + t_and.u.list.num_elements = 2; + t_and.u.list.elements = childs; + + ret = ldb_next_search_bytree(module, base, scope, &t_and, attrs, res); + + talloc_free(t_present.u.present.attr); + + return ret; +} + +static int map_search_bytree_mp(struct ldb_module *module, const struct ldb_dn *base, + enum ldb_scope scope, struct ldb_parse_tree *tree, + const char * const *attrs, struct ldb_message ***res) +{ struct ldb_parse_tree *new_tree; struct ldb_dn *new_base; struct ldb_message **newres; - struct ldb_map_context *privdat = &((struct map_private *)module->private_data)->context; + const char **newattrs; + int mpret, ret; + struct ldb_map_context *privdat = map_get_privdat(module); int i; + /*- search mapped database */ + new_tree = ldb_map_parse_tree(module, module, tree); newattrs = ldb_map_attrs(module, attrs); new_base = map_local_dn(privdat, module, base); - ret = ldb_next_search_bytree(module, new_base, scope, new_tree, newattrs, &newres); + mpret = ldb_search_bytree(privdat->mapped_ldb, new_base, scope, new_tree, newattrs, &newres); talloc_free(new_base); talloc_free(new_tree); talloc_free(newattrs); - *res = talloc_array(module, struct ldb_message *, ret); + /* + - per returned record, search local one for additional data (by dn) + - test if (full expression) is now true + */ + + + *res = talloc_array(module, struct ldb_message *, mpret); - for (i = 0; i < ret; i++) { - (*res)[i] = ldb_map_message_incoming(module, attrs, newres[i]); + ret = 0; + + for (i = 0; i < mpret; i++) { + struct ldb_message *merged = ldb_map_message_incoming(module, attrs, newres[i]); + struct ldb_message **extrares = NULL; + int extraret; + + /* Merge with additional data from local database */ + extraret = ldb_next_search(module, merged->dn, LDB_SCOPE_ONELEVEL, "", NULL, &extrares); + + if (extraret > 1) { + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "More then one result for extra data!\n"); + return -1; + } else if (extraret == 1) { + int j; + ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Extra data found for remote DN"); + for (j = 0; j < merged->num_elements; j++) { + ldb_msg_add(module->ldb, merged, &extrares[0]->elements[j], extrares[0]->elements[j].flags); + } + } else { + ldb_debug(module->ldb, LDB_DEBUG_TRACE, "No extra data found for remote DN"); + } + + talloc_free(extrares); + + if (ldb_match_msg(module->ldb, merged, tree, base, scope)) { + (*res)[ret] = merged; + ret++; + } else { + ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Discarded merged message because it did not match"); + } + talloc_free(newres[i]); } return ret; } + + +/* + search for matching records using a ldb_parse_tree +*/ +static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base, + enum ldb_scope scope, struct ldb_parse_tree *tree, + const char * const *attrs, struct ldb_message ***res) +{ + int ret; + struct ldb_message **fbres, **mpres; + int i; + int ret_fb, ret_mp; + + ret_fb = map_search_bytree_fb(module, base, scope, tree, attrs, &fbres); + if (ret_fb == -1) + return -1; + + ret_mp = map_search_bytree_mp(module, base, scope, tree, attrs, &mpres); + if (ret_mp == -1) + return -1; + + /* Merge results */ + *res = talloc_array(module, struct ldb_message *, ret_fb + ret_mp); + + for (i = 0; i < ret_fb; i++) (*res)[i] = fbres[i]; + for (i = 0; i < ret_mp; i++) (*res)[ret_fb+i] = mpres[i]; + + return ret_fb + ret_mp; + + return ret; +} /* search for matching records */ @@ -678,12 +833,33 @@ static int map_search(struct ldb_module *module, const struct ldb_dn *base, */ static int map_add(struct ldb_module *module, const struct ldb_message *msg) { - struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg); int ret; + struct ldb_map_context *privdat = map_get_privdat(module); + struct ldb_message *fb, *mp; - ret = ldb_next_add_record(module, nmsg); + if (!map_is_mappable(privdat, msg)) { + return ldb_next_add_record(module, msg); + } - talloc_free(nmsg); + if (ldb_map_message_outgoing(module, msg, &fb, &mp) == -1) + return -1; + + ldb_msg_add_string(module->ldb, fb, "isMapped", "TRUE"); + + ret = ldb_next_add_record(module, fb); + if (ret == -1) { + ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Adding fallback record failed"); + return -1; + } + + ret = ldb_add(privdat->mapped_ldb, mp); + if (ret == -1) { + ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Adding mapped record failed"); + return -1; + } + + talloc_free(fb); + talloc_free(mp); return ret; } @@ -694,12 +870,25 @@ static int map_add(struct ldb_module *module, const struct ldb_message *msg) */ static int map_modify(struct ldb_module *module, const struct ldb_message *msg) { - struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg); + struct ldb_map_context *privdat = map_get_privdat(module); + struct ldb_message *fb, *mp; int ret; - ret = ldb_next_modify_record(module, nmsg); + if (!map_is_mappable(privdat, msg)) + return ldb_next_modify_record(module, msg); + + + if (ldb_map_message_outgoing(module, msg, &fb, &mp) == -1) + return -1; + + ldb_msg_add_string(module->ldb, fb, "isMapped", "TRUE"); + + ret = ldb_next_modify_record(module, fb); + + ret = ldb_modify(privdat->mapped_ldb, mp); - talloc_free(nmsg); + talloc_free(fb); + talloc_free(mp); return ret; } @@ -740,12 +929,41 @@ static const struct ldb_module_ops map_ops = { .errstring = map_errstring }; +static char *map_find_url(struct ldb_context *ldb, const char *name) +{ + const char * const attrs[] = { "@MAP_URL" , NULL}; + struct ldb_message **msg = NULL; + struct ldb_dn *mods; + char *url; + int ret; + + mods = ldb_dn_string_compose(ldb, NULL, "@MAP=%s", name); + if (mods == NULL) { + ldb_debug(ldb, LDB_DEBUG_ERROR, "Can't construct DN"); + return NULL; + } + + ret = ldb_search(ldb, mods, LDB_SCOPE_BASE, "", attrs, &msg); + talloc_free(mods); + if (ret < 1) { + ldb_debug(ldb, LDB_DEBUG_ERROR, "Not enough results found looking for @MAP"); + return NULL; + } + + url = talloc_strdup(ldb, ldb_msg_find_string(msg[0], "@MAP_URL", NULL)); + + talloc_free(msg); + + return url; +} + /* the init function */ -struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_attribute *attrs, const struct ldb_map_objectclass *ocls, const char *options[]) +struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_attribute *attrs, const struct ldb_map_objectclass *ocls, const char *name) { int i, j; struct ldb_module *ctx; struct map_private *data; + char *url; ctx = talloc(ldb, struct ldb_module); if (!ctx) @@ -757,6 +975,21 @@ struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_at return NULL; } + data->context.mapped_ldb = ldb_init(data); + url = map_find_url(ldb, name); + + if (!url) { + ldb_debug(ldb, LDB_DEBUG_FATAL, "@MAP=%s not set!\n", name); + return NULL; + } + + if (ldb_connect(data->context.mapped_ldb, url, 0, NULL) != 0) { + ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to open mapped database for %s at '%s'\n", name, url); + return NULL; + } + + talloc_free(url); + data->last_err_string = NULL; /* Get list of attribute maps */ @@ -841,7 +1074,6 @@ static struct ldb_val map_convert_local_objectclass(struct ldb_map_context *map, } } - DEBUG(1, ("Unable to map local object class '%s'\n", (char *)val->data)); return ldb_val_dup(ctx, val); } @@ -859,7 +1091,6 @@ static struct ldb_val map_convert_remote_objectclass(struct ldb_map_context *map } } - DEBUG(1, ("Unable to map remote object class '%s'\n", (char *)val->data)); return ldb_val_dup(ctx, val); } -- cgit From 615e1c55bfd0b5e5cb2ac77b19a0c395ef566bd2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 29 Aug 2005 17:31:19 +0000 Subject: r9751: Remove C version of samba3dump (the EJS version works nicely as well). Fix a couple of bugs in ldb_map. (This used to be commit 66df76a63433aea4081eab8b20bf3ba86e0a606d) --- source4/lib/ldb/ldb_map/ldb_map.c | 59 +++++++++++++++++++++++++++++---------- 1 file changed, 44 insertions(+), 15 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 79d3c26f90..f68ba3d545 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -62,10 +62,35 @@ static struct ldb_map_context *map_get_privdat(struct ldb_module *module) return &((struct map_private *)module->private_data)->context; } +static const struct ldb_map_objectclass *map_find_objectclass_local(struct ldb_map_context *privdat, const char *name) +{ + int i; + for (i = 0; privdat->objectclass_maps[i].local_name; i++) { + if (!ldb_attr_cmp(privdat->objectclass_maps[i].local_name, name)) + return &privdat->objectclass_maps[i]; + } + + return NULL; +} + +/* Decide whether a add/modify should be pushed to the + * remote LDAP server. We currently only do this if we see an objectClass we know */ static BOOL map_is_mappable(struct ldb_map_context *privdat, const struct ldb_message *msg) { - /* FIXME */ - return True; + int i; + struct ldb_message_element *el = ldb_msg_find_element(msg, "objectClass"); + + /* No objectClass... */ + if (el == NULL) { + return False; + } + + for (i = 0; i < el->num_values; i++) { + if (map_find_objectclass_local(privdat, (char *)el->values[i].data)) + return True; + } + + return False; } /* find an attribute by the local name */ @@ -745,22 +770,29 @@ static int map_search_bytree_mp(struct ldb_module *module, const struct ldb_dn * int extraret; /* Merge with additional data from local database */ - extraret = ldb_next_search(module, merged->dn, LDB_SCOPE_ONELEVEL, "", NULL, &extrares); + extraret = ldb_next_search(module, merged->dn, LDB_SCOPE_BASE, "", NULL, &extrares); - if (extraret > 1) { + if (extraret == -1) { + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Error searching for extra data!\n"); + } else if (extraret > 1) { ldb_debug(module->ldb, LDB_DEBUG_ERROR, "More then one result for extra data!\n"); + talloc_free(newres); return -1; - } else if (extraret == 1) { + } else if (extraret == 0) { + ldb_debug(module->ldb, LDB_DEBUG_TRACE, "No extra data found for remote DN"); + } + + if (extraret == 1) { int j; ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Extra data found for remote DN"); - for (j = 0; j < merged->num_elements; j++) { - ldb_msg_add(module->ldb, merged, &extrares[0]->elements[j], extrares[0]->elements[j].flags); + for (j = 0; j < extrares[0]->num_elements; j++) { + ldb_msg_add(module->ldb, merged, &(extrares[0]->elements[j]), extrares[0]->elements[j].flags); } + + ldb_msg_add_string(module->ldb, merged, "extraMapped", "TRUE"); } else { - ldb_debug(module->ldb, LDB_DEBUG_TRACE, "No extra data found for remote DN"); + ldb_msg_add_string(module->ldb, merged, "extraMapped", "FALSE"); } - - talloc_free(extrares); if (ldb_match_msg(module->ldb, merged, tree, base, scope)) { (*res)[ret] = merged; @@ -768,10 +800,10 @@ static int map_search_bytree_mp(struct ldb_module *module, const struct ldb_dn * } else { ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Discarded merged message because it did not match"); } - - talloc_free(newres[i]); } + talloc_free(newres); + return ret; } @@ -783,7 +815,6 @@ static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *bas enum ldb_scope scope, struct ldb_parse_tree *tree, const char * const *attrs, struct ldb_message ***res) { - int ret; struct ldb_message **fbres, **mpres; int i; int ret_fb, ret_mp; @@ -803,8 +834,6 @@ static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *bas for (i = 0; i < ret_mp; i++) (*res)[ret_fb+i] = mpres[i]; return ret_fb + ret_mp; - - return ret; } /* search for matching records -- cgit From 7be4cf8c1ded42daf7e86ecd2c0dbfeeed312b22 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 30 Aug 2005 00:41:02 +0000 Subject: r9770: Couple other bugfixes Update TODO-list (This used to be commit d9541535e3f9e1c058410eeb0a54d60181572f2b) --- source4/lib/ldb/ldb_map/ldb_map.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index f68ba3d545..7a620f3b81 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -754,12 +754,17 @@ static int map_search_bytree_mp(struct ldb_module *module, const struct ldb_dn * talloc_free(new_tree); talloc_free(newattrs); + if (mpret == -1) { + struct map_private *map_private = module->private_data; + map_private->last_err_string = ldb_errstring(privdat->mapped_ldb); + return -1; + } + /* - - per returned record, search local one for additional data (by dn) + - per returned record, search fallback database for additional data (by dn) - test if (full expression) is now true */ - *res = talloc_array(module, struct ldb_message *, mpret); ret = 0; @@ -775,7 +780,7 @@ static int map_search_bytree_mp(struct ldb_module *module, const struct ldb_dn * if (extraret == -1) { ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Error searching for extra data!\n"); } else if (extraret > 1) { - ldb_debug(module->ldb, LDB_DEBUG_ERROR, "More then one result for extra data!\n"); + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "More than one result for extra data!\n"); talloc_free(newres); return -1; } else if (extraret == 0) { @@ -820,12 +825,13 @@ static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *bas int ret_fb, ret_mp; ret_fb = map_search_bytree_fb(module, base, scope, tree, attrs, &fbres); - if (ret_fb == -1) + if (ret_fb == -1) return -1; ret_mp = map_search_bytree_mp(module, base, scope, tree, attrs, &mpres); - if (ret_mp == -1) + if (ret_mp == -1) { return -1; + } /* Merge results */ *res = talloc_array(module, struct ldb_message *, ret_fb + ret_mp); -- cgit From f9447d2a17089178d311e03e398c25c749450f6d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 30 Aug 2005 11:08:03 +0000 Subject: r9786: Move ldb_map into ldb/modules/ Move samba3sam to dsdb/ (This used to be commit eb9d615bcd49328131613f64745760a90553b7f2) --- source4/lib/ldb/ldb_map/ldb_map.c | 1151 ------------------------------------- 1 file changed, 1151 deletions(-) delete mode 100644 source4/lib/ldb/ldb_map/ldb_map.c (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c deleted file mode 100644 index 7a620f3b81..0000000000 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ /dev/null @@ -1,1151 +0,0 @@ -/* - ldb database library - map backend - - Copyright (C) Jelmer Vernooij 2005 - - ** NOTE! The following LGPL license applies to the ldb - ** library. This does NOT imply that all of Samba is released - ** under the LGPL - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -*/ - -#include "includes.h" -#include "lib/ldb/include/ldb.h" -#include "lib/ldb/include/ldb_private.h" -#include "lib/ldb/ldb_map/ldb_map.h" - -/* TODO: - * - objectclass hint in ldb_map_attribute - * for use when multiple remote attributes (independant of each other) - * map to one local attribute. E.g.: (uid, gidNumber) -> unixName - * (use MAP_GENERATE instead ?) - */ - -/* - - special attribute 'isMapped' - - add/modify - - split up ldb_message into fallback and mapped parts if is_mappable - - search: - - search local one for not isMapped entries - - remove remote attributes from ldb_parse_tree - - search remote one - - per record, search local one for additional data (by dn) - - test if (full expression) is now true - - delete - - delete both - - rename - - rename locally and remotely -*/ - -static const struct ldb_map_attribute builtin_attribute_maps[]; - -struct map_private { - struct ldb_map_context context; - const char *last_err_string; -}; - -static struct ldb_map_context *map_get_privdat(struct ldb_module *module) -{ - return &((struct map_private *)module->private_data)->context; -} - -static const struct ldb_map_objectclass *map_find_objectclass_local(struct ldb_map_context *privdat, const char *name) -{ - int i; - for (i = 0; privdat->objectclass_maps[i].local_name; i++) { - if (!ldb_attr_cmp(privdat->objectclass_maps[i].local_name, name)) - return &privdat->objectclass_maps[i]; - } - - return NULL; -} - -/* Decide whether a add/modify should be pushed to the - * remote LDAP server. We currently only do this if we see an objectClass we know */ -static BOOL map_is_mappable(struct ldb_map_context *privdat, const struct ldb_message *msg) -{ - int i; - struct ldb_message_element *el = ldb_msg_find_element(msg, "objectClass"); - - /* No objectClass... */ - if (el == NULL) { - return False; - } - - for (i = 0; i < el->num_values; i++) { - if (map_find_objectclass_local(privdat, (char *)el->values[i].data)) - return True; - } - - return False; -} - -/* find an attribute by the local name */ -static const struct ldb_map_attribute *map_find_attr_local(struct ldb_map_context *privdat, const char *attr) -{ - int i; - - for (i = 0; privdat->attribute_maps[i].local_name; i++) { - if (!ldb_attr_cmp(privdat->attribute_maps[i].local_name, attr)) - return &privdat->attribute_maps[i]; - } - - return NULL; -} - -/* find an attribute by the remote name */ -static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_map_context *privdat, const char *attr) -{ - int i; - - for (i = 0; privdat->attribute_maps[i].local_name; i++) { - if (privdat->attribute_maps[i].type == MAP_IGNORE) - continue; - - if (privdat->attribute_maps[i].type == MAP_GENERATE) - continue; - - if (privdat->attribute_maps[i].type == MAP_KEEP && - ldb_attr_cmp(privdat->attribute_maps[i].local_name, attr) == 0) - return &privdat->attribute_maps[i]; - - if ((privdat->attribute_maps[i].type == MAP_RENAME || - privdat->attribute_maps[i].type == MAP_CONVERT) && - ldb_attr_cmp(privdat->attribute_maps[i].u.rename.remote_name, attr) == 0) - return &privdat->attribute_maps[i]; - - } - - return NULL; -} - -static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_parse_tree *tree) -{ - int i; - const struct ldb_map_attribute *attr; - struct ldb_parse_tree *new_tree; - enum ldb_map_attr_type map_type; - struct ldb_val value, newvalue; - struct ldb_map_context *privdat = map_get_privdat(module); - - if (tree == NULL) - return NULL; - - - /* Find attr in question and: - * - if it has a convert_operator function, run that - * - otherwise, replace attr name with required[0] */ - - if (tree->operation == LDB_OP_AND || - tree->operation == LDB_OP_OR) { - - new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); - new_tree->u.list.elements = talloc_array(new_tree, struct ldb_parse_tree *, tree->u.list.num_elements); - new_tree->u.list.num_elements = 0; - for (i = 0; i < tree->u.list.num_elements; i++) { - struct ldb_parse_tree *child = ldb_map_parse_tree(module, new_tree, tree->u.list.elements[i]); - - if (child) { - new_tree->u.list.elements[i] = child; - new_tree->u.list.num_elements++; - } - } - - return new_tree; - } - - if (tree->operation == LDB_OP_NOT) { - struct ldb_parse_tree *child; - - new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); - child = ldb_map_parse_tree(module, new_tree, tree->u.isnot.child); - - if (!child) { - talloc_free(new_tree); - return NULL; - } - - new_tree->u.isnot.child = child; - return new_tree; - } - - /* tree->operation is LDB_OP_EQUALITY, LDB_OP_SUBSTRING, LDB_OP_GREATER, - * LDB_OP_LESS, LDB_OP_APPROX, LDB_OP_PRESENT or LDB_OP_EXTENDED - * - * (all have attr as the first element) - */ - - attr = map_find_attr_local(privdat, tree->u.equality.attr); - - if (!attr) { - ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr); - map_type = MAP_KEEP; - } else { - map_type = attr->type; - } - - if (attr && attr->convert_operator) { - /* Run convert_operator */ - return attr->convert_operator(privdat, module, tree); - } - - if (map_type == MAP_IGNORE) { - ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Search on ignored attribute '%s'\n", tree->u.equality.attr); - return NULL; - } - - if (map_type == MAP_GENERATE) { - ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Can't do conversion for MAP_GENERATE in map_parse_tree without convert_operator for '%s'\n", tree->u.equality.attr); - return NULL; - } - - if (tree->operation == LDB_OP_EQUALITY) { - value = tree->u.equality.value; - } else if (tree->operation == LDB_OP_LESS || tree->operation == LDB_OP_GREATER || - tree->operation == LDB_OP_APPROX) { - value = tree->u.comparison.value; - } else if (tree->operation == LDB_OP_EXTENDED) { - value = tree->u.extended.value; - } - - new_tree = talloc_memdup(ctx, tree, sizeof(*tree)); - - if (map_type == MAP_KEEP) { - new_tree->u.equality.attr = talloc_strdup(new_tree, tree->u.equality.attr); - } else { /* MAP_RENAME / MAP_CONVERT */ - new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name); - } - - if (new_tree->operation == LDB_OP_PRESENT) - return new_tree; - - if (new_tree->operation == LDB_OP_SUBSTRING) { - new_tree->u.substring.chunks = NULL; /* FIXME! */ - return new_tree; - } - - if (map_type == MAP_CONVERT) { - newvalue = attr->u.convert.convert_local(privdat, new_tree, &value); - } else { - newvalue = ldb_val_dup(new_tree, &value); - } - - if (new_tree->operation == LDB_OP_EQUALITY) { - new_tree->u.equality.value = newvalue; - } else if (new_tree->operation == LDB_OP_LESS || new_tree->operation == LDB_OP_GREATER || - new_tree->operation == LDB_OP_APPROX) { - new_tree->u.comparison.value = newvalue; - } else if (new_tree->operation == LDB_OP_EXTENDED) { - new_tree->u.extended.value = newvalue; - new_tree->u.extended.rule_id = talloc_strdup(new_tree, tree->u.extended.rule_id); - } - - return new_tree; -} - -/* Remote DN -> Local DN */ -static struct ldb_dn *map_remote_dn(struct ldb_map_context *privdat, TALLOC_CTX *ctx, const struct ldb_dn *dn) -{ - struct ldb_dn *newdn; - int i; - - if (dn == NULL) - return NULL; - - newdn = talloc_memdup(ctx, dn, sizeof(*dn)); - if (!newdn) - return NULL; - - newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num); - - if (!newdn->components) - return NULL; - - /* For each rdn, map the attribute name and possibly the - * complete rdn */ - - for (i = 0; i < dn->comp_num; i++) { - const struct ldb_map_attribute *attr = map_find_attr_remote(privdat, dn->components[i].name); - enum ldb_map_attr_type map_type; - - /* Unknown attribute - leave this dn as is and hope the best... */ - if (!attr) map_type = MAP_KEEP; - else map_type = attr->type; - - switch (map_type) { - case MAP_IGNORE: - case MAP_GENERATE: - DEBUG(0, ("Local MAP_IGNORE or MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); - talloc_free(newdn); - return NULL; - - case MAP_KEEP: - newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); - newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); - break; - - case MAP_CONVERT: - newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name); - newdn->components[i].value = attr->u.convert.convert_remote(privdat, ctx, &dn->components[i].value); - break; - - case MAP_RENAME: - newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name); - newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); - break; - } - } - return newdn; -} - -/* Local DN -> Remote DN */ -static struct ldb_dn *map_local_dn(struct ldb_map_context *privdat, TALLOC_CTX *ctx, const struct ldb_dn *dn) -{ - struct ldb_dn *newdn; - int i; - - if (dn == NULL) - return NULL; - - newdn = talloc_memdup(ctx, dn, sizeof(*dn)); - if (!newdn) - return NULL; - - newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num); - - if (!newdn->components) - return NULL; - - /* For each rdn, map the attribute name and possibly the - * complete rdn using an equality convert_operator call */ - - for (i = 0; i < dn->comp_num; i++) { - const struct ldb_map_attribute *attr = map_find_attr_local(privdat, dn->components[i].name); - enum ldb_map_attr_type map_type; - - /* Unknown attribute - leave this dn as is and hope the best... */ - if (!attr) map_type = MAP_KEEP; else map_type = attr->type; - - switch (map_type) - { - case MAP_IGNORE: - case MAP_GENERATE: - DEBUG(0, ("Local MAP_IGNORE/MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name)); - talloc_free(newdn); - return NULL; - - case MAP_CONVERT: - newdn->components[i].name = talloc_strdup(newdn->components, attr->u.convert.remote_name); - newdn->components[i].value = attr->u.convert.convert_local(privdat, newdn->components, &dn->components[i].value); - break; - - case MAP_RENAME: - newdn->components[i].name = talloc_strdup(newdn->components, attr->u.rename.remote_name); - newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); - break; - - case MAP_KEEP: - newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name); - newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value); - continue; - } - } - - return newdn; -} - -/* Loop over ldb_map_attribute array and add remote_names */ -static const char **ldb_map_attrs(struct ldb_module *module, const char *const attrs[]) -{ - int i; - const char **ret; - int ar_size = 0, last_element = 0; - struct ldb_map_context *privdat = map_get_privdat(module); - - if (attrs == NULL) - return NULL; - - /* Start with good guess of number of elements */ - for (i = 0; attrs[i]; i++); - - ret = talloc_array(module, const char *, i); - ar_size = i; - - for (i = 0; attrs[i]; i++) { - int j; - const struct ldb_map_attribute *attr = map_find_attr_local(privdat, attrs[i]); - enum ldb_map_attr_type map_type; - - if (!attr) { - ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Local attribute '%s' does not have a definition!\n", attrs[i]); - map_type = MAP_IGNORE; - } else map_type = attr->type; - - switch (map_type) - { - case MAP_IGNORE: break; - case MAP_KEEP: - if (last_element >= ar_size) { - ret = talloc_realloc(module, ret, const char *, ar_size+1); - ar_size++; - } - ret[last_element] = attr->local_name; - last_element++; - break; - - case MAP_RENAME: - case MAP_CONVERT: - if (last_element >= ar_size) { - ret = talloc_realloc(module, ret, const char *, ar_size+1); - ar_size++; - } - ret[last_element] = attr->u.rename.remote_name; - last_element++; - break; - - case MAP_GENERATE: - /* Add remote_names[] for this attribute to the list of - * attributes to request from the remote server */ - for (j = 0; attr->u.generate.remote_names[j]; j++) { - if (last_element >= ar_size) { - ret = talloc_realloc(module, ret, const char *, ar_size+1); - ar_size++; - } - ret[last_element] = attr->u.generate.remote_names[j]; - last_element++; - } - break; - } - } - - if (last_element >= ar_size) { - ret = talloc_realloc(module, ret, const char *, ar_size+1); - ar_size++; - } - - ret[last_element] = NULL; - - return ret; -} - -static const char **available_local_attributes(struct ldb_module *module, const struct ldb_message *msg) -{ - struct ldb_map_context *privdat = map_get_privdat(module); - int i, j; - int count = 0; - const char **ret = talloc_array(module, const char *, 1); - - ret[0] = NULL; - - for (i = 0; privdat->attribute_maps[i].local_name; i++) { - BOOL avail = False; - const struct ldb_map_attribute *attr = &privdat->attribute_maps[i]; - - /* If all remote attributes for this attribute are present, add the - * local one to the list */ - - switch (attr->type) { - case MAP_IGNORE: break; - case MAP_KEEP: - avail = (ldb_msg_find_ldb_val(msg, attr->local_name) != NULL); - break; - - case MAP_RENAME: - case MAP_CONVERT: - avail = (ldb_msg_find_ldb_val(msg, attr->u.rename.remote_name) != NULL); - break; - - case MAP_GENERATE: - avail = True; - for (j = 0; attr->u.generate.remote_names[j]; j++) { - avail &= (ldb_msg_find_ldb_val(msg, attr->u.generate.remote_names[j]) != NULL); - } - break; - } - - if (!avail) - continue; - - ret = talloc_realloc(module, ret, const char *, count+2); - ret[count] = attr->local_name; - ret[count+1] = NULL; - count++; - } - - return ret; -} - -/* Used for search */ -static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi) -{ - int i, j; - struct ldb_message *msg = talloc_zero(module, struct ldb_message); - struct ldb_message_element *elm, *oldelm; - struct ldb_map_context *privdat = map_get_privdat(module); - const char **newattrs = NULL; - - msg->dn = map_remote_dn(privdat, module, mi->dn); - - ldb_msg_add_string(module->ldb, msg, "mappedFromDn", ldb_dn_linearize(msg, mi->dn)); - - /* Loop over attrs, find in ldb_map_attribute array and - * run generate() */ - - if (attrs == NULL) { - /* Generate list of the local attributes that /can/ be generated - * using the specific remote attributes */ - - attrs = newattrs = available_local_attributes(module, mi); - } - - for (i = 0; attrs[i]; i++) { - const struct ldb_map_attribute *attr = map_find_attr_local(privdat, attrs[i]); - enum ldb_map_attr_type map_type; - - if (!attr) { - ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Unable to find local attribute '%s' when generating incoming message\n", attrs[i]); - map_type = MAP_IGNORE; - } else map_type = attr->type; - - switch (map_type) { - case MAP_IGNORE:break; - case MAP_RENAME: - oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); - if (!oldelm) continue; - - elm = talloc(msg, struct ldb_message_element); - elm->name = talloc_strdup(elm, attr->local_name); - elm->num_values = oldelm->num_values; - elm->values = talloc_reference(elm, oldelm->values); - - ldb_msg_add(module->ldb, msg, elm, oldelm->flags); - break; - - case MAP_CONVERT: - oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name); - if (!oldelm) continue; - - elm = talloc(msg, struct ldb_message_element); - elm->name = talloc_strdup(elm, attr->local_name); - elm->num_values = oldelm->num_values; - elm->values = talloc_array(elm, struct ldb_val, elm->num_values); - - for (j = 0; j < oldelm->num_values; j++) - elm->values[j] = attr->u.convert.convert_remote(privdat, elm, &oldelm->values[j]); - - ldb_msg_add(module->ldb, msg, elm, oldelm->flags); - break; - - case MAP_KEEP: - oldelm = ldb_msg_find_element(mi, attr->local_name); - if (!oldelm) continue; - - elm = talloc(msg, struct ldb_message_element); - - elm->num_values = oldelm->num_values; - elm->values = talloc_reference(elm, oldelm->values); - elm->name = talloc_strdup(elm, oldelm->name); - - ldb_msg_add(module->ldb, msg, elm, oldelm->flags); - break; - - case MAP_GENERATE: - elm = attr->u.generate.generate_local(privdat, msg, attr->local_name, mi); - if (!elm) continue; - - ldb_msg_add(module->ldb, msg, elm, elm->flags); - break; - default: - ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Unknown attr->type for %s", attr->local_name); - break; - } - } - - talloc_free(newattrs); - - return msg; -} - -/* Used for add, modify */ -static int ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo, struct ldb_message **fb, struct ldb_message **mp) -{ - struct ldb_map_context *privdat = map_get_privdat(module); - struct ldb_message *msg = talloc_zero(module, struct ldb_message); - struct ldb_message_element *elm; - int i,j; - - *fb = talloc_zero(module, struct ldb_message); - (*fb)->dn = talloc_reference(*fb, mo->dn); - - *mp = msg; - - msg->private_data = mo->private_data; - - msg->dn = map_local_dn(privdat, module, mo->dn); - - /* Loop over mi and call generate_remote for each attribute */ - for (i = 0; i < mo->num_elements; i++) { - const struct ldb_map_attribute *attr = map_find_attr_local(privdat, mo->elements[i].name); - enum ldb_map_attr_type map_type; - - if (!attr) { - ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Undefined local attribute '%s', ignoring\n", mo->elements[i].name); - map_type = MAP_IGNORE; - continue; - } else map_type = attr->type; - - switch (map_type) { - case MAP_IGNORE: /* Add to fallback message */ - elm = talloc(*fb, struct ldb_message_element); - - elm->num_values = mo->elements[i].num_values; - elm->values = talloc_reference(elm, mo->elements[i].values); - elm->name = talloc_strdup(elm, mo->elements[i].name); - - ldb_msg_add(module->ldb, *fb, elm, mo->elements[i].flags); - break; - case MAP_RENAME: - elm = talloc(msg, struct ldb_message_element); - - elm->name = talloc_strdup(elm, attr->u.rename.remote_name); - elm->num_values = mo->elements[i].num_values; - elm->values = talloc_reference(elm, mo->elements[i].values); - - ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags); - break; - - case MAP_CONVERT: - elm = talloc(msg, struct ldb_message_element); - - elm->name = talloc_strdup(elm, attr->u.rename.remote_name); - elm->num_values = mo->elements[i].num_values; - elm->values = talloc_array(elm, struct ldb_val, elm->num_values); - - for (j = 0; j < elm->num_values; j++) { - elm->values[j] = attr->u.convert.convert_local(privdat, msg, &mo->elements[i].values[j]); - } - - ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags); - break; - - case MAP_KEEP: - elm = talloc(msg, struct ldb_message_element); - - elm->num_values = mo->elements[i].num_values; - elm->values = talloc_reference(elm, mo->elements[i].values); - elm->name = talloc_strdup(elm, mo->elements[i].name); - - ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags); - break; - - case MAP_GENERATE: - attr->u.generate.generate_remote(privdat, attr->local_name, mo, msg); - break; - } - } - - return 0; -} - - -/* - rename a record -*/ -static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn) -{ - struct ldb_map_context *privdat = map_get_privdat(module); - struct ldb_dn *n_olddn, *n_newdn; - int ret; - - ret = ldb_next_rename_record(module, olddn, newdn); - - n_olddn = map_local_dn(privdat, module, olddn); - n_newdn = map_local_dn(privdat, module, newdn); - - ret = ldb_rename(privdat->mapped_ldb, n_olddn, n_newdn); - - talloc_free(n_olddn); - talloc_free(n_newdn); - - return ret; -} - -/* - delete a record -*/ -static int map_delete(struct ldb_module *module, const struct ldb_dn *dn) -{ - struct ldb_map_context *privdat = map_get_privdat(module); - struct ldb_dn *newdn; - int ret; - - ret = ldb_next_delete_record(module, dn); - - newdn = map_local_dn(privdat, module, dn); - - ret = ldb_delete(privdat->mapped_ldb, newdn); - - talloc_free(newdn); - - return ret; -} - -/* search fallback database */ -static int map_search_bytree_fb(struct ldb_module *module, const struct ldb_dn *base, - enum ldb_scope scope, struct ldb_parse_tree *tree, - const char * const *attrs, struct ldb_message ***res) -{ - int ret; - struct ldb_parse_tree t_and, t_not, t_present, *childs[2]; - - t_present.operation = LDB_OP_PRESENT; - t_present.u.present.attr = talloc_strdup(NULL, "isMapped"); - - t_not.operation = LDB_OP_NOT; - t_not.u.isnot.child = &t_present; - - childs[0] = &t_not; - childs[1] = tree; - t_and.operation = LDB_OP_AND; - t_and.u.list.num_elements = 2; - t_and.u.list.elements = childs; - - ret = ldb_next_search_bytree(module, base, scope, &t_and, attrs, res); - - talloc_free(t_present.u.present.attr); - - return ret; -} - -static int map_search_bytree_mp(struct ldb_module *module, const struct ldb_dn *base, - enum ldb_scope scope, struct ldb_parse_tree *tree, - const char * const *attrs, struct ldb_message ***res) -{ - struct ldb_parse_tree *new_tree; - struct ldb_dn *new_base; - struct ldb_message **newres; - const char **newattrs; - int mpret, ret; - struct ldb_map_context *privdat = map_get_privdat(module); - int i; - - /*- search mapped database */ - - new_tree = ldb_map_parse_tree(module, module, tree); - newattrs = ldb_map_attrs(module, attrs); - new_base = map_local_dn(privdat, module, base); - - mpret = ldb_search_bytree(privdat->mapped_ldb, new_base, scope, new_tree, newattrs, &newres); - - talloc_free(new_base); - talloc_free(new_tree); - talloc_free(newattrs); - - if (mpret == -1) { - struct map_private *map_private = module->private_data; - map_private->last_err_string = ldb_errstring(privdat->mapped_ldb); - return -1; - } - - /* - - per returned record, search fallback database for additional data (by dn) - - test if (full expression) is now true - */ - - *res = talloc_array(module, struct ldb_message *, mpret); - - ret = 0; - - for (i = 0; i < mpret; i++) { - struct ldb_message *merged = ldb_map_message_incoming(module, attrs, newres[i]); - struct ldb_message **extrares = NULL; - int extraret; - - /* Merge with additional data from local database */ - extraret = ldb_next_search(module, merged->dn, LDB_SCOPE_BASE, "", NULL, &extrares); - - if (extraret == -1) { - ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Error searching for extra data!\n"); - } else if (extraret > 1) { - ldb_debug(module->ldb, LDB_DEBUG_ERROR, "More than one result for extra data!\n"); - talloc_free(newres); - return -1; - } else if (extraret == 0) { - ldb_debug(module->ldb, LDB_DEBUG_TRACE, "No extra data found for remote DN"); - } - - if (extraret == 1) { - int j; - ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Extra data found for remote DN"); - for (j = 0; j < extrares[0]->num_elements; j++) { - ldb_msg_add(module->ldb, merged, &(extrares[0]->elements[j]), extrares[0]->elements[j].flags); - } - - ldb_msg_add_string(module->ldb, merged, "extraMapped", "TRUE"); - } else { - ldb_msg_add_string(module->ldb, merged, "extraMapped", "FALSE"); - } - - if (ldb_match_msg(module->ldb, merged, tree, base, scope)) { - (*res)[ret] = merged; - ret++; - } else { - ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Discarded merged message because it did not match"); - } - } - - talloc_free(newres); - - return ret; -} - - -/* - search for matching records using a ldb_parse_tree -*/ -static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base, - enum ldb_scope scope, struct ldb_parse_tree *tree, - const char * const *attrs, struct ldb_message ***res) -{ - struct ldb_message **fbres, **mpres; - int i; - int ret_fb, ret_mp; - - ret_fb = map_search_bytree_fb(module, base, scope, tree, attrs, &fbres); - if (ret_fb == -1) - return -1; - - ret_mp = map_search_bytree_mp(module, base, scope, tree, attrs, &mpres); - if (ret_mp == -1) { - return -1; - } - - /* Merge results */ - *res = talloc_array(module, struct ldb_message *, ret_fb + ret_mp); - - for (i = 0; i < ret_fb; i++) (*res)[i] = fbres[i]; - for (i = 0; i < ret_mp; i++) (*res)[ret_fb+i] = mpres[i]; - - return ret_fb + ret_mp; -} -/* - search for matching records -*/ -static int map_search(struct ldb_module *module, const struct ldb_dn *base, - enum ldb_scope scope, const char *expression, - const char * const *attrs, struct ldb_message ***res) -{ - struct map_private *map = module->private_data; - struct ldb_parse_tree *tree; - int ret; - - tree = ldb_parse_tree(NULL, expression); - if (tree == NULL) { - map->last_err_string = "expression parse failed"; - return -1; - } - - ret = map_search_bytree(module, base, scope, tree, attrs, res); - talloc_free(tree); - return ret; -} - -/* - add a record -*/ -static int map_add(struct ldb_module *module, const struct ldb_message *msg) -{ - int ret; - struct ldb_map_context *privdat = map_get_privdat(module); - struct ldb_message *fb, *mp; - - if (!map_is_mappable(privdat, msg)) { - return ldb_next_add_record(module, msg); - } - - if (ldb_map_message_outgoing(module, msg, &fb, &mp) == -1) - return -1; - - ldb_msg_add_string(module->ldb, fb, "isMapped", "TRUE"); - - ret = ldb_next_add_record(module, fb); - if (ret == -1) { - ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Adding fallback record failed"); - return -1; - } - - ret = ldb_add(privdat->mapped_ldb, mp); - if (ret == -1) { - ldb_debug(module->ldb, LDB_DEBUG_TRACE, "Adding mapped record failed"); - return -1; - } - - talloc_free(fb); - talloc_free(mp); - - return ret; -} - - -/* - modify a record -*/ -static int map_modify(struct ldb_module *module, const struct ldb_message *msg) -{ - struct ldb_map_context *privdat = map_get_privdat(module); - struct ldb_message *fb, *mp; - int ret; - - if (!map_is_mappable(privdat, msg)) - return ldb_next_modify_record(module, msg); - - - if (ldb_map_message_outgoing(module, msg, &fb, &mp) == -1) - return -1; - - ldb_msg_add_string(module->ldb, fb, "isMapped", "TRUE"); - - ret = ldb_next_modify_record(module, fb); - - ret = ldb_modify(privdat->mapped_ldb, mp); - - talloc_free(fb); - talloc_free(mp); - - return ret; -} - -static int map_lock(struct ldb_module *module, const char *lockname) -{ - return ldb_next_named_lock(module, lockname); -} - -static int map_unlock(struct ldb_module *module, const char *lockname) -{ - return ldb_next_named_unlock(module, lockname); -} - -/* - return extended error information -*/ -static const char *map_errstring(struct ldb_module *module) -{ - struct map_private *map = module->private_data; - - if (map->last_err_string) - return map->last_err_string; - - return ldb_next_errstring(module); -} - -static const struct ldb_module_ops map_ops = { - .name = "map", - .search = map_search, - .search_bytree = map_search_bytree, - .add_record = map_add, - .modify_record = map_modify, - .delete_record = map_delete, - .rename_record = map_rename, - .named_lock = map_lock, - .named_unlock = map_unlock, - .errstring = map_errstring -}; - -static char *map_find_url(struct ldb_context *ldb, const char *name) -{ - const char * const attrs[] = { "@MAP_URL" , NULL}; - struct ldb_message **msg = NULL; - struct ldb_dn *mods; - char *url; - int ret; - - mods = ldb_dn_string_compose(ldb, NULL, "@MAP=%s", name); - if (mods == NULL) { - ldb_debug(ldb, LDB_DEBUG_ERROR, "Can't construct DN"); - return NULL; - } - - ret = ldb_search(ldb, mods, LDB_SCOPE_BASE, "", attrs, &msg); - talloc_free(mods); - if (ret < 1) { - ldb_debug(ldb, LDB_DEBUG_ERROR, "Not enough results found looking for @MAP"); - return NULL; - } - - url = talloc_strdup(ldb, ldb_msg_find_string(msg[0], "@MAP_URL", NULL)); - - talloc_free(msg); - - return url; -} - -/* the init function */ -struct ldb_module *ldb_map_init(struct ldb_context *ldb, const struct ldb_map_attribute *attrs, const struct ldb_map_objectclass *ocls, const char *name) -{ - int i, j; - struct ldb_module *ctx; - struct map_private *data; - char *url; - - ctx = talloc(ldb, struct ldb_module); - if (!ctx) - return NULL; - - data = talloc(ctx, struct map_private); - if (!data) { - talloc_free(ctx); - return NULL; - } - - data->context.mapped_ldb = ldb_init(data); - url = map_find_url(ldb, name); - - if (!url) { - ldb_debug(ldb, LDB_DEBUG_FATAL, "@MAP=%s not set!\n", name); - return NULL; - } - - if (ldb_connect(data->context.mapped_ldb, url, 0, NULL) != 0) { - ldb_debug(ldb, LDB_DEBUG_FATAL, "Unable to open mapped database for %s at '%s'\n", name, url); - return NULL; - } - - talloc_free(url); - - data->last_err_string = NULL; - - /* Get list of attribute maps */ - j = 0; - data->context.attribute_maps = NULL; - - for (i = 0; attrs[i].local_name; i++) { - data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1); - data->context.attribute_maps[j] = attrs[i]; - j++; - } - - for (i = 0; builtin_attribute_maps[i].local_name; i++) { - data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1); - data->context.attribute_maps[j] = builtin_attribute_maps[i]; - j++; - } - - data->context.attribute_maps = talloc_realloc(data, data->context.attribute_maps, struct ldb_map_attribute, j+1); - ZERO_STRUCT(data->context.attribute_maps[j].local_name); - - data->context.objectclass_maps = ocls; - ctx->private_data = data; - ctx->ldb = ldb; - ctx->prev = ctx->next = NULL; - ctx->ops = &map_ops; - - return ctx; -} - -static struct ldb_val map_convert_local_dn(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) -{ - struct ldb_dn *dn, *newdn;; - struct ldb_val *newval; - - dn = ldb_dn_explode(ctx, (char *)val->data); - - newdn = map_local_dn(map, ctx, dn); - - talloc_free(dn); - - newval = talloc(ctx, struct ldb_val); - newval->data = (uint8_t *)ldb_dn_linearize(ctx, newdn); - newval->length = strlen((char *)newval->data); - - talloc_free(newdn); - - return *newval; -} - -static struct ldb_val map_convert_remote_dn(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) -{ - struct ldb_dn *dn, *newdn;; - struct ldb_val *newval; - - dn = ldb_dn_explode(ctx, (char *)val->data); - - newdn = map_remote_dn(map, ctx, dn); - - talloc_free(dn); - - newval = talloc(ctx, struct ldb_val); - newval->data = (uint8_t *)ldb_dn_linearize(ctx, newdn); - newval->length = strlen((char *)newval->data); - - talloc_free(newdn); - - return *newval; -} - -static struct ldb_val map_convert_local_objectclass(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) -{ - int i; - - for (i = 0; map->objectclass_maps[i].local_name; i++) { - if (!strcmp(map->objectclass_maps[i].local_name, (char *)val->data)) { - struct ldb_val newval; - newval.data = (uint8_t*)talloc_strdup(ctx, map->objectclass_maps[i].remote_name); - newval.length = strlen((char *)newval.data); - - return ldb_val_dup(ctx, &newval); - } - } - - return ldb_val_dup(ctx, val); -} - -static struct ldb_val map_convert_remote_objectclass(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val) -{ - int i; - - for (i = 0; map->objectclass_maps[i].remote_name; i++) { - if (!strcmp(map->objectclass_maps[i].remote_name, (char *)val->data)) { - struct ldb_val newval; - newval.data = (uint8_t*)talloc_strdup(ctx, map->objectclass_maps[i].local_name); - newval.length = strlen((char *)newval.data); - - return ldb_val_dup(ctx, &newval); - } - } - - return ldb_val_dup(ctx, val); -} - -static const struct ldb_map_attribute builtin_attribute_maps[] = { - { - .local_name = "dn", - .type = MAP_CONVERT, - .u.convert.remote_name = "dn", - .u.convert.convert_local = map_convert_local_dn, - .u.convert.convert_remote = map_convert_remote_dn, - }, - { - .local_name = "objectclass", - .type = MAP_CONVERT, - .u.convert.remote_name = "objectclass", - .u.convert.convert_local = map_convert_local_objectclass, - .u.convert.convert_remote = map_convert_remote_objectclass, - }, - { - .local_name = NULL, - } -}; - -- cgit From cc26fe9b749d00bc7c002f6a5a24ff67af497c49 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 8 May 2007 21:17:58 +0000 Subject: r22762: Some ldb_map changes: * Change license to LGPL, so it can be used by non-Samba users of LDB (cleared with Martin as well). * Include ldb_map in standalone build. * Move ldb_map to its own directory (This used to be commit a90202abca26c0da5425a2f3dd8494077c3290fd) --- source4/lib/ldb/ldb_map/ldb_map.c | 1400 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1400 insertions(+) create mode 100644 source4/lib/ldb/ldb_map/ldb_map.c (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c new file mode 100644 index 0000000000..64484220b5 --- /dev/null +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -0,0 +1,1400 @@ +/* + ldb database mapping module + + Copyright (C) Jelmer Vernooij 2005 + Copyright (C) Martin Kuehl 2006 + + ** NOTE! The following LGPL license applies to the ldb + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ + +/* + * Name: ldb + * + * Component: ldb ldb_map module + * + * Description: Map portions of data into a different format on a + * remote partition. + * + * Author: Jelmer Vernooij, Martin Kuehl + */ + +#include "ldb_includes.h" + +#include "ldb_map.h" +#include "ldb_map_private.h" + +#ifndef _PUBLIC_ +#define _PUBLIC_ +#endif + +/* Description of the provided ldb requests: + - special attribute 'isMapped' + + - search: + - if parse tree can be split + - search remote records w/ remote attrs and parse tree + - otherwise + - enumerate all remote records + - for each remote result + - map remote result to local message + - search local result + - is present + - merge local into remote result + - run callback on merged result + - otherwise + - run callback on remote result + + - add: + - split message into local and remote part + - if local message is not empty + - add isMapped to local message + - add local message + - add remote message + + - modify: + - split message into local and remote part + - if local message is not empty + - add isMapped to local message + - search for local record + - if present + - modify local record + - otherwise + - add local message + - modify remote record + + - delete: + - search for local record + - if present + - delete local record + - delete remote record + + - rename: + - search for local record + - if present + - rename local record + - modify local isMapped + - rename remote record +*/ + + + +/* Private data structures + * ======================= */ + +/* Global private data */ +/* Extract mappings from private data. */ +const struct ldb_map_context *map_get_context(struct ldb_module *module) +{ + const struct map_private *data = talloc_get_type(module->private_data, struct map_private); + return data->context; +} + +/* Create a generic request context. */ +static struct map_context *map_init_context(struct ldb_handle *h, struct ldb_request *req) +{ + struct map_context *ac; + + ac = talloc_zero(h, struct map_context); + if (ac == NULL) { + map_oom(h->module); + return NULL; + } + + ac->module = h->module; + ac->orig_req = req; + + return ac; +} + +/* Create a search request context. */ +struct map_search_context *map_init_search_context(struct map_context *ac, struct ldb_reply *ares) +{ + struct map_search_context *sc; + + sc = talloc_zero(ac, struct map_search_context); + if (sc == NULL) { + map_oom(ac->module); + return NULL; + } + + sc->ac = ac; + sc->local_res = NULL; + sc->remote_res = ares; + + return sc; +} + +/* Create a request context and handle. */ +struct ldb_handle *map_init_handle(struct ldb_request *req, struct ldb_module *module) +{ + struct map_context *ac; + struct ldb_handle *h; + + h = talloc_zero(req, struct ldb_handle); + if (h == NULL) { + map_oom(module); + return NULL; + } + + h->module = module; + + ac = map_init_context(h, req); + if (ac == NULL) { + talloc_free(h); + return NULL; + } + + h->private_data = (void *)ac; + + h->state = LDB_ASYNC_INIT; + h->status = LDB_SUCCESS; + + return h; +} + + +/* Dealing with DNs for different partitions + * ========================================= */ + +/* Check whether any data should be stored in the local partition. */ +bool map_check_local_db(struct ldb_module *module) +{ + const struct ldb_map_context *data = map_get_context(module); + + if (!data->remote_base_dn || !data->local_base_dn) { + return false; + } + + return true; +} + +/* Copy a DN with the base DN of the local partition. */ +static struct ldb_dn *ldb_dn_rebase_local(void *mem_ctx, const struct ldb_map_context *data, struct ldb_dn *dn) +{ + struct ldb_dn *new_dn; + + new_dn = ldb_dn_copy(mem_ctx, dn); + if ( ! ldb_dn_validate(new_dn)) { + talloc_free(new_dn); + return NULL; + } + + /* may be we don't need to rebase at all */ + if ( ! data->remote_base_dn || ! data->local_base_dn) { + return new_dn; + } + + if ( ! ldb_dn_remove_base_components(new_dn, ldb_dn_get_comp_num(data->remote_base_dn))) { + talloc_free(new_dn); + return NULL; + } + + if ( ! ldb_dn_add_base(new_dn, data->local_base_dn)) { + talloc_free(new_dn); + return NULL; + } + + return new_dn; +} + +/* Copy a DN with the base DN of the remote partition. */ +static struct ldb_dn *ldb_dn_rebase_remote(void *mem_ctx, const struct ldb_map_context *data, struct ldb_dn *dn) +{ + struct ldb_dn *new_dn; + + new_dn = ldb_dn_copy(mem_ctx, dn); + if ( ! ldb_dn_validate(new_dn)) { + talloc_free(new_dn); + return NULL; + } + + /* may be we don't need to rebase at all */ + if ( ! data->remote_base_dn || ! data->local_base_dn) { + return new_dn; + } + + if ( ! ldb_dn_remove_base_components(new_dn, ldb_dn_get_comp_num(data->local_base_dn))) { + talloc_free(new_dn); + return NULL; + } + + if ( ! ldb_dn_add_base(new_dn, data->remote_base_dn)) { + talloc_free(new_dn); + return NULL; + } + + return new_dn; +} + +/* Run a request and make sure it targets the remote partition. */ +/* TODO: free old DNs and messages? */ +int ldb_next_remote_request(struct ldb_module *module, struct ldb_request *request) +{ + const struct ldb_map_context *data = map_get_context(module); + struct ldb_message *msg; + + switch (request->operation) { + case LDB_SEARCH: + if (request->op.search.base) { + request->op.search.base = ldb_dn_rebase_remote(request, data, request->op.search.base); + } else { + request->op.search.base = data->remote_base_dn; + /* TODO: adjust scope? */ + } + break; + + case LDB_ADD: + msg = ldb_msg_copy_shallow(request, request->op.add.message); + msg->dn = ldb_dn_rebase_remote(msg, data, msg->dn); + request->op.add.message = msg; + break; + + case LDB_MODIFY: + msg = ldb_msg_copy_shallow(request, request->op.mod.message); + msg->dn = ldb_dn_rebase_remote(msg, data, msg->dn); + request->op.mod.message = msg; + break; + + case LDB_DELETE: + request->op.del.dn = ldb_dn_rebase_remote(request, data, request->op.del.dn); + break; + + case LDB_RENAME: + request->op.rename.olddn = ldb_dn_rebase_remote(request, data, request->op.rename.olddn); + request->op.rename.newdn = ldb_dn_rebase_remote(request, data, request->op.rename.newdn); + break; + + default: + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "Invalid remote request!\n"); + return LDB_ERR_OPERATIONS_ERROR; + } + + return ldb_next_request(module, request); +} + + +/* Finding mappings for attributes and objectClasses + * ================================================= */ + +/* Find an objectClass mapping by the local name. */ +static const struct ldb_map_objectclass *map_objectclass_find_local(const struct ldb_map_context *data, const char *name) +{ + int i; + + for (i = 0; data->objectclass_maps && data->objectclass_maps[i].local_name; i++) { + if (ldb_attr_cmp(data->objectclass_maps[i].local_name, name) == 0) { + return &data->objectclass_maps[i]; + } + } + + return NULL; +} + +/* Find an objectClass mapping by the remote name. */ +static const struct ldb_map_objectclass *map_objectclass_find_remote(const struct ldb_map_context *data, const char *name) +{ + int i; + + for (i = 0; data->objectclass_maps && data->objectclass_maps[i].remote_name; i++) { + if (ldb_attr_cmp(data->objectclass_maps[i].remote_name, name) == 0) { + return &data->objectclass_maps[i]; + } + } + + return NULL; +} + +/* Find an attribute mapping by the local name. */ +const struct ldb_map_attribute *map_attr_find_local(const struct ldb_map_context *data, const char *name) +{ + int i; + + for (i = 0; data->attribute_maps[i].local_name; i++) { + if (ldb_attr_cmp(data->attribute_maps[i].local_name, name) == 0) { + return &data->attribute_maps[i]; + } + } + for (i = 0; data->attribute_maps[i].local_name; i++) { + if (ldb_attr_cmp(data->attribute_maps[i].local_name, "*") == 0) { + return &data->attribute_maps[i]; + } + } + + return NULL; +} + +/* Find an attribute mapping by the remote name. */ +const struct ldb_map_attribute *map_attr_find_remote(const struct ldb_map_context *data, const char *name) +{ + const struct ldb_map_attribute *map; + const struct ldb_map_attribute *wildcard = NULL; + int i, j; + + for (i = 0; data->attribute_maps[i].local_name; i++) { + map = &data->attribute_maps[i]; + if (ldb_attr_cmp(map->local_name, "*") == 0) { + wildcard = &data->attribute_maps[i]; + } + + switch (map->type) { + case MAP_IGNORE: + break; + + case MAP_KEEP: + if (ldb_attr_cmp(map->local_name, name) == 0) { + return map; + } + break; + + case MAP_RENAME: + case MAP_CONVERT: + if (ldb_attr_cmp(map->u.rename.remote_name, name) == 0) { + return map; + } + break; + + case MAP_GENERATE: + for (j = 0; map->u.generate.remote_names && map->u.generate.remote_names[j]; j++) { + if (ldb_attr_cmp(map->u.generate.remote_names[j], name) == 0) { + return map; + } + } + break; + } + } + + /* We didn't find it, so return the wildcard record if one was configured */ + return wildcard; +} + + +/* Mapping attributes + * ================== */ + +/* Check whether an attribute will be mapped into the remote partition. */ +bool map_attr_check_remote(const struct ldb_map_context *data, const char *attr) +{ + const struct ldb_map_attribute *map = map_attr_find_local(data, attr); + + if (map == NULL) { + return false; + } + if (map->type == MAP_IGNORE) { + return false; + } + + return true; +} + +/* Map an attribute name into the remote partition. */ +const char *map_attr_map_local(void *mem_ctx, const struct ldb_map_attribute *map, const char *attr) +{ + if (map == NULL) { + return talloc_strdup(mem_ctx, attr); + } + + switch (map->type) { + case MAP_KEEP: + return talloc_strdup(mem_ctx, attr); + + case MAP_RENAME: + case MAP_CONVERT: + return talloc_strdup(mem_ctx, map->u.rename.remote_name); + + default: + return NULL; + } +} + +/* Map an attribute name back into the local partition. */ +const char *map_attr_map_remote(void *mem_ctx, const struct ldb_map_attribute *map, const char *attr) +{ + if (map == NULL) { + return talloc_strdup(mem_ctx, attr); + } + + if (map->type == MAP_KEEP) { + return talloc_strdup(mem_ctx, attr); + } + + return talloc_strdup(mem_ctx, map->local_name); +} + + +/* Merge two lists of attributes into a single one. */ +int map_attrs_merge(struct ldb_module *module, void *mem_ctx, + const char ***attrs, const char * const *more_attrs) +{ + int i, j, k; + + for (i = 0; *attrs && (*attrs)[i]; i++) /* noop */ ; + for (j = 0; more_attrs && more_attrs[j]; j++) /* noop */ ; + + *attrs = talloc_realloc(mem_ctx, *attrs, const char *, i+j+1); + if (*attrs == NULL) { + map_oom(module); + return -1; + } + + for (k = 0; k < j; k++) { + (*attrs)[i + k] = more_attrs[k]; + } + + (*attrs)[i+k] = NULL; + + return 0; +} + +/* Mapping ldb values + * ================== */ + +/* Map an ldb value into the remote partition. */ +struct ldb_val ldb_val_map_local(struct ldb_module *module, void *mem_ctx, + const struct ldb_map_attribute *map, const struct ldb_val *val) +{ + if (map && (map->type == MAP_CONVERT) && (map->u.convert.convert_local)) { + return map->u.convert.convert_local(module, mem_ctx, val); + } + + return ldb_val_dup(mem_ctx, val); +} + +/* Map an ldb value back into the local partition. */ +struct ldb_val ldb_val_map_remote(struct ldb_module *module, void *mem_ctx, + const struct ldb_map_attribute *map, const struct ldb_val *val) +{ + if (map && (map->type == MAP_CONVERT) && (map->u.convert.convert_remote)) { + return map->u.convert.convert_remote(module, mem_ctx, val); + } + + return ldb_val_dup(mem_ctx, val); +} + + +/* Mapping DNs + * =========== */ + +/* Check whether a DN is below the local baseDN. */ +bool ldb_dn_check_local(struct ldb_module *module, struct ldb_dn *dn) +{ + const struct ldb_map_context *data = map_get_context(module); + + if (!data->local_base_dn) { + return true; + } + + return ldb_dn_compare_base(data->local_base_dn, dn) == 0; +} + +/* Map a DN into the remote partition. */ +struct ldb_dn *ldb_dn_map_local(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn) +{ + const struct ldb_map_context *data = map_get_context(module); + struct ldb_dn *newdn; + const struct ldb_map_attribute *map; + enum ldb_map_attr_type map_type; + const char *name; + struct ldb_val value; + int i, ret; + + if (dn == NULL) { + return NULL; + } + + newdn = ldb_dn_copy(mem_ctx, dn); + if (newdn == NULL) { + map_oom(module); + return NULL; + } + + /* For each RDN, map the component name and possibly the value */ + for (i = 0; i < ldb_dn_get_comp_num(newdn); i++) { + map = map_attr_find_local(data, ldb_dn_get_component_name(dn, i)); + + /* Unknown attribute - leave this RDN as is and hope the best... */ + if (map == NULL) { + map_type = MAP_KEEP; + } else { + map_type = map->type; + } + + switch (map_type) { + case MAP_IGNORE: + case MAP_GENERATE: + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "MAP_IGNORE/MAP_GENERATE attribute '%s' " + "used in DN!\n", ldb_dn_get_component_name(dn, i)); + goto failed; + + case MAP_CONVERT: + if (map->u.convert.convert_local == NULL) { + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "'convert_local' not set for attribute '%s' " + "used in DN!\n", ldb_dn_get_component_name(dn, i)); + goto failed; + } + /* fall through */ + case MAP_KEEP: + case MAP_RENAME: + name = map_attr_map_local(newdn, map, ldb_dn_get_component_name(dn, i)); + if (name == NULL) goto failed; + + value = ldb_val_map_local(module, newdn, map, ldb_dn_get_component_val(dn, i)); + if (value.data == NULL) goto failed; + + ret = ldb_dn_set_component(newdn, i, name, value); + if (ret != LDB_SUCCESS) { + goto failed; + } + + break; + } + } + + return newdn; + +failed: + talloc_free(newdn); + return NULL; +} + +/* Map a DN into the local partition. */ +struct ldb_dn *ldb_dn_map_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn) +{ + const struct ldb_map_context *data = map_get_context(module); + struct ldb_dn *newdn; + const struct ldb_map_attribute *map; + enum ldb_map_attr_type map_type; + const char *name; + struct ldb_val value; + int i, ret; + + if (dn == NULL) { + return NULL; + } + + newdn = ldb_dn_copy(mem_ctx, dn); + if (newdn == NULL) { + map_oom(module); + return NULL; + } + + /* For each RDN, map the component name and possibly the value */ + for (i = 0; i < ldb_dn_get_comp_num(newdn); i++) { + map = map_attr_find_remote(data, ldb_dn_get_component_name(dn, i)); + + /* Unknown attribute - leave this RDN as is and hope the best... */ + if (map == NULL) { + map_type = MAP_KEEP; + } else { + map_type = map->type; + } + + switch (map_type) { + case MAP_IGNORE: + case MAP_GENERATE: + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "MAP_IGNORE/MAP_GENERATE attribute '%s' " + "used in DN!\n", ldb_dn_get_component_name(dn, i)); + goto failed; + + case MAP_CONVERT: + if (map->u.convert.convert_remote == NULL) { + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "'convert_remote' not set for attribute '%s' " + "used in DN!\n", ldb_dn_get_component_name(dn, i)); + goto failed; + } + /* fall through */ + case MAP_KEEP: + case MAP_RENAME: + name = map_attr_map_remote(newdn, map, ldb_dn_get_component_name(dn, i)); + if (name == NULL) goto failed; + + value = ldb_val_map_remote(module, newdn, map, ldb_dn_get_component_val(dn, i)); + if (value.data == NULL) goto failed; + + ret = ldb_dn_set_component(newdn, i, name, value); + if (ret != LDB_SUCCESS) { + goto failed; + } + + break; + } + } + + return newdn; + +failed: + talloc_free(newdn); + return NULL; +} + +/* Map a DN and its base into the local partition. */ +/* TODO: This should not be required with GUIDs. */ +struct ldb_dn *ldb_dn_map_rebase_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn) +{ + const struct ldb_map_context *data = map_get_context(module); + struct ldb_dn *dn1, *dn2; + + dn1 = ldb_dn_rebase_local(mem_ctx, data, dn); + dn2 = ldb_dn_map_remote(module, mem_ctx, dn1); + + talloc_free(dn1); + return dn2; +} + + +/* Converting DNs and objectClasses (as ldb values) + * ================================================ */ + +/* Map a DN contained in an ldb value into the remote partition. */ +static struct ldb_val ldb_dn_convert_local(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val) +{ + struct ldb_dn *dn, *newdn; + struct ldb_val newval; + + dn = ldb_dn_new(mem_ctx, module->ldb, (char *)val->data); + if (! ldb_dn_validate(dn)) { + newval.length = 0; + newval.data = NULL; + talloc_free(dn); + return newval; + } + newdn = ldb_dn_map_local(module, mem_ctx, dn); + talloc_free(dn); + + newval.length = 0; + newval.data = (uint8_t *)ldb_dn_alloc_linearized(mem_ctx, newdn); + if (newval.data) { + newval.length = strlen((char *)newval.data); + } + talloc_free(newdn); + + return newval; +} + +/* Map a DN contained in an ldb value into the local partition. */ +static struct ldb_val ldb_dn_convert_remote(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val) +{ + struct ldb_dn *dn, *newdn; + struct ldb_val newval; + + dn = ldb_dn_new(mem_ctx, module->ldb, (char *)val->data); + if (! ldb_dn_validate(dn)) { + newval.length = 0; + newval.data = NULL; + talloc_free(dn); + return newval; + } + newdn = ldb_dn_map_remote(module, mem_ctx, dn); + talloc_free(dn); + + newval.length = 0; + newval.data = (uint8_t *)ldb_dn_alloc_linearized(mem_ctx, newdn); + if (newval.data) { + newval.length = strlen((char *)newval.data); + } + talloc_free(newdn); + + return newval; +} + +/* Map an objectClass into the remote partition. */ +static struct ldb_val map_objectclass_convert_local(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val) +{ + const struct ldb_map_context *data = map_get_context(module); + const char *name = (char *)val->data; + const struct ldb_map_objectclass *map = map_objectclass_find_local(data, name); + struct ldb_val newval; + + if (map) { + newval.data = (uint8_t*)talloc_strdup(mem_ctx, map->remote_name); + newval.length = strlen((char *)newval.data); + return newval; + } + + return ldb_val_dup(mem_ctx, val); +} + +/* Generate a remote message with a mapped objectClass. */ +static void map_objectclass_generate_remote(struct ldb_module *module, const char *local_attr, const struct ldb_message *old, struct ldb_message *remote, struct ldb_message *local) +{ + struct ldb_message_element *el, *oc; + struct ldb_val val; + bool found_extensibleObject = false; + int i; + + /* Find old local objectClass */ + oc = ldb_msg_find_element(old, "objectClass"); + if (oc == NULL) { + return; + } + + /* Prepare new element */ + el = talloc_zero(remote, struct ldb_message_element); + if (el == NULL) { + ldb_oom(module->ldb); + return; /* TODO: fail? */ + } + + /* Copy local objectClass element, reverse space for an extra value */ + el->num_values = oc->num_values + 1; + el->values = talloc_array(el, struct ldb_val, el->num_values); + if (el->values == NULL) { + talloc_free(el); + ldb_oom(module->ldb); + return; /* TODO: fail? */ + } + + /* Copy local element name "objectClass" */ + el->name = talloc_strdup(el, local_attr); + + /* Convert all local objectClasses */ + for (i = 0; i < el->num_values - 1; i++) { + el->values[i] = map_objectclass_convert_local(module, el->values, &oc->values[i]); + if (ldb_attr_cmp((char *)el->values[i].data, "extensibleObject") == 0) { + found_extensibleObject = true; + } + } + + if (!found_extensibleObject) { + val.data = (uint8_t *)talloc_strdup(el->values, "extensibleObject"); + val.length = strlen((char *)val.data); + + /* Append additional objectClass "extensibleObject" */ + el->values[i] = val; + } else { + el->num_values--; + } + + /* Add new objectClass to remote message */ + ldb_msg_add(remote, el, 0); +} + +/* Map an objectClass into the local partition. */ +static struct ldb_val map_objectclass_convert_remote(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val) +{ + const struct ldb_map_context *data = map_get_context(module); + const char *name = (char *)val->data; + const struct ldb_map_objectclass *map = map_objectclass_find_remote(data, name); + struct ldb_val newval; + + if (map) { + newval.data = (uint8_t*)talloc_strdup(mem_ctx, map->local_name); + newval.length = strlen((char *)newval.data); + return newval; + } + + return ldb_val_dup(mem_ctx, val); +} + +/* Generate a local message with a mapped objectClass. */ +static struct ldb_message_element *map_objectclass_generate_local(struct ldb_module *module, void *mem_ctx, const char *local_attr, const struct ldb_message *remote) +{ + struct ldb_message_element *el, *oc; + struct ldb_val val; + int i; + + /* Find old remote objectClass */ + oc = ldb_msg_find_element(remote, "objectClass"); + if (oc == NULL) { + return NULL; + } + + /* Prepare new element */ + el = talloc_zero(mem_ctx, struct ldb_message_element); + if (el == NULL) { + ldb_oom(module->ldb); + return NULL; + } + + /* Copy remote objectClass element */ + el->num_values = oc->num_values; + el->values = talloc_array(el, struct ldb_val, el->num_values); + if (el->values == NULL) { + talloc_free(el); + ldb_oom(module->ldb); + return NULL; + } + + /* Copy remote element name "objectClass" */ + el->name = talloc_strdup(el, local_attr); + + /* Convert all remote objectClasses */ + for (i = 0; i < el->num_values; i++) { + el->values[i] = map_objectclass_convert_remote(module, el->values, &oc->values[i]); + } + + val.data = (uint8_t *)talloc_strdup(el->values, "extensibleObject"); + val.length = strlen((char *)val.data); + + /* Remove last value if it was "extensibleObject" */ + if (ldb_val_equal_exact(&val, &el->values[i-1])) { + el->num_values--; + el->values = talloc_realloc(el, el->values, struct ldb_val, el->num_values); + if (el->values == NULL) { + talloc_free(el); + ldb_oom(module->ldb); + return NULL; + } + } + + return el; +} + +/* Mappings for searches on objectClass= assuming a one-to-one + * mapping. Needed because this is a generate operator for the + * add/modify code */ +static int map_objectclass_convert_operator(struct ldb_module *module, void *mem_ctx, + struct ldb_parse_tree **new, const struct ldb_parse_tree *tree) +{ + + static const struct ldb_map_attribute objectclass_map = { + .local_name = "objectClass", + .type = MAP_CONVERT, + .u = { + .convert = { + .remote_name = "objectClass", + .convert_local = map_objectclass_convert_local, + .convert_remote = map_objectclass_convert_remote, + }, + }, + }; + + return map_subtree_collect_remote_simple(module, mem_ctx, new, tree, &objectclass_map); +} + +/* Auxiliary request construction + * ============================== */ + +/* Store the DN of a single search result in context. */ +static int map_search_self_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares) +{ + struct map_context *ac; + + if (context == NULL || ares == NULL) { + ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback")); + return LDB_ERR_OPERATIONS_ERROR; + } + + ac = talloc_get_type(context, struct map_context); + + /* We are interested only in the single reply */ + if (ares->type != LDB_REPLY_ENTRY) { + talloc_free(ares); + return LDB_SUCCESS; + } + + /* We have already found a remote DN */ + if (ac->local_dn) { + ldb_set_errstring(ldb, talloc_asprintf(ldb, "Too many results to base search")); + talloc_free(ares); + return LDB_ERR_OPERATIONS_ERROR; + } + + /* Store local DN */ + ac->local_dn = ares->message->dn; + + return LDB_SUCCESS; +} + +/* Build a request to search a record by its DN. */ +struct ldb_request *map_search_base_req(struct map_context *ac, struct ldb_dn *dn, const char * const *attrs, const struct ldb_parse_tree *tree, void *context, ldb_search_callback callback) +{ + struct ldb_request *req; + + req = talloc_zero(ac, struct ldb_request); + if (req == NULL) { + map_oom(ac->module); + return NULL; + } + + req->operation = LDB_SEARCH; + req->op.search.base = dn; + req->op.search.scope = LDB_SCOPE_BASE; + req->op.search.attrs = attrs; + + if (tree) { + req->op.search.tree = tree; + } else { + req->op.search.tree = ldb_parse_tree(req, NULL); + if (req->op.search.tree == NULL) { + talloc_free(req); + return NULL; + } + } + + req->controls = NULL; + req->context = context; + req->callback = callback; + ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, req); + + return req; +} + +/* Build a request to search the local record by its DN. */ +struct ldb_request *map_search_self_req(struct map_context *ac, struct ldb_dn *dn) +{ + /* attrs[] is returned from this function in + * ac->search_req->op.search.attrs, so it must be static, as + * otherwise the compiler can put it on the stack */ + static const char * const attrs[] = { IS_MAPPED, NULL }; + struct ldb_parse_tree *tree; + + /* Limit search to records with 'IS_MAPPED' present */ + /* TODO: `tree = ldb_parse_tree(ac, IS_MAPPED);' won't do. */ + tree = talloc_zero(ac, struct ldb_parse_tree); + if (tree == NULL) { + map_oom(ac->module); + return NULL; + } + + tree->operation = LDB_OP_PRESENT; + tree->u.present.attr = talloc_strdup(tree, IS_MAPPED); + + return map_search_base_req(ac, dn, attrs, tree, ac, map_search_self_callback); +} + +/* Build a request to update the 'IS_MAPPED' attribute */ +struct ldb_request *map_build_fixup_req(struct map_context *ac, struct ldb_dn *olddn, struct ldb_dn *newdn) +{ + struct ldb_request *req; + struct ldb_message *msg; + const char *dn; + + /* Prepare request */ + req = talloc_zero(ac, struct ldb_request); + if (req == NULL) { + map_oom(ac->module); + return NULL; + } + + /* Prepare message */ + msg = ldb_msg_new(req); + if (msg == NULL) { + map_oom(ac->module); + goto failed; + } + + /* Update local 'IS_MAPPED' to the new remote DN */ + msg->dn = ldb_dn_copy(msg, olddn); + dn = ldb_dn_alloc_linearized(msg, newdn); + if ( ! dn || ! ldb_dn_validate(msg->dn)) { + goto failed; + } + if (ldb_msg_add_empty(msg, IS_MAPPED, LDB_FLAG_MOD_REPLACE, NULL) != 0) { + goto failed; + } + if (ldb_msg_add_string(msg, IS_MAPPED, dn) != 0) { + goto failed; + } + + req->operation = LDB_MODIFY; + req->op.mod.message = msg; + req->controls = NULL; + req->handle = NULL; + req->context = NULL; + req->callback = NULL; + + return req; + +failed: + talloc_free(req); + return NULL; +} + + +/* Asynchronous call structure + * =========================== */ + +/* Figure out which request is currently pending. */ +static struct ldb_request *map_get_req(struct map_context *ac) +{ + switch (ac->step) { + case MAP_SEARCH_SELF_MODIFY: + case MAP_SEARCH_SELF_DELETE: + case MAP_SEARCH_SELF_RENAME: + return ac->search_req; + + case MAP_ADD_REMOTE: + case MAP_MODIFY_REMOTE: + case MAP_DELETE_REMOTE: + case MAP_RENAME_REMOTE: + return ac->remote_req; + + case MAP_RENAME_FIXUP: + return ac->down_req; + + case MAP_ADD_LOCAL: + case MAP_MODIFY_LOCAL: + case MAP_DELETE_LOCAL: + case MAP_RENAME_LOCAL: + return ac->local_req; + + case MAP_SEARCH_REMOTE: + /* Can't happen */ + break; + } + + return NULL; /* unreachable; silences a warning */ +} + +typedef int (*map_next_function)(struct ldb_handle *handle); + +/* Figure out the next request to run. */ +static map_next_function map_get_next(struct map_context *ac) +{ + switch (ac->step) { + case MAP_SEARCH_REMOTE: + return NULL; + + case MAP_ADD_LOCAL: + return map_add_do_remote; + case MAP_ADD_REMOTE: + return NULL; + + case MAP_SEARCH_SELF_MODIFY: + return map_modify_do_local; + case MAP_MODIFY_LOCAL: + return map_modify_do_remote; + case MAP_MODIFY_REMOTE: + return NULL; + + case MAP_SEARCH_SELF_DELETE: + return map_delete_do_local; + case MAP_DELETE_LOCAL: + return map_delete_do_remote; + case MAP_DELETE_REMOTE: + return NULL; + + case MAP_SEARCH_SELF_RENAME: + return map_rename_do_local; + case MAP_RENAME_LOCAL: + return map_rename_do_fixup; + case MAP_RENAME_FIXUP: + return map_rename_do_remote; + case MAP_RENAME_REMOTE: + return NULL; + } + + return NULL; /* unreachable; silences a warning */ +} + +/* Wait for the current pending request to finish and continue with the next. */ +static int map_wait_next(struct ldb_handle *handle) +{ + struct map_context *ac; + struct ldb_request *req; + map_next_function next; + int ret; + + if (handle == NULL || handle->private_data == NULL) { + return LDB_ERR_OPERATIONS_ERROR; + } + + if (handle->state == LDB_ASYNC_DONE) { + return handle->status; + } + + handle->state = LDB_ASYNC_PENDING; + handle->status = LDB_SUCCESS; + + ac = talloc_get_type(handle->private_data, struct map_context); + + if (ac->step == MAP_SEARCH_REMOTE) { + int i; + for (i = 0; i < ac->num_searches; i++) { + req = ac->search_reqs[i]; + ret = ldb_wait(req->handle, LDB_WAIT_NONE); + + if (ret != LDB_SUCCESS) { + handle->status = ret; + goto done; + } + if (req->handle->status != LDB_SUCCESS) { + handle->status = req->handle->status; + goto done; + } + if (req->handle->state != LDB_ASYNC_DONE) { + return LDB_SUCCESS; + } + } + } else { + + req = map_get_req(ac); + + ret = ldb_wait(req->handle, LDB_WAIT_NONE); + + if (ret != LDB_SUCCESS) { + handle->status = ret; + goto done; + } + if (req->handle->status != LDB_SUCCESS) { + handle->status = req->handle->status; + goto done; + } + if (req->handle->state != LDB_ASYNC_DONE) { + return LDB_SUCCESS; + } + + next = map_get_next(ac); + if (next) { + return next(handle); + } + } + + ret = LDB_SUCCESS; + +done: + handle->state = LDB_ASYNC_DONE; + return ret; +} + +/* Wait for all current pending requests to finish. */ +static int map_wait_all(struct ldb_handle *handle) +{ + int ret; + + while (handle->state != LDB_ASYNC_DONE) { + ret = map_wait_next(handle); + if (ret != LDB_SUCCESS) { + return ret; + } + } + + return handle->status; +} + +/* Wait for pending requests to finish. */ +static int map_wait(struct ldb_handle *handle, enum ldb_wait_type type) +{ + if (type == LDB_WAIT_ALL) { + return map_wait_all(handle); + } else { + return map_wait_next(handle); + } +} + + +/* Module initialization + * ===================== */ + +/* Provided module operations */ +static const struct ldb_module_ops map_ops = { + .name = "ldb_map", + .add = map_add, + .modify = map_modify, + .del = map_delete, + .rename = map_rename, + .search = map_search, + .wait = map_wait, +}; + +/* Builtin mappings for DNs and objectClasses */ +static const struct ldb_map_attribute builtin_attribute_maps[] = { + { + .local_name = "dn", + .type = MAP_CONVERT, + .u = { + .convert = { + .remote_name = "dn", + .convert_local = ldb_dn_convert_local, + .convert_remote = ldb_dn_convert_remote, + }, + }, + }, + { + .local_name = "objectClass", + .type = MAP_GENERATE, + .convert_operator = map_objectclass_convert_operator, + .u = { + .generate = { + .remote_names = { "objectClass", NULL }, + .generate_local = map_objectclass_generate_local, + .generate_remote = map_objectclass_generate_remote, + }, + }, + }, + { + .local_name = NULL, + } +}; + +/* Find the special 'MAP_DN_NAME' record and store local and remote + * base DNs in private data. */ +static int map_init_dns(struct ldb_module *module, struct ldb_map_context *data, const char *name) +{ + static const char * const attrs[] = { MAP_DN_FROM, MAP_DN_TO, NULL }; + struct ldb_dn *dn; + struct ldb_message *msg; + struct ldb_result *res; + int ret; + + if (!name) { + data->local_base_dn = NULL; + data->remote_base_dn = NULL; + return LDB_SUCCESS; + } + + dn = ldb_dn_new_fmt(data, module->ldb, "%s=%s", MAP_DN_NAME, name); + if ( ! ldb_dn_validate(dn)) { + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "Failed to construct '%s' DN!\n", MAP_DN_NAME); + return LDB_ERR_OPERATIONS_ERROR; + } + + ret = ldb_search(module->ldb, dn, LDB_SCOPE_BASE, NULL, attrs, &res); + talloc_free(dn); + if (ret != LDB_SUCCESS) { + return ret; + } + if (res->count == 0) { + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "No results for '%s=%s'!\n", MAP_DN_NAME, name); + talloc_free(res); + return LDB_ERR_CONSTRAINT_VIOLATION; + } + if (res->count > 1) { + ldb_debug(module->ldb, LDB_DEBUG_ERROR, "ldb_map: " + "Too many results for '%s=%s'!\n", MAP_DN_NAME, name); + talloc_free(res); + return LDB_ERR_CONSTRAINT_VIOLATION; + } + + msg = res->msgs[0]; + data->local_base_dn = ldb_msg_find_attr_as_dn(module->ldb, data, msg, MAP_DN_FROM); + data->remote_base_dn = ldb_msg_find_attr_as_dn(module->ldb, data, msg, MAP_DN_TO); + talloc_free(res); + + return LDB_SUCCESS; +} + +/* Store attribute maps and objectClass maps in private data. */ +static int map_init_maps(struct ldb_module *module, struct ldb_map_context *data, + const struct ldb_map_attribute *attrs, + const struct ldb_map_objectclass *ocls, + const char * const *wildcard_attributes) +{ + int i, j, last; + last = 0; + + /* Count specified attribute maps */ + for (i = 0; attrs[i].local_name; i++) /* noop */ ; + /* Count built-in attribute maps */ + for (j = 0; builtin_attribute_maps[j].local_name; j++) /* noop */ ; + + /* Store list of attribute maps */ + data->attribute_maps = talloc_array(data, struct ldb_map_attribute, i+j+1); + if (data->attribute_maps == NULL) { + map_oom(module); + return LDB_ERR_OPERATIONS_ERROR; + } + + /* Specified ones go first */ + for (i = 0; attrs[i].local_name; i++) { + data->attribute_maps[last] = attrs[i]; + last++; + } + + /* Built-in ones go last */ + for (i = 0; builtin_attribute_maps[i].local_name; i++) { + data->attribute_maps[last] = builtin_attribute_maps[i]; + last++; + } + + /* Ensure 'local_name == NULL' for the last entry */ + memset(&data->attribute_maps[last], 0, sizeof(struct ldb_map_attribute)); + + /* Store list of objectClass maps */ + data->objectclass_maps = ocls; + + data->wildcard_attributes = wildcard_attributes; + + return LDB_SUCCESS; +} + +/* Copy the list of provided module operations. */ +_PUBLIC_ struct ldb_module_ops ldb_map_get_ops(void) +{ + return map_ops; +} + +/* Initialize global private data. */ +_PUBLIC_ int ldb_map_init(struct ldb_module *module, const struct ldb_map_attribute *attrs, + const struct ldb_map_objectclass *ocls, + const char * const *wildcard_attributes, + const char *name) +{ + struct map_private *data; + int ret; + + /* Prepare private data */ + data = talloc_zero(module, struct map_private); + if (data == NULL) { + map_oom(module); + return LDB_ERR_OPERATIONS_ERROR; + } + + module->private_data = data; + + data->context = talloc_zero(data, struct ldb_map_context); + if (!data->context) { + map_oom(module); + return LDB_ERR_OPERATIONS_ERROR; + } + + /* Store local and remote baseDNs */ + ret = map_init_dns(module, data->context, name); + if (ret != LDB_SUCCESS) { + talloc_free(data); + return ret; + } + + /* Store list of attribute and objectClass maps */ + ret = map_init_maps(module, data->context, attrs, ocls, wildcard_attributes); + if (ret != LDB_SUCCESS) { + talloc_free(data); + return ret; + } + + return LDB_SUCCESS; +} + +/* Usage note for initialization of this module: + * + * ldb_map is meant to be used from a different module that sets up + * the mappings and gets registered in ldb. + * + * 'ldb_map_init' initializes the private data of this module and + * stores the attribute and objectClass maps in there. It also looks + * up the '@MAP' special DN so requests can be redirected to the + * remote partition. + * + * This function should be called from the 'init_context' op of the + * module using ldb_map. + * + * 'ldb_map_get_ops' returns a copy of ldb_maps module operations. + * + * It should be called from the initialize function of the using + * module, which should then override the 'init_context' op with a + * function making the appropriate calls to 'ldb_map_init'. + */ -- cgit From b8d69a7ea2505b706ff7c74d7c97bc89d82dfa07 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 10 Jul 2007 02:46:15 +0000 Subject: r23795: more v2->v3 conversion (This used to be commit 84b468b2f8f2dffda89593f816e8bc6a8b6d42ac) --- source4/lib/ldb/ldb_map/ldb_map.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 64484220b5..62e85db389 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -11,7 +11,7 @@ This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. + version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of -- cgit From 6c973f4e8ccbcb6c9275f8a54e26abb19df7e15a Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 10 Jul 2007 03:42:26 +0000 Subject: r23798: updated old Temple Place FSF addresses to new URL (This used to be commit 40c0919aaa9c1b14bbaebb95ecce53eb0380fdbb) --- source4/lib/ldb/ldb_map/ldb_map.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 62e85db389..39df427c2c 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -19,8 +19,7 @@ Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + License along with this library; if not, see . */ -- cgit From 3e75f222bcdf114238cc4f2bcc61332dc059135f Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 19 Dec 2007 23:27:42 +0100 Subject: r26539: Remove unnecessary statics. (This used to be commit e53e79eebef3ece6978f0a2b4a1ee0a0814bb5d2) --- source4/lib/ldb/ldb_map/ldb_map.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 39df427c2c..87f5f25392 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -867,7 +867,7 @@ static int map_objectclass_convert_operator(struct ldb_module *module, void *mem struct ldb_parse_tree **new, const struct ldb_parse_tree *tree) { - static const struct ldb_map_attribute objectclass_map = { + const struct ldb_map_attribute objectclass_map = { .local_name = "objectClass", .type = MAP_CONVERT, .u = { @@ -956,7 +956,7 @@ struct ldb_request *map_search_self_req(struct map_context *ac, struct ldb_dn *d /* attrs[] is returned from this function in * ac->search_req->op.search.attrs, so it must be static, as * otherwise the compiler can put it on the stack */ - static const char * const attrs[] = { IS_MAPPED, NULL }; + const char * const attrs[] = { IS_MAPPED, NULL }; struct ldb_parse_tree *tree; /* Limit search to records with 'IS_MAPPED' present */ @@ -1242,7 +1242,7 @@ static const struct ldb_map_attribute builtin_attribute_maps[] = { * base DNs in private data. */ static int map_init_dns(struct ldb_module *module, struct ldb_map_context *data, const char *name) { - static const char * const attrs[] = { MAP_DN_FROM, MAP_DN_TO, NULL }; + const char * const attrs[] = { MAP_DN_FROM, MAP_DN_TO, NULL }; struct ldb_dn *dn; struct ldb_message *msg; struct ldb_result *res; -- cgit From 0500b87092540d300b4e021a0fb95ce16a44fbd2 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 20 Dec 2007 00:02:15 +0100 Subject: r26540: Revert my previous commit after concerns raised by Andrew. (This used to be commit 6ac86f8be7d9a8c5ab396a93e6d1e6819e11f173) --- source4/lib/ldb/ldb_map/ldb_map.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 87f5f25392..39df427c2c 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -867,7 +867,7 @@ static int map_objectclass_convert_operator(struct ldb_module *module, void *mem struct ldb_parse_tree **new, const struct ldb_parse_tree *tree) { - const struct ldb_map_attribute objectclass_map = { + static const struct ldb_map_attribute objectclass_map = { .local_name = "objectClass", .type = MAP_CONVERT, .u = { @@ -956,7 +956,7 @@ struct ldb_request *map_search_self_req(struct map_context *ac, struct ldb_dn *d /* attrs[] is returned from this function in * ac->search_req->op.search.attrs, so it must be static, as * otherwise the compiler can put it on the stack */ - const char * const attrs[] = { IS_MAPPED, NULL }; + static const char * const attrs[] = { IS_MAPPED, NULL }; struct ldb_parse_tree *tree; /* Limit search to records with 'IS_MAPPED' present */ @@ -1242,7 +1242,7 @@ static const struct ldb_map_attribute builtin_attribute_maps[] = { * base DNs in private data. */ static int map_init_dns(struct ldb_module *module, struct ldb_map_context *data, const char *name) { - const char * const attrs[] = { MAP_DN_FROM, MAP_DN_TO, NULL }; + static const char * const attrs[] = { MAP_DN_FROM, MAP_DN_TO, NULL }; struct ldb_dn *dn; struct ldb_message *msg; struct ldb_result *res; -- cgit From 27b3c24040b1a7aa88413c477a3769bcd6847d72 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Wed, 16 Jan 2008 09:45:29 +1100 Subject: Allow the 'extra' objectclass added to objectClass attributes by ldb_map to be modified (or omitted). This should allow the current abuse of extensibleObject to be replaced by a normal objectClass, possibly samba4TOP Andrew Bartlett (This used to be commit 8831a5c7935f7e2181252b7b6561541b8c8db679) --- source4/lib/ldb/ldb_map/ldb_map.c | 80 +++++++++++++++++++++++---------------- 1 file changed, 48 insertions(+), 32 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 39df427c2c..9582f36130 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -737,6 +737,7 @@ static struct ldb_val map_objectclass_convert_local(struct ldb_module *module, v /* Generate a remote message with a mapped objectClass. */ static void map_objectclass_generate_remote(struct ldb_module *module, const char *local_attr, const struct ldb_message *old, struct ldb_message *remote, struct ldb_message *local) { + const struct ldb_map_context *data = map_get_context(module); struct ldb_message_element *el, *oc; struct ldb_val val; bool found_extensibleObject = false; @@ -770,16 +771,16 @@ static void map_objectclass_generate_remote(struct ldb_module *module, const cha /* Convert all local objectClasses */ for (i = 0; i < el->num_values - 1; i++) { el->values[i] = map_objectclass_convert_local(module, el->values, &oc->values[i]); - if (ldb_attr_cmp((char *)el->values[i].data, "extensibleObject") == 0) { + if (ldb_attr_cmp((char *)el->values[i].data, data->add_objectclass) == 0) { found_extensibleObject = true; } } if (!found_extensibleObject) { - val.data = (uint8_t *)talloc_strdup(el->values, "extensibleObject"); + val.data = (uint8_t *)talloc_strdup(el->values, data->add_objectclass); val.length = strlen((char *)val.data); - /* Append additional objectClass "extensibleObject" */ + /* Append additional objectClass data->add_objectclass */ el->values[i] = val; } else { el->num_values--; @@ -860,6 +861,19 @@ static struct ldb_message_element *map_objectclass_generate_local(struct ldb_mod return el; } +static const struct ldb_map_attribute objectclass_convert_map = { + .local_name = "objectClass", + .type = MAP_CONVERT, + .u = { + .convert = { + .remote_name = "objectClass", + .convert_local = map_objectclass_convert_local, + .convert_remote = map_objectclass_convert_remote, + }, + }, +}; + + /* Mappings for searches on objectClass= assuming a one-to-one * mapping. Needed because this is a generate operator for the * add/modify code */ @@ -867,19 +881,7 @@ static int map_objectclass_convert_operator(struct ldb_module *module, void *mem struct ldb_parse_tree **new, const struct ldb_parse_tree *tree) { - static const struct ldb_map_attribute objectclass_map = { - .local_name = "objectClass", - .type = MAP_CONVERT, - .u = { - .convert = { - .remote_name = "objectClass", - .convert_local = map_objectclass_convert_local, - .convert_remote = map_objectclass_convert_remote, - }, - }, - }; - - return map_subtree_collect_remote_simple(module, mem_ctx, new, tree, &objectclass_map); + return map_subtree_collect_remote_simple(module, mem_ctx, new, tree, &objectclass_convert_map); } /* Auxiliary request construction @@ -1221,23 +1223,25 @@ static const struct ldb_map_attribute builtin_attribute_maps[] = { }, }, }, - { - .local_name = "objectClass", - .type = MAP_GENERATE, - .convert_operator = map_objectclass_convert_operator, - .u = { - .generate = { - .remote_names = { "objectClass", NULL }, - .generate_local = map_objectclass_generate_local, - .generate_remote = map_objectclass_generate_remote, - }, - }, - }, { .local_name = NULL, } }; +static const struct ldb_map_attribute objectclass_attribute_map = { + .local_name = "objectClass", + .type = MAP_GENERATE, + .convert_operator = map_objectclass_convert_operator, + .u = { + .generate = { + .remote_names = { "objectClass", NULL }, + .generate_local = map_objectclass_generate_local, + .generate_remote = map_objectclass_generate_remote, + }, + }, +}; + + /* Find the special 'MAP_DN_NAME' record and store local and remote * base DNs in private data. */ static int map_init_dns(struct ldb_module *module, struct ldb_map_context *data, const char *name) @@ -1302,7 +1306,7 @@ static int map_init_maps(struct ldb_module *module, struct ldb_map_context *data for (j = 0; builtin_attribute_maps[j].local_name; j++) /* noop */ ; /* Store list of attribute maps */ - data->attribute_maps = talloc_array(data, struct ldb_map_attribute, i+j+1); + data->attribute_maps = talloc_array(data, struct ldb_map_attribute, i+j+2); if (data->attribute_maps == NULL) { map_oom(module); return LDB_ERR_OPERATIONS_ERROR; @@ -1320,6 +1324,15 @@ static int map_init_maps(struct ldb_module *module, struct ldb_map_context *data last++; } + if (data->add_objectclass) { + /* ObjectClass one is very last, if required */ + data->attribute_maps[last] = objectclass_attribute_map; + last++; + } else if (ocls) { + data->attribute_maps[last] = objectclass_convert_map; + last++; + } + /* Ensure 'local_name == NULL' for the last entry */ memset(&data->attribute_maps[last], 0, sizeof(struct ldb_map_attribute)); @@ -1339,9 +1352,10 @@ _PUBLIC_ struct ldb_module_ops ldb_map_get_ops(void) /* Initialize global private data. */ _PUBLIC_ int ldb_map_init(struct ldb_module *module, const struct ldb_map_attribute *attrs, - const struct ldb_map_objectclass *ocls, - const char * const *wildcard_attributes, - const char *name) + const struct ldb_map_objectclass *ocls, + const char * const *wildcard_attributes, + const char *add_objectclass, + const char *name) { struct map_private *data; int ret; @@ -1368,6 +1382,8 @@ _PUBLIC_ int ldb_map_init(struct ldb_module *module, const struct ldb_map_attrib return ret; } + data->context->add_objectclass = add_objectclass; + /* Store list of attribute and objectClass maps */ ret = map_init_maps(module, data->context, attrs, ocls, wildcard_attributes); if (ret != LDB_SUCCESS) { -- cgit From 16109a40c0abd8c30a5eb9bf9ef692bfae9dfc7d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 20 Feb 2008 01:54:32 +0100 Subject: Use struct-based rather than function-based initialization for ldb modules everywhere. (This used to be commit 85c96a325867f7bcdb412ebc53f8a47dbf7cd89b) --- source4/lib/ldb/ldb_map/ldb_map.c | 38 +------------------------------------- 1 file changed, 1 insertion(+), 37 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 9582f36130..9c189feb11 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -1186,7 +1186,7 @@ static int map_wait_all(struct ldb_handle *handle) } /* Wait for pending requests to finish. */ -static int map_wait(struct ldb_handle *handle, enum ldb_wait_type type) +int map_wait(struct ldb_handle *handle, enum ldb_wait_type type) { if (type == LDB_WAIT_ALL) { return map_wait_all(handle); @@ -1199,16 +1199,6 @@ static int map_wait(struct ldb_handle *handle, enum ldb_wait_type type) /* Module initialization * ===================== */ -/* Provided module operations */ -static const struct ldb_module_ops map_ops = { - .name = "ldb_map", - .add = map_add, - .modify = map_modify, - .del = map_delete, - .rename = map_rename, - .search = map_search, - .wait = map_wait, -}; /* Builtin mappings for DNs and objectClasses */ static const struct ldb_map_attribute builtin_attribute_maps[] = { @@ -1344,12 +1334,6 @@ static int map_init_maps(struct ldb_module *module, struct ldb_map_context *data return LDB_SUCCESS; } -/* Copy the list of provided module operations. */ -_PUBLIC_ struct ldb_module_ops ldb_map_get_ops(void) -{ - return map_ops; -} - /* Initialize global private data. */ _PUBLIC_ int ldb_map_init(struct ldb_module *module, const struct ldb_map_attribute *attrs, const struct ldb_map_objectclass *ocls, @@ -1393,23 +1377,3 @@ _PUBLIC_ int ldb_map_init(struct ldb_module *module, const struct ldb_map_attrib return LDB_SUCCESS; } - -/* Usage note for initialization of this module: - * - * ldb_map is meant to be used from a different module that sets up - * the mappings and gets registered in ldb. - * - * 'ldb_map_init' initializes the private data of this module and - * stores the attribute and objectClass maps in there. It also looks - * up the '@MAP' special DN so requests can be redirected to the - * remote partition. - * - * This function should be called from the 'init_context' op of the - * module using ldb_map. - * - * 'ldb_map_get_ops' returns a copy of ldb_maps module operations. - * - * It should be called from the initialize function of the using - * module, which should then override the 'init_context' op with a - * function making the appropriate calls to 'ldb_map_init'. - */ -- cgit From ca46ad25b8ee43d50383cefb804694fe27595d33 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Mon, 21 Jul 2008 11:18:21 +1000 Subject: Fix ldb_map to add/remove the same 'extra' objectclass The code previously added data->add_objectClass, but only removed the fixed objectclass of extensibleObject. Found by the ldap.py test. Andrew Bartlett (This used to be commit 4fa15c3173a997fa0b9041161d81e742e1fdb41c) --- source4/lib/ldb/ldb_map/ldb_map.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source4/lib/ldb/ldb_map/ldb_map.c') diff --git a/source4/lib/ldb/ldb_map/ldb_map.c b/source4/lib/ldb/ldb_map/ldb_map.c index 9c189feb11..b3f639dc67 100644 --- a/source4/lib/ldb/ldb_map/ldb_map.c +++ b/source4/lib/ldb/ldb_map/ldb_map.c @@ -810,6 +810,7 @@ static struct ldb_val map_objectclass_convert_remote(struct ldb_module *module, /* Generate a local message with a mapped objectClass. */ static struct ldb_message_element *map_objectclass_generate_local(struct ldb_module *module, void *mem_ctx, const char *local_attr, const struct ldb_message *remote) { + const struct ldb_map_context *data = map_get_context(module); struct ldb_message_element *el, *oc; struct ldb_val val; int i; @@ -844,10 +845,10 @@ static struct ldb_message_element *map_objectclass_generate_local(struct ldb_mod el->values[i] = map_objectclass_convert_remote(module, el->values, &oc->values[i]); } - val.data = (uint8_t *)talloc_strdup(el->values, "extensibleObject"); + val.data = (uint8_t *)talloc_strdup(el->values, data->add_objectclass); val.length = strlen((char *)val.data); - /* Remove last value if it was "extensibleObject" */ + /* Remove last value if it was the string in data->add_objectclass (eg samba4top, extensibleObject) */ if (ldb_val_equal_exact(&val, &el->values[i-1])) { el->num_values--; el->values = talloc_realloc(el, el->values, struct ldb_val, el->num_values); -- cgit