source4/lib/ldb/ldb_map/ldb_map.c

   1 /*
   2    ldb database library - map backend
   3
   4    Copyright (C) Jelmer Vernooij 2005
   5
   6      ** NOTE! The following LGPL license applies to the ldb
   7      ** library. This does NOT imply that all of Samba is released
   8      ** under the LGPL
   9
  10    This library is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU Lesser General Public
  12    License as published by the Free Software Foundation; either
  13    version 2 of the License, or (at your option) any later version.
  14
  15    This library is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    Lesser General Public License for more details.
  19
  20    You should have received a copy of the GNU Lesser General Public
  21    License along with this library; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23 */
  24
  25 #include "includes.h"
  26 #include "lib/ldb/include/ldb.h"
  27 #include "lib/ldb/include/ldb_private.h"
  28 #include "lib/ldb/ldb_map/ldb_map.h"
  29
  30 /* TODO:
  31  *  - objectclass hint in ldb_map_attribute
  32  *     for use when multiple remote attributes (independant of each other)
  33  *     map to one local attribute. E.g.: (uid, gidNumber) -> unixName
  34  */
  35
  36 struct map_private {
  37         const struct ldb_map_attribute *attribute_maps;
  38         const struct ldb_map_objectclass *objectclass_maps;
  39         const char *last_err_string;
  40 };
  41
  42 /* find an attribute by the local name */
  43 static const struct ldb_map_attribute *map_find_attr_local(struct ldb_module *module, const char *attr)
  44 {
  45         struct map_private *privdat = module->private_data;
  46         int i;
  47         for (i = 0; privdat->attribute_maps[i].local_name; i++) {
  48                 if (!strcmp(privdat->attribute_maps[i].local_name, attr))
  49                         return &privdat->attribute_maps[i];
  50         }
  51
  52         return NULL;
  53 }
  54
  55 /* find an attribute by the remote name */
  56 static const struct ldb_map_attribute *map_find_attr_remote(struct ldb_module *module, const char *attr)
  57 {
  58         struct map_private *privdat = module->private_data;
  59         int i;
  60         for (i = 0; privdat->attribute_maps[i].local_name; i++) {
  61                 if (privdat->attribute_maps[i].type != MAP_RENAME &&
  62                         privdat->attribute_maps[i].type != MAP_CONVERT)
  63                         continue;
  64
  65                 if (!strcmp(privdat->attribute_maps[i].u.rename.remote_name, attr))
  66                         return &privdat->attribute_maps[i];
  67         }
  68
  69         return NULL;
  70 }
  71
  72 static struct ldb_parse_tree *ldb_map_parse_tree(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_parse_tree *tree)
  73 {
  74         int i;
  75         const struct ldb_map_attribute *attr;
  76         struct ldb_parse_tree *new_tree;
  77
  78         if (tree == NULL)
  79                 return NULL;
  80
  81         new_tree = talloc_memdup(ctx, tree, sizeof(*tree));
  82
  83         /* Find attr in question and:
  84          *  - if it has a convert_operator function, run that
  85          *  - otherwise, replace attr name with required[0] */
  86
  87         if (tree->operation == LDB_OP_AND ||
  88                 tree->operation == LDB_OP_OR) {
  89                 new_tree->u.list.elements = talloc_array(new_tree, struct ldb_parse_tree *, tree->u.list.num_elements);
  90                 for (i = 0; i < new_tree->u.list.num_elements; i++) {
  91                         new_tree->u.list.elements[i] = ldb_map_parse_tree(module, new_tree, tree->u.list.elements[i]);
  92                 }
  93
  94                 return new_tree;
  95         }
  96
  97         if (tree->operation == LDB_OP_NOT) {
  98                 new_tree->u.isnot.child = ldb_map_parse_tree(module, new_tree, tree->u.isnot.child);
  99                 return new_tree;
 100         }
 101
 102         /* tree->operation is LDB_OP_EQUALITY, LDB_OP_SUBSTRING, LDB_OP_GREATER,
 103          * LDB_OP_LESS, LDB_OP_APPROX, LDB_OP_PRESENT or LDB_OP_EXTENDED
 104          *
 105          * (all have attr as the first element)
 106          */
 107
 108         if (new_tree->operation == LDB_OP_EQUALITY) {
 109                 new_tree->u.equality.value = ldb_val_dup(new_tree, &tree->u.equality.value);
 110         } else if (new_tree->operation == LDB_OP_SUBSTRING) {
 111                 new_tree->u.substring.chunks = NULL; /* FIXME! */
 112         } else if (new_tree->operation == LDB_OP_LESS ||
 113                            new_tree->operation == LDB_OP_GREATER ||
 114                            new_tree->operation == LDB_OP_APPROX) {
 115                 new_tree->u.comparison.value = ldb_val_dup(new_tree, &tree->u.comparison.value);
 116         } else if (new_tree->operation == LDB_OP_EXTENDED) {
 117                 new_tree->u.extended.value = ldb_val_dup(new_tree, &tree->u.extended.value);
 118                 new_tree->u.extended.rule_id = talloc_strdup(new_tree, tree->u.extended.rule_id);
 119         }
 120
 121         attr = map_find_attr_local(module, tree->u.equality.attr);
 122
 123         if (!attr || attr->type == MAP_KEEP) {
 124                 DEBUG(0, ("Unable to find local attribute '%s', leaving as is\n", tree->u.equality.attr));
 125                 new_tree->u.equality.attr = talloc_strdup(new_tree, tree->u.equality.attr);
 126                 return new_tree;
 127         }
 128
 129         if (attr->type == MAP_IGNORE) {
 130                 talloc_free(new_tree);
 131                 return NULL;
 132         }
 133
 134         if (attr->convert_operator) {
 135                 /* Run convert_operator */
 136                 talloc_free(new_tree);
 137                 new_tree = attr->convert_operator(module, tree);
 138
 139                 return new_tree;
 140         } else {
 141                 new_tree->u.equality.attr = talloc_strdup(new_tree, attr->u.rename.remote_name);
 142         }
 143
 144         return new_tree;
 145 }
 146
 147 /* Remote DN -> Local DN */
 148 static struct ldb_dn *map_remote_dn(struct ldb_module *module, const struct ldb_dn *dn)
 149 {
 150         struct ldb_dn *newdn;
 151         int i;
 152
 153         if (dn == NULL)
 154                 return NULL;
 155
 156         newdn = talloc_memdup(module, dn, sizeof(*dn));
 157         if (!newdn)
 158                 return NULL;
 159
 160         newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
 161
 162         if (!newdn->components)
 163                 return NULL;
 164
 165         /* For each rdn, map the attribute name and possibly the
 166          * complete rdn */
 167
 168         for (i = 0; i < dn->comp_num; i++) {
 169                 const struct ldb_map_attribute *attr = map_find_attr_remote(module, dn->components[i].name);
 170
 171                 /* Unknown attribute - leave this dn as is and hope the best... */
 172                 if (!attr || attr->type == MAP_KEEP) {
 173                         newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name);
 174                         newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
 175                 } else if (attr->type == MAP_IGNORE || attr->type == MAP_GENERATE) {
 176                         DEBUG(0, ("Local MAP_IGNORE or MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name));
 177                         talloc_free(newdn);
 178                         return NULL;
 179                 } else if (attr->type == MAP_CONVERT) {
 180                         struct ldb_message_element elm, *newelm;
 181                         struct ldb_val vals[1] = { dn->components[i].value };
 182
 183                         elm.flags = 0;
 184                         elm.name = attr->u.convert.remote_name;
 185                         elm.num_values = 1;
 186                         elm.values = vals;
 187
 188                         newelm = attr->u.convert.convert_remote(module, attr->local_name, &elm);
 189
 190                         newdn->components[i].name = talloc_strdup(newdn->components, newelm->name);
 191                         newdn->components[i].value = ldb_val_dup(newdn->components, &newelm->values[0]);
 192
 193                         talloc_free(newelm);
 194                 } else if (attr->type == MAP_RENAME) {
 195                         newdn->components[i].name = talloc_strdup(newdn->components, attr->local_name);
 196                         newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
 197                 }
 198         }
 199         return newdn;
 200 }
 201
 202 /* Local DN -> Remote DN */
 203 static struct ldb_dn *map_local_dn(struct ldb_module *module, const struct ldb_dn *dn)
 204 {       struct ldb_dn *newdn;
 205         int i;
 206         struct ldb_parse_tree eqtree, *new_eqtree;
 207
 208         if (dn == NULL)
 209                 return NULL;
 210
 211         newdn = talloc_memdup(module, dn, sizeof(*dn));
 212         if (!newdn)
 213                 return NULL;
 214
 215         newdn->components = talloc_array(newdn, struct ldb_dn_component, newdn->comp_num);
 216
 217         if (!newdn->components)
 218                 return NULL;
 219
 220         /* For each rdn, map the attribute name and possibly the
 221          * complete rdn using an equality convert_operator call */
 222
 223         for (i = 0; i < dn->comp_num; i++) {
 224                 const struct ldb_map_attribute *attr = map_find_attr_local(module, dn->components[i].name);
 225
 226                 /* Unknown attribute - leave this dn as is and hope the best... */
 227                 if (!attr || attr->type == MAP_KEEP) {
 228                         newdn->components[i].name = talloc_strdup(newdn->components, dn->components[i].name);
 229                         newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
 230                         continue;
 231                 } else if (attr->type == MAP_IGNORE || attr->type == MAP_GENERATE) {
 232                         DEBUG(0, ("Local MAP_IGNORE/MAP_GENERATE attribute '%s' used in DN!", dn->components[i].name));
 233                         talloc_free(newdn);
 234                         return NULL;
 235                 }
 236
 237                 /* Simple rename/convert only */
 238                 if (attr->convert_operator) {
 239                         /* Fancy stuff */
 240                         eqtree.operation = LDB_OP_EQUALITY;
 241                         eqtree.u.equality.attr = dn->components[i].name;
 242                         eqtree.u.equality.value = dn->components[i].value;
 243
 244                         new_eqtree = ldb_map_parse_tree(module, newdn, &eqtree);
 245
 246                         /* Silently continue for now */
 247                         if (!new_eqtree) {
 248                                 DEBUG(0, ("Unable to convert RDN for attribute %s\n", dn->components[i].name));
 249                                 continue;
 250                         }
 251
 252                         newdn->components[i].name = talloc_strdup(newdn->components, new_eqtree->u.equality.attr);
 253                         newdn->components[i].value = ldb_val_dup(newdn->components, &new_eqtree->u.equality.value);
 254
 255                         talloc_free(new_eqtree);
 256                 } else if (attr->type == MAP_CONVERT) {
 257                         struct ldb_message_element elm, *newelm;
 258                         struct ldb_val vals[1] = { dn->components[i].value };
 259                         elm.flags = 0;
 260                         elm.name = attr->local_name;
 261                         elm.num_values = 1;
 262                         elm.values = vals;
 263
 264                         newelm = attr->u.convert.convert_local(module, attr->u.convert.remote_name, &elm);
 265
 266                         newdn->components[i].name = talloc_strdup(newdn->components, newelm->name);
 267                         newdn->components[i].value = ldb_val_dup(newdn->components, &newelm->values[0]);
 268
 269                         talloc_free(newelm);
 270                 } else if (attr->type == MAP_RENAME) {
 271                         newdn->components[i].name = talloc_strdup(newdn->components, attr->u.rename.remote_name);
 272                         newdn->components[i].value = ldb_val_dup(newdn->components, &dn->components[i].value);
 273                 }
 274         }
 275
 276         return newdn;
 277 }
 278
 279 /* Loop over ldb_map_attribute array and add remote_names */
 280 static const char **ldb_map_attrs(struct ldb_module *module, const char *const attrs[])
 281 {
 282         int i;
 283         const char **ret;
 284         int ar_size = 0, last_element = 0;
 285
 286         if (attrs == NULL)
 287                 return NULL;
 288
 289         /* Start with good guess of number of elements */
 290         for (i = 0; attrs[i]; i++);
 291
 292         ret = talloc_array(module, const char *, i);
 293         ar_size = i;
 294
 295         for (i = 0; attrs[i]; i++) {
 296                 int j;
 297                 const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]);
 298
 299                 if (!attr) {
 300                         DEBUG(0, ("Local attribute '%s' does not have a definition!\n", attrs[i]));
 301                         continue;
 302                 }
 303
 304                 switch (attr->type)
 305                 {
 306                         case MAP_IGNORE: break;
 307                         case MAP_KEEP:
 308                                 if (last_element >= ar_size) {
 309                                         ret = talloc_realloc(module, ret, const char *, ar_size+1);
 310                                         ar_size++;
 311                                 }
 312                                 ret[last_element] = attr->local_name;
 313                                 last_element++;
 314                                 break;
 315
 316                         case MAP_RENAME:
 317                         case MAP_CONVERT:
 318                                 if (last_element >= ar_size) {
 319                                         ret = talloc_realloc(module, ret, const char *, ar_size+1);
 320                                         ar_size++;
 321                                 }
 322                                 ret[last_element] = attr->u.rename.remote_name;
 323                                 last_element++;
 324                                 break;
 325
 326                         case MAP_GENERATE:
 327                                 /* Add remote_names[] for this attribute to the list of
 328                                  * attributes to request from the remote server */
 329                                 for (j = 0; attr->u.generate.remote_names[j]; j++) {
 330                                         if (last_element >= ar_size) {
 331                                                 ret = talloc_realloc(module, ret, const char *, ar_size+1);
 332                                                 ar_size++;
 333                                         }
 334                                         ret[last_element] = attr->u.generate.remote_names[j];
 335                                         last_element++;
 336                                 }
 337                                 break;
 338                 }
 339         }
 340
 341         return NULL;
 342 }
 343
 344 static const char **available_local_attributes(struct ldb_module *module, const struct ldb_message *msg)
 345 {
 346         struct map_private *map = module->private_data;
 347         int i, j;
 348         int count = 0;
 349         const char **ret = talloc_array(module, const char *, 1);
 350
 351         ret[0] = NULL;
 352
 353         for (i = 0; map->attribute_maps[i].local_name; i++) {
 354                 BOOL avail = False;
 355                 const struct ldb_map_attribute *attr = &map->attribute_maps[i];
 356
 357                 /* If all remote attributes for this attribute are present, add the
 358                  * local one to the list */
 359
 360                 switch (attr->type) {
 361                 case MAP_IGNORE: break;
 362                 case MAP_KEEP:
 363                                 avail = (ldb_msg_find_ldb_val(msg, attr->local_name) != NULL);
 364                                 break;
 365
 366                 case MAP_RENAME:
 367                 case MAP_CONVERT:
 368                                 avail = (ldb_msg_find_ldb_val(msg, attr->u.rename.remote_name) != NULL);
 369                                 break;
 370
 371                 case MAP_GENERATE:
 372                                 avail = True;
 373                                 for (j = 0; attr->u.generate.remote_names[j]; j++) {
 374                                         avail &= (ldb_msg_find_ldb_val(msg, attr->u.generate.remote_names[j]) != NULL);
 375                                 }
 376                                 break;
 377                 }
 378
 379                 if (!avail)
 380                         continue;
 381
 382                 ret = talloc_realloc(module, ret, const char *, count+2);
 383                 ret[count] = attr->local_name;
 384                 ret[count+1] = NULL;
 385                 count++;
 386         }
 387
 388         return ret;
 389 }
 390
 391 /* Used for search */
 392 static struct ldb_message *ldb_map_message_incoming(struct ldb_module *module, const char * const*attrs, const struct ldb_message *mi)
 393 {
 394         int i;
 395         struct ldb_message *msg = talloc_zero(module, struct ldb_message);
 396         struct ldb_message_element *elm, *oldelm;
 397         const char **newattrs = NULL;
 398
 399         msg->dn = map_remote_dn(module, mi->dn);
 400
 401         /* Loop over attrs, find in ldb_map_attribute array and
 402          * run generate() */
 403
 404         if (attrs == NULL) {
 405                 /* Generate list of the local attributes that /can/ be generated
 406                  * using the specific remote attributes */
 407
 408                 attrs = newattrs = available_local_attributes(module, mi);
 409         }
 410
 411         for (i = 0; attrs[i]; i++) {
 412                 const struct ldb_map_attribute *attr = map_find_attr_local(module, attrs[i]);
 413
 414                 if (!attr) {
 415                         DEBUG(0, ("Unable to find local attribute '%s' when generating incoming message\n", attrs[i]));
 416                         continue;
 417                 }
 418
 419                 switch (attr->type) {
 420                         case MAP_IGNORE:break;
 421                         case MAP_RENAME:
 422                                 oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name);
 423                                 if (!oldelm) continue;
 424
 425                                 elm = talloc(msg, struct ldb_message_element);
 426                                 elm->name = talloc_strdup(elm, attr->local_name);
 427                                 elm->num_values = oldelm->num_values;
 428                                 elm->values = talloc_reference(elm, oldelm->values);
 429
 430                                 ldb_msg_add(module->ldb, msg, elm, oldelm->flags);
 431                                 break;
 432
 433                         case MAP_CONVERT:
 434                                 oldelm = ldb_msg_find_element(mi, attr->u.rename.remote_name);
 435                                 if (!oldelm) continue;
 436
 437                                 elm = attr->u.convert.convert_remote(msg, attr->local_name, oldelm);
 438                                 if (!elm) continue;
 439
 440                                 ldb_msg_add(module->ldb, msg, elm, elm->flags);
 441                                 break;
 442
 443                         case MAP_KEEP:
 444                                 oldelm = ldb_msg_find_element(mi, attr->local_name);
 445                                 if (!oldelm) continue;
 446
 447                                 elm = talloc(msg, struct ldb_message_element);
 448
 449                                 elm->num_values = oldelm->num_values;
 450                                 elm->values = talloc_reference(elm, oldelm->values);
 451                                 elm->name = talloc_strdup(elm, oldelm->name);
 452
 453                                 ldb_msg_add(module->ldb, msg, elm, oldelm->flags);
 454                                 break;
 455
 456                         case MAP_GENERATE:
 457                                 elm = attr->u.generate.generate_local(msg, attr->local_name, mi);
 458                                 if (!elm) continue;
 459
 460                                 ldb_msg_add(module->ldb, msg, elm, elm->flags);
 461                                 break;
 462                         default:
 463                                 DEBUG(0, ("Unknown attr->type for %s", attr->local_name));
 464                                 break;
 465                 }
 466         }
 467
 468         talloc_free(newattrs);
 469
 470         return msg;
 471 }
 472
 473 /* Used for add, modify */
 474 static struct ldb_message *ldb_map_message_outgoing(struct ldb_module *module, const struct ldb_message *mo)
 475 {
 476         struct ldb_message *msg = talloc_zero(module, struct ldb_message);
 477         struct ldb_message_element *elm;
 478         int i;
 479
 480         msg->private_data = mo->private_data;
 481
 482         msg->dn = map_local_dn(module, mo->dn);
 483
 484         /* Loop over mi and call generate_remote for each attribute */
 485         for (i = 0; i < mo->num_elements; i++) {
 486                 const struct ldb_map_attribute *attr = map_find_attr_local(module, mo->elements[i].name);
 487
 488                 if (!attr) {
 489                         DEBUG(0, ("Undefined local attribute '%s', ignoring\n", mo->elements[i].name));
 490                         continue;
 491                 }
 492
 493                 switch (attr->type) {
 494                 case MAP_IGNORE: break;
 495                 case MAP_RENAME:
 496                         elm = talloc(msg, struct ldb_message_element);
 497
 498                         elm->name = talloc_strdup(elm, attr->u.rename.remote_name);
 499                         elm->num_values = mo->elements[i].num_values;
 500                         elm->values = talloc_reference(elm, mo->elements[i].values);
 501
 502                         ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags);
 503                         break;
 504
 505                 case MAP_CONVERT:
 506                         elm = attr->u.convert.convert_local(msg, attr->u.convert.remote_name, &mo->elements[i]);
 507                         ldb_msg_add(module->ldb, msg, elm, elm->flags);
 508                         break;
 509
 510                 case MAP_KEEP:
 511                         elm = talloc(msg, struct ldb_message_element);
 512
 513                         elm->num_values = mo->elements[i].num_values;
 514                         elm->values = talloc_reference(elm, mo->elements[i].values);
 515                         elm->name = talloc_strdup(elm, mo->elements[i].name);
 516
 517                         ldb_msg_add(module->ldb, msg, elm, mo->elements[i].flags);
 518                         break;
 519
 520                 case MAP_GENERATE:
 521                         attr->u.generate.generate_remote(attr->local_name, mo, msg);
 522                         break;
 523                 }
 524         }
 525
 526         return msg;
 527 }
 528
 529 /*
 530   rename a record
 531 */
 532 static int map_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
 533 {
 534         struct ldb_dn *n_olddn, *n_newdn;
 535         int ret;
 536
 537         n_olddn = map_local_dn(module, olddn);
 538         n_newdn = map_local_dn(module, newdn);
 539
 540         ret = ldb_next_rename_record(module, n_olddn, n_newdn);
 541
 542         talloc_free(n_olddn);
 543         talloc_free(n_newdn);
 544
 545         return ret;
 546 }
 547
 548 /*
 549   delete a record
 550 */
 551 static int map_delete(struct ldb_module *module, const struct ldb_dn *dn)
 552 {
 553         struct ldb_dn *newdn;
 554         int ret;
 555
 556         newdn = map_local_dn(module, dn);
 557
 558         ret = ldb_next_delete_record(module, newdn);
 559
 560         talloc_free(newdn);
 561
 562         return ret;
 563 }
 564
 565 /*
 566   search for matching records using a ldb_parse_tree
 567 */
 568 static int map_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
 569                               enum ldb_scope scope, struct ldb_parse_tree *tree,
 570                               const char * const *attrs, struct ldb_message ***res)
 571 {
 572         int ret;
 573         const char **newattrs;
 574         struct ldb_parse_tree *new_tree;
 575         struct ldb_dn *new_base;
 576         struct ldb_message **newres;
 577         int i;
 578
 579         new_tree = ldb_map_parse_tree(module, module, tree);
 580         newattrs = ldb_map_attrs(module, attrs);
 581         new_base = map_local_dn(module, base);
 582
 583         ret = ldb_next_search_bytree(module, new_base, scope, new_tree, newattrs, &newres);
 584
 585         talloc_free(new_base);
 586         talloc_free(new_tree);
 587         talloc_free(newattrs);
 588
 589         *res = talloc_array(module, struct ldb_message *, ret);
 590
 591         for (i = 0; i < ret; i++) {
 592                 (*res)[i] = ldb_map_message_incoming(module, attrs, newres[i]);
 593                 talloc_free(newres[i]);
 594         }
 595
 596         return ret;
 597 }
 598 /*
 599   search for matching records
 600 */
 601 static int map_search(struct ldb_module *module, const struct ldb_dn *base,
 602                        enum ldb_scope scope, const char *expression,
 603                        const char * const *attrs, struct ldb_message ***res)
 604 {
 605         struct map_private *map = module->private_data;
 606         struct ldb_parse_tree *tree;
 607         int ret;
 608
 609         tree = ldb_parse_tree(NULL, expression);
 610         if (tree == NULL) {
 611                 map->last_err_string = "expression parse failed";
 612                 return -1;
 613         }
 614
 615         ret = map_search_bytree(module, base, scope, tree, attrs, res);
 616         talloc_free(tree);
 617         return ret;
 618 }
 619
 620 /*
 621   add a record
 622 */
 623 static int map_add(struct ldb_module *module, const struct ldb_message *msg)
 624 {
 625         struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg);
 626         int ret;
 627
 628         ret = ldb_next_add_record(module, nmsg);
 629
 630         talloc_free(nmsg);
 631
 632         return ret;
 633 }
 634
 635
 636
 637
 638 /*
 639   modify a record
 640 */
 641 static int map_modify(struct ldb_module *module, const struct ldb_message *msg)
 642 {
 643         struct ldb_message *nmsg = ldb_map_message_outgoing(module, msg);
 644         int ret;
 645
 646         ret = ldb_next_modify_record(module, nmsg);
 647
 648         talloc_free(nmsg);
 649
 650         return ret;
 651 }
 652
 653 static int map_lock(struct ldb_module *module, const char *lockname)
 654 {
 655         return ldb_next_named_lock(module, lockname);
 656 }
 657
 658 static int map_unlock(struct ldb_module *module, const char *lockname)
 659 {
 660         return ldb_next_named_unlock(module, lockname);
 661 }
 662
 663 /*
 664   return extended error information
 665 */
 666 static const char *map_errstring(struct ldb_module *module)
 667 {
 668         struct map_private *map = module->private_data;
 669
 670         if (map->last_err_string)
 671                 return map->last_err_string;
 672
 673         return ldb_next_errstring(module);
 674 }
 675
 676 static const struct ldb_module_ops map_ops = {
 677         .name          = "map",
 678         .search        = map_search,
 679         .search_bytree = map_search_bytree,
 680         .add_record    = map_add,
 681         .modify_record = map_modify,
 682         .delete_record = map_delete,
 683         .rename_record = map_rename,
 684         .named_lock    = map_lock,
 685         .named_unlock  = map_unlock,
 686         .errstring     = map_errstring
 687 };
 688
 689 /* the init function */
 690 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[])
 691 {
 692         struct ldb_module *ctx;
 693         struct map_private *data;
 694
 695         ctx = talloc(ldb, struct ldb_module);
 696         if (!ctx)
 697                 return NULL;
 698
 699         data = talloc(ctx, struct map_private);
 700         if (!data) {
 701                 talloc_free(ctx);
 702                 return NULL;
 703         }
 704
 705         data->last_err_string = NULL;
 706
 707         data->attribute_maps = attrs;
 708         data->objectclass_maps = ocls;
 709         ctx->private_data = data;
 710         ctx->ldb = ldb;
 711         ctx->prev = ctx->next = NULL;
 712         ctx->ops = &map_ops;
 713
 714         return ctx;
 715 }