* - 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];
}
}
/* 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;
}
-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;
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(module, tree, sizeof(*tree));
/* Find attr in question and:
* - if it has a convert_operator function, run that
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 = 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]);
}
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 = 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;
}
* (all have attr as the first element)
*/
- attr = map_find_attr_local(module, tree->u.equality.attr);
+ 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));
- return new_tree;
+ 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 (attr->type == MAP_IGNORE)
+ if (map_type == MAP_IGNORE)
return NULL;
- if (attr->convert_operator) {
- /* Run convert_operator */
- talloc_free(new_tree);
- new_tree = attr->convert_operator(module, tree);
- } else {
+ 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 (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_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;
if (dn == NULL)
return NULL;
- newdn = talloc_memdup(module, dn, sizeof(*dn));
+ newdn = talloc_memdup(ctx, dn, sizeof(*dn));
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;
* 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)
- 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) 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;
- }
-
- 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);
+ 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;
- 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;
* 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)
- 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) 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, &eqtree);
-
- /* Silently continue for now */
- if (!new_eqtree) {
- DEBUG(0, ("Unable to convert RDN for attribute %s\n", dn->components[i].name));
- continue;
- }
+ 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;
- 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);
+ 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;
}
}
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;
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:
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 */
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;
+ 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() */
}
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);
- elm = talloc_memdup(msg, oldelm, sizeof(*oldelm));
+ 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, 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);
+ 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);
- ldb_msg_add(module->ldb, msg, elm, 0);
+ 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:
- ldb_msg_add(module->ldb, msg, ldb_msg_find_element(mi, attr->local_name), 0);
+ 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(msg, attr->local_name, mi);
- ldb_msg_add(module->ldb, msg, elm, 0);
+ 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:
DEBUG(0, ("Unknown attr->type for %s", attr->local_name));
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_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_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 = 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:
- 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:
- attr->u.generate.generate_remote(attr->local_name, mo, msg);
+ attr->u.generate.generate_remote(privdat, attr->local_name, mo, msg);
break;
}
}
*/
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);
*/
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);
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, tree);
+ 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);
}
-
-
/*
modify a record
*/
/* 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;
return NULL;
}
- data->attribute_maps = attrs;
- data->objectclass_maps = ocls;
+ 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;
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,
+ }
+};
+
git.samba.org / sfrench / samba-autobuild / .git / blobdiff