source4/lib/ldb/common/ldb.c

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Andrew Tridgell  2004
   5    Copyright (C) Simo Sorce  2005-2008
   6
   7      ** NOTE! The following LGPL license applies to the ldb
   8      ** library. This does NOT imply that all of Samba is released
   9      ** under the LGPL
  10
  11    This library is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU Lesser General Public
  13    License as published by the Free Software Foundation; either
  14    version 3 of the License, or (at your option) any later version.
  15
  16    This library is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    Lesser General Public License for more details.
  20
  21    You should have received a copy of the GNU Lesser General Public
  22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 /*
  26  *  Name: ldb
  27  *
  28  *  Component: ldb core API
  29  *
  30  *  Description: core API routines interfacing to ldb backends
  31  *
  32  *  Author: Andrew Tridgell
  33  */
  34
  35 #include "ldb_includes.h"
  36
  37 /*
  38    initialise a ldb context
  39    The mem_ctx is required
  40    The event_ctx is required
  41 */
  42 struct ldb_context *ldb_init(TALLOC_CTX *mem_ctx, struct event_context *ev_ctx)
  43 {
  44         struct ldb_context *ldb;
  45         int ret;
  46
  47         ldb = talloc_zero(mem_ctx, struct ldb_context);
  48         /* FIXME: Hack a new event context so that CMD line utilities work
  49          * until we have them all converted */
  50         if (ev_ctx == NULL) {
  51                 ev_ctx = event_context_init(talloc_autofree_context());
  52         }
  53
  54         ret = ldb_setup_wellknown_attributes(ldb);
  55         if (ret != 0) {
  56                 talloc_free(ldb);
  57                 return NULL;
  58         }
  59
  60         ldb_set_utf8_default(ldb);
  61         ldb_set_create_perms(ldb, 0666);
  62         ldb_set_modules_dir(ldb, LDB_MODULESDIR);
  63         ldb_set_event_context(ldb, ev_ctx);
  64
  65         /* TODO: get timeout from options if available there */
  66         ldb->default_timeout = 300; /* set default to 5 minutes */
  67
  68         return ldb;
  69 }
  70
  71 static struct backends_list_entry {
  72         struct ldb_backend_ops *ops;
  73         struct backends_list_entry *prev, *next;
  74 } *ldb_backends = NULL;
  75
  76 #ifndef STATIC_LIBLDB_BACKENDS
  77
  78 #ifdef HAVE_LDB_LDAP
  79 #define LDAP_INIT &ldb_ldap_backend_ops, \
  80                                   &ldb_ldapi_backend_ops, \
  81                                   &ldb_ldaps_backend_ops,
  82 #else
  83 #define LDAP_INIT
  84 #endif
  85
  86 #ifdef HAVE_LDB_SQLITE3
  87 #define SQLITE3_INIT &ldb_sqlite3_backend_ops,
  88 #else
  89 #define SQLITE3_INIT
  90 #endif
  91
  92 #define STATIC_LIBLDB_BACKENDS \
  93         LDAP_INIT \
  94         SQLITE3_INIT \
  95         &ldb_tdb_backend_ops,   \
  96         NULL
  97 #endif
  98
  99 const static struct ldb_backend_ops *builtin_backends[] = {
 100         STATIC_LIBLDB_BACKENDS
 101 };
 102
 103 static ldb_connect_fn ldb_find_backend(const char *url)
 104 {
 105         struct backends_list_entry *backend;
 106         int i;
 107
 108         for (i = 0; builtin_backends[i]; i++) {
 109                 if (strncmp(builtin_backends[i]->name, url,
 110                             strlen(builtin_backends[i]->name)) == 0)
 111                         return builtin_backends[i]->connect_fn;
 112         }
 113
 114         for (backend = ldb_backends; backend; backend = backend->next) {
 115                 if (strncmp(backend->ops->name, url,
 116                             strlen(backend->ops->name)) == 0) {
 117                         return backend->ops->connect_fn;
 118                 }
 119         }
 120
 121         return NULL;
 122 }
 123
 124 /*
 125  register a new ldb backend
 126 */
 127 int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
 128 {
 129         struct ldb_backend_ops *backend;
 130         struct backends_list_entry *entry;
 131
 132         backend = talloc(talloc_autofree_context(), struct ldb_backend_ops);
 133         if (!backend) return LDB_ERR_OPERATIONS_ERROR;
 134
 135         entry = talloc(talloc_autofree_context(), struct backends_list_entry);
 136         if (!entry) {
 137                 talloc_free(backend);
 138                 return LDB_ERR_OPERATIONS_ERROR;
 139         }
 140
 141         if (ldb_find_backend(url_prefix)) {
 142                 return LDB_SUCCESS;
 143         }
 144
 145         /* Maybe check for duplicity here later on? */
 146
 147         backend->name = talloc_strdup(backend, url_prefix);
 148         backend->connect_fn = connectfn;
 149         entry->ops = backend;
 150         DLIST_ADD(ldb_backends, entry);
 151
 152         return LDB_SUCCESS;
 153 }
 154
 155 /*
 156    Return the ldb module form of a database.
 157    The URL can either be one of the following forms
 158    ldb://path
 159    ldapi://path
 160
 161    flags is made up of LDB_FLG_*
 162
 163    the options are passed uninterpreted to the backend, and are
 164    backend specific.
 165
 166    This allows modules to get at only the backend module, for example where a
 167    module may wish to direct certain requests at a particular backend.
 168 */
 169 int ldb_connect_backend(struct ldb_context *ldb,
 170                         const char *url,
 171                         const char *options[],
 172                         struct ldb_module **backend_module)
 173 {
 174         int ret;
 175         char *backend;
 176         ldb_connect_fn fn;
 177
 178         if (strchr(url, ':') != NULL) {
 179                 backend = talloc_strndup(ldb, url, strchr(url, ':')-url);
 180         } else {
 181                 /* Default to tdb */
 182                 backend = talloc_strdup(ldb, "tdb");
 183         }
 184
 185         fn = ldb_find_backend(backend);
 186
 187         if (fn == NULL) {
 188                 struct ldb_backend_ops *ops;
 189                 char *symbol_name = talloc_asprintf(ldb, "ldb_%s_backend_ops", backend);
 190                 if (symbol_name == NULL) {
 191                         return LDB_ERR_OPERATIONS_ERROR;
 192                 }
 193                 ops = ldb_dso_load_symbol(ldb, backend, symbol_name);
 194                 if (ops != NULL) {
 195                         fn = ops->connect_fn;
 196                 }
 197                 talloc_free(symbol_name);
 198         }
 199
 200         talloc_free(backend);
 201
 202         if (fn == NULL) {
 203                 ldb_debug(ldb, LDB_DEBUG_FATAL,
 204                           "Unable to find backend for '%s'\n", url);
 205                 return LDB_ERR_OTHER;
 206         }
 207
 208         ret = fn(ldb, url, ldb->flags, options, backend_module);
 209
 210         if (ret != LDB_SUCCESS) {
 211                 ldb_debug(ldb, LDB_DEBUG_ERROR,
 212                           "Failed to connect to '%s'\n", url);
 213                 return ret;
 214         }
 215         return ret;
 216 }
 217
 218 /*
 219   try to autodetect a basedn if none specified. This fixes one of my
 220   pet hates about ldapsearch, which is that you have to get a long,
 221   complex basedn right to make any use of it.
 222 */
 223 void ldb_set_default_dns(struct ldb_context *ldb)
 224 {
 225         TALLOC_CTX *tmp_ctx;
 226         int ret;
 227         struct ldb_result *res;
 228         struct ldb_dn *tmp_dn=NULL;
 229         static const char *attrs[] = {
 230                 "rootDomainNamingContext",
 231                 "configurationNamingContext",
 232                 "schemaNamingContext",
 233                 "defaultNamingContext",
 234                 NULL
 235         };
 236
 237         tmp_ctx = talloc_new(ldb);
 238         ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, NULL), LDB_SCOPE_BASE,
 239                          "(objectClass=*)", attrs, &res);
 240         if (ret != LDB_SUCCESS) {
 241                 talloc_free(tmp_ctx);
 242                 return;
 243         }
 244
 245         if (res->count != 1) {
 246                 talloc_free(res);
 247                 return;
 248         }
 249
 250         if (!ldb_get_opaque(ldb, "rootDomainNamingContext")) {
 251                 tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
 252                                                  "rootDomainNamingContext");
 253                 ldb_set_opaque(ldb, "rootDomainNamingContext", tmp_dn);
 254         }
 255
 256         if (!ldb_get_opaque(ldb, "configurationNamingContext")) {
 257                 tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
 258                                                  "configurationNamingContext");
 259                 ldb_set_opaque(ldb, "configurationNamingContext", tmp_dn);
 260         }
 261
 262         if (!ldb_get_opaque(ldb, "schemaNamingContext")) {
 263                 tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
 264                                                  "schemaNamingContext");
 265                 ldb_set_opaque(ldb, "schemaNamingContext", tmp_dn);
 266         }
 267
 268         if (!ldb_get_opaque(ldb, "defaultNamingContext")) {
 269                 tmp_dn = ldb_msg_find_attr_as_dn(ldb, ldb, res->msgs[0],
 270                                                  "defaultNamingContext");
 271                 ldb_set_opaque(ldb, "defaultNamingContext", tmp_dn);
 272         }
 273
 274         talloc_free(res);
 275         talloc_free(tmp_ctx);
 276 }
 277
 278 struct ldb_dn *ldb_get_root_basedn(struct ldb_context *ldb)
 279 {
 280         void *opaque = ldb_get_opaque(ldb, "rootDomainNamingContext");
 281         return talloc_get_type(opaque, struct ldb_dn);
 282 }
 283
 284 struct ldb_dn *ldb_get_config_basedn(struct ldb_context *ldb)
 285 {
 286         void *opaque = ldb_get_opaque(ldb, "configurationNamingContext");
 287         return talloc_get_type(opaque, struct ldb_dn);
 288 }
 289
 290 struct ldb_dn *ldb_get_schema_basedn(struct ldb_context *ldb)
 291 {
 292         void *opaque = ldb_get_opaque(ldb, "schemaNamingContext");
 293         return talloc_get_type(opaque, struct ldb_dn);
 294 }
 295
 296 struct ldb_dn *ldb_get_default_basedn(struct ldb_context *ldb)
 297 {
 298         void *opaque = ldb_get_opaque(ldb, "defaultNamingContext");
 299         return talloc_get_type(opaque, struct ldb_dn);
 300 }
 301
 302 /*
 303    connect to a database. The URL can either be one of the following forms
 304    ldb://path
 305    ldapi://path
 306
 307    flags is made up of LDB_FLG_*
 308
 309    the options are passed uninterpreted to the backend, and are
 310    backend specific
 311 */
 312 int ldb_connect(struct ldb_context *ldb, const char *url,
 313                 unsigned int flags, const char *options[])
 314 {
 315         int ret;
 316         const char *url2;
 317         /* We seem to need to do this here, or else some utilities don't
 318          * get ldb backends */
 319
 320         ldb->flags = flags;
 321
 322         url2 = talloc_strdup(ldb, url);
 323         if (!url2) {
 324                 ldb_oom(ldb);
 325                 return LDB_ERR_OPERATIONS_ERROR;
 326         }
 327         ret = ldb_set_opaque(ldb, "ldb_url", talloc_strdup(ldb, url2));
 328         if (ret != LDB_SUCCESS) {
 329                 return ret;
 330         }
 331
 332         ret = ldb_connect_backend(ldb, url, options, &ldb->modules);
 333         if (ret != LDB_SUCCESS) {
 334                 return ret;
 335         }
 336
 337         if (ldb_load_modules(ldb, options) != LDB_SUCCESS) {
 338                 ldb_debug(ldb, LDB_DEBUG_FATAL,
 339                           "Unable to load modules for %s: %s\n",
 340                           url, ldb_errstring(ldb));
 341                 return LDB_ERR_OTHER;
 342         }
 343
 344         /* TODO: get timeout from options if available there */
 345         ldb->default_timeout = 300; /* set default to 5 minutes */
 346
 347         /* set the default base dn */
 348         ldb_set_default_dns(ldb);
 349
 350         return LDB_SUCCESS;
 351 }
 352
 353 void ldb_set_errstring(struct ldb_context *ldb, const char *err_string)
 354 {
 355         if (ldb->err_string) {
 356                 talloc_free(ldb->err_string);
 357         }
 358         ldb->err_string = talloc_strdup(ldb, err_string);
 359 }
 360
 361 void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...)
 362 {
 363         va_list ap;
 364         char *old_string = NULL;
 365
 366         if (ldb->err_string) {
 367                 old_string = ldb->err_string;
 368         }
 369
 370         va_start(ap, format);
 371         ldb->err_string = talloc_vasprintf(ldb, format, ap);
 372         va_end(ap);
 373         talloc_free(old_string);
 374 }
 375
 376 void ldb_reset_err_string(struct ldb_context *ldb)
 377 {
 378         if (ldb->err_string) {
 379                 talloc_free(ldb->err_string);
 380                 ldb->err_string = NULL;
 381         }
 382 }
 383
 384 #define FIRST_OP(ldb, op) do { \
 385         module = ldb->modules;                                  \
 386         while (module && module->ops->op == NULL) module = module->next; \
 387         if (module == NULL) {                                           \
 388                 ldb_asprintf_errstring(ldb, "unable to find module or backend to handle operation: " #op); \
 389                 return LDB_ERR_OPERATIONS_ERROR;                        \
 390         } \
 391 } while (0)
 392
 393 /*
 394   start a transaction
 395 */
 396 static int ldb_transaction_start_internal(struct ldb_context *ldb)
 397 {
 398         struct ldb_module *module;
 399         int status;
 400         FIRST_OP(ldb, start_transaction);
 401
 402         ldb_reset_err_string(ldb);
 403
 404         status = module->ops->start_transaction(module);
 405         if (status != LDB_SUCCESS) {
 406                 if (ldb->err_string == NULL) {
 407                         /* no error string was setup by the backend */
 408                         ldb_asprintf_errstring(ldb,
 409                                 "ldb transaction start: %s (%d)",
 410                                 ldb_strerror(status),
 411                                 status);
 412                 }
 413         }
 414         return status;
 415 }
 416
 417 /*
 418   commit a transaction
 419 */
 420 static int ldb_transaction_commit_internal(struct ldb_context *ldb)
 421 {
 422         struct ldb_module *module;
 423         int status;
 424         FIRST_OP(ldb, end_transaction);
 425
 426         ldb_reset_err_string(ldb);
 427
 428         status = module->ops->end_transaction(module);
 429         if (status != LDB_SUCCESS) {
 430                 if (ldb->err_string == NULL) {
 431                         /* no error string was setup by the backend */
 432                         ldb_asprintf_errstring(ldb,
 433                                 "ldb transaction commit: %s (%d)",
 434                                 ldb_strerror(status),
 435                                 status);
 436                 }
 437         }
 438         return status;
 439 }
 440
 441 /*
 442   cancel a transaction
 443 */
 444 static int ldb_transaction_cancel_internal(struct ldb_context *ldb)
 445 {
 446         struct ldb_module *module;
 447         int status;
 448         FIRST_OP(ldb, del_transaction);
 449
 450         status = module->ops->del_transaction(module);
 451         if (status != LDB_SUCCESS) {
 452                 if (ldb->err_string == NULL) {
 453                         /* no error string was setup by the backend */
 454                         ldb_asprintf_errstring(ldb,
 455                                 "ldb transaction cancel: %s (%d)",
 456                                 ldb_strerror(status),
 457                                 status);
 458                 }
 459         }
 460         return status;
 461 }
 462
 463 int ldb_transaction_start(struct ldb_context *ldb)
 464 {
 465         /* disable autotransactions */
 466         ldb->transaction_active++;
 467
 468         return ldb_transaction_start_internal(ldb);
 469 }
 470
 471 int ldb_transaction_commit(struct ldb_context *ldb)
 472 {
 473         /* renable autotransactions (when we reach 0) */
 474         if (ldb->transaction_active > 0)
 475                 ldb->transaction_active--;
 476
 477         return ldb_transaction_commit_internal(ldb);
 478 }
 479
 480 int ldb_transaction_cancel(struct ldb_context *ldb)
 481 {
 482         /* renable autotransactions (when we reach 0) */
 483         if (ldb->transaction_active > 0)
 484                 ldb->transaction_active--;
 485
 486         return ldb_transaction_cancel_internal(ldb);
 487 }
 488
 489 static int ldb_autotransaction_start(struct ldb_context *ldb)
 490 {
 491         /* explicit transaction active, ignore autotransaction request */
 492         if (ldb->transaction_active)
 493                 return LDB_SUCCESS;
 494
 495         return ldb_transaction_start_internal(ldb);
 496 }
 497
 498 static int ldb_autotransaction_commit(struct ldb_context *ldb)
 499 {
 500         /* explicit transaction active, ignore autotransaction request */
 501         if (ldb->transaction_active)
 502                 return LDB_SUCCESS;
 503
 504         return ldb_transaction_commit_internal(ldb);
 505 }
 506
 507 static int ldb_autotransaction_cancel(struct ldb_context *ldb)
 508 {
 509         /* explicit transaction active, ignore autotransaction request */
 510         if (ldb->transaction_active)
 511                 return LDB_SUCCESS;
 512
 513         return ldb_transaction_cancel_internal(ldb);
 514 }
 515
 516 /* autostarts a transacion if none active */
 517 static int ldb_autotransaction_request(struct ldb_context *ldb,
 518                                        struct ldb_request *req)
 519 {
 520         int ret;
 521
 522         ret = ldb_autotransaction_start(ldb);
 523         if (ret != LDB_SUCCESS) {
 524                 return ret;
 525         }
 526
 527         ret = ldb_request(ldb, req);
 528         if (ret == LDB_SUCCESS) {
 529                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
 530         }
 531
 532         if (ret == LDB_SUCCESS) {
 533                 return ldb_autotransaction_commit(ldb);
 534         }
 535         ldb_autotransaction_cancel(ldb);
 536
 537         if (ldb->err_string == NULL) {
 538                 /* no error string was setup by the backend */
 539                 ldb_asprintf_errstring(ldb, "%s (%d)", ldb_strerror(ret), ret);
 540         }
 541
 542         return ret;
 543 }
 544
 545 int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
 546 {
 547         int ret;
 548         if (!handle) {
 549                 return LDB_SUCCESS;
 550         }
 551
 552         ret = handle->module->ops->wait(handle, type);
 553         if (!ldb_errstring(handle->module->ldb)) {
 554                 /* Set a default error string, to place the blame somewhere */
 555                 ldb_asprintf_errstring(handle->module->ldb,
 556                                         "error waiting on module %s: %s (%d)",
 557                                         handle->module->ops->name,
 558                                         ldb_strerror(ret), ret);
 559         }
 560         return ret;
 561 }
 562
 563 /* set the specified timeout or, if timeout is 0 set the default timeout */
 564 /* timeout == -1 means no timeout */
 565 int ldb_set_timeout(struct ldb_context *ldb,
 566                     struct ldb_request *req,
 567                     int timeout)
 568 {
 569         if (req == NULL) return LDB_ERR_OPERATIONS_ERROR;
 570
 571         if (timeout != 0) {
 572                 req->timeout = timeout;
 573         } else {
 574                 req->timeout = ldb->default_timeout;
 575         }
 576         req->starttime = time(NULL);
 577
 578         return LDB_SUCCESS;
 579 }
 580
 581 /* calculates the new timeout based on the previous starttime and timeout */
 582 int ldb_set_timeout_from_prev_req(struct ldb_context *ldb,
 583                                   struct ldb_request *oldreq,
 584                                   struct ldb_request *newreq)
 585 {
 586         time_t now;
 587
 588         if (newreq == NULL) return LDB_ERR_OPERATIONS_ERROR;
 589
 590         now = time(NULL);
 591
 592         if (oldreq == NULL)
 593                 return ldb_set_timeout(ldb, newreq, 0);
 594
 595         if ((now - oldreq->starttime) > oldreq->timeout) {
 596                 return LDB_ERR_TIME_LIMIT_EXCEEDED;
 597         }
 598         newreq->starttime = oldreq->starttime;
 599         newreq->timeout = oldreq->timeout - (now - oldreq->starttime);
 600
 601         return LDB_SUCCESS;
 602 }
 603
 604
 605 /*
 606    set the permissions for new files to be passed to open() in
 607    backends that use local files
 608  */
 609 void ldb_set_create_perms(struct ldb_context *ldb, unsigned int perms)
 610 {
 611         ldb->create_perms = perms;
 612 }
 613
 614 void ldb_set_event_context(struct ldb_context *ldb, struct event_context *ev)
 615 {
 616         ldb->ev_ctx = ev;
 617 }
 618
 619 struct event_context * ldb_get_event_context(struct ldb_context *ldb)
 620 {
 621         return ldb->ev_ctx;
 622 }
 623
 624 /*
 625   start an ldb request
 626   NOTE: the request must be a talloc context.
 627   returns LDB_ERR_* on errors.
 628 */
 629 int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 630 {
 631         struct ldb_module *module;
 632         int ret;
 633
 634         ldb_reset_err_string(ldb);
 635
 636         /* call the first module in the chain */
 637         switch (req->operation) {
 638         case LDB_SEARCH:
 639                 FIRST_OP(ldb, search);
 640                 ret = module->ops->search(module, req);
 641                 break;
 642         case LDB_ADD:
 643                 FIRST_OP(ldb, add);
 644                 ret = module->ops->add(module, req);
 645                 break;
 646         case LDB_MODIFY:
 647                 FIRST_OP(ldb, modify);
 648                 ret = module->ops->modify(module, req);
 649                 break;
 650         case LDB_DELETE:
 651                 FIRST_OP(ldb, del);
 652                 ret = module->ops->del(module, req);
 653                 break;
 654         case LDB_RENAME:
 655                 FIRST_OP(ldb, rename);
 656                 ret = module->ops->rename(module, req);
 657                 break;
 658         case LDB_EXTENDED:
 659                 FIRST_OP(ldb, extended);
 660                 ret = module->ops->extended(module, req);
 661                 break;
 662         case LDB_SEQUENCE_NUMBER:
 663                 FIRST_OP(ldb, sequence_number);
 664                 ret = module->ops->sequence_number(module, req);
 665                 break;
 666         default:
 667                 FIRST_OP(ldb, request);
 668                 ret = module->ops->request(module, req);
 669                 break;
 670         }
 671
 672         return ret;
 673 }
 674
 675 /*
 676   search the database given a LDAP-like search expression
 677
 678   returns an LDB error code
 679
 680   Use talloc_free to free the ldb_message returned in 'res', if successful
 681
 682 */
 683 int ldb_search_default_callback(struct ldb_context *ldb,
 684                                 void *context,
 685                                 struct ldb_reply *ares)
 686 {
 687         struct ldb_result *res;
 688         int n;
 689
 690         if (!context) {
 691                 ldb_set_errstring(ldb, "NULL Context in callback");
 692                 return LDB_ERR_OPERATIONS_ERROR;
 693         }
 694
 695         res = talloc_get_type(context, struct ldb_result);
 696
 697         if (!res || !ares) {
 698                 ldb_set_errstring(ldb, "NULL res or ares in callback");
 699                 goto error;
 700         }
 701
 702         switch (ares->type) {
 703         case LDB_REPLY_ENTRY:
 704                 res->msgs = talloc_realloc(res, res->msgs,
 705                                            struct ldb_message *,
 706                                            res->count + 2);
 707                 if (! res->msgs) {
 708                         goto error;
 709                 }
 710
 711                 res->msgs[res->count + 1] = NULL;
 712
 713                 res->msgs[res->count] = talloc_move(res->msgs, &ares->message);
 714                 res->count++;
 715                 break;
 716         case LDB_REPLY_REFERRAL:
 717                 if (res->refs) {
 718                         for (n = 0; res->refs[n]; n++) /*noop*/ ;
 719                 } else {
 720                         n = 0;
 721                 }
 722
 723                 res->refs = talloc_realloc(res, res->refs, char *, n + 2);
 724                 if (! res->refs) {
 725                         goto error;
 726                 }
 727
 728                 res->refs[n] = talloc_move(res->refs, &ares->referral);
 729                 res->refs[n + 1] = NULL;
 730                 break;
 731         case LDB_REPLY_EXTENDED:
 732         case LDB_REPLY_DONE:
 733                 /* TODO: we should really support controls on entries
 734                  * and referrals too! */
 735                 res->controls = talloc_move(res, &ares->controls);
 736                 break;
 737         }
 738         talloc_free(ares);
 739         return LDB_SUCCESS;
 740
 741 error:
 742         talloc_free(ares);
 743         return LDB_ERR_OPERATIONS_ERROR;
 744 }
 745
 746 int ldb_build_search_req(struct ldb_request **ret_req,
 747                         struct ldb_context *ldb,
 748                         void *mem_ctx,
 749                         struct ldb_dn *base,
 750                         enum ldb_scope scope,
 751                         const char *expression,
 752                         const char * const *attrs,
 753                         struct ldb_control **controls,
 754                         void *context,
 755                         ldb_request_callback_t callback)
 756 {
 757         struct ldb_request *req;
 758
 759         *ret_req = NULL;
 760
 761         req = talloc(mem_ctx, struct ldb_request);
 762         if (req == NULL) {
 763                 ldb_set_errstring(ldb, "Out of Memory");
 764                 return LDB_ERR_OPERATIONS_ERROR;
 765         }
 766
 767         req->operation = LDB_SEARCH;
 768         if (base == NULL) {
 769                 req->op.search.base = ldb_dn_new(req, ldb, NULL);
 770         } else {
 771                 req->op.search.base = base;
 772         }
 773         req->op.search.scope = scope;
 774
 775         req->op.search.tree = ldb_parse_tree(req, expression);
 776         if (req->op.search.tree == NULL) {
 777                 ldb_set_errstring(ldb, "Unable to parse search expression");
 778                 talloc_free(req);
 779                 return LDB_ERR_OPERATIONS_ERROR;
 780         }
 781
 782         req->op.search.attrs = attrs;
 783         req->controls = controls;
 784         req->context = context;
 785         req->callback = callback;
 786
 787         *ret_req = req;
 788         return LDB_SUCCESS;
 789 }
 790
 791 int ldb_build_add_req(struct ldb_request **ret_req,
 792                         struct ldb_context *ldb,
 793                         void *mem_ctx,
 794                         const struct ldb_message *message,
 795                         struct ldb_control **controls,
 796                         void *context,
 797                         ldb_request_callback_t callback)
 798 {
 799         struct ldb_request *req;
 800
 801         *ret_req = NULL;
 802
 803         req = talloc(mem_ctx, struct ldb_request);
 804         if (req == NULL) {
 805                 ldb_set_errstring(ldb, "Out of Memory");
 806                 return LDB_ERR_OPERATIONS_ERROR;
 807         }
 808
 809         req->operation = LDB_ADD;
 810         req->op.add.message = message;
 811         req->controls = controls;
 812         req->context = context;
 813         req->callback = callback;
 814
 815         *ret_req = req;
 816
 817         return LDB_SUCCESS;
 818 }
 819
 820 int ldb_build_mod_req(struct ldb_request **ret_req,
 821                         struct ldb_context *ldb,
 822                         void *mem_ctx,
 823                         const struct ldb_message *message,
 824                         struct ldb_control **controls,
 825                         void *context,
 826                         ldb_request_callback_t callback)
 827 {
 828         struct ldb_request *req;
 829
 830         *ret_req = NULL;
 831
 832         req = talloc(mem_ctx, struct ldb_request);
 833         if (req == NULL) {
 834                 ldb_set_errstring(ldb, "Out of Memory");
 835                 return LDB_ERR_OPERATIONS_ERROR;
 836         }
 837
 838         req->operation = LDB_MODIFY;
 839         req->op.mod.message = message;
 840         req->controls = controls;
 841         req->context = context;
 842         req->callback = callback;
 843
 844         *ret_req = req;
 845
 846         return LDB_SUCCESS;
 847 }
 848
 849 int ldb_build_del_req(struct ldb_request **ret_req,
 850                         struct ldb_context *ldb,
 851                         void *mem_ctx,
 852                         struct ldb_dn *dn,
 853                         struct ldb_control **controls,
 854                         void *context,
 855                         ldb_request_callback_t callback)
 856 {
 857         struct ldb_request *req;
 858
 859         *ret_req = NULL;
 860
 861         req = talloc(mem_ctx, struct ldb_request);
 862         if (req == NULL) {
 863                 ldb_set_errstring(ldb, "Out of Memory");
 864                 return LDB_ERR_OPERATIONS_ERROR;
 865         }
 866
 867         req->operation = LDB_DELETE;
 868         req->op.del.dn = dn;
 869         req->controls = controls;
 870         req->context = context;
 871         req->callback = callback;
 872
 873         *ret_req = req;
 874
 875         return LDB_SUCCESS;
 876 }
 877
 878 int ldb_build_rename_req(struct ldb_request **ret_req,
 879                         struct ldb_context *ldb,
 880                         void *mem_ctx,
 881                         struct ldb_dn *olddn,
 882                         struct ldb_dn *newdn,
 883                         struct ldb_control **controls,
 884                         void *context,
 885                         ldb_request_callback_t callback)
 886 {
 887         struct ldb_request *req;
 888
 889         *ret_req = NULL;
 890
 891         req = talloc(mem_ctx, struct ldb_request);
 892         if (req == NULL) {
 893                 ldb_set_errstring(ldb, "Out of Memory");
 894                 return LDB_ERR_OPERATIONS_ERROR;
 895         }
 896
 897         req->operation = LDB_RENAME;
 898         req->op.rename.olddn = olddn;
 899         req->op.rename.newdn = newdn;
 900         req->controls = controls;
 901         req->context = context;
 902         req->callback = callback;
 903
 904         *ret_req = req;
 905
 906         return LDB_SUCCESS;
 907 }
 908
 909 int ldb_extended_default_callback(struct ldb_context *ldb,
 910                                   void *context,
 911                                   struct ldb_reply *ares)
 912 {
 913         struct ldb_result *res;
 914
 915         if (!context) {
 916                 ldb_set_errstring(ldb, "NULL Context in callback");
 917                 return LDB_ERR_OPERATIONS_ERROR;
 918         }
 919
 920         res = talloc_get_type(context, struct ldb_result);
 921         if (!res || !ares) {
 922                 ldb_set_errstring(ldb, "NULL res or ares in callback");
 923                 goto error;
 924         }
 925
 926         switch (ares->type) {
 927         case LDB_REPLY_ENTRY:
 928         case LDB_REPLY_REFERRAL:
 929         case LDB_REPLY_DONE:
 930                 ldb_set_errstring(ldb, "invalid ares type in callback");
 931                 goto error;
 932         case LDB_REPLY_EXTENDED:
 933                 /* TODO: we should really support controls on entries and
 934                  * referrals too! */
 935                 res->extended = talloc_move(res, &ares->response);
 936                 res->controls = talloc_move(res, &ares->controls);
 937                 break;
 938         }
 939         talloc_free(ares);
 940         return LDB_SUCCESS;
 941
 942 error:
 943         talloc_free(ares);
 944         return LDB_ERR_OPERATIONS_ERROR;
 945 }
 946
 947 int ldb_build_extended_req(struct ldb_request **ret_req,
 948                            struct ldb_context *ldb,
 949                            void *mem_ctx,
 950                            const char *oid,
 951                            void *data,
 952                            struct ldb_control **controls,
 953                            void *context,
 954                            ldb_request_callback_t callback)
 955 {
 956         struct ldb_request *req;
 957
 958         *ret_req = NULL;
 959
 960         req = talloc(mem_ctx, struct ldb_request);
 961         if (req == NULL) {
 962                 ldb_set_errstring(ldb, "Out of Memory");
 963                 return LDB_ERR_OPERATIONS_ERROR;
 964         }
 965
 966         req->operation = LDB_EXTENDED;
 967         req->op.extended.oid = oid;
 968         req->op.extended.data = data;
 969         req->controls = controls;
 970         req->context = context;
 971         req->callback = callback;
 972
 973         *ret_req = req;
 974
 975         return LDB_SUCCESS;
 976 }
 977
 978 int ldb_extended(struct ldb_context *ldb,
 979                  const char *oid,
 980                  void *data,
 981                  struct ldb_result **_res)
 982 {
 983         struct ldb_request *req;
 984         int ret;
 985         struct ldb_result *res;
 986
 987         *_res = NULL;
 988
 989         res = talloc_zero(ldb, struct ldb_result);
 990         if (!res) {
 991                 return LDB_ERR_OPERATIONS_ERROR;
 992         }
 993
 994         ret = ldb_build_extended_req(&req, ldb, ldb,
 995                                      oid, data, NULL,
 996                                      res, ldb_extended_default_callback);
 997         if (ret != LDB_SUCCESS) goto done;
 998
 999         ldb_set_timeout(ldb, req, 0); /* use default timeout */
1000
1001         ret = ldb_request(ldb, req);
1002
1003         if (ret == LDB_SUCCESS) {
1004                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
1005         }
1006
1007         talloc_free(req);
1008
1009 done:
1010         if (ret != LDB_SUCCESS) {
1011                 talloc_free(res);
1012         }
1013
1014         *_res = res;
1015         return ret;
1016 }
1017
1018 /*
1019   note that ldb_search() will automatically replace a NULL 'base' value
1020   with the defaultNamingContext from the rootDSE if available.
1021 */
1022 int ldb_search(struct ldb_context *ldb,
1023                struct ldb_dn *base,
1024                enum ldb_scope scope,
1025                const char *expression,
1026                const char * const *attrs,
1027                struct ldb_result **_res)
1028 {
1029         struct ldb_request *req;
1030         int ret;
1031         struct ldb_result *res;
1032
1033         *_res = NULL;
1034
1035         res = talloc_zero(ldb, struct ldb_result);
1036         if (!res) {
1037                 return LDB_ERR_OPERATIONS_ERROR;
1038         }
1039
1040         ret = ldb_build_search_req(&req, ldb, ldb,
1041                                         base?base:ldb_get_default_basedn(ldb),
1042                                         scope,
1043                                         expression,
1044                                         attrs,
1045                                         NULL,
1046                                         res,
1047                                         ldb_search_default_callback);
1048
1049         if (ret != LDB_SUCCESS) goto done;
1050
1051         ldb_set_timeout(ldb, req, 0); /* use default timeout */
1052
1053         ret = ldb_request(ldb, req);
1054
1055         if (ret == LDB_SUCCESS) {
1056                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
1057         }
1058
1059         talloc_free(req);
1060
1061 done:
1062         if (ret != LDB_SUCCESS) {
1063                 talloc_free(res);
1064         }
1065
1066         *_res = res;
1067         return ret;
1068 }
1069
1070 /*
1071  a useful search function where you can easily define the expression and that
1072  takes a memory context where results are allocated
1073 */
1074
1075 int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
1076                         struct ldb_result **result, struct ldb_dn *base,
1077                         enum ldb_scope scope, const char * const *attrs,
1078                         const char *exp_fmt, ...)
1079 {
1080         struct ldb_result *res;
1081         char *expression;
1082         va_list ap;
1083         int ret;
1084
1085         res = NULL;
1086         *result = NULL;
1087
1088         va_start(ap, exp_fmt);
1089         expression = talloc_vasprintf(mem_ctx, exp_fmt, ap);
1090         va_end(ap);
1091
1092         if ( ! expression) {
1093                 return LDB_ERR_OPERATIONS_ERROR;
1094         }
1095
1096         ret = ldb_search(ldb, base, scope, expression, attrs, &res);
1097
1098         if (ret == LDB_SUCCESS) {
1099                 talloc_steal(mem_ctx, res);
1100                 *result = res;
1101         }
1102
1103         talloc_free(expression);
1104
1105         return ret;
1106 }
1107
1108 /*
1109   add a record to the database. Will fail if a record with the
1110   given class and key already exists
1111 */
1112 int ldb_add(struct ldb_context *ldb,
1113             const struct ldb_message *message)
1114 {
1115         struct ldb_request *req;
1116         int ret;
1117
1118         ret = ldb_msg_sanity_check(ldb, message);
1119         if (ret != LDB_SUCCESS) {
1120                 return ret;
1121         }
1122
1123         ret = ldb_build_add_req(&req, ldb, ldb,
1124                                         message,
1125                                         NULL,
1126                                         NULL,
1127                                         NULL);
1128
1129         if (ret != LDB_SUCCESS) return ret;
1130
1131         ldb_set_timeout(ldb, req, 0); /* use default timeout */
1132
1133         /* do request and autostart a transaction */
1134         ret = ldb_autotransaction_request(ldb, req);
1135
1136         talloc_free(req);
1137         return ret;
1138 }
1139
1140 /*
1141   modify the specified attributes of a record
1142 */
1143 int ldb_modify(struct ldb_context *ldb,
1144                const struct ldb_message *message)
1145 {
1146         struct ldb_request *req;
1147         int ret;
1148
1149         ret = ldb_msg_sanity_check(ldb, message);
1150         if (ret != LDB_SUCCESS) {
1151                 return ret;
1152         }
1153
1154         ret = ldb_build_mod_req(&req, ldb, ldb,
1155                                         message,
1156                                         NULL,
1157                                         NULL,
1158                                         NULL);
1159
1160         if (ret != LDB_SUCCESS) return ret;
1161
1162         ldb_set_timeout(ldb, req, 0); /* use default timeout */
1163
1164         /* do request and autostart a transaction */
1165         ret = ldb_autotransaction_request(ldb, req);
1166
1167         talloc_free(req);
1168         return ret;
1169 }
1170
1171
1172 /*
1173   delete a record from the database
1174 */
1175 int ldb_delete(struct ldb_context *ldb, struct ldb_dn *dn)
1176 {
1177         struct ldb_request *req;
1178         int ret;
1179
1180         ret = ldb_build_del_req(&req, ldb, ldb,
1181                                         dn,
1182                                         NULL,
1183                                         NULL,
1184                                         NULL);
1185
1186         if (ret != LDB_SUCCESS) return ret;
1187
1188         ldb_set_timeout(ldb, req, 0); /* use default timeout */
1189
1190         /* do request and autostart a transaction */
1191         ret = ldb_autotransaction_request(ldb, req);
1192
1193         talloc_free(req);
1194         return ret;
1195 }
1196
1197 /*
1198   rename a record in the database
1199 */
1200 int ldb_rename(struct ldb_context *ldb,
1201                 struct ldb_dn *olddn, struct ldb_dn *newdn)
1202 {
1203         struct ldb_request *req;
1204         int ret;
1205
1206         ret = ldb_build_rename_req(&req, ldb, ldb,
1207                                         olddn,
1208                                         newdn,
1209                                         NULL,
1210                                         NULL,
1211                                         NULL);
1212
1213         if (ret != LDB_SUCCESS) return ret;
1214
1215         ldb_set_timeout(ldb, req, 0); /* use default timeout */
1216
1217         /* do request and autostart a transaction */
1218         ret = ldb_autotransaction_request(ldb, req);
1219
1220         talloc_free(req);
1221         return ret;
1222 }
1223
1224
1225 /*
1226   return the global sequence number
1227 */
1228 int ldb_sequence_number(struct ldb_context *ldb,
1229                         enum ldb_sequence_type type,
1230                         uint64_t *seq_num)
1231 {
1232         struct ldb_request *req;
1233         int ret;
1234
1235         req = talloc(ldb, struct ldb_request);
1236         if (req == NULL) {
1237                 ldb_set_errstring(ldb, "Out of Memory");
1238                 return LDB_ERR_OPERATIONS_ERROR;
1239         }
1240
1241         req->operation = LDB_SEQUENCE_NUMBER;
1242         req->controls = NULL;
1243         req->context = NULL;
1244         req->callback = NULL;
1245         ldb_set_timeout(ldb, req, 0); /* use default timeout */
1246
1247         req->op.seq_num.type = type;
1248         /* do request and autostart a transaction */
1249         ret = ldb_request(ldb, req);
1250
1251         if (ret == LDB_SUCCESS) {
1252                 *seq_num = req->op.seq_num.seq_num;
1253         }
1254
1255         talloc_free(req);
1256         return ret;
1257 }
1258
1259
1260
1261 /*
1262   return extended error information
1263 */
1264 const char *ldb_errstring(struct ldb_context *ldb)
1265 {
1266         if (ldb->err_string) {
1267                 return ldb->err_string;
1268         }
1269
1270         return NULL;
1271 }
1272
1273 /*
1274   return a string explaining what a ldb error constant meancs
1275 */
1276 const char *ldb_strerror(int ldb_err)
1277 {
1278         switch (ldb_err) {
1279         case LDB_SUCCESS:
1280                 return "Success";
1281         case LDB_ERR_OPERATIONS_ERROR:
1282                 return "Operations error";
1283         case LDB_ERR_PROTOCOL_ERROR:
1284                 return "Protocol error";
1285         case LDB_ERR_TIME_LIMIT_EXCEEDED:
1286                 return "Time limit exceeded";
1287         case LDB_ERR_SIZE_LIMIT_EXCEEDED:
1288                 return "Size limit exceeded";
1289         case LDB_ERR_COMPARE_FALSE:
1290                 return "Compare false";
1291         case LDB_ERR_COMPARE_TRUE:
1292                 return "Compare true";
1293         case LDB_ERR_AUTH_METHOD_NOT_SUPPORTED:
1294                 return "Auth method not supported";
1295         case LDB_ERR_STRONG_AUTH_REQUIRED:
1296                 return "Strong auth required";
1297 /* 9 RESERVED */
1298         case LDB_ERR_REFERRAL:
1299                 return "Referral error";
1300         case LDB_ERR_ADMIN_LIMIT_EXCEEDED:
1301                 return "Admin limit exceeded";
1302         case LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION:
1303                 return "Unsupported critical extension";
1304         case LDB_ERR_CONFIDENTIALITY_REQUIRED:
1305                 return "Confidentiality required";
1306         case LDB_ERR_SASL_BIND_IN_PROGRESS:
1307                 return "SASL bind in progress";
1308         case LDB_ERR_NO_SUCH_ATTRIBUTE:
1309                 return "No such attribute";
1310         case LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE:
1311                 return "Undefined attribute type";
1312         case LDB_ERR_INAPPROPRIATE_MATCHING:
1313                 return "Inappropriate matching";
1314         case LDB_ERR_CONSTRAINT_VIOLATION:
1315                 return "Constraint violation";
1316         case LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS:
1317                 return "Attribute or value exists";
1318         case LDB_ERR_INVALID_ATTRIBUTE_SYNTAX:
1319                 return "Invalid attribute syntax";
1320 /* 22-31 unused */
1321         case LDB_ERR_NO_SUCH_OBJECT:
1322                 return "No such object";
1323         case LDB_ERR_ALIAS_PROBLEM:
1324                 return "Alias problem";
1325         case LDB_ERR_INVALID_DN_SYNTAX:
1326                 return "Invalid DN syntax";
1327 /* 35 RESERVED */
1328         case LDB_ERR_ALIAS_DEREFERENCING_PROBLEM:
1329                 return "Alias dereferencing problem";
1330 /* 37-47 unused */
1331         case LDB_ERR_INAPPROPRIATE_AUTHENTICATION:
1332                 return "Inappropriate authentication";
1333         case LDB_ERR_INVALID_CREDENTIALS:
1334                 return "Invalid credentials";
1335         case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
1336                 return "insufficient access rights";
1337         case LDB_ERR_BUSY:
1338                 return "Busy";
1339         case LDB_ERR_UNAVAILABLE:
1340                 return "Unavailable";
1341         case LDB_ERR_UNWILLING_TO_PERFORM:
1342                 return "Unwilling to perform";
1343         case LDB_ERR_LOOP_DETECT:
1344                 return "Loop detect";
1345 /* 55-63 unused */
1346         case LDB_ERR_NAMING_VIOLATION:
1347                 return "Naming violation";
1348         case LDB_ERR_OBJECT_CLASS_VIOLATION:
1349                 return "Object class violation";
1350         case LDB_ERR_NOT_ALLOWED_ON_NON_LEAF:
1351                 return "Not allowed on non-leaf";
1352         case LDB_ERR_NOT_ALLOWED_ON_RDN:
1353                 return "Not allowed on RDN";
1354         case LDB_ERR_ENTRY_ALREADY_EXISTS:
1355                 return "Entry already exists";
1356         case LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED:
1357                 return "Object class mods prohibited";
1358 /* 70 RESERVED FOR CLDAP */
1359         case LDB_ERR_AFFECTS_MULTIPLE_DSAS:
1360                 return "Affects multiple DSAs";
1361 /* 72-79 unused */
1362         case LDB_ERR_OTHER:
1363                 return "Other";
1364         }
1365
1366         return "Unknown error";
1367 }
1368
1369 /*
1370   set backend specific opaque parameters
1371 */
1372 int ldb_set_opaque(struct ldb_context *ldb, const char *name, void *value)
1373 {
1374         struct ldb_opaque *o;
1375
1376         /* allow updating an existing value */
1377         for (o=ldb->opaque;o;o=o->next) {
1378                 if (strcmp(o->name, name) == 0) {
1379                         o->value = value;
1380                         return LDB_SUCCESS;
1381                 }
1382         }
1383
1384         o = talloc(ldb, struct ldb_opaque);
1385         if (o == NULL) {
1386                 ldb_oom(ldb);
1387                 return LDB_ERR_OTHER;
1388         }
1389         o->next = ldb->opaque;
1390         o->name = name;
1391         o->value = value;
1392         ldb->opaque = o;
1393         return LDB_SUCCESS;
1394 }
1395
1396 /*
1397   get a previously set opaque value
1398 */
1399 void *ldb_get_opaque(struct ldb_context *ldb, const char *name)
1400 {
1401         struct ldb_opaque *o;
1402         for (o=ldb->opaque;o;o=o->next) {
1403                 if (strcmp(o->name, name) == 0) {
1404                         return o->value;
1405                 }
1406         }
1407         return NULL;
1408 }