9f8b3e9f35fe3d14e88e8bcc7b36e17b23446232
[gd/samba-autobuild/.git] / source4 / lib / ldb / ldb_ldap / ldb_ldap.c
1 /* 
2    ldb database library
3
4    Copyright (C) Andrew Tridgell  2004
5    Copyright (C) Simo Sorce       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 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_ldap
27  *
28  *  Component: ldb ldap backend
29  *
30  *  Description: core files for LDAP backend
31  *
32  *  Author: Andrew Tridgell
33  *
34  *  Modifications:
35  *
36  *  - description: make the module use asyncronous calls
37  *    date: Feb 2006
38  *    author: Simo Sorce
39  */
40
41 #include "ldb_includes.h"
42
43 #define LDAP_DEPRECATED 1
44 #include <ldap.h>
45
46 struct lldb_private {
47         LDAP *ldap;
48 };
49
50 struct lldb_context {
51         struct ldb_module *module;
52         struct ldb_request *req;
53
54         struct lldb_private *lldb;
55
56         struct ldb_control **controls;
57         int msgid;
58 };
59
60 static int lldb_ldap_to_ldb(int err) {
61         /* Ldap errors and ldb errors are defined to the same values */
62         return err;
63 }
64
65 /*
66   convert a ldb_message structure to a list of LDAPMod structures
67   ready for ldap_add() or ldap_modify()
68 */
69 static LDAPMod **lldb_msg_to_mods(void *mem_ctx, const struct ldb_message *msg, int use_flags)
70 {
71         LDAPMod **mods;
72         unsigned int i, j;
73         int num_mods = 0;
74
75         /* allocate maximum number of elements needed */
76         mods = talloc_array(mem_ctx, LDAPMod *, msg->num_elements+1);
77         if (!mods) {
78                 errno = ENOMEM;
79                 return NULL;
80         }
81         mods[0] = NULL;
82
83         for (i=0;i<msg->num_elements;i++) {
84                 const struct ldb_message_element *el = &msg->elements[i];
85
86                 mods[num_mods] = talloc(mods, LDAPMod);
87                 if (!mods[num_mods]) {
88                         goto failed;
89                 }
90                 mods[num_mods+1] = NULL;
91                 mods[num_mods]->mod_op = LDAP_MOD_BVALUES;
92                 if (use_flags) {
93                         switch (el->flags & LDB_FLAG_MOD_MASK) {
94                         case LDB_FLAG_MOD_ADD:
95                                 mods[num_mods]->mod_op |= LDAP_MOD_ADD;
96                                 break;
97                         case LDB_FLAG_MOD_DELETE:
98                                 mods[num_mods]->mod_op |= LDAP_MOD_DELETE;
99                                 break;
100                         case LDB_FLAG_MOD_REPLACE:
101                                 mods[num_mods]->mod_op |= LDAP_MOD_REPLACE;
102                                 break;
103                         }
104                 }
105                 mods[num_mods]->mod_type = discard_const_p(char, el->name);
106                 mods[num_mods]->mod_vals.modv_bvals = talloc_array(mods[num_mods], 
107                                                                    struct berval *,
108                                                                    1+el->num_values);
109                 if (!mods[num_mods]->mod_vals.modv_bvals) {
110                         goto failed;
111                 }
112
113                 for (j=0;j<el->num_values;j++) {
114                         mods[num_mods]->mod_vals.modv_bvals[j] = talloc(mods[num_mods]->mod_vals.modv_bvals,
115                                                                         struct berval);
116                         if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
117                                 goto failed;
118                         }
119                         mods[num_mods]->mod_vals.modv_bvals[j]->bv_val = el->values[j].data;
120                         mods[num_mods]->mod_vals.modv_bvals[j]->bv_len = el->values[j].length;
121                 }
122                 mods[num_mods]->mod_vals.modv_bvals[j] = NULL;
123                 num_mods++;
124         }
125
126         return mods;
127
128 failed:
129         talloc_free(mods);
130         return NULL;
131 }
132
133 /*
134   add a single set of ldap message values to a ldb_message
135 */
136 static int lldb_add_msg_attr(struct ldb_context *ldb,
137                              struct ldb_message *msg, 
138                              const char *attr, struct berval **bval)
139 {
140         int count, i;
141         struct ldb_message_element *el;
142
143         count = ldap_count_values_len(bval);
144
145         if (count <= 0) {
146                 return -1;
147         }
148
149         el = talloc_realloc(msg, msg->elements, struct ldb_message_element, 
150                               msg->num_elements + 1);
151         if (!el) {
152                 errno = ENOMEM;
153                 return -1;
154         }
155
156         msg->elements = el;
157
158         el = &msg->elements[msg->num_elements];
159
160         el->name = talloc_strdup(msg->elements, attr);
161         if (!el->name) {
162                 errno = ENOMEM;
163                 return -1;
164         }
165         el->flags = 0;
166
167         el->num_values = 0;
168         el->values = talloc_array(msg->elements, struct ldb_val, count);
169         if (!el->values) {
170                 errno = ENOMEM;
171                 return -1;
172         }
173
174         for (i=0;i<count;i++) {
175                 /* we have to ensure this is null terminated so that
176                    ldb_msg_find_attr_as_string() can work */
177                 el->values[i].data = talloc_size(el->values, bval[i]->bv_len+1);
178                 if (!el->values[i].data) {
179                         errno = ENOMEM;
180                         return -1;
181                 }
182                 memcpy(el->values[i].data, bval[i]->bv_val, bval[i]->bv_len);
183                 el->values[i].data[bval[i]->bv_len] = 0;
184                 el->values[i].length = bval[i]->bv_len;
185                 el->num_values++;
186         }
187
188         msg->num_elements++;
189
190         return 0;
191 }
192
193 /*
194   search for matching records
195 */
196 static int lldb_search(struct lldb_context *lldb_ac)
197 {
198         struct lldb_private *lldb = lldb_ac->lldb;
199         struct ldb_module *module = lldb_ac->module;
200         struct ldb_request *req = lldb_ac->req;
201         struct timeval tv;
202         int ldap_scope;
203         char *search_base;
204         char *expression;
205         int ret;
206
207         if (!req->callback || !req->context) {
208                 ldb_set_errstring(module->ldb, "Async interface called with NULL callback function or NULL context");
209                 return LDB_ERR_OPERATIONS_ERROR;
210         }
211
212         if (req->op.search.tree == NULL) {
213                 ldb_set_errstring(module->ldb, "Invalid expression parse tree");
214                 return LDB_ERR_OPERATIONS_ERROR;
215         }
216
217         if (req->controls != NULL) {
218                 ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
219         }
220
221         req->handle->state = LDB_ASYNC_PENDING;
222
223         search_base = ldb_dn_alloc_linearized(lldb_ac, req->op.search.base);
224         if (req->op.search.base == NULL) {
225                 search_base = talloc_strdup(lldb_ac, "");
226         }
227         if (search_base == NULL) {
228                 return LDB_ERR_OPERATIONS_ERROR;
229         }
230
231         expression = ldb_filter_from_tree(lldb_ac, req->op.search.tree);
232         if (expression == NULL) {
233                 return LDB_ERR_OPERATIONS_ERROR;
234         }
235
236         switch (req->op.search.scope) {
237         case LDB_SCOPE_BASE:
238                 ldap_scope = LDAP_SCOPE_BASE;
239                 break;
240         case LDB_SCOPE_ONELEVEL:
241                 ldap_scope = LDAP_SCOPE_ONELEVEL;
242                 break;
243         default:
244                 ldap_scope = LDAP_SCOPE_SUBTREE;
245                 break;
246         }
247
248         tv.tv_sec = req->timeout;
249         tv.tv_usec = 0;
250
251         ret = ldap_search_ext(lldb->ldap, search_base, ldap_scope, 
252                             expression, 
253                             discard_const_p(char *, req->op.search.attrs), 
254                             0,
255                             NULL,
256                             NULL,
257                             &tv,
258                             LDAP_NO_LIMIT,
259                             &lldb_ac->msgid);
260
261         if (ret != LDAP_SUCCESS) {
262                 ldb_set_errstring(module->ldb, ldap_err2string(ret));
263         }
264
265         return lldb_ldap_to_ldb(ret);
266 }
267
268 /*
269   add a record
270 */
271 static int lldb_add(struct lldb_context *lldb_ac)
272 {
273         struct lldb_private *lldb = lldb_ac->lldb;
274         struct ldb_module *module = lldb_ac->module;
275         struct ldb_request *req = lldb_ac->req;
276         LDAPMod **mods;
277         char *dn;
278         int ret;
279
280         req->handle->state = LDB_ASYNC_PENDING;
281
282         mods = lldb_msg_to_mods(lldb_ac, req->op.add.message, 0);
283         if (mods == NULL) {
284                 return LDB_ERR_OPERATIONS_ERROR;
285         }
286
287         dn = ldb_dn_alloc_linearized(lldb_ac, req->op.add.message->dn);
288         if (dn == NULL) {
289                 return LDB_ERR_OPERATIONS_ERROR;
290         }
291
292         ret = ldap_add_ext(lldb->ldap, dn, mods,
293                            NULL,
294                            NULL,
295                            &lldb_ac->msgid);
296
297         if (ret != LDAP_SUCCESS) {
298                 ldb_set_errstring(module->ldb, ldap_err2string(ret));
299         }
300
301         return lldb_ldap_to_ldb(ret);
302 }
303
304 /*
305   modify a record
306 */
307 static int lldb_modify(struct lldb_context *lldb_ac)
308 {
309         struct lldb_private *lldb = lldb_ac->lldb;
310         struct ldb_module *module = lldb_ac->module;
311         struct ldb_request *req = lldb_ac->req;
312         LDAPMod **mods;
313         char *dn;
314         int ret;
315
316         req->handle->state = LDB_ASYNC_PENDING;
317
318         mods = lldb_msg_to_mods(lldb_ac, req->op.mod.message, 1);
319         if (mods == NULL) {
320                 return LDB_ERR_OPERATIONS_ERROR;
321         }
322
323         dn = ldb_dn_alloc_linearized(lldb_ac, req->op.mod.message->dn);
324         if (dn == NULL) {
325                 return LDB_ERR_OPERATIONS_ERROR;
326         }
327
328         ret = ldap_modify_ext(lldb->ldap, dn, mods,
329                               NULL,
330                               NULL,
331                               &lldb_ac->msgid);
332
333         if (ret != LDAP_SUCCESS) {
334                 ldb_set_errstring(module->ldb, ldap_err2string(ret));
335         }
336
337         return lldb_ldap_to_ldb(ret);
338 }
339
340 /*
341   delete a record
342 */
343 static int lldb_delete(struct lldb_context *lldb_ac)
344 {
345         struct lldb_private *lldb = lldb_ac->lldb;
346         struct ldb_module *module = lldb_ac->module;
347         struct ldb_request *req = lldb_ac->req;
348         char *dnstr;
349         int ret;
350
351         req->handle->state = LDB_ASYNC_PENDING;
352
353         dnstr = ldb_dn_alloc_linearized(lldb_ac, req->op.del.dn);
354
355         ret = ldap_delete_ext(lldb->ldap, dnstr,
356                               NULL,
357                               NULL,
358                               &lldb_ac->msgid);
359
360         if (ret != LDAP_SUCCESS) {
361                 ldb_set_errstring(module->ldb, ldap_err2string(ret));
362         }
363
364         return lldb_ldap_to_ldb(ret);
365 }
366
367 /*
368   rename a record
369 */
370 static int lldb_rename(struct lldb_context *lldb_ac)
371 {
372         struct lldb_private *lldb = lldb_ac->lldb;
373         struct ldb_module *module = lldb_ac->module;
374         struct ldb_request *req = lldb_ac->req;
375         char *old_dn;
376         char *newrdn;
377         char *parentdn;
378         int ret;
379
380         req->handle->state = LDB_ASYNC_PENDING;
381
382         old_dn = ldb_dn_alloc_linearized(lldb_ac, req->op.rename.olddn);
383         if (old_dn == NULL) {
384                 return LDB_ERR_OPERATIONS_ERROR;
385         }
386
387         newrdn = talloc_asprintf(lldb_ac, "%s=%s",
388                                  ldb_dn_get_rdn_name(req->op.rename.newdn),
389                                  ldb_dn_escape_value(lldb, *(ldb_dn_get_rdn_val(req->op.rename.newdn))));
390         if (!newrdn) {
391                 return LDB_ERR_OPERATIONS_ERROR;
392         }
393
394         parentdn = ldb_dn_alloc_linearized(lldb_ac, ldb_dn_get_parent(lldb_ac, req->op.rename.newdn));
395         if (!parentdn) {
396                 return LDB_ERR_OPERATIONS_ERROR;
397         }
398
399         ret = ldap_rename(lldb->ldap, old_dn, newrdn, parentdn,
400                           1, NULL, NULL,
401                           &lldb_ac->msgid);
402
403         if (ret != LDAP_SUCCESS) {
404                 ldb_set_errstring(module->ldb, ldap_err2string(ret));
405         }
406
407         return lldb_ldap_to_ldb(ret);
408 }
409
410 static int lldb_start_trans(struct ldb_module *module)
411 {
412         /* TODO implement a local transaction mechanism here */
413
414         return LDB_SUCCESS;
415 }
416
417 static int lldb_end_trans(struct ldb_module *module)
418 {
419         /* TODO implement a local transaction mechanism here */
420
421         return LDB_SUCCESS;
422 }
423
424 static int lldb_del_trans(struct ldb_module *module)
425 {
426         /* TODO implement a local transaction mechanism here */
427
428         return LDB_SUCCESS;
429 }
430
431 void lldb_request_done(struct ldb_request *req,
432                         struct ldb_control **ctrls, int error)
433 {
434         struct ldb_reply *ares;
435
436         ares = talloc_zero(req, struct ldb_reply);
437         if (!ares) {
438                 ldb_oom(req->handle->ldb);
439                 req->callback(req, NULL);
440                 return;
441         }
442         ares->type = LDB_REPLY_DONE;
443         ares->controls = talloc_steal(ares, ctrls);
444         ares->error = error;
445
446         req->callback(req, ares);
447 }
448
449 /* return false if the request is still in progress
450  * return true if the request is completed
451  */
452 static bool lldb_parse_result(struct lldb_context *ac, LDAPMessage *result)
453 {
454         struct lldb_private *lldb = ac->lldb;
455         LDAPControl **serverctrlsp = NULL;
456         char **referralsp = NULL;
457         char *matcheddnp = NULL;
458         char *errmsgp = NULL;
459         LDAPMessage *msg;
460         int type;
461         struct ldb_message *ldbmsg;
462         char *referral;
463         bool callback_failed;
464         bool request_done;
465         bool lret;
466         int ret;
467         int i;
468
469         type = ldap_msgtype(result);
470         callback_failed = false;
471         request_done = false;
472
473         switch (type) {
474         case LDAP_RES_SEARCH_ENTRY:
475
476                 msg = ldap_first_entry(lldb->ldap, result);
477                 if (msg != NULL) {
478                         BerElement *berptr = NULL;
479                         char *attr, *dn;
480
481                         ldbmsg = ldb_msg_new(ac);
482                         if (!ldbmsg) {
483                                 ret = LDB_ERR_OPERATIONS_ERROR;
484                                 break;
485                         }
486
487                         dn = ldap_get_dn(lldb->ldap, msg);
488                         if (!dn) {
489                                 talloc_free(ldbmsg);
490                                 ret = LDB_ERR_OPERATIONS_ERROR;
491                                 break;
492                         }
493                         ldbmsg->dn = ldb_dn_new(ldbmsg, ac->module->ldb, dn);
494                         if ( ! ldb_dn_validate(ldbmsg->dn)) {
495                                 talloc_free(ldbmsg);
496                                 ret = LDB_ERR_OPERATIONS_ERROR;
497                                 break;
498                         }
499                         ldap_memfree(dn);
500
501                         ldbmsg->num_elements = 0;
502                         ldbmsg->elements = NULL;
503
504                         /* loop over all attributes */
505                         for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
506                              attr;
507                              attr=ldap_next_attribute(lldb->ldap, msg, berptr)) {
508                                 struct berval **bval;
509                                 bval = ldap_get_values_len(lldb->ldap, msg, attr);
510
511                                 if (bval) {
512                                         lldb_add_msg_attr(ac->module->ldb, ldbmsg, attr, bval);
513                                         ldap_value_free_len(bval);
514                                 }
515                         }
516                         if (berptr) ber_free(berptr, 0);
517
518                         ret = ldb_module_send_entry(ac->req, ldbmsg, NULL /* controls not yet supported */);
519                         if (ret != LDB_SUCCESS) {
520
521                                 callback_failed = true;
522                         }
523                 } else {
524                         ret = LDB_ERR_OPERATIONS_ERROR;
525                 }
526                 break;
527
528         case LDAP_RES_SEARCH_REFERENCE:
529
530                 if (ldap_parse_result(lldb->ldap, result, &ret,
531                                         &matcheddnp, &errmsgp,
532                                         &referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
533                         ret = LDB_ERR_OPERATIONS_ERROR;
534                 }
535                 if (ret != LDB_SUCCESS) {
536                         break;
537                 }
538                 if (referralsp == NULL) {
539                         ret = LDB_ERR_PROTOCOL_ERROR;
540                         break;
541                 }
542
543                 for (i = 0; referralsp[i]; i++) {
544                         referral = talloc_strdup(ac, referralsp[i]);
545
546                         ret = ldb_module_send_referral(ac->req, referral);
547                         if (ret != LDB_SUCCESS) {
548                                 callback_failed = true;
549                                 break;
550                         }
551                 }
552                 break;
553
554         case LDAP_RES_SEARCH_RESULT:
555         case LDAP_RES_MODIFY:
556         case LDAP_RES_ADD:
557         case LDAP_RES_DELETE:
558         case LDAP_RES_MODDN:
559
560                 if (ldap_parse_result(lldb->ldap, result, &ret,
561                                         &matcheddnp, &errmsgp,
562                                         &referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
563                         ret = LDB_ERR_OPERATIONS_ERROR;
564                 }
565                 if (ret != LDB_SUCCESS) {
566                         break;
567                 }
568
569                 if (serverctrlsp != NULL) {
570                         /* FIXME: transform the LDAPControl list into an ldb_control one */
571                         ac->controls = NULL;
572                 }
573
574                 request_done = true;
575                 break;
576
577         default:
578                 ret = LDB_ERR_PROTOCOL_ERROR;
579                 break;
580         }
581
582         if (ret != LDB_SUCCESS) {
583
584                 /* if the callback failed the caller will have freed the
585                  * request. Just return and don't try to use it */
586                 if (callback_failed) {
587
588                         /* tell lldb_wait to remove the request from the
589                          *  queue */
590                         lret = true;
591                         goto free_and_return;
592                 }
593
594                 request_done = true;
595         }
596
597         if (request_done) {
598                 lldb_request_done(ac->req, ac->controls, ret);
599                 lret = true;
600                 goto free_and_return;
601         }
602
603         lret = false;
604
605 free_and_return:
606
607         if (matcheddnp) ldap_memfree(matcheddnp);
608         if (errmsgp && *errmsgp) {
609                 ldb_set_errstring(ac->module->ldb, errmsgp);
610         }
611         if (errmsgp) {
612                 ldap_memfree(errmsgp);
613         }
614         if (referralsp) ldap_value_free(referralsp);
615         if (serverctrlsp) ldap_controls_free(serverctrlsp);
616
617         ldap_msgfree(result);
618
619         return lret;
620 }
621
622 static void lldb_timeout(struct event_context *ev,
623                          struct timed_event *te,
624                          struct timeval t,
625                          void *private_data)
626 {
627         struct lldb_context *ac;
628         ac = talloc_get_type(private_data, struct lldb_context);
629
630         lldb_request_done(ac->req, NULL, LDB_ERR_TIME_LIMIT_EXCEEDED);
631 }
632
633 static void lldb_callback(struct event_context *ev,
634                           struct timed_event *te,
635                           struct timeval t,
636                           void *private_data)
637 {
638         struct lldb_context *ac;
639         struct timed_event *lte;
640         struct timeval tv;
641         LDAPMessage *result;
642         int lret;
643
644         ac = talloc_get_type(private_data, struct lldb_context);
645
646         if (!ac->msgid) {
647                 lldb_request_done(ac->req, NULL, LDB_ERR_OPERATIONS_ERROR);
648                 return;
649         }
650
651         tv.tv_sec = 0;
652         tv.tv_usec = 0;
653         lret = ldap_result(ac->lldb->ldap, ac->msgid, 0, &tv, &result);
654         if (lret == 0) {
655                 goto respin;
656         }
657         if (lret == -1) {
658                 lldb_request_done(ac->req, NULL, LDB_ERR_OPERATIONS_ERROR);
659                 return;
660         }
661
662         if ( ! lldb_parse_result(ac, result)) {
663                 goto respin;
664         }
665
666         return;
667
668 respin:
669         tv.tv_sec = 0;
670         tv.tv_usec = 100;
671         lte = event_add_timed(ev, ac, tv, lldb_callback, ac);
672         if (NULL == lte) {
673                 lldb_request_done(ac->req, NULL, LDB_ERR_OPERATIONS_ERROR);
674         }
675 }
676
677 static bool lldb_dn_is_special(struct ldb_request *req)
678 {
679         struct ldb_dn *dn = NULL;
680
681         switch (req->operation) {
682         case LDB_ADD:
683                 dn = req->op.add.message->dn;
684                 break;
685         case LDB_MODIFY:
686                 dn = req->op.mod.message->dn;
687                 break;
688         case LDB_DELETE:
689                 dn = req->op.del.dn;
690                 break;
691         case LDB_RENAME:
692                 dn = req->op.rename.olddn;
693                 break;
694         default:
695                 break;
696         }
697
698         if (dn && ldb_dn_is_special(dn)) {
699                 return true;
700         }
701         return false;
702 }
703
704 static void lldb_auto_done_callback(struct event_context *ev,
705                                     struct timed_event *te,
706                                     struct timeval t,
707                                     void *private_data)
708 {
709         struct lldb_context *ac;
710
711         ac = talloc_get_type(private_data, struct lldb_context);
712         lldb_request_done(ac->req, NULL, LDB_SUCCESS);
713 }
714
715 static int lldb_handle_request(struct ldb_module *module, struct ldb_request *req)
716 {
717         struct lldb_private *lldb;
718         struct lldb_context *ac;
719         struct event_context *ev;
720         struct timed_event *te;
721         struct timeval tv;
722         int ret;
723
724         lldb = talloc_get_type(module->private_data, struct lldb_private);
725
726         if (req->starttime == 0 || req->timeout == 0) {
727                 ldb_set_errstring(module->ldb, "Invalid timeout settings");
728                 return LDB_ERR_TIME_LIMIT_EXCEEDED;
729         }
730
731         ev = ldb_get_event_context(module->ldb);
732         if (NULL == ev) {
733                 return LDB_ERR_OPERATIONS_ERROR;
734         }
735
736         ac = talloc_zero(module->ldb, struct lldb_context);
737         if (ac == NULL) {
738                 ldb_set_errstring(module->ldb, "Out of Memory");
739                 return LDB_ERR_OPERATIONS_ERROR;
740         }
741
742         ac->module = module;
743         ac->req = req;
744         ac->lldb = lldb;
745         ac->msgid = 0;
746
747         if (lldb_dn_is_special(req)) {
748                 tv.tv_sec = 0;
749                 tv.tv_usec = 0;
750                 te = event_add_timed(ev, ac, tv,
751                                      lldb_auto_done_callback, ac);
752                 if (NULL == te) {
753                         return LDB_ERR_OPERATIONS_ERROR;
754                 }
755
756                 return LDB_SUCCESS;
757         }
758
759         switch (ac->req->operation) {
760         case LDB_SEARCH:
761                 ret = lldb_search(ac);
762                 break;
763         case LDB_ADD:
764                 ret = lldb_add(ac);
765                 break;
766         case LDB_MODIFY:
767                 ret = lldb_modify(ac);
768                 break;
769         case LDB_DELETE:
770                 ret = lldb_delete(ac);
771                 break;
772         case LDB_RENAME:
773                 ret = lldb_rename(ac);
774                 break;
775         default:
776                 /* no other op supported */
777                 ret = LDB_ERR_OPERATIONS_ERROR;
778                 break;
779         }
780
781         if (ret != LDB_SUCCESS) {
782                 lldb_request_done(req, NULL, ret);
783                 return ret;
784         }
785
786         tv.tv_sec = 0;
787         tv.tv_usec = 0;
788         te = event_add_timed(ev, ac, tv, lldb_callback, ac);
789         if (NULL == te) {
790                 return LDB_ERR_OPERATIONS_ERROR;
791         }
792
793
794         tv.tv_sec = req->starttime + req->timeout;
795         tv.tv_usec = 0;
796         te = event_add_timed(ev, ac, tv, lldb_timeout, ac);
797         if (NULL == te) {
798                 return LDB_ERR_OPERATIONS_ERROR;
799         }
800
801         return LDB_SUCCESS;
802 }
803
804 static const struct ldb_module_ops lldb_ops = {
805         .name              = "ldap",
806         .search            = lldb_handle_request,
807         .add               = lldb_handle_request,
808         .modify            = lldb_handle_request,
809         .del               = lldb_handle_request,
810         .rename            = lldb_handle_request,
811         .request           = lldb_handle_request,
812         .start_transaction = lldb_start_trans,
813         .end_transaction   = lldb_end_trans,
814         .del_transaction   = lldb_del_trans,
815 };
816
817
818 static int lldb_destructor(struct lldb_private *lldb)
819 {
820         ldap_unbind(lldb->ldap);
821         return 0;
822 }
823
824 /*
825   connect to the database
826 */
827 static int lldb_connect(struct ldb_context *ldb,
828                         const char *url,
829                         unsigned int flags,
830                         const char *options[],
831                         struct ldb_module **_module)
832 {
833         struct ldb_module *module;
834         struct lldb_private *lldb;
835         int version = 3;
836         int ret;
837
838         module = talloc(ldb, struct ldb_module);
839         if (module == NULL) {
840                 ldb_oom(ldb);
841                 talloc_free(lldb);
842                 return -1;
843         }
844         talloc_set_name_const(module, "ldb_ldap backend");
845         module->ldb             = ldb;
846         module->prev            = module->next = NULL;
847         module->ops             = &lldb_ops;
848
849         lldb = talloc(module, struct lldb_private);
850         if (!lldb) {
851                 ldb_oom(ldb);
852                 goto failed;
853         }
854         module->private_data    = lldb;
855         lldb->ldap              = NULL;
856
857         ret = ldap_initialize(&lldb->ldap, url);
858         if (ret != LDAP_SUCCESS) {
859                 ldb_debug(ldb, LDB_DEBUG_FATAL, "ldap_initialize failed for URL '%s' - %s\n",
860                           url, ldap_err2string(ret));
861                 goto failed;
862         }
863
864         talloc_set_destructor(lldb, lldb_destructor);
865
866         ret = ldap_set_option(lldb->ldap, LDAP_OPT_PROTOCOL_VERSION, &version);
867         if (ret != LDAP_SUCCESS) {
868                 ldb_debug(ldb, LDB_DEBUG_FATAL, "ldap_set_option failed - %s\n",
869                           ldap_err2string(ret));
870                 goto failed;
871         }
872
873         *_module = module;
874         return 0;
875
876 failed:
877         talloc_free(module);
878         return -1;
879 }
880
881 const struct ldb_backend_ops ldb_ldap_backend_ops = {
882         .name = "ldap",
883         .connect_fn = lldb_connect
884 };
885
886 const struct ldb_backend_ops ldb_ldapi_backend_ops = {
887         .name = "ldapi",
888         .connect_fn = lldb_connect
889 };
890
891 const struct ldb_backend_ops ldb_ldaps_backend_ops = {
892         .name = "ldaps",
893         .connect_fn = lldb_connect
894 };