lib/ldb/ldb_map/ldb_map.c

   1 /*
   2    ldb database mapping module
   3
   4    Copyright (C) Jelmer Vernooij 2005
   5    Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
   6    Copyright (C) Simo Sorce 2008
   7
   8      ** NOTE! The following LGPL license applies to the ldb
   9      ** library. This does NOT imply that all of Samba is released
  10      ** under the LGPL
  11
  12    This library is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Lesser General Public
  14    License as published by the Free Software Foundation; either
  15    version 3 of the License, or (at your option) any later version.
  16
  17    This library is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    Lesser General Public License for more details.
  21
  22    You should have received a copy of the GNU Lesser General Public
  23    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  24
  25 */
  26
  27 /*
  28  *  Name: ldb
  29  *
  30  *  Component: ldb ldb_map module
  31  *
  32  *  Description: Map portions of data into a different format on a
  33  *  remote partition.
  34  *
  35  *  Author: Jelmer Vernooij, Martin Kuehl
  36  */
  37
  38 #include "replace.h"
  39 #include "system/filesys.h"
  40 #include "system/time.h"
  41 #include "ldb_map.h"
  42 #include "ldb_map_private.h"
  43
  44 #ifndef _PUBLIC_
  45 #define _PUBLIC_
  46 #endif
  47
  48 /* Description of the provided ldb requests:
  49  - special attribute 'isMapped'
  50
  51  - search:
  52      - if parse tree can be split
  53          - search remote records w/ remote attrs and parse tree
  54      - otherwise
  55          - enumerate all remote records
  56      - for each remote result
  57          - map remote result to local message
  58          - search local result
  59          - is present
  60              - merge local into remote result
  61              - run callback on merged result
  62          - otherwise
  63              - run callback on remote result
  64
  65  - add:
  66      - split message into local and remote part
  67      - if local message is not empty
  68          - add isMapped to local message
  69          - add local message
  70      - add remote message
  71
  72  - modify:
  73      - split message into local and remote part
  74      - if local message is not empty
  75          - add isMapped to local message
  76          - search for local record
  77          - if present
  78              - modify local record
  79          - otherwise
  80              - add local message
  81      - modify remote record
  82
  83  - delete:
  84      - search for local record
  85      - if present
  86          - delete local record
  87      - delete remote record
  88
  89  - rename:
  90      - search for local record
  91      - if present
  92          - rename local record
  93          - modify local isMapped
  94      - rename remote record
  95 */
  96
  97
  98
  99 /* Private data structures
 100  * ======================= */
 101
 102 /* Global private data */
 103 /* Extract mappings from private data. */
 104 const struct ldb_map_context *map_get_context(struct ldb_module *module)
 105 {
 106         const struct map_private *data = talloc_get_type(ldb_module_get_private(module), struct map_private);
 107         return data->context;
 108 }
 109
 110 /* Create a generic request context. */
 111 struct map_context *map_init_context(struct ldb_module *module,
 112                                         struct ldb_request *req)
 113 {
 114         struct ldb_context *ldb;
 115         struct map_context *ac;
 116
 117         ldb = ldb_module_get_ctx(module);
 118
 119         ac = talloc_zero(req, struct map_context);
 120         if (ac == NULL) {
 121                 ldb_set_errstring(ldb, "Out of Memory");
 122                 return NULL;
 123         }
 124
 125         ac->module = module;
 126         ac->req = req;
 127
 128         return ac;
 129 }
 130
 131 /* Dealing with DNs for different partitions
 132  * ========================================= */
 133
 134 /* Check whether any data should be stored in the local partition. */
 135 bool map_check_local_db(struct ldb_module *module)
 136 {
 137         const struct ldb_map_context *data = map_get_context(module);
 138
 139         if (!data->remote_base_dn || !data->local_base_dn) {
 140                 return false;
 141         }
 142
 143         return true;
 144 }
 145
 146 /* Copy a DN with the base DN of the local partition. */
 147 static struct ldb_dn *ldb_dn_rebase_local(void *mem_ctx, const struct ldb_map_context *data, struct ldb_dn *dn)
 148 {
 149         struct ldb_dn *new_dn;
 150
 151         new_dn = ldb_dn_copy(mem_ctx, dn);
 152         if ( ! ldb_dn_validate(new_dn)) {
 153                 talloc_free(new_dn);
 154                 return NULL;
 155         }
 156
 157         /* may be we don't need to rebase at all */
 158         if ( ! data->remote_base_dn || ! data->local_base_dn) {
 159                 return new_dn;
 160         }
 161
 162         if ( ! ldb_dn_remove_base_components(new_dn, ldb_dn_get_comp_num(data->remote_base_dn))) {
 163                 talloc_free(new_dn);
 164                 return NULL;
 165         }
 166
 167         if ( ! ldb_dn_add_base(new_dn, data->local_base_dn)) {
 168                 talloc_free(new_dn);
 169                 return NULL;
 170         }
 171
 172         return new_dn;
 173 }
 174
 175 /* Copy a DN with the base DN of the remote partition. */
 176 static struct ldb_dn *ldb_dn_rebase_remote(void *mem_ctx, const struct ldb_map_context *data, struct ldb_dn *dn)
 177 {
 178         struct ldb_dn *new_dn;
 179
 180         new_dn = ldb_dn_copy(mem_ctx, dn);
 181         if ( ! ldb_dn_validate(new_dn)) {
 182                 talloc_free(new_dn);
 183                 return NULL;
 184         }
 185
 186         /* may be we don't need to rebase at all */
 187         if ( ! data->remote_base_dn || ! data->local_base_dn) {
 188                 return new_dn;
 189         }
 190
 191         if ( ! ldb_dn_remove_base_components(new_dn, ldb_dn_get_comp_num(data->local_base_dn))) {
 192                 talloc_free(new_dn);
 193                 return NULL;
 194         }
 195
 196         if ( ! ldb_dn_add_base(new_dn, data->remote_base_dn)) {
 197                 talloc_free(new_dn);
 198                 return NULL;
 199         }
 200
 201         return new_dn;
 202 }
 203
 204 /* Run a request and make sure it targets the remote partition. */
 205 /* TODO: free old DNs and messages? */
 206 int ldb_next_remote_request(struct ldb_module *module, struct ldb_request *request)
 207 {
 208         const struct ldb_map_context *data = map_get_context(module);
 209         struct ldb_context *ldb;
 210         struct ldb_message *msg;
 211
 212         ldb = ldb_module_get_ctx(module);
 213
 214         switch (request->operation) {
 215         case LDB_SEARCH:
 216                 if (request->op.search.base) {
 217                         request->op.search.base = ldb_dn_rebase_remote(request, data, request->op.search.base);
 218                 } else {
 219                         request->op.search.base = data->remote_base_dn;
 220                         /* TODO: adjust scope? */
 221                 }
 222                 break;
 223
 224         case LDB_ADD:
 225                 msg = ldb_msg_copy_shallow(request, request->op.add.message);
 226                 if (msg == NULL) {
 227                         return LDB_ERR_OPERATIONS_ERROR;
 228                 }
 229                 msg->dn = ldb_dn_rebase_remote(msg, data, msg->dn);
 230                 request->op.add.message = msg;
 231                 break;
 232
 233         case LDB_MODIFY:
 234                 msg = ldb_msg_copy_shallow(request, request->op.mod.message);
 235                 if (msg == NULL) {
 236                         return LDB_ERR_OPERATIONS_ERROR;
 237                 }
 238                 msg->dn = ldb_dn_rebase_remote(msg, data, msg->dn);
 239                 request->op.mod.message = msg;
 240                 break;
 241
 242         case LDB_DELETE:
 243                 request->op.del.dn = ldb_dn_rebase_remote(request, data, request->op.del.dn);
 244                 break;
 245
 246         case LDB_RENAME:
 247                 request->op.rename.olddn = ldb_dn_rebase_remote(request, data, request->op.rename.olddn);
 248                 request->op.rename.newdn = ldb_dn_rebase_remote(request, data, request->op.rename.newdn);
 249                 break;
 250
 251         default:
 252                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 253                           "Invalid remote request!");
 254                 return LDB_ERR_OPERATIONS_ERROR;
 255         }
 256
 257         return ldb_next_request(module, request);
 258 }
 259
 260
 261 /* Finding mappings for attributes and objectClasses
 262  * ================================================= */
 263
 264 /* Find an objectClass mapping by the local name. */
 265 static const struct ldb_map_objectclass *map_objectclass_find_local(const struct ldb_map_context *data, const char *name)
 266 {
 267         unsigned int i;
 268
 269         for (i = 0; data->objectclass_maps && data->objectclass_maps[i].local_name; i++) {
 270                 if (ldb_attr_cmp(data->objectclass_maps[i].local_name, name) == 0) {
 271                         return &data->objectclass_maps[i];
 272                 }
 273         }
 274
 275         return NULL;
 276 }
 277
 278 /* Find an objectClass mapping by the remote name. */
 279 static const struct ldb_map_objectclass *map_objectclass_find_remote(const struct ldb_map_context *data, const char *name)
 280 {
 281         unsigned int i;
 282
 283         for (i = 0; data->objectclass_maps && data->objectclass_maps[i].remote_name; i++) {
 284                 if (ldb_attr_cmp(data->objectclass_maps[i].remote_name, name) == 0) {
 285                         return &data->objectclass_maps[i];
 286                 }
 287         }
 288
 289         return NULL;
 290 }
 291
 292 /* Find an attribute mapping by the local name. */
 293 const struct ldb_map_attribute *map_attr_find_local(const struct ldb_map_context *data, const char *name)
 294 {
 295         unsigned int i;
 296
 297         for (i = 0; data->attribute_maps[i].local_name; i++) {
 298                 if (ldb_attr_cmp(data->attribute_maps[i].local_name, name) == 0) {
 299                         return &data->attribute_maps[i];
 300                 }
 301         }
 302         for (i = 0; data->attribute_maps[i].local_name; i++) {
 303                 if (ldb_attr_cmp(data->attribute_maps[i].local_name, "*") == 0) {
 304                         return &data->attribute_maps[i];
 305                 }
 306         }
 307
 308         return NULL;
 309 }
 310
 311 /* Find an attribute mapping by the remote name. */
 312 const struct ldb_map_attribute *map_attr_find_remote(const struct ldb_map_context *data, const char *name)
 313 {
 314         const struct ldb_map_attribute *map;
 315         const struct ldb_map_attribute *wildcard = NULL;
 316         unsigned int i, j;
 317
 318         for (i = 0; data->attribute_maps[i].local_name; i++) {
 319                 map = &data->attribute_maps[i];
 320                 if (ldb_attr_cmp(map->local_name, "*") == 0) {
 321                         wildcard = &data->attribute_maps[i];
 322                 }
 323
 324                 switch (map->type) {
 325                 case LDB_MAP_IGNORE:
 326                         break;
 327
 328                 case LDB_MAP_KEEP:
 329                         if (ldb_attr_cmp(map->local_name, name) == 0) {
 330                                 return map;
 331                         }
 332                         break;
 333
 334                 case LDB_MAP_RENAME:
 335                 case LDB_MAP_RENDROP:
 336                 case LDB_MAP_CONVERT:
 337                         if (ldb_attr_cmp(map->u.rename.remote_name, name) == 0) {
 338                                 return map;
 339                         }
 340                         break;
 341
 342                 case LDB_MAP_GENERATE:
 343                         for (j = 0; map->u.generate.remote_names[j]; j++) {
 344                                 if (ldb_attr_cmp(map->u.generate.remote_names[j], name) == 0) {
 345                                         return map;
 346                                 }
 347                         }
 348                         break;
 349                 }
 350         }
 351
 352         /* We didn't find it, so return the wildcard record if one was configured */
 353         return wildcard;
 354 }
 355
 356
 357 /* Mapping attributes
 358  * ================== */
 359
 360 /* Check whether an attribute will be mapped into the remote partition. */
 361 bool map_attr_check_remote(const struct ldb_map_context *data, const char *attr)
 362 {
 363         const struct ldb_map_attribute *map = map_attr_find_local(data, attr);
 364
 365         if (map == NULL) {
 366                 return false;
 367         }
 368         if (map->type == LDB_MAP_IGNORE) {
 369                 return false;
 370         }
 371
 372         return true;
 373 }
 374
 375 /* Map an attribute name into the remote partition. */
 376 const char *map_attr_map_local(void *mem_ctx, const struct ldb_map_attribute *map, const char *attr)
 377 {
 378         if (map == NULL) {
 379                 return talloc_strdup(mem_ctx, attr);
 380         }
 381
 382         switch (map->type) {
 383         case LDB_MAP_KEEP:
 384                 return talloc_strdup(mem_ctx, attr);
 385
 386         case LDB_MAP_RENAME:
 387         case LDB_MAP_RENDROP:
 388         case LDB_MAP_CONVERT:
 389                 return talloc_strdup(mem_ctx, map->u.rename.remote_name);
 390
 391         default:
 392                 return NULL;
 393         }
 394 }
 395
 396 /* Map an attribute name back into the local partition. */
 397 const char *map_attr_map_remote(void *mem_ctx, const struct ldb_map_attribute *map, const char *attr)
 398 {
 399         if (map == NULL) {
 400                 return talloc_strdup(mem_ctx, attr);
 401         }
 402
 403         if (map->type == LDB_MAP_KEEP) {
 404                 return talloc_strdup(mem_ctx, attr);
 405         }
 406
 407         return talloc_strdup(mem_ctx, map->local_name);
 408 }
 409
 410
 411 /* Merge two lists of attributes into a single one. */
 412 int map_attrs_merge(struct ldb_module *module, void *mem_ctx,
 413                     const char ***attrs, const char * const *more_attrs)
 414 {
 415         unsigned int i, j, k;
 416
 417         for (i = 0; *attrs && (*attrs)[i]; i++) /* noop */ ;
 418         for (j = 0; more_attrs && more_attrs[j]; j++) /* noop */ ;
 419
 420         *attrs = talloc_realloc(mem_ctx, *attrs, const char *, i+j+1);
 421         if (*attrs == NULL) {
 422                 map_oom(module);
 423                 return -1;
 424         }
 425
 426         for (k = 0; k < j; k++) {
 427                 (*attrs)[i + k] = more_attrs[k];
 428         }
 429
 430         (*attrs)[i+k] = NULL;
 431
 432         return 0;
 433 }
 434
 435 /* Mapping ldb values
 436  * ================== */
 437
 438 /* Map an ldb value into the remote partition. */
 439 struct ldb_val ldb_val_map_local(struct ldb_module *module, void *mem_ctx,
 440                                  const struct ldb_map_attribute *map, const struct ldb_val *val)
 441 {
 442         if (map && (map->type == LDB_MAP_CONVERT) && (map->u.convert.convert_local)) {
 443                 return map->u.convert.convert_local(module, mem_ctx, val);
 444         }
 445
 446         return ldb_val_dup(mem_ctx, val);
 447 }
 448
 449 /* Map an ldb value back into the local partition. */
 450 struct ldb_val ldb_val_map_remote(struct ldb_module *module, void *mem_ctx,
 451                                   const struct ldb_map_attribute *map, const struct ldb_val *val)
 452 {
 453         if (map && (map->type == LDB_MAP_CONVERT) && (map->u.convert.convert_remote)) {
 454                 return map->u.convert.convert_remote(module, mem_ctx, val);
 455         }
 456
 457         return ldb_val_dup(mem_ctx, val);
 458 }
 459
 460
 461 /* Mapping DNs
 462  * =========== */
 463
 464 /* Check whether a DN is below the local baseDN. */
 465 bool ldb_dn_check_local(struct ldb_module *module, struct ldb_dn *dn)
 466 {
 467         const struct ldb_map_context *data = map_get_context(module);
 468
 469         if (!data->local_base_dn) {
 470                 return true;
 471         }
 472
 473         return ldb_dn_compare_base(data->local_base_dn, dn) == 0;
 474 }
 475
 476 /* Map a DN into the remote partition. */
 477 struct ldb_dn *ldb_dn_map_local(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn)
 478 {
 479         const struct ldb_map_context *data = map_get_context(module);
 480         struct ldb_context *ldb;
 481         struct ldb_dn *newdn;
 482         const struct ldb_map_attribute *map;
 483         enum ldb_map_attr_type map_type;
 484         const char *name;
 485         struct ldb_val value;
 486         int i, ret;
 487
 488         if (dn == NULL) {
 489                 return NULL;
 490         }
 491
 492         ldb = ldb_module_get_ctx(module);
 493
 494         newdn = ldb_dn_copy(mem_ctx, dn);
 495         if (newdn == NULL) {
 496                 map_oom(module);
 497                 return NULL;
 498         }
 499
 500         /* For each RDN, map the component name and possibly the value */
 501         for (i = 0; i < ldb_dn_get_comp_num(newdn); i++) {
 502                 map = map_attr_find_local(data, ldb_dn_get_component_name(dn, i));
 503
 504                 /* Unknown attribute - leave this RDN as is and hope the best... */
 505                 if (map == NULL) {
 506                         map_type = LDB_MAP_KEEP;
 507                 } else {
 508                         map_type = map->type;
 509                 }
 510
 511                 switch (map_type) {
 512                 case LDB_MAP_IGNORE:
 513                 case LDB_MAP_GENERATE:
 514                         ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 515                                   "LDB_MAP_IGNORE/LDB_MAP_GENERATE attribute '%s' "
 516                                   "used in DN!", ldb_dn_get_component_name(dn, i));
 517                         goto failed;
 518
 519                 case LDB_MAP_CONVERT:
 520                         if (map->u.convert.convert_local == NULL) {
 521                                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 522                                           "'convert_local' not set for attribute '%s' "
 523                                           "used in DN!", ldb_dn_get_component_name(dn, i));
 524                                 goto failed;
 525                         }
 526                         /* fall through */
 527                 case LDB_MAP_KEEP:
 528                 case LDB_MAP_RENAME:
 529                 case LDB_MAP_RENDROP:
 530                         name = map_attr_map_local(newdn, map, ldb_dn_get_component_name(dn, i));
 531                         if (name == NULL) goto failed;
 532
 533                         value = ldb_val_map_local(module, newdn, map, ldb_dn_get_component_val(dn, i));
 534                         if (value.data == NULL) goto failed;
 535
 536                         ret = ldb_dn_set_component(newdn, i, name, value);
 537                         if (ret != LDB_SUCCESS) {
 538                                 goto failed;
 539                         }
 540
 541                         break;
 542                 }
 543         }
 544
 545         return newdn;
 546
 547 failed:
 548         talloc_free(newdn);
 549         return NULL;
 550 }
 551
 552 /* Map a DN into the local partition. */
 553 struct ldb_dn *ldb_dn_map_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn)
 554 {
 555         const struct ldb_map_context *data = map_get_context(module);
 556         struct ldb_context *ldb;
 557         struct ldb_dn *newdn;
 558         const struct ldb_map_attribute *map;
 559         enum ldb_map_attr_type map_type;
 560         const char *name;
 561         struct ldb_val value;
 562         int i, ret;
 563
 564         if (dn == NULL) {
 565                 return NULL;
 566         }
 567
 568         ldb = ldb_module_get_ctx(module);
 569
 570         newdn = ldb_dn_copy(mem_ctx, dn);
 571         if (newdn == NULL) {
 572                 map_oom(module);
 573                 return NULL;
 574         }
 575
 576         /* For each RDN, map the component name and possibly the value */
 577         for (i = 0; i < ldb_dn_get_comp_num(newdn); i++) {
 578                 map = map_attr_find_remote(data, ldb_dn_get_component_name(dn, i));
 579
 580                 /* Unknown attribute - leave this RDN as is and hope the best... */
 581                 if (map == NULL) {
 582                         map_type = LDB_MAP_KEEP;
 583                 } else {
 584                         map_type = map->type;
 585                 }
 586
 587                 switch (map_type) {
 588                 case LDB_MAP_IGNORE:
 589                 case LDB_MAP_GENERATE:
 590                         ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 591                                   "LDB_MAP_IGNORE/LDB_MAP_GENERATE attribute '%s' "
 592                                   "used in DN!", ldb_dn_get_component_name(dn, i));
 593                         goto failed;
 594
 595                 case LDB_MAP_CONVERT:
 596                         if (map->u.convert.convert_remote == NULL) {
 597                                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 598                                           "'convert_remote' not set for attribute '%s' "
 599                                           "used in DN!", ldb_dn_get_component_name(dn, i));
 600                                 goto failed;
 601                         }
 602                         /* fall through */
 603                 case LDB_MAP_KEEP:
 604                 case LDB_MAP_RENAME:
 605                 case LDB_MAP_RENDROP:
 606                         name = map_attr_map_remote(newdn, map, ldb_dn_get_component_name(dn, i));
 607                         if (name == NULL) goto failed;
 608
 609                         value = ldb_val_map_remote(module, newdn, map, ldb_dn_get_component_val(dn, i));
 610                         if (value.data == NULL) goto failed;
 611
 612                         ret = ldb_dn_set_component(newdn, i, name, value);
 613                         if (ret != LDB_SUCCESS) {
 614                                 goto failed;
 615                         }
 616
 617                         break;
 618                 }
 619         }
 620
 621         return newdn;
 622
 623 failed:
 624         talloc_free(newdn);
 625         return NULL;
 626 }
 627
 628 /* Map a DN and its base into the local partition. */
 629 /* TODO: This should not be required with GUIDs. */
 630 struct ldb_dn *ldb_dn_map_rebase_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn)
 631 {
 632         const struct ldb_map_context *data = map_get_context(module);
 633         struct ldb_dn *dn1, *dn2;
 634
 635         dn1 = ldb_dn_rebase_local(mem_ctx, data, dn);
 636         dn2 = ldb_dn_map_remote(module, mem_ctx, dn1);
 637
 638         talloc_free(dn1);
 639         return dn2;
 640 }
 641
 642
 643 /* Converting DNs and objectClasses (as ldb values)
 644  * ================================================ */
 645
 646 /* Map a DN contained in an ldb value into the remote partition. */
 647 static struct ldb_val ldb_dn_convert_local(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val)
 648 {
 649         struct ldb_context *ldb;
 650         struct ldb_dn *dn, *newdn;
 651         struct ldb_val newval;
 652
 653         ldb = ldb_module_get_ctx(module);
 654
 655         dn = ldb_dn_from_ldb_val(mem_ctx, ldb, val);
 656         if (! ldb_dn_validate(dn)) {
 657                 newval.length = 0;
 658                 newval.data = NULL;
 659                 talloc_free(dn);
 660                 return newval;
 661         }
 662         newdn = ldb_dn_map_local(module, mem_ctx, dn);
 663         talloc_free(dn);
 664
 665         newval.length = 0;
 666         newval.data = (uint8_t *)ldb_dn_alloc_linearized(mem_ctx, newdn);
 667         if (newval.data) {
 668                 newval.length = strlen((char *)newval.data);
 669         }
 670         talloc_free(newdn);
 671
 672         return newval;
 673 }
 674
 675 /* Map a DN contained in an ldb value into the local partition. */
 676 static struct ldb_val ldb_dn_convert_remote(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val)
 677 {
 678         struct ldb_context *ldb;
 679         struct ldb_dn *dn, *newdn;
 680         struct ldb_val newval;
 681
 682         ldb = ldb_module_get_ctx(module);
 683
 684         dn = ldb_dn_from_ldb_val(mem_ctx, ldb, val);
 685         if (! ldb_dn_validate(dn)) {
 686                 newval.length = 0;
 687                 newval.data = NULL;
 688                 talloc_free(dn);
 689                 return newval;
 690         }
 691         newdn = ldb_dn_map_remote(module, mem_ctx, dn);
 692         talloc_free(dn);
 693
 694         newval.length = 0;
 695         newval.data = (uint8_t *)ldb_dn_alloc_linearized(mem_ctx, newdn);
 696         if (newval.data) {
 697                 newval.length = strlen((char *)newval.data);
 698         }
 699         talloc_free(newdn);
 700
 701         return newval;
 702 }
 703
 704 /* Map an objectClass into the remote partition. */
 705 static struct ldb_val map_objectclass_convert_local(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val)
 706 {
 707         const struct ldb_map_context *data = map_get_context(module);
 708         const char *name = (char *)val->data;
 709         const struct ldb_map_objectclass *map = map_objectclass_find_local(data, name);
 710         struct ldb_val newval;
 711
 712         if (map) {
 713                 newval.data = (uint8_t*)talloc_strdup(mem_ctx, map->remote_name);
 714                 newval.length = strlen((char *)newval.data);
 715                 return newval;
 716         }
 717
 718         return ldb_val_dup(mem_ctx, val);
 719 }
 720
 721 /* Generate a remote message with a mapped objectClass. */
 722 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)
 723 {
 724         const struct ldb_map_context *data = map_get_context(module);
 725         struct ldb_context *ldb;
 726         struct ldb_message_element *el, *oc;
 727         struct ldb_val val;
 728         bool found_extensibleObject = false;
 729         unsigned int i;
 730
 731         ldb = ldb_module_get_ctx(module);
 732
 733         /* Find old local objectClass */
 734         oc = ldb_msg_find_element(old, "objectClass");
 735         if (oc == NULL) {
 736                 return;
 737         }
 738
 739         /* Prepare new element */
 740         el = talloc_zero(remote, struct ldb_message_element);
 741         if (el == NULL) {
 742                 ldb_oom(ldb);
 743                 return;                 /* TODO: fail? */
 744         }
 745
 746         /* Copy local objectClass element, reverse space for an extra value */
 747         el->num_values = oc->num_values + 1;
 748         el->values = talloc_array(el, struct ldb_val, el->num_values);
 749         if (el->values == NULL) {
 750                 talloc_free(el);
 751                 ldb_oom(ldb);
 752                 return;                 /* TODO: fail? */
 753         }
 754
 755         /* Copy local element name "objectClass" */
 756         el->name = talloc_strdup(el, local_attr);
 757
 758         /* Convert all local objectClasses */
 759         for (i = 0; i < el->num_values - 1; i++) {
 760                 el->values[i] = map_objectclass_convert_local(module, el->values, &oc->values[i]);
 761                 if (ldb_attr_cmp((char *)el->values[i].data, data->add_objectclass) == 0) {
 762                         found_extensibleObject = true;
 763                 }
 764         }
 765
 766         if (!found_extensibleObject) {
 767                 val.data = (uint8_t *)talloc_strdup(el->values, data->add_objectclass);
 768                 val.length = strlen((char *)val.data);
 769
 770                 /* Append additional objectClass data->add_objectclass */
 771                 el->values[i] = val;
 772         } else {
 773                 el->num_values--;
 774         }
 775
 776         /* Add new objectClass to remote message */
 777         ldb_msg_add(remote, el, 0);
 778 }
 779
 780 /* Map an objectClass into the local partition. */
 781 static struct ldb_val map_objectclass_convert_remote(struct ldb_module *module, void *mem_ctx, const struct ldb_val *val)
 782 {
 783         const struct ldb_map_context *data = map_get_context(module);
 784         const char *name = (char *)val->data;
 785         const struct ldb_map_objectclass *map = map_objectclass_find_remote(data, name);
 786         struct ldb_val newval;
 787
 788         if (map) {
 789                 newval.data = (uint8_t*)talloc_strdup(mem_ctx, map->local_name);
 790                 newval.length = strlen((char *)newval.data);
 791                 return newval;
 792         }
 793
 794         return ldb_val_dup(mem_ctx, val);
 795 }
 796
 797 /* Generate a local message with a mapped objectClass. */
 798 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)
 799 {
 800         const struct ldb_map_context *data = map_get_context(module);
 801         struct ldb_context *ldb;
 802         struct ldb_message_element *el, *oc;
 803         struct ldb_val val;
 804         unsigned int i;
 805
 806         ldb = ldb_module_get_ctx(module);
 807
 808         /* Find old remote objectClass */
 809         oc = ldb_msg_find_element(remote, "objectClass");
 810         if (oc == NULL) {
 811                 return NULL;
 812         }
 813
 814         /* Prepare new element */
 815         el = talloc_zero(mem_ctx, struct ldb_message_element);
 816         if (el == NULL) {
 817                 ldb_oom(ldb);
 818                 return NULL;
 819         }
 820
 821         /* Copy remote objectClass element */
 822         el->num_values = oc->num_values;
 823         el->values = talloc_array(el, struct ldb_val, el->num_values);
 824         if (el->values == NULL) {
 825                 talloc_free(el);
 826                 ldb_oom(ldb);
 827                 return NULL;
 828         }
 829
 830         /* Copy remote element name "objectClass" */
 831         el->name = talloc_strdup(el, local_attr);
 832
 833         /* Convert all remote objectClasses */
 834         for (i = 0; i < el->num_values; i++) {
 835                 el->values[i] = map_objectclass_convert_remote(module, el->values, &oc->values[i]);
 836         }
 837
 838         val.data = (uint8_t *)talloc_strdup(el->values, data->add_objectclass);
 839         val.length = strlen((char *)val.data);
 840
 841         /* Remove last value if it was the string in data->add_objectclass (eg samba4top, extensibleObject) */
 842         if (ldb_val_equal_exact(&val, &el->values[i-1])) {
 843                 el->num_values--;
 844                 el->values = talloc_realloc(el, el->values, struct ldb_val, el->num_values);
 845                 if (el->values == NULL) {
 846                         talloc_free(el);
 847                         ldb_oom(ldb);
 848                         return NULL;
 849                 }
 850         }
 851
 852         return el;
 853 }
 854
 855 static const struct ldb_map_attribute objectclass_convert_map = {
 856         .local_name = "objectClass",
 857         .type = LDB_MAP_CONVERT,
 858         .u = {
 859                 .convert = {
 860                         .remote_name = "objectClass",
 861                         .convert_local = map_objectclass_convert_local,
 862                         .convert_remote = map_objectclass_convert_remote,
 863                 },
 864         },
 865 };
 866
 867
 868 /* Mappings for searches on objectClass= assuming a one-to-one
 869  * mapping.  Needed because this is a generate operator for the
 870  * add/modify code */
 871 static int map_objectclass_convert_operator(struct ldb_module *module, void *mem_ctx,
 872                                             struct ldb_parse_tree **new, const struct ldb_parse_tree *tree)
 873 {
 874
 875         return map_subtree_collect_remote_simple(module, mem_ctx, new, tree, &objectclass_convert_map);
 876 }
 877
 878 /* Auxiliary request construction
 879  * ============================== */
 880
 881 /* Build a request to search a record by its DN. */
 882 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)
 883 {
 884         struct ldb_parse_tree *search_tree;
 885         struct ldb_context *ldb;
 886         struct ldb_request *req;
 887         int ret;
 888
 889         ldb = ldb_module_get_ctx(ac->module);
 890
 891         if (tree) {
 892                 search_tree = tree;
 893         } else {
 894                 search_tree = ldb_parse_tree(ac, NULL);
 895                 if (search_tree == NULL) {
 896                         return NULL;
 897                 }
 898         }
 899
 900         ret = ldb_build_search_req_ex(&req, ldb, ac,
 901                                         dn, LDB_SCOPE_BASE,
 902                                         search_tree, attrs,
 903                                         NULL,
 904                                         context, callback,
 905                                         ac->req);
 906         LDB_REQ_SET_LOCATION(req);
 907         if (ret != LDB_SUCCESS) {
 908                 return NULL;
 909         }
 910
 911         return req;
 912 }
 913
 914 /* Build a request to update the 'IS_MAPPED' attribute */
 915 struct ldb_request *map_build_fixup_req(struct map_context *ac,
 916                                         struct ldb_dn *olddn,
 917                                         struct ldb_dn *newdn,
 918                                         void *context,
 919                                         ldb_map_callback_t callback)
 920 {
 921         struct ldb_context *ldb;
 922         struct ldb_request *req;
 923         struct ldb_message *msg;
 924         const char *dn;
 925         int ret;
 926
 927         ldb = ldb_module_get_ctx(ac->module);
 928
 929         /* Prepare message */
 930         msg = ldb_msg_new(ac);
 931         if (msg == NULL) {
 932                 map_oom(ac->module);
 933                 return NULL;
 934         }
 935
 936         /* Update local 'IS_MAPPED' to the new remote DN */
 937         msg->dn = ldb_dn_copy(msg, olddn);
 938         dn = ldb_dn_alloc_linearized(msg, newdn);
 939         if ( ! dn || ! ldb_dn_validate(msg->dn)) {
 940                 goto failed;
 941         }
 942         if (ldb_msg_add_empty(msg, IS_MAPPED, LDB_FLAG_MOD_REPLACE, NULL) != 0) {
 943                 goto failed;
 944         }
 945         if (ldb_msg_add_string(msg, IS_MAPPED, dn) != 0) {
 946                 goto failed;
 947         }
 948
 949         /* Prepare request */
 950         ret = ldb_build_mod_req(&req, ldb,
 951                                 ac, msg, NULL,
 952                                 context, callback,
 953                                 ac->req);
 954         LDB_REQ_SET_LOCATION(req);
 955         if (ret != LDB_SUCCESS) {
 956                 goto failed;
 957         }
 958         talloc_steal(req, msg);
 959
 960         return req;
 961 failed:
 962         talloc_free(msg);
 963         return NULL;
 964 }
 965
 966 /* Module initialization
 967  * ===================== */
 968
 969
 970 /* Builtin mappings for DNs and objectClasses */
 971 static const struct ldb_map_attribute builtin_attribute_maps[] = {
 972         {
 973                 .local_name = "dn",
 974                 .type = LDB_MAP_CONVERT,
 975                 .u = {
 976                         .convert = {
 977                                  .remote_name = "dn",
 978                                  .convert_local = ldb_dn_convert_local,
 979                                  .convert_remote = ldb_dn_convert_remote,
 980                          },
 981                 },
 982         },
 983         {
 984                 .local_name = NULL,
 985         }
 986 };
 987
 988 static const struct ldb_map_attribute objectclass_attribute_map = {
 989         .local_name = "objectClass",
 990         .type = LDB_MAP_GENERATE,
 991         .convert_operator = map_objectclass_convert_operator,
 992         .u = {
 993                 .generate = {
 994                         .remote_names = { "objectClass", NULL },
 995                         .generate_local = map_objectclass_generate_local,
 996                         .generate_remote = map_objectclass_generate_remote,
 997                 },
 998         },
 999 };
1000
1001
1002 /* Find the special 'MAP_DN_NAME' record and store local and remote
1003  * base DNs in private data. */
1004 static int map_init_dns(struct ldb_module *module, struct ldb_map_context *data, const char *name)
1005 {
1006         static const char * const attrs[] = { MAP_DN_FROM, MAP_DN_TO, NULL };
1007         struct ldb_context *ldb;
1008         struct ldb_dn *dn;
1009         struct ldb_message *msg;
1010         struct ldb_result *res;
1011         int ret;
1012
1013         if (!name) {
1014                 data->local_base_dn = NULL;
1015                 data->remote_base_dn = NULL;
1016                 return LDB_SUCCESS;
1017         }
1018
1019         ldb = ldb_module_get_ctx(module);
1020
1021         dn = ldb_dn_new_fmt(data, ldb, "%s=%s", MAP_DN_NAME, name);
1022         if ( ! ldb_dn_validate(dn)) {
1023                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
1024                           "Failed to construct '%s' DN!", MAP_DN_NAME);
1025                 return LDB_ERR_OPERATIONS_ERROR;
1026         }
1027
1028         ret = ldb_search(ldb, data, &res, dn, LDB_SCOPE_BASE, attrs, NULL);
1029         talloc_free(dn);
1030         if (ret != LDB_SUCCESS) {
1031                 return ret;
1032         }
1033         if (res->count == 0) {
1034                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
1035                           "No results for '%s=%s'!", MAP_DN_NAME, name);
1036                 talloc_free(res);
1037                 return LDB_ERR_CONSTRAINT_VIOLATION;
1038         }
1039         if (res->count > 1) {
1040                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
1041                           "Too many results for '%s=%s'!", MAP_DN_NAME, name);
1042                 talloc_free(res);
1043                 return LDB_ERR_CONSTRAINT_VIOLATION;
1044         }
1045
1046         msg = res->msgs[0];
1047         data->local_base_dn = ldb_msg_find_attr_as_dn(ldb, data, msg, MAP_DN_FROM);
1048         data->remote_base_dn = ldb_msg_find_attr_as_dn(ldb, data, msg, MAP_DN_TO);
1049         talloc_free(res);
1050
1051         return LDB_SUCCESS;
1052 }
1053
1054 /* Store attribute maps and objectClass maps in private data. */
1055 static int map_init_maps(struct ldb_module *module, struct ldb_map_context *data,
1056                          const struct ldb_map_attribute *attrs,
1057                          const struct ldb_map_objectclass *ocls,
1058                          const char * const *wildcard_attributes)
1059 {
1060         unsigned int i, j, last;
1061         last = 0;
1062
1063         /* Count specified attribute maps */
1064         for (i = 0; attrs[i].local_name; i++) /* noop */ ;
1065         /* Count built-in attribute maps */
1066         for (j = 0; builtin_attribute_maps[j].local_name; j++) /* noop */ ;
1067
1068         /* Store list of attribute maps */
1069         data->attribute_maps = talloc_array(data, struct ldb_map_attribute, i+j+2);
1070         if (data->attribute_maps == NULL) {
1071                 map_oom(module);
1072                 return LDB_ERR_OPERATIONS_ERROR;
1073         }
1074
1075         /* Specified ones go first */
1076         for (i = 0; attrs[i].local_name; i++) {
1077                 data->attribute_maps[last] = attrs[i];
1078                 last++;
1079         }
1080
1081         /* Built-in ones go last */
1082         for (i = 0; builtin_attribute_maps[i].local_name; i++) {
1083                 data->attribute_maps[last] = builtin_attribute_maps[i];
1084                 last++;
1085         }
1086
1087         if (data->add_objectclass) {
1088                 /* ObjectClass one is very last, if required */
1089                 data->attribute_maps[last] = objectclass_attribute_map;
1090                 last++;
1091         } else if (ocls) {
1092                 data->attribute_maps[last] = objectclass_convert_map;
1093                 last++;
1094         }
1095
1096         /* Ensure 'local_name == NULL' for the last entry */
1097         memset(&data->attribute_maps[last], 0, sizeof(struct ldb_map_attribute));
1098
1099         /* Store list of objectClass maps */
1100         data->objectclass_maps = ocls;
1101
1102         data->wildcard_attributes = wildcard_attributes;
1103
1104         return LDB_SUCCESS;
1105 }
1106
1107 /* Initialize global private data. */
1108 _PUBLIC_ int ldb_map_init(struct ldb_module *module, const struct ldb_map_attribute *attrs,
1109                           const struct ldb_map_objectclass *ocls,
1110                           const char * const *wildcard_attributes,
1111                           const char *add_objectclass,
1112                           const char *name)
1113 {
1114         struct map_private *data;
1115         int ret;
1116
1117         /* Prepare private data */
1118         data = talloc_zero(module, struct map_private);
1119         if (data == NULL) {
1120                 map_oom(module);
1121                 return LDB_ERR_OPERATIONS_ERROR;
1122         }
1123
1124         ldb_module_set_private(module, data);
1125
1126         data->context = talloc_zero(data, struct ldb_map_context);
1127         if (!data->context) {
1128                 map_oom(module);
1129                 return LDB_ERR_OPERATIONS_ERROR;
1130         }
1131
1132         /* Store local and remote baseDNs */
1133         ret = map_init_dns(module, data->context, name);
1134         if (ret != LDB_SUCCESS) {
1135                 talloc_free(data);
1136                 return ret;
1137         }
1138
1139         data->context->add_objectclass = add_objectclass;
1140
1141         /* Store list of attribute and objectClass maps */
1142         ret = map_init_maps(module, data->context, attrs, ocls, wildcard_attributes);
1143         if (ret != LDB_SUCCESS) {
1144                 talloc_free(data);
1145                 return ret;
1146         }
1147
1148         return LDB_SUCCESS;
1149 }