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                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
 790                         "primaryGroupID", "513");
 791                 if (ret != LDB_SUCCESS) return ret;
 792                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
 793                         "accountExpires", "9223372036854775807");
 794                 if (ret != LDB_SUCCESS) return ret;
 795                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
 796                         "logonCount", "0");
 797                 if (ret != LDB_SUCCESS) return ret;
 798         } else if (strcmp(ac->type, "group") == 0) {
 799                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
 800                         "groupType", "-2147483646");
 801                 if (ret != LDB_SUCCESS) return ret;
 802         } else if (strcmp(ac->type, "classSchema") == 0) {
 803                 const struct ldb_val *rdn_value;
 804
 805                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
 806                                                   "rdnAttId", "cn");
 807                 if (ret != LDB_SUCCESS) return ret;
 808
 809                 rdn_value = ldb_dn_get_rdn_val(ac->msg->dn);
 810                 if (!ldb_msg_find_element(ac->msg, "lDAPDisplayName")) {
 811                         /* the RDN has prefix "CN" */
 812                         ret = ldb_msg_add_string(ac->msg, "lDAPDisplayName",
 813                                 samdb_cn_to_lDAPDisplayName(ac,
 814                                         (const char *) rdn_value->data));
 815                         if (ret != LDB_SUCCESS) {
 816                                 ldb_oom(ldb);
 817                                 return ret;
 818                         }
 819                 }
 820
 821                 if (!ldb_msg_find_element(ac->msg, "schemaIDGUID")) {
 822                         struct GUID guid;
 823                         /* a new GUID */
 824                         guid = GUID_random();
 825                         ret = dsdb_msg_add_guid(ac->msg, &guid, "schemaIDGUID");
 826                         if (ret != LDB_SUCCESS) {
 827                                 ldb_oom(ldb);
 828                                 return ret;
 829                         }
 830                 }
 831
 832                 ret = samldb_add_step(ac, samldb_add_entry);
 833                 if (ret != LDB_SUCCESS) return ret;
 834
 835                 ret = samldb_add_step(ac, samldb_find_for_defaultObjectCategory);
 836                 if (ret != LDB_SUCCESS) return ret;
 837
 838                 ret = samldb_add_step(ac, samldb_set_defaultObjectCategory);
 839                 if (ret != LDB_SUCCESS) return ret;
 840
 841                 return samldb_first_step(ac);
 842         } else if (strcmp(ac->type, "attributeSchema") == 0) {
 843                 const struct ldb_val *rdn_value;
 844                 rdn_value = ldb_dn_get_rdn_val(ac->msg->dn);
 845                 if (!ldb_msg_find_element(ac->msg, "lDAPDisplayName")) {
 846                         /* the RDN has prefix "CN" */
 847                         ret = ldb_msg_add_string(ac->msg, "lDAPDisplayName",
 848                                 samdb_cn_to_lDAPDisplayName(ac,
 849                                         (const char *) rdn_value->data));
 850                         if (ret != LDB_SUCCESS) {
 851                                 ldb_oom(ldb);
 852                                 return ret;
 853                         }
 854                 }
 855
 856                 ret = samdb_find_or_add_attribute(ldb, ac->msg,
 857                                                   "isSingleValued", "FALSE");
 858                 if (ret != LDB_SUCCESS) return ret;
 859
 860                 if (!ldb_msg_find_element(ac->msg, "schemaIDGUID")) {
 861                         struct GUID guid;
 862                         /* a new GUID */
 863                         guid = GUID_random();
 864                         ret = dsdb_msg_add_guid(ac->msg, &guid, "schemaIDGUID");
 865                         if (ret != LDB_SUCCESS) {
 866                                 ldb_oom(ldb);
 867                                 return ret;
 868                         }
 869                 }
 870
 871                 ret = samldb_add_step(ac, samldb_add_entry);
 872                 if (ret != LDB_SUCCESS) return ret;
 873
 874                 return samldb_first_step(ac);
 875         } else {
 876                 ldb_asprintf_errstring(ldb,
 877                         "Invalid entry type!");
 878                 return LDB_ERR_OPERATIONS_ERROR;
 879         }
 880
 881         /* check if we have a valid samAccountName */
 882         ret = samldb_add_step(ac, samldb_check_samAccountName);
 883         if (ret != LDB_SUCCESS) return ret;
 884
 885         /* check account_type/group_type */
 886         ret = samldb_add_step(ac, samldb_check_samAccountType);
 887         if (ret != LDB_SUCCESS) return ret;
 888
 889         /* check if we have a valid primary group ID */
 890         if (strcmp(ac->type, "user") == 0) {
 891                 ret = samldb_add_step(ac, samldb_check_primaryGroupID_1);
 892                 if (ret != LDB_SUCCESS) return ret;
 893                 ret = samldb_add_step(ac, samldb_dn_from_sid);
 894                 if (ret != LDB_SUCCESS) return ret;
 895                 ret = samldb_add_step(ac, samldb_check_primaryGroupID_2);
 896                 if (ret != LDB_SUCCESS) return ret;
 897         }
 898
 899         lp_ctx = talloc_get_type(ldb_get_opaque(ldb, "loadparm"),
 900                  struct loadparm_context);
 901
 902         /* don't allow objectSID to be specified without the RELAX control */
 903         ac->sid = samdb_result_dom_sid(ac, ac->msg, "objectSid");
 904         if (ac->sid && !ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID)) {
 905                 ldb_asprintf_errstring(ldb, "No SID may be specified in user/group creation for %s",
 906                                        ldb_dn_get_linearized(ac->msg->dn));
 907                 return LDB_ERR_UNWILLING_TO_PERFORM;
 908         }
 909
 910         if ( ! ac->sid) {
 911                 sid_generator = lp_sid_generator(lp_ctx);
 912                 if (sid_generator == SID_GENERATOR_INTERNAL) {
 913                         ret = samldb_add_step(ac, samldb_allocate_sid);
 914                         if (ret != LDB_SUCCESS) return ret;
 915                 }
 916         }
 917
 918         /* finally proceed with adding the entry */
 919         ret = samldb_add_step(ac, samldb_add_entry);
 920         if (ret != LDB_SUCCESS) return ret;
 921
 922         return samldb_first_step(ac);
 923 }
 924
 925 static int samldb_fill_foreignSecurityPrincipal_object(struct samldb_ctx *ac)
 926 {
 927         struct ldb_context *ldb;
 928         int ret;
 929
 930         ldb = ldb_module_get_ctx(ac->module);
 931
 932         ac->sid = samdb_result_dom_sid(ac->msg, ac->msg, "objectSid");
 933         if (ac->sid == NULL) {
 934                 ac->sid = dom_sid_parse_talloc(ac->msg,
 935                            (const char *)ldb_dn_get_rdn_val(ac->msg->dn)->data);
 936                 if (!ac->sid) {
 937                         ldb_set_errstring(ldb,
 938                                         "No valid SID found in "
 939                                         "ForeignSecurityPrincipal CN!");
 940                         talloc_free(ac);
 941                         return LDB_ERR_CONSTRAINT_VIOLATION;
 942                 }
 943                 if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
 944                         talloc_free(ac);
 945                         return LDB_ERR_OPERATIONS_ERROR;
 946                 }
 947         }
 948
 949         /* finally proceed with adding the entry */
 950         ret = samldb_add_step(ac, samldb_add_entry);
 951         if (ret != LDB_SUCCESS) return ret;
 952
 953         return samldb_first_step(ac);
 954 }
 955
 956 static int samldb_check_rdn(struct ldb_module *module, struct ldb_dn *dn)
 957 {
 958         struct ldb_context *ldb;
 959         const char *rdn_name;
 960
 961         ldb = ldb_module_get_ctx(module);
 962         rdn_name = ldb_dn_get_rdn_name(dn);
 963
 964         if (strcasecmp(rdn_name, "cn") != 0) {
 965                 ldb_asprintf_errstring(ldb,
 966                                         "Bad RDN (%s=) for samldb object, "
 967                                         "should be CN=!", rdn_name);
 968                 return LDB_ERR_CONSTRAINT_VIOLATION;
 969         }
 970
 971         return LDB_SUCCESS;
 972 }
 973
 974 /*
 975  * samldb_sid_from_dn (async)
 976  */
 977
 978 static int samldb_sid_from_dn(struct samldb_ctx *ac);
 979
 980 static int samldb_sid_from_dn_callback(struct ldb_request *req,
 981         struct ldb_reply *ares)
 982 {
 983         struct ldb_context *ldb;
 984         struct samldb_ctx *ac;
 985         int ret;
 986
 987         ac = talloc_get_type(req->context, struct samldb_ctx);
 988         ldb = ldb_module_get_ctx(ac->module);
 989
 990         if (!ares) {
 991                 ret = LDB_ERR_OPERATIONS_ERROR;
 992                 goto done;
 993         }
 994         if (ares->error != LDB_SUCCESS) {
 995                 return ldb_module_done(ac->req, ares->controls,
 996                                         ares->response, ares->error);
 997         }
 998
 999         switch (ares->type) {
1000         case LDB_REPLY_ENTRY:
1001                 /* save entry */
1002                 if (ac->res_sid != NULL) {
1003                         /* one too many! */
1004                         ldb_set_errstring(ldb,
1005                                 "Invalid number of results while searching "
1006                                 "for domain objects!");
1007                         ret = LDB_ERR_OPERATIONS_ERROR;
1008                         break;
1009                 }
1010                 ac->res_sid = samdb_result_dom_sid(ac, ares->message,
1011                         "objectSid");
1012
1013                 talloc_free(ares);
1014                 ret = LDB_SUCCESS;
1015                 break;
1016
1017         case LDB_REPLY_REFERRAL:
1018                 /* ignore */
1019                 talloc_free(ares);
1020                 ret = LDB_SUCCESS;
1021                 break;
1022
1023         case LDB_REPLY_DONE:
1024                 talloc_free(ares);
1025
1026                 /* found or not found, go on */
1027                 ret = samldb_next_step(ac);
1028                 break;
1029         }
1030
1031 done:
1032         if (ret != LDB_SUCCESS) {
1033                 return ldb_module_done(ac->req, NULL, NULL, ret);
1034         }
1035
1036         return LDB_SUCCESS;
1037 }
1038
1039 /* Finds the SID "res_sid" of an object with a given DN "dn" */
1040 static int samldb_sid_from_dn(struct samldb_ctx *ac)
1041 {
1042         struct ldb_context *ldb;
1043         static const char * const attrs[] = { "objectSid", NULL };
1044         struct ldb_request *req;
1045         int ret;
1046
1047         ldb = ldb_module_get_ctx(ac->module);
1048
1049         if (ac->dn == NULL)
1050                 return LDB_ERR_OPERATIONS_ERROR;
1051
1052         ret = ldb_build_search_req(&req, ldb, ac,
1053                                 ac->dn,
1054                                 LDB_SCOPE_BASE,
1055                                 NULL, attrs,
1056                                 NULL,
1057                                 ac, samldb_sid_from_dn_callback,
1058                                 ac->req);
1059         if (ret != LDB_SUCCESS)
1060                 return ret;
1061
1062         return ldb_next_request(ac->module, req);
1063 }
1064
1065 /*
1066  * samldb_user_dn_to_prim_group_rid (async)
1067  */
1068
1069 static int samldb_user_dn_to_prim_group_rid(struct samldb_ctx *ac);
1070
1071 static int samldb_user_dn_to_prim_group_rid_callback(struct ldb_request *req,
1072         struct ldb_reply *ares)
1073 {
1074         struct ldb_context *ldb;
1075         struct samldb_ctx *ac;
1076         int ret;
1077
1078         ac = talloc_get_type(req->context, struct samldb_ctx);
1079         ldb = ldb_module_get_ctx(ac->module);
1080
1081         if (!ares) {
1082                 ret = LDB_ERR_OPERATIONS_ERROR;
1083                 goto done;
1084         }
1085         if (ares->error != LDB_SUCCESS) {
1086                 return ldb_module_done(ac->req, ares->controls,
1087                                         ares->response, ares->error);
1088         }
1089
1090         switch (ares->type) {
1091         case LDB_REPLY_ENTRY:
1092                 /* save entry */
1093                 if (ac->prim_group_rid != 0) {
1094                         /* one too many! */
1095                         ldb_set_errstring(ldb,
1096                                 "Invalid number of results while searching "
1097                                 "for domain objects!");
1098                         ret = LDB_ERR_OPERATIONS_ERROR;
1099                         break;
1100                 }
1101                 ac->prim_group_rid = samdb_result_uint(ares->message,
1102                         "primaryGroupID", ~0);
1103
1104                 talloc_free(ares);
1105                 ret = LDB_SUCCESS;
1106                 break;
1107
1108         case LDB_REPLY_REFERRAL:
1109                 /* ignore */
1110                 talloc_free(ares);
1111                 ret = LDB_SUCCESS;
1112                 break;
1113
1114         case LDB_REPLY_DONE:
1115                 talloc_free(ares);
1116                 if (ac->prim_group_rid == 0) {
1117                         ldb_asprintf_errstring(ldb,
1118                                 "Unable to get the primary group RID!");
1119                         ret = LDB_ERR_OPERATIONS_ERROR;
1120                         break;
1121                 }
1122
1123                 /* found, go on */
1124                 ret = samldb_next_step(ac);
1125                 break;
1126         }
1127
1128 done:
1129         if (ret != LDB_SUCCESS) {
1130                 return ldb_module_done(ac->req, NULL, NULL, ret);
1131         }
1132
1133         return LDB_SUCCESS;
1134 }
1135
1136 /* Locates the "primaryGroupID" attribute from a certain user specified as
1137  * "user_dn". Saves the result in "prim_group_rid". */
1138 static int samldb_user_dn_to_prim_group_rid(struct samldb_ctx *ac)
1139 {
1140         struct ldb_context *ldb;
1141         static const char * const attrs[] = { "primaryGroupID", NULL };
1142         struct ldb_request *req;
1143         int ret;
1144
1145         ldb = ldb_module_get_ctx(ac->module);
1146
1147         if (ac->user_dn == NULL)
1148                 return LDB_ERR_OPERATIONS_ERROR;
1149
1150         ret = ldb_build_search_req(&req, ldb, ac,
1151                                 ac->user_dn,
1152                                 LDB_SCOPE_BASE,
1153                                 NULL, attrs,
1154                                 NULL,
1155                                 ac, samldb_user_dn_to_prim_group_rid_callback,
1156                                 ac->req);
1157         if (ret != LDB_SUCCESS)
1158                 return ret;
1159
1160         return ldb_next_request(ac->module, req);
1161 }
1162
1163 /*
1164  * samldb_prim_group_rid_to_users_cnt (async)
1165  */
1166
1167 static int samldb_prim_group_rid_to_users_cnt(struct samldb_ctx *ac);
1168
1169 static int samldb_prim_group_rid_to_users_cnt_callback(struct ldb_request *req,
1170         struct ldb_reply *ares)
1171 {
1172         struct ldb_context *ldb;
1173         struct samldb_ctx *ac;
1174         int ret;
1175
1176         ac = talloc_get_type(req->context, struct samldb_ctx);
1177         ldb = ldb_module_get_ctx(ac->module);
1178
1179         if (!ares) {
1180                 ret = LDB_ERR_OPERATIONS_ERROR;
1181                 goto done;
1182         }
1183         if (ares->error != LDB_SUCCESS) {
1184                 return ldb_module_done(ac->req, ares->controls,
1185                                         ares->response, ares->error);
1186         }
1187
1188         switch (ares->type) {
1189         case LDB_REPLY_ENTRY:
1190                 /* save entry */
1191                 ++(ac->users_cnt);
1192
1193                 talloc_free(ares);
1194                 ret = LDB_SUCCESS;
1195                 break;
1196
1197         case LDB_REPLY_REFERRAL:
1198                 /* ignore */
1199                 talloc_free(ares);
1200                 ret = LDB_SUCCESS;
1201                 break;
1202
1203         case LDB_REPLY_DONE:
1204                 talloc_free(ares);
1205
1206                 /* found or not found, go on */
1207                 ret = samldb_next_step(ac);
1208                 break;
1209         }
1210
1211 done:
1212         if (ret != LDB_SUCCESS) {
1213                 return ldb_module_done(ac->req, NULL, NULL, ret);
1214         }
1215
1216         return LDB_SUCCESS;
1217 }
1218
1219 /* Finds the amount of users which have the primary group "prim_group_rid" and
1220  * save the result in "users_cnt" */
1221 static int samldb_prim_group_rid_to_users_cnt(struct samldb_ctx *ac)
1222 {
1223         struct ldb_context *ldb;
1224         static const char * const attrs[] = { NULL };
1225         struct ldb_request *req;
1226         char *filter;
1227         int ret;
1228
1229         ldb = ldb_module_get_ctx(ac->module);
1230
1231         if ((ac->prim_group_rid == 0) || (ac->users_cnt != 0))
1232                 return LDB_ERR_OPERATIONS_ERROR;
1233
1234         filter = talloc_asprintf(ac, "(&(primaryGroupID=%u)(objectclass=user))",
1235                 ac->prim_group_rid);
1236         if (filter == NULL)
1237                 return LDB_ERR_OPERATIONS_ERROR;
1238
1239         ret = ldb_build_search_req(&req, ldb, ac,
1240                                 ldb_get_default_basedn(ldb),
1241                                 LDB_SCOPE_SUBTREE,
1242                                 filter, attrs,
1243                                 NULL,
1244                                 ac,
1245                                 samldb_prim_group_rid_to_users_cnt_callback,
1246                                 ac->req);
1247         if (ret != LDB_SUCCESS)
1248                 return ret;
1249
1250         return ldb_next_request(ac->module, req);
1251 }
1252
1253 /*
1254  * samldb_group_add_member (async)
1255  * samldb_group_del_member (async)
1256  */
1257
1258 static int samldb_group_add_del_member_callback(struct ldb_request *req,
1259         struct ldb_reply *ares)
1260 {
1261         struct ldb_context *ldb;
1262         struct samldb_ctx *ac;
1263         int ret;
1264
1265         ac = talloc_get_type(req->context, struct samldb_ctx);
1266         ldb = ldb_module_get_ctx(ac->module);
1267
1268         if (!ares) {
1269                 ret = LDB_ERR_OPERATIONS_ERROR;
1270                 goto done;
1271         }
1272         if (ares->error != LDB_SUCCESS) {
1273                 if (ares->error == LDB_ERR_NO_SUCH_ATTRIBUTE) {
1274                         /* On error "NO_SUCH_ATTRIBUTE" (delete of an invalid
1275                          * "member" attribute) return "UNWILLING_TO_PERFORM" */
1276                         ares->error = LDB_ERR_UNWILLING_TO_PERFORM;
1277                 }
1278                 return ldb_module_done(ac->req, ares->controls,
1279                                         ares->response, ares->error);
1280         }
1281         if (ares->type != LDB_REPLY_DONE) {
1282                 ldb_set_errstring(ldb,
1283                         "Invalid reply type!");
1284                 ret = LDB_ERR_OPERATIONS_ERROR;
1285                 goto done;
1286         }
1287
1288         ret = samldb_next_step(ac);
1289
1290 done:
1291         if (ret != LDB_SUCCESS) {
1292                 return ldb_module_done(ac->req, NULL, NULL, ret);
1293         }
1294
1295         return LDB_SUCCESS;
1296 }
1297
1298 /* Adds a member with DN "member_dn" to a group with DN "group_dn" */
1299 static int samldb_group_add_member(struct samldb_ctx *ac)
1300 {
1301         struct ldb_context *ldb;
1302         struct ldb_request *req;
1303         struct ldb_message *msg;
1304         int ret;
1305
1306         ldb = ldb_module_get_ctx(ac->module);
1307
1308         if ((ac->group_dn == NULL) || (ac->member_dn == NULL))
1309                 return LDB_ERR_OPERATIONS_ERROR;
1310
1311         msg = ldb_msg_new(ac);
1312         msg->dn = ac->group_dn;
1313         samdb_msg_add_addval(ldb, ac, msg, "member",
1314                 ldb_dn_get_linearized(ac->member_dn));
1315
1316         ret = ldb_build_mod_req(&req, ldb, ac,
1317                                 msg, NULL,
1318                                 ac, samldb_group_add_del_member_callback,
1319                                 ac->req);
1320         if (ret != LDB_SUCCESS)
1321                 return ret;
1322
1323         return ldb_next_request(ac->module, req);
1324 }
1325
1326 /* Removes a member with DN "member_dn" from a group with DN "group_dn" */
1327 static int samldb_group_del_member(struct samldb_ctx *ac)
1328 {
1329         struct ldb_context *ldb;
1330         struct ldb_request *req;
1331         struct ldb_message *msg;
1332         int ret;
1333
1334         ldb = ldb_module_get_ctx(ac->module);
1335
1336         if ((ac->group_dn == NULL) || (ac->member_dn == NULL))
1337                 return LDB_ERR_OPERATIONS_ERROR;
1338
1339         msg = ldb_msg_new(ac);
1340         msg->dn = ac->group_dn;
1341         samdb_msg_add_delval(ldb, ac, msg, "member",
1342                 ldb_dn_get_linearized(ac->member_dn));
1343
1344         ret = ldb_build_mod_req(&req, ldb, ac,
1345                                 msg, NULL,
1346                                 ac, samldb_group_add_del_member_callback,
1347                                 ac->req);
1348         if (ret != LDB_SUCCESS)
1349                 return ret;
1350
1351         return ldb_next_request(ac->module, req);
1352 }
1353
1354
1355 static int samldb_prim_group_change_1(struct samldb_ctx *ac)
1356 {
1357         struct ldb_context *ldb;
1358         uint32_t rid;
1359
1360         ldb = ldb_module_get_ctx(ac->module);
1361
1362         ac->user_dn = ac->msg->dn;
1363
1364         rid = samdb_result_uint(ac->msg, "primaryGroupID", ~0);
1365         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
1366         if (ac->sid == NULL)
1367                 return LDB_ERR_OPERATIONS_ERROR;
1368         ac->res_dn = NULL;
1369
1370         ac->prim_group_rid = 0;
1371
1372         return samldb_next_step(ac);
1373 }
1374
1375 static int samldb_prim_group_change_2(struct samldb_ctx *ac)
1376 {
1377         struct ldb_context *ldb;
1378
1379         ldb = ldb_module_get_ctx(ac->module);
1380
1381         if (ac->res_dn != NULL)
1382                 ac->new_prim_group_dn = ac->res_dn;
1383         else
1384                 return LDB_ERR_UNWILLING_TO_PERFORM;
1385
1386         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb),
1387                 ac->prim_group_rid);
1388         if (ac->sid == NULL)
1389                 return LDB_ERR_OPERATIONS_ERROR;
1390         ac->res_dn = NULL;
1391
1392         return samldb_next_step(ac);
1393 }
1394
1395 static int samldb_prim_group_change_4(struct samldb_ctx *ac);
1396 static int samldb_prim_group_change_5(struct samldb_ctx *ac);
1397 static int samldb_prim_group_change_6(struct samldb_ctx *ac);
1398
1399 static int samldb_prim_group_change_3(struct samldb_ctx *ac)
1400 {
1401         int ret;
1402
1403         if (ac->res_dn != NULL)
1404                 ac->old_prim_group_dn = ac->res_dn;
1405         else
1406                 return LDB_ERR_UNWILLING_TO_PERFORM;
1407
1408         /* Only update when the primary group changed */
1409         if (ldb_dn_compare(ac->old_prim_group_dn, ac->new_prim_group_dn) != 0) {
1410                 ac->member_dn = ac->user_dn;
1411                 /* Remove the "member" attribute of the actual (new) primary
1412                  * group */
1413
1414                 ret = samldb_add_step(ac, samldb_prim_group_change_4);
1415                 if (ret != LDB_SUCCESS) return ret;
1416
1417                 ret = samldb_add_step(ac, samldb_group_del_member);
1418                 if (ret != LDB_SUCCESS) return ret;
1419
1420                 /* Add a "member" attribute for the previous primary group */
1421
1422                 ret = samldb_add_step(ac, samldb_prim_group_change_5);
1423                 if (ret != LDB_SUCCESS) return ret;
1424
1425                 ret = samldb_add_step(ac, samldb_group_add_member);
1426                 if (ret != LDB_SUCCESS) return ret;
1427         }
1428
1429         ret = samldb_add_step(ac, samldb_prim_group_change_6);
1430         if (ret != LDB_SUCCESS) return ret;
1431
1432         return samldb_next_step(ac);
1433 }
1434
1435 static int samldb_prim_group_change_4(struct samldb_ctx *ac)
1436 {
1437         ac->group_dn = ac->new_prim_group_dn;
1438
1439         return samldb_next_step(ac);
1440 }
1441
1442 static int samldb_prim_group_change_5(struct samldb_ctx *ac)
1443 {
1444         ac->group_dn = ac->old_prim_group_dn;
1445
1446         return samldb_next_step(ac);
1447 }
1448
1449 static int samldb_prim_group_change_6(struct samldb_ctx *ac)
1450 {
1451         return ldb_next_request(ac->module, ac->req);
1452 }
1453
1454 static int samldb_prim_group_change(struct samldb_ctx *ac)
1455 {
1456         int ret;
1457
1458         /* Finds out the DN of the new primary group */
1459
1460         ret = samldb_add_step(ac, samldb_prim_group_change_1);
1461         if (ret != LDB_SUCCESS) return ret;
1462
1463         ret = samldb_add_step(ac, samldb_dn_from_sid);
1464         if (ret != LDB_SUCCESS) return ret;
1465
1466         ret = samldb_add_step(ac, samldb_user_dn_to_prim_group_rid);
1467         if (ret != LDB_SUCCESS) return ret;
1468
1469         /* Finds out the DN of the old primary group */
1470
1471         ret = samldb_add_step(ac, samldb_prim_group_change_2);
1472         if (ret != LDB_SUCCESS) return ret;
1473
1474         ret = samldb_add_step(ac, samldb_dn_from_sid);
1475         if (ret != LDB_SUCCESS) return ret;
1476
1477         ret = samldb_add_step(ac, samldb_prim_group_change_3);
1478         if (ret != LDB_SUCCESS) return ret;
1479
1480         return samldb_first_step(ac);
1481 }
1482
1483
1484 static int samldb_member_check_1(struct samldb_ctx *ac)
1485 {
1486         struct ldb_context *ldb;
1487         struct ldb_message_element *el;
1488
1489         ldb = ldb_module_get_ctx(ac->module);
1490
1491         el = ldb_msg_find_element(ac->msg, "member");
1492
1493         ac->user_dn = ldb_dn_from_ldb_val(ac, ldb, &el->values[ac->cnt]);
1494         if (!ldb_dn_validate(ac->user_dn))
1495                 return LDB_ERR_OPERATIONS_ERROR;
1496         ac->prim_group_rid = 0;
1497
1498         return samldb_next_step(ac);
1499 }
1500
1501 static int samldb_member_check_2(struct samldb_ctx *ac)
1502 {
1503         struct ldb_context *ldb;
1504
1505         ldb = ldb_module_get_ctx(ac->module);
1506
1507         ac->sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb),
1508                 ac->prim_group_rid);
1509         if (ac->sid == NULL)
1510                 return LDB_ERR_OPERATIONS_ERROR;
1511         ac->res_dn = NULL;
1512
1513         return samldb_next_step(ac);
1514 }
1515
1516 static int samldb_member_check_3(struct samldb_ctx *ac)
1517 {
1518         if (ldb_dn_compare(ac->res_dn, ac->msg->dn) == 0)
1519                 return LDB_ERR_ENTRY_ALREADY_EXISTS;
1520
1521         ++(ac->cnt);
1522
1523         return samldb_next_step(ac);
1524 }
1525
1526 static int samldb_member_check_4(struct samldb_ctx *ac)
1527 {
1528         return ldb_next_request(ac->module, ac->req);
1529 }
1530
1531 static int samldb_member_check(struct samldb_ctx *ac)
1532 {
1533         struct ldb_message_element *el;
1534         int i, ret;
1535
1536         el = ldb_msg_find_element(ac->msg, "member");
1537         ac->cnt = 0;
1538         for (i = 0; i < el->num_values; i++) {
1539                 /* Denies to add "member"s to groups which are primary ones
1540                  * for them */
1541                 ret = samldb_add_step(ac, samldb_member_check_1);
1542                 if (ret != LDB_SUCCESS) return ret;
1543
1544                 ret = samldb_add_step(ac, samldb_user_dn_to_prim_group_rid);
1545                 if (ret != LDB_SUCCESS) return ret;
1546
1547                 ret = samldb_add_step(ac, samldb_member_check_2);
1548                 if (ret != LDB_SUCCESS) return ret;
1549
1550                 ret = samldb_add_step(ac, samldb_dn_from_sid);
1551                 if (ret != LDB_SUCCESS) return ret;
1552
1553                 ret = samldb_add_step(ac, samldb_member_check_3);
1554                 if (ret != LDB_SUCCESS) return ret;
1555         }
1556
1557         ret = samldb_add_step(ac, samldb_member_check_4);
1558         if (ret != LDB_SUCCESS) return ret;
1559
1560         return samldb_first_step(ac);
1561 }
1562
1563
1564 static int samldb_prim_group_users_check_1(struct samldb_ctx *ac)
1565 {
1566         ac->dn = ac->req->op.del.dn;
1567         ac->res_sid = NULL;
1568
1569         return samldb_next_step(ac);
1570 }
1571
1572 static int samldb_prim_group_users_check_2(struct samldb_ctx *ac)
1573 {
1574         NTSTATUS status;
1575         uint32_t rid;
1576
1577         if (ac->res_sid == NULL) {
1578                 /* No SID - therefore ok here */
1579                 return ldb_next_request(ac->module, ac->req);
1580         }
1581         status = dom_sid_split_rid(ac, ac->res_sid, NULL, &rid);
1582         if (!NT_STATUS_IS_OK(status))
1583                 return LDB_ERR_OPERATIONS_ERROR;
1584
1585         if (rid == 0) {
1586                 /* Special object (security principal?) */
1587                 return ldb_next_request(ac->module, ac->req);
1588         }
1589
1590         ac->prim_group_rid = rid;
1591         ac->users_cnt = 0;
1592
1593         return samldb_next_step(ac);
1594 }
1595
1596 static int samldb_prim_group_users_check_3(struct samldb_ctx *ac)
1597 {
1598         if (ac->users_cnt > 0)
1599                 return LDB_ERR_ENTRY_ALREADY_EXISTS;
1600
1601         return ldb_next_request(ac->module, ac->req);
1602 }
1603
1604 static int samldb_prim_group_users_check(struct samldb_ctx *ac)
1605 {
1606         int ret;
1607
1608         /* Finds out the SID/RID of the domain object */
1609
1610         ret = samldb_add_step(ac, samldb_prim_group_users_check_1);
1611         if (ret != LDB_SUCCESS) return ret;
1612
1613         ret = samldb_add_step(ac, samldb_sid_from_dn);
1614         if (ret != LDB_SUCCESS) return ret;
1615
1616         /* Deny delete requests from groups which are primary ones */
1617
1618         ret = samldb_add_step(ac, samldb_prim_group_users_check_2);
1619         if (ret != LDB_SUCCESS) return ret;
1620
1621         ret = samldb_add_step(ac, samldb_prim_group_rid_to_users_cnt);
1622         if (ret != LDB_SUCCESS) return ret;
1623
1624         ret = samldb_add_step(ac, samldb_prim_group_users_check_3);
1625         if (ret != LDB_SUCCESS) return ret;
1626
1627         return samldb_first_step(ac);
1628 }
1629
1630
1631 /* add */
1632 static int samldb_add(struct ldb_module *module, struct ldb_request *req)
1633 {
1634         struct ldb_context *ldb;
1635         struct samldb_ctx *ac;
1636         int ret;
1637
1638         ldb = ldb_module_get_ctx(module);
1639         ldb_debug(ldb, LDB_DEBUG_TRACE, "samldb_add\n");
1640
1641         /* do not manipulate our control entries */
1642         if (ldb_dn_is_special(req->op.add.message->dn)) {
1643                 return ldb_next_request(module, req);
1644         }
1645
1646         ac = samldb_ctx_init(module, req);
1647         if (ac == NULL) {
1648                 return LDB_ERR_OPERATIONS_ERROR;
1649         }
1650
1651         /* build the new msg */
1652         ac->msg = ldb_msg_copy(ac, ac->req->op.add.message);
1653         if (!ac->msg) {
1654                 talloc_free(ac);
1655                 ldb_debug(ldb, LDB_DEBUG_FATAL,
1656                           "samldb_add: ldb_msg_copy failed!\n");
1657                 return LDB_ERR_OPERATIONS_ERROR;
1658         }
1659
1660         if (samdb_find_attribute(ldb, ac->msg,
1661                                  "objectclass", "computer") != NULL) {
1662
1663                 /* make sure the computer object also has the 'user'
1664                  * objectclass so it will be handled by the next call */
1665                 ret = samdb_find_or_add_value(ldb, ac->msg,
1666                                                 "objectclass", "user");
1667                 if (ret != LDB_SUCCESS) {
1668                         talloc_free(ac);
1669                         return ret;
1670                 }
1671         }
1672
1673         if (samdb_find_attribute(ldb, ac->msg,
1674                                  "objectclass", "user") != NULL) {
1675
1676                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1677                 if (ret != LDB_SUCCESS) {
1678                         talloc_free(ac);
1679                         return ret;
1680                 }
1681
1682                 return samldb_fill_object(ac, "user");
1683         }
1684
1685         if (samdb_find_attribute(ldb, ac->msg,
1686                                  "objectclass", "group") != NULL) {
1687
1688                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1689                 if (ret != LDB_SUCCESS) {
1690                         talloc_free(ac);
1691                         return ret;
1692                 }
1693
1694                 return samldb_fill_object(ac, "group");
1695         }
1696
1697         /* perhaps a foreignSecurityPrincipal? */
1698         if (samdb_find_attribute(ldb, ac->msg,
1699                                  "objectclass",
1700                                  "foreignSecurityPrincipal") != NULL) {
1701
1702                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1703                 if (ret != LDB_SUCCESS) {
1704                         talloc_free(ac);
1705                         return ret;
1706                 }
1707
1708                 return samldb_fill_foreignSecurityPrincipal_object(ac);
1709         }
1710
1711         if (samdb_find_attribute(ldb, ac->msg,
1712                                  "objectclass", "classSchema") != NULL) {
1713
1714                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1715                 if (ret != LDB_SUCCESS) {
1716                         talloc_free(ac);
1717                         return ret;
1718                 }
1719
1720                 return samldb_fill_object(ac, "classSchema");
1721         }
1722
1723         if (samdb_find_attribute(ldb, ac->msg,
1724                                  "objectclass", "attributeSchema") != NULL) {
1725
1726                 ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
1727                 if (ret != LDB_SUCCESS) {
1728                         talloc_free(ac);
1729                         return ret;
1730                 }
1731
1732                 return samldb_fill_object(ac, "attributeSchema");
1733         }
1734
1735         talloc_free(ac);
1736
1737         /* nothing matched, go on */
1738         return ldb_next_request(module, req);
1739 }
1740
1741 /* modify */
1742 static int samldb_modify(struct ldb_module *module, struct ldb_request *req)
1743 {
1744         struct ldb_context *ldb;
1745         struct ldb_message *msg;
1746         struct ldb_message_element *el, *el2;
1747         int ret;
1748         uint32_t account_type;
1749
1750         if (ldb_dn_is_special(req->op.mod.message->dn)) {
1751                 /* do not manipulate our control entries */
1752                 return ldb_next_request(module, req);
1753         }
1754
1755         ldb = ldb_module_get_ctx(module);
1756
1757         if (ldb_msg_find_element(req->op.mod.message, "sAMAccountType") != NULL) {
1758                 ldb_asprintf_errstring(ldb,
1759                         "sAMAccountType must not be specified!");
1760                 return LDB_ERR_UNWILLING_TO_PERFORM;
1761         }
1762
1763         /* TODO: do not modify original request, create a new one */
1764
1765         el = ldb_msg_find_element(req->op.mod.message, "groupType");
1766         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1767                 uint32_t group_type;
1768
1769                 req->op.mod.message = msg = ldb_msg_copy_shallow(req,
1770                         req->op.mod.message);
1771
1772                 group_type = strtoul((const char *)el->values[0].data, NULL, 0);
1773                 account_type =  ds_gtype2atype(group_type);
1774                 ret = samdb_msg_add_uint(ldb, msg, msg,
1775                                          "sAMAccountType",
1776                                          account_type);
1777                 if (ret != LDB_SUCCESS) {
1778                         return ret;
1779                 }
1780                 el2 = ldb_msg_find_element(msg, "sAMAccountType");
1781                 el2->flags = LDB_FLAG_MOD_REPLACE;
1782         }
1783
1784         el = ldb_msg_find_element(req->op.mod.message, "userAccountControl");
1785         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1786                 uint32_t user_account_control;
1787
1788                 req->op.mod.message = msg = ldb_msg_copy_shallow(req,
1789                         req->op.mod.message);
1790
1791                 user_account_control = strtoul((const char *)el->values[0].data,
1792                         NULL, 0);
1793                 account_type = ds_uf2atype(user_account_control);
1794                 ret = samdb_msg_add_uint(ldb, msg, msg,
1795                                          "sAMAccountType",
1796                                          account_type);
1797                 if (ret != LDB_SUCCESS) {
1798                         return ret;
1799                 }
1800                 el2 = ldb_msg_find_element(msg, "sAMAccountType");
1801                 el2->flags = LDB_FLAG_MOD_REPLACE;
1802
1803                 if (user_account_control & UF_SERVER_TRUST_ACCOUNT) {
1804                         ret = samdb_msg_add_string(ldb, msg, msg,
1805                                                    "isCriticalSystemObject", "TRUE");
1806                         if (ret != LDB_SUCCESS) {
1807                                 return ret;
1808                         }
1809                         el2 = ldb_msg_find_element(msg, "isCriticalSystemObject");
1810                         el2->flags = LDB_FLAG_MOD_REPLACE;
1811                 }
1812         }
1813
1814         el = ldb_msg_find_element(req->op.mod.message, "primaryGroupID");
1815         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1816                 struct samldb_ctx *ac;
1817
1818                 ac = samldb_ctx_init(module, req);
1819                 if (ac == NULL)
1820                         return LDB_ERR_OPERATIONS_ERROR;
1821
1822                 req->op.mod.message = ac->msg = ldb_msg_copy_shallow(req,
1823                         req->op.mod.message);
1824
1825                 return samldb_prim_group_change(ac);
1826         }
1827
1828         el = ldb_msg_find_element(req->op.mod.message, "member");
1829         if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
1830                 struct samldb_ctx *ac;
1831
1832                 ac = samldb_ctx_init(module, req);
1833                 if (ac == NULL)
1834                         return LDB_ERR_OPERATIONS_ERROR;
1835
1836                 req->op.mod.message = ac->msg = ldb_msg_copy_shallow(req,
1837                         req->op.mod.message);
1838
1839                 return samldb_member_check(ac);
1840         }
1841
1842         /* nothing matched, go on */
1843         return ldb_next_request(module, req);
1844 }
1845
1846 /* delete */
1847 static int samldb_delete(struct ldb_module *module, struct ldb_request *req)
1848 {
1849         struct samldb_ctx *ac;
1850
1851         if (ldb_dn_is_special(req->op.del.dn)) {
1852                 /* do not manipulate our control entries */
1853                 return ldb_next_request(module, req);
1854         }
1855
1856         ac = samldb_ctx_init(module, req);
1857         if (ac == NULL)
1858                 return LDB_ERR_OPERATIONS_ERROR;
1859
1860         return samldb_prim_group_users_check(ac);
1861 }
1862
1863 static int samldb_extended_allocate_rid_pool(struct ldb_module *module, struct ldb_request *req)
1864 {
1865         struct ldb_context *ldb = ldb_module_get_ctx(module);
1866         struct dsdb_fsmo_extended_op *exop;
1867         int ret;
1868
1869         exop = talloc_get_type(req->op.extended.data, struct dsdb_fsmo_extended_op);
1870         if (!exop) {
1871                 ldb_debug(ldb, LDB_DEBUG_FATAL, "samldb_extended_allocate_rid_pool: invalid extended data\n");
1872                 return LDB_ERR_PROTOCOL_ERROR;
1873         }
1874
1875         ret = ridalloc_allocate_rid_pool_fsmo(module, exop);
1876         if (ret != LDB_SUCCESS) {
1877                 return ret;
1878         }
1879
1880         return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
1881 }
1882
1883 static int samldb_extended(struct ldb_module *module, struct ldb_request *req)
1884 {
1885         if (strcmp(req->op.extended.oid, DSDB_EXTENDED_ALLOCATE_RID_POOL) == 0) {
1886                 return samldb_extended_allocate_rid_pool(module, req);
1887         }
1888
1889         return ldb_next_request(module, req);
1890 }
1891
1892
1893 _PUBLIC_ const struct ldb_module_ops ldb_samldb_module_ops = {
1894         .name          = "samldb",
1895         .add           = samldb_add,
1896         .modify        = samldb_modify,
1897         .del           = samldb_delete,
1898         .extended      = samldb_extended
1899 };
1900