s3:libsmb: add an option to cli_push to let the caller provide the buffers
[ira/wip.git] / source4 / lib / ldb / ldb_tdb / ldb_tdb.c
1 /*
2    ldb database library
3
4    Copyright (C) Andrew Tridgell  2004
5    Copyright (C) Stefan Metzmacher  2004
6    Copyright (C) Simo Sorce       2006-2008
7
8
9      ** NOTE! The following LGPL license applies to the ldb
10      ** library. This does NOT imply that all of Samba is released
11      ** under the LGPL
12
13    This library is free software; you can redistribute it and/or
14    modify it under the terms of the GNU Lesser General Public
15    License as published by the Free Software Foundation; either
16    version 3 of the License, or (at your option) any later version.
17
18    This library is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21    Lesser General Public License for more details.
22
23    You should have received a copy of the GNU Lesser General Public
24    License along with this library; if not, see <http://www.gnu.org/licenses/>.
25 */
26
27 /*
28  *  Name: ldb_tdb
29  *
30  *  Component: ldb tdb backend
31  *
32  *  Description: core functions for tdb backend
33  *
34  *  Author: Andrew Tridgell
35  *  Author: Stefan Metzmacher
36  *
37  *  Modifications:
38  *
39  *  - description: make the module use asyncronous calls
40  *    date: Feb 2006
41  *    Author: Simo Sorce
42  *
43  *  - description: make it possible to use event contexts
44  *    date: Jan 2008
45  *    Author: Simo Sorce
46  */
47
48 #include "ldb_tdb.h"
49
50
51 /*
52   map a tdb error code to a ldb error code
53 */
54 static int ltdb_err_map(enum TDB_ERROR tdb_code)
55 {
56         switch (tdb_code) {
57         case TDB_SUCCESS:
58                 return LDB_SUCCESS;
59         case TDB_ERR_CORRUPT:
60         case TDB_ERR_OOM:
61         case TDB_ERR_EINVAL:
62                 return LDB_ERR_OPERATIONS_ERROR;
63         case TDB_ERR_IO:
64                 return LDB_ERR_PROTOCOL_ERROR;
65         case TDB_ERR_LOCK:
66         case TDB_ERR_NOLOCK:
67                 return LDB_ERR_BUSY;
68         case TDB_ERR_LOCK_TIMEOUT:
69                 return LDB_ERR_TIME_LIMIT_EXCEEDED;
70         case TDB_ERR_EXISTS:
71                 return LDB_ERR_ENTRY_ALREADY_EXISTS;
72         case TDB_ERR_NOEXIST:
73                 return LDB_ERR_NO_SUCH_OBJECT;
74         case TDB_ERR_RDONLY:
75                 return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
76         }
77         return LDB_ERR_OTHER;
78 }
79
80 /*
81   lock the database for read - use by ltdb_search and ltdb_sequence_number
82 */
83 int ltdb_lock_read(struct ldb_module *module)
84 {
85         void *data = ldb_module_get_private(module);
86         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
87         if (ltdb->in_transaction == 0) {
88                 return tdb_lockall_read(ltdb->tdb);
89         }
90         return 0;
91 }
92
93 /*
94   unlock the database after a ltdb_lock_read()
95 */
96 int ltdb_unlock_read(struct ldb_module *module)
97 {
98         void *data = ldb_module_get_private(module);
99         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
100         if (ltdb->in_transaction == 0) {
101                 return tdb_unlockall_read(ltdb->tdb);
102         }
103         return 0;
104 }
105
106
107 /*
108   form a TDB_DATA for a record key
109   caller frees
110
111   note that the key for a record can depend on whether the
112   dn refers to a case sensitive index record or not
113 */
114 struct TDB_DATA ltdb_key(struct ldb_module *module, struct ldb_dn *dn)
115 {
116         struct ldb_context *ldb = ldb_module_get_ctx(module);
117         TDB_DATA key;
118         char *key_str = NULL;
119         const char *dn_folded = NULL;
120
121         /*
122           most DNs are case insensitive. The exception is index DNs for
123           case sensitive attributes
124
125           there are 3 cases dealt with in this code:
126
127           1) if the dn doesn't start with @ then uppercase the attribute
128              names and the attributes values of case insensitive attributes
129           2) if the dn starts with @ then leave it alone -
130              the indexing code handles the rest
131         */
132
133         dn_folded = ldb_dn_get_casefold(dn);
134         if (!dn_folded) {
135                 goto failed;
136         }
137
138         key_str = talloc_strdup(ldb, "DN=");
139         if (!key_str) {
140                 goto failed;
141         }
142
143         key_str = talloc_strdup_append_buffer(key_str, dn_folded);
144         if (!key_str) {
145                 goto failed;
146         }
147
148         key.dptr = (uint8_t *)key_str;
149         key.dsize = strlen(key_str) + 1;
150
151         return key;
152
153 failed:
154         errno = ENOMEM;
155         key.dptr = NULL;
156         key.dsize = 0;
157         return key;
158 }
159
160 /*
161   check special dn's have valid attributes
162   currently only @ATTRIBUTES is checked
163 */
164 static int ltdb_check_special_dn(struct ldb_module *module,
165                           const struct ldb_message *msg)
166 {
167         struct ldb_context *ldb = ldb_module_get_ctx(module);
168         int i, j;
169
170         if (! ldb_dn_is_special(msg->dn) ||
171             ! ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) {
172                 return 0;
173         }
174
175         /* we have @ATTRIBUTES, let's check attributes are fine */
176         /* should we check that we deny multivalued attributes ? */
177         for (i = 0; i < msg->num_elements; i++) {
178                 for (j = 0; j < msg->elements[i].num_values; j++) {
179                         if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
180                                 ldb_set_errstring(ldb, "Invalid attribute value in an @ATTRIBUTES entry");
181                                 return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
182                         }
183                 }
184         }
185
186         return 0;
187 }
188
189
190 /*
191   we've made a modification to a dn - possibly reindex and
192   update sequence number
193 */
194 static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
195 {
196         int ret = LDB_SUCCESS;
197
198         if (ldb_dn_is_special(dn) &&
199             (ldb_dn_check_special(dn, LTDB_INDEXLIST) ||
200              ldb_dn_check_special(dn, LTDB_ATTRIBUTES)) ) {
201                 ret = ltdb_reindex(module);
202         }
203
204         if (ret == LDB_SUCCESS &&
205             !(ldb_dn_is_special(dn) &&
206               ldb_dn_check_special(dn, LTDB_BASEINFO)) ) {
207                 ret = ltdb_increase_sequence_number(module);
208         }
209
210         return ret;
211 }
212
213 /*
214   store a record into the db
215 */
216 int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
217 {
218         void *data = ldb_module_get_private(module);
219         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
220         TDB_DATA tdb_key, tdb_data;
221         int ret;
222
223         tdb_key = ltdb_key(module, msg->dn);
224         if (!tdb_key.dptr) {
225                 return LDB_ERR_OTHER;
226         }
227
228         ret = ltdb_pack_data(module, msg, &tdb_data);
229         if (ret == -1) {
230                 talloc_free(tdb_key.dptr);
231                 return LDB_ERR_OTHER;
232         }
233
234         ret = tdb_store(ltdb->tdb, tdb_key, tdb_data, flgs);
235         if (ret == -1) {
236                 ret = ltdb_err_map(tdb_error(ltdb->tdb));
237                 goto done;
238         }
239
240         ret = ltdb_index_add(module, msg);
241         if (ret != LDB_SUCCESS) {
242                 tdb_delete(ltdb->tdb, tdb_key);
243         }
244
245 done:
246         talloc_free(tdb_key.dptr);
247         talloc_free(tdb_data.dptr);
248
249         return ret;
250 }
251
252
253 static int ltdb_add_internal(struct ldb_module *module,
254                              const struct ldb_message *msg)
255 {
256         struct ldb_context *ldb = ldb_module_get_ctx(module);
257         int ret;
258
259         ret = ltdb_check_special_dn(module, msg);
260         if (ret != LDB_SUCCESS) {
261                 return ret;
262         }
263
264         if (ltdb_cache_load(module) != 0) {
265                 return LDB_ERR_OPERATIONS_ERROR;
266         }
267
268         ret = ltdb_store(module, msg, TDB_INSERT);
269
270         if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
271                 ldb_asprintf_errstring(ldb,
272                                         "Entry %s already exists",
273                                         ldb_dn_get_linearized(msg->dn));
274                 return ret;
275         }
276
277         if (ret == LDB_SUCCESS) {
278                 ret = ltdb_index_one(module, msg, 1);
279                 if (ret != LDB_SUCCESS) {
280                         return ret;
281                 }
282
283                 ret = ltdb_modified(module, msg->dn);
284                 if (ret != LDB_SUCCESS) {
285                         return ret;
286                 }
287         }
288
289         return ret;
290 }
291
292 /*
293   add a record to the database
294 */
295 static int ltdb_add(struct ltdb_context *ctx)
296 {
297         struct ldb_module *module = ctx->module;
298         struct ldb_request *req = ctx->req;
299         int tret;
300
301         ldb_request_set_state(req, LDB_ASYNC_PENDING);
302
303         tret = ltdb_add_internal(module, req->op.add.message);
304         if (tret != LDB_SUCCESS) {
305                 return tret;
306         }
307
308         return LDB_SUCCESS;
309 }
310
311 /*
312   delete a record from the database, not updating indexes (used for deleting
313   index records)
314 */
315 int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn)
316 {
317         void *data = ldb_module_get_private(module);
318         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
319         TDB_DATA tdb_key;
320         int ret;
321
322         tdb_key = ltdb_key(module, dn);
323         if (!tdb_key.dptr) {
324                 return LDB_ERR_OTHER;
325         }
326
327         ret = tdb_delete(ltdb->tdb, tdb_key);
328         talloc_free(tdb_key.dptr);
329
330         if (ret != 0) {
331                 ret = ltdb_err_map(tdb_error(ltdb->tdb));
332         }
333
334         return ret;
335 }
336
337 static int ltdb_delete_internal(struct ldb_module *module, struct ldb_dn *dn)
338 {
339         struct ldb_message *msg;
340         int ret;
341
342         msg = talloc(module, struct ldb_message);
343         if (msg == NULL) {
344                 return LDB_ERR_OPERATIONS_ERROR;
345         }
346
347         /* in case any attribute of the message was indexed, we need
348            to fetch the old record */
349         ret = ltdb_search_dn1(module, dn, msg);
350         if (ret != LDB_SUCCESS) {
351                 /* not finding the old record is an error */
352                 goto done;
353         }
354
355         ret = ltdb_delete_noindex(module, dn);
356         if (ret != LDB_SUCCESS) {
357                 goto done;
358         }
359
360         /* remove one level attribute */
361         ret = ltdb_index_one(module, msg, 0);
362         if (ret != LDB_SUCCESS) {
363                 goto done;
364         }
365
366         /* remove any indexed attributes */
367         ret = ltdb_index_del(module, msg);
368         if (ret != LDB_SUCCESS) {
369                 goto done;
370         }
371
372         ret = ltdb_modified(module, dn);
373         if (ret != LDB_SUCCESS) {
374                 goto done;
375         }
376
377 done:
378         talloc_free(msg);
379         return ret;
380 }
381
382 /*
383   delete a record from the database
384 */
385 static int ltdb_delete(struct ltdb_context *ctx)
386 {
387         struct ldb_module *module = ctx->module;
388         struct ldb_request *req = ctx->req;
389         int tret;
390
391         ldb_request_set_state(req, LDB_ASYNC_PENDING);
392
393         if (ltdb_cache_load(module) != 0) {
394                 return LDB_ERR_OPERATIONS_ERROR;
395         }
396
397         tret = ltdb_delete_internal(module, req->op.del.dn);
398         if (tret != LDB_SUCCESS) {
399                 return tret;
400         }
401
402         return LDB_SUCCESS;
403 }
404
405 /*
406   find an element by attribute name. At the moment this does a linear search,
407   it should be re-coded to use a binary search once all places that modify
408   records guarantee sorted order
409
410   return the index of the first matching element if found, otherwise -1
411 */
412 static int find_element(const struct ldb_message *msg, const char *name)
413 {
414         unsigned int i;
415         for (i=0;i<msg->num_elements;i++) {
416                 if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
417                         return i;
418                 }
419         }
420         return -1;
421 }
422
423
424 /*
425   add an element to an existing record. Assumes a elements array that we
426   can call re-alloc on, and assumed that we can re-use the data pointers from
427   the passed in additional values. Use with care!
428
429   returns 0 on success, -1 on failure (and sets errno)
430 */
431 static int msg_add_element(struct ldb_context *ldb,
432                            struct ldb_message *msg,
433                            struct ldb_message_element *el)
434 {
435         struct ldb_message_element *e2;
436         unsigned int i;
437
438         e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
439                               msg->num_elements+1);
440         if (!e2) {
441                 errno = ENOMEM;
442                 return -1;
443         }
444
445         msg->elements = e2;
446
447         e2 = &msg->elements[msg->num_elements];
448
449         e2->name = el->name;
450         e2->flags = el->flags;
451         e2->values = NULL;
452         if (el->num_values != 0) {
453                 e2->values = talloc_array(msg->elements,
454                                           struct ldb_val, el->num_values);
455                 if (!e2->values) {
456                         errno = ENOMEM;
457                         return -1;
458                 }
459         }
460         for (i=0;i<el->num_values;i++) {
461                 e2->values[i] = el->values[i];
462         }
463         e2->num_values = el->num_values;
464
465         msg->num_elements++;
466
467         return 0;
468 }
469
470 /*
471   delete all elements having a specified attribute name
472 */
473 static int msg_delete_attribute(struct ldb_module *module,
474                                 struct ldb_context *ldb,
475                                 struct ldb_message *msg, const char *name)
476 {
477         const char *dn;
478         unsigned int i, j;
479
480         dn = ldb_dn_get_linearized(msg->dn);
481         if (dn == NULL) {
482                 return -1;
483         }
484
485         for (i=0;i<msg->num_elements;i++) {
486                 if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
487                         for (j=0;j<msg->elements[i].num_values;j++) {
488                                 ltdb_index_del_value(module, dn,
489                                                      &msg->elements[i], j);
490                         }
491                         talloc_free(msg->elements[i].values);
492                         if (msg->num_elements > (i+1)) {
493                                 memmove(&msg->elements[i],
494                                         &msg->elements[i+1],
495                                         sizeof(struct ldb_message_element)*
496                                         (msg->num_elements - (i+1)));
497                         }
498                         msg->num_elements--;
499                         i--;
500                         msg->elements = talloc_realloc(msg, msg->elements,
501                                                         struct ldb_message_element,
502                                                         msg->num_elements);
503                 }
504         }
505
506         return 0;
507 }
508
509 /*
510   delete all elements matching an attribute name/value
511
512   return 0 on success, -1 on failure
513 */
514 static int msg_delete_element(struct ldb_module *module,
515                               struct ldb_message *msg,
516                               const char *name,
517                               const struct ldb_val *val)
518 {
519         struct ldb_context *ldb = ldb_module_get_ctx(module);
520         unsigned int i;
521         int found;
522         struct ldb_message_element *el;
523         const struct ldb_schema_attribute *a;
524
525         found = find_element(msg, name);
526         if (found == -1) {
527                 return -1;
528         }
529
530         el = &msg->elements[found];
531
532         a = ldb_schema_attribute_by_name(ldb, el->name);
533
534         for (i=0;i<el->num_values;i++) {
535                 if (a->syntax->comparison_fn(ldb, ldb,
536                                                 &el->values[i], val) == 0) {
537                         if (i<el->num_values-1) {
538                                 memmove(&el->values[i], &el->values[i+1],
539                                         sizeof(el->values[i])*
540                                                 (el->num_values-(i+1)));
541                         }
542                         el->num_values--;
543                         if (el->num_values == 0) {
544                                 return msg_delete_attribute(module, ldb,
545                                                             msg, name);
546                         }
547                         return 0;
548                 }
549         }
550
551         return -1;
552 }
553
554
555 /*
556   modify a record - internal interface
557
558   yuck - this is O(n^2). Luckily n is usually small so we probably
559   get away with it, but if we ever have really large attribute lists
560   then we'll need to look at this again
561 */
562 int ltdb_modify_internal(struct ldb_module *module,
563                          const struct ldb_message *msg)
564 {
565         struct ldb_context *ldb = ldb_module_get_ctx(module);
566         void *data = ldb_module_get_private(module);
567         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
568         TDB_DATA tdb_key, tdb_data;
569         struct ldb_message *msg2;
570         unsigned i, j;
571         int ret, idx;
572
573         tdb_key = ltdb_key(module, msg->dn);
574         if (!tdb_key.dptr) {
575                 return LDB_ERR_OTHER;
576         }
577
578         tdb_data = tdb_fetch(ltdb->tdb, tdb_key);
579         if (!tdb_data.dptr) {
580                 talloc_free(tdb_key.dptr);
581                 return ltdb_err_map(tdb_error(ltdb->tdb));
582         }
583
584         msg2 = talloc(tdb_key.dptr, struct ldb_message);
585         if (msg2 == NULL) {
586                 talloc_free(tdb_key.dptr);
587                 return LDB_ERR_OTHER;
588         }
589
590         ret = ltdb_unpack_data(module, &tdb_data, msg2);
591         if (ret == -1) {
592                 ret = LDB_ERR_OTHER;
593                 goto failed;
594         }
595
596         if (!msg2->dn) {
597                 msg2->dn = msg->dn;
598         }
599
600         for (i=0;i<msg->num_elements;i++) {
601                 struct ldb_message_element *el = &msg->elements[i];
602                 struct ldb_message_element *el2;
603                 struct ldb_val *vals;
604                 const char *dn;
605
606                 switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
607
608                 case LDB_FLAG_MOD_ADD:
609                         /* add this element to the message. fail if it
610                            already exists */
611                         idx = find_element(msg2, el->name);
612
613                         if (idx == -1) {
614                                 if (msg_add_element(ldb, msg2, el) != 0) {
615                                         ret = LDB_ERR_OTHER;
616                                         goto failed;
617                                 }
618                                 continue;
619                         }
620
621                         el2 = &msg2->elements[idx];
622
623                         /* An attribute with this name already exists,
624                          * add all values if they don't already exist
625                          * (check both the other elements to be added,
626                          * and those already in the db). */
627
628                         for (j=0;j<el->num_values;j++) {
629                                 if (ldb_msg_find_val(el2, &el->values[j])) {
630                                         ldb_asprintf_errstring(ldb, "%s: value #%d already exists", el->name, j);
631                                         ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
632                                         goto failed;
633                                 }
634                                 if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
635                                         ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
636                                         ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
637                                         goto failed;
638                                 }
639                         }
640
641                         vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
642                                                 el2->num_values + el->num_values);
643
644                         if (vals == NULL) {
645                                 ret = LDB_ERR_OTHER;
646                                 goto failed;
647                         }
648
649                         for (j=0;j<el->num_values;j++) {
650                                 vals[el2->num_values + j] =
651                                         ldb_val_dup(vals, &el->values[j]);
652                         }
653
654                         el2->values = vals;
655                         el2->num_values += el->num_values;
656
657                         break;
658
659                 case LDB_FLAG_MOD_REPLACE:
660                         /* replace all elements of this attribute name with the elements
661                            listed. The attribute not existing is not an error */
662                         msg_delete_attribute(module, ldb, msg2, el->name);
663
664                         for (j=0;j<el->num_values;j++) {
665                                 if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
666                                         ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
667                                         ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
668                                         goto failed;
669                                 }
670                         }
671
672                         /* add the replacement element, if not empty */
673                         if (el->num_values != 0 &&
674                             msg_add_element(ldb, msg2, el) != 0) {
675                                 ret = LDB_ERR_OTHER;
676                                 goto failed;
677                         }
678                         break;
679
680                 case LDB_FLAG_MOD_DELETE:
681
682                         dn = ldb_dn_get_linearized(msg->dn);
683                         if (dn == NULL) {
684                                 ret = LDB_ERR_OTHER;
685                                 goto failed;
686                         }
687
688                         /* we could be being asked to delete all
689                            values or just some values */
690                         if (msg->elements[i].num_values == 0) {
691                                 if (msg_delete_attribute(module, ldb, msg2, 
692                                                          msg->elements[i].name) != 0) {
693                                         ldb_asprintf_errstring(ldb, "No such attribute: %s for delete on %s", msg->elements[i].name, dn);
694                                         ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
695                                         goto failed;
696                                 }
697                                 break;
698                         }
699                         for (j=0;j<msg->elements[i].num_values;j++) {
700                                 if (msg_delete_element(module,
701                                                        msg2, 
702                                                        msg->elements[i].name,
703                                                        &msg->elements[i].values[j]) != 0) {
704                                         ldb_asprintf_errstring(ldb, "No matching attribute value when deleting attribute: %s on %s", msg->elements[i].name, dn);
705                                         ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
706                                         goto failed;
707                                 }
708                                 ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
709                                 if (ret != LDB_SUCCESS) {
710                                         goto failed;
711                                 }
712                         }
713                         break;
714                 default:
715                         ldb_asprintf_errstring(ldb,
716                                 "Invalid ldb_modify flags on %s: 0x%x",
717                                 msg->elements[i].name,
718                                 msg->elements[i].flags & LDB_FLAG_MOD_MASK);
719                         ret = LDB_ERR_PROTOCOL_ERROR;
720                         goto failed;
721                 }
722         }
723
724         /* we've made all the mods
725          * save the modified record back into the database */
726         ret = ltdb_store(module, msg2, TDB_MODIFY);
727         if (ret != LDB_SUCCESS) {
728                 goto failed;
729         }
730
731         ret = ltdb_modified(module, msg->dn);
732         if (ret != LDB_SUCCESS) {
733                 goto failed;
734         }
735
736         talloc_free(tdb_key.dptr);
737         free(tdb_data.dptr);
738         return ret;
739
740 failed:
741         talloc_free(tdb_key.dptr);
742         free(tdb_data.dptr);
743         return ret;
744 }
745
746 /*
747   modify a record
748 */
749 static int ltdb_modify(struct ltdb_context *ctx)
750 {
751         struct ldb_module *module = ctx->module;
752         struct ldb_request *req = ctx->req;
753         int tret;
754
755         ldb_request_set_state(req, LDB_ASYNC_PENDING);
756
757         tret = ltdb_check_special_dn(module, req->op.mod.message);
758         if (tret != LDB_SUCCESS) {
759                 return tret;
760         }
761
762         if (ltdb_cache_load(module) != 0) {
763                 return LDB_ERR_OPERATIONS_ERROR;
764         }
765
766         tret = ltdb_modify_internal(module, req->op.mod.message);
767         if (tret != LDB_SUCCESS) {
768                 return tret;
769         }
770
771         return LDB_SUCCESS;
772 }
773
774 /*
775   rename a record
776 */
777 static int ltdb_rename(struct ltdb_context *ctx)
778 {
779         struct ldb_module *module = ctx->module;
780         struct ldb_request *req = ctx->req;
781         struct ldb_message *msg;
782         int tret;
783
784         ldb_request_set_state(req, LDB_ASYNC_PENDING);
785
786         if (ltdb_cache_load(ctx->module) != 0) {
787                 return LDB_ERR_OPERATIONS_ERROR;
788         }
789
790         msg = talloc(ctx, struct ldb_message);
791         if (msg == NULL) {
792                 return LDB_ERR_OPERATIONS_ERROR;
793         }
794
795         /* in case any attribute of the message was indexed, we need
796            to fetch the old record */
797         tret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
798         if (tret != LDB_SUCCESS) {
799                 /* not finding the old record is an error */
800                 return tret;
801         }
802
803         msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
804         if (!msg->dn) {
805                 return LDB_ERR_OPERATIONS_ERROR;
806         }
807
808         if (ldb_dn_compare(req->op.rename.olddn, req->op.rename.newdn) == 0) {
809                 /* The rename operation is apparently only changing case -
810                    the DNs are the same.  Delete the old DN before adding
811                    the new one to avoid a TDB_ERR_EXISTS error.
812
813                    The only drawback to this is that if the delete
814                    succeeds but the add fails, we rely on the
815                    transaction to roll this all back. */
816                 tret = ltdb_delete_internal(module, req->op.rename.olddn);
817                 if (tret != LDB_SUCCESS) {
818                         return tret;
819                 }
820
821                 tret = ltdb_add_internal(module, msg);
822                 if (tret != LDB_SUCCESS) {
823                         return tret;
824                 }
825         } else {
826                 /* The rename operation is changing DNs.  Try to add the new
827                    DN first to avoid clobbering another DN not related to
828                    this rename operation. */
829                 tret = ltdb_add_internal(module, msg);
830                 if (tret != LDB_SUCCESS) {
831                         return tret;
832                 }
833
834                 tret = ltdb_delete_internal(module, req->op.rename.olddn);
835                 if (tret != LDB_SUCCESS) {
836                         ltdb_delete_internal(module, req->op.rename.newdn);
837                         return LDB_ERR_OPERATIONS_ERROR;
838                 }
839         }
840
841         return LDB_SUCCESS;
842 }
843
844 static int ltdb_start_trans(struct ldb_module *module)
845 {
846         void *data = ldb_module_get_private(module);
847         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
848
849         if (tdb_transaction_start(ltdb->tdb) != 0) {
850                 return ltdb_err_map(tdb_error(ltdb->tdb));
851         }
852
853         ltdb->in_transaction++;
854
855         ltdb_index_transaction_start(module);
856
857         return LDB_SUCCESS;
858 }
859
860 static int ltdb_end_trans(struct ldb_module *module)
861 {
862         void *data = ldb_module_get_private(module);
863         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
864
865         ltdb->in_transaction--;
866
867         if (ltdb_index_transaction_commit(module) != 0) {
868                 tdb_transaction_cancel(ltdb->tdb);
869                 return ltdb_err_map(tdb_error(ltdb->tdb));
870         }
871
872         if (tdb_transaction_commit(ltdb->tdb) != 0) {
873                 return ltdb_err_map(tdb_error(ltdb->tdb));
874         }
875
876         return LDB_SUCCESS;
877 }
878
879 static int ltdb_del_trans(struct ldb_module *module)
880 {
881         void *data = ldb_module_get_private(module);
882         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
883
884         ltdb->in_transaction--;
885
886         if (ltdb_index_transaction_cancel(module) != 0) {
887                 tdb_transaction_cancel(ltdb->tdb);
888                 return ltdb_err_map(tdb_error(ltdb->tdb));
889         }
890
891         if (tdb_transaction_cancel(ltdb->tdb) != 0) {
892                 return ltdb_err_map(tdb_error(ltdb->tdb));
893         }
894
895         return LDB_SUCCESS;
896 }
897
898 /*
899   return sequenceNumber from @BASEINFO
900 */
901 static int ltdb_sequence_number(struct ltdb_context *ctx,
902                                 struct ldb_extended **ext)
903 {
904         struct ldb_context *ldb;
905         struct ldb_module *module = ctx->module;
906         struct ldb_request *req = ctx->req;
907         TALLOC_CTX *tmp_ctx;
908         struct ldb_seqnum_request *seq;
909         struct ldb_seqnum_result *res;
910         struct ldb_message *msg = NULL;
911         struct ldb_dn *dn;
912         const char *date;
913         int ret;
914
915         ldb = ldb_module_get_ctx(module);
916
917         seq = talloc_get_type(req->op.extended.data,
918                                 struct ldb_seqnum_request);
919         if (seq == NULL) {
920                 return LDB_ERR_OPERATIONS_ERROR;
921         }
922
923         ldb_request_set_state(req, LDB_ASYNC_PENDING);
924
925         if (ltdb_lock_read(module) != 0) {
926                 return LDB_ERR_OPERATIONS_ERROR;
927         }
928
929         res = talloc_zero(req, struct ldb_seqnum_result);
930         if (res == NULL) {
931                 ret = LDB_ERR_OPERATIONS_ERROR;
932                 goto done;
933         }
934         tmp_ctx = talloc_new(req);
935         if (tmp_ctx == NULL) {
936                 ret = LDB_ERR_OPERATIONS_ERROR;
937                 goto done;
938         }
939
940         dn = ldb_dn_new(tmp_ctx, ldb, LTDB_BASEINFO);
941
942         msg = talloc(tmp_ctx, struct ldb_message);
943         if (msg == NULL) {
944                 ret = LDB_ERR_OPERATIONS_ERROR;
945                 goto done;
946         }
947
948         ret = ltdb_search_dn1(module, dn, msg);
949         if (ret != LDB_SUCCESS) {
950                 goto done;
951         }
952
953         switch (seq->type) {
954         case LDB_SEQ_HIGHEST_SEQ:
955                 res->seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
956                 break;
957         case LDB_SEQ_NEXT:
958                 res->seq_num = ldb_msg_find_attr_as_uint64(msg, LTDB_SEQUENCE_NUMBER, 0);
959                 res->seq_num++;
960                 break;
961         case LDB_SEQ_HIGHEST_TIMESTAMP:
962                 date = ldb_msg_find_attr_as_string(msg, LTDB_MOD_TIMESTAMP, NULL);
963                 if (date) {
964                         res->seq_num = ldb_string_to_time(date);
965                 } else {
966                         res->seq_num = 0;
967                         /* zero is as good as anything when we don't know */
968                 }
969                 break;
970         }
971
972         *ext = talloc_zero(req, struct ldb_extended);
973         if (*ext == NULL) {
974                 ret = LDB_ERR_OPERATIONS_ERROR;
975                 goto done;
976         }
977         (*ext)->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
978         (*ext)->data = talloc_steal(*ext, res);
979
980         ret = LDB_SUCCESS;
981
982 done:
983         talloc_free(tmp_ctx);
984         ltdb_unlock_read(module);
985         return ret;
986 }
987
988 static void ltdb_request_done(struct ltdb_context *ctx, int error)
989 {
990         struct ldb_context *ldb;
991         struct ldb_request *req;
992         struct ldb_reply *ares;
993
994         ldb = ldb_module_get_ctx(ctx->module);
995         req = ctx->req;
996
997         /* if we already returned an error just return */
998         if (ldb_request_get_status(req) != LDB_SUCCESS) {
999                 return;
1000         }
1001
1002         ares = talloc_zero(req, struct ldb_reply);
1003         if (!ares) {
1004                 ldb_oom(ldb);
1005                 req->callback(req, NULL);
1006                 return;
1007         }
1008         ares->type = LDB_REPLY_DONE;
1009         ares->error = error;
1010
1011         req->callback(req, ares);
1012 }
1013
1014 static void ltdb_timeout(struct tevent_context *ev,
1015                           struct tevent_timer *te,
1016                           struct timeval t,
1017                           void *private_data)
1018 {
1019         struct ltdb_context *ctx;
1020         ctx = talloc_get_type(private_data, struct ltdb_context);
1021
1022         if (!ctx->request_terminated) {
1023                 /* neutralize the spy */
1024                 ctx->spy->ctx = NULL;
1025
1026                 /* request is done now */
1027                 ltdb_request_done(ctx, LDB_ERR_TIME_LIMIT_EXCEEDED);
1028         }
1029
1030         talloc_free(ctx);
1031 }
1032
1033 static void ltdb_request_extended_done(struct ltdb_context *ctx,
1034                                         struct ldb_extended *ext,
1035                                         int error)
1036 {
1037         struct ldb_context *ldb;
1038         struct ldb_request *req;
1039         struct ldb_reply *ares;
1040
1041         ldb = ldb_module_get_ctx(ctx->module);
1042         req = ctx->req;
1043
1044         /* if we already returned an error just return */
1045         if (ldb_request_get_status(req) != LDB_SUCCESS) {
1046                 return;
1047         }
1048
1049         ares = talloc_zero(req, struct ldb_reply);
1050         if (!ares) {
1051                 ldb_oom(ldb);
1052                 req->callback(req, NULL);
1053                 return;
1054         }
1055         ares->type = LDB_REPLY_DONE;
1056         ares->response = ext;
1057         ares->error = error;
1058
1059         req->callback(req, ares);
1060 }
1061
1062 static void ltdb_handle_extended(struct ltdb_context *ctx)
1063 {
1064         struct ldb_extended *ext = NULL;
1065         int ret;
1066
1067         if (strcmp(ctx->req->op.extended.oid,
1068                    LDB_EXTENDED_SEQUENCE_NUMBER) == 0) {
1069                 /* get sequence number */
1070                 ret = ltdb_sequence_number(ctx, &ext);
1071         } else {
1072                 /* not recognized */
1073                 ret = LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
1074         }
1075
1076         ltdb_request_extended_done(ctx, ext, ret);
1077 }
1078
1079 static void ltdb_callback(struct tevent_context *ev,
1080                           struct tevent_timer *te,
1081                           struct timeval t,
1082                           void *private_data)
1083 {
1084         struct ltdb_context *ctx;
1085         int ret;
1086
1087         ctx = talloc_get_type(private_data, struct ltdb_context);
1088
1089         if (!ctx->request_terminated) {
1090                 /* neutralize the spy */
1091                 ctx->spy->ctx = NULL;
1092         } else goto done;
1093
1094         switch (ctx->req->operation) {
1095         case LDB_SEARCH:
1096                 ret = ltdb_search(ctx);
1097                 break;
1098         case LDB_ADD:
1099                 ret = ltdb_add(ctx);
1100                 break;
1101         case LDB_MODIFY:
1102                 ret = ltdb_modify(ctx);
1103                 break;
1104         case LDB_DELETE:
1105                 ret = ltdb_delete(ctx);
1106                 break;
1107         case LDB_RENAME:
1108                 ret = ltdb_rename(ctx);
1109                 break;
1110         case LDB_EXTENDED:
1111                 ltdb_handle_extended(ctx);
1112                 return;
1113         default:
1114                 /* no other op supported */
1115                 ret = LDB_ERR_UNWILLING_TO_PERFORM;
1116         }
1117
1118         if (!ctx->request_terminated) {
1119                 /* request is done now */
1120                 ltdb_request_done(ctx, ret);
1121         }
1122
1123 done:
1124         talloc_free(ctx);
1125 }
1126
1127 static int ltdb_request_destructor(void *ptr)
1128 {
1129         struct ltdb_req_spy *spy = talloc_get_type(ptr, struct ltdb_req_spy);
1130
1131         if (spy->ctx != NULL) {
1132                 spy->ctx->request_terminated = true;
1133         }
1134
1135         return 0;
1136 }
1137
1138 static int ltdb_handle_request(struct ldb_module *module,
1139                                struct ldb_request *req)
1140 {
1141         struct ldb_context *ldb;
1142         struct tevent_context *ev;
1143         struct ltdb_context *ac;
1144         struct tevent_timer *te;
1145         struct timeval tv;
1146
1147         if (check_critical_controls(req->controls)) {
1148                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
1149         }
1150
1151         ldb = ldb_module_get_ctx(module);
1152
1153         if (req->starttime == 0 || req->timeout == 0) {
1154                 ldb_set_errstring(ldb, "Invalid timeout settings");
1155                 return LDB_ERR_TIME_LIMIT_EXCEEDED;
1156         }
1157
1158         ev = ldb_get_event_context(ldb);
1159
1160         ac = talloc_zero(ldb, struct ltdb_context);
1161         if (ac == NULL) {
1162                 ldb_set_errstring(ldb, "Out of Memory");
1163                 return LDB_ERR_OPERATIONS_ERROR;
1164         }
1165
1166         ac->module = module;
1167         ac->req = req;
1168
1169         tv.tv_sec = 0;
1170         tv.tv_usec = 0;
1171         te = tevent_add_timer(ev, ac, tv, ltdb_callback, ac);
1172         if (NULL == te) {
1173                 talloc_free(ac);
1174                 return LDB_ERR_OPERATIONS_ERROR;
1175         }
1176
1177         tv.tv_sec = req->starttime + req->timeout;
1178         ac->timeout_event = tevent_add_timer(ev, ac, tv, ltdb_timeout, ac);
1179         if (NULL == ac->timeout_event) {
1180                 talloc_free(ac);
1181                 return LDB_ERR_OPERATIONS_ERROR;
1182         }
1183
1184         /* set a spy so that we do not try to use the request context
1185          * if it is freed before ltdb_callback fires */
1186         ac->spy = talloc(req, struct ltdb_req_spy);
1187         if (NULL == ac->spy) {
1188                 talloc_free(ac);
1189                 return LDB_ERR_OPERATIONS_ERROR;
1190         }
1191         ac->spy->ctx = ac;
1192
1193         talloc_set_destructor((TALLOC_CTX *)ac->spy, ltdb_request_destructor);
1194
1195         return LDB_SUCCESS;
1196 }
1197
1198 static const struct ldb_module_ops ltdb_ops = {
1199         .name              = "tdb",
1200         .search            = ltdb_handle_request,
1201         .add               = ltdb_handle_request,
1202         .modify            = ltdb_handle_request,
1203         .del               = ltdb_handle_request,
1204         .rename            = ltdb_handle_request,
1205         .extended          = ltdb_handle_request,
1206         .start_transaction = ltdb_start_trans,
1207         .end_transaction   = ltdb_end_trans,
1208         .del_transaction   = ltdb_del_trans,
1209 };
1210
1211 /*
1212   connect to the database
1213 */
1214 static int ltdb_connect(struct ldb_context *ldb, const char *url,
1215                         unsigned int flags, const char *options[],
1216                         struct ldb_module **_module)
1217 {
1218         struct ldb_module *module;
1219         const char *path;
1220         int tdb_flags, open_flags;
1221         struct ltdb_private *ltdb;
1222
1223         /* parse the url */
1224         if (strchr(url, ':')) {
1225                 if (strncmp(url, "tdb://", 6) != 0) {
1226                         ldb_debug(ldb, LDB_DEBUG_ERROR,
1227                                   "Invalid tdb URL '%s'", url);
1228                         return -1;
1229                 }
1230                 path = url+6;
1231         } else {
1232                 path = url;
1233         }
1234
1235         tdb_flags = TDB_DEFAULT | TDB_SEQNUM;
1236
1237         /* check for the 'nosync' option */
1238         if (flags & LDB_FLG_NOSYNC) {
1239                 tdb_flags |= TDB_NOSYNC;
1240         }
1241
1242         /* and nommap option */
1243         if (flags & LDB_FLG_NOMMAP) {
1244                 tdb_flags |= TDB_NOMMAP;
1245         }
1246
1247         if (flags & LDB_FLG_RDONLY) {
1248                 open_flags = O_RDONLY;
1249         } else {
1250                 open_flags = O_CREAT | O_RDWR;
1251         }
1252
1253         ltdb = talloc_zero(ldb, struct ltdb_private);
1254         if (!ltdb) {
1255                 ldb_oom(ldb);
1256                 return -1;
1257         }
1258
1259         /* note that we use quite a large default hash size */
1260         ltdb->tdb = ltdb_wrap_open(ltdb, path, 10000,
1261                                    tdb_flags, open_flags,
1262                                    ldb_get_create_perms(ldb), ldb);
1263         if (!ltdb->tdb) {
1264                 ldb_debug(ldb, LDB_DEBUG_ERROR,
1265                           "Unable to open tdb '%s'\n", path);
1266                 talloc_free(ltdb);
1267                 return -1;
1268         }
1269
1270         ltdb->sequence_number = 0;
1271
1272         module = ldb_module_new(ldb, ldb, "ldb_tdb backend", &ltdb_ops);
1273         if (!module) {
1274                 talloc_free(ltdb);
1275                 return -1;
1276         }
1277         ldb_module_set_private(module, ltdb);
1278
1279         if (ltdb_cache_load(module) != 0) {
1280                 talloc_free(module);
1281                 talloc_free(ltdb);
1282                 return -1;
1283         }
1284
1285         *_module = module;
1286         return 0;
1287 }
1288
1289 const struct ldb_backend_ops ldb_tdb_backend_ops = {
1290         .name = "tdb",
1291         .connect_fn = ltdb_connect
1292 };