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