1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00

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 b7b079167d)
This commit is contained in:
Jelmer Vernooij 2005-08-27 23:47:17 +00:00 committed by Gerald (Jerry) Carter
parent 3c265c7986
commit 95ed275dbb
6 changed files with 358 additions and 213 deletions

View File

@ -187,14 +187,14 @@ enum smb_signing_state {SMB_SIGNING_OFF, SMB_SIGNING_SUPPORTED,
#define NTCREATEX_ACTION_UNKNOWN 5
/* used to hold an arbitrary blob of data */
typedef struct data_blob {
typedef struct datablob {
uint8_t *data;
size_t length;
} DATA_BLOB;
/* by making struct ldb_val and DATA_BLOB the same, we can simplify
a fair bit of code */
#define ldb_val data_blob
#define ldb_val datablob
/* 64 bit time (100 nanosec) 1601 - cifs6.txt, section 3.5, page 30, 4 byte aligned */
typedef uint64_t NTTIME;

View File

@ -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 (!strcmp(privdat->attribute_maps[i].u.rename.remote_name, attr))
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;
@ -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(privdat, tree->u.equality.attr);
attr = map_find_attr_local(module, 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));
return new_tree;
} else {
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;
@ -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 };
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;
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_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;
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;
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]);
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,
}
};

View File

@ -38,13 +38,15 @@
* returning too much attributes in ldb_search() doesn't)
*/
struct ldb_map_context;
struct ldb_map_attribute
{
const char *local_name; /* local name */
enum {
enum ldb_map_attr_type {
MAP_IGNORE, /* Ignore this local attribute. Doesn't exist remotely. */
MAP_KEEP, /* Keep as is */
MAP_KEEP, /* Keep as is. Same name locally and remotely. */
MAP_RENAME, /* Simply rename the attribute. Name changes, data is the same */
MAP_CONVERT, /* Rename + convert data */
MAP_GENERATE /* Use generate function for generating new name/data.
@ -53,7 +55,7 @@ struct ldb_map_attribute
} type;
/* if set, will be called for expressions that contain this attribute */
struct ldb_parse_tree *(*convert_operator) (TALLOC_CTX *ctx, const struct ldb_parse_tree *);
struct ldb_parse_tree *(*convert_operator) (struct ldb_map_context *, TALLOC_CTX *ctx, const struct ldb_parse_tree *);
union {
struct {
@ -62,27 +64,21 @@ struct ldb_map_attribute
struct {
const char *remote_name;
struct ldb_message_element *(*convert_local) (
TALLOC_CTX *ctx,
const char *remote_attr,
const struct ldb_message_element *);
struct ldb_message_element *(*convert_remote) (
TALLOC_CTX *ctx,
const char *local_attr,
const struct ldb_message_element *);
struct ldb_val (*convert_local) (struct ldb_map_context *, TALLOC_CTX *, const struct ldb_val *);
struct ldb_val (*convert_remote) (struct ldb_map_context *, TALLOC_CTX *, const struct ldb_val *);
} convert;
struct {
/* Generate the local attribute from remote message */
struct ldb_message_element *(*generate_local) (
struct ldb_map_context *,
TALLOC_CTX *ctx,
const char *attr,
const char *attr,
const struct ldb_message *remote);
/* Update remote message with information from local message */
void (*generate_remote) (
struct ldb_map_context *,
const char *local_attr,
const struct ldb_message *local,
struct ldb_message *remote);
@ -102,4 +98,10 @@ struct ldb_map_objectclass
const char *remote_name;
};
struct ldb_map_context
{
struct ldb_map_attribute *attribute_maps;
const struct ldb_map_objectclass *objectclass_maps;
};
#endif /* __LDB_MAP_H__ */

View File

@ -60,86 +60,39 @@
* sambaMungedDial
* sambaLogonHours */
static struct ldb_message_element *convert_sid_rid(TALLOC_CTX *ctx, const char *remote_attr, const struct ldb_message_element *el)
static struct ldb_val convert_sid_rid(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
{
struct ldb_message_element *ret = talloc(ctx, struct ldb_message_element);
int i;
printf("Converting SID TO RID *\n");
ret->flags = el->flags;
ret->name = talloc_strdup(ret, remote_attr);
ret->num_values = el->num_values;
ret->values = talloc_array(ret, struct ldb_val, ret->num_values);
for (i = 0; i < ret->num_values; i++) {
ret->values[i] = ldb_val_dup(ret->values, &el->values[i]);
}
return ret;
return ldb_val_dup(ctx, val);
}
static struct ldb_message_element *convert_rid_sid(TALLOC_CTX *ctx, const char *remote_attr, const struct ldb_message_element *el)
static struct ldb_val convert_rid_sid(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
{
struct ldb_message_element *ret = talloc(ctx, struct ldb_message_element);
int i;
printf("Converting RID TO SID *\n");
ret->flags = el->flags;
ret->name = talloc_strdup(ret, remote_attr);
ret->num_values = el->num_values;
ret->values = talloc_array(ret, struct ldb_val, ret->num_values);
for (i = 0; i < ret->num_values; i++) {
ret->values[i] = ldb_val_dup(ret->values, &el->values[i]);
}
return ret;
return ldb_val_dup(ctx, val);
}
static struct ldb_message_element *convert_unix_id2name(TALLOC_CTX *ctx, const char *remote_attr, const struct ldb_message_element *el)
static struct ldb_val convert_unix_id2name(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
{
int i;
struct ldb_message_element *ret = talloc(ctx, struct ldb_message_element);
printf("Converting UNIX ID to name\n");
ret->flags = el->flags;
ret->name = talloc_strdup(ret, remote_attr);
ret->num_values = el->num_values;
ret->values = talloc_array(ret, struct ldb_val, ret->num_values);
for (i = 0; i < ret->num_values; i++) {
ret->values[i] = ldb_val_dup(ret->values, &el->values[i]);
}
return ret;
return ldb_val_dup(ctx, val);
}
static struct ldb_message_element *convert_unix_name2id(TALLOC_CTX *ctx, const char *remote_attr, const struct ldb_message_element *el)
static struct ldb_val convert_unix_name2id(struct ldb_map_context *map, TALLOC_CTX *ctx, const struct ldb_val *val)
{
struct ldb_message_element *ret = talloc(ctx, struct ldb_message_element);
int i;
printf("Converting UNIX name to ID\n");
ret->flags = el->flags;
ret->name = talloc_strdup(ret, remote_attr);
ret->num_values = el->num_values;
ret->values = talloc_array(ret, struct ldb_val, ret->num_values);
for (i = 0; i < ret->num_values; i++) {
ret->values[i] = ldb_val_dup(ret->values, &el->values[i]);
}
return ret;
return ldb_val_dup(ctx, val);
}
const struct ldb_map_objectclass samba3_objectclasses[] = {
{ "group", "sambaGroupMapping" },
{ "user", "sambaSAMAccount" },
{ "domain", "sambaDomain" },
{ NULL, NULL }
};
const struct ldb_map_attribute samba3_attributes[] =
@ -253,12 +206,21 @@ const struct ldb_map_attribute samba3_attributes[] =
.u.rename.remote_name = "sambaSID",
},
/* sambaPwdLastSet -> pwdLastSet*/
/* sambaPwdLastSet -> pwdLastSet */
{
.local_name = "pwdLastSet",
.type = MAP_RENAME,
.u.rename.remote_name = "sambaPwdLastSet",
},
/* cn -> cn */
{
.local_name = "cn",
.type = MAP_KEEP,
},
{
.local_name = NULL,
}
};
/* the init function */

View File

@ -30,5 +30,18 @@ echo "Checking for existance of record (mapped)"
$VALGRIND ldbsearch $OPT "(cn=Foo)" unixName lastLogon cn || exit 1
echo "Checking for existance of record (non-mapped)"
$VALGRIND ldbsearch $LOC "(cn=Foo)" uid sambaLogonTime cn || exit 1
$VALGRIND ldbsearch $LOC"(cn=foo)" uid sambaLogonTime cn || exit 1
echo "Adding record with mapped attribute in dn"
$VALGRIND ldbadd $OPT <<EOF
dn: unixName=nobody,dc=idealx,dc=org
unixName: nobody
cn: Niemand
EOF
echo "Checking for existance of record (mapped)"
$VALGRIND ldbsearch $OPT "(unixName=nobody)" unixName cn dn || exit 1
echo "Checking for existance of record (non-mapped)"
$VALGRIND ldbsearch $OPT "(uid=nobody)" unixName cn dn || exit 1

View File

@ -323,7 +323,7 @@ struct MprVar mprNTSTATUS(NTSTATUS status)
struct MprVar mprDataBlob(DATA_BLOB blob)
{
struct MprVar res;
struct data_blob *pblob = talloc(mprMemCtx(), struct data_blob);
DATA_BLOB *pblob = talloc(mprMemCtx(), DATA_BLOB);
*pblob = data_blob_talloc(pblob, blob.data, blob.length);
res = mprObject("DATA_BLOB");