mirror of
https://github.com/samba-team/samba.git
synced 2024-12-24 21:34:56 +03:00
1157 lines
29 KiB
C
1157 lines
29 KiB
C
/*
|
|
ldb database mapping module
|
|
|
|
Copyright (C) Jelmer Vernooij 2005
|
|
Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
|
|
Copyright (C) Simo Sorce 2008
|
|
|
|
** 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 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
|
|
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, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
/*
|
|
* 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 "replace.h"
|
|
#include "system/filesys.h"
|
|
#include "system/time.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(ldb_module_get_private(module), struct map_private);
|
|
return data->context;
|
|
}
|
|
|
|
/* Create a generic request context. */
|
|
struct map_context *map_init_context(struct ldb_module *module,
|
|
struct ldb_request *req)
|
|
{
|
|
struct ldb_context *ldb;
|
|
struct map_context *ac;
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
ac = talloc_zero(req, struct map_context);
|
|
if (ac == NULL) {
|
|
ldb_set_errstring(ldb, "Out of Memory");
|
|
return NULL;
|
|
}
|
|
|
|
ac->module = module;
|
|
ac->req = req;
|
|
|
|
return ac;
|
|
}
|
|
|
|
/* 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_context *ldb;
|
|
struct ldb_message *msg;
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
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);
|
|
if (msg == NULL) {
|
|
return LDB_ERR_OPERATIONS_ERROR;
|
|
}
|
|
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);
|
|
if (msg == NULL) {
|
|
return LDB_ERR_OPERATIONS_ERROR;
|
|
}
|
|
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(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"Invalid remote request!");
|
|
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)
|
|
{
|
|
unsigned 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)
|
|
{
|
|
unsigned 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)
|
|
{
|
|
unsigned 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;
|
|
unsigned 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 LDB_MAP_IGNORE:
|
|
break;
|
|
|
|
case LDB_MAP_KEEP:
|
|
if (ldb_attr_cmp(map->local_name, name) == 0) {
|
|
return map;
|
|
}
|
|
break;
|
|
|
|
case LDB_MAP_RENAME:
|
|
case LDB_MAP_RENDROP:
|
|
case LDB_MAP_CONVERT:
|
|
if (ldb_attr_cmp(map->u.rename.remote_name, name) == 0) {
|
|
return map;
|
|
}
|
|
break;
|
|
|
|
case LDB_MAP_GENERATE:
|
|
for (j = 0; 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 == LDB_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 LDB_MAP_KEEP:
|
|
return talloc_strdup(mem_ctx, attr);
|
|
|
|
case LDB_MAP_RENAME:
|
|
case LDB_MAP_RENDROP:
|
|
case LDB_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 == LDB_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)
|
|
{
|
|
unsigned 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 == LDB_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 == LDB_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_context *ldb;
|
|
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;
|
|
}
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
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 = LDB_MAP_KEEP;
|
|
} else {
|
|
map_type = map->type;
|
|
}
|
|
|
|
switch (map_type) {
|
|
case LDB_MAP_IGNORE:
|
|
case LDB_MAP_GENERATE:
|
|
ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"LDB_MAP_IGNORE/LDB_MAP_GENERATE attribute '%s' "
|
|
"used in DN!", ldb_dn_get_component_name(dn, i));
|
|
goto failed;
|
|
|
|
case LDB_MAP_CONVERT:
|
|
if (map->u.convert.convert_local == NULL) {
|
|
ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"'convert_local' not set for attribute '%s' "
|
|
"used in DN!", ldb_dn_get_component_name(dn, i));
|
|
goto failed;
|
|
}
|
|
|
|
FALL_THROUGH;
|
|
case LDB_MAP_KEEP:
|
|
case LDB_MAP_RENAME:
|
|
case LDB_MAP_RENDROP:
|
|
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_context *ldb;
|
|
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;
|
|
}
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
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 = LDB_MAP_KEEP;
|
|
} else {
|
|
map_type = map->type;
|
|
}
|
|
|
|
switch (map_type) {
|
|
case LDB_MAP_IGNORE:
|
|
case LDB_MAP_GENERATE:
|
|
ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"LDB_MAP_IGNORE/LDB_MAP_GENERATE attribute '%s' "
|
|
"used in DN!", ldb_dn_get_component_name(dn, i));
|
|
goto failed;
|
|
|
|
case LDB_MAP_CONVERT:
|
|
if (map->u.convert.convert_remote == NULL) {
|
|
ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"'convert_remote' not set for attribute '%s' "
|
|
"used in DN!", ldb_dn_get_component_name(dn, i));
|
|
goto failed;
|
|
}
|
|
|
|
FALL_THROUGH;
|
|
case LDB_MAP_KEEP:
|
|
case LDB_MAP_RENAME:
|
|
case LDB_MAP_RENDROP:
|
|
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_context *ldb;
|
|
struct ldb_dn *dn, *newdn;
|
|
struct ldb_val newval;
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
dn = ldb_dn_from_ldb_val(mem_ctx, ldb, val);
|
|
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_context *ldb;
|
|
struct ldb_dn *dn, *newdn;
|
|
struct ldb_val newval;
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
dn = ldb_dn_from_ldb_val(mem_ctx, ldb, val);
|
|
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)
|
|
{
|
|
const struct ldb_map_context *data = map_get_context(module);
|
|
struct ldb_context *ldb;
|
|
struct ldb_message_element *el, *oc;
|
|
struct ldb_val val;
|
|
bool found_extensibleObject = false;
|
|
unsigned int i;
|
|
int ret;
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
/* 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(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(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, data->add_objectclass) == 0) {
|
|
found_extensibleObject = true;
|
|
}
|
|
}
|
|
|
|
if (!found_extensibleObject) {
|
|
val.data = (uint8_t *)talloc_strdup(el->values, data->add_objectclass);
|
|
val.length = strlen((char *)val.data);
|
|
|
|
/* Append additional objectClass data->add_objectclass */
|
|
el->values[i] = val;
|
|
} else {
|
|
el->num_values--;
|
|
}
|
|
|
|
/* Add new objectClass to remote message */
|
|
ret = ldb_msg_add(remote, el, 0);
|
|
if (ret != LDB_SUCCESS) {
|
|
ldb_oom(ldb);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
const struct ldb_map_context *data = map_get_context(module);
|
|
struct ldb_context *ldb;
|
|
struct ldb_message_element *el, *oc;
|
|
struct ldb_val val;
|
|
unsigned int i;
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
/* 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(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(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, data->add_objectclass);
|
|
val.length = strlen((char *)val.data);
|
|
|
|
/* 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);
|
|
if (el->values == NULL) {
|
|
talloc_free(el);
|
|
ldb_oom(ldb);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return el;
|
|
}
|
|
|
|
static const struct ldb_map_attribute objectclass_convert_map = {
|
|
.local_name = "objectClass",
|
|
.type = LDB_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 */
|
|
static int map_objectclass_convert_operator(struct ldb_module *module, void *mem_ctx,
|
|
struct ldb_parse_tree **new, const struct ldb_parse_tree *tree)
|
|
{
|
|
|
|
return map_subtree_collect_remote_simple(module, mem_ctx, new, tree, &objectclass_convert_map);
|
|
}
|
|
|
|
/* Auxiliary request construction
|
|
* ============================== */
|
|
|
|
/* 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, struct ldb_parse_tree *tree, void *context, ldb_map_callback_t callback)
|
|
{
|
|
struct ldb_parse_tree *search_tree;
|
|
struct ldb_context *ldb;
|
|
struct ldb_request *req;
|
|
int ret;
|
|
|
|
ldb = ldb_module_get_ctx(ac->module);
|
|
|
|
if (tree) {
|
|
search_tree = tree;
|
|
} else {
|
|
search_tree = ldb_parse_tree(ac, NULL);
|
|
if (search_tree == NULL) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
ret = ldb_build_search_req_ex(&req, ldb, ac,
|
|
dn, LDB_SCOPE_BASE,
|
|
search_tree, attrs,
|
|
NULL,
|
|
context, callback,
|
|
ac->req);
|
|
LDB_REQ_SET_LOCATION(req);
|
|
if (ret != LDB_SUCCESS) {
|
|
return NULL;
|
|
}
|
|
|
|
return req;
|
|
}
|
|
|
|
/* 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,
|
|
void *context,
|
|
ldb_map_callback_t callback)
|
|
{
|
|
struct ldb_context *ldb;
|
|
struct ldb_request *req;
|
|
struct ldb_message *msg;
|
|
const char *dn;
|
|
int ret;
|
|
|
|
ldb = ldb_module_get_ctx(ac->module);
|
|
|
|
/* Prepare message */
|
|
msg = ldb_msg_new(ac);
|
|
if (msg == NULL) {
|
|
map_oom(ac->module);
|
|
return NULL;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/* Prepare request */
|
|
ret = ldb_build_mod_req(&req, ldb,
|
|
ac, msg, NULL,
|
|
context, callback,
|
|
ac->req);
|
|
LDB_REQ_SET_LOCATION(req);
|
|
if (ret != LDB_SUCCESS) {
|
|
goto failed;
|
|
}
|
|
talloc_steal(req, msg);
|
|
|
|
return req;
|
|
failed:
|
|
talloc_free(msg);
|
|
return NULL;
|
|
}
|
|
|
|
/* Module initialization
|
|
* ===================== */
|
|
|
|
|
|
/* Builtin mappings for DNs and objectClasses */
|
|
static const struct ldb_map_attribute builtin_attribute_maps[] = {
|
|
{
|
|
.local_name = "dn",
|
|
.type = LDB_MAP_CONVERT,
|
|
.u = {
|
|
.convert = {
|
|
.remote_name = "dn",
|
|
.convert_local = ldb_dn_convert_local,
|
|
.convert_remote = ldb_dn_convert_remote,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
.local_name = NULL,
|
|
}
|
|
};
|
|
|
|
static const struct ldb_map_attribute objectclass_attribute_map = {
|
|
.local_name = "objectClass",
|
|
.type = LDB_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)
|
|
{
|
|
static const char * const attrs[] = { MAP_DN_FROM, MAP_DN_TO, NULL };
|
|
struct ldb_context *ldb;
|
|
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;
|
|
}
|
|
|
|
ldb = ldb_module_get_ctx(module);
|
|
|
|
dn = ldb_dn_new_fmt(data, ldb, "%s=%s", MAP_DN_NAME, name);
|
|
if ( ! ldb_dn_validate(dn)) {
|
|
ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"Failed to construct '%s' DN!", MAP_DN_NAME);
|
|
return LDB_ERR_OPERATIONS_ERROR;
|
|
}
|
|
|
|
ret = ldb_search(ldb, data, &res, dn, LDB_SCOPE_BASE, attrs, NULL);
|
|
talloc_free(dn);
|
|
if (ret != LDB_SUCCESS) {
|
|
return ret;
|
|
}
|
|
if (res->count == 0) {
|
|
ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"No results for '%s=%s'!", MAP_DN_NAME, name);
|
|
talloc_free(res);
|
|
return LDB_ERR_CONSTRAINT_VIOLATION;
|
|
}
|
|
if (res->count > 1) {
|
|
ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
|
|
"Too many results for '%s=%s'!", 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(ldb, data, msg, MAP_DN_FROM);
|
|
data->remote_base_dn = ldb_msg_find_attr_as_dn(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)
|
|
{
|
|
unsigned 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+2);
|
|
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++;
|
|
}
|
|
|
|
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));
|
|
|
|
/* Store list of objectClass maps */
|
|
data->objectclass_maps = ocls;
|
|
|
|
data->wildcard_attributes = wildcard_attributes;
|
|
|
|
return LDB_SUCCESS;
|
|
}
|
|
|
|
/* 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 *add_objectclass,
|
|
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;
|
|
}
|
|
|
|
ldb_module_set_private(module, 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;
|
|
}
|
|
|
|
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) {
|
|
talloc_free(data);
|
|
return ret;
|
|
}
|
|
|
|
return LDB_SUCCESS;
|
|
}
|