s4-samldb: fixed primaryGroupID when promoting a machine to a DC
[ira/wip.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    Copyright (C) Matthias Dieter Wallnöfer 2009
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 /*
23  *  Name: ldb
24  *
25  *  Component: ldb samldb module
26  *
27  *  Description: add embedded user/group creation functionality
28  *
29  *  Author: Simo Sorce
30  */
31
32 #include "includes.h"
33 #include "libcli/ldap/ldap_ndr.h"
34 #include "ldb_module.h"
35 #include "dsdb/samdb/samdb.h"
36 #include "dsdb/samdb/ldb_modules/util.h"
37 #include "libcli/security/security.h"
38 #include "librpc/gen_ndr/ndr_security.h"
39 #include "../lib/util/util_ldb.h"
40 #include "ldb_wrap.h"
41 #include "param/param.h"
42
43 struct samldb_ctx;
44
45 typedef int (*samldb_step_fn_t)(struct samldb_ctx *);
46
47 struct samldb_step {
48         struct samldb_step *next;
49         samldb_step_fn_t fn;
50 };
51
52 struct samldb_ctx {
53         struct ldb_module *module;
54         struct ldb_request *req;
55
56         /* used for add operations */
57         const char *type;
58
59         /* the resulting message */
60         struct ldb_message *msg;
61
62         /* holds the entry SID */
63         struct dom_sid *sid;
64
65         /* holds a generic dn */
66         struct ldb_dn *dn;
67
68         /* used in conjunction with "sid" in "samldb_dn_from_sid" */
69         struct ldb_dn *res_dn;
70
71         /* used in conjunction with "dn" in "samldb_sid_from_dn" */
72         struct dom_sid *res_sid;
73
74         /* used in "samldb_user_dn_to_prim_group_rid" */
75         uint32_t prim_group_rid;
76
77         /* used in conjunction with "prim_group_rid" in
78          * "samldb_prim_group_rid_to_users_cnt" */
79         unsigned int users_cnt;
80
81         /* used in "samldb_group_add_member" and "samldb_group_del_member" */
82         struct ldb_dn *group_dn;
83         struct ldb_dn *member_dn;
84
85         /* used in "samldb_primary_group_change" */
86         struct ldb_dn *user_dn;
87         struct ldb_dn *old_prim_group_dn, *new_prim_group_dn;
88
89         /* generic counter - used in "samldb_member_check" */
90         unsigned int cnt;
91
92         /* all the async steps necessary to complete the operation */
93         struct samldb_step *steps;
94         struct samldb_step *curstep;
95
96         /* If someone set an ares to forward controls and response back to the caller */
97         struct ldb_reply *ares;
98 };
99
100 static struct samldb_ctx *samldb_ctx_init(struct ldb_module *module,
101                                           struct ldb_request *req)
102 {
103         struct ldb_context *ldb;
104         struct samldb_ctx *ac;
105
106         ldb = ldb_module_get_ctx(module);
107
108         ac = talloc_zero(req, struct samldb_ctx);
109         if (ac == NULL) {
110                 ldb_oom(ldb);
111                 return NULL;
112         }
113
114         ac->module = module;
115         ac->req = req;
116
117         return ac;
118 }
119
120 static int samldb_add_step(struct samldb_ctx *ac, samldb_step_fn_t fn)
121 {
122         struct samldb_step *step, *stepper;
123
124         step = talloc_zero(ac, struct samldb_step);
125         if (step == NULL) {
126                 return LDB_ERR_OPERATIONS_ERROR;
127         }
128
129         step->fn = fn;
130
131         if (ac->steps == NULL) {
132                 ac->steps = step;
133                 ac->curstep = step;
134         } else {
135                 if (ac->curstep == NULL)
136                         return LDB_ERR_OPERATIONS_ERROR;
137                 for (stepper = ac->curstep; stepper->next != NULL;
138                         stepper = stepper->next);
139                 stepper->next = step;
140         }
141
142         return LDB_SUCCESS;
143 }
144
145 static int samldb_first_step(struct samldb_ctx *ac)
146 {
147         if (ac->steps == NULL) {
148                 return LDB_ERR_OPERATIONS_ERROR;
149         }
150
151         ac->curstep = ac->steps;
152         return ac->curstep->fn(ac);
153 }
154
155 static int samldb_next_step(struct samldb_ctx *ac)
156 {
157         if (ac->curstep->next) {
158                 ac->curstep = ac->curstep->next;
159                 return ac->curstep->fn(ac);
160         }
161
162         /* we exit the samldb module here */
163         /* If someone set an ares to forward controls and response back to the caller, use them */
164         if (ac->ares) {
165                 return ldb_module_done(ac->req, ac->ares->controls,
166                                        ac->ares->response, LDB_SUCCESS);
167         } else {
168                 return ldb_module_done(ac->req, NULL, NULL, LDB_SUCCESS);
169         }
170 }
171
172 static int samldb_generate_samAccountName(struct ldb_message *msg)
173 {
174         char *name;
175
176         /* Format: $000000-000000000000 */
177
178         name = talloc_asprintf(msg, "$%.6X-%.6X%.6X",
179                                 (unsigned int)generate_random(),
180                                 (unsigned int)generate_random(),
181                                 (unsigned int)generate_random());
182         if (name == NULL) {
183                 return LDB_ERR_OPERATIONS_ERROR;
184         }
185         return ldb_msg_add_steal_string(msg, "samAccountName", name);
186 }
187
188 /*
189  * samldb_check_samAccountName (async)
190  */
191
192 static int samldb_check_samAccountName_callback(struct ldb_request *req,
193                                                 struct ldb_reply *ares)
194 {
195         struct samldb_ctx *ac;
196         int ret;
197
198         ac = talloc_get_type(req->context, struct samldb_ctx);
199
200         if (ares->error != LDB_SUCCESS) {
201                 return ldb_module_done(ac->req, ares->controls,
202                                        ares->response, ares->error);
203         }
204
205         switch (ares->type) {
206         case LDB_REPLY_ENTRY:
207                 /* if we get an entry it means this samAccountName
208                  * already exists */
209                 return ldb_module_done(ac->req, NULL, NULL,
210                                        LDB_ERR_ENTRY_ALREADY_EXISTS);
211
212         case LDB_REPLY_REFERRAL:
213                 /* this should not happen */
214                 return ldb_module_done(ac->req, NULL, NULL,
215                                        LDB_ERR_OPERATIONS_ERROR);
216
217         case LDB_REPLY_DONE:
218                 /* not found, go on */
219                 talloc_free(ares);
220                 ret = samldb_next_step(ac);
221                 break;
222         }
223
224         if (ret != LDB_SUCCESS) {
225                 return ldb_module_done(ac->req, NULL, NULL, ret);
226         }
227
228         return LDB_SUCCESS;
229 }
230
231 static int samldb_check_samAccountName(struct samldb_ctx *ac)
232 {
233         struct ldb_context *ldb;
234         struct ldb_request *req;
235         const char *name;
236         char *filter;
237         int ret;
238
239         ldb = ldb_module_get_ctx(ac->module);
240
241         if (ldb_msg_find_element(ac->msg, "samAccountName") == NULL) {
242                 ret = samldb_generate_samAccountName(ac->msg);
243                 if (ret != LDB_SUCCESS) {
244                         return ret;
245                 }
246         }
247
248         name = ldb_msg_find_attr_as_string(ac->msg, "samAccountName", NULL);
249         if (name == NULL) {
250                 return LDB_ERR_OPERATIONS_ERROR;
251         }
252         filter = talloc_asprintf(ac, "samAccountName=%s",
253                                  ldb_binary_encode_string(ac, name));
254         if (filter == NULL) {
255                 return LDB_ERR_OPERATIONS_ERROR;
256         }
257
258         ret = ldb_build_search_req(&req, ldb, ac,
259                                    samdb_base_dn(ldb), LDB_SCOPE_SUBTREE,
260                                    filter, NULL,
261                                    NULL,
262                                    ac, samldb_check_samAccountName_callback,
263                                    ac->req);
264         talloc_free(filter);
265         if (ret != LDB_SUCCESS) {
266                 return ret;
267         }
268         return ldb_next_request(ac->module, req);
269 }
270
271
272 static int samldb_check_samAccountType(struct samldb_ctx *ac)
273 {
274         struct ldb_context *ldb;
275         unsigned int account_type;
276         unsigned int group_type;
277         unsigned int uac;
278         int ret;
279
280         ldb = ldb_module_get_ctx(ac->module);
281
282         /* make sure sAMAccountType is not specified */
283         if (ldb_msg_find_element(ac->msg, "sAMAccountType") != NULL) {
284                 ldb_asprintf_errstring(ldb,
285                         "sAMAccountType must not be specified!");
286                 return LDB_ERR_UNWILLING_TO_PERFORM;
287         }
288
289         if (strcmp("user", ac->type) == 0) {
290                 uac = samdb_result_uint(ac->msg, "userAccountControl", 0);
291                 if (uac == 0) {
292                         ldb_asprintf_errstring(ldb,
293                                 "userAccountControl invalid!");
294                         return LDB_ERR_UNWILLING_TO_PERFORM;
295                 } else {
296                         account_type = ds_uf2atype(uac);
297                         ret = samdb_msg_add_uint(ldb,
298                                                  ac->msg, ac->msg,
299                                                  "sAMAccountType",
300                                                  account_type);
301                         if (ret != LDB_SUCCESS) {
302                                 return ret;
303                         }
304                 }
305         } else
306         if (strcmp("group", ac->type) == 0) {
307
308                 group_type = samdb_result_uint(ac->msg, "groupType", 0);
309                 if (group_type == 0) {
310                         ldb_asprintf_errstring(ldb,
311                                 "groupType invalid!\n");
312                         return LDB_ERR_UNWILLING_TO_PERFORM;
313                 } else {
314                         account_type = ds_gtype2atype(group_type);
315                         ret = samdb_msg_add_uint(ldb,
316                                                  ac->msg, ac->msg,
317                                                  "sAMAccountType",
318                                                  account_type);
319                         if (ret != LDB_SUCCESS) {
320                                 return ret;
321                         }
322                 }
323         }
324
325         return samldb_next_step(ac);
326 }
327
328 static bool samldb_msg_add_sid(struct ldb_message *msg,
329                                 const char *name,
330                                 const struct dom_sid *sid)
331 {
332         struct ldb_val v;
333         enum ndr_err_code ndr_err;
334
335         ndr_err = ndr_push_struct_blob(&v, msg, NULL, sid,
336                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
337         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
338                 return false;
339         }
340         return (ldb_msg_add_value(msg, name, &v, NULL) == 0);
341 }
342
343
344 /* allocate a SID using our RID Set */
345 static int samldb_allocate_sid(struct samldb_ctx *ac)
346 {
347         uint32_t rid;
348         int ret;
349         struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
350
351         ret = ridalloc_allocate_rid(ac->module, &rid);
352         if (ret != LDB_SUCCESS) {
353                 return ret;
354         }
355
356         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
357         if (ac->sid == NULL) {
358                 ldb_module_oom(ac->module);
359                 return LDB_ERR_OPERATIONS_ERROR;
360         }
361
362         if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
363                 return LDB_ERR_OPERATIONS_ERROR;
364         }
365
366         return samldb_next_step(ac);
367 }
368
369 /*
370  * samldb_dn_from_sid (async)
371  */
372
373 static int samldb_dn_from_sid(struct samldb_ctx *ac);
374
375 static int samldb_dn_from_sid_callback(struct ldb_request *req,
376         struct ldb_reply *ares)
377 {
378         struct ldb_context *ldb;
379         struct samldb_ctx *ac;
380         int ret;
381
382         ac = talloc_get_type(req->context, struct samldb_ctx);
383         ldb = ldb_module_get_ctx(ac->module);
384
385         if (!ares) {
386                 ret = LDB_ERR_OPERATIONS_ERROR;
387                 goto done;
388         }
389         if (ares->error != LDB_SUCCESS) {
390                 return ldb_module_done(ac->req, ares->controls,
391                                         ares->response, ares->error);
392         }
393
394         switch (ares->type) {
395         case LDB_REPLY_ENTRY:
396                 /* save entry */
397                 if (ac->res_dn != NULL) {
398                         /* one too many! */
399                         ldb_set_errstring(ldb,
400                                 "Invalid number of results while searching "
401                                 "for domain objects!");
402                         ret = LDB_ERR_OPERATIONS_ERROR;
403                         break;
404                 }
405                 ac->res_dn = ldb_dn_copy(ac, ares->message->dn);
406
407                 talloc_free(ares);
408                 ret = LDB_SUCCESS;
409                 break;
410
411         case LDB_REPLY_REFERRAL:
412                 /* ignore */
413                 talloc_free(ares);
414                 ret = LDB_SUCCESS;
415                 break;
416
417         case LDB_REPLY_DONE:
418                 talloc_free(ares);
419
420                 /* found or not found, go on */
421                 ret = samldb_next_step(ac);
422                 break;
423         }
424
425 done:
426         if (ret != LDB_SUCCESS) {
427                 return ldb_module_done(ac->req, NULL, NULL, ret);
428         }
429
430         return LDB_SUCCESS;
431 }
432
433 /* Finds the DN "res_dn" of an object with a given SID "sid" */
434 static int samldb_dn_from_sid(struct samldb_ctx *ac)
435 {
436         struct ldb_context *ldb;
437         static const char * const attrs[] = { NULL };
438         struct ldb_request *req;
439         char *filter;
440         int ret;
441
442         ldb = ldb_module_get_ctx(ac->module);
443
444         if (ac->sid == NULL)
445                 return LDB_ERR_OPERATIONS_ERROR;
446
447         filter = talloc_asprintf(ac, "(objectSid=%s)",
448                 ldap_encode_ndr_dom_sid(ac, ac->sid));
449         if (filter == NULL)
450                 return LDB_ERR_OPERATIONS_ERROR;
451
452         ret = ldb_build_search_req(&req, ldb, ac,
453                                 ldb_get_default_basedn(ldb),
454                                 LDB_SCOPE_SUBTREE,
455                                 filter, attrs,
456                                 NULL,
457                                 ac, samldb_dn_from_sid_callback,
458                                 ac->req);
459         if (ret != LDB_SUCCESS)
460                 return ret;
461
462         return ldb_next_request(ac->module, req);
463 }
464
465
466 static int samldb_check_primaryGroupID_1(struct samldb_ctx *ac)
467 {
468         struct ldb_context *ldb;
469         uint32_t rid;
470
471         ldb = ldb_module_get_ctx(ac->module);
472
473         rid = samdb_result_uint(ac->msg, "primaryGroupID", ~0);
474         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
475         if (ac->sid == NULL)
476                 return LDB_ERR_OPERATIONS_ERROR;
477         ac->res_dn = NULL;
478
479         return samldb_next_step(ac);
480 }
481
482 static int samldb_check_primaryGroupID_2(struct samldb_ctx *ac)
483 {
484         if (ac->res_dn == NULL) {
485                 struct ldb_context *ldb;
486                 ldb = ldb_module_get_ctx(ac->module);
487                 ldb_asprintf_errstring(ldb,
488                                        "Failed to find group sid %s!",
489                                        dom_sid_string(ac->sid, ac->sid));
490                 return LDB_ERR_UNWILLING_TO_PERFORM;
491         }
492
493         return samldb_next_step(ac);
494 }
495
496
497 /*
498  * samldb_set_defaultObjectCategory_callback (async)
499  */
500
501 static int samldb_set_defaultObjectCategory_callback(struct ldb_request *req,
502                                                      struct ldb_reply *ares)
503 {
504         struct ldb_context *ldb;
505         struct samldb_ctx *ac;
506         int ret;
507
508         ac = talloc_get_type(req->context, struct samldb_ctx);
509         ldb = ldb_module_get_ctx(ac->module);
510
511         if (!ares) {
512                 ret = LDB_ERR_OPERATIONS_ERROR;
513                 goto done;
514         }
515         if (ares->error != LDB_SUCCESS) {
516                 return ldb_module_done(ac->req, ares->controls,
517                                         ares->response, ares->error);
518         }
519         if (ares->type != LDB_REPLY_DONE) {
520                 ldb_set_errstring(ldb,
521                         "Invalid reply type!");
522                 ret = LDB_ERR_OPERATIONS_ERROR;
523                 goto done;
524         }
525
526         ret = samldb_next_step(ac);
527
528 done:
529         if (ret != LDB_SUCCESS) {
530                 return ldb_module_done(ac->req, NULL, NULL, ret);
531         }
532
533         return LDB_SUCCESS;
534 }
535
536 static int samldb_set_defaultObjectCategory(struct samldb_ctx *ac)
537 {
538         struct ldb_context *ldb;
539         struct ldb_message *msg;
540         struct ldb_request *req;
541         int ret;
542
543         ldb = ldb_module_get_ctx(ac->module);
544
545         /* (Re)set the default object category to have it set to the DN in the
546          * storage format */
547         msg = ldb_msg_new(ac);
548         msg->dn = ac->msg->dn;
549         ldb_msg_add_empty(msg, "defaultObjectCategory",
550                           LDB_FLAG_MOD_REPLACE, NULL);
551         ldb_msg_add_steal_string(msg, "defaultObjectCategory",
552                                  ldb_dn_alloc_linearized(msg, ac->dn));
553
554         ret = ldb_build_mod_req(&req, ldb, ac,
555                                 msg, NULL,
556                                 ac,
557                                 samldb_set_defaultObjectCategory_callback,
558                                 ac->req);
559         if (ret != LDB_SUCCESS) {
560                 talloc_free(msg);
561                 return ret;
562         }
563
564         return ldb_next_request(ac->module, req);
565 }
566
567 /*
568  * samldb_find_for_defaultObjectCategory (async)
569  */
570
571 static int samldb_find_for_defaultObjectCategory_callback(struct ldb_request *req,
572                                                           struct ldb_reply *ares)
573 {
574         struct ldb_context *ldb;
575         struct samldb_ctx *ac;
576         int ret;
577
578         ac = talloc_get_type(req->context, struct samldb_ctx);
579         ldb = ldb_module_get_ctx(ac->module);
580
581         if (!ares) {
582                 ret = LDB_ERR_OPERATIONS_ERROR;
583                 goto done;
584         }
585         if (ares->error != LDB_SUCCESS) {
586                 if (ares->error == LDB_ERR_NO_SUCH_OBJECT) {
587                         if (ldb_request_get_control(ac->req,
588                                                     LDB_CONTROL_RELAX_OID) != NULL) {
589                                 /* Don't be pricky when the DN doesn't exist */
590                                 /* if we have the RELAX control specified */
591                                 ac->dn = req->op.search.base;
592                                 return samldb_next_step(ac);
593                         } else {
594                                 ldb_set_errstring(ldb,
595                                         "samldb_find_defaultObjectCategory: "
596                                         "Invalid DN for 'defaultObjectCategory'!");
597                                 ares->error = LDB_ERR_CONSTRAINT_VIOLATION;
598                         }
599                 }
600
601                 return ldb_module_done(ac->req, ares->controls,
602                                        ares->response, ares->error);
603         }
604
605         switch (ares->type) {
606         case LDB_REPLY_ENTRY:
607                 ac->dn = talloc_steal(ac, ares->message->dn);
608
609                 ret = LDB_SUCCESS;
610                 break;
611
612         case LDB_REPLY_REFERRAL:
613                 /* this should not happen */
614                 talloc_free(ares);
615                 ret = LDB_ERR_OPERATIONS_ERROR;
616                 break;
617
618         case LDB_REPLY_DONE:
619                 talloc_free(ares);
620
621                 if (ac->dn != NULL) {
622                         /* when found go on */
623                         ret = samldb_next_step(ac);
624                 } else {
625                         ret = LDB_ERR_OPERATIONS_ERROR;
626                 }
627                 break;
628         }
629
630 done:
631         if (ret != LDB_SUCCESS) {
632                 return ldb_module_done(ac->req, NULL, NULL, ret);
633         }
634
635         return LDB_SUCCESS;
636 }
637
638 static int samldb_find_for_defaultObjectCategory(struct samldb_ctx *ac)
639 {
640         struct ldb_context *ldb;
641         struct ldb_request *req;
642         static const char *no_attrs[] = { NULL };
643         int ret;
644         const struct ldb_val *val;
645         struct ldb_dn *def_obj_cat_dn;
646
647         ldb = ldb_module_get_ctx(ac->module);
648
649         ac->dn = NULL;
650
651         val = ldb_msg_find_ldb_val(ac->msg, "defaultObjectCategory");
652         if (val != NULL) {
653                 /* "defaultObjectCategory" has been set by the caller. Do some
654                  * checks for consistency.
655                  * NOTE: The real constraint check (that 'defaultObjectCategory'
656                  * is the DN of the new objectclass or any parent of it) is
657                  * still incomplete.
658                  * For now we say that 'defaultObjectCategory' is valid if it
659                  * exists and it is of objectclass "classSchema". */
660                 def_obj_cat_dn = ldb_dn_from_ldb_val(ac, ldb, val);
661                 if (def_obj_cat_dn == NULL) {
662                         ldb_set_errstring(ldb,
663                                 "samldb_find_defaultObjectCategory: Invalid DN "
664                                 "for 'defaultObjectCategory'!");
665                         return LDB_ERR_CONSTRAINT_VIOLATION;
666                 }
667         } else {
668                 /* "defaultObjectCategory" has not been set by the caller. Use
669                  * the entry DN for it. */
670                 def_obj_cat_dn = ac->msg->dn;
671         }
672
673         ret = ldb_build_search_req(&req, ldb, ac,
674                                    def_obj_cat_dn, LDB_SCOPE_BASE,
675                                    "objectClass=classSchema", no_attrs,
676                                    NULL,
677                                    ac, samldb_find_for_defaultObjectCategory_callback,
678                                    ac->req);
679         if (ret != LDB_SUCCESS) {
680                 return ret;
681         }
682
683         ret = dsdb_request_add_controls(ac->module, req,
684                                         DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT);
685         if (ret != LDB_SUCCESS) {
686                 return ret;
687         }
688
689         return ldb_next_request(ac->module, req);
690 }
691
692
693 /*
694  * samldb_add_entry (async)
695  */
696
697 static int samldb_add_entry_callback(struct ldb_request *req,
698                                         struct ldb_reply *ares)
699 {
700         struct ldb_context *ldb;
701         struct samldb_ctx *ac;
702         int ret;
703
704         ac = talloc_get_type(req->context, struct samldb_ctx);
705         ldb = ldb_module_get_ctx(ac->module);
706
707         if (!ares) {
708                 return ldb_module_done(ac->req, NULL, NULL,
709                                         LDB_ERR_OPERATIONS_ERROR);
710         }
711         if (ares->error != LDB_SUCCESS) {
712                 return ldb_module_done(ac->req, ares->controls,
713                                         ares->response, ares->error);
714         }
715         if (ares->type != LDB_REPLY_DONE) {
716                 ldb_set_errstring(ldb,
717                         "Invalid reply type!\n");
718                 return ldb_module_done(ac->req, NULL, NULL,
719                                         LDB_ERR_OPERATIONS_ERROR);
720         }
721
722         /* The caller may wish to get controls back from the add */
723         ac->ares = talloc_steal(ac, ares);
724
725         ret = samldb_next_step(ac);
726         if (ret != LDB_SUCCESS) {
727                 return ldb_module_done(ac->req, NULL, NULL, ret);
728         }
729         return ret;
730 }
731
732 static int samldb_add_entry(struct samldb_ctx *ac)
733 {
734         struct ldb_context *ldb;
735         struct ldb_request *req;
736         int ret;
737
738         ldb = ldb_module_get_ctx(ac->module);
739
740         ret = ldb_build_add_req(&req, ldb, ac,
741                                 ac->msg,
742                                 ac->req->controls,
743                                 ac, samldb_add_entry_callback,
744                                 ac->req);
745         if (ret != LDB_SUCCESS) {
746                 return ret;
747         }
748
749         return ldb_next_request(ac->module, req);
750 }
751
752
753 static int samldb_fill_object(struct samldb_ctx *ac, const char *type)
754 {
755         struct ldb_context *ldb;
756         struct loadparm_context *lp_ctx;
757         enum sid_generator sid_generator;
758         int ret;
759
760         ldb = ldb_module_get_ctx(ac->module);
761
762         /* Add informations for the different account types */
763         ac->type = type;
764         if (strcmp(ac->type, "user") == 0) {
765                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
766                         "userAccountControl", "546");
767                 if (ret != LDB_SUCCESS) return ret;
768                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
769                         "badPwdCount", "0");
770                 if (ret != LDB_SUCCESS) return ret;
771                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
772                         "codePage", "0");
773                 if (ret != LDB_SUCCESS) return ret;
774                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
775                         "countryCode", "0");
776                 if (ret != LDB_SUCCESS) return ret;
777                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
778                         "badPasswordTime", "0");
779                 if (ret != LDB_SUCCESS) return ret;
780                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
781                         "lastLogoff", "0");
782                 if (ret != LDB_SUCCESS) return ret;
783                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
784                         "lastLogon", "0");
785                 if (ret != LDB_SUCCESS) return ret;
786                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
787                         "pwdLastSet", "0");
788                 if (ret != LDB_SUCCESS) return ret;
789                 if (!ldb_msg_find_element(ac->msg, "primaryGroupID")) {
790                         ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg,
791                                                  "primaryGroupID", DOMAIN_RID_USERS);
792                         if (ret != LDB_SUCCESS) return ret;
793                 }
794                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
795                         "accountExpires", "9223372036854775807");
796                 if (ret != LDB_SUCCESS) return ret;
797                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
798                         "logonCount", "0");
799                 if (ret != LDB_SUCCESS) return ret;
800         } else if (strcmp(ac->type, "group") == 0) {
801                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
802                         "groupType", "-2147483646");
803                 if (ret != LDB_SUCCESS) return ret;
804         } else if (strcmp(ac->type, "classSchema") == 0) {
805                 const struct ldb_val *rdn_value;
806
807                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
808                                                   "rdnAttId", "cn");
809                 if (ret != LDB_SUCCESS) return ret;
810
811                 rdn_value = ldb_dn_get_rdn_val(ac->msg->dn);
812                 if (!ldb_msg_find_element(ac->msg, "lDAPDisplayName")) {
813                         /* the RDN has prefix "CN" */
814                         ret = ldb_msg_add_string(ac->msg, "lDAPDisplayName",
815                                 samdb_cn_to_lDAPDisplayName(ac,
816                                         (const char *) rdn_value->data));
817                         if (ret != LDB_SUCCESS) {
818                                 ldb_oom(ldb);
819                                 return ret;
820                         }
821                 }
822
823                 if (!ldb_msg_find_element(ac->msg, "schemaIDGUID")) {
824                         struct GUID guid;
825                         /* a new GUID */
826                         guid = GUID_random();
827                         ret = dsdb_msg_add_guid(ac->msg, &guid, "schemaIDGUID");
828                         if (ret != LDB_SUCCESS) {
829                                 ldb_oom(ldb);
830                                 return ret;
831                         }
832                 }
833
834                 ret = samldb_add_step(ac, samldb_add_entry);
835                 if (ret != LDB_SUCCESS) return ret;
836
837                 ret = samldb_add_step(ac, samldb_find_for_defaultObjectCategory);
838                 if (ret != LDB_SUCCESS) return ret;
839
840                 ret = samldb_add_step(ac, samldb_set_defaultObjectCategory);
841                 if (ret != LDB_SUCCESS) return ret;
842
843                 return samldb_first_step(ac);
844         } else if (strcmp(ac->type, "attributeSchema") == 0) {
845                 const struct ldb_val *rdn_value;
846                 rdn_value = ldb_dn_get_rdn_val(ac->msg->dn);
847                 if (!ldb_msg_find_element(ac->msg, "lDAPDisplayName")) {
848                         /* the RDN has prefix "CN" */
849                         ret = ldb_msg_add_string(ac->msg, "lDAPDisplayName",
850                                 samdb_cn_to_lDAPDisplayName(ac,
851                                         (const char *) rdn_value->data));
852                         if (ret != LDB_SUCCESS) {
853                                 ldb_oom(ldb);
854                                 return ret;
855                         }
856                 }
857
858                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
859                                                   "isSingleValued", "FALSE");
860                 if (ret != LDB_SUCCESS) return ret;
861
862                 if (!ldb_msg_find_element(ac->msg, "schemaIDGUID")) {
863                         struct GUID guid;
864                         /* a new GUID */
865                         guid = GUID_random();
866                         ret = dsdb_msg_add_guid(ac->msg, &guid, "schemaIDGUID");
867                         if (ret != LDB_SUCCESS) {
868                                 ldb_oom(ldb);
869                                 return ret;
870                         }
871                 }
872
873                 ret = samldb_add_step(ac, samldb_add_entry);
874                 if (ret != LDB_SUCCESS) return ret;
875
876                 return samldb_first_step(ac);
877         } else {
878                 ldb_asprintf_errstring(ldb,
879                         "Invalid entry type!");
880                 return LDB_ERR_OPERATIONS_ERROR;
881         }
882
883         /* check if we have a valid samAccountName */
884         ret = samldb_add_step(ac, samldb_check_samAccountName);
885         if (ret != LDB_SUCCESS) return ret;
886
887         /* check account_type/group_type */
888         ret = samldb_add_step(ac, samldb_check_samAccountType);
889         if (ret != LDB_SUCCESS) return ret;
890
891         /* check if we have a valid primary group ID */
892         if (strcmp(ac->type, "user") == 0) {
893                 ret = samldb_add_step(ac, samldb_check_primaryGroupID_1);
894                 if (ret != LDB_SUCCESS) return ret;
895                 ret = samldb_add_step(ac, samldb_dn_from_sid);
896                 if (ret != LDB_SUCCESS) return ret;
897                 ret = samldb_add_step(ac, samldb_check_primaryGroupID_2);
898                 if (ret != LDB_SUCCESS) return ret;
899         }
900
901         lp_ctx = talloc_get_type(ldb_get_opaque(ldb, "loadparm"),
902                  struct loadparm_context);
903
904         /* don't allow objectSID to be specified without the RELAX control */
905         ac->sid = samdb_result_dom_sid(ac, ac->msg, "objectSid");
906         if (ac->sid && !ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID) &&
907             !dsdb_module_am_system(ac->module)) {
908                 ldb_asprintf_errstring(ldb, "No SID may be specified in user/group creation for %s",
909                                        ldb_dn_get_linearized(ac->msg->dn));
910                 return LDB_ERR_UNWILLING_TO_PERFORM;
911         }
912
913         if ( ! ac->sid) {
914                 sid_generator = lp_sid_generator(lp_ctx);
915                 if (sid_generator == SID_GENERATOR_INTERNAL) {
916                         ret = samldb_add_step(ac, samldb_allocate_sid);
917                         if (ret != LDB_SUCCESS) return ret;
918                 }
919         }
920
921         /* finally proceed with adding the entry */
922         ret = samldb_add_step(ac, samldb_add_entry);
923         if (ret != LDB_SUCCESS) return ret;
924
925         return samldb_first_step(ac);
926 }
927
928 static int samldb_fill_foreignSecurityPrincipal_object(struct samldb_ctx *ac)
929 {
930         struct ldb_context *ldb;
931         int ret;
932
933         ldb = ldb_module_get_ctx(ac->module);
934
935         ac->sid = samdb_result_dom_sid(ac->msg, ac->msg, "objectSid");
936         if (ac->sid == NULL) {
937                 ac->sid = dom_sid_parse_talloc(ac->msg,
938                            (const char *)ldb_dn_get_rdn_val(ac->msg->dn)->data);
939                 if (!ac->sid) {
940                         ldb_set_errstring(ldb,
941                                         "No valid SID found in "
942                                         "ForeignSecurityPrincipal CN!");
943                         talloc_free(ac);
944                         return LDB_ERR_CONSTRAINT_VIOLATION;
945                 }
946                 if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
947                         talloc_free(ac);
948                         return LDB_ERR_OPERATIONS_ERROR;
949                 }
950         }
951
952         /* finally proceed with adding the entry */
953         ret = samldb_add_step(ac, samldb_add_entry);
954         if (ret != LDB_SUCCESS) return ret;
955
956         return samldb_first_step(ac);
957 }
958
959 static int samldb_check_rdn(struct ldb_module *module, struct ldb_dn *dn)
960 {
961         struct ldb_context *ldb;
962         const char *rdn_name;
963
964         ldb = ldb_module_get_ctx(module);
965         rdn_name = ldb_dn_get_rdn_name(dn);
966
967         if (strcasecmp(rdn_name, "cn") != 0) {
968                 ldb_asprintf_errstring(ldb,
969                                         "Bad RDN (%s=) for samldb object, "
970                                         "should be CN=!", rdn_name);
971                 return LDB_ERR_CONSTRAINT_VIOLATION;
972         }
973
974         return LDB_SUCCESS;
975 }
976
977 /*
978  * samldb_sid_from_dn (async)
979  */
980
981 static int samldb_sid_from_dn(struct samldb_ctx *ac);
982
983 static int samldb_sid_from_dn_callback(struct ldb_request *req,
984         struct ldb_reply *ares)
985 {
986         struct ldb_context *ldb;
987         struct samldb_ctx *ac;
988         int ret;
989
990         ac = talloc_get_type(req->context, struct samldb_ctx);
991         ldb = ldb_module_get_ctx(ac->module);
992
993         if (!ares) {
994                 ret = LDB_ERR_OPERATIONS_ERROR;
995                 goto done;
996         }
997         if (ares->error != LDB_SUCCESS) {
998                 return ldb_module_done(ac->req, ares->controls,
999                                         ares->response, ares->error);
1000         }
1001
1002         switch (ares->type) {
1003         case LDB_REPLY_ENTRY:
1004                 /* save entry */
1005                 if (ac->res_sid != NULL) {
1006                         /* one too many! */
1007                         ldb_set_errstring(ldb,
1008                                 "Invalid number of results while searching "
1009                                 "for domain objects!");
1010                         ret = LDB_ERR_OPERATIONS_ERROR;
1011                         break;
1012                 }
1013                 ac->res_sid = samdb_result_dom_sid(ac, ares->message,
1014                         "objectSid");
1015
1016                 talloc_free(ares);
1017                 ret = LDB_SUCCESS;
1018                 break;
1019
1020         case LDB_REPLY_REFERRAL:
1021                 /* ignore */
1022                 talloc_free(ares);
1023                 ret = LDB_SUCCESS;
1024                 break;
1025
1026         case LDB_REPLY_DONE:
1027                 talloc_free(ares);
1028
1029                 /* found or not found, go on */
1030                 ret = samldb_next_step(ac);
1031                 break;
1032         }
1033
1034 done:
1035         if (ret != LDB_SUCCESS) {
1036                 return ldb_module_done(ac->req, NULL, NULL, ret);
1037         }
1038
1039         return LDB_SUCCESS;
1040 }
1041
1042 /* Finds the SID "res_sid" of an object with a given DN "dn" */
1043 static int samldb_sid_from_dn(struct samldb_ctx *ac)
1044 {
1045         struct ldb_context *ldb;
1046         static const char * const attrs[] = { "objectSid", NULL };
1047         struct ldb_request *req;
1048         int ret;
1049
1050         ldb = ldb_module_get_ctx(ac->module);
1051
1052         if (ac->dn == NULL)
1053                 return LDB_ERR_OPERATIONS_ERROR;
1054
1055         ret = ldb_build_search_req(&req, ldb, ac,
1056                                 ac->dn,
1057                                 LDB_SCOPE_BASE,
1058                                 NULL, attrs,
1059                                 NULL,
1060                                 ac, samldb_sid_from_dn_callback,
1061                                 ac->req);
1062         if (ret != LDB_SUCCESS)
1063                 return ret;
1064
1065         return ldb_next_request(ac->module, req);
1066 }
1067
1068 /*
1069  * samldb_user_dn_to_prim_group_rid (async)
1070  */
1071
1072 static int samldb_user_dn_to_prim_group_rid(struct samldb_ctx *ac);
1073
1074 static int samldb_user_dn_to_prim_group_rid_callback(struct ldb_request *req,
1075         struct ldb_reply *ares)
1076 {
1077         struct ldb_context *ldb;
1078         struct samldb_ctx *ac;
1079         int ret;
1080
1081         ac = talloc_get_type(req->context, struct samldb_ctx);
1082         ldb = ldb_module_get_ctx(ac->module);
1083
1084         if (!ares) {
1085                 ret = LDB_ERR_OPERATIONS_ERROR;
1086                 goto done;
1087         }
1088         if (ares->error != LDB_SUCCESS) {
1089                 return ldb_module_done(ac->req, ares->controls,
1090                                         ares->response, ares->error);
1091         }
1092
1093         switch (ares->type) {
1094         case LDB_REPLY_ENTRY:
1095                 /* save entry */
1096                 if (ac->prim_group_rid != 0) {
1097                         /* one too many! */
1098                         ldb_set_errstring(ldb,
1099                                 "Invalid number of results while searching "
1100                                 "for domain objects!");
1101                         ret = LDB_ERR_OPERATIONS_ERROR;
1102                         break;
1103                 }
1104                 ac->prim_group_rid = samdb_result_uint(ares->message,
1105                         "primaryGroupID", ~0);
1106
1107                 talloc_free(ares);
1108                 ret = LDB_SUCCESS;
1109                 break;
1110
1111         case LDB_REPLY_REFERRAL:
1112                 /* ignore */
1113                 talloc_free(ares);
1114                 ret = LDB_SUCCESS;
1115                 break;
1116
1117         case LDB_REPLY_DONE:
1118                 talloc_free(ares);
1119                 if (ac->prim_group_rid == 0) {
1120                         ldb_asprintf_errstring(ldb,
1121                                 "Unable to get the primary group RID!");
1122                         ret = LDB_ERR_OPERATIONS_ERROR;
1123                         break;
1124                 }
1125
1126                 /* found, go on */
1127                 ret = samldb_next_step(ac);
1128                 break;
1129         }
1130
1131 done:
1132         if (ret != LDB_SUCCESS) {
1133                 return ldb_module_done(ac->req, NULL, NULL, ret);
1134         }
1135
1136         return LDB_SUCCESS;
1137 }
1138
1139 /* Locates the "primaryGroupID" attribute from a certain user specified as
1140  * "user_dn". Saves the result in "prim_group_rid". */
1141 static int samldb_user_dn_to_prim_group_rid(struct samldb_ctx *ac)
1142 {
1143         struct ldb_context *ldb;
1144         static const char * const attrs[] = { "primaryGroupID", NULL };
1145         struct ldb_request *req;
1146         int ret;
1147
1148         ldb = ldb_module_get_ctx(ac->module);
1149
1150         if (ac->user_dn == NULL)
1151                 return LDB_ERR_OPERATIONS_ERROR;
1152
1153         ret = ldb_build_search_req(&req, ldb, ac,
1154                                 ac->user_dn,
1155                                 LDB_SCOPE_BASE,
1156                                 NULL, attrs,
1157                                 NULL,
1158                                 ac, samldb_user_dn_to_prim_group_rid_callback,
1159                                 ac->req);
1160         if (ret != LDB_SUCCESS)
1161                 return ret;
1162
1163         return ldb_next_request(ac->module, req);
1164 }
1165
1166 /*
1167  * samldb_prim_group_rid_to_users_cnt (async)
1168  */
1169
1170 static int samldb_prim_group_rid_to_users_cnt(struct samldb_ctx *ac);
1171
1172 static int samldb_prim_group_rid_to_users_cnt_callback(struct ldb_request *req,
1173         struct ldb_reply *ares)
1174 {
1175         struct ldb_context *ldb;
1176         struct samldb_ctx *ac;
1177         int ret;
1178
1179         ac = talloc_get_type(req->context, struct samldb_ctx);
1180         ldb = ldb_module_get_ctx(ac->module);
1181
1182         if (!ares) {
1183                 ret = LDB_ERR_OPERATIONS_ERROR;
1184                 goto done;
1185         }
1186         if (ares->error != LDB_SUCCESS) {
1187                 return ldb_module_done(ac->req, ares->controls,
1188                                         ares->response, ares->error);
1189         }
1190
1191         switch (ares->type) {
1192         case LDB_REPLY_ENTRY:
1193                 /* save entry */
1194                 ++(ac->users_cnt);
1195
1196                 talloc_free(ares);
1197                 ret = LDB_SUCCESS;
1198                 break;
1199
1200         case LDB_REPLY_REFERRAL:
1201                 /* ignore */
1202                 talloc_free(ares);
1203                 ret = LDB_SUCCESS;
1204                 break;
1205
1206         case LDB_REPLY_DONE:
1207                 talloc_free(ares);
1208
1209                 /* found or not found, go on */
1210                 ret = samldb_next_step(ac);
1211                 break;
1212         }
1213
1214 done:
1215         if (ret != LDB_SUCCESS) {
1216                 return ldb_module_done(ac->req, NULL, NULL, ret);
1217         }
1218
1219         return LDB_SUCCESS;
1220 }
1221
1222 /* Finds the amount of users which have the primary group "prim_group_rid" and
1223  * save the result in "users_cnt" */
1224 static int samldb_prim_group_rid_to_users_cnt(struct samldb_ctx *ac)
1225 {
1226         struct ldb_context *ldb;
1227         static const char * const attrs[] = { NULL };
1228         struct ldb_request *req;
1229         char *filter;
1230         int ret;
1231
1232         ldb = ldb_module_get_ctx(ac->module);
1233
1234         if ((ac->prim_group_rid == 0) || (ac->users_cnt != 0))
1235                 return LDB_ERR_OPERATIONS_ERROR;
1236
1237         filter = talloc_asprintf(ac, "(&(primaryGroupID=%u)(objectclass=user))",
1238                 ac->prim_group_rid);
1239         if (filter == NULL)
1240                 return LDB_ERR_OPERATIONS_ERROR;
1241
1242         ret = ldb_build_search_req(&req, ldb, ac,
1243                                 ldb_get_default_basedn(ldb),
1244                                 LDB_SCOPE_SUBTREE,
1245                                 filter, attrs,
1246                                 NULL,
1247                                 ac,
1248                                 samldb_prim_group_rid_to_users_cnt_callback,
1249                                 ac->req);
1250         if (ret != LDB_SUCCESS)
1251                 return ret;
1252
1253         return ldb_next_request(ac->module, req);
1254 }
1255
1256 /*
1257  * samldb_group_add_member (async)
1258  * samldb_group_del_member (async)
1259  */
1260
1261 static int samldb_group_add_del_member_callback(struct ldb_request *req,
1262         struct ldb_reply *ares)
1263 {
1264         struct ldb_context *ldb;
1265         struct samldb_ctx *ac;
1266         int ret;
1267
1268         ac = talloc_get_type(req->context, struct samldb_ctx);
1269         ldb = ldb_module_get_ctx(ac->module);
1270
1271         if (!ares) {
1272                 ret = LDB_ERR_OPERATIONS_ERROR;
1273                 goto done;
1274         }
1275         if (ares->error != LDB_SUCCESS) {
1276                 if (ares->error == LDB_ERR_NO_SUCH_ATTRIBUTE) {
1277                         /* On error "NO_SUCH_ATTRIBUTE" (delete of an invalid
1278                          * "member" attribute) return "UNWILLING_TO_PERFORM" */
1279                         ares->error = LDB_ERR_UNWILLING_TO_PERFORM;
1280                 }
1281                 return ldb_module_done(ac->req, ares->controls,
1282                                         ares->response, ares->error);
1283         }
1284         if (ares->type != LDB_REPLY_DONE) {
1285                 ldb_set_errstring(ldb,
1286                         "Invalid reply type!");
1287                 ret = LDB_ERR_OPERATIONS_ERROR;
1288                 goto done;
1289         }
1290
1291         ret = samldb_next_step(ac);
1292
1293 done:
1294         if (ret != LDB_SUCCESS) {
1295                 return ldb_module_done(ac->req, NULL, NULL, ret);
1296         }
1297
1298         return LDB_SUCCESS;
1299 }
1300
1301 /* Adds a member with DN "member_dn" to a group with DN "group_dn" */
1302 static int samldb_group_add_member(struct samldb_ctx *ac)
1303 {
1304         struct ldb_context *ldb;
1305         struct ldb_request *req;
1306         struct ldb_message *msg;
1307         int ret;
1308
1309         ldb = ldb_module_get_ctx(ac->module);
1310
1311         if ((ac->group_dn == NULL) || (ac->member_dn == NULL))
1312                 return LDB_ERR_OPERATIONS_ERROR;
1313
1314         msg = ldb_msg_new(ac);
1315         msg->dn = ac->group_dn;
1316         samdb_msg_add_addval(ldb, ac, msg, "member",
1317                 ldb_dn_get_linearized(ac->member_dn));
1318
1319         ret = ldb_build_mod_req(&req, ldb, ac,
1320                                 msg, NULL,
1321                                 ac, samldb_group_add_del_member_callback,
1322                                 ac->req);
1323         if (ret != LDB_SUCCESS)
1324                 return ret;
1325
1326         return ldb_next_request(ac->module, req);
1327 }
1328
1329 /* Removes a member with DN "member_dn" from a group with DN "group_dn" */
1330 static int samldb_group_del_member(struct samldb_ctx *ac)
1331 {
1332         struct ldb_context *ldb;
1333         struct ldb_request *req;
1334         struct ldb_message *msg;
1335         int ret;
1336
1337         ldb = ldb_module_get_ctx(ac->module);
1338
1339         if ((ac->group_dn == NULL) || (ac->member_dn == NULL))
1340                 return LDB_ERR_OPERATIONS_ERROR;
1341
1342         msg = ldb_msg_new(ac);
1343         msg->dn = ac->group_dn;
1344         samdb_msg_add_delval(ldb, ac, msg, "member",
1345                 ldb_dn_get_linearized(ac->member_dn));
1346
1347         ret = ldb_build_mod_req(&req, ldb, ac,
1348                                 msg, NULL,
1349                                 ac, samldb_group_add_del_member_callback,
1350                                 ac->req);
1351         if (ret != LDB_SUCCESS)
1352                 return ret;
1353
1354         return ldb_next_request(ac->module, req);
1355 }
1356
1357
1358 static int samldb_prim_group_change_1(struct samldb_ctx *ac)
1359 {
1360         struct ldb_context *ldb;
1361         uint32_t rid;
1362
1363         ldb = ldb_module_get_ctx(ac->module);
1364
1365         ac->user_dn = ac->msg->dn;
1366
1367         rid = samdb_result_uint(ac->msg, "primaryGroupID", ~0);
1368         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
1369         if (ac->sid == NULL)
1370                 return LDB_ERR_OPERATIONS_ERROR;
1371         ac->res_dn = NULL;
1372
1373         ac->prim_group_rid = 0;
1374
1375         return samldb_next_step(ac);
1376 }
1377
1378 static int samldb_prim_group_change_2(struct samldb_ctx *ac)
1379 {
1380         struct ldb_context *ldb;
1381
1382         ldb = ldb_module_get_ctx(ac->module);
1383
1384         if (ac->res_dn != NULL)
1385                 ac->new_prim_group_dn = ac->res_dn;
1386         else
1387                 return LDB_ERR_UNWILLING_TO_PERFORM;
1388
1389         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb),
1390                 ac->prim_group_rid);
1391         if (ac->sid == NULL)
1392                 return LDB_ERR_OPERATIONS_ERROR;
1393         ac->res_dn = NULL;
1394
1395         return samldb_next_step(ac);
1396 }
1397
1398 static int samldb_prim_group_change_4(struct samldb_ctx *ac);
1399 static int samldb_prim_group_change_5(struct samldb_ctx *ac);
1400 static int samldb_prim_group_change_6(struct samldb_ctx *ac);
1401
1402 static int samldb_prim_group_change_3(struct samldb_ctx *ac)
1403 {
1404         int ret;
1405
1406         if (ac->res_dn != NULL)
1407                 ac->old_prim_group_dn = ac->res_dn;
1408         else
1409                 return LDB_ERR_UNWILLING_TO_PERFORM;
1410
1411         /* Only update when the primary group changed */
1412         if (ldb_dn_compare(ac->old_prim_group_dn, ac->new_prim_group_dn) != 0) {
1413                 ac->member_dn = ac->user_dn;
1414                 /* Remove the "member" attribute of the actual (new) primary
1415                  * group */
1416
1417                 ret = samldb_add_step(ac, samldb_prim_group_change_4);
1418                 if (ret != LDB_SUCCESS) return ret;
1419
1420                 ret = samldb_add_step(ac, samldb_group_del_member);
1421                 if (ret != LDB_SUCCESS) return ret;
1422
1423                 /* Add a "member" attribute for the previous primary group */
1424
1425                 ret = samldb_add_step(ac, samldb_prim_group_change_5);
1426                 if (ret != LDB_SUCCESS) return ret;
1427
1428                 ret = samldb_add_step(ac, samldb_group_add_member);
1429                 if (ret != LDB_SUCCESS) return ret;
1430         }
1431
1432         ret = samldb_add_step(ac, samldb_prim_group_change_6);
1433         if (ret != LDB_SUCCESS) return ret;
1434
1435         return samldb_next_step(ac);
1436 }
1437
1438 static int samldb_prim_group_change_4(struct samldb_ctx *ac)
1439 {
1440         ac->group_dn = ac->new_prim_group_dn;
1441
1442         return samldb_next_step(ac);
1443 }
1444
1445 static int samldb_prim_group_change_5(struct samldb_ctx *ac)
1446 {
1447         ac->group_dn = ac->old_prim_group_dn;
1448
1449         return samldb_next_step(ac);
1450 }
1451
1452 static int samldb_prim_group_change_6(struct samldb_ctx *ac)
1453 {
1454         return ldb_next_request(ac->module, ac->req);
1455 }
1456
1457 static int samldb_prim_group_change(struct samldb_ctx *ac)
1458 {
1459         int ret;
1460
1461         /* Finds out the DN of the new primary group */
1462
1463         ret = samldb_add_step(ac, samldb_prim_group_change_1);
1464         if (ret != LDB_SUCCESS) return ret;
1465
1466         ret = samldb_add_step(ac, samldb_dn_from_sid);
1467         if (ret != LDB_SUCCESS) return ret;
1468
1469         ret = samldb_add_step(ac, samldb_user_dn_to_prim_group_rid);
1470         if (ret != LDB_SUCCESS) return ret;
1471
1472         /* Finds out the DN of the old primary group */
1473
1474         ret = samldb_add_step(ac, samldb_prim_group_change_2);
1475         if (ret != LDB_SUCCESS) return ret;
1476
1477         ret = samldb_add_step(ac, samldb_dn_from_sid);
1478         if (ret != LDB_SUCCESS) return ret;
1479
1480         ret = samldb_add_step(ac, samldb_prim_group_change_3);
1481         if (ret != LDB_SUCCESS) return ret;
1482
1483         return samldb_first_step(ac);
1484 }
1485
1486
1487 static int samldb_member_check_1(struct samldb_ctx *ac)
1488 {
1489         struct ldb_context *ldb;
1490         struct ldb_message_element *el;
1491
1492         ldb = ldb_module_get_ctx(ac->module);
1493
1494         el = ldb_msg_find_element(ac->msg, "member");
1495
1496         ac->user_dn = ldb_dn_from_ldb_val(ac, ldb, &el->values[ac->cnt]);
1497         if (!ldb_dn_validate(ac->user_dn))
1498                 return LDB_ERR_OPERATIONS_ERROR;
1499         ac->prim_group_rid = 0;
1500
1501         return samldb_next_step(ac);
1502 }
1503
1504 static int samldb_member_check_2(struct samldb_ctx *ac)
1505 {
1506         struct ldb_context *ldb;
1507
1508         ldb = ldb_module_get_ctx(ac->module);
1509
1510         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb),
1511                 ac->prim_group_rid);
1512         if (ac->sid == NULL)
1513                 return LDB_ERR_OPERATIONS_ERROR;
1514         ac->res_dn = NULL;
1515
1516         return samldb_next_step(ac);
1517 }
1518
1519 static int samldb_member_check_3(struct samldb_ctx *ac)
1520 {
1521         if (ldb_dn_compare(ac->res_dn, ac->msg->dn) == 0)
1522                 return LDB_ERR_ENTRY_ALREADY_EXISTS;
1523
1524         ++(ac->cnt);
1525
1526         return samldb_next_step(ac);
1527 }
1528
1529 static int samldb_member_check_4(struct samldb_ctx *ac)
1530 {
1531         return ldb_next_request(ac->module, ac->req);
1532 }
1533
1534 static int samldb_member_check(struct samldb_ctx *ac)
1535 {
1536         struct ldb_message_element *el;
1537         int i, ret;
1538
1539         el = ldb_msg_find_element(ac->msg, "member");
1540         ac->cnt = 0;
1541         for (i = 0; i < el->num_values; i++) {
1542                 /* Denies to add "member"s to groups which are primary ones
1543                  * for them */
1544                 ret = samldb_add_step(ac, samldb_member_check_1);
1545                 if (ret != LDB_SUCCESS) return ret;
1546
1547                 ret = samldb_add_step(ac, samldb_user_dn_to_prim_group_rid);
1548                 if (ret != LDB_SUCCESS) return ret;
1549
1550                 ret = samldb_add_step(ac, samldb_member_check_2);
1551                 if (ret != LDB_SUCCESS) return ret;
1552
1553                 ret = samldb_add_step(ac, samldb_dn_from_sid);
1554                 if (ret != LDB_SUCCESS) return ret;
1555
1556                 ret = samldb_add_step(ac, samldb_member_check_3);
1557                 if (ret != LDB_SUCCESS) return ret;
1558         }
1559
1560         ret = samldb_add_step(ac, samldb_member_check_4);
1561         if (ret != LDB_SUCCESS) return ret;
1562
1563         return samldb_first_step(ac);
1564 }
1565
1566
1567 static int samldb_prim_group_users_check_1(struct samldb_ctx *ac)
1568 {
1569         ac->dn = ac->req->op.del.dn;
1570         ac->res_sid = NULL;
1571
1572         return samldb_next_step(ac);
1573 }
1574
1575 static int samldb_prim_group_users_check_2(struct samldb_ctx *ac)
1576 {
1577         NTSTATUS status;
1578         uint32_t rid;
1579
1580         if (ac->res_sid == NULL) {
1581                 /* No SID - therefore ok here */
1582                 return ldb_next_request(ac->module, ac->req);
1583         }
1584         status = dom_sid_split_rid(ac, ac->res_sid, NULL, &rid);
1585         if (!NT_STATUS_IS_OK(status))
1586                 return LDB_ERR_OPERATIONS_ERROR;
1587
1588         if (rid == 0) {
1589                 /* Special object (security principal?) */
1590                 return ldb_next_request(ac->module, ac->req);
1591         }
1592
1593         ac->prim_group_rid = rid;
1594         ac->users_cnt = 0;
1595
1596         return samldb_next_step(ac);
1597 }
1598
1599 static int samldb_prim_group_users_check_3(struct samldb_ctx *ac)
1600 {
1601         if (ac->users_cnt > 0)
1602                 return LDB_ERR_ENTRY_ALREADY_EXISTS;
1603
1604         return ldb_next_request(ac->module, ac->req);
1605 }
1606
1607 static int samldb_prim_group_users_check(struct samldb_ctx *ac)
1608 {
1609         int ret;
1610
1611         /* Finds out the SID/RID of the domain object */
1612
1613         ret = samldb_add_step(ac, samldb_prim_group_users_check_1);
1614         if (ret != LDB_SUCCESS) return ret;
1615
1616         ret = samldb_add_step(ac, samldb_sid_from_dn);
1617         if (ret != LDB_SUCCESS) return ret;
1618
1619         /* Deny delete requests from groups which are primary ones */
1620
1621         ret = samldb_add_step(ac, samldb_prim_group_users_check_2);
1622         if (ret != LDB_SUCCESS) return ret;
1623
1624         ret = samldb_add_step(ac, samldb_prim_group_rid_to_users_cnt);
1625         if (ret != LDB_SUCCESS) return ret;
1626
1627         ret = samldb_add_step(ac, samldb_prim_group_users_check_3);
1628         if (ret != LDB_SUCCESS) return ret;
1629
1630         return samldb_first_step(ac);
1631 }
1632
1633
1634 /* add */
1635 static int samldb_add(struct ldb_module *module, struct ldb_request *req)
1636 {
1637         struct ldb_context *ldb;
1638         struct samldb_ctx *ac;
1639         int ret;
1640
1641         ldb = ldb_module_get_ctx(module);
1642         ldb_debug(ldb, LDB_DEBUG_TRACE, "samldb_add\n");
1643
1644         /* do not manipulate our control entries */
1645         if (ldb_dn_is_special(req->op.add.message->dn)) {
1646                 return ldb_next_request(module, req);
1647         }
1648
1649         ac = samldb_ctx_init(module, req);
1650         if (ac == NULL) {
1651                 return LDB_ERR_OPERATIONS_ERROR;
1652         }
1653
1654         /* build the new msg */
1655         ac->msg = ldb_msg_copy(ac, ac->req->op.add.message);
1656         if (!ac->msg) {
1657                 talloc_free(ac);
1658                 ldb_debug(ldb, LDB_DEBUG_FATAL,
1659                           "samldb_add: ldb_msg_copy failed!\n");
1660                 return LDB_ERR_OPERATIONS_ERROR;
1661         }
1662
1663         if (samdb_find_attribute(ldb, ac->msg,
1664                                  "objectclass", "computer") != NULL) {
1665
1666                 /* make sure the computer object also has the 'user'
1667                  * objectclass so it will be handled by the next call */
1668                 ret = samdb_find_or_add_value(ldb, ac->msg,
1669                                                 "objectclass", "user");
1670                 if (ret != LDB_SUCCESS) {
1671                         talloc_free(ac);
1672                         return ret;
1673                 }
1674         }
1675
1676         if (samdb_find_attribute(ldb, ac->msg,
1677                                  "objectclass", "user") != NULL) {
1678
1679                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1680                 if (ret != LDB_SUCCESS) {
1681                         talloc_free(ac);
1682                         return ret;
1683                 }
1684
1685                 return samldb_fill_object(ac, "user");
1686         }
1687
1688         if (samdb_find_attribute(ldb, ac->msg,
1689                                  "objectclass", "group") != NULL) {
1690
1691                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1692                 if (ret != LDB_SUCCESS) {
1693                         talloc_free(ac);
1694                         return ret;
1695                 }
1696
1697                 return samldb_fill_object(ac, "group");
1698         }
1699
1700         /* perhaps a foreignSecurityPrincipal? */
1701         if (samdb_find_attribute(ldb, ac->msg,
1702                                  "objectclass",
1703                                  "foreignSecurityPrincipal") != NULL) {
1704
1705                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1706                 if (ret != LDB_SUCCESS) {
1707                         talloc_free(ac);
1708                         return ret;
1709                 }
1710
1711                 return samldb_fill_foreignSecurityPrincipal_object(ac);
1712         }
1713
1714         if (samdb_find_attribute(ldb, ac->msg,
1715                                  "objectclass", "classSchema") != NULL) {
1716
1717                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1718                 if (ret != LDB_SUCCESS) {
1719                         talloc_free(ac);
1720                         return ret;
1721                 }
1722
1723                 return samldb_fill_object(ac, "classSchema");
1724         }
1725
1726         if (samdb_find_attribute(ldb, ac->msg,
1727                                  "objectclass", "attributeSchema") != NULL) {
1728
1729                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1730                 if (ret != LDB_SUCCESS) {
1731                         talloc_free(ac);
1732                         return ret;
1733                 }
1734
1735                 return samldb_fill_object(ac, "attributeSchema");
1736         }
1737
1738         talloc_free(ac);
1739
1740         /* nothing matched, go on */
1741         return ldb_next_request(module, req);
1742 }
1743
1744 /* modify */
1745 static int samldb_modify(struct ldb_module *module, struct ldb_request *req)
1746 {
1747         struct ldb_context *ldb;
1748         struct ldb_message *msg;
1749         struct ldb_message_element *el, *el2;
1750         int ret;
1751         uint32_t account_type;
1752
1753         if (ldb_dn_is_special(req->op.mod.message->dn)) {
1754                 /* do not manipulate our control entries */
1755                 return ldb_next_request(module, req);
1756         }
1757
1758         ldb = ldb_module_get_ctx(module);
1759
1760         if (ldb_msg_find_element(req->op.mod.message, "sAMAccountType") != NULL) {
1761                 ldb_asprintf_errstring(ldb,
1762                         "sAMAccountType must not be specified!");
1763                 return LDB_ERR_UNWILLING_TO_PERFORM;
1764         }
1765
1766         /* TODO: do not modify original request, create a new one */
1767
1768         el = ldb_msg_find_element(req->op.mod.message, "groupType");
1769         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1770                 uint32_t group_type;
1771
1772                 req->op.mod.message = msg = ldb_msg_copy_shallow(req,
1773                         req->op.mod.message);
1774
1775                 group_type = strtoul((const char *)el->values[0].data, NULL, 0);
1776                 account_type =  ds_gtype2atype(group_type);
1777                 ret = samdb_msg_add_uint(ldb, msg, msg,
1778                                          "sAMAccountType",
1779                                          account_type);
1780                 if (ret != LDB_SUCCESS) {
1781                         return ret;
1782                 }
1783                 el2 = ldb_msg_find_element(msg, "sAMAccountType");
1784                 el2->flags = LDB_FLAG_MOD_REPLACE;
1785         }
1786
1787         el = ldb_msg_find_element(req->op.mod.message, "primaryGroupID");
1788         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1789                 struct samldb_ctx *ac;
1790
1791                 ac = samldb_ctx_init(module, req);
1792                 if (ac == NULL)
1793                         return LDB_ERR_OPERATIONS_ERROR;
1794
1795                 req->op.mod.message = ac->msg = ldb_msg_copy_shallow(req,
1796                         req->op.mod.message);
1797
1798                 return samldb_prim_group_change(ac);
1799         }
1800
1801         el = ldb_msg_find_element(req->op.mod.message, "userAccountControl");
1802         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1803                 uint32_t user_account_control;
1804
1805                 req->op.mod.message = msg = ldb_msg_copy_shallow(req,
1806                         req->op.mod.message);
1807
1808                 user_account_control = strtoul((const char *)el->values[0].data,
1809                         NULL, 0);
1810                 account_type = ds_uf2atype(user_account_control);
1811                 ret = samdb_msg_add_uint(ldb, msg, msg,
1812                                          "sAMAccountType",
1813                                          account_type);
1814                 if (ret != LDB_SUCCESS) {
1815                         return ret;
1816                 }
1817                 el2 = ldb_msg_find_element(msg, "sAMAccountType");
1818                 el2->flags = LDB_FLAG_MOD_REPLACE;
1819
1820                 if (user_account_control & UF_SERVER_TRUST_ACCOUNT) {
1821                         ret = samdb_msg_add_string(ldb, msg, msg,
1822                                                    "isCriticalSystemObject", "TRUE");
1823                         if (ret != LDB_SUCCESS) {
1824                                 return ret;
1825                         }
1826                         el2 = ldb_msg_find_element(msg, "isCriticalSystemObject");
1827                         el2->flags = LDB_FLAG_MOD_REPLACE;
1828
1829                         /* DCs have primaryGroupID of DOMAIN_RID_DCS */
1830                         if (!ldb_msg_find_element(msg, "primaryGroupID")) {
1831                                 ret = samdb_msg_add_uint(ldb, msg, msg,
1832                                                          "primaryGroupID", DOMAIN_RID_DCS);
1833                                 if (ret != LDB_SUCCESS) {
1834                                         return ret;
1835                                 }
1836                                 el2 = ldb_msg_find_element(msg, "primaryGroupID");
1837                                 el2->flags = LDB_FLAG_MOD_REPLACE;
1838                         }
1839                 }
1840         }
1841
1842         el = ldb_msg_find_element(req->op.mod.message, "member");
1843         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1844                 struct samldb_ctx *ac;
1845
1846                 ac = samldb_ctx_init(module, req);
1847                 if (ac == NULL)
1848                         return LDB_ERR_OPERATIONS_ERROR;
1849
1850                 req->op.mod.message = ac->msg = ldb_msg_copy_shallow(req,
1851                         req->op.mod.message);
1852
1853                 return samldb_member_check(ac);
1854         }
1855
1856         /* nothing matched, go on */
1857         return ldb_next_request(module, req);
1858 }
1859
1860 /* delete */
1861 static int samldb_delete(struct ldb_module *module, struct ldb_request *req)
1862 {
1863         struct samldb_ctx *ac;
1864
1865         if (ldb_dn_is_special(req->op.del.dn)) {
1866                 /* do not manipulate our control entries */
1867                 return ldb_next_request(module, req);
1868         }
1869
1870         ac = samldb_ctx_init(module, req);
1871         if (ac == NULL)
1872                 return LDB_ERR_OPERATIONS_ERROR;
1873
1874         return samldb_prim_group_users_check(ac);
1875 }
1876
1877 static int samldb_extended_allocate_rid_pool(struct ldb_module *module, struct ldb_request *req)
1878 {
1879         struct ldb_context *ldb = ldb_module_get_ctx(module);
1880         struct dsdb_fsmo_extended_op *exop;
1881         int ret;
1882
1883         exop = talloc_get_type(req->op.extended.data, struct dsdb_fsmo_extended_op);
1884         if (!exop) {
1885                 ldb_debug(ldb, LDB_DEBUG_FATAL, "samldb_extended_allocate_rid_pool: invalid extended data\n");
1886                 return LDB_ERR_PROTOCOL_ERROR;
1887         }
1888
1889         ret = ridalloc_allocate_rid_pool_fsmo(module, exop);
1890         if (ret != LDB_SUCCESS) {
1891                 return ret;
1892         }
1893
1894         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
1895 }
1896
1897 static int samldb_extended(struct ldb_module *module, struct ldb_request *req)
1898 {
1899         if (strcmp(req->op.extended.oid, DSDB_EXTENDED_ALLOCATE_RID_POOL) == 0) {
1900                 return samldb_extended_allocate_rid_pool(module, req);
1901         }
1902
1903         return ldb_next_request(module, req);
1904 }
1905
1906
1907 _PUBLIC_ const struct ldb_module_ops ldb_samldb_module_ops = {
1908         .name          = "samldb",
1909         .add           = samldb_add,
1910         .modify        = samldb_modify,
1911         .del           = samldb_delete,
1912         .extended      = samldb_extended
1913 };
1914