source4/lib/ldb/ldb_tdb/ldb_tdb.c

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Andrew Tridgell  2004
   5    Copyright (C) Stefan Metzmacher  2004
   6    Copyright (C) Simo Sorce       2006
   7
   8
   9      ** NOTE! The following LGPL license applies to the ldb
  10      ** library. This does NOT imply that all of Samba is released
  11      ** under the LGPL
  12
  13    This library is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU Lesser General Public
  15    License as published by the Free Software Foundation; either
  16    version 3 of the License, or (at your option) any later version.
  17
  18    This library is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    Lesser General Public License for more details.
  22
  23    You should have received a copy of the GNU Lesser General Public
  24    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  25 */
  26
  27 /*
  28  *  Name: ldb_tdb
  29  *
  30  *  Component: ldb tdb backend
  31  *
  32  *  Description: core functions for tdb backend
  33  *
  34  *  Author: Andrew Tridgell
  35  *  Author: Stefan Metzmacher
  36  *
  37  *  Modifications:
  38  *
  39  *  - description: make the module use asyncronous calls
  40  *    date: Feb 2006
  41  *    Author: Simo Sorce
  42  */
  43
  44 #include "ldb_includes.h"
  45
  46 #include "ldb_tdb.h"
  47
  48
  49 /*
  50   map a tdb error code to a ldb error code
  51 */
  52 static int ltdb_err_map(enum TDB_ERROR tdb_code)
  53 {
  54         switch (tdb_code) {
  55         case TDB_SUCCESS:
  56                 return LDB_SUCCESS;
  57         case TDB_ERR_CORRUPT:
  58         case TDB_ERR_OOM:
  59         case TDB_ERR_EINVAL:
  60                 return LDB_ERR_OPERATIONS_ERROR;
  61         case TDB_ERR_IO:
  62                 return LDB_ERR_PROTOCOL_ERROR;
  63         case TDB_ERR_LOCK:
  64         case TDB_ERR_NOLOCK:
  65                 return LDB_ERR_BUSY;
  66         case TDB_ERR_LOCK_TIMEOUT:
  67                 return LDB_ERR_TIME_LIMIT_EXCEEDED;
  68         case TDB_ERR_EXISTS:
  69                 return LDB_ERR_ENTRY_ALREADY_EXISTS;
  70         case TDB_ERR_NOEXIST:
  71                 return LDB_ERR_NO_SUCH_OBJECT;
  72         case TDB_ERR_RDONLY:
  73                 return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
  74         }
  75         return LDB_ERR_OTHER;
  76 }
  77
  78
  79 struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb, struct ldb_module *module,
  80                                     struct ldb_request *req)
  81 {
  82         struct ltdb_context *ac;
  83         struct ldb_handle *h;
  84
  85         h = talloc_zero(req, struct ldb_handle);
  86         if (h == NULL) {
  87                 ldb_set_errstring(module->ldb, "Out of Memory");
  88                 return NULL;
  89         }
  90
  91         h->module = module;
  92
  93         ac = talloc_zero(h, struct ltdb_context);
  94         if (ac == NULL) {
  95                 ldb_set_errstring(module->ldb, "Out of Memory");
  96                 talloc_free(h);
  97                 return NULL;
  98         }
  99
 100         h->private_data = (void *)ac;
 101
 102         h->state = LDB_ASYNC_INIT;
 103         h->status = LDB_SUCCESS;
 104
 105         ac->module = module;
 106         ac->context = req->context;
 107         ac->callback = req->callback;
 108
 109         return h;
 110 }
 111
 112 /*
 113   form a TDB_DATA for a record key
 114   caller frees
 115
 116   note that the key for a record can depend on whether the
 117   dn refers to a case sensitive index record or not
 118 */
 119 struct TDB_DATA ltdb_key(struct ldb_module *module, struct ldb_dn *dn)
 120 {
 121         struct ldb_context *ldb = module->ldb;
 122         TDB_DATA key;
 123         char *key_str = NULL;
 124         const char *dn_folded = NULL;
 125
 126         /*
 127           most DNs are case insensitive. The exception is index DNs for
 128           case sensitive attributes
 129
 130           there are 3 cases dealt with in this code:
 131
 132           1) if the dn doesn't start with @ then uppercase the attribute
 133              names and the attributes values of case insensitive attributes
 134           2) if the dn starts with @ then leave it alone - the indexing code handles
 135              the rest
 136         */
 137
 138         dn_folded = ldb_dn_get_casefold(dn);
 139         if (!dn_folded) {
 140                 goto failed;
 141         }
 142
 143         key_str = talloc_strdup(ldb, "DN=");
 144         if (!key_str) {
 145                 goto failed;
 146         }
 147
 148         key_str = talloc_append_string(ldb, key_str, dn_folded);
 149         if (!key_str) {
 150                 goto failed;
 151         }
 152
 153         key.dptr = (uint8_t *)key_str;
 154         key.dsize = strlen(key_str) + 1;
 155
 156         return key;
 157
 158 failed:
 159         errno = ENOMEM;
 160         key.dptr = NULL;
 161         key.dsize = 0;
 162         return key;
 163 }
 164
 165 /*
 166   check special dn's have valid attributes
 167   currently only @ATTRIBUTES is checked
 168 */
 169 int ltdb_check_special_dn(struct ldb_module *module, const struct ldb_message *msg)
 170 {
 171         int i, j;
 172
 173         if (! ldb_dn_is_special(msg->dn) ||
 174             ! ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) {
 175                 return 0;
 176         }
 177
 178         /* we have @ATTRIBUTES, let's check attributes are fine */
 179         /* should we check that we deny multivalued attributes ? */
 180         for (i = 0; i < msg->num_elements; i++) {
 181                 for (j = 0; j < msg->elements[i].num_values; j++) {
 182                         if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
 183                                 ldb_set_errstring(module->ldb, "Invalid attribute value in an @ATTRIBUTES entry");
 184                                 return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
 185                         }
 186                 }
 187         }
 188
 189         return 0;
 190 }
 191
 192
 193 /*
 194   we've made a modification to a dn - possibly reindex and
 195   update sequence number
 196 */
 197 static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
 198 {
 199         int ret = LDB_SUCCESS;
 200
 201         if (ldb_dn_is_special(dn) &&
 202             (ldb_dn_check_special(dn, LTDB_INDEXLIST) ||
 203              ldb_dn_check_special(dn, LTDB_ATTRIBUTES)) ) {
 204                 ret = ltdb_reindex(module);
 205         }
 206
 207         if (ret == LDB_SUCCESS &&
 208             !(ldb_dn_is_special(dn) &&
 209               ldb_dn_check_special(dn, LTDB_BASEINFO)) ) {
 210                 ret = ltdb_increase_sequence_number(module);
 211         }
 212
 213         return ret;
 214 }
 215
 216 /*
 217   store a record into the db
 218 */
 219 int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
 220 {
 221         struct ltdb_private *ltdb =
 222                 talloc_get_type(module->private_data, struct ltdb_private);
 223         TDB_DATA tdb_key, tdb_data;
 224         int ret;
 225
 226         tdb_key = ltdb_key(module, msg->dn);
 227         if (!tdb_key.dptr) {
 228                 return LDB_ERR_OTHER;
 229         }
 230
 231         ret = ltdb_pack_data(module, msg, &tdb_data);
 232         if (ret == -1) {
 233                 talloc_free(tdb_key.dptr);
 234                 return LDB_ERR_OTHER;
 235         }
 236
 237         ret = tdb_store(ltdb->tdb, tdb_key, tdb_data, flgs);
 238         if (ret == -1) {
 239                 ret = ltdb_err_map(tdb_error(ltdb->tdb));
 240                 goto done;
 241         }
 242
 243         ret = ltdb_index_add(module, msg);
 244         if (ret != LDB_SUCCESS) {
 245                 tdb_delete(ltdb->tdb, tdb_key);
 246         }
 247
 248 done:
 249         talloc_free(tdb_key.dptr);
 250         talloc_free(tdb_data.dptr);
 251
 252         return ret;
 253 }
 254
 255
 256 static int ltdb_add_internal(struct ldb_module *module, const struct ldb_message *msg)
 257 {
 258         int ret;
 259
 260         ret = ltdb_check_special_dn(module, msg);
 261         if (ret != LDB_SUCCESS) {
 262                 return ret;
 263         }
 264
 265         if (ltdb_cache_load(module) != 0) {
 266                 return LDB_ERR_OPERATIONS_ERROR;
 267         }
 268
 269         ret = ltdb_store(module, msg, TDB_INSERT);
 270
 271         if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
 272                 ldb_asprintf_errstring(module->ldb, "Entry %s already exists", ldb_dn_get_linearized(msg->dn));
 273                 return ret;
 274         }
 275
 276         if (ret == LDB_SUCCESS) {
 277                 ret = ltdb_index_one(module, msg, 1);
 278                 if (ret != LDB_SUCCESS) {
 279                         return ret;
 280                 }
 281
 282                 ret = ltdb_modified(module, msg->dn);
 283                 if (ret != LDB_SUCCESS) {
 284                         return ret;
 285                 }
 286         }
 287
 288         return ret;
 289 }
 290
 291 /*
 292   add a record to the database
 293 */
 294 static int ltdb_add(struct ldb_module *module, struct ldb_request *req)
 295 {
 296         struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
 297         struct ltdb_context *ltdb_ac;
 298         int tret, ret = LDB_SUCCESS;
 299
 300         if (check_critical_controls(req->controls)) {
 301                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
 302         }
 303
 304         req->handle = init_ltdb_handle(ltdb, module, req);
 305         if (req->handle == NULL) {
 306                 return LDB_ERR_OPERATIONS_ERROR;
 307         }
 308         ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
 309
 310         tret = ltdb_add_internal(module, req->op.add.message);
 311         if (tret != LDB_SUCCESS) {
 312                 req->handle->status = tret;
 313                 goto done;
 314         }
 315
 316         if (ltdb_ac->callback) {
 317                 ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
 318         }
 319 done:
 320         req->handle->state = LDB_ASYNC_DONE;
 321         return ret;
 322 }
 323
 324 /*
 325   delete a record from the database, not updating indexes (used for deleting
 326   index records)
 327 */
 328 int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn)
 329 {
 330         struct ltdb_private *ltdb =
 331                 talloc_get_type(module->private_data, struct ltdb_private);
 332         TDB_DATA tdb_key;
 333         int ret;
 334
 335         tdb_key = ltdb_key(module, dn);
 336         if (!tdb_key.dptr) {
 337                 return LDB_ERR_OTHER;
 338         }
 339
 340         ret = tdb_delete(ltdb->tdb, tdb_key);
 341         talloc_free(tdb_key.dptr);
 342
 343         if (ret != 0) {
 344                 ret = ltdb_err_map(tdb_error(ltdb->tdb));
 345         }
 346
 347         return ret;
 348 }
 349
 350 static int ltdb_delete_internal(struct ldb_module *module, struct ldb_dn *dn)
 351 {
 352         struct ldb_message *msg;
 353         int ret;
 354
 355         msg = talloc(module, struct ldb_message);
 356         if (msg == NULL) {
 357                 return LDB_ERR_OPERATIONS_ERROR;
 358         }
 359
 360         /* in case any attribute of the message was indexed, we need
 361            to fetch the old record */
 362         ret = ltdb_search_dn1(module, dn, msg);
 363         if (ret != LDB_SUCCESS) {
 364                 /* not finding the old record is an error */
 365                 goto done;
 366         }
 367
 368         ret = ltdb_delete_noindex(module, dn);
 369         if (ret != LDB_SUCCESS) {
 370                 goto done;
 371         }
 372
 373         /* remove one level attribute */
 374         ret = ltdb_index_one(module, msg, 0);
 375         if (ret != LDB_SUCCESS) {
 376                 goto done;
 377         }
 378
 379         /* remove any indexed attributes */
 380         ret = ltdb_index_del(module, msg);
 381         if (ret != LDB_SUCCESS) {
 382                 goto done;
 383         }
 384
 385         ret = ltdb_modified(module, dn);
 386         if (ret != LDB_SUCCESS) {
 387                 goto done;
 388         }
 389
 390 done:
 391         talloc_free(msg);
 392         return ret;
 393 }
 394
 395 /*
 396   delete a record from the database
 397 */
 398 static int ltdb_delete(struct ldb_module *module, struct ldb_request *req)
 399 {
 400         struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
 401         struct ltdb_context *ltdb_ac;
 402         int tret, ret = LDB_SUCCESS;
 403
 404         if (check_critical_controls(req->controls)) {
 405                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
 406         }
 407
 408         req->handle = NULL;
 409
 410         if (ltdb_cache_load(module) != 0) {
 411                 return LDB_ERR_OPERATIONS_ERROR;
 412         }
 413
 414         req->handle = init_ltdb_handle(ltdb, module, req);
 415         if (req->handle == NULL) {
 416                 return LDB_ERR_OPERATIONS_ERROR;
 417         }
 418         ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
 419
 420         tret = ltdb_delete_internal(module, req->op.del.dn);
 421         if (tret != LDB_SUCCESS) {
 422                 req->handle->status = tret;
 423                 goto done;
 424         }
 425
 426         if (ltdb_ac->callback) {
 427                 ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
 428         }
 429 done:
 430         req->handle->state = LDB_ASYNC_DONE;
 431         return ret;
 432 }
 433
 434 /*
 435   find an element by attribute name. At the moment this does a linear search, it should
 436   be re-coded to use a binary search once all places that modify records guarantee
 437   sorted order
 438
 439   return the index of the first matching element if found, otherwise -1
 440 */
 441 static int find_element(const struct ldb_message *msg, const char *name)
 442 {
 443         unsigned int i;
 444         for (i=0;i<msg->num_elements;i++) {
 445                 if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
 446                         return i;
 447                 }
 448         }
 449         return -1;
 450 }
 451
 452
 453 /*
 454   add an element to an existing record. Assumes a elements array that we
 455   can call re-alloc on, and assumed that we can re-use the data pointers from the
 456   passed in additional values. Use with care!
 457
 458   returns 0 on success, -1 on failure (and sets errno)
 459 */
 460 static int msg_add_element(struct ldb_context *ldb,
 461                            struct ldb_message *msg, struct ldb_message_element *el)
 462 {
 463         struct ldb_message_element *e2;
 464         unsigned int i;
 465
 466         e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
 467                               msg->num_elements+1);
 468         if (!e2) {
 469                 errno = ENOMEM;
 470                 return -1;
 471         }
 472
 473         msg->elements = e2;
 474
 475         e2 = &msg->elements[msg->num_elements];
 476
 477         e2->name = el->name;
 478         e2->flags = el->flags;
 479         e2->values = NULL;
 480         if (el->num_values != 0) {
 481                 e2->values = talloc_array(msg->elements, struct ldb_val, el->num_values);
 482                 if (!e2->values) {
 483                         errno = ENOMEM;
 484                         return -1;
 485                 }
 486         }
 487         for (i=0;i<el->num_values;i++) {
 488                 e2->values[i] = el->values[i];
 489         }
 490         e2->num_values = el->num_values;
 491
 492         msg->num_elements++;
 493
 494         return 0;
 495 }
 496
 497 /*
 498   delete all elements having a specified attribute name
 499 */
 500 static int msg_delete_attribute(struct ldb_module *module,
 501                                 struct ldb_context *ldb,
 502                                 struct ldb_message *msg, const char *name)
 503 {
 504         const char *dn;
 505         unsigned int i, j;
 506
 507         dn = ldb_dn_get_linearized(msg->dn);
 508         if (dn == NULL) {
 509                 return -1;
 510         }
 511
 512         for (i=0;i<msg->num_elements;i++) {
 513                 if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
 514                         for (j=0;j<msg->elements[i].num_values;j++) {
 515                                 ltdb_index_del_value(module, dn, &msg->elements[i], j);
 516                         }
 517                         talloc_free(msg->elements[i].values);
 518                         if (msg->num_elements > (i+1)) {
 519                                 memmove(&msg->elements[i],
 520                                         &msg->elements[i+1],
 521                                         sizeof(struct ldb_message_element)*
 522                                         (msg->num_elements - (i+1)));
 523                         }
 524                         msg->num_elements--;
 525                         i--;
 526                         msg->elements = talloc_realloc(msg, msg->elements,
 527                                                          struct ldb_message_element,
 528                                                          msg->num_elements);
 529                 }
 530         }
 531
 532         return 0;
 533 }
 534
 535 /*
 536   delete all elements matching an attribute name/value
 537
 538   return 0 on success, -1 on failure
 539 */
 540 static int msg_delete_element(struct ldb_module *module,
 541                               struct ldb_message *msg,
 542                               const char *name,
 543                               const struct ldb_val *val)
 544 {
 545         struct ldb_context *ldb = module->ldb;
 546         unsigned int i;
 547         int found;
 548         struct ldb_message_element *el;
 549         const struct ldb_schema_attribute *a;
 550
 551         found = find_element(msg, name);
 552         if (found == -1) {
 553                 return -1;
 554         }
 555
 556         el = &msg->elements[found];
 557
 558         a = ldb_schema_attribute_by_name(ldb, el->name);
 559
 560         for (i=0;i<el->num_values;i++) {
 561                 if (a->syntax->comparison_fn(ldb, ldb, &el->values[i], val) == 0) {
 562                         if (i<el->num_values-1) {
 563                                 memmove(&el->values[i], &el->values[i+1],
 564                                         sizeof(el->values[i])*(el->num_values-(i+1)));
 565                         }
 566                         el->num_values--;
 567                         if (el->num_values == 0) {
 568                                 return msg_delete_attribute(module, ldb, msg, name);
 569                         }
 570                         return 0;
 571                 }
 572         }
 573
 574         return -1;
 575 }
 576
 577
 578 /*
 579   modify a record - internal interface
 580
 581   yuck - this is O(n^2). Luckily n is usually small so we probably
 582   get away with it, but if we ever have really large attribute lists
 583   then we'll need to look at this again
 584 */
 585 int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *msg)
 586 {
 587         struct ldb_context *ldb = module->ldb;
 588         struct ltdb_private *ltdb =
 589                 talloc_get_type(module->private_data, struct ltdb_private);
 590         TDB_DATA tdb_key, tdb_data;
 591         struct ldb_message *msg2;
 592         unsigned i, j;
 593         int ret, idx;
 594
 595         tdb_key = ltdb_key(module, msg->dn);
 596         if (!tdb_key.dptr) {
 597                 return LDB_ERR_OTHER;
 598         }
 599
 600         tdb_data = tdb_fetch(ltdb->tdb, tdb_key);
 601         if (!tdb_data.dptr) {
 602                 talloc_free(tdb_key.dptr);
 603                 return ltdb_err_map(tdb_error(ltdb->tdb));
 604         }
 605
 606         msg2 = talloc(tdb_key.dptr, struct ldb_message);
 607         if (msg2 == NULL) {
 608                 talloc_free(tdb_key.dptr);
 609                 return LDB_ERR_OTHER;
 610         }
 611
 612         ret = ltdb_unpack_data(module, &tdb_data, msg2);
 613         if (ret == -1) {
 614                 ret = LDB_ERR_OTHER;
 615                 goto failed;
 616         }
 617
 618         if (!msg2->dn) {
 619                 msg2->dn = msg->dn;
 620         }
 621
 622         for (i=0;i<msg->num_elements;i++) {
 623                 struct ldb_message_element *el = &msg->elements[i];
 624                 struct ldb_message_element *el2;
 625                 struct ldb_val *vals;
 626                 const char *dn;
 627
 628                 switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
 629
 630                 case LDB_FLAG_MOD_ADD:
 631                         /* add this element to the message. fail if it
 632                            already exists */
 633                         idx = find_element(msg2, el->name);
 634
 635                         if (idx == -1) {
 636                                 if (msg_add_element(ldb, msg2, el) != 0) {
 637                                         ret = LDB_ERR_OTHER;
 638                                         goto failed;
 639                                 }
 640                                 continue;
 641                         }
 642
 643                         el2 = &msg2->elements[idx];
 644
 645                         /* An attribute with this name already exists,
 646                          * add all values if they don't already exist
 647                          * (check both the other elements to be added,
 648                          * and those already in the db). */
 649
 650                         for (j=0;j<el->num_values;j++) {
 651                                 if (ldb_msg_find_val(el2, &el->values[j])) {
 652                                         ldb_asprintf_errstring(module->ldb, "%s: value #%d already exists", el->name, j);
 653                                         ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
 654                                         goto failed;
 655                                 }
 656                                 if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
 657                                         ldb_asprintf_errstring(module->ldb, "%s: value #%d provided more than once", el->name, j);
 658                                         ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
 659                                         goto failed;
 660                                 }
 661                         }
 662
 663                         vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
 664                                                 el2->num_values + el->num_values);
 665
 666                         if (vals == NULL) {
 667                                 ret = LDB_ERR_OTHER;
 668                                 goto failed;
 669                         }
 670
 671                         for (j=0;j<el->num_values;j++) {
 672                                 vals[el2->num_values + j] =
 673                                         ldb_val_dup(vals, &el->values[j]);
 674                         }
 675
 676                         el2->values = vals;
 677                         el2->num_values += el->num_values;
 678
 679                         break;
 680
 681                 case LDB_FLAG_MOD_REPLACE:
 682                         /* replace all elements of this attribute name with the elements
 683                            listed. The attribute not existing is not an error */
 684                         msg_delete_attribute(module, ldb, msg2, el->name);
 685
 686                         for (j=0;j<el->num_values;j++) {
 687                                 if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
 688                                         ldb_asprintf_errstring(module->ldb, "%s: value #%d provided more than once", el->name, j);
 689                                         ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
 690                                         goto failed;
 691                                 }
 692                         }
 693
 694                         /* add the replacement element, if not empty */
 695                         if (el->num_values != 0 &&
 696                             msg_add_element(ldb, msg2, el) != 0) {
 697                                 ret = LDB_ERR_OTHER;
 698                                 goto failed;
 699                         }
 700                         break;
 701
 702                 case LDB_FLAG_MOD_DELETE:
 703
 704                         dn = ldb_dn_get_linearized(msg->dn);
 705                         if (dn == NULL) {
 706                                 ret = LDB_ERR_OTHER;
 707                                 goto failed;
 708                         }
 709
 710                         /* we could be being asked to delete all
 711                            values or just some values */
 712                         if (msg->elements[i].num_values == 0) {
 713                                 if (msg_delete_attribute(module, ldb, msg2,
 714                                                          msg->elements[i].name) != 0) {
 715                                         ldb_asprintf_errstring(module->ldb, "No such attribute: %s for delete on %s", msg->elements[i].name, dn);
 716                                         ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
 717                                         goto failed;
 718                                 }
 719                                 break;
 720                         }
 721                         for (j=0;j<msg->elements[i].num_values;j++) {
 722                                 if (msg_delete_element(module,
 723                                                        msg2,
 724                                                        msg->elements[i].name,
 725                                                        &msg->elements[i].values[j]) != 0) {
 726                                         ldb_asprintf_errstring(module->ldb, "No matching attribute value when deleting attribute: %s on %s", msg->elements[i].name, dn);
 727                                         ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
 728                                         goto failed;
 729                                 }
 730                                 ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
 731                                 if (ret != LDB_SUCCESS) {
 732                                         goto failed;
 733                                 }
 734                         }
 735                         break;
 736                 default:
 737                         ldb_asprintf_errstring(module->ldb, "Invalid ldb_modify flags on %s: 0x%x",
 738                                                              msg->elements[i].name,
 739                                                              msg->elements[i].flags & LDB_FLAG_MOD_MASK);
 740                         ret = LDB_ERR_PROTOCOL_ERROR;
 741                         goto failed;
 742                 }
 743         }
 744
 745         /* we've made all the mods - save the modified record back into the database */
 746         ret = ltdb_store(module, msg2, TDB_MODIFY);
 747         if (ret != LDB_SUCCESS) {
 748                 goto failed;
 749         }
 750
 751         ret = ltdb_modified(module, msg->dn);
 752         if (ret != LDB_SUCCESS) {
 753                 goto failed;
 754         }
 755
 756         talloc_free(tdb_key.dptr);
 757         free(tdb_data.dptr);
 758         return ret;
 759
 760 failed:
 761         talloc_free(tdb_key.dptr);
 762         free(tdb_data.dptr);
 763         return ret;
 764 }
 765
 766 /*
 767   modify a record
 768 */
 769 static int ltdb_modify(struct ldb_module *module, struct ldb_request *req)
 770 {
 771         struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
 772         struct ltdb_context *ltdb_ac;
 773         int tret, ret = LDB_SUCCESS;
 774
 775         if (check_critical_controls(req->controls)) {
 776                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
 777         }
 778
 779         req->handle = NULL;
 780
 781         req->handle = init_ltdb_handle(ltdb, module, req);
 782         if (req->handle == NULL) {
 783                 return LDB_ERR_OPERATIONS_ERROR;
 784         }
 785         ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
 786
 787         tret = ltdb_check_special_dn(module, req->op.mod.message);
 788         if (tret != LDB_SUCCESS) {
 789                 req->handle->status = tret;
 790                 goto done;
 791         }
 792
 793         if (ltdb_cache_load(module) != 0) {
 794                 ret = LDB_ERR_OPERATIONS_ERROR;
 795                 goto done;
 796         }
 797
 798         tret = ltdb_modify_internal(module, req->op.mod.message);
 799         if (tret != LDB_SUCCESS) {
 800                 req->handle->status = tret;
 801                 goto done;
 802         }
 803
 804         if (ltdb_ac->callback) {
 805                 ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
 806         }
 807 done:
 808         req->handle->state = LDB_ASYNC_DONE;
 809         return ret;
 810 }
 811
 812 /*
 813   rename a record
 814 */
 815 static int ltdb_rename(struct ldb_module *module, struct ldb_request *req)
 816 {
 817         struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
 818         struct ltdb_context *ltdb_ac;
 819         struct ldb_message *msg;
 820         int tret, ret = LDB_SUCCESS;
 821
 822         if (check_critical_controls(req->controls)) {
 823                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
 824         }
 825
 826         req->handle = NULL;
 827
 828         if (ltdb_cache_load(module) != 0) {
 829                 return LDB_ERR_OPERATIONS_ERROR;
 830         }
 831
 832         req->handle = init_ltdb_handle(ltdb, module, req);
 833         if (req->handle == NULL) {
 834                 return LDB_ERR_OPERATIONS_ERROR;
 835         }
 836         ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
 837
 838         msg = talloc(ltdb_ac, struct ldb_message);
 839         if (msg == NULL) {
 840                 ret = LDB_ERR_OPERATIONS_ERROR;
 841                 goto done;
 842         }
 843
 844         /* in case any attribute of the message was indexed, we need
 845            to fetch the old record */
 846         tret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
 847         if (tret != LDB_SUCCESS) {
 848                 /* not finding the old record is an error */
 849                 req->handle->status = tret;
 850                 goto done;
 851         }
 852
 853         msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
 854         if (!msg->dn) {
 855                 ret = LDB_ERR_OPERATIONS_ERROR;
 856                 goto done;
 857         }
 858
 859         ret = ltdb_add_internal(module, msg);
 860         if (ret != LDB_SUCCESS) {
 861                 goto done;
 862         }
 863
 864         tret = ltdb_delete_internal(module, req->op.rename.olddn);
 865         if (tret != LDB_SUCCESS) {
 866                 ltdb_delete_internal(module, req->op.rename.newdn);
 867                 ret = LDB_ERR_OPERATIONS_ERROR;
 868                 goto done;
 869         }
 870
 871         if (ltdb_ac->callback) {
 872                 ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
 873         }
 874 done:
 875         req->handle->state = LDB_ASYNC_DONE;
 876         return ret;
 877 }
 878
 879 static int ltdb_start_trans(struct ldb_module *module)
 880 {
 881         struct ltdb_private *ltdb =
 882                 talloc_get_type(module->private_data, struct ltdb_private);
 883
 884         if (tdb_transaction_start(ltdb->tdb) != 0) {
 885                 return ltdb_err_map(tdb_error(ltdb->tdb));
 886         }
 887
 888         return LDB_SUCCESS;
 889 }
 890
 891 static int ltdb_end_trans(struct ldb_module *module)
 892 {
 893         struct ltdb_private *ltdb =
 894                 talloc_get_type(module->private_data, struct ltdb_private);
 895
 896         if (tdb_transaction_commit(ltdb->tdb) != 0) {
 897                 return ltdb_err_map(tdb_error(ltdb->tdb));
 898         }
 899
 900         return LDB_SUCCESS;
 901 }
 902
 903 static int ltdb_del_trans(struct ldb_module *module)
 904 {
 905         struct ltdb_private *ltdb =
 906                 talloc_get_type(module->private_data, struct ltdb_private);
 907
 908         if (tdb_transaction_cancel(ltdb->tdb) != 0) {
 909                 return ltdb_err_map(tdb_error(ltdb->tdb));
 910         }
 911
 912         return LDB_SUCCESS;
 913 }
 914
 915 static int ltdb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 916 {
 917         return handle->status;
 918 }
 919
 920 static int ltdb_request(struct ldb_module *module, struct ldb_request *req)
 921 {
 922         /* check for oustanding critical controls and return an error if found */
 923         if (check_critical_controls(req->controls)) {
 924                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
 925         }
 926
 927         /* search, add, modify, delete, rename are handled by their own, no other op supported */
 928         return LDB_ERR_OPERATIONS_ERROR;
 929 }
 930
 931 /*
 932   return sequenceNumber from @BASEINFO
 933 */
 934 static int ltdb_sequence_number(struct ldb_module *module, struct ldb_request *req)
 935 {
 936         TALLOC_CTX *tmp_ctx = talloc_new(req);
 937         struct ldb_message *msg = NULL;
 938         struct ldb_dn *dn = ldb_dn_new(tmp_ctx, module->ldb, LTDB_BASEINFO);
 939         int tret;
 940
 941         if (tmp_ctx == NULL) {
 942                 talloc_free(tmp_ctx);
 943                 return LDB_ERR_OPERATIONS_ERROR;
 944         }
 945
 946         msg = talloc(tmp_ctx, struct ldb_message);
 947         if (msg == NULL) {
 948                 talloc_free(tmp_ctx);
 949                 return LDB_ERR_OPERATIONS_ERROR;
 950         }
 951
 952         req->op.seq_num.flags = 0;
 953
 954         tret = ltdb_search_dn1(module, dn, msg);
 955         if (tret != LDB_SUCCESS) {
 956                 talloc_free(tmp_ctx);
 957                 /* zero is as good as anything when we don't know */
 958                 req->op.seq_num.seq_num = 0;
 959                 return LDB_SUCCESS;
 960         }
 961
 962         switch (req->op.seq_num.type) {
 963         case LDB_SEQ_HIGHEST_SEQ:
 964                 req->op.seq_num.seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
 965                 break;
 966         case LDB_SEQ_NEXT:
 967                 req->op.seq_num.seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
 968                 req->op.seq_num.seq_num++;
 969                 break;
 970         case LDB_SEQ_HIGHEST_TIMESTAMP:
 971         {
 972                 const char *date = ldb_msg_find_attr_as_string(msg, LTDB_MOD_TIMESTAMP, NULL);
 973                 if (date) {
 974                         req->op.seq_num.seq_num = ldb_string_to_time(date);
 975                 } else {
 976                         req->op.seq_num.seq_num = 0;
 977                         /* zero is as good as anything when we don't know */
 978                 }
 979                 break;
 980         }
 981         }
 982         talloc_free(tmp_ctx);
 983         return LDB_SUCCESS;
 984 }
 985
 986 static const struct ldb_module_ops ltdb_ops = {
 987         .name              = "tdb",
 988         .search            = ltdb_search,
 989         .add               = ltdb_add,
 990         .modify            = ltdb_modify,
 991         .del               = ltdb_delete,
 992         .rename            = ltdb_rename,
 993         .request           = ltdb_request,
 994         .start_transaction = ltdb_start_trans,
 995         .end_transaction   = ltdb_end_trans,
 996         .del_transaction   = ltdb_del_trans,
 997         .wait              = ltdb_wait,
 998         .sequence_number   = ltdb_sequence_number
 999 };
1000
1001 /*
1002   connect to the database
1003 */
1004 static int ltdb_connect(struct ldb_context *ldb, const char *url,
1005                         unsigned int flags, const char *options[],
1006                         struct ldb_module **module)
1007 {
1008         const char *path;
1009         int tdb_flags, open_flags;
1010         struct ltdb_private *ltdb;
1011
1012         /* parse the url */
1013         if (strchr(url, ':')) {
1014                 if (strncmp(url, "tdb://", 6) != 0) {
1015                         ldb_debug(ldb, LDB_DEBUG_ERROR, "Invalid tdb URL '%s'", url);
1016                         return -1;
1017                 }
1018                 path = url+6;
1019         } else {
1020                 path = url;
1021         }
1022
1023         tdb_flags = TDB_DEFAULT | TDB_SEQNUM;
1024
1025         /* check for the 'nosync' option */
1026         if (flags & LDB_FLG_NOSYNC) {
1027                 tdb_flags |= TDB_NOSYNC;
1028         }
1029
1030         /* and nommap option */
1031         if (flags & LDB_FLG_NOMMAP) {
1032                 tdb_flags |= TDB_NOMMAP;
1033         }
1034
1035         if (flags & LDB_FLG_RDONLY) {
1036                 open_flags = O_RDONLY;
1037         } else {
1038                 open_flags = O_CREAT | O_RDWR;
1039         }
1040
1041         ltdb = talloc_zero(ldb, struct ltdb_private);
1042         if (!ltdb) {
1043                 ldb_oom(ldb);
1044                 return -1;
1045         }
1046
1047         /* note that we use quite a large default hash size */
1048         ltdb->tdb = ltdb_wrap_open(ltdb, path, 10000,
1049                                    tdb_flags, open_flags,
1050                                    ldb->create_perms, ldb);
1051         if (!ltdb->tdb) {
1052                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Unable to open tdb '%s'\n", path);
1053                 talloc_free(ltdb);
1054                 return -1;
1055         }
1056
1057         ltdb->sequence_number = 0;
1058
1059         *module = talloc(ldb, struct ldb_module);
1060         if (!module) {
1061                 ldb_oom(ldb);
1062                 talloc_free(ltdb);
1063                 return -1;
1064         }
1065         talloc_set_name_const(*module, "ldb_tdb backend");
1066         (*module)->ldb = ldb;
1067         (*module)->prev = (*module)->next = NULL;
1068         (*module)->private_data = ltdb;
1069         (*module)->ops = &ltdb_ops;
1070
1071         if (ltdb_cache_load(*module) != 0) {
1072                 talloc_free(*module);
1073                 talloc_free(ltdb);
1074                 return -1;
1075         }
1076
1077         return 0;
1078 }
1079
1080 int ldb_tdb_init(void)
1081 {
1082         return ldb_register_backend("tdb", ltdb_connect);
1083 }