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