b47d79de528879fe3304b39da691445e695a78ec
[samba.git] / source / 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    
7
8      ** NOTE! The following LGPL license applies to the ldb
9      ** library. This does NOT imply that all of Samba is released
10      ** under the LGPL
11    
12    This library is free software; you can redistribute it and/or
13    modify it under the terms of the GNU Lesser General Public
14    License as published by the Free Software Foundation; either
15    version 2 of the License, or (at your option) any later version.
16
17    This library is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20    Lesser General Public License for more details.
21
22    You should have received a copy of the GNU Lesser General Public
23    License along with this library; if not, write to the Free Software
24    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25 */
26
27 /*
28  *  Name: ldb
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
38 #include "includes.h"
39 #include "ldb/include/ldb.h"
40 #include "ldb/include/ldb_private.h"
41 #include "ldb/ldb_tdb/ldb_tdb.h"
42
43 #define LDBLOCK "INT_LDBLOCK"
44
45
46 /*
47   casefold a dn. We need to uppercase the attribute names, and the 
48   attribute values of case insensitive attributes. We also need to remove
49   extraneous spaces between elements
50 */
51 static char *ltdb_dn_fold(struct ldb_module *module, const char *dn)
52 {
53         const char *dn_orig = dn;
54         struct ldb_context *ldb = module->ldb;
55         TALLOC_CTX *tmp_ctx = talloc_new(ldb);
56         char *ret;
57         size_t len;
58
59         ret = talloc_strdup(tmp_ctx, "");
60         if (ret == NULL) goto failed;
61
62         while ((len = strcspn(dn, ",")) > 0) {
63                 char *p = strchr(dn, '=');
64                 char *attr, *value;
65                 int flags;
66
67                 if (p == NULL || (p-dn) > len) goto failed;
68
69                 attr = talloc_strndup(tmp_ctx, dn, p-dn);
70                 if (attr == NULL) goto failed;
71
72                 /* trim spaces from the attribute name */
73                 while (' ' == *attr) attr++;
74                 while (' ' == attr[strlen(attr)-1]) {
75                         attr[strlen(attr)-1] = 0;
76                 }
77                 if (*attr == 0) goto failed;
78
79                 value = talloc_strndup(tmp_ctx, p+1, len-(p+1-dn));
80                 if (value == NULL) goto failed;
81
82                 /* trim spaces from the value */
83                 while (' ' == *value) value++;
84                 while (' ' == value[strlen(value)-1]) {
85                         value[strlen(value)-1] = 0;
86                 }
87                 if (*value == 0) goto failed;
88
89                 flags = ltdb_attribute_flags(module, attr);
90
91                 attr = ldb_casefold(ldb, attr);
92                 if (attr == NULL) goto failed;
93                 talloc_steal(tmp_ctx, attr);
94
95                 if (flags & LTDB_FLAG_CASE_INSENSITIVE) {
96                         value = ldb_casefold(ldb, value);
97                         if (value == NULL) goto failed;
98                         talloc_steal(tmp_ctx, value);
99                 }               
100
101                 if (dn[len] == ',') {
102                         ret = talloc_asprintf_append(ret, "%s=%s,", attr, value);
103                 } else {
104                         ret = talloc_asprintf_append(ret, "%s=%s", attr, value);
105                 }
106                 if (ret == NULL) goto failed;
107
108                 dn += len;
109                 if (*dn == ',') dn++;
110         }
111
112         talloc_steal(ldb, ret);
113         talloc_free(tmp_ctx);
114         return ret;
115
116 failed:
117         talloc_free(tmp_ctx);
118         return ldb_casefold(ldb, dn_orig);
119 }
120
121 /*
122   form a TDB_DATA for a record key
123   caller frees
124
125   note that the key for a record can depend on whether the 
126   dn refers to a case sensitive index record or not
127 */
128 struct TDB_DATA ltdb_key(struct ldb_module *module, const char *dn)
129 {
130         struct ldb_context *ldb = module->ldb;
131         TDB_DATA key;
132         char *key_str = NULL;
133         char *dn_folded = NULL;
134         const char *prefix = LTDB_INDEX ":";
135         const char *s;
136         int flags;
137
138         /*
139           most DNs are case insensitive. The exception is index DNs for
140           case sensitive attributes
141
142           there are 3 cases dealt with in this code:
143
144           1) if the dn doesn't start with @INDEX: then uppercase the attribute
145              names and the attributes values of case insensitive attributes
146           2) if the dn starts with @INDEX:attr and 'attr' is a case insensitive
147              attribute then uppercase whole dn
148           3) if the dn starts with @INDEX:attr and 'attr' is a case sensitive
149              attribute then uppercase up to the value of the attribute, but 
150              not the value itself
151         */
152         if (strncmp(dn, prefix, strlen(prefix)) == 0 &&
153             (s = strchr(dn+strlen(prefix), ':'))) {
154                 char *attr_name, *attr_name_folded;
155                 attr_name = talloc_strndup(ldb, dn+strlen(prefix), (s-(dn+strlen(prefix))));
156                 if (!attr_name) {
157                         goto failed;
158                 }
159                 flags = ltdb_attribute_flags(module, attr_name);
160                 
161                 if (flags & LTDB_FLAG_CASE_INSENSITIVE) {
162                         dn_folded = ldb_casefold(ldb, dn);
163                 } else {
164                         attr_name_folded = ldb_casefold(ldb, attr_name);
165                         if (!attr_name_folded) {
166                                 goto failed;
167                         }
168                         dn_folded = talloc_asprintf(ldb, "%s:%s:%s",
169                                                     prefix, attr_name_folded,
170                                                     s+1);
171                         talloc_free(attr_name_folded);
172                 }
173                 talloc_free(attr_name);
174         } else {
175                 dn_folded = ltdb_dn_fold(module, dn);
176         }
177
178         if (!dn_folded) {
179                 goto failed;
180         }
181
182         key_str = talloc_asprintf(ldb, "DN=%s", dn_folded);
183         talloc_free(dn_folded);
184
185         if (!key_str) {
186                 goto failed;
187         }
188
189         key.dptr = key_str;
190         key.dsize = strlen(key_str)+1;
191
192         return key;
193
194 failed:
195         errno = ENOMEM;
196         key.dptr = NULL;
197         key.dsize = 0;
198         return key;
199 }
200
201 /*
202   lock the database for write - currently a single lock is used
203 */
204 static int ltdb_lock(struct ldb_module *module, const char *lockname)
205 {
206         struct ltdb_private *ltdb = module->private_data;
207         TDB_DATA key;
208         int ret;
209
210         if (lockname == NULL) {
211                 return -1;
212         }
213
214         key = ltdb_key(module, lockname);
215         if (!key.dptr) {
216                 return -1;
217         }
218
219         ret = tdb_chainlock(ltdb->tdb, key);
220
221         talloc_free(key.dptr);
222
223         return ret;
224 }
225
226 /*
227   unlock the database after a ltdb_lock()
228 */
229 static int ltdb_unlock(struct ldb_module *module, const char *lockname)
230 {
231         struct ltdb_private *ltdb = module->private_data;
232         TDB_DATA key;
233
234         if (lockname == NULL) {
235                 return -1;
236         }
237
238         key = ltdb_key(module, lockname);
239         if (!key.dptr) {
240                 return -1;
241         }
242
243         tdb_chainunlock(ltdb->tdb, key);
244
245         talloc_free(key.dptr);
246
247         return 0;
248 }
249
250
251 /*
252   lock the database for read - use by ltdb_search
253 */
254 int ltdb_lock_read(struct ldb_module *module)
255 {
256         struct ltdb_private *ltdb = module->private_data;
257         TDB_DATA key;
258         int ret;
259         key = ltdb_key(module, LDBLOCK);
260         if (!key.dptr) {
261                 return -1;
262         }
263         ret = tdb_chainlock_read(ltdb->tdb, key);
264         talloc_free(key.dptr);
265         return ret;
266 }
267
268 /*
269   unlock the database after a ltdb_lock_read()
270 */
271 int ltdb_unlock_read(struct ldb_module *module)
272 {
273         struct ltdb_private *ltdb = module->private_data;
274         TDB_DATA key;
275         key = ltdb_key(module, LDBLOCK);
276         if (!key.dptr) {
277                 return -1;
278         }
279         tdb_chainunlock_read(ltdb->tdb, key);
280         talloc_free(key.dptr);
281         return 0;
282 }
283
284
285 /*
286   we've made a modification to a dn - possibly reindex and 
287   update sequence number
288 */
289 static int ltdb_modified(struct ldb_module *module, const char *dn)
290 {
291         int ret = 0;
292
293         if (strcmp(dn, LTDB_INDEXLIST) == 0 ||
294             strcmp(dn, LTDB_ATTRIBUTES) == 0) {
295                 ret = ltdb_reindex(module);
296         }
297
298         if (ret == 0 &&
299             strcmp(dn, LTDB_BASEINFO) != 0) {
300                 ret = ltdb_increase_sequence_number(module);
301         }
302
303         return ret;
304 }
305
306 /*
307   store a record into the db
308 */
309 int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs)
310 {
311         struct ltdb_private *ltdb = module->private_data;
312         TDB_DATA tdb_key, tdb_data;
313         int ret;
314
315         tdb_key = ltdb_key(module, msg->dn);
316         if (!tdb_key.dptr) {
317                 return -1;
318         }
319
320         ret = ltdb_pack_data(module, msg, &tdb_data);
321         if (ret == -1) {
322                 talloc_free(tdb_key.dptr);
323                 return -1;
324         }
325
326         ret = tdb_store(ltdb->tdb, tdb_key, tdb_data, flgs);
327         if (ret == -1) {
328                 goto done;
329         }
330         
331         ret = ltdb_index_add(module, msg);
332         if (ret == -1) {
333                 tdb_delete(ltdb->tdb, tdb_key);
334         }
335
336 done:
337         talloc_free(tdb_key.dptr);
338         talloc_free(tdb_data.dptr);
339
340         return ret;
341 }
342
343
344 /*
345   add a record to the database
346 */
347 static int ltdb_add(struct ldb_module *module, const struct ldb_message *msg)
348 {
349         struct ltdb_private *ltdb = module->private_data;
350         int ret;
351
352         ltdb->last_err_string = NULL;
353
354         if (ltdb_lock(module, LDBLOCK) != 0) {
355                 return -1;
356         }
357
358         if (ltdb_cache_load(module) != 0) {
359                 ltdb_unlock(module, LDBLOCK);
360                 return -1;
361         }
362         
363         ret = ltdb_store(module, msg, TDB_INSERT);
364
365         if (ret == 0) {
366                 ltdb_modified(module, msg->dn);
367         }
368
369         ltdb_unlock(module, LDBLOCK);
370         return ret;
371 }
372
373
374 /*
375   delete a record from the database, not updating indexes (used for deleting
376   index records)
377 */
378 int ltdb_delete_noindex(struct ldb_module *module, const char *dn)
379 {
380         struct ltdb_private *ltdb = module->private_data;
381         TDB_DATA tdb_key;
382         int ret;
383
384         tdb_key = ltdb_key(module, dn);
385         if (!tdb_key.dptr) {
386                 return -1;
387         }
388
389         ret = tdb_delete(ltdb->tdb, tdb_key);
390         talloc_free(tdb_key.dptr);
391
392         return ret;
393 }
394
395 /*
396   delete a record from the database
397 */
398 static int ltdb_delete(struct ldb_module *module, const char *dn)
399 {
400         struct ltdb_private *ltdb = module->private_data;
401         int ret;
402         struct ldb_message *msg = NULL;
403
404         ltdb->last_err_string = NULL;
405
406         if (ltdb_lock(module, LDBLOCK) != 0) {
407                 return -1;
408         }
409
410         if (ltdb_cache_load(module) != 0) {
411                 goto failed;
412         }
413
414         msg = talloc(module, struct ldb_message);
415         if (msg == NULL) {
416                 goto failed;
417         }
418
419         /* in case any attribute of the message was indexed, we need
420            to fetch the old record */
421         ret = ltdb_search_dn1(module, dn, msg);
422         if (ret != 1) {
423                 /* not finding the old record is an error */
424                 goto failed;
425         }
426
427         ret = ltdb_delete_noindex(module, dn);
428         if (ret == -1) {
429                 goto failed;
430         }
431
432         /* remove any indexed attributes */
433         ret = ltdb_index_del(module, msg);
434
435         if (ret == 0) {
436                 ltdb_modified(module, dn);
437         }
438
439         talloc_free(msg);
440         ltdb_unlock(module, LDBLOCK);
441         return ret;
442
443 failed:
444         talloc_free(msg);
445         ltdb_unlock(module, LDBLOCK);
446         return -1;
447 }
448
449
450 /*
451   find an element by attribute name. At the moment this does a linear search, it should
452   be re-coded to use a binary search once all places that modify records guarantee
453   sorted order
454
455   return the index of the first matching element if found, otherwise -1
456 */
457 static int find_element(const struct ldb_message *msg, const char *name)
458 {
459         unsigned int i;
460         for (i=0;i<msg->num_elements;i++) {
461                 if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
462                         return i;
463                 }
464         }
465         return -1;
466 }
467
468
469 /*
470   add an element to an existing record. Assumes a elements array that we
471   can call re-alloc on, and assumed that we can re-use the data pointers from the 
472   passed in additional values. Use with care!
473
474   returns 0 on success, -1 on failure (and sets errno)
475 */
476 static int msg_add_element(struct ldb_context *ldb,
477                            struct ldb_message *msg, struct ldb_message_element *el)
478 {
479         struct ldb_message_element *e2;
480         unsigned int i;
481
482         e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element, 
483                               msg->num_elements+1);
484         if (!e2) {
485                 errno = ENOMEM;
486                 return -1;
487         }
488
489         msg->elements = e2;
490
491         e2 = &msg->elements[msg->num_elements];
492
493         e2->name = el->name;
494         e2->flags = el->flags;
495         e2->values = NULL;
496         if (el->num_values != 0) {
497                 e2->values = talloc_array(msg->elements, struct ldb_val, el->num_values);
498                 if (!e2->values) {
499                         errno = ENOMEM;
500                         return -1;
501                 }
502         }
503         for (i=0;i<el->num_values;i++) {
504                 e2->values[i] = el->values[i];
505         }
506         e2->num_values = el->num_values;
507
508         msg->num_elements++;
509
510         return 0;
511 }
512
513 /*
514   delete all elements having a specified attribute name
515 */
516 static int msg_delete_attribute(struct ldb_module *module,
517                                 struct ldb_context *ldb,
518                                 struct ldb_message *msg, const char *name)
519 {
520         unsigned int i, j;
521
522         for (i=0;i<msg->num_elements;i++) {
523                 if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
524                         for (j=0;j<msg->elements[i].num_values;j++) {
525                                 ltdb_index_del_value(module, msg->dn, &msg->elements[i], j);
526                         }
527                         talloc_free(msg->elements[i].values);
528                         if (msg->num_elements > (i+1)) {
529                                 memmove(&msg->elements[i], 
530                                         &msg->elements[i+1], 
531                                         sizeof(struct ldb_message_element)*
532                                         (msg->num_elements - (i+1)));
533                         }
534                         msg->num_elements--;
535                         i--;
536                         msg->elements = talloc_realloc(msg, msg->elements, 
537                                                          struct ldb_message_element, 
538                                                          msg->num_elements);
539                 }
540         }
541
542         return 0;
543 }
544
545 /*
546   delete all elements matching an attribute name/value 
547
548   return 0 on success, -1 on failure
549 */
550 static int msg_delete_element(struct ldb_module *module,
551                               struct ldb_message *msg, 
552                               const char *name,
553                               const struct ldb_val *val)
554 {
555         struct ldb_context *ldb = module->ldb;
556         unsigned int i;
557         int found;
558         struct ldb_message_element *el;
559
560         found = find_element(msg, name);
561         if (found == -1) {
562                 return -1;
563         }
564
565         el = &msg->elements[found];
566
567         for (i=0;i<el->num_values;i++) {
568                 if (ltdb_val_equal(module, msg->elements[i].name, &el->values[i], val)) {
569                         if (i<el->num_values-1) {
570                                 memmove(&el->values[i], &el->values[i+1],
571                                         sizeof(el->values[i])*(el->num_values-(i+1)));
572                         }
573                         el->num_values--;
574                         if (el->num_values == 0) {
575                                 return msg_delete_attribute(module, ldb, msg, name);
576                         }
577                         return 0;
578                 }
579         }
580
581         return -1;
582 }
583
584
585 /*
586   modify a record - internal interface
587
588   yuck - this is O(n^2). Luckily n is usually small so we probably
589   get away with it, but if we ever have really large attribute lists 
590   then we'll need to look at this again
591 */
592 int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *msg)
593 {
594         struct ldb_context *ldb = module->ldb;
595         struct ltdb_private *ltdb = module->private_data;
596         TDB_DATA tdb_key, tdb_data;
597         struct ldb_message *msg2;
598         unsigned i, j;
599         int ret;
600
601         tdb_key = ltdb_key(module, msg->dn);
602         if (!tdb_key.dptr) {
603                 return -1;
604         }
605
606         tdb_data = tdb_fetch(ltdb->tdb, tdb_key);
607         if (!tdb_data.dptr) {
608                 talloc_free(tdb_key.dptr);
609                 return -1;
610         }
611
612         msg2 = talloc(tdb_key.dptr, struct ldb_message);
613         if (msg2 == NULL) {
614                 talloc_free(tdb_key.dptr);
615                 return -1;
616         }
617
618         ret = ltdb_unpack_data(module, &tdb_data, msg2);
619         if (ret == -1) {
620                 talloc_free(tdb_key.dptr);
621                 free(tdb_data.dptr);
622                 return -1;
623         }
624
625         if (!msg2->dn) {
626                 msg2->dn = msg->dn;
627         }
628
629         for (i=0;i<msg->num_elements;i++) {
630                 struct ldb_message_element *el = &msg->elements[i];
631                 struct ldb_message_element *el2;
632                 struct ldb_val *vals;
633
634                 switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
635
636                 case LDB_FLAG_MOD_ADD:
637                         /* add this element to the message. fail if it
638                            already exists */
639                         ret = find_element(msg2, el->name);
640
641                         if (ret == -1) {
642                                 if (msg_add_element(ldb, msg2, el) != 0) {
643                                         goto failed;
644                                 }
645                                 continue;
646                         }
647
648                         el2 = &msg2->elements[ret];
649
650                         /* An attribute with this name already exists, add all
651                          * values if they don't already exist. */
652
653                         for (j=0;j<el->num_values;j++) {
654                                 if (ldb_msg_find_val(el2, &el->values[j])) {
655                                         ltdb->last_err_string =
656                                                 "Type or value exists";
657                                         goto failed;
658                                 }
659                         }
660
661                         vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
662                                                 el2->num_values + el->num_values);
663
664                         if (vals == NULL)
665                                 goto failed;
666
667                         for (j=0;j<el->num_values;j++) {
668                                 vals[el2->num_values + j] =
669                                         ldb_val_dup(vals, &el->values[j]);
670                         }
671
672                         el2->values = vals;
673                         el2->num_values += el->num_values;
674
675                         break;
676
677                 case LDB_FLAG_MOD_REPLACE:
678                         /* replace all elements of this attribute name with the elements
679                            listed. The attribute not existing is not an error */
680                         msg_delete_attribute(module, ldb, msg2, msg->elements[i].name);
681
682                         /* add the replacement element, if not empty */
683                         if (msg->elements[i].num_values != 0 &&
684                             msg_add_element(ldb, msg2, &msg->elements[i]) != 0) {
685                                 goto failed;
686                         }
687                         break;
688
689                 case LDB_FLAG_MOD_DELETE:
690                         /* we could be being asked to delete all
691                            values or just some values */
692                         if (msg->elements[i].num_values == 0) {
693                                 if (msg_delete_attribute(module, ldb, msg2, 
694                                                          msg->elements[i].name) != 0) {
695                                         ltdb->last_err_string = "No such attribute";
696                                         goto failed;
697                                 }
698                                 break;
699                         }
700                         for (j=0;j<msg->elements[i].num_values;j++) {
701                                 if (msg_delete_element(module,
702                                                        msg2, 
703                                                        msg->elements[i].name,
704                                                        &msg->elements[i].values[j]) != 0) {
705                                         ltdb->last_err_string = "No such attribute";
706                                         goto failed;
707                                 }
708                                 if (ltdb_index_del_value(module, msg->dn, &msg->elements[i], j) != 0) {
709                                         goto failed;
710                                 }
711                         }
712                         break;
713                 }
714         }
715
716         /* we've made all the mods - save the modified record back into the database */
717         ret = ltdb_store(module, msg2, TDB_MODIFY);
718
719         talloc_free(tdb_key.dptr);
720         free(tdb_data.dptr);
721         return ret;
722
723 failed:
724         talloc_free(tdb_key.dptr);
725         free(tdb_data.dptr);
726         return -1;
727 }
728
729 /*
730   modify a record
731 */
732 static int ltdb_modify(struct ldb_module *module, const struct ldb_message *msg)
733 {
734         struct ltdb_private *ltdb = module->private_data;
735         int ret;
736
737         ltdb->last_err_string = NULL;
738
739         if (ltdb_lock(module, LDBLOCK) != 0) {
740                 return -1;
741         }
742
743         if (ltdb_cache_load(module) != 0) {
744                 ltdb_unlock(module, LDBLOCK);
745                 return -1;
746         }
747
748         ret = ltdb_modify_internal(module, msg);
749
750         if (ret == 0) {
751                 ltdb_modified(module, msg->dn);
752         }
753
754         ltdb_unlock(module, LDBLOCK);
755
756         return ret;
757 }
758
759 /*
760   rename a record
761 */
762 static int ltdb_rename(struct ldb_module *module, const char *olddn, const char *newdn)
763 {
764         struct ltdb_private *ltdb = module->private_data;
765         int ret;
766         struct ldb_message *msg;
767         const char *error_str;
768
769         ltdb->last_err_string = NULL;
770
771         if (ltdb_lock(module, LDBLOCK) != 0) {
772                 return -1;
773         }
774
775         msg = talloc(module, struct ldb_message);
776         if (msg == NULL) {
777                 goto failed;
778         }
779
780         /* in case any attribute of the message was indexed, we need
781            to fetch the old record */
782         ret = ltdb_search_dn1(module, olddn, msg);
783         if (ret != 1) {
784                 /* not finding the old record is an error */
785                 goto failed;
786         }
787
788         msg->dn = talloc_strdup(msg, newdn);
789         if (!msg->dn) {
790                 goto failed;
791         }
792
793         ret = ltdb_add(module, msg);
794         if (ret == -1) {
795                 goto failed;
796         }
797
798         ret = ltdb_delete(module, olddn);
799         error_str = ltdb->last_err_string;
800         if (ret == -1) {
801                 ltdb_delete(module, newdn);
802         }
803
804         ltdb->last_err_string = error_str;
805
806         talloc_free(msg);
807         ltdb_unlock(module, LDBLOCK);
808
809         return ret;
810
811 failed:
812         talloc_free(msg);
813         ltdb_unlock(module, LDBLOCK);
814         return -1;
815 }
816
817
818 /*
819   return extended error information
820 */
821 static const char *ltdb_errstring(struct ldb_module *module)
822 {
823         struct ltdb_private *ltdb = module->private_data;
824         if (ltdb->last_err_string) {
825                 return ltdb->last_err_string;
826         }
827         return tdb_errorstr(ltdb->tdb);
828 }
829
830
831 static const struct ldb_module_ops ltdb_ops = {
832         "tdb",
833         ltdb_search,
834         ltdb_add,
835         ltdb_modify,
836         ltdb_delete,
837         ltdb_rename,
838         ltdb_lock,
839         ltdb_unlock,
840         ltdb_errstring
841 };
842
843
844 /*
845   destroy the ltdb context
846 */
847 static int ltdb_destructor(void *p)
848 {
849         struct ltdb_private *ltdb = p;
850         tdb_close(ltdb->tdb);
851         return 0;
852 }
853
854 /*
855   connect to the database
856 */
857 struct ldb_context *ltdb_connect(const char *url, 
858                                  unsigned int flags, 
859                                  const char *options[])
860 {
861         const char *path;
862         int tdb_flags, open_flags;
863         struct ltdb_private *ltdb;
864         TDB_CONTEXT *tdb;
865         struct ldb_context *ldb;
866
867         ldb = talloc_zero(NULL, struct ldb_context);
868         if (!ldb) {
869                 errno = ENOMEM;
870                 return NULL;
871         }
872
873         /* parse the url */
874         if (strchr(url, ':')) {
875                 if (strncmp(url, "tdb://", 6) != 0) {
876                         errno = EINVAL;
877                         talloc_free(ldb);
878                         return NULL;
879                 }
880                 path = url+6;
881         } else {
882                 path = url;
883         }
884
885         tdb_flags = TDB_DEFAULT;
886
887         if (flags & LDB_FLG_RDONLY) {
888                 open_flags = O_RDONLY;
889         } else {
890                 open_flags = O_CREAT | O_RDWR;
891         }
892
893         /* note that we use quite a large default hash size */
894         tdb = tdb_open(path, 10000, tdb_flags, open_flags, 0666);
895         if (!tdb) {
896                 talloc_free(ldb);
897                 return NULL;
898         }
899
900         ltdb = talloc_zero(ldb, struct ltdb_private);
901         if (!ltdb) {
902                 tdb_close(tdb);
903                 talloc_free(ldb);
904                 errno = ENOMEM;
905                 return NULL;
906         }
907
908         ltdb->tdb = tdb;
909         ltdb->sequence_number = 0;
910
911         talloc_set_destructor(ltdb, ltdb_destructor);
912
913         ldb->modules = talloc(ldb, struct ldb_module);
914         if (!ldb->modules) {
915                 talloc_free(ldb);
916                 errno = ENOMEM;
917                 return NULL;
918         }
919         ldb->modules->ldb = ldb;
920         ldb->modules->prev = ldb->modules->next = NULL;
921         ldb->modules->private_data = ltdb;
922         ldb->modules->ops = &ltdb_ops;
923
924         return ldb;
925 }