Fix include paths to new location of libutil.
[kai/samba-autobuild/.git] / source4 / dsdb / samdb / ldb_modules / samldb.c
1 /*
2    SAM ldb module
3
4    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
5    Copyright (C) Simo Sorce  2004-2008
6
7    * NOTICE: this module is NOT released under the GNU LGPL license as
8    * other ldb code. This module is release under the GNU GPL v3 or
9    * later license.
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
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 "libcli/ldap/ldap_ndr.h"
37 #include "lib/ldb/include/ldb_errors.h"
38 #include "lib/ldb/include/ldb.h"
39 #include "lib/ldb/include/ldb_private.h"
40 #include "lib/events/events.h"
41 #include "dsdb/samdb/samdb.h"
42 #include "libcli/security/security.h"
43 #include "librpc/gen_ndr/ndr_security.h"
44 #include "../lib/util/util_ldb.h"
45 #include "ldb_wrap.h"
46
47 struct samldb_ctx;
48
49 typedef int (*samldb_step_fn_t)(struct samldb_ctx *);
50
51 struct samldb_step {
52         struct samldb_step *next;
53         samldb_step_fn_t fn;
54 };
55
56 struct samldb_ctx {
57         struct ldb_module *module;
58         struct ldb_request *req;
59
60         /* the resulting message */
61         struct ldb_message *msg;
62
63         /* used to apply templates */
64         const char *type;
65
66         /* used to find parent domain */
67         struct ldb_dn *check_dn;
68         struct ldb_dn *domain_dn;
69         struct dom_sid *domain_sid;
70         uint32_t next_rid;
71
72         /* generic storage, remember to zero it before use */
73         struct ldb_reply *ares;
74
75         /* holds the entry SID */
76         struct dom_sid *sid;
77
78         /* all the async steps necessary to complete the operation */
79         struct samldb_step *steps;
80         struct samldb_step *curstep;
81 };
82
83 struct samldb_ctx *samldb_ctx_init(struct ldb_module *module,
84                                    struct ldb_request *req)
85 {
86         struct samldb_ctx *ac;
87
88         ac = talloc_zero(req, struct samldb_ctx);
89         if (ac == NULL) {
90                 ldb_oom(module->ldb);
91                 return NULL;
92         }
93
94         ac->module = module;
95         ac->req = req;
96
97         return ac;
98 }
99
100 static int samldb_add_step(struct samldb_ctx *ac, samldb_step_fn_t fn)
101 {
102         struct samldb_step *step;
103
104         step = talloc_zero(ac, struct samldb_step);
105         if (step == NULL) {
106                 return LDB_ERR_OPERATIONS_ERROR;
107         }
108
109         if (ac->steps == NULL) {
110                 ac->steps = step;
111                 ac->curstep = step;
112         } else {
113                 ac->curstep->next = step;
114                 ac->curstep = step;
115         }
116
117         step->fn = fn;
118
119         return LDB_SUCCESS;
120 }
121
122 static int samldb_first_step(struct samldb_ctx *ac)
123 {
124         if (ac->steps == NULL) {
125                 return LDB_ERR_OPERATIONS_ERROR;
126         }
127
128         ac->curstep = ac->steps;
129         return ac->curstep->fn(ac);
130 }
131
132 static int samldb_next_step(struct samldb_ctx *ac)
133 {
134         if (ac->curstep->next) {
135                 ac->curstep = ac->curstep->next;
136                 return ac->curstep->fn(ac);
137         }
138
139         /* it is an error if the last step does not properly
140          * return to the upper module by itself */
141         return LDB_ERR_OPERATIONS_ERROR;
142 }
143
144 static int samldb_search_template_callback(struct ldb_request *req,
145                                            struct ldb_reply *ares)
146 {
147         struct samldb_ctx *ac;
148         int ret;
149
150         ac = talloc_get_type(req->context, struct samldb_ctx);
151
152         if (!ares) {
153                 ret = LDB_ERR_OPERATIONS_ERROR;
154                 goto done;
155         }
156         if (ares->error != LDB_SUCCESS) {
157                 return ldb_module_done(ac->req, ares->controls,
158                                         ares->response, ares->error);
159         }
160
161         switch (ares->type) {
162         case LDB_REPLY_ENTRY:
163                 /* save entry */
164                 if (ac->ares != NULL) {
165                         /* one too many! */
166                         ldb_set_errstring(ac->module->ldb,
167                                 "Invalid number of results while searching "
168                                 "for template objects");
169                         ret = LDB_ERR_OPERATIONS_ERROR;
170                         goto done;
171                 }
172
173                 ac->ares = talloc_steal(ac, ares);
174                 ret = LDB_SUCCESS;
175                 break;
176
177         case LDB_REPLY_REFERRAL:
178                 /* ignore */
179                 talloc_free(ares);
180                 ret = LDB_SUCCESS;
181                 break;
182
183         case LDB_REPLY_DONE:
184
185                 talloc_free(ares);
186                 ret = samldb_next_step(ac);
187                 break;
188         }
189
190 done:
191         if (ret != LDB_SUCCESS) {
192                 return ldb_module_done(ac->req, NULL, NULL, ret);
193         }
194
195         return LDB_SUCCESS;
196 }
197
198 static int samldb_search_template(struct samldb_ctx *ac)
199 {
200         struct event_context *ev;
201         struct loadparm_context *lparm_ctx;
202         struct ldb_context *templates_ldb;
203         char *templates_ldb_path;
204         struct ldb_request *req;
205         struct ldb_dn *basedn;
206         void *opaque;
207         int ret;
208
209         opaque = ldb_get_opaque(ac->module->ldb, "loadparm");
210         lparm_ctx = talloc_get_type(opaque, struct loadparm_context);
211         if (lparm_ctx == NULL) {
212                 ldb_set_errstring(ac->module->ldb,
213                         "Unable to find loadparm context\n");
214                 return LDB_ERR_OPERATIONS_ERROR;
215         }
216
217         opaque = ldb_get_opaque(ac->module->ldb, "templates_ldb");
218         templates_ldb = talloc_get_type(opaque, struct ldb_context);
219
220         /* make sure we have the templates ldb */
221         if (!templates_ldb) {
222                 templates_ldb_path = samdb_relative_path(ac->module->ldb, ac,
223                                                          "templates.ldb");
224                 if (!templates_ldb_path) {
225                         ldb_set_errstring(ac->module->ldb,
226                                         "samldb_init_template: ERROR: Failed "
227                                         "to contruct path for template db");
228                         return LDB_ERR_OPERATIONS_ERROR;
229                 }
230
231                 ev = ldb_get_event_context(ac->module->ldb);
232
233                 templates_ldb = ldb_wrap_connect(ac->module->ldb, ev,
234                                                 lparm_ctx, templates_ldb_path,
235                                                 NULL, NULL, 0, NULL);
236                 talloc_free(templates_ldb_path);
237
238                 if (!templates_ldb) {
239                         return LDB_ERR_OPERATIONS_ERROR;
240                 }
241
242                 if (!talloc_reference(templates_ldb, ev)) {
243                         return LDB_ERR_OPERATIONS_ERROR;
244                 }
245
246                 ret = ldb_set_opaque(ac->module->ldb,
247                                         "templates_ldb", templates_ldb);
248                 if (ret != LDB_SUCCESS) {
249                         return ret;
250                 }
251         }
252
253         /* search template */
254         basedn = ldb_dn_new_fmt(ac, templates_ldb,
255                             "cn=Template%s,cn=Templates", ac->type);
256         if (basedn == NULL) {
257                 ldb_set_errstring(ac->module->ldb,
258                         "samldb_init_template: ERROR: Failed "
259                         "to contruct DN for template");
260                 return LDB_ERR_OPERATIONS_ERROR;
261         }
262
263         /* pull the template record */
264         ret = ldb_build_search_req(&req, templates_ldb, ac,
265                                    basedn, LDB_SCOPE_BASE,
266                                   "(distinguishedName=*)", NULL,
267                                   NULL,
268                                   ac, samldb_search_template_callback,
269                                   ac->req);
270         if (ret != LDB_SUCCESS) {
271                 return ret;
272         }
273
274         talloc_steal(req, basedn);
275         ac->ares = NULL;
276
277         return ldb_request(templates_ldb, req);
278 }
279
280 static int samldb_apply_template(struct samldb_ctx *ac)
281 {
282         struct ldb_message_element *el;
283         struct ldb_message *msg;
284         int i, j;
285         int ret;
286
287         msg = ac->ares->message;
288
289         for (i = 0; i < msg->num_elements; i++) {
290                 el = &msg->elements[i];
291                 /* some elements should not be copied */
292                 if (ldb_attr_cmp(el->name, "cn") == 0 ||
293                     ldb_attr_cmp(el->name, "name") == 0 ||
294                     ldb_attr_cmp(el->name, "objectClass") == 0 ||
295                     ldb_attr_cmp(el->name, "sAMAccountName") == 0 ||
296                     ldb_attr_cmp(el->name, "sAMAccountName") == 0 ||
297                     ldb_attr_cmp(el->name, "distinguishedName") == 0 ||
298                     ldb_attr_cmp(el->name, "objectGUID") == 0) {
299                         continue;
300                 }
301                 for (j = 0; j < el->num_values; j++) {
302                         ret = samdb_find_or_add_attribute(
303                                         ac->module->ldb, ac->msg, el->name,
304                                         (char *)el->values[j].data);
305                         if (ret != LDB_SUCCESS) {
306                                 ldb_set_errstring(ac->module->ldb,
307                                           "Failed adding template attribute\n");
308                                 return LDB_ERR_OPERATIONS_ERROR;
309                         }
310                 }
311         }
312
313         return samldb_next_step(ac);
314 }
315
316 static int samldb_get_parent_domain(struct samldb_ctx *ac);
317
318 static int samldb_get_parent_domain_callback(struct ldb_request *req,
319                                              struct ldb_reply *ares)
320 {
321         struct samldb_ctx *ac;
322         const char *nextRid;
323         int ret;
324
325         ac = talloc_get_type(req->context, struct samldb_ctx);
326
327         if (!ares) {
328                 ret = LDB_ERR_OPERATIONS_ERROR;
329                 goto done;
330         }
331         if (ares->error != LDB_SUCCESS) {
332                 return ldb_module_done(ac->req, ares->controls,
333                                         ares->response, ares->error);
334         }
335
336         switch (ares->type) {
337         case LDB_REPLY_ENTRY:
338                 /* save entry */
339                 if (ac->domain_dn != NULL) {
340                         /* one too many! */
341                         ldb_set_errstring(ac->module->ldb,
342                                 "Invalid number of results while searching "
343                                 "for domain object");
344                         ret = LDB_ERR_OPERATIONS_ERROR;
345                         break;
346                 }
347
348                 nextRid = ldb_msg_find_attr_as_string(ares->message,
349                                                         "nextRid", NULL);
350                 if (nextRid == NULL) {
351                         ldb_asprintf_errstring(ac->module->ldb,
352                                 "attribute nextRid not found in %s\n",
353                                 ldb_dn_get_linearized(ares->message->dn));
354                         ret = LDB_ERR_OPERATIONS_ERROR;
355                         break;;
356                 }
357
358                 ac->next_rid = strtol(nextRid, NULL, 0);
359
360                 ac->domain_sid = samdb_result_dom_sid(ac, ares->message,
361                                                                 "objectSid");
362                 if (ac->domain_sid == NULL) {
363                         ldb_set_errstring(ac->module->ldb,
364                                 "error retrieving parent domain domain sid!\n");
365                         ret = LDB_ERR_CONSTRAINT_VIOLATION;
366                         break;
367                 }
368                 ac->domain_dn = talloc_steal(ac, ares->message->dn);
369
370                 talloc_free(ares);
371                 ret = LDB_SUCCESS;
372                 break;
373
374         case LDB_REPLY_REFERRAL:
375                 /* ignore */
376                 talloc_free(ares);
377                 ret = LDB_SUCCESS;
378                 break;
379
380         case LDB_REPLY_DONE:
381
382                 talloc_free(ares);
383                 if (ac->domain_dn == NULL) {
384                         /* search again */
385                         ret = samldb_get_parent_domain(ac);
386                 } else {
387                         /* found, go on */
388                         ret = samldb_next_step(ac);
389                 }
390                 break;
391         }
392
393 done:
394         if (ret != LDB_SUCCESS) {
395                 return ldb_module_done(ac->req, NULL, NULL, ret);
396         }
397
398         return LDB_SUCCESS;
399 }
400
401 /* Find a domain object in the parents of a particular DN.  */
402 static int samldb_get_parent_domain(struct samldb_ctx *ac)
403 {
404         static const char * const attrs[3] = { "objectSid", "nextRid", NULL };
405         struct ldb_request *req;
406         struct ldb_dn *dn;
407         int ret;
408
409         if (ac->check_dn == NULL) {
410                 return LDB_ERR_OPERATIONS_ERROR;
411         }
412
413         dn = ldb_dn_get_parent(ac, ac->check_dn);
414         if (dn == NULL) {
415                 ldb_set_errstring(ac->module->ldb,
416                         "Unable to find parent domain object");
417                 return LDB_ERR_CONSTRAINT_VIOLATION;
418         }
419
420         ac->check_dn = dn;
421
422         ret = ldb_build_search_req(&req, ac->module->ldb, ac,
423                                    dn, LDB_SCOPE_BASE,
424                                    "(|(objectClass=domain)"
425                                      "(objectClass=builtinDomain)"
426                                      "(objectClass=samba4LocalDomain))",
427                                    attrs,
428                                    NULL,
429                                    ac, samldb_get_parent_domain_callback,
430                                    ac->req);
431
432         if (ret != LDB_SUCCESS) {
433                 return ret;
434         }
435
436         return ldb_next_request(ac->module, req);
437 }
438
439 static int samldb_generate_samAccountName(struct ldb_message *msg)
440 {
441         char *name;
442
443         /* Format: $000000-000000000000 */
444
445         name = talloc_asprintf(msg, "$%.6X-%.6X%.6X",
446                                 (unsigned int)generate_random(),
447                                 (unsigned int)generate_random(),
448                                 (unsigned int)generate_random());
449         if (name == NULL) {
450                 return LDB_ERR_OPERATIONS_ERROR;
451         }
452         return ldb_msg_add_steal_string(msg, "samAccountName", name);
453 }
454
455 static int samldb_check_samAccountName_callback(struct ldb_request *req,
456                                                 struct ldb_reply *ares)
457 {
458         struct samldb_ctx *ac;
459         int ret;
460
461         ac = talloc_get_type(req->context, struct samldb_ctx);
462
463         if (!ares) {
464                 ret = LDB_ERR_OPERATIONS_ERROR;
465                 goto done;
466         }
467         if (ares->error != LDB_SUCCESS) {
468                 return ldb_module_done(ac->req, ares->controls,
469                                         ares->response, ares->error);
470         }
471
472         switch (ares->type) {
473         case LDB_REPLY_ENTRY:
474
475                 /* if we get an entry it means this samAccountName
476                  * already exists */
477                 return ldb_module_done(ac->req, NULL, NULL,
478                                         LDB_ERR_ENTRY_ALREADY_EXISTS);
479
480         case LDB_REPLY_REFERRAL:
481                 /* ignore */
482                 talloc_free(ares);
483                 ret = LDB_SUCCESS;
484                 break;
485
486         case LDB_REPLY_DONE:
487
488                 /* not found, go on */
489                 talloc_free(ares);
490                 ret = samldb_next_step(ac);
491                 break;
492         }
493
494 done:
495         if (ret != LDB_SUCCESS) {
496                 return ldb_module_done(ac->req, NULL, NULL, ret);
497         }
498
499         return LDB_SUCCESS;
500 }
501
502 static int samldb_check_samAccountName(struct samldb_ctx *ac)
503 {
504         struct ldb_request *req;
505         const char *name;
506         char *filter;
507         int ret;
508
509         if (ldb_msg_find_element(ac->msg, "samAccountName") == NULL) {
510                 ret = samldb_generate_samAccountName(ac->msg);
511                 if (ret != LDB_SUCCESS) {
512                         return ret;
513                 }
514         }
515
516         name = ldb_msg_find_attr_as_string(ac->msg, "samAccountName", NULL);
517         if (name == NULL) {
518                 return LDB_ERR_OPERATIONS_ERROR;
519         }
520         filter = talloc_asprintf(ac, "samAccountName=%s", name);
521         if (filter == NULL) {
522                 return LDB_ERR_OPERATIONS_ERROR;
523         }
524
525         ret = ldb_build_search_req(&req, ac->module->ldb, ac,
526                                 ac->domain_dn, LDB_SCOPE_SUBTREE,
527                                 filter, NULL,
528                                 NULL,
529                                 ac, samldb_check_samAccountName_callback,
530                                 ac->req);
531         talloc_free(filter);
532         if (ret != LDB_SUCCESS) {
533                 return ret;
534         }
535         ac->ares = NULL;
536         return ldb_next_request(ac->module, req);
537 }
538
539 static int samldb_check_samAccountType(struct samldb_ctx *ac)
540 {
541         unsigned int account_type;
542         unsigned int group_type;
543         unsigned int uac;
544         int ret;
545
546         /* make sure sAMAccountType is not specified */
547         if (ldb_msg_find_element(ac->msg, "sAMAccountType") != NULL) {
548                 ldb_asprintf_errstring(ac->module->ldb,
549                                         "sAMAccountType must not be specified");
550                 return LDB_ERR_UNWILLING_TO_PERFORM;
551         }
552
553         if (strcmp("user", ac->type) == 0) {
554                 uac = samdb_result_uint(ac->msg, "userAccountControl", 0);
555                 if (uac == 0) {
556                         ldb_asprintf_errstring(ac->module->ldb,
557                                                 "userAccountControl invalid");
558                         return LDB_ERR_UNWILLING_TO_PERFORM;
559                 } else {
560                         account_type = samdb_uf2atype(uac);
561                         ret = samdb_msg_add_uint(ac->module->ldb,
562                                                  ac->msg, ac->msg,
563                                                  "sAMAccountType",
564                                                  account_type);
565                         if (ret != LDB_SUCCESS) {
566                                 return ret;
567                         }
568                 }
569         } else
570         if (strcmp("group", ac->type) == 0) {
571
572                 group_type = samdb_result_uint(ac->msg, "groupType", 0);
573                 if (group_type == 0) {
574                         ldb_asprintf_errstring(ac->module->ldb,
575                                                 "groupType invalid");
576                         return LDB_ERR_UNWILLING_TO_PERFORM;
577                 } else {
578                         account_type = samdb_gtype2atype(group_type);
579                         ret = samdb_msg_add_uint(ac->module->ldb,
580                                                  ac->msg, ac->msg,
581                                                  "sAMAccountType",
582                                                  account_type);
583                         if (ret != LDB_SUCCESS) {
584                                 return ret;
585                         }
586                 }
587         }
588
589         return samldb_next_step(ac);
590 }
591
592 static int samldb_get_sid_domain_callback(struct ldb_request *req,
593                                           struct ldb_reply *ares)
594 {
595         struct samldb_ctx *ac;
596         const char *nextRid;
597         int ret;
598
599         ac = talloc_get_type(req->context, struct samldb_ctx);
600
601         if (!ares) {
602                 ret = LDB_ERR_OPERATIONS_ERROR;
603                 goto done;
604         }
605         if (ares->error != LDB_SUCCESS) {
606                 return ldb_module_done(ac->req, ares->controls,
607                                         ares->response, ares->error);
608         }
609
610         switch (ares->type) {
611         case LDB_REPLY_ENTRY:
612                 /* save entry */
613                 if (ac->next_rid != 0) {
614                         /* one too many! */
615                         ldb_set_errstring(ac->module->ldb,
616                                 "Invalid number of results while searching "
617                                 "for domain object");
618                         ret = LDB_ERR_OPERATIONS_ERROR;
619                         break;
620                 }
621
622                 nextRid = ldb_msg_find_attr_as_string(ares->message,
623                                                         "nextRid", NULL);
624                 if (nextRid == NULL) {
625                         ldb_asprintf_errstring(ac->module->ldb,
626                                 "attribute nextRid not found in %s\n",
627                                 ldb_dn_get_linearized(ares->message->dn));
628                         ret = LDB_ERR_OPERATIONS_ERROR;
629                         break;
630                 }
631
632                 ac->next_rid = strtol(nextRid, NULL, 0);
633
634                 ac->domain_dn = talloc_steal(ac, ares->message->dn);
635
636                 talloc_free(ares);
637                 ret = LDB_SUCCESS;
638                 break;
639
640         case LDB_REPLY_REFERRAL:
641                 /* ignore */
642                 talloc_free(ares);
643                 ret = LDB_SUCCESS;
644                 break;
645
646         case LDB_REPLY_DONE:
647
648                 if (ac->next_rid == 0) {
649                         ldb_asprintf_errstring(ac->module->ldb,
650                                 "Unable to get nextRid from domain entry\n");
651                         ret = LDB_ERR_OPERATIONS_ERROR;
652                         break;
653                 }
654
655                 /* found, go on */
656                 ret = samldb_next_step(ac);
657                 break;
658         }
659
660 done:
661         if (ret != LDB_SUCCESS) {
662                 return ldb_module_done(ac->req, NULL, NULL, ret);
663         }
664
665         return LDB_SUCCESS;
666 }
667
668 /* Find a domain object in the parents of a particular DN.  */
669 static int samldb_get_sid_domain(struct samldb_ctx *ac)
670 {
671         static const char * const attrs[2] = { "nextRid", NULL };
672         struct ldb_request *req;
673         char *filter;
674         int ret;
675
676         if (ac->sid == NULL) {
677                 return LDB_ERR_OPERATIONS_ERROR;
678         }
679
680         ac->domain_sid = dom_sid_dup(ac, ac->sid);
681         if (!ac->domain_sid) {
682                 return LDB_ERR_OPERATIONS_ERROR;
683         }
684         /* get the domain component part of the provided SID */
685         ac->domain_sid->num_auths--;
686
687         filter = talloc_asprintf(ac, "(&(objectSid=%s)"
688                                        "(|(objectClass=domain)"
689                                          "(objectClass=builtinDomain)"
690                                          "(objectClass=samba4LocalDomain)))",
691                                  ldap_encode_ndr_dom_sid(ac, ac->domain_sid));
692         if (filter == NULL) {
693                 return LDB_ERR_OPERATIONS_ERROR;
694         }
695
696         ret = ldb_build_search_req(&req, ac->module->ldb, ac,
697                                    ldb_get_default_basedn(ac->module->ldb),
698                                    LDB_SCOPE_SUBTREE,
699                                    filter, attrs,
700                                    NULL,
701                                    ac, samldb_get_sid_domain_callback,
702                                    ac->req);
703
704         if (ret != LDB_SUCCESS) {
705                 return ret;
706         }
707
708         ac->next_rid = 0;
709         return ldb_next_request(ac->module, req);
710 }
711
712 static bool samldb_msg_add_sid(struct ldb_message *msg,
713                                 const char *name,
714                                 const struct dom_sid *sid)
715 {
716         struct ldb_val v;
717         enum ndr_err_code ndr_err;
718
719         ndr_err = ndr_push_struct_blob(&v, msg, NULL, sid,
720                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
721         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
722                 return false;
723         }
724         return (ldb_msg_add_value(msg, name, &v, NULL) == 0);
725 }
726
727 static int samldb_new_sid(struct samldb_ctx *ac)
728 {
729
730         if (ac->domain_sid == NULL || ac->next_rid == 0) {
731                 return LDB_ERR_OPERATIONS_ERROR;
732         }
733
734         ac->sid = dom_sid_add_rid(ac, ac->domain_sid, ac->next_rid + 1);
735         if (ac->sid == NULL) {
736                 return LDB_ERR_OPERATIONS_ERROR;
737         }
738
739         if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
740                 return LDB_ERR_OPERATIONS_ERROR;
741         }
742
743         return samldb_next_step(ac);
744 }
745
746 static int samldb_check_sid_callback(struct ldb_request *req,
747                                      struct ldb_reply *ares)
748 {
749         struct samldb_ctx *ac;
750         int ret;
751
752         ac = talloc_get_type(req->context, struct samldb_ctx);
753
754         if (!ares) {
755                 ret = LDB_ERR_OPERATIONS_ERROR;
756                 goto done;
757         }
758         if (ares->error != LDB_SUCCESS) {
759                 return ldb_module_done(ac->req, ares->controls,
760                                         ares->response, ares->error);
761         }
762
763         switch (ares->type) {
764         case LDB_REPLY_ENTRY:
765
766                 /* if we get an entry it means an object with the
767                  * requested sid exists */
768                 return ldb_module_done(ac->req, NULL, NULL,
769                                         LDB_ERR_CONSTRAINT_VIOLATION);
770
771         case LDB_REPLY_REFERRAL:
772                 /* ignore */
773                 talloc_free(ares);
774                 break;
775
776         case LDB_REPLY_DONE:
777
778                 /* not found, go on */
779                 talloc_free(ares);
780                 ret = samldb_next_step(ac);
781                 break;
782         }
783
784 done:
785         if (ret != LDB_SUCCESS) {
786                 return ldb_module_done(ac->req, NULL, NULL, ret);
787         }
788
789         return LDB_SUCCESS;
790 }
791
792 static int samldb_check_sid(struct samldb_ctx *ac)
793 {
794         const char *const attrs[2] = { "objectSid", NULL };
795         struct ldb_request *req;
796         char *filter;
797         int ret;
798
799         if (ac->sid == NULL) {
800                 return LDB_ERR_OPERATIONS_ERROR;
801         }
802
803         filter = talloc_asprintf(ac, "(objectSid=%s)",
804                                  ldap_encode_ndr_dom_sid(ac, ac->sid));
805         if (filter == NULL) {
806                 return LDB_ERR_OPERATIONS_ERROR;
807         }
808
809         ret = ldb_build_search_req(&req, ac->module->ldb, ac,
810                                    ldb_get_default_basedn(ac->module->ldb),
811                                    LDB_SCOPE_SUBTREE,
812                                    filter, attrs,
813                                    NULL,
814                                    ac, samldb_check_sid_callback,
815                                    ac->req);
816
817         if (ret != LDB_SUCCESS) {
818                 return ret;
819         }
820
821         return ldb_next_request(ac->module, req);
822 }
823
824 static int samldb_notice_sid_callback(struct ldb_request *req,
825                                         struct ldb_reply *ares)
826 {
827         struct samldb_ctx *ac;
828         int ret;
829
830         ac = talloc_get_type(req->context, struct samldb_ctx);
831
832         if (!ares) {
833                 ret = LDB_ERR_OPERATIONS_ERROR;
834                 goto done;
835         }
836         if (ares->error != LDB_SUCCESS) {
837                 return ldb_module_done(ac->req, ares->controls,
838                                         ares->response, ares->error);
839         }
840         if (ares->type != LDB_REPLY_DONE) {
841                 ldb_set_errstring(ac->module->ldb,
842                         "Invalid reply type!\n");
843                 ret = LDB_ERR_OPERATIONS_ERROR;
844                 goto done;
845         }
846
847         ret = samldb_next_step(ac);
848
849 done:
850         if (ret != LDB_SUCCESS) {
851                 return ldb_module_done(ac->req, NULL, NULL, ret);
852         }
853
854         return LDB_SUCCESS;
855 }
856
857 /* If we are adding new users/groups, we need to update the nextRid
858  * attribute to be 'above' the new/incoming RID. Attempt to do it
859  *atomically. */
860 static int samldb_notice_sid(struct samldb_ctx *ac)
861 {
862         uint32_t old_id, new_id;
863         struct ldb_request *req;
864         struct ldb_message *msg;
865         struct ldb_message_element *els;
866         struct ldb_val *vals;
867         int ret;
868
869         old_id = ac->next_rid;
870         new_id = ac->sid->sub_auths[ac->sid->num_auths - 1];
871
872         if (old_id >= new_id) {
873                 /* no need to update the domain nextRid attribute */
874                 return samldb_next_step(ac);
875         }
876
877         /* we do a delete and add as a single operation. That prevents
878            a race, in case we are not actually on a transaction db */
879         msg = talloc_zero(ac, struct ldb_message);
880         if (msg == NULL) {
881                 ldb_oom(ac->module->ldb);
882                 return LDB_ERR_OPERATIONS_ERROR;
883         }
884         els = talloc_array(msg, struct ldb_message_element, 2);
885         if (els == NULL) {
886                 ldb_oom(ac->module->ldb);
887                 return LDB_ERR_OPERATIONS_ERROR;
888         }
889         vals = talloc_array(msg, struct ldb_val, 2);
890         if (vals == NULL) {
891                 ldb_oom(ac->module->ldb);
892                 return LDB_ERR_OPERATIONS_ERROR;
893         }
894         msg->dn = ac->domain_dn;
895         msg->num_elements = 2;
896         msg->elements = els;
897
898         els[0].num_values = 1;
899         els[0].values = &vals[0];
900         els[0].flags = LDB_FLAG_MOD_DELETE;
901         els[0].name = talloc_strdup(msg, "nextRid");
902         if (!els[0].name) {
903                 ldb_oom(ac->module->ldb);
904                 return LDB_ERR_OPERATIONS_ERROR;
905         }
906
907         els[1].num_values = 1;
908         els[1].values = &vals[1];
909         els[1].flags = LDB_FLAG_MOD_ADD;
910         els[1].name = els[0].name;
911
912         vals[0].data = (uint8_t *)talloc_asprintf(vals, "%u", old_id);
913         if (!vals[0].data) {
914                 ldb_oom(ac->module->ldb);
915                 return LDB_ERR_OPERATIONS_ERROR;
916         }
917         vals[0].length = strlen((char *)vals[0].data);
918
919         vals[1].data = (uint8_t *)talloc_asprintf(vals, "%u", new_id);
920         if (!vals[1].data) {
921                 ldb_oom(ac->module->ldb);
922                 return LDB_ERR_OPERATIONS_ERROR;
923         }
924         vals[1].length = strlen((char *)vals[1].data);
925
926         ret = ldb_build_mod_req(&req, ac->module->ldb, ac,
927                                 msg, NULL,
928                                 ac, samldb_notice_sid_callback,
929                                 ac->req);
930         if (ret != LDB_SUCCESS) {
931                 return ret;
932         }
933
934         return ldb_next_request(ac->module, req);
935 }
936
937 static int samldb_add_entry_callback(struct ldb_request *req,
938                                         struct ldb_reply *ares)
939 {
940         struct samldb_ctx *ac;
941
942         ac = talloc_get_type(req->context, struct samldb_ctx);
943
944         if (!ares) {
945                 return ldb_module_done(ac->req, NULL, NULL,
946                                         LDB_ERR_OPERATIONS_ERROR);
947         }
948         if (ares->error != LDB_SUCCESS) {
949                 return ldb_module_done(ac->req, ares->controls,
950                                         ares->response, ares->error);
951         }
952         if (ares->type != LDB_REPLY_DONE) {
953                 ldb_set_errstring(ac->module->ldb,
954                         "Invalid reply type!\n");
955                 return ldb_module_done(ac->req, NULL, NULL,
956                                         LDB_ERR_OPERATIONS_ERROR);
957         }
958
959         /* we exit the samldb module here */
960         return ldb_module_done(ac->req, ares->controls,
961                                 ares->response, LDB_SUCCESS);
962 }
963
964 static int samldb_add_entry(struct samldb_ctx *ac)
965 {
966         struct ldb_request *req;
967         int ret;
968
969         ret = ldb_build_add_req(&req, ac->module->ldb, ac,
970                                 ac->msg,
971                                 ac->req->controls,
972                                 ac, samldb_add_entry_callback,
973                                 ac->req);
974         if (ret != LDB_SUCCESS) {
975                 return ret;
976         }
977
978         return ldb_next_request(ac->module, req);
979 }
980
981 static int samldb_fill_object(struct samldb_ctx *ac, const char *type)
982 {
983         int ret;
984
985         /* first look for the template */
986         ac->type = type;
987         ret = samldb_add_step(ac, samldb_search_template);
988         if (ret != LDB_SUCCESS) return ret;
989
990         /* then apply it */
991         ret = samldb_add_step(ac, samldb_apply_template);
992         if (ret != LDB_SUCCESS) return ret;
993
994         /* search for a parent domain objet */
995         ac->check_dn = ac->req->op.add.message->dn;
996         ret = samldb_add_step(ac, samldb_get_parent_domain);
997         if (ret != LDB_SUCCESS) return ret;
998
999         /* check if we have a valid samAccountName */
1000         ret = samldb_add_step(ac, samldb_check_samAccountName);
1001         if (ret != LDB_SUCCESS) return ret;
1002
1003         /* check account_type/group_type */
1004         ret = samldb_add_step(ac, samldb_check_samAccountType);
1005         if (ret != LDB_SUCCESS) return ret;
1006
1007         /* check if we have a valid SID */
1008         ac->sid = samdb_result_dom_sid(ac, ac->msg, "objectSid");
1009         if ( ! ac->sid) {
1010                 ret = samldb_add_step(ac, samldb_new_sid);
1011                 if (ret != LDB_SUCCESS) return ret;
1012         } else {
1013                 ret = samldb_add_step(ac, samldb_get_sid_domain);
1014                 if (ret != LDB_SUCCESS) return ret;
1015         }
1016
1017         ret = samldb_add_step(ac, samldb_check_sid);
1018         if (ret != LDB_SUCCESS) return ret;
1019
1020         ret = samldb_add_step(ac, samldb_notice_sid);
1021         if (ret != LDB_SUCCESS) return ret;
1022
1023         /* finally proceed with adding the entry */
1024         ret = samldb_add_step(ac, samldb_add_entry);
1025         if (ret != LDB_SUCCESS) return ret;
1026
1027         return samldb_first_step(ac);
1028
1029         /* TODO: userAccountControl, badPwdCount, codePage,
1030          *       countryCode, badPasswordTime, lastLogoff, lastLogon,
1031          *       pwdLastSet, primaryGroupID, accountExpires, logonCount */
1032
1033 }
1034
1035 static int samldb_foreign_notice_sid_callback(struct ldb_request *req,
1036                                                 struct ldb_reply *ares)
1037 {
1038         struct samldb_ctx *ac;
1039         const char *nextRid;
1040         const char *name;
1041         int ret;
1042
1043         ac = talloc_get_type(req->context, struct samldb_ctx);
1044
1045         if (!ares) {
1046                 ret = LDB_ERR_OPERATIONS_ERROR;
1047                 goto done;
1048         }
1049         if (ares->error != LDB_SUCCESS) {
1050                 return ldb_module_done(ac->req, ares->controls,
1051                                         ares->response, ares->error);
1052         }
1053
1054         switch (ares->type) {
1055         case LDB_REPLY_ENTRY:
1056                 /* save entry */
1057                 if (ac->next_rid != 0) {
1058                         /* one too many! */
1059                         ldb_set_errstring(ac->module->ldb,
1060                                 "Invalid number of results while searching "
1061                                 "for domain object");
1062                         ret = LDB_ERR_OPERATIONS_ERROR;
1063                         break;
1064                 }
1065
1066                 nextRid = ldb_msg_find_attr_as_string(ares->message,
1067                                                         "nextRid", NULL);
1068                 if (nextRid == NULL) {
1069                         ldb_asprintf_errstring(ac->module->ldb,
1070                                 "attribute nextRid not found in %s\n",
1071                                 ldb_dn_get_linearized(ares->message->dn));
1072                         ret = LDB_ERR_OPERATIONS_ERROR;
1073                         break;
1074                 }
1075
1076                 ac->next_rid = strtol(nextRid, NULL, 0);
1077
1078                 ac->domain_dn = talloc_steal(ac, ares->message->dn);
1079
1080                 name = samdb_result_string(ares->message, "name", NULL);
1081                 ldb_debug(ac->module->ldb, LDB_DEBUG_TRACE,
1082                          "NOTE (strange but valid): Adding foreign SID "
1083                          "record with SID %s, but this domain (%s) is "
1084                          "not foreign in the database",
1085                          dom_sid_string(ares, ac->sid), name);
1086
1087                 talloc_free(ares);
1088                 break;
1089
1090         case LDB_REPLY_REFERRAL:
1091                 /* ignore */
1092                 talloc_free(ares);
1093                 break;
1094
1095         case LDB_REPLY_DONE:
1096
1097                 /* if this is a fake foreign SID, notice the SID */
1098                 if (ac->domain_dn) {
1099                         ret = samldb_notice_sid(ac);
1100                         break;
1101                 }
1102
1103                 /* found, go on */
1104                 ret = samldb_next_step(ac);
1105                 break;
1106         }
1107
1108 done:
1109         if (ret != LDB_SUCCESS) {
1110                 return ldb_module_done(ac->req, NULL, NULL, ret);
1111         }
1112
1113         return LDB_SUCCESS;
1114 }
1115
1116 /* Find a domain object in the parents of a particular DN. */
1117 static int samldb_foreign_notice_sid(struct samldb_ctx *ac)
1118 {
1119         static const char * const attrs[3] = { "nextRid", "name", NULL };
1120         struct ldb_request *req;
1121         char *filter;
1122         int ret;
1123
1124         if (ac->sid == NULL) {
1125                 return LDB_ERR_OPERATIONS_ERROR;
1126         }
1127
1128         ac->domain_sid = dom_sid_dup(ac, ac->sid);
1129         if (!ac->domain_sid) {
1130                 return LDB_ERR_OPERATIONS_ERROR;
1131         }
1132         /* get the domain component part of the provided SID */
1133         ac->domain_sid->num_auths--;
1134
1135         filter = talloc_asprintf(ac, "(&(objectSid=%s)(objectclass=domain))",
1136                                  ldap_encode_ndr_dom_sid(ac, ac->domain_sid));
1137         if (filter == NULL) {
1138                 return LDB_ERR_OPERATIONS_ERROR;
1139         }
1140
1141         ret = ldb_build_search_req(&req, ac->module->ldb, ac,
1142                                    ldb_get_default_basedn(ac->module->ldb),
1143                                    LDB_SCOPE_SUBTREE,
1144                                    filter, attrs,
1145                                    NULL,
1146                                    ac, samldb_foreign_notice_sid_callback,
1147                                    ac->req);
1148
1149         if (ret != LDB_SUCCESS) {
1150                 return ret;
1151         }
1152
1153         ac->next_rid = 0;
1154         return ldb_next_request(ac->module, req);
1155 }
1156
1157 static int samldb_fill_foreignSecurityPrincipal_object(struct samldb_ctx *ac)
1158 {
1159         int ret;
1160
1161         ac->sid = samdb_result_dom_sid(ac->msg, ac->msg, "objectSid");
1162         if (ac->sid == NULL) {
1163                 ac->sid = dom_sid_parse_talloc(ac->msg,
1164                            (const char *)ldb_dn_get_rdn_val(ac->msg->dn)->data);
1165                 if (!ac->sid) {
1166                         ldb_set_errstring(ac->module->ldb,
1167                                         "No valid found SID in "
1168                                         "ForeignSecurityPrincipal CN!");
1169                         talloc_free(ac);
1170                         return LDB_ERR_CONSTRAINT_VIOLATION;
1171                 }
1172                 if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
1173                         talloc_free(ac);
1174                         return LDB_ERR_OPERATIONS_ERROR;
1175                 }
1176         }
1177
1178         /* first look for the template */
1179         ac->type = "foreignSecurityPrincipal";
1180         ret = samldb_add_step(ac, samldb_search_template);
1181         if (ret != LDB_SUCCESS) return ret;
1182
1183         /* then apply it */
1184         ret = samldb_add_step(ac, samldb_apply_template);
1185         if (ret != LDB_SUCCESS) return ret;
1186
1187         /* check we do not already have this SID */
1188         ret = samldb_add_step(ac, samldb_check_sid);
1189         if (ret != LDB_SUCCESS) return ret;
1190
1191         /* check if we need to notice this SID */
1192         ret = samldb_add_step(ac, samldb_foreign_notice_sid);
1193         if (ret != LDB_SUCCESS) return ret;
1194
1195         /* finally proceed with adding the entry */
1196         ret = samldb_add_step(ac, samldb_add_entry);
1197         if (ret != LDB_SUCCESS) return ret;
1198
1199         return samldb_first_step(ac);
1200 }
1201
1202 static int samldb_check_rdn(struct ldb_module *module, struct ldb_dn *dn)
1203 {
1204         const char *rdn_name;
1205
1206         rdn_name = ldb_dn_get_rdn_name(dn);
1207
1208         if (strcasecmp(rdn_name, "cn") != 0) {
1209                 ldb_asprintf_errstring(module->ldb,
1210                                         "Bad RDN (%s=) for samldb object, "
1211                                         "should be CN=!\n", rdn_name);
1212                 return LDB_ERR_CONSTRAINT_VIOLATION;
1213         }
1214
1215         return LDB_SUCCESS;
1216 }
1217
1218 /* add_record */
1219 static int samldb_add(struct ldb_module *module, struct ldb_request *req)
1220 {
1221         struct samldb_ctx *ac;
1222         int ret;
1223
1224         ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_add_record\n");
1225
1226         /* do not manipulate our control entries */
1227         if (ldb_dn_is_special(req->op.add.message->dn)) {
1228                 return ldb_next_request(module, req);
1229         }
1230
1231         ac = samldb_ctx_init(module, req);
1232         if (ac == NULL) {
1233                 return LDB_ERR_OPERATIONS_ERROR;
1234         }
1235
1236         /* build the new msg */
1237         ac->msg = ldb_msg_copy(ac, ac->req->op.add.message);
1238         if (!ac->msg) {
1239                 talloc_free(ac);
1240                 ldb_debug(ac->module->ldb, LDB_DEBUG_FATAL,
1241                           "samldb_add: ldb_msg_copy failed!\n");
1242                 return LDB_ERR_OPERATIONS_ERROR;
1243         }
1244
1245         if (samdb_find_attribute(module->ldb, ac->msg,
1246                                  "objectclass", "computer") != NULL) {
1247
1248                 /* make sure the computer object also has the 'user'
1249                  * objectclass so it will be handled by the next call */
1250                 ret = samdb_find_or_add_value(module->ldb, ac->msg,
1251                                                 "objectclass", "user");
1252                 if (ret != LDB_SUCCESS) {
1253                         talloc_free(ac);
1254                         return ret;
1255                 }
1256         }
1257
1258         if (samdb_find_attribute(module->ldb, ac->msg,
1259                                  "objectclass", "user") != NULL) {
1260
1261                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1262                 if (ret != LDB_SUCCESS) {
1263                         talloc_free(ac);
1264                         return ret;
1265                 }
1266
1267                 return samldb_fill_object(ac, "user");
1268         }
1269
1270         if (samdb_find_attribute(module->ldb, ac->msg,
1271                                  "objectclass", "group") != NULL) {
1272
1273                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1274                 if (ret != LDB_SUCCESS) {
1275                         talloc_free(ac);
1276                         return ret;
1277                 }
1278
1279                 return samldb_fill_object(ac, "group");
1280         }
1281
1282         /* perhaps a foreignSecurityPrincipal? */
1283         if (samdb_find_attribute(module->ldb, ac->msg,
1284                                  "objectclass",
1285                                  "foreignSecurityPrincipal") != NULL) {
1286
1287                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1288                 if (ret != LDB_SUCCESS) {
1289                         talloc_free(ac);
1290                         return ret;
1291                 }
1292
1293                 return samldb_fill_foreignSecurityPrincipal_object(ac);
1294         }
1295
1296         talloc_free(ac);
1297
1298         /* nothing matched, go on */
1299         return ldb_next_request(module, req);
1300 }
1301
1302 /* modify */
1303 static int samldb_modify(struct ldb_module *module, struct ldb_request *req)
1304 {
1305         struct ldb_message *msg;
1306         struct ldb_message_element *el, *el2;
1307         int ret;
1308         unsigned int group_type, user_account_control, account_type;
1309         if (ldb_dn_is_special(req->op.mod.message->dn)) { /* do not manipulate our control entries */
1310                 return ldb_next_request(module, req);
1311         }
1312
1313         if (ldb_msg_find_element(req->op.mod.message, "sAMAccountType") != NULL) {
1314                 ldb_asprintf_errstring(module->ldb, "sAMAccountType must not be specified");
1315                 return LDB_ERR_UNWILLING_TO_PERFORM;
1316         }
1317
1318         /* TODO: do not modify original request, create a new one */
1319
1320         el = ldb_msg_find_element(req->op.mod.message, "groupType");
1321         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1322                 req->op.mod.message = msg = ldb_msg_copy_shallow(req, req->op.mod.message);
1323
1324                 group_type = strtoul((const char *)el->values[0].data, NULL, 0);
1325                 account_type =  samdb_gtype2atype(group_type);
1326                 ret = samdb_msg_add_uint(module->ldb, msg, msg,
1327                                          "sAMAccountType",
1328                                          account_type);
1329                 if (ret != LDB_SUCCESS) {
1330                         return ret;
1331                 }
1332                 el2 = ldb_msg_find_element(msg, "sAMAccountType");
1333                 el2->flags = LDB_FLAG_MOD_REPLACE;
1334         }
1335
1336         el = ldb_msg_find_element(req->op.mod.message, "userAccountControl");
1337         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1338                 req->op.mod.message = msg = ldb_msg_copy_shallow(req, req->op.mod.message);
1339
1340                 user_account_control = strtoul((const char *)el->values[0].data, NULL, 0);
1341                 account_type = samdb_uf2atype(user_account_control);
1342                 ret = samdb_msg_add_uint(module->ldb, msg, msg,
1343                                          "sAMAccountType",
1344                                          account_type);
1345                 if (ret != LDB_SUCCESS) {
1346                         return ret;
1347                 }
1348                 el2 = ldb_msg_find_element(msg, "sAMAccountType");
1349                 el2->flags = LDB_FLAG_MOD_REPLACE;
1350         }
1351         return ldb_next_request(module, req);
1352 }
1353
1354
1355 static int samldb_init(struct ldb_module *module)
1356 {
1357         return ldb_next_init(module);
1358 }
1359
1360 _PUBLIC_ const struct ldb_module_ops ldb_samldb_module_ops = {
1361         .name          = "samldb",
1362         .init_context  = samldb_init,
1363         .add           = samldb_add,
1364         .modify        = samldb_modify
1365 };