Change our module code to not use the special symbol name init_module()
[kai/samba.git] / 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 }