lib/ldb/tests/ldb_mod_op_test.c

   1 /*
   2  * from cmocka.c:
   3  * These headers or their equivalents should be included prior to
   4  * including
   5  * this header file.
   6  *
   7  * #include <stdarg.h>
   8  * #include <stddef.h>
   9  * #include <setjmp.h>
  10  *
  11  * This allows test applications to use custom definitions of C standard
  12  * library functions and types.
  13  */
  14 #include <stdarg.h>
  15 #include <stddef.h>
  16 #include <setjmp.h>
  17 #include <cmocka.h>
  18
  19 #include <errno.h>
  20 #include <unistd.h>
  21 #include <talloc.h>
  22
  23 #define TEVENT_DEPRECATED 1
  24 #include <tevent.h>
  25
  26 #include <ldb.h>
  27 #include <ldb_module.h>
  28 #include <ldb_private.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31
  32 #include <sys/wait.h>
  33
  34
  35 #define DEFAULT_BE  "tdb"
  36
  37 #ifndef TEST_BE
  38 #define TEST_BE DEFAULT_BE
  39 #endif /* TEST_BE */
  40
  41 struct ldbtest_ctx {
  42         struct tevent_context *ev;
  43         struct ldb_context *ldb;
  44
  45         const char *dbfile;
  46         const char *lockfile;   /* lockfile is separate */
  47
  48         const char *dbpath;
  49 };
  50
  51 static void unlink_old_db(struct ldbtest_ctx *test_ctx)
  52 {
  53         int ret;
  54
  55         errno = 0;
  56         ret = unlink(test_ctx->lockfile);
  57         if (ret == -1 && errno != ENOENT) {
  58                 fail();
  59         }
  60
  61         errno = 0;
  62         ret = unlink(test_ctx->dbfile);
  63         if (ret == -1 && errno != ENOENT) {
  64                 fail();
  65         }
  66 }
  67
  68 static int ldbtest_noconn_setup(void **state)
  69 {
  70         struct ldbtest_ctx *test_ctx;
  71
  72         test_ctx = talloc_zero(NULL, struct ldbtest_ctx);
  73         assert_non_null(test_ctx);
  74
  75         test_ctx->ev = tevent_context_init(test_ctx);
  76         assert_non_null(test_ctx->ev);
  77
  78         test_ctx->ldb = ldb_init(test_ctx, test_ctx->ev);
  79         assert_non_null(test_ctx->ldb);
  80
  81         test_ctx->dbfile = talloc_strdup(test_ctx, "apitest.ldb");
  82         assert_non_null(test_ctx->dbfile);
  83
  84         test_ctx->lockfile = talloc_asprintf(test_ctx, "%s-lock",
  85                                              test_ctx->dbfile);
  86         assert_non_null(test_ctx->lockfile);
  87
  88         test_ctx->dbpath = talloc_asprintf(test_ctx,
  89                         TEST_BE"://%s", test_ctx->dbfile);
  90         assert_non_null(test_ctx->dbpath);
  91
  92         unlink_old_db(test_ctx);
  93         *state = test_ctx;
  94         return 0;
  95 }
  96
  97 static int ldbtest_noconn_teardown(void **state)
  98 {
  99         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 100                                                         struct ldbtest_ctx);
 101
 102         unlink_old_db(test_ctx);
 103         talloc_free(test_ctx);
 104         return 0;
 105 }
 106
 107 static void test_connect(void **state)
 108 {
 109         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 110                                                         struct ldbtest_ctx);
 111         int ret;
 112
 113         ret = ldb_connect(test_ctx->ldb, test_ctx->dbpath, 0, NULL);
 114         assert_int_equal(ret, 0);
 115 }
 116
 117 static int ldbtest_setup(void **state)
 118 {
 119         struct ldbtest_ctx *test_ctx;
 120         int ret;
 121
 122         ldbtest_noconn_setup((void **) &test_ctx);
 123
 124         ret = ldb_connect(test_ctx->ldb, test_ctx->dbpath, 0, NULL);
 125         assert_int_equal(ret, 0);
 126
 127         *state = test_ctx;
 128         return 0;
 129 }
 130
 131 static int ldbtest_teardown(void **state)
 132 {
 133         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 134                                                         struct ldbtest_ctx);
 135         ldbtest_noconn_teardown((void **) &test_ctx);
 136         return 0;
 137 }
 138
 139 static void test_ldb_add(void **state)
 140 {
 141         int ret;
 142         struct ldb_message *msg;
 143         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 144                                                         struct ldbtest_ctx);
 145         TALLOC_CTX *tmp_ctx;
 146
 147         tmp_ctx = talloc_new(test_ctx);
 148         assert_non_null(tmp_ctx);
 149
 150         msg = ldb_msg_new(tmp_ctx);
 151         assert_non_null(msg);
 152
 153         msg->dn = ldb_dn_new_fmt(msg, test_ctx->ldb, "dc=test");
 154         assert_non_null(msg->dn);
 155
 156         ret = ldb_msg_add_string(msg, "cn", "test_cn_val");
 157         assert_int_equal(ret, 0);
 158
 159         ret = ldb_add(test_ctx->ldb, msg);
 160         assert_int_equal(ret, 0);
 161
 162         talloc_free(tmp_ctx);
 163 }
 164
 165 static void test_ldb_search(void **state)
 166 {
 167         int ret;
 168         struct ldb_message *msg;
 169         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 170                                                         struct ldbtest_ctx);
 171         TALLOC_CTX *tmp_ctx;
 172         struct ldb_dn *basedn;
 173         struct ldb_dn *basedn2;
 174         struct ldb_result *result = NULL;
 175
 176         tmp_ctx = talloc_new(test_ctx);
 177         assert_non_null(tmp_ctx);
 178
 179         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "dc=test");
 180         assert_non_null(basedn);
 181
 182         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
 183                          LDB_SCOPE_BASE, NULL, NULL);
 184         assert_int_equal(ret, 0);
 185         assert_non_null(result);
 186         assert_int_equal(result->count, 0);
 187
 188         msg = ldb_msg_new(tmp_ctx);
 189         assert_non_null(msg);
 190
 191         msg->dn = basedn;
 192         assert_non_null(msg->dn);
 193
 194         ret = ldb_msg_add_string(msg, "cn", "test_cn_val1");
 195         assert_int_equal(ret, 0);
 196
 197         ret = ldb_add(test_ctx->ldb, msg);
 198         assert_int_equal(ret, 0);
 199
 200         basedn2 = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "dc=test2");
 201         assert_non_null(basedn2);
 202
 203         msg = ldb_msg_new(tmp_ctx);
 204         assert_non_null(msg);
 205
 206         msg->dn = basedn2;
 207         assert_non_null(msg->dn);
 208
 209         ret = ldb_msg_add_string(msg, "cn", "test_cn_val2");
 210         assert_int_equal(ret, 0);
 211
 212         ret = ldb_add(test_ctx->ldb, msg);
 213         assert_int_equal(ret, 0);
 214
 215         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
 216                          LDB_SCOPE_BASE, NULL, NULL);
 217         assert_int_equal(ret, 0);
 218         assert_non_null(result);
 219         assert_int_equal(result->count, 1);
 220         assert_string_equal(ldb_dn_get_linearized(result->msgs[0]->dn),
 221                             ldb_dn_get_linearized(basedn));
 222
 223         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn2,
 224                          LDB_SCOPE_BASE, NULL, NULL);
 225         assert_int_equal(ret, 0);
 226         assert_non_null(result);
 227         assert_int_equal(result->count, 1);
 228         assert_string_equal(ldb_dn_get_linearized(result->msgs[0]->dn),
 229                             ldb_dn_get_linearized(basedn2));
 230
 231         talloc_free(tmp_ctx);
 232 }
 233
 234 static int base_search_count(struct ldbtest_ctx *test_ctx, const char *entry_dn)
 235 {
 236         TALLOC_CTX *tmp_ctx;
 237         struct ldb_dn *basedn;
 238         struct ldb_result *result = NULL;
 239         int ret;
 240         int count;
 241
 242         tmp_ctx = talloc_new(test_ctx);
 243         assert_non_null(tmp_ctx);
 244
 245         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "%s", entry_dn);
 246         assert_non_null(basedn);
 247
 248         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
 249                          LDB_SCOPE_BASE, NULL, NULL);
 250         assert_int_equal(ret, LDB_SUCCESS);
 251         assert_non_null(result);
 252
 253         count = result->count;
 254         talloc_free(tmp_ctx);
 255         return count;
 256 }
 257
 258 static int sub_search_count(struct ldbtest_ctx *test_ctx,
 259                             const char *base_dn,
 260                             const char *filter)
 261 {
 262         TALLOC_CTX *tmp_ctx;
 263         struct ldb_dn *basedn;
 264         struct ldb_result *result = NULL;
 265         int ret;
 266         int count;
 267
 268         tmp_ctx = talloc_new(test_ctx);
 269         assert_non_null(tmp_ctx);
 270
 271         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "%s", base_dn);
 272         assert_non_null(basedn);
 273
 274         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
 275                          LDB_SCOPE_SUBTREE, NULL, "%s", filter);
 276         assert_int_equal(ret, LDB_SUCCESS);
 277         assert_non_null(result);
 278
 279         count = result->count;
 280         talloc_free(tmp_ctx);
 281         return count;
 282 }
 283
 284 /* In general it would be better if utility test functions didn't assert
 285  * but only returned a value, then assert in the test shows correct
 286  * line
 287  */
 288 static void assert_dn_exists(struct ldbtest_ctx *test_ctx,
 289                              const char *entry_dn)
 290 {
 291         int count;
 292
 293         count = base_search_count(test_ctx, entry_dn);
 294         assert_int_equal(count, 1);
 295 }
 296
 297 static void assert_dn_doesnt_exist(struct ldbtest_ctx *test_ctx,
 298                                    const char *entry_dn)
 299 {
 300         int count;
 301
 302         count = base_search_count(test_ctx, entry_dn);
 303         assert_int_equal(count, 0);
 304 }
 305
 306 static void add_dn_with_cn(struct ldbtest_ctx *test_ctx,
 307                            struct ldb_dn *dn,
 308                            const char *cn_value)
 309 {
 310         int ret;
 311         TALLOC_CTX *tmp_ctx;
 312         struct ldb_message *msg;
 313
 314         tmp_ctx = talloc_new(test_ctx);
 315         assert_non_null(tmp_ctx);
 316
 317         assert_dn_doesnt_exist(test_ctx,
 318                                ldb_dn_get_linearized(dn));
 319
 320         msg = ldb_msg_new(tmp_ctx);
 321         assert_non_null(msg);
 322         msg->dn = dn;
 323
 324         ret = ldb_msg_add_string(msg, "cn", cn_value);
 325         assert_int_equal(ret, LDB_SUCCESS);
 326
 327         ret = ldb_add(test_ctx->ldb, msg);
 328         assert_int_equal(ret, LDB_SUCCESS);
 329
 330         assert_dn_exists(test_ctx,
 331                          ldb_dn_get_linearized(dn));
 332         talloc_free(tmp_ctx);
 333 }
 334
 335 static void test_ldb_del(void **state)
 336 {
 337         int ret;
 338         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 339                                                         struct ldbtest_ctx);
 340         const char *basedn = "dc=ldb_del_test";
 341         struct ldb_dn *dn;
 342
 343         dn = ldb_dn_new_fmt(test_ctx, test_ctx->ldb, "%s", basedn);
 344         assert_non_null(dn);
 345
 346         add_dn_with_cn(test_ctx, dn, "test_del_cn_val");
 347
 348         ret = ldb_delete(test_ctx->ldb, dn);
 349         assert_int_equal(ret, LDB_SUCCESS);
 350
 351         assert_dn_doesnt_exist(test_ctx, basedn);
 352 }
 353
 354 static void test_ldb_del_noexist(void **state)
 355 {
 356         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 357                                                              struct ldbtest_ctx);
 358         struct ldb_dn *basedn;
 359         int ret;
 360
 361         basedn = ldb_dn_new(test_ctx, test_ctx->ldb, "dc=nosuchplace");
 362         assert_non_null(basedn);
 363
 364         ret = ldb_delete(test_ctx->ldb, basedn);
 365         assert_int_equal(ret, LDB_ERR_NO_SUCH_OBJECT);
 366 }
 367
 368 static void test_ldb_handle(void **state)
 369 {
 370         int ret;
 371         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 372                                                         struct ldbtest_ctx);
 373         TALLOC_CTX *tmp_ctx;
 374         struct ldb_dn *basedn;
 375         struct ldb_request *request = NULL;
 376         struct ldb_request *request2 = NULL;
 377         struct ldb_result *res = NULL;
 378         const char *attrs[] = { "cn", NULL };
 379
 380         tmp_ctx = talloc_new(test_ctx);
 381         assert_non_null(tmp_ctx);
 382
 383         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "dc=test");
 384         assert_non_null(basedn);
 385
 386         res = talloc_zero(tmp_ctx, struct ldb_result);
 387         assert_non_null(res);
 388
 389         ret = ldb_build_search_req(&request, test_ctx->ldb, tmp_ctx,
 390                                    basedn, LDB_SCOPE_BASE,
 391                                    NULL, attrs, NULL, res,
 392                                    ldb_search_default_callback,
 393                                    NULL);
 394         assert_int_equal(ret, 0);
 395
 396         /* We are against ldb_tdb, so expect private event contexts */
 397         assert_ptr_not_equal(ldb_handle_get_event_context(request->handle),
 398                              ldb_get_event_context(test_ctx->ldb));
 399
 400         ret = ldb_build_search_req(&request2, test_ctx->ldb, tmp_ctx,
 401                                    basedn, LDB_SCOPE_BASE,
 402                                    NULL, attrs, NULL, res,
 403                                    ldb_search_default_callback,
 404                                    request);
 405         assert_int_equal(ret, 0);
 406
 407         /* Expect that same event context will be chained */
 408         assert_ptr_equal(ldb_handle_get_event_context(request->handle),
 409                          ldb_handle_get_event_context(request2->handle));
 410
 411         /* Now force this to use the global context */
 412         ldb_handle_use_global_event_context(request2->handle);
 413         assert_ptr_equal(ldb_handle_get_event_context(request2->handle),
 414                          ldb_get_event_context(test_ctx->ldb));
 415
 416         talloc_free(tmp_ctx);
 417 }
 418
 419 static void test_ldb_build_search_req(void **state)
 420 {
 421         int ret;
 422         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 423                                                         struct ldbtest_ctx);
 424         TALLOC_CTX *tmp_ctx;
 425         struct ldb_dn *basedn;
 426         struct ldb_request *request = NULL;
 427         struct ldb_request *request2 = NULL;
 428         struct ldb_result *res = NULL;
 429         const char *attrs[] = { "cn", NULL };
 430
 431         tmp_ctx = talloc_new(test_ctx);
 432         assert_non_null(tmp_ctx);
 433
 434         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "dc=test");
 435         assert_non_null(basedn);
 436
 437         res = talloc_zero(tmp_ctx, struct ldb_result);
 438         assert_non_null(res);
 439
 440         ret = ldb_build_search_req(&request, test_ctx->ldb, tmp_ctx,
 441                                    basedn, LDB_SCOPE_BASE,
 442                                    NULL, attrs, NULL, res,
 443                                    ldb_search_default_callback,
 444                                    NULL);
 445         assert_int_equal(ret, 0);
 446
 447         assert_int_equal(request->operation, LDB_SEARCH);
 448         assert_ptr_equal(request->op.search.base, basedn);
 449         assert_int_equal(request->op.search.scope, LDB_SCOPE_BASE);
 450         assert_non_null(request->op.search.tree);
 451         assert_ptr_equal(request->op.search.attrs, attrs);
 452         assert_ptr_equal(request->context, res);
 453         assert_ptr_equal(request->callback, ldb_search_default_callback);
 454
 455         ret = ldb_build_search_req(&request2, test_ctx->ldb, tmp_ctx,
 456                                    basedn, LDB_SCOPE_BASE,
 457                                    NULL, attrs, NULL, res,
 458                                    ldb_search_default_callback,
 459                                    request);
 460         assert_int_equal(ret, 0);
 461         assert_ptr_equal(request, request2->handle->parent);
 462         assert_int_equal(request->starttime, request2->starttime);
 463         assert_int_equal(request->timeout, request2->timeout);
 464
 465         talloc_free(tmp_ctx);
 466 }
 467
 468 static void add_keyval(struct ldbtest_ctx *test_ctx,
 469                        const char *key,
 470                        const char *val)
 471 {
 472         int ret;
 473         struct ldb_message *msg;
 474
 475         msg = ldb_msg_new(test_ctx);
 476         assert_non_null(msg);
 477
 478         msg->dn = ldb_dn_new_fmt(msg, test_ctx->ldb, "%s=%s", key, val);
 479         assert_non_null(msg->dn);
 480
 481         ret = ldb_msg_add_string(msg, key, val);
 482         assert_int_equal(ret, 0);
 483
 484         ret = ldb_add(test_ctx->ldb, msg);
 485         assert_int_equal(ret, 0);
 486
 487         talloc_free(msg);
 488 }
 489
 490 static struct ldb_result *get_keyval(struct ldbtest_ctx *test_ctx,
 491                                      const char *key,
 492                                      const char *val)
 493 {
 494         int ret;
 495         struct ldb_result *result;
 496         struct ldb_dn *basedn;
 497
 498         basedn = ldb_dn_new_fmt(test_ctx, test_ctx->ldb, "%s=%s", key, val);
 499         assert_non_null(basedn);
 500
 501         ret = ldb_search(test_ctx->ldb, test_ctx, &result, basedn,
 502                         LDB_SCOPE_BASE, NULL, NULL);
 503         assert_int_equal(ret, 0);
 504
 505         return result;
 506 }
 507
 508 static void test_transactions(void **state)
 509 {
 510         int ret;
 511         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
 512                         struct ldbtest_ctx);
 513         struct ldb_result *res;
 514
 515         /* start lev-0 transaction */
 516         ret = ldb_transaction_start(test_ctx->ldb);
 517         assert_int_equal(ret, 0);
 518
 519         add_keyval(test_ctx, "vegetable", "carrot");
 520
 521         /* commit lev-0 transaction */
 522         ret = ldb_transaction_commit(test_ctx->ldb);
 523         assert_int_equal(ret, 0);
 524
 525         /* start another lev-1 nested transaction */
 526         ret = ldb_transaction_start(test_ctx->ldb);
 527         assert_int_equal(ret, 0);
 528
 529         add_keyval(test_ctx, "fruit", "apple");
 530
 531         /* abort lev-1 nested transaction */
 532         ret = ldb_transaction_cancel(test_ctx->ldb);
 533         assert_int_equal(ret, 0);
 534
 535         res = get_keyval(test_ctx, "vegetable", "carrot");
 536         assert_non_null(res);
 537         assert_int_equal(res->count, 1);
 538
 539         res = get_keyval(test_ctx, "fruit", "apple");
 540         assert_non_null(res);
 541         assert_int_equal(res->count, 0);
 542 }
 543
 544 struct ldb_mod_test_ctx {
 545         struct ldbtest_ctx *ldb_test_ctx;
 546         const char *entry_dn;
 547 };
 548
 549 struct keyval {
 550         const char *key;
 551         const char *val;
 552 };
 553
 554 static struct ldb_message *build_mod_msg(TALLOC_CTX *mem_ctx,
 555                                          struct ldbtest_ctx *test_ctx,
 556                                          const char *dn,
 557                                          int modify_flags,
 558                                          struct keyval *kvs)
 559 {
 560         struct ldb_message *msg;
 561         int ret;
 562         int i;
 563
 564         msg = ldb_msg_new(mem_ctx);
 565         assert_non_null(msg);
 566
 567         msg->dn = ldb_dn_new_fmt(msg, test_ctx->ldb, "%s", dn);
 568         assert_non_null(msg->dn);
 569
 570         for (i = 0; kvs[i].key != NULL; i++) {
 571                 if (modify_flags) {
 572                         ret = ldb_msg_add_empty(msg, kvs[i].key,
 573                                                 modify_flags, NULL);
 574                         assert_int_equal(ret, 0);
 575                 }
 576
 577                 if (kvs[i].val) {
 578                         ret = ldb_msg_add_string(msg, kvs[i].key, kvs[i].val);
 579                         assert_int_equal(ret, LDB_SUCCESS);
 580                 }
 581         }
 582
 583         return msg;
 584 }
 585
 586 static void ldb_test_add_data(TALLOC_CTX *mem_ctx,
 587                               struct ldbtest_ctx *ldb_test_ctx,
 588                               const char *basedn,
 589                               struct keyval *kvs)
 590 {
 591         TALLOC_CTX *tmp_ctx;
 592         struct ldb_message *msg;
 593         struct ldb_result *result = NULL;
 594         int ret;
 595
 596         tmp_ctx = talloc_new(mem_ctx);
 597         assert_non_null(tmp_ctx);
 598
 599         msg = build_mod_msg(tmp_ctx, ldb_test_ctx,
 600                             basedn, 0, kvs);
 601         assert_non_null(msg);
 602
 603         ret = ldb_add(ldb_test_ctx->ldb, msg);
 604         assert_int_equal(ret, LDB_SUCCESS);
 605
 606         ret = ldb_search(ldb_test_ctx->ldb, tmp_ctx, &result, msg->dn,
 607                          LDB_SCOPE_BASE, NULL, NULL);
 608         assert_int_equal(ret, LDB_SUCCESS);
 609         assert_non_null(result);
 610         assert_int_equal(result->count, 1);
 611         assert_string_equal(ldb_dn_get_linearized(result->msgs[0]->dn),
 612                             ldb_dn_get_linearized(msg->dn));
 613
 614         talloc_free(tmp_ctx);
 615 }
 616
 617 static void ldb_test_remove_data(TALLOC_CTX *mem_ctx,
 618                                  struct ldbtest_ctx *ldb_test_ctx,
 619                                  const char *strdn)
 620 {
 621         TALLOC_CTX *tmp_ctx;
 622         struct ldb_dn *basedn;
 623         int ret;
 624         size_t count;
 625
 626         tmp_ctx = talloc_new(mem_ctx);
 627         assert_non_null(tmp_ctx);
 628
 629         basedn = ldb_dn_new_fmt(tmp_ctx, ldb_test_ctx->ldb,
 630                                 "%s", strdn);
 631         assert_non_null(basedn);
 632
 633         ret = ldb_delete(ldb_test_ctx->ldb, basedn);
 634         assert_true(ret == LDB_SUCCESS || ret == LDB_ERR_NO_SUCH_OBJECT);
 635
 636         count = base_search_count(ldb_test_ctx, ldb_dn_get_linearized(basedn));
 637         assert_int_equal(count, 0);
 638
 639         talloc_free(tmp_ctx);
 640 }
 641
 642 static void mod_test_add_data(struct ldb_mod_test_ctx *mod_test_ctx,
 643                               struct keyval *kvs)
 644 {
 645         ldb_test_add_data(mod_test_ctx,
 646                           mod_test_ctx->ldb_test_ctx,
 647                           mod_test_ctx->entry_dn,
 648                           kvs);
 649 }
 650
 651 static void mod_test_remove_data(struct ldb_mod_test_ctx *mod_test_ctx)
 652 {
 653         ldb_test_remove_data(mod_test_ctx,
 654                              mod_test_ctx->ldb_test_ctx,
 655                              mod_test_ctx->entry_dn);
 656 }
 657
 658 static struct ldb_result *run_mod_test(struct ldb_mod_test_ctx *mod_test_ctx,
 659                                        int modify_flags,
 660                                        struct keyval *kvs)
 661 {
 662         TALLOC_CTX *tmp_ctx;
 663         struct ldb_result *res;
 664         struct ldb_message *mod_msg;
 665         struct ldb_dn *basedn;
 666         struct ldbtest_ctx *ldb_test_ctx;
 667         int ret;
 668
 669         ldb_test_ctx = mod_test_ctx->ldb_test_ctx;
 670
 671         tmp_ctx = talloc_new(mod_test_ctx);
 672         assert_non_null(tmp_ctx);
 673
 674         mod_msg = build_mod_msg(tmp_ctx, ldb_test_ctx, mod_test_ctx->entry_dn,
 675                                 modify_flags, kvs);
 676         assert_non_null(mod_msg);
 677
 678         ret = ldb_modify(ldb_test_ctx->ldb, mod_msg);
 679         assert_int_equal(ret, LDB_SUCCESS);
 680
 681         basedn = ldb_dn_new_fmt(tmp_ctx, ldb_test_ctx->ldb,
 682                         "%s", mod_test_ctx->entry_dn);
 683         assert_non_null(basedn);
 684
 685         ret = ldb_search(ldb_test_ctx->ldb, mod_test_ctx, &res, basedn,
 686                          LDB_SCOPE_BASE, NULL, NULL);
 687         assert_int_equal(ret, LDB_SUCCESS);
 688         assert_non_null(res);
 689         assert_int_equal(res->count, 1);
 690         assert_string_equal(ldb_dn_get_linearized(res->msgs[0]->dn),
 691                             ldb_dn_get_linearized(mod_msg->dn));
 692
 693         talloc_free(tmp_ctx);
 694         return res;
 695 }
 696
 697 static int ldb_modify_test_setup(void **state)
 698 {
 699         struct ldbtest_ctx *ldb_test_ctx;
 700         struct ldb_mod_test_ctx *mod_test_ctx;
 701         struct keyval kvs[] = {
 702                 { "cn", "test_mod_cn" },
 703                 { NULL, NULL },
 704         };
 705
 706         ldbtest_setup((void **) &ldb_test_ctx);
 707
 708         mod_test_ctx = talloc(ldb_test_ctx, struct ldb_mod_test_ctx);
 709         assert_non_null(mod_test_ctx);
 710
 711         mod_test_ctx->entry_dn = "dc=mod_test_entry";
 712         mod_test_ctx->ldb_test_ctx = ldb_test_ctx;
 713
 714         mod_test_remove_data(mod_test_ctx);
 715         mod_test_add_data(mod_test_ctx, kvs);
 716         *state = mod_test_ctx;
 717         return 0;
 718 }
 719
 720 static int ldb_modify_test_teardown(void **state)
 721 {
 722         struct ldb_mod_test_ctx *mod_test_ctx = \
 723                                 talloc_get_type_abort(*state,
 724                                                       struct ldb_mod_test_ctx);
 725         struct ldbtest_ctx *ldb_test_ctx;
 726
 727         ldb_test_ctx = mod_test_ctx->ldb_test_ctx;
 728
 729         mod_test_remove_data(mod_test_ctx);
 730         talloc_free(mod_test_ctx);
 731
 732         ldbtest_teardown((void **) &ldb_test_ctx);
 733         return 0;
 734 }
 735
 736 static void test_ldb_modify_add_key(void **state)
 737 {
 738         struct ldb_mod_test_ctx *mod_test_ctx = \
 739                                 talloc_get_type_abort(*state,
 740                                                       struct ldb_mod_test_ctx);
 741         struct keyval mod_kvs[] = {
 742                 { "name", "test_mod_name" },
 743                 { NULL, NULL },
 744         };
 745         struct ldb_result *res;
 746         struct ldb_message_element *el;
 747
 748         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_ADD, mod_kvs);
 749         assert_non_null(res);
 750
 751         /* Check cn is intact and name was added */
 752         assert_int_equal(res->count, 1);
 753         el = ldb_msg_find_element(res->msgs[0], "cn");
 754         assert_non_null(el);
 755         assert_int_equal(el->num_values, 1);
 756         assert_string_equal(el->values[0].data, "test_mod_cn");
 757
 758         el = ldb_msg_find_element(res->msgs[0], "name");
 759         assert_non_null(el);
 760         assert_int_equal(el->num_values, 1);
 761         assert_string_equal(el->values[0].data, "test_mod_name");
 762 }
 763
 764 static void test_ldb_modify_extend_key(void **state)
 765 {
 766         struct ldb_mod_test_ctx *mod_test_ctx = \
 767                         talloc_get_type_abort(*state,
 768                                               struct ldb_mod_test_ctx);
 769         struct keyval mod_kvs[] = {
 770                 { "cn", "test_mod_cn2" },
 771                 { NULL, NULL },
 772         };
 773         struct ldb_result *res;
 774         struct ldb_message_element *el;
 775
 776         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_ADD, mod_kvs);
 777         assert_non_null(res);
 778
 779         /* Check cn was extended with another value */
 780         assert_int_equal(res->count, 1);
 781         el = ldb_msg_find_element(res->msgs[0], "cn");
 782         assert_non_null(el);
 783         assert_int_equal(el->num_values, 2);
 784         assert_string_equal(el->values[0].data, "test_mod_cn");
 785         assert_string_equal(el->values[1].data, "test_mod_cn2");
 786 }
 787
 788 static void test_ldb_modify_add_key_noval(void **state)
 789 {
 790         struct ldb_mod_test_ctx *mod_test_ctx = \
 791                         talloc_get_type_abort(*state,
 792                                               struct ldb_mod_test_ctx);
 793         struct ldb_message *mod_msg;
 794         struct ldbtest_ctx *ldb_test_ctx;
 795         struct ldb_message_element *el;
 796         int ret;
 797
 798         ldb_test_ctx = mod_test_ctx->ldb_test_ctx;
 799
 800         mod_msg = ldb_msg_new(mod_test_ctx);
 801         assert_non_null(mod_msg);
 802
 803         mod_msg->dn = ldb_dn_new_fmt(mod_msg, ldb_test_ctx->ldb,
 804                         "%s", mod_test_ctx->entry_dn);
 805         assert_non_null(mod_msg->dn);
 806
 807         el = talloc_zero(mod_msg, struct ldb_message_element);
 808         el->flags = LDB_FLAG_MOD_ADD;
 809         assert_non_null(el);
 810         el->name = talloc_strdup(el, "cn");
 811         assert_non_null(el->name);
 812
 813         mod_msg->elements = el;
 814         mod_msg->num_elements = 1;
 815
 816         ret = ldb_modify(ldb_test_ctx->ldb, mod_msg);
 817         assert_int_equal(ret, LDB_ERR_CONSTRAINT_VIOLATION);
 818 }
 819
 820 static void test_ldb_modify_replace_key(void **state)
 821 {
 822         struct ldb_mod_test_ctx *mod_test_ctx = \
 823                         talloc_get_type_abort(*state,
 824                                               struct ldb_mod_test_ctx);
 825         const char *new_cn = "new_cn";
 826         struct keyval mod_kvs[] = {
 827                 { "cn", new_cn },
 828                 { NULL, NULL },
 829         };
 830         struct ldb_result *res;
 831         struct ldb_message_element *el;
 832
 833         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, mod_kvs);
 834         assert_non_null(res);
 835
 836         /* Check cn was replaced */
 837         assert_int_equal(res->count, 1);
 838         el = ldb_msg_find_element(res->msgs[0], "cn");
 839         assert_non_null(el);
 840         assert_int_equal(el->num_values, 1);
 841         assert_string_equal(el->values[0].data, new_cn);
 842 }
 843
 844 static void test_ldb_modify_replace_noexist_key(void **state)
 845 {
 846         struct ldb_mod_test_ctx *mod_test_ctx = \
 847                         talloc_get_type_abort(*state,
 848                                               struct ldb_mod_test_ctx);
 849         struct keyval mod_kvs[] = {
 850                 { "name", "name_val" },
 851                 { NULL, NULL },
 852         };
 853         struct ldb_result *res;
 854         struct ldb_message_element *el;
 855
 856         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, mod_kvs);
 857         assert_non_null(res);
 858
 859         /* Check cn is intact and name was added */
 860         assert_int_equal(res->count, 1);
 861         el = ldb_msg_find_element(res->msgs[0], "cn");
 862         assert_non_null(el);
 863         assert_int_equal(el->num_values, 1);
 864         assert_string_equal(el->values[0].data, "test_mod_cn");
 865
 866         el = ldb_msg_find_element(res->msgs[0], mod_kvs[0].key);
 867         assert_non_null(el);
 868         assert_int_equal(el->num_values, 1);
 869         assert_string_equal(el->values[0].data, mod_kvs[0].val);
 870 }
 871
 872 static void test_ldb_modify_replace_zero_vals(void **state)
 873 {
 874         struct ldb_mod_test_ctx *mod_test_ctx = \
 875                         talloc_get_type_abort(*state,
 876                                               struct ldb_mod_test_ctx);
 877         struct ldb_message_element *el;
 878         struct ldb_result *res;
 879         struct keyval kvs[] = {
 880                 { "cn", NULL },
 881                 { NULL, NULL },
 882         };
 883
 884         /* cn must be gone */
 885         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, kvs);
 886         assert_non_null(res);
 887         el = ldb_msg_find_element(res->msgs[0], "cn");
 888         assert_null(el);
 889 }
 890
 891 static void test_ldb_modify_replace_noexist_key_zero_vals(void **state)
 892 {
 893         struct ldb_mod_test_ctx *mod_test_ctx = \
 894                         talloc_get_type_abort(*state,
 895                                               struct ldb_mod_test_ctx);
 896         struct ldb_message_element *el;
 897         struct ldb_result *res;
 898         struct keyval kvs[] = {
 899                 { "noexist_key", NULL },
 900                 { NULL, NULL },
 901         };
 902
 903         /* cn must be gone */
 904         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, kvs);
 905         assert_non_null(res);
 906
 907         /* cn should be intact */
 908         el = ldb_msg_find_element(res->msgs[0], "cn");
 909         assert_non_null(el);
 910 }
 911
 912 static void test_ldb_modify_del_key(void **state)
 913 {
 914         struct ldb_mod_test_ctx *mod_test_ctx = \
 915                         talloc_get_type_abort(*state,
 916                                               struct ldb_mod_test_ctx);
 917         struct ldb_message_element *el;
 918         struct ldb_result *res;
 919         struct keyval kvs[] = {
 920                 { "cn", NULL },
 921                 { NULL, NULL },
 922         };
 923
 924         /* cn must be gone */
 925         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_DELETE, kvs);
 926         assert_non_null(res);
 927
 928         el = ldb_msg_find_element(res->msgs[0], "cn");
 929         assert_null(el);
 930 }
 931
 932 static void test_ldb_modify_del_keyval(void **state)
 933 {
 934         struct ldb_mod_test_ctx *mod_test_ctx = \
 935                         talloc_get_type_abort(*state,
 936                                               struct ldb_mod_test_ctx);
 937         struct ldb_message_element *el;
 938         struct ldb_result *res;
 939         struct keyval kvs[] = {
 940                 { "cn", "test_mod_cn" },
 941                 { NULL, NULL },
 942         };
 943
 944         /* cn must be gone */
 945         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_DELETE, kvs);
 946         assert_non_null(res);
 947
 948         el = ldb_msg_find_element(res->msgs[0], "cn");
 949         assert_null(el);
 950 }
 951
 952 struct search_test_ctx {
 953         struct ldbtest_ctx *ldb_test_ctx;
 954         const char *base_dn;
 955 };
 956
 957 static char *get_full_dn(TALLOC_CTX *mem_ctx,
 958                          struct search_test_ctx *search_test_ctx,
 959                          const char *rdn)
 960 {
 961         char *full_dn;
 962
 963         full_dn = talloc_asprintf(mem_ctx,
 964                                   "%s,%s", rdn, search_test_ctx->base_dn);
 965         assert_non_null(full_dn);
 966
 967         return full_dn;
 968 }
 969
 970 static void search_test_add_data(struct search_test_ctx *search_test_ctx,
 971                                  const char *rdn,
 972                                  struct keyval *kvs)
 973 {
 974         char *full_dn;
 975
 976         full_dn = get_full_dn(search_test_ctx, search_test_ctx, rdn);
 977
 978         ldb_test_add_data(search_test_ctx,
 979                           search_test_ctx->ldb_test_ctx,
 980                           full_dn,
 981                           kvs);
 982 }
 983
 984 static void search_test_remove_data(struct search_test_ctx *search_test_ctx,
 985                                     const char *rdn)
 986 {
 987         char *full_dn;
 988
 989         full_dn = talloc_asprintf(search_test_ctx,
 990                                   "%s,%s", rdn, search_test_ctx->base_dn);
 991         assert_non_null(full_dn);
 992
 993         ldb_test_remove_data(search_test_ctx,
 994                              search_test_ctx->ldb_test_ctx,
 995                              full_dn);
 996 }
 997
 998 static int ldb_search_test_setup(void **state)
 999 {
1000         struct ldbtest_ctx *ldb_test_ctx;
1001         struct search_test_ctx *search_test_ctx;
1002         struct keyval kvs[] = {
1003                 { "cn", "test_search_cn" },
1004                 { "cn", "test_search_cn2" },
1005                 { "uid", "test_search_uid" },
1006                 { "uid", "test_search_uid2" },
1007                 { NULL, NULL },
1008         };
1009         struct keyval kvs2[] = {
1010                 { "cn", "test_search_2_cn" },
1011                 { "cn", "test_search_2_cn2" },
1012                 { "uid", "test_search_2_uid" },
1013                 { "uid", "test_search_2_uid2" },
1014                 { NULL, NULL },
1015         };
1016
1017         ldbtest_setup((void **) &ldb_test_ctx);
1018
1019         search_test_ctx = talloc(ldb_test_ctx, struct search_test_ctx);
1020         assert_non_null(search_test_ctx);
1021
1022         search_test_ctx->base_dn = "dc=search_test_entry";
1023         search_test_ctx->ldb_test_ctx = ldb_test_ctx;
1024
1025         search_test_remove_data(search_test_ctx, "cn=test_search_cn");
1026         search_test_add_data(search_test_ctx, "cn=test_search_cn", kvs);
1027
1028         search_test_remove_data(search_test_ctx, "cn=test_search_2_cn");
1029         search_test_add_data(search_test_ctx, "cn=test_search_2_cn", kvs2);
1030
1031         *state = search_test_ctx;
1032         return 0;
1033 }
1034
1035 static int ldb_search_test_teardown(void **state)
1036 {
1037         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1038                         struct search_test_ctx);
1039         struct ldbtest_ctx *ldb_test_ctx;
1040
1041         ldb_test_ctx = search_test_ctx->ldb_test_ctx;
1042
1043         search_test_remove_data(search_test_ctx, "cn=test_search_cn");
1044         search_test_remove_data(search_test_ctx, "cn=test_search_2_cn");
1045         ldbtest_teardown((void **) &ldb_test_ctx);
1046         return 0;
1047 }
1048
1049 static void assert_attr_has_vals(struct ldb_message *msg,
1050                                  const char *attr,
1051                                  const char *vals[],
1052                                  const size_t nvals)
1053 {
1054         struct ldb_message_element *el;
1055         size_t i;
1056
1057         el = ldb_msg_find_element(msg, attr);
1058         assert_non_null(el);
1059
1060         assert_int_equal(el->num_values, nvals);
1061         for (i = 0; i < nvals; i++) {
1062                 assert_string_equal(el->values[i].data,
1063                                     vals[i]);
1064         }
1065 }
1066
1067 static void assert_has_no_attr(struct ldb_message *msg,
1068                                const char *attr)
1069 {
1070         struct ldb_message_element *el;
1071
1072         el = ldb_msg_find_element(msg, attr);
1073         assert_null(el);
1074 }
1075
1076 static bool has_dn(struct ldb_message *msg, const char *dn)
1077 {
1078         const char *msgdn;
1079
1080         msgdn = ldb_dn_get_linearized(msg->dn);
1081         if (strcmp(dn, msgdn) == 0) {
1082                 return true;
1083         }
1084
1085         return false;
1086 }
1087
1088 static void test_search_match_none(void **state)
1089 {
1090         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1091                         struct search_test_ctx);
1092         size_t count;
1093
1094         count = base_search_count(search_test_ctx->ldb_test_ctx,
1095                                   "dc=no_such_entry");
1096         assert_int_equal(count, 0);
1097 }
1098
1099 static void test_search_match_one(void **state)
1100 {
1101         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1102                         struct search_test_ctx);
1103         int ret;
1104         struct ldb_dn *basedn;
1105         struct ldb_result *result = NULL;
1106         const char *cn_vals[] = { "test_search_cn",
1107                                   "test_search_cn2" };
1108         const char *uid_vals[] = { "test_search_uid",
1109                                    "test_search_uid2" };
1110
1111         basedn = ldb_dn_new_fmt(search_test_ctx,
1112                                 search_test_ctx->ldb_test_ctx->ldb,
1113                                 "%s",
1114                                 search_test_ctx->base_dn);
1115         assert_non_null(basedn);
1116
1117         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1118                          search_test_ctx,
1119                          &result,
1120                          basedn,
1121                          LDB_SCOPE_SUBTREE, NULL,
1122                          "cn=test_search_cn");
1123         assert_int_equal(ret, 0);
1124         assert_non_null(result);
1125         assert_int_equal(result->count, 1);
1126
1127         assert_attr_has_vals(result->msgs[0], "cn", cn_vals, 2);
1128         assert_attr_has_vals(result->msgs[0], "uid", uid_vals, 2);
1129 }
1130
1131 static void test_search_match_filter(void **state)
1132 {
1133         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1134                         struct search_test_ctx);
1135         int ret;
1136         struct ldb_dn *basedn;
1137         struct ldb_result *result = NULL;
1138         const char *cn_vals[] = { "test_search_cn",
1139                                   "test_search_cn2" };
1140         const char *attrs[] = { "cn", NULL };
1141
1142         basedn = ldb_dn_new_fmt(search_test_ctx,
1143                                 search_test_ctx->ldb_test_ctx->ldb,
1144                                 "%s",
1145                                 search_test_ctx->base_dn);
1146         assert_non_null(basedn);
1147
1148         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1149                          search_test_ctx,
1150                          &result,
1151                          basedn,
1152                          LDB_SCOPE_SUBTREE,
1153                          attrs,
1154                          "cn=test_search_cn");
1155         assert_int_equal(ret, 0);
1156         assert_non_null(result);
1157         assert_int_equal(result->count, 1);
1158
1159         assert_attr_has_vals(result->msgs[0], "cn", cn_vals, 2);
1160         assert_has_no_attr(result->msgs[0], "uid");
1161 }
1162
1163 static void assert_expected(struct search_test_ctx *search_test_ctx,
1164                             struct ldb_message *msg)
1165 {
1166         char *full_dn1;
1167         char *full_dn2;
1168         const char *cn_vals[] = { "test_search_cn",
1169                                   "test_search_cn2" };
1170         const char *uid_vals[] = { "test_search_uid",
1171                                    "test_search_uid2" };
1172         const char *cn2_vals[] = { "test_search_2_cn",
1173                                    "test_search_2_cn2" };
1174         const char *uid2_vals[] = { "test_search_2_uid",
1175                                     "test_search_2_uid2" };
1176
1177         full_dn1 = get_full_dn(search_test_ctx,
1178                                search_test_ctx,
1179                                "cn=test_search_cn");
1180
1181         full_dn2 = get_full_dn(search_test_ctx,
1182                                search_test_ctx,
1183                                "cn=test_search_2_cn");
1184
1185         if (has_dn(msg, full_dn1) == true) {
1186                 assert_attr_has_vals(msg, "cn", cn_vals, 2);
1187                 assert_attr_has_vals(msg, "uid", uid_vals, 2);
1188         } else if (has_dn(msg, full_dn2) == true) {
1189                 assert_attr_has_vals(msg, "cn", cn2_vals, 2);
1190                 assert_attr_has_vals(msg, "uid", uid2_vals, 2);
1191         } else {
1192                 fail();
1193         }
1194 }
1195
1196 static void test_search_match_both(void **state)
1197 {
1198         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1199                         struct search_test_ctx);
1200         int ret;
1201         struct ldb_dn *basedn;
1202         struct ldb_result *result = NULL;
1203
1204         basedn = ldb_dn_new_fmt(search_test_ctx,
1205                                 search_test_ctx->ldb_test_ctx->ldb,
1206                                 "%s",
1207                                 search_test_ctx->base_dn);
1208         assert_non_null(basedn);
1209
1210         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1211                          search_test_ctx,
1212                          &result,
1213                          basedn,
1214                          LDB_SCOPE_SUBTREE, NULL,
1215                          "cn=test_search_*");
1216         assert_int_equal(ret, 0);
1217         assert_non_null(result);
1218         assert_int_equal(result->count, 2);
1219
1220         assert_expected(search_test_ctx, result->msgs[0]);
1221         assert_expected(search_test_ctx, result->msgs[1]);
1222 }
1223
1224 static void test_search_match_basedn(void **state)
1225 {
1226         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1227                         struct search_test_ctx);
1228         int ret;
1229         struct ldb_dn *basedn;
1230         struct ldb_result *result = NULL;
1231         struct ldb_message *msg;
1232
1233         basedn = ldb_dn_new_fmt(search_test_ctx,
1234                                 search_test_ctx->ldb_test_ctx->ldb,
1235                                 "dc=nosuchdn");
1236         assert_non_null(basedn);
1237
1238         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1239                          search_test_ctx,
1240                          &result,
1241                          basedn,
1242                          LDB_SCOPE_SUBTREE, NULL,
1243                          "cn=*");
1244         assert_int_equal(ret, 0);
1245
1246         /* Add 'checkBaseOnSearch' to @OPTIONS */
1247         msg = ldb_msg_new(search_test_ctx);
1248         assert_non_null(msg);
1249
1250         msg->dn = ldb_dn_new_fmt(msg,
1251                                  search_test_ctx->ldb_test_ctx->ldb,
1252                                  "@OPTIONS");
1253         assert_non_null(msg->dn);
1254
1255         ret = ldb_msg_add_string(msg, "checkBaseOnSearch", "TRUE");
1256         assert_int_equal(ret, 0);
1257
1258         ret = ldb_add(search_test_ctx->ldb_test_ctx->ldb, msg);
1259         assert_int_equal(ret, 0);
1260
1261         /* Search again */
1262         /* The search should return LDB_ERR_NO_SUCH_OBJECT */
1263         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1264                          search_test_ctx,
1265                          &result,
1266                          basedn,
1267                          LDB_SCOPE_SUBTREE, NULL,
1268                          "cn=*");
1269         assert_int_equal(ret, LDB_ERR_NO_SUCH_OBJECT);
1270
1271         ret = ldb_delete(search_test_ctx->ldb_test_ctx->ldb, msg->dn);
1272         assert_int_equal(ret, 0);
1273 }
1274
1275
1276 /*
1277  * This test is complex.
1278  * The purpose is to test for a deadlock detected between ldb_search()
1279  * and ldb_transaction_commit().  The deadlock happens if in process
1280  * (1) and (2):
1281  *  - (1) the all-record lock is taken in ltdb_search()
1282  *  - (2) the ldb_transaction_start() call is made
1283  *  - (1) an un-indexed search starts (forced here by doing it in
1284  *        the callback
1285  *  - (2) the ldb_transaction_commit() is called.
1286  *        This returns LDB_ERR_BUSY if the deadlock is detected
1287  *
1288  * With ldb 1.1.29 and tdb 1.3.12 we avoid this only due to a missing
1289  * lock call in ltdb_search() due to a refcounting bug in
1290  * ltdb_lock_read()
1291  */
1292
1293 struct search_against_transaction_ctx {
1294         struct ldbtest_ctx *test_ctx;
1295         int res_count;
1296         pid_t child_pid;
1297         struct ldb_dn *basedn;
1298 };
1299
1300 static int test_ldb_search_against_transaction_callback2(struct ldb_request *req,
1301                                                          struct ldb_reply *ares)
1302 {
1303         struct search_against_transaction_ctx *ctx = req->context;
1304         switch (ares->type) {
1305         case LDB_REPLY_ENTRY:
1306                 ctx->res_count++;
1307                 if (ctx->res_count != 1) {
1308                         return LDB_SUCCESS;
1309                 }
1310
1311                 break;
1312
1313         case LDB_REPLY_REFERRAL:
1314                 break;
1315
1316         case LDB_REPLY_DONE:
1317                 return ldb_request_done(req, LDB_SUCCESS);
1318         }
1319
1320         return 0;
1321
1322 }
1323
1324 /*
1325  * This purpose of this callback is to trigger a transaction in
1326  * the child process while the all-record lock is held, but before
1327  * we take any locks in the tdb_traverse_read() handler.
1328  *
1329  * In tdb 1.3.12 tdb_traverse_read() take the read transaction lock
1330  * however in ldb 1.1.29 ltdb_search() forgets to take the all-record
1331  * lock (except the very first time) due to a ref-counting bug.
1332  *
1333  */
1334
1335 static int test_ldb_search_against_transaction_callback1(struct ldb_request *req,
1336                                                          struct ldb_reply *ares)
1337 {
1338         int ret, ret2;
1339         int pipes[2];
1340         char buf[2];
1341         struct search_against_transaction_ctx *ctx = req->context;
1342         switch (ares->type) {
1343         case LDB_REPLY_ENTRY:
1344                 break;
1345
1346         case LDB_REPLY_REFERRAL:
1347                 return LDB_SUCCESS;
1348
1349         case LDB_REPLY_DONE:
1350                 return ldb_request_done(req, LDB_SUCCESS);
1351         }
1352
1353         ret = pipe(pipes);
1354         assert_int_equal(ret, 0);
1355
1356         ctx->child_pid = fork();
1357         if (ctx->child_pid == 0) {
1358                 TALLOC_CTX *tmp_ctx = NULL;
1359                 struct ldb_message *msg;
1360                 TALLOC_FREE(ctx->test_ctx->ldb);
1361                 TALLOC_FREE(ctx->test_ctx->ev);
1362                 ctx->test_ctx->ev = tevent_context_init(ctx->test_ctx);
1363                 if (ctx->test_ctx->ev == NULL) {
1364                         exit(LDB_ERR_OPERATIONS_ERROR);
1365                 }
1366
1367                 ctx->test_ctx->ldb = ldb_init(ctx->test_ctx,
1368                                               ctx->test_ctx->ev);
1369                 if (ctx->test_ctx->ldb == NULL) {
1370                         exit(LDB_ERR_OPERATIONS_ERROR);
1371                 }
1372
1373                 ret = ldb_connect(ctx->test_ctx->ldb,
1374                                   ctx->test_ctx->dbpath, 0, NULL);
1375                 if (ret != LDB_SUCCESS) {
1376                         exit(ret);
1377                 }
1378
1379                 tmp_ctx = talloc_new(ctx->test_ctx);
1380                 if (tmp_ctx == NULL) {
1381                         exit(LDB_ERR_OPERATIONS_ERROR);
1382                 }
1383
1384                 msg = ldb_msg_new(tmp_ctx);
1385                 if (msg == NULL) {
1386                         exit(LDB_ERR_OPERATIONS_ERROR);
1387                 }
1388
1389                 msg->dn = ldb_dn_new_fmt(msg, ctx->test_ctx->ldb,
1390                                          "dc=test");
1391                 if (msg->dn == NULL) {
1392                         exit(LDB_ERR_OPERATIONS_ERROR);
1393                 }
1394
1395                 ret = ldb_msg_add_string(msg, "cn", "test_cn_val");
1396                 if (ret != 0) {
1397                         exit(LDB_ERR_OPERATIONS_ERROR);
1398                 }
1399
1400                 ret = ldb_transaction_start(ctx->test_ctx->ldb);
1401                 if (ret != 0) {
1402                         exit(ret);
1403                 }
1404
1405                 ret = write(pipes[1], "GO", 2);
1406                 if (ret != 2) {
1407                         exit(LDB_ERR_OPERATIONS_ERROR);
1408                 }
1409
1410                 ret = ldb_add(ctx->test_ctx->ldb, msg);
1411                 if (ret != 0) {
1412                         exit(ret);
1413                 }
1414
1415                 ret = ldb_transaction_commit(ctx->test_ctx->ldb);
1416                 exit(ret);
1417         }
1418
1419         ret = read(pipes[0], buf, 2);
1420         assert_int_equal(ret, 2);
1421
1422         /* This search must be unindexed (ie traverse in tdb) */
1423         ret = ldb_build_search_req(&req,
1424                                    ctx->test_ctx->ldb,
1425                                    ctx->test_ctx,
1426                                    ctx->basedn,
1427                                    LDB_SCOPE_SUBTREE,
1428                                    "cn=*", NULL,
1429                                    NULL,
1430                                    ctx,
1431                                    test_ldb_search_against_transaction_callback2,
1432                                    NULL);
1433         /*
1434          * we don't assert on these return codes until after the search is
1435          * finished, or the clean up will fail because we hold locks.
1436          */
1437
1438         ret2 = ldb_request(ctx->test_ctx->ldb, req);
1439
1440         if (ret2 == LDB_SUCCESS) {
1441                 ret2 = ldb_wait(req->handle, LDB_WAIT_ALL);
1442         }
1443         assert_int_equal(ret, 0);
1444         assert_int_equal(ret2, 0);
1445         assert_int_equal(ctx->res_count, 2);
1446
1447         return LDB_SUCCESS;
1448 }
1449
1450 static void test_ldb_search_against_transaction(void **state)
1451 {
1452         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1453                         struct search_test_ctx);
1454         struct search_against_transaction_ctx
1455                 ctx =
1456                 { .res_count = 0,
1457                   .test_ctx = search_test_ctx->ldb_test_ctx
1458                 };
1459
1460         int ret;
1461         struct ldb_request *req;
1462         pid_t pid;
1463         int wstatus;
1464         struct ldb_dn *base_search_dn;
1465
1466         tevent_loop_allow_nesting(search_test_ctx->ldb_test_ctx->ev);
1467
1468         base_search_dn
1469                 = ldb_dn_new_fmt(search_test_ctx,
1470                                  search_test_ctx->ldb_test_ctx->ldb,
1471                                  "cn=test_search_cn,%s",
1472                                  search_test_ctx->base_dn);
1473         assert_non_null(base_search_dn);
1474
1475         ctx.basedn
1476                 = ldb_dn_new_fmt(search_test_ctx,
1477                                  search_test_ctx->ldb_test_ctx->ldb,
1478                                  "%s",
1479                                  search_test_ctx->base_dn);
1480         assert_non_null(ctx.basedn);
1481
1482
1483         /* This search must be indexed (ie no traverse in tdb) */
1484         ret = ldb_build_search_req(&req,
1485                                    search_test_ctx->ldb_test_ctx->ldb,
1486                                    search_test_ctx,
1487                                    base_search_dn,
1488                                    LDB_SCOPE_BASE,
1489                                    "cn=*", NULL,
1490                                    NULL,
1491                                    &ctx,
1492                                    test_ldb_search_against_transaction_callback1,
1493                                    NULL);
1494         assert_int_equal(ret, 0);
1495         ret = ldb_request(search_test_ctx->ldb_test_ctx->ldb, req);
1496
1497         if (ret == LDB_SUCCESS) {
1498                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
1499         }
1500         assert_int_equal(ret, 0);
1501         assert_int_equal(ctx.res_count, 2);
1502
1503         pid = waitpid(ctx.child_pid, &wstatus, 0);
1504         assert_int_equal(pid, ctx.child_pid);
1505
1506         assert_true(WIFEXITED(wstatus));
1507
1508         assert_int_equal(WEXITSTATUS(wstatus), 0);
1509
1510
1511 }
1512
1513 static int ldb_case_test_setup(void **state)
1514 {
1515         int ret;
1516         struct ldb_ldif *ldif;
1517         struct ldbtest_ctx *ldb_test_ctx;
1518         const char *attrs_ldif =  \
1519                 "dn: @ATTRIBUTES\n"
1520                 "cn: CASE_INSENSITIVE\n"
1521                 "\n";
1522         struct keyval kvs[] = {
1523                 { "cn", "CaseInsensitiveValue" },
1524                 { "uid", "CaseSensitiveValue" },
1525                 { NULL, NULL },
1526         };
1527
1528
1529         ldbtest_setup((void **) &ldb_test_ctx);
1530
1531         while ((ldif = ldb_ldif_read_string(ldb_test_ctx->ldb, &attrs_ldif))) {
1532                 ret = ldb_add(ldb_test_ctx->ldb, ldif->msg);
1533                 assert_int_equal(ret, LDB_SUCCESS);
1534         }
1535
1536         ldb_test_add_data(ldb_test_ctx,
1537                           ldb_test_ctx,
1538                           "cn=CaseInsensitiveValue",
1539                           kvs);
1540
1541         *state = ldb_test_ctx;
1542         return 0;
1543 }
1544
1545 static int ldb_case_test_teardown(void **state)
1546 {
1547         int ret;
1548         struct ldbtest_ctx *ldb_test_ctx = talloc_get_type_abort(*state,
1549                         struct ldbtest_ctx);
1550
1551         struct ldb_dn *del_dn;
1552
1553         del_dn = ldb_dn_new_fmt(ldb_test_ctx,
1554                                 ldb_test_ctx->ldb,
1555                                 "@ATTRIBUTES");
1556         assert_non_null(del_dn);
1557
1558         ret = ldb_delete(ldb_test_ctx->ldb, del_dn);
1559         assert_int_equal(ret, LDB_SUCCESS);
1560
1561         assert_dn_doesnt_exist(ldb_test_ctx,
1562                                "@ATTRIBUTES");
1563
1564         ldb_test_remove_data(ldb_test_ctx, ldb_test_ctx,
1565                              "cn=CaseInsensitiveValue");
1566
1567         ldbtest_teardown((void **) &ldb_test_ctx);
1568         return 0;
1569 }
1570
1571 static void test_ldb_attrs_case_insensitive(void **state)
1572 {
1573         int cnt;
1574         struct ldbtest_ctx *ldb_test_ctx = talloc_get_type_abort(*state,
1575                         struct ldbtest_ctx);
1576
1577         /* cn matches exact case */
1578         cnt = sub_search_count(ldb_test_ctx, "", "cn=CaseInsensitiveValue");
1579         assert_int_equal(cnt, 1);
1580
1581         /* cn matches lower case */
1582         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1583         assert_int_equal(cnt, 1);
1584
1585         /* uid matches exact case */
1586         cnt = sub_search_count(ldb_test_ctx, "", "uid=CaseSensitiveValue");
1587         assert_int_equal(cnt, 1);
1588
1589         /* uid does not match lower case */
1590         cnt = sub_search_count(ldb_test_ctx, "", "uid=casesensitivevalue");
1591         assert_int_equal(cnt, 0);
1592 }
1593
1594 static struct ldb_schema_attribute cn_attr_1;
1595 static struct ldb_schema_attribute cn_attr_2;
1596 static struct ldb_schema_attribute default_attr;
1597
1598 /*
1599   override the name to attribute handler function
1600  */
1601 static const struct ldb_schema_attribute *ldb_test_attribute_handler_override(struct ldb_context *ldb,
1602                                                                               void *private_data,
1603                                                                               const char *name)
1604 {
1605         if (private_data != NULL && ldb_attr_cmp(name, "cn") == 0) {
1606                 return &cn_attr_1;
1607         } else if (private_data == NULL && ldb_attr_cmp(name, "cn") == 0) {
1608                 return &cn_attr_2;
1609         } else if (ldb_attr_cmp(name, "uid") == 0) {
1610                 return &cn_attr_2;
1611         }
1612         return &default_attr;
1613 }
1614
1615 static void test_ldb_attrs_case_handler(void **state)
1616 {
1617         int cnt;
1618         int ret;
1619         const struct ldb_schema_syntax *syntax;
1620
1621         struct ldbtest_ctx *ldb_test_ctx = talloc_get_type_abort(*state,
1622                         struct ldbtest_ctx);
1623         struct ldb_context *ldb = ldb_test_ctx->ldb;
1624
1625         /* cn matches lower case */
1626         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1627         assert_int_equal(cnt, 1);
1628
1629         syntax = ldb_standard_syntax_by_name(ldb, LDB_SYNTAX_OCTET_STRING);
1630         assert_non_null(syntax);
1631
1632         ret = ldb_schema_attribute_fill_with_syntax(ldb, ldb,
1633                                                     "*", 0,
1634                                                     syntax, &default_attr);
1635         assert_int_equal(ret, LDB_SUCCESS);
1636
1637         syntax = ldb_standard_syntax_by_name(ldb, LDB_SYNTAX_OCTET_STRING);
1638         assert_non_null(syntax);
1639
1640         ret = ldb_schema_attribute_fill_with_syntax(ldb, ldb,
1641                                                     "cn", 0,
1642                                                     syntax, &cn_attr_1);
1643         assert_int_equal(ret, LDB_SUCCESS);
1644
1645         /*
1646          * Set an attribute handler, which will fail to match as we
1647          * force case sensitive
1648          */
1649         ldb_schema_attribute_set_override_handler(ldb,
1650                                                   ldb_test_attribute_handler_override,
1651                                                   (void *)1);
1652
1653         /* cn does not matche lower case */
1654         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1655         assert_int_equal(cnt, 0);
1656
1657         syntax = ldb_standard_syntax_by_name(ldb, LDB_SYNTAX_DIRECTORY_STRING);
1658         assert_non_null(syntax);
1659
1660         ret = ldb_schema_attribute_fill_with_syntax(ldb, ldb,
1661                                                     "cn", 0,
1662                                                     syntax, &cn_attr_2);
1663         assert_int_equal(ret, LDB_SUCCESS);
1664
1665         /*
1666          * Set an attribute handler, which will match as we
1667          * force case insensitive
1668          */
1669         ldb_schema_attribute_set_override_handler(ldb,
1670                                                   ldb_test_attribute_handler_override,
1671                                                   NULL);
1672
1673         /* cn matches lower case */
1674         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1675         assert_int_equal(cnt, 1);
1676
1677 }
1678
1679
1680 static void test_ldb_attrs_index_handler(void **state)
1681 {
1682         int cnt;
1683         int ret;
1684         const struct ldb_schema_syntax *syntax;
1685         struct ldb_ldif *ldif;
1686
1687         const char *index_ldif =  \
1688                 "dn: @INDEXLIST\n"
1689                 "@IDXATTR: cn\n"
1690                 "\n";
1691
1692         struct ldbtest_ctx *ldb_test_ctx = talloc_get_type_abort(*state,
1693                         struct ldbtest_ctx);
1694         struct ldb_context *ldb = ldb_test_ctx->ldb;
1695
1696         /* cn matches lower case */
1697         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1698         assert_int_equal(cnt, 1);
1699
1700         syntax = ldb_standard_syntax_by_name(ldb, LDB_SYNTAX_OCTET_STRING);
1701         assert_non_null(syntax);
1702
1703         ret = ldb_schema_attribute_fill_with_syntax(ldb, ldb,
1704                                                     "cn", 0,
1705                                                     syntax, &cn_attr_1);
1706         assert_int_equal(ret, LDB_SUCCESS);
1707
1708         syntax = ldb_standard_syntax_by_name(ldb, LDB_SYNTAX_DIRECTORY_STRING);
1709         assert_non_null(syntax);
1710
1711         ret = ldb_schema_attribute_fill_with_syntax(ldb, ldb,
1712                                                     "cn", LDB_ATTR_FLAG_INDEXED,
1713                                                     syntax, &cn_attr_2);
1714         assert_int_equal(ret, LDB_SUCCESS);
1715
1716         /*
1717          * Set an attribute handler
1718          */
1719         ldb_schema_attribute_set_override_handler(ldb,
1720                                                   ldb_test_attribute_handler_override,
1721                                                   NULL);
1722
1723         /* cn matches lower case */
1724         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1725         assert_int_equal(cnt, 1);
1726
1727         /* Add the index (actually any modify will do) */
1728         while ((ldif = ldb_ldif_read_string(ldb_test_ctx->ldb, &index_ldif))) {
1729                 ret = ldb_add(ldb_test_ctx->ldb, ldif->msg);
1730                 assert_int_equal(ret, LDB_SUCCESS);
1731         }
1732
1733         ldb_schema_set_override_indexlist(ldb, false);
1734
1735         /* cn does match as there is an index now */
1736         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1737         assert_int_equal(cnt, 1);
1738
1739         /*
1740          * Set an attribute handler, which will later fail to match as we
1741          * didn't re-index the DB
1742          */
1743         ldb_schema_attribute_set_override_handler(ldb,
1744                                                   ldb_test_attribute_handler_override,
1745                                                   (void *)1);
1746
1747         /*
1748          * cn does not match as we changed the case sensitivity, but
1749          * didn't re-index
1750          *
1751          * This shows that the override is in control
1752          */
1753         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1754         assert_int_equal(cnt, 0);
1755
1756 }
1757
1758 static int ldb_case_attrs_index_test_teardown(void **state)
1759 {
1760         int ret;
1761         struct ldbtest_ctx *ldb_test_ctx = talloc_get_type_abort(*state,
1762                         struct ldbtest_ctx);
1763         struct ldb_dn *del_dn;
1764
1765         del_dn = ldb_dn_new_fmt(ldb_test_ctx,
1766                                 ldb_test_ctx->ldb,
1767                                 "@INDEXLIST");
1768         assert_non_null(del_dn);
1769
1770         ret = ldb_delete(ldb_test_ctx->ldb, del_dn);
1771         if (ret != LDB_ERR_NO_SUCH_OBJECT) {
1772                 assert_int_equal(ret, LDB_SUCCESS);
1773         }
1774
1775         assert_dn_doesnt_exist(ldb_test_ctx,
1776                                "@INDEXLIST");
1777
1778         ldb_case_test_teardown(state);
1779         return 0;
1780 }
1781
1782
1783 struct rename_test_ctx {
1784         struct ldbtest_ctx *ldb_test_ctx;
1785
1786         struct ldb_dn *basedn;
1787         const char *str_basedn;
1788
1789         const char *teardown_dn;
1790 };
1791
1792 static int ldb_rename_test_setup(void **state)
1793 {
1794         struct ldbtest_ctx *ldb_test_ctx;
1795         struct rename_test_ctx *rename_test_ctx;
1796         const char *strdn = "dc=rename_test_entry_from";
1797
1798         ldbtest_setup((void **) &ldb_test_ctx);
1799
1800         rename_test_ctx = talloc(ldb_test_ctx, struct rename_test_ctx);
1801         assert_non_null(rename_test_ctx);
1802         rename_test_ctx->ldb_test_ctx = ldb_test_ctx;
1803         assert_non_null(rename_test_ctx->ldb_test_ctx);
1804
1805         rename_test_ctx->basedn = ldb_dn_new_fmt(rename_test_ctx,
1806                                 rename_test_ctx->ldb_test_ctx->ldb,
1807                                 "%s", strdn);
1808         assert_non_null(rename_test_ctx->basedn);
1809
1810         rename_test_ctx->str_basedn = strdn;
1811         rename_test_ctx->teardown_dn = strdn;
1812
1813         add_dn_with_cn(ldb_test_ctx,
1814                        rename_test_ctx->basedn,
1815                        "test_rename_cn_val");
1816
1817         *state = rename_test_ctx;
1818         return 0;
1819 }
1820
1821 static int ldb_rename_test_teardown(void **state)
1822 {
1823         int ret;
1824         struct rename_test_ctx *rename_test_ctx = talloc_get_type_abort(*state,
1825                         struct rename_test_ctx);
1826         struct ldbtest_ctx *ldb_test_ctx;
1827         struct ldb_dn *del_dn;
1828
1829         ldb_test_ctx = rename_test_ctx->ldb_test_ctx;
1830
1831         del_dn = ldb_dn_new_fmt(rename_test_ctx,
1832                                 rename_test_ctx->ldb_test_ctx->ldb,
1833                                 "%s", rename_test_ctx->teardown_dn);
1834         assert_non_null(del_dn);
1835
1836         ret = ldb_delete(ldb_test_ctx->ldb, del_dn);
1837         assert_int_equal(ret, LDB_SUCCESS);
1838
1839         assert_dn_doesnt_exist(ldb_test_ctx,
1840                                rename_test_ctx->teardown_dn);
1841
1842         ldbtest_teardown((void **) &ldb_test_ctx);
1843         return 0;
1844 }
1845
1846 static void test_ldb_rename(void **state)
1847 {
1848         struct rename_test_ctx *rename_test_ctx =
1849                 talloc_get_type_abort(*state, struct rename_test_ctx);
1850         int ret;
1851         const char *str_new_dn = "dc=rename_test_entry_to";
1852         struct ldb_dn *new_dn;
1853
1854         new_dn = ldb_dn_new_fmt(rename_test_ctx,
1855                                 rename_test_ctx->ldb_test_ctx->ldb,
1856                                 "%s", str_new_dn);
1857         assert_non_null(new_dn);
1858
1859         ret = ldb_rename(rename_test_ctx->ldb_test_ctx->ldb,
1860                          rename_test_ctx->basedn,
1861                          new_dn);
1862         assert_int_equal(ret, LDB_SUCCESS);
1863
1864         assert_dn_exists(rename_test_ctx->ldb_test_ctx, str_new_dn);
1865         assert_dn_doesnt_exist(rename_test_ctx->ldb_test_ctx,
1866                                rename_test_ctx->str_basedn);
1867         rename_test_ctx->teardown_dn = str_new_dn;
1868
1869         /* FIXME - test the values which didn't change */
1870 }
1871
1872 static void test_ldb_rename_from_doesnt_exist(void **state)
1873 {
1874         struct rename_test_ctx *rename_test_ctx = talloc_get_type_abort(
1875                                                         *state,
1876                                                         struct rename_test_ctx);
1877         int ret;
1878         const char *str_new_dn = "dc=rename_test_entry_to";
1879         const char *str_bad_old_dn = "dc=rename_test_no_such_entry";
1880         struct ldb_dn *new_dn;
1881         struct ldb_dn *bad_old_dn;
1882
1883         new_dn = ldb_dn_new_fmt(rename_test_ctx,
1884                                 rename_test_ctx->ldb_test_ctx->ldb,
1885                                 "%s", str_new_dn);
1886         assert_non_null(new_dn);
1887
1888         bad_old_dn = ldb_dn_new_fmt(rename_test_ctx,
1889                                     rename_test_ctx->ldb_test_ctx->ldb,
1890                                     "%s", str_bad_old_dn);
1891         assert_non_null(bad_old_dn);
1892
1893         assert_dn_doesnt_exist(rename_test_ctx->ldb_test_ctx,
1894                                str_bad_old_dn);
1895
1896         ret = ldb_rename(rename_test_ctx->ldb_test_ctx->ldb,
1897                          bad_old_dn, new_dn);
1898         assert_int_equal(ret, LDB_ERR_NO_SUCH_OBJECT);
1899
1900         assert_dn_doesnt_exist(rename_test_ctx->ldb_test_ctx,
1901                                str_new_dn);
1902 }
1903
1904 static void test_ldb_rename_to_exists(void **state)
1905 {
1906         struct rename_test_ctx *rename_test_ctx = talloc_get_type_abort(
1907                                                         *state,
1908                                                         struct rename_test_ctx);
1909         int ret;
1910         const char *str_new_dn = "dc=rename_test_already_exists";
1911         struct ldb_dn *new_dn;
1912
1913         new_dn = ldb_dn_new_fmt(rename_test_ctx,
1914                                 rename_test_ctx->ldb_test_ctx->ldb,
1915                                 "%s", str_new_dn);
1916         assert_non_null(new_dn);
1917
1918         add_dn_with_cn(rename_test_ctx->ldb_test_ctx,
1919                        new_dn,
1920                        "test_rename_cn_val");
1921
1922         ret = ldb_rename(rename_test_ctx->ldb_test_ctx->ldb,
1923                          rename_test_ctx->basedn,
1924                          new_dn);
1925         assert_int_equal(ret, LDB_ERR_ENTRY_ALREADY_EXISTS);
1926
1927         /* Old object must still exist */
1928         assert_dn_exists(rename_test_ctx->ldb_test_ctx,
1929                          rename_test_ctx->str_basedn);
1930
1931         ret = ldb_delete(rename_test_ctx->ldb_test_ctx->ldb,
1932                          new_dn);
1933         assert_int_equal(ret, LDB_SUCCESS);
1934
1935         assert_dn_exists(rename_test_ctx->ldb_test_ctx,
1936                                rename_test_ctx->teardown_dn);
1937 }
1938
1939 static void test_ldb_rename_self(void **state)
1940 {
1941         struct rename_test_ctx *rename_test_ctx = talloc_get_type_abort(
1942                                                         *state,
1943                                                         struct rename_test_ctx);
1944         int ret;
1945
1946         /* Oddly enough, this is a success in ldb.. */
1947         ret = ldb_rename(rename_test_ctx->ldb_test_ctx->ldb,
1948                          rename_test_ctx->basedn,
1949                          rename_test_ctx->basedn);
1950         assert_int_equal(ret, LDB_SUCCESS);
1951
1952         /* Old object must still exist */
1953         assert_dn_exists(rename_test_ctx->ldb_test_ctx,
1954                          rename_test_ctx->str_basedn);
1955 }
1956
1957 static void test_ldb_rename_dn_case_change(void **state)
1958 {
1959         struct rename_test_ctx *rename_test_ctx = talloc_get_type_abort(
1960                                                         *state,
1961                                                         struct rename_test_ctx);
1962         int ret;
1963         char *str_new_dn;
1964         struct ldb_dn *new_dn;
1965         unsigned i;
1966
1967         str_new_dn = talloc_strdup(rename_test_ctx, rename_test_ctx->str_basedn);
1968         assert_non_null(str_new_dn);
1969         for (i = 0; str_new_dn[i]; i++) {
1970                 str_new_dn[i] = toupper(str_new_dn[i]);
1971         }
1972
1973         new_dn = ldb_dn_new_fmt(rename_test_ctx,
1974                                 rename_test_ctx->ldb_test_ctx->ldb,
1975                                 "%s", str_new_dn);
1976         assert_non_null(new_dn);
1977
1978         ret = ldb_rename(rename_test_ctx->ldb_test_ctx->ldb,
1979                          rename_test_ctx->basedn,
1980                          new_dn);
1981         assert_int_equal(ret, LDB_SUCCESS);
1982
1983         /* DNs are case insensitive, so both searches will match */
1984         assert_dn_exists(rename_test_ctx->ldb_test_ctx, str_new_dn);
1985         assert_dn_exists(rename_test_ctx->ldb_test_ctx,
1986                          rename_test_ctx->str_basedn);
1987         /* FIXME - test the values didn't change */
1988 }
1989
1990 int main(int argc, const char **argv)
1991 {
1992         const struct CMUnitTest tests[] = {
1993                 cmocka_unit_test_setup_teardown(test_connect,
1994                                                 ldbtest_noconn_setup,
1995                                                 ldbtest_noconn_teardown),
1996                 cmocka_unit_test_setup_teardown(test_ldb_add,
1997                                                 ldbtest_setup,
1998                                                 ldbtest_teardown),
1999                 cmocka_unit_test_setup_teardown(test_ldb_search,
2000                                                 ldbtest_setup,
2001                                                 ldbtest_teardown),
2002                 cmocka_unit_test_setup_teardown(test_ldb_del,
2003                                                 ldbtest_setup,
2004                                                 ldbtest_teardown),
2005                 cmocka_unit_test_setup_teardown(test_ldb_del_noexist,
2006                                                 ldbtest_setup,
2007                                                 ldbtest_teardown),
2008                 cmocka_unit_test_setup_teardown(test_ldb_handle,
2009                                                 ldbtest_setup,
2010                                                 ldbtest_teardown),
2011                 cmocka_unit_test_setup_teardown(test_ldb_build_search_req,
2012                                                 ldbtest_setup,
2013                                                 ldbtest_teardown),
2014                 cmocka_unit_test_setup_teardown(test_transactions,
2015                                                 ldbtest_setup,
2016                                                 ldbtest_teardown),
2017                 cmocka_unit_test_setup_teardown(test_ldb_modify_add_key,
2018                                                 ldb_modify_test_setup,
2019                                                 ldb_modify_test_teardown),
2020                 cmocka_unit_test_setup_teardown(test_ldb_modify_extend_key,
2021                                                 ldb_modify_test_setup,
2022                                                 ldb_modify_test_teardown),
2023                 cmocka_unit_test_setup_teardown(test_ldb_modify_add_key_noval,
2024                                                 ldb_modify_test_setup,
2025                                                 ldb_modify_test_teardown),
2026                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_key,
2027                                                 ldb_modify_test_setup,
2028                                                 ldb_modify_test_teardown),
2029                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_noexist_key,
2030                                                 ldb_modify_test_setup,
2031                                                 ldb_modify_test_teardown),
2032                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_zero_vals,
2033                                                 ldb_modify_test_setup,
2034                                                 ldb_modify_test_teardown),
2035                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_noexist_key_zero_vals,
2036                                                 ldb_modify_test_setup,
2037                                                 ldb_modify_test_teardown),
2038                 cmocka_unit_test_setup_teardown(test_ldb_modify_del_key,
2039                                                 ldb_modify_test_setup,
2040                                                 ldb_modify_test_teardown),
2041                 cmocka_unit_test_setup_teardown(test_ldb_modify_del_keyval,
2042                                                 ldb_modify_test_setup,
2043                                                 ldb_modify_test_teardown),
2044                 cmocka_unit_test_setup_teardown(test_search_match_none,
2045                                                 ldb_search_test_setup,
2046                                                 ldb_search_test_teardown),
2047                 cmocka_unit_test_setup_teardown(test_search_match_one,
2048                                                 ldb_search_test_setup,
2049                                                 ldb_search_test_teardown),
2050                 cmocka_unit_test_setup_teardown(test_search_match_filter,
2051                                                 ldb_search_test_setup,
2052                                                 ldb_search_test_teardown),
2053                 cmocka_unit_test_setup_teardown(test_search_match_both,
2054                                                 ldb_search_test_setup,
2055                                                 ldb_search_test_teardown),
2056                 cmocka_unit_test_setup_teardown(test_search_match_basedn,
2057                                                 ldb_search_test_setup,
2058                                                 ldb_search_test_teardown),
2059                 cmocka_unit_test_setup_teardown(test_ldb_search_against_transaction,
2060                                                 ldb_search_test_setup,
2061                                                 ldb_search_test_teardown),
2062                 cmocka_unit_test_setup_teardown(test_ldb_attrs_case_insensitive,
2063                                                 ldb_case_test_setup,
2064                                                 ldb_case_test_teardown),
2065                 cmocka_unit_test_setup_teardown(test_ldb_attrs_case_handler,
2066                                                 ldb_case_test_setup,
2067                                                 ldb_case_test_teardown),
2068                 cmocka_unit_test_setup_teardown(test_ldb_attrs_index_handler,
2069                                                 ldb_case_test_setup,
2070                                                 ldb_case_attrs_index_test_teardown),
2071                 cmocka_unit_test_setup_teardown(test_ldb_rename,
2072                                                 ldb_rename_test_setup,
2073                                                 ldb_rename_test_teardown),
2074                 cmocka_unit_test_setup_teardown(test_ldb_rename_from_doesnt_exist,
2075                                                 ldb_rename_test_setup,
2076                                                 ldb_rename_test_teardown),
2077                 cmocka_unit_test_setup_teardown(test_ldb_rename_to_exists,
2078                                                 ldb_rename_test_setup,
2079                                                 ldb_rename_test_teardown),
2080                 cmocka_unit_test_setup_teardown(test_ldb_rename_self,
2081                                                 ldb_rename_test_setup,
2082                                                 ldb_rename_test_teardown),
2083                 cmocka_unit_test_setup_teardown(test_ldb_rename_dn_case_change,
2084                                                 ldb_rename_test_setup,
2085                                                 ldb_rename_test_teardown),
2086         };
2087
2088         return cmocka_run_group_tests(tests, NULL, NULL);
2089 }