9ab683016161596ac658fa02fd2be12e5f3731a4
[ira/wip.git] / source4 / dsdb / samdb / ldb_modules / samldb.c
1 /* 
2    SAM ldb module
3
4    Copyright (C) Simo Sorce  2004
5
6    * NOTICE: this module is NOT released under the GNU LGPL license as
7    * other ldb code. This module is release under the GNU GPL v2 or
8    * later license.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 /*
26  *  Name: ldb
27  *
28  *  Component: ldb samldb module
29  *
30  *  Description: add embedded user/group creation functionality
31  *
32  *  Author: Simo Sorce
33  */
34
35 #include "includes.h"
36 #include "lib/ldb/include/ldb.h"
37 #include "lib/ldb/include/ldb_private.h"
38 #include "system/time.h"
39 #include "librpc/gen_ndr/ndr_security.h"
40
41 #define SAM_ACCOUNT_NAME_BASE "$000000-000000000000"
42
43 struct private_data {
44         const char *error_string;
45 };
46
47 static int samldb_search(struct ldb_module *module, const struct ldb_dn *base,
48                                   enum ldb_scope scope, const char *expression,
49                                   const char * const *attrs, struct ldb_message ***res)
50 {
51         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_search\n");
52         return ldb_next_search(module, base, scope, expression, attrs, res);
53 }
54
55 static int samldb_search_bytree(struct ldb_module *module, const struct ldb_dn *base,
56                                 enum ldb_scope scope, struct ldb_parse_tree *tree,
57                                 const char * const *attrs, struct ldb_message ***res)
58 {
59         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_search\n");
60         return ldb_next_search_bytree(module, base, scope, tree, attrs, res);
61 }
62
63 /*
64   allocate a new id, attempting to do it atomically
65   return 0 on failure, the id on success
66 */
67 static int samldb_allocate_next_rid(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
68                                    const struct ldb_dn *dn, uint32_t *id)
69 {
70         const char * const attrs[2] = { "nextRid", NULL };
71         struct ldb_message **res = NULL;
72         struct ldb_message msg;
73         int ret;
74         const char *str;
75         struct ldb_val vals[2];
76         struct ldb_message_element els[2];
77
78         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, "nextRid=*", attrs, &res);
79         if (ret != 1) {
80                 if (res) talloc_free(res);
81                 return -1;
82         }
83         str = ldb_msg_find_string(res[0], "nextRid", NULL);
84         if (str == NULL) {
85                 ldb_debug(ldb, LDB_DEBUG_FATAL, "attribute nextRid not found in %s\n", ldb_dn_linearize(res, dn));
86                 talloc_free(res);
87                 return -1;
88         }
89
90         *id = strtol(str, NULL, 0);
91         if ((*id)+1 == 0) {
92                 /* out of IDs ! */
93                 ldb_debug(ldb, LDB_DEBUG_FATAL, "Are we out of valid IDs ?\n");
94                 talloc_free(res);
95                 return -1;
96         }
97         talloc_free(res);
98
99         /* we do a delete and add as a single operation. That prevents
100            a race */
101         ZERO_STRUCT(msg);
102         msg.dn = ldb_dn_copy(mem_ctx, dn);
103         if (!msg.dn) {
104                 return -1;
105         }
106         msg.num_elements = 2;
107         msg.elements = els;
108
109         els[0].num_values = 1;
110         els[0].values = &vals[0];
111         els[0].flags = LDB_FLAG_MOD_DELETE;
112         els[0].name = talloc_strdup(mem_ctx, "nextRid");
113         if (!els[0].name) {
114                 return -1;
115         }
116
117         els[1].num_values = 1;
118         els[1].values = &vals[1];
119         els[1].flags = LDB_FLAG_MOD_ADD;
120         els[1].name = els[0].name;
121
122         vals[0].data = talloc_asprintf(mem_ctx, "%u", *id);
123         if (!vals[0].data) {
124                 return -1;
125         }
126         vals[0].length = strlen(vals[0].data);
127
128         vals[1].data = talloc_asprintf(mem_ctx, "%u", (*id)+1);
129         if (!vals[1].data) {
130                 return -1;
131         }
132         vals[1].length = strlen(vals[1].data);
133
134         ret = ldb_modify(ldb, &msg);
135         if (ret != 0) {
136                 return 1;
137         }
138
139         (*id)++;
140
141         return 0;
142 }
143
144 static struct ldb_dn *samldb_search_domain(struct ldb_module *module, TALLOC_CTX *mem_ctx, const struct ldb_dn *dn)
145 {
146         TALLOC_CTX *local_ctx;
147         struct ldb_dn *sdn;
148         struct ldb_message **res = NULL;
149         int ret = 0;
150
151         local_ctx = talloc_named(mem_ctx, 0, "samldb_search_domain memory conext");
152         if (local_ctx == NULL) return NULL;
153
154         sdn = ldb_dn_copy(local_ctx, dn);
155         do {
156                 ret = ldb_search(module->ldb, sdn, LDB_SCOPE_BASE, "objectClass=domain", NULL, &res);
157                 talloc_free(res);
158
159                 if (ret == 1)
160                         break;
161
162         } while ((sdn = ldb_dn_get_parent(local_ctx, sdn)));
163
164         if (ret != 1) {
165                 talloc_free(local_ctx);
166                 return NULL;
167         }
168
169         talloc_steal(mem_ctx, sdn);
170         talloc_free(local_ctx);
171
172         return sdn;
173 }
174
175 /* search the domain related to the provided dn
176    allocate a new RID for the domain
177    return the new sid string
178 */
179 static struct dom_sid *samldb_get_new_sid(struct ldb_module *module, 
180                                           TALLOC_CTX *mem_ctx, const struct ldb_dn *obj_dn)
181 {
182         const char * const attrs[2] = { "objectSid", NULL };
183         struct ldb_message **res = NULL;
184         const struct ldb_dn *dom_dn;
185         uint32_t rid;
186         int ret, tries = 10;
187         struct dom_sid *dom_sid, *obj_sid;
188
189         /* get the domain component part of the provided dn */
190
191         /* FIXME: quick search here, I think we should use something like
192            ldap_parse_dn here to be 100% sure we get the right domain dn */
193
194         /* FIXME: "dc=" is probably not utf8 safe either,
195            we need a multibyte safe substring search function here */
196         
197         dom_dn = samldb_search_domain(module, mem_ctx, obj_dn);
198         if (dom_dn == NULL) {
199                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Invalid dn (%s) not child of a domain object!\n", ldb_dn_linearize(mem_ctx, obj_dn));
200                 return NULL;
201         }
202
203         /* find the domain sid */
204
205         ret = ldb_search(module->ldb, dom_dn, LDB_SCOPE_BASE, "objectSid=*", attrs, &res);
206         if (ret != 1) {
207                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_get_new_sid: error retrieving domain sid!\n");
208                 talloc_free(res);
209                 return NULL;
210         }
211
212         dom_sid = samdb_result_dom_sid(res, res[0], "objectSid");
213         if (dom_sid == NULL) {
214                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_get_new_sid: error retrieving domain sid!\n");
215                 talloc_free(res);
216                 return NULL;
217         }
218
219         /* allocate a new Rid for the domain */
220
221         /* we need to try multiple times to cope with two account
222            creations at the same time */
223         while (tries--) {
224                 ret = samldb_allocate_next_rid(module->ldb, mem_ctx, dom_dn, &rid);
225                 if (ret != 1) {
226                         break;
227                 }
228         }
229         if (ret != 0) {
230                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Failed to increment nextRid of %s\n", ldb_dn_linearize(mem_ctx, dom_dn));
231                 talloc_free(res);
232                 return NULL;
233         }
234
235         /* return the new object sid */
236         obj_sid = dom_sid_add_rid(mem_ctx, dom_sid, rid);
237
238         talloc_free(res);
239
240         return obj_sid;
241 }
242
243 static char *samldb_generate_samAccountName(const void *mem_ctx) {
244         char *name;
245
246         name = talloc_strdup(mem_ctx, SAM_ACCOUNT_NAME_BASE);
247         /* TODO: randomize name */      
248
249         return name;
250 }
251
252 /* if value is not null also check for attribute to have exactly that value */
253 static struct ldb_message_element *samldb_find_attribute(const struct ldb_message *msg, const char *name, const char *value)
254 {
255         int i, j;
256
257         for (i = 0; i < msg->num_elements; i++) {
258                 if (ldb_attr_cmp(name, msg->elements[i].name) == 0) {
259                         if (!value) {
260                                 return &msg->elements[i];
261                         }
262                         for (j = 0; j < msg->elements[i].num_values; j++) {
263                                 if (strcasecmp(value, msg->elements[i].values[j].data) == 0) {
264                                         return &msg->elements[i];
265                                 }
266                         }
267                 }
268         }
269
270         return NULL;
271 }
272
273 static BOOL samldb_msg_add_string(struct ldb_module *module, struct ldb_message *msg, const char *name, const char *value)
274 {
275         char *aname = talloc_strdup(msg, name);
276         char *aval = talloc_strdup(msg, value);
277
278         if (aname == NULL || aval == NULL) {
279                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_msg_add_string: talloc_strdup failed!\n");
280                 return False;
281         }
282
283         if (ldb_msg_add_string(module->ldb, msg, aname, aval) != 0) {
284                 return False;
285         }
286
287         return True;
288 }
289
290 static BOOL samldb_msg_add_sid(struct ldb_module *module, struct ldb_message *msg, const char *name, const struct dom_sid *sid)
291 {
292         struct ldb_val v;
293         NTSTATUS status;
294         status = ndr_push_struct_blob(&v, msg, sid, 
295                                       (ndr_push_flags_fn_t)ndr_push_dom_sid);
296         if (!NT_STATUS_IS_OK(status)) {
297                 return -1;
298         }
299         return (ldb_msg_add_value(module->ldb, msg, name, &v) == 0);
300 }
301
302 static BOOL samldb_find_or_add_attribute(struct ldb_module *module, struct ldb_message *msg, const char *name, const char *value, const char *set_value)
303 {
304         if (samldb_find_attribute(msg, name, value) == NULL) {
305                 return samldb_msg_add_string(module, msg, name, set_value);
306         }
307         return True;
308 }
309
310 static int samldb_copy_template(struct ldb_module *module, struct ldb_message *msg, const char *filter)
311 {
312         struct ldb_message **res, *t;
313         int ret, i, j;
314         
315
316         /* pull the template record */
317         ret = ldb_search(module->ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &res);
318         if (ret != 1) {
319                 ldb_debug(module->ldb, LDB_DEBUG_WARNING, "samldb: ERROR: template '%s' matched %d records\n", filter, ret);
320                 return -1;
321         }
322         t = res[0];
323
324         for (i = 0; i < t->num_elements; i++) {
325                 struct ldb_message_element *el = &t->elements[i];
326                 /* some elements should not be copied from the template */
327                 if (strcasecmp(el->name, "cn") == 0 ||
328                     strcasecmp(el->name, "name") == 0 ||
329                     strcasecmp(el->name, "sAMAccountName") == 0 ||
330                     strcasecmp(el->name, "objectGUID") == 0) {
331                         continue;
332                 }
333                 for (j = 0; j < el->num_values; j++) {
334                         if (strcasecmp(el->name, "objectClass") == 0 &&
335                             (strcasecmp((char *)el->values[j].data, "Template") == 0 ||
336                              strcasecmp((char *)el->values[j].data, "userTemplate") == 0 ||
337                              strcasecmp((char *)el->values[j].data, "groupTemplate") == 0 ||
338                              strcasecmp((char *)el->values[j].data, "foreignSecurityPrincipalTemplate") == 0 ||
339                              strcasecmp((char *)el->values[j].data, "aliasTemplate") == 0 || 
340                              strcasecmp((char *)el->values[j].data, "trustedDomainTemplate") == 0 || 
341                              strcasecmp((char *)el->values[j].data, "secretTemplate") == 0)) {
342                                 continue;
343                         }
344                         if ( ! samldb_find_or_add_attribute(module, msg, el->name, 
345                                                             NULL,
346                                                             (char *)el->values[j].data)) {
347                                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Attribute adding failed...\n");
348                                 talloc_free(res);
349                                 return -1;
350                         }
351                 }
352         }
353
354         talloc_free(res);
355
356         return 0;
357 }
358
359 static struct ldb_message *samldb_fill_group_object(struct ldb_module *module, const struct ldb_message *msg)
360 {
361         struct ldb_message *msg2;
362         struct ldb_message_element *attribute;
363         struct ldb_dn_component *rdn;
364
365         if (samldb_find_attribute(msg, "objectclass", "group") == NULL) {
366                 return NULL;
367         }
368
369         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_fill_group_object\n");
370
371         /* build the new msg */
372         msg2 = ldb_msg_copy(module->ldb, msg);
373         if (!msg2) {
374                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_group_object: ldb_msg_copy failed!\n");
375                 return NULL;
376         }
377
378         if (samldb_copy_template(module, msg2, "(&(CN=TemplateGroup)(objectclass=groupTemplate))") != 0) {
379                 ldb_debug(module->ldb, LDB_DEBUG_WARNING, "samldb_fill_group_object: Error copying template!\n");
380                 return NULL;
381         }
382
383         if ((rdn = ldb_dn_get_rdn(msg2, msg2->dn)) == NULL) {
384                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_group_object: Bad DN (%s)!\n", ldb_dn_linearize(msg2, msg2->dn));
385                 return NULL;
386         }
387         if (strcasecmp(rdn->name, "cn") != 0) {
388                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_group_object: Bad RDN (%s) for group!\n", rdn->name);
389                 return NULL;
390         }
391
392         if ((attribute = samldb_find_attribute(msg2, "objectSid", NULL)) == NULL ) {
393                 struct dom_sid *sid = samldb_get_new_sid(module, msg2, msg2->dn);
394                 if (sid == NULL) {
395                         ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_group_object: internal error! Can't generate new sid\n");
396                         return NULL;
397                 }
398
399                 if (!samldb_msg_add_sid(module, msg2, "objectSid", sid)) {
400                         talloc_free(sid);
401                         return NULL;
402                 }
403                 talloc_free(sid);
404         }
405
406         if ( ! samldb_find_or_add_attribute(module, msg2, "sAMAccountName", NULL, samldb_generate_samAccountName(msg2))) {
407                 return NULL;
408         }
409
410         talloc_steal(msg, msg2);
411
412         return msg2;
413 }
414
415 static struct ldb_message *samldb_fill_user_or_computer_object(struct ldb_module *module, const struct ldb_message *msg)
416 {
417         struct ldb_message *msg2;
418         struct ldb_message_element *attribute;
419         struct ldb_dn_component *rdn;
420
421         if ((samldb_find_attribute(msg, "objectclass", "user") == NULL) && 
422             (samldb_find_attribute(msg, "objectclass", "computer") == NULL)) {
423                 return NULL;
424         }
425
426         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_fill_user_or_computer_object\n");
427
428         /* build the new msg */
429         msg2 = ldb_msg_copy(module->ldb, msg);
430         if (!msg2) {
431                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_group_object: ldb_msg_copy failed!\n");
432                 return NULL;
433         }
434
435         if (samldb_find_attribute(msg, "objectclass", "computer") != NULL) {
436                 if (samldb_copy_template(module, msg2, "(&(CN=TemplateMemberServer)(objectclass=userTemplate))") != 0) {
437                         ldb_debug(module->ldb, LDB_DEBUG_WARNING, "samldb_fill_user_or_computer_object: Error copying computer template!\n");
438                         return NULL;
439                 }
440         } else {
441                 if (samldb_copy_template(module, msg2, "(&(CN=TemplateUser)(objectclass=userTemplate))") != 0) {
442                         ldb_debug(module->ldb, LDB_DEBUG_WARNING, "samldb_fill_user_or_computer_object: Error copying user template!\n");
443                         return NULL;
444                 }
445         }
446
447         if ((rdn = ldb_dn_get_rdn(msg2, msg2->dn)) == NULL) {
448                 return NULL;
449         }
450         if (strcasecmp(rdn->name, "cn") != 0) {
451                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_user_or_computer_object: Bad RDN (%s) for user/computer!\n", rdn->name);
452                 return NULL;
453         }
454
455         /* if the only attribute was: "objectclass: computer", then make sure we also add "user" objectclass */
456         if ( ! samldb_find_or_add_attribute(module, msg2, "objectclass", "user", "user")) {
457                 return NULL;
458         }
459
460         if ((attribute = samldb_find_attribute(msg2, "objectSid", NULL)) == NULL ) {
461                 struct dom_sid *sid;
462                 sid = samldb_get_new_sid(module, msg2, msg2->dn);
463                 if (sid == NULL) {
464                         ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_user_or_computer_object: internal error! Can't generate new sid\n");
465                         return NULL;
466                 }
467
468                 if ( ! samldb_msg_add_sid(module, msg2, "objectSid", sid)) {
469                         talloc_free(sid);
470                         return NULL;
471                 }
472                 talloc_free(sid);
473         }
474
475         if ( ! samldb_find_or_add_attribute(module, msg2, "sAMAccountName", NULL, samldb_generate_samAccountName(msg2))) {
476                 return NULL;
477         }
478
479         /* TODO: objectCategory, userAccountControl, badPwdCount, codePage, countryCode, badPasswordTime, lastLogoff, lastLogon, pwdLastSet, primaryGroupID, accountExpires, logonCount */
480
481         return msg2;
482 }
483
484 static struct ldb_message *samldb_fill_foreignSecurityPrincipal_object(struct ldb_module *module, const struct ldb_message *msg)
485 {
486         struct ldb_message *msg2;
487         struct ldb_message_element *attribute;
488         struct ldb_dn_component *rdn;
489
490         if (samldb_find_attribute(msg, "objectclass", "foreignSecurityPrincipal") == NULL) {
491                 return NULL;
492         }
493
494         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_fill_foreignSecurityPrincipal_object\n");
495
496         /* build the new msg */
497         msg2 = ldb_msg_copy(module->ldb, msg);
498         if (!msg2) {
499                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_foreignSecurityPrincpal_object: ldb_msg_copy failed!\n");
500                 return NULL;
501         }
502
503         talloc_steal(msg, msg2);
504
505         if (samldb_copy_template(module, msg2, "(&(CN=TemplateForeignSecurityPrincipal)(objectclass=foreignSecurityPrincipalTemplate))") != 0) {
506                 ldb_debug(module->ldb, LDB_DEBUG_WARNING, "samldb_fill_foreignSecurityPrincipal_object: Error copying template!\n");
507                 return NULL;
508         }
509
510         if ((rdn = ldb_dn_get_rdn(msg2, msg2->dn)) == NULL) {
511                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_foreignSecurityPrincipal_object: Bad DN (%s)!\n", ldb_dn_linearize(msg2, msg2->dn));
512                 return NULL;
513         }
514         if (strcasecmp(rdn->name, "cn") != 0) {
515                 ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_foreignSecurityPrincipal_object: Bad RDN (%s) for foreignSecurityPrincpal!\n", rdn->name);
516                 return NULL;
517         }
518
519         if ((attribute = samldb_find_attribute(msg2, "objectSid", NULL)) == NULL ) {
520                 struct dom_sid *sid = dom_sid_parse_talloc(msg2, rdn->value.data);
521                 if (sid == NULL) {
522                         ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_foreignSecurityPrincipal_object: internal error! Can't parse sid in CN\n");
523                         return NULL;
524                 }
525
526                 if (!samldb_msg_add_sid(module, msg2, "objectSid", sid)) {
527                         talloc_free(sid);
528                         return NULL;
529                 }
530                 talloc_free(sid);
531         }
532
533         return msg2;
534 }
535
536 /* add_record */
537 static int samldb_add_record(struct ldb_module *module, const struct ldb_message *msg)
538 {
539         struct ldb_message *msg2 = NULL;
540         int ret;
541
542         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_add_record\n");
543
544         if (strcmp(msg->dn->components[0].name, LDB_SPECIAL) == 0) { /* do not manipulate our control entries */
545                 return ldb_next_add_record(module, msg);
546         }
547
548         /* is user or computer?  add all relevant missing objects */
549         msg2 = samldb_fill_user_or_computer_object(module, msg);
550
551         /* is group? add all relevant missing objects */
552         if ( ! msg2 ) {
553                 msg2 = samldb_fill_group_object(module, msg);
554         }
555
556         /* perhaps a foreignSecurityPrincipal? */
557         if ( ! msg2 ) {
558                 msg2 = samldb_fill_foreignSecurityPrincipal_object(module, msg);
559         }
560
561         if (msg2) {
562                 ret = ldb_next_add_record(module, msg2);
563         } else {
564                 ret = ldb_next_add_record(module, msg);
565         }
566
567         return ret;
568 }
569
570 /* modify_record: change modifyTimestamp as well */
571 static int samldb_modify_record(struct ldb_module *module, const struct ldb_message *msg)
572 {
573         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_modify_record\n");
574         return ldb_next_modify_record(module, msg);
575 }
576
577 static int samldb_delete_record(struct ldb_module *module, const struct ldb_dn *dn)
578 {
579         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_delete_record\n");
580         return ldb_next_delete_record(module, dn);
581 }
582
583 static int samldb_rename_record(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
584 {
585         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_rename_record\n");
586         return ldb_next_rename_record(module, olddn, newdn);
587 }
588
589 static int samldb_lock(struct ldb_module *module, const char *lockname)
590 {
591         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_lock\n");
592         return ldb_next_named_lock(module, lockname);
593 }
594
595 static int samldb_unlock(struct ldb_module *module, const char *lockname)
596 {
597         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_unlock\n");
598         return ldb_next_named_unlock(module, lockname);
599 }
600
601 /* return extended error information */
602 static const char *samldb_errstring(struct ldb_module *module)
603 {
604         struct private_data *data = (struct private_data *)module->private_data;
605
606         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_errstring\n");
607         if (data->error_string) {
608                 const char *error;
609
610                 error = data->error_string;
611                 data->error_string = NULL;
612                 return error;
613         }
614
615         return ldb_next_errstring(module);
616 }
617
618 static int samldb_destructor(void *module_ctx)
619 {
620         /* struct ldb_module *ctx = module_ctx; */
621         /* put your clean-up functions here */
622         return 0;
623 }
624
625 static const struct ldb_module_ops samldb_ops = {
626         .name          = "samldb",
627         .search        = samldb_search,
628         .search_bytree = samldb_search_bytree,
629         .add_record    = samldb_add_record,
630         .modify_record = samldb_modify_record,
631         .delete_record = samldb_delete_record,
632         .rename_record = samldb_rename_record,
633         .named_lock    = samldb_lock,
634         .named_unlock  = samldb_unlock,
635         .errstring     = samldb_errstring
636 };
637
638
639 /* the init function */
640 #ifdef HAVE_DLOPEN_DISABLED
641  struct ldb_module *init_module(struct ldb_context *ldb, const char *options[])
642 #else
643 struct ldb_module *samldb_module_init(struct ldb_context *ldb, const char *options[])
644 #endif
645 {
646         struct ldb_module *ctx;
647         struct private_data *data;
648
649         ctx = talloc(ldb, struct ldb_module);
650         if (!ctx)
651                 return NULL;
652
653         data = talloc(ctx, struct private_data);
654         if (!data) {
655                 talloc_free(ctx);
656                 return NULL;
657         }
658
659         data->error_string = NULL;
660         ctx->private_data = data;
661         ctx->ldb = ldb;
662         ctx->prev = ctx->next = NULL;
663         ctx->ops = &samldb_ops;
664
665         talloc_set_destructor(ctx, samldb_destructor);
666
667         return ctx;
668 }