source4/rpc_server/samr/dcesrv_samr.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    endpoint server for the samr pipe
   5
   6    Copyright (C) Andrew Tridgell 2004
   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "rpc_server/common/common.h"
  25
  26 /*
  27   this type allows us to distinguish handle types
  28 */
  29 enum samr_handle {
  30         SAMR_HANDLE_CONNECT,
  31         SAMR_HANDLE_DOMAIN,
  32         SAMR_HANDLE_USER,
  33         SAMR_HANDLE_GROUP,
  34         SAMR_HANDLE_ALIAS
  35 };
  36
  37
  38 /*
  39   state asscoiated with a samr_Connect*() operation
  40 */
  41 struct samr_connect_state {
  42         int reference_count;
  43         void *sam_ctx;
  44         TALLOC_CTX *mem_ctx;
  45         uint32 access_mask;
  46 };
  47
  48 /*
  49   state associated with a samr_OpenDomain() operation
  50 */
  51 struct samr_domain_state {
  52         struct samr_connect_state *connect_state;
  53         int reference_count;
  54         void *sam_ctx;
  55         TALLOC_CTX *mem_ctx;
  56         uint32 access_mask;
  57         const char *domain_sid;
  58         const char *domain_name;
  59         const char *domain_dn;
  60 };
  61
  62 /*
  63   state associated with a open account handle
  64 */
  65 struct samr_account_state {
  66         struct samr_domain_state *domain_state;
  67         void *sam_ctx;
  68         TALLOC_CTX *mem_ctx;
  69         uint32 access_mask;
  70         const char *account_sid;
  71         const char *account_name;
  72         const char *account_dn;
  73 };
  74
  75
  76 /*
  77   destroy connection state
  78 */
  79 static void samr_Connect_close(struct samr_connect_state *c_state)
  80 {
  81         c_state->reference_count--;
  82         if (c_state->reference_count == 0) {
  83                 samdb_close(c_state->sam_ctx);
  84                 talloc_destroy(c_state->mem_ctx);
  85         }
  86 }
  87
  88 /*
  89   destroy an open connection. This closes the database connection
  90 */
  91 static void samr_Connect_destroy(struct dcesrv_connection *conn, struct dcesrv_handle *h)
  92 {
  93         struct samr_connect_state *c_state = h->data;
  94         samr_Connect_close(c_state);
  95 }
  96
  97 /*
  98   samr_Connect
  99
 100   create a connection to the SAM database
 101 */
 102 static NTSTATUS samr_Connect(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 103                              struct samr_Connect *r)
 104 {
 105         struct samr_connect_state *c_state;
 106         struct dcesrv_handle *handle;
 107         TALLOC_CTX *connect_mem_ctx;
 108
 109         ZERO_STRUCTP(r->out.handle);
 110
 111         connect_mem_ctx = talloc_init("samr_Connect");
 112         if (!connect_mem_ctx) {
 113                 return NT_STATUS_NO_MEMORY;
 114         }
 115
 116         c_state = talloc_p(connect_mem_ctx, struct samr_connect_state);
 117         if (!c_state) {
 118                 return NT_STATUS_NO_MEMORY;
 119         }
 120         c_state->mem_ctx = connect_mem_ctx;
 121
 122         /* make sure the sam database is accessible */
 123         c_state->sam_ctx = samdb_connect();
 124         if (c_state->sam_ctx == NULL) {
 125                 talloc_destroy(c_state->mem_ctx);
 126                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
 127         }
 128
 129         handle = dcesrv_handle_new(dce_call->conn, SAMR_HANDLE_CONNECT);
 130         if (!handle) {
 131                 talloc_destroy(c_state->mem_ctx);
 132                 return NT_STATUS_NO_MEMORY;
 133         }
 134
 135         handle->data = c_state;
 136         handle->destroy = samr_Connect_destroy;
 137
 138         c_state->reference_count = 1;
 139         c_state->access_mask = r->in.access_mask;
 140         *r->out.handle = handle->wire_handle;
 141
 142         return NT_STATUS_OK;
 143 }
 144
 145
 146 /*
 147   samr_Close
 148 */
 149 static NTSTATUS samr_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 150                            struct samr_Close *r)
 151 {
 152         struct dcesrv_handle *h;
 153
 154         *r->out.handle = *r->in.handle;
 155
 156         DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
 157
 158         /* this causes the callback samr_XXX_destroy() to be called by
 159            the handle destroy code which destroys the state associated
 160            with the handle */
 161         dcesrv_handle_destroy(dce_call->conn, h);
 162
 163         ZERO_STRUCTP(r->out.handle);
 164
 165         return NT_STATUS_OK;
 166 }
 167
 168
 169 /*
 170   samr_SetSecurity
 171 */
 172 static NTSTATUS samr_SetSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 173                                  struct samr_SetSecurity *r)
 174 {
 175         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 176 }
 177
 178
 179 /*
 180   samr_QuerySecurity
 181 */
 182 static NTSTATUS samr_QuerySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 183                                    struct samr_QuerySecurity *r)
 184 {
 185         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 186 }
 187
 188
 189 /*
 190   samr_Shutdown
 191
 192   we refuse this operation completely. If a admin wants to shutdown samr
 193   in Samba then they should use the samba admin tools to disable the samr pipe
 194 */
 195 static NTSTATUS samr_Shutdown(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 196                               struct samr_Shutdown *r)
 197 {
 198         return NT_STATUS_ACCESS_DENIED;
 199 }
 200
 201
 202 /*
 203   samr_LookupDomain
 204
 205   this maps from a domain name to a SID
 206 */
 207 static NTSTATUS samr_LookupDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 208                                   struct samr_LookupDomain *r)
 209 {
 210         struct samr_connect_state *c_state;
 211         struct dcesrv_handle *h;
 212         struct dom_sid2 *sid;
 213         const char *sidstr;
 214
 215         r->out.sid = NULL;
 216
 217         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_CONNECT);
 218
 219         c_state = h->data;
 220
 221         if (r->in.domain->name == NULL) {
 222                 return NT_STATUS_INVALID_PARAMETER;
 223         }
 224
 225         sidstr = samdb_search_string(c_state->sam_ctx,
 226                                      mem_ctx, NULL, "objectSid",
 227                                      "(&(name=%s)(objectclass=domain))",
 228                                      r->in.domain->name);
 229         if (sidstr == NULL) {
 230                 return NT_STATUS_NO_SUCH_DOMAIN;
 231         }
 232
 233         sid = dom_sid_parse_talloc(mem_ctx, sidstr);
 234         if (sid == NULL) {
 235                 DEBUG(1,("samdb: Invalid sid '%s' for domain %s\n",
 236                          sidstr, r->in.domain->name));
 237                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 238         }
 239
 240         r->out.sid = sid;
 241
 242         return NT_STATUS_OK;
 243 }
 244
 245
 246 /*
 247   samr_EnumDomains
 248
 249   list the domains in the SAM
 250 */
 251 static NTSTATUS samr_EnumDomains(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 252                                  struct samr_EnumDomains *r)
 253 {
 254         struct samr_connect_state *c_state;
 255         struct dcesrv_handle *h;
 256         struct samr_SamArray *array;
 257         const char **domains;
 258         int count, i, start_i;
 259
 260         *r->out.resume_handle = 0;
 261         r->out.sam = NULL;
 262         r->out.num_entries = 0;
 263
 264         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_CONNECT);
 265
 266         c_state = h->data;
 267
 268         count = samdb_search_string_multiple(c_state->sam_ctx,
 269                                              mem_ctx, NULL, &domains,
 270                                              "name", "(objectclass=domain)");
 271         if (count == -1) {
 272                 DEBUG(1,("samdb: no domains found in EnumDomains\n"));
 273                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 274         }
 275
 276         *r->out.resume_handle = count;
 277
 278         start_i = *r->in.resume_handle;
 279
 280         if (start_i >= count) {
 281                 /* search past end of list is not an error for this call */
 282                 return NT_STATUS_OK;
 283         }
 284
 285         array = talloc_p(mem_ctx, struct samr_SamArray);
 286         if (array == NULL) {
 287                 return NT_STATUS_NO_MEMORY;
 288         }
 289
 290         array->count = 0;
 291         array->entries = NULL;
 292
 293         array->entries = talloc_array_p(mem_ctx, struct samr_SamEntry, count - start_i);
 294         if (array->entries == NULL) {
 295                 return NT_STATUS_NO_MEMORY;
 296         }
 297
 298         for (i=0;i<count-start_i;i++) {
 299                 array->entries[i].idx = start_i + i;
 300                 array->entries[i].name.name = domains[start_i+i];
 301         }
 302
 303         r->out.sam = array;
 304         r->out.num_entries = i - start_i;
 305         array->count = r->out.num_entries;
 306
 307         return NT_STATUS_OK;
 308 }
 309
 310
 311 /*
 312   close an open domain context
 313 */
 314 static void samr_Domain_close(struct dcesrv_connection *conn,
 315                               struct samr_domain_state *d_state)
 316 {
 317         d_state->reference_count--;
 318         if (d_state->reference_count == 0) {
 319                 samr_Connect_close(d_state->connect_state);
 320                 talloc_destroy(d_state->mem_ctx);
 321         }
 322 }
 323
 324 /*
 325   destroy an open domain context
 326 */
 327 static void samr_Domain_destroy(struct dcesrv_connection *conn, struct dcesrv_handle *h)
 328 {
 329         struct samr_domain_state *d_state = h->data;
 330         samr_Domain_close(conn, d_state);
 331 }
 332
 333 /*
 334   samr_OpenDomain
 335 */
 336 static NTSTATUS samr_OpenDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 337                                 struct samr_OpenDomain *r)
 338 {
 339         struct dcesrv_handle *h_conn, *h_domain;
 340         const char *sidstr, *domain_name;
 341         struct samr_connect_state *c_state;
 342         struct samr_domain_state *d_state;
 343         TALLOC_CTX *mem_ctx2;
 344         const char * const attrs[2] = { "name", NULL};
 345         struct ldb_message **msgs;
 346         int ret;
 347
 348         ZERO_STRUCTP(r->out.domain_handle);
 349
 350         DCESRV_PULL_HANDLE(h_conn, r->in.handle, SAMR_HANDLE_CONNECT);
 351
 352         c_state = h_conn->data;
 353
 354         if (r->in.sid == NULL) {
 355                 return NT_STATUS_INVALID_PARAMETER;
 356         }
 357
 358         sidstr = dom_sid_string(mem_ctx, r->in.sid);
 359         if (sidstr == NULL) {
 360                 return NT_STATUS_INVALID_PARAMETER;
 361         }
 362
 363         ret = samdb_search(c_state->sam_ctx,
 364                            mem_ctx, NULL, &msgs, attrs,
 365                            "(&(objectSid=%s)(objectclass=domain))",
 366                            sidstr);
 367         if (ret != 1) {
 368                 return NT_STATUS_NO_SUCH_DOMAIN;
 369         }
 370
 371         domain_name = ldb_msg_find_string(msgs[0], "name", NULL);
 372         if (domain_name == NULL) {
 373                 return NT_STATUS_NO_SUCH_DOMAIN;
 374         }
 375
 376         mem_ctx2 = talloc_init("OpenDomain(%s)\n", domain_name);
 377         if (!mem_ctx2) {
 378                 return NT_STATUS_NO_MEMORY;
 379         }
 380
 381         d_state = talloc_p(mem_ctx2, struct samr_domain_state);
 382         if (!d_state) {
 383                 talloc_destroy(mem_ctx2);
 384                 return NT_STATUS_NO_MEMORY;
 385         }
 386
 387         d_state->reference_count = 1;
 388         d_state->connect_state = c_state;
 389         d_state->sam_ctx = c_state->sam_ctx;
 390         d_state->mem_ctx = mem_ctx2;
 391         d_state->domain_sid = talloc_strdup(mem_ctx2, sidstr);
 392         d_state->domain_name = talloc_strdup(mem_ctx2, domain_name);
 393         d_state->domain_dn = talloc_strdup(mem_ctx2, msgs[0]->dn);
 394         if (!d_state->domain_sid || !d_state->domain_name || !d_state->domain_dn) {
 395                 talloc_destroy(mem_ctx2);
 396                 return NT_STATUS_NO_MEMORY;
 397         }
 398         d_state->access_mask = r->in.access_mask;
 399
 400         h_domain = dcesrv_handle_new(dce_call->conn, SAMR_HANDLE_DOMAIN);
 401         if (!h_domain) {
 402                 talloc_destroy(mem_ctx2);
 403                 return NT_STATUS_NO_MEMORY;
 404         }
 405
 406         c_state->reference_count++;
 407         h_domain->data = d_state;
 408         h_domain->destroy = samr_Domain_destroy;
 409         *r->out.domain_handle = h_domain->wire_handle;
 410
 411         return NT_STATUS_OK;
 412 }
 413
 414
 415 /*
 416   samr_QueryDomainInfo
 417 */
 418 static NTSTATUS samr_QueryDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 419                        struct samr_QueryDomainInfo *r)
 420 {
 421         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 422 }
 423
 424
 425 /*
 426   samr_SetDomainInfo
 427 */
 428 static NTSTATUS samr_SetDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 429                        struct samr_SetDomainInfo *r)
 430 {
 431         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 432 }
 433
 434 /*
 435   destroy an open account context
 436 */
 437 static void samr_Account_destroy(struct dcesrv_connection *conn, struct dcesrv_handle *h)
 438 {
 439         struct samr_account_state *a_state = h->data;
 440         samr_Domain_close(conn, a_state->domain_state);
 441         talloc_destroy(a_state->mem_ctx);
 442 }
 443
 444 /*
 445   samr_CreateDomainGroup
 446 */
 447 static NTSTATUS samr_CreateDomainGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 448                                        struct samr_CreateDomainGroup *r)
 449 {
 450         struct samr_domain_state *d_state;
 451         struct samr_account_state *a_state;
 452         struct dcesrv_handle *h;
 453         const char *name;
 454         struct ldb_message msg;
 455         uint32 rid;
 456         const char *groupname, *sidstr;
 457         time_t now = time(NULL);
 458         TALLOC_CTX *mem_ctx2;
 459         struct dcesrv_handle *g_handle;
 460         int ret;
 461         NTSTATUS status;
 462
 463         ZERO_STRUCTP(r->out.group_handle);
 464         *r->out.rid = 0;
 465
 466         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_DOMAIN);
 467
 468         d_state = h->data;
 469
 470         groupname = r->in.name->name;
 471
 472         if (groupname == NULL) {
 473                 return NT_STATUS_INVALID_PARAMETER;
 474         }
 475
 476         /* check if the group already exists */
 477         name = samdb_search_string(d_state->sam_ctx, mem_ctx, d_state->domain_dn,
 478                                    "sAMAccountName",
 479                                    "(&(sAMAccountName=%s)(objectclass=group))",
 480                                    groupname);
 481         if (name != NULL) {
 482                 return NT_STATUS_GROUP_EXISTS;
 483         }
 484
 485         ZERO_STRUCT(msg);
 486
 487         /* pull in all the template attributes */
 488         ret = samdb_copy_template(d_state->sam_ctx, mem_ctx, &msg,
 489                                   "(&(name=TemplateGroup)(objectclass=groupTemplate))");
 490         if (ret != 0) {
 491                 DEBUG(1,("Failed to load TemplateGroup from samdb\n"));
 492                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 493         }
 494
 495         /* allocate a rid */
 496         status = samdb_allocate_next_id(d_state->sam_ctx, mem_ctx,
 497                                         d_state->domain_dn, "nextRid", &rid);
 498         if (!NT_STATUS_IS_OK(status)) {
 499                 return status;
 500         }
 501
 502         /* and the group SID */
 503         sidstr = talloc_asprintf(mem_ctx, "%s-%u", d_state->domain_sid, rid);
 504         if (!sidstr) {
 505                 return NT_STATUS_NO_MEMORY;
 506         }
 507
 508         /* add core elements to the ldb_message for the user */
 509         msg.dn = talloc_asprintf(mem_ctx, "CN=%s,CN=Users,%s", groupname,
 510                                  d_state->domain_dn);
 511         if (!msg.dn) {
 512                 return NT_STATUS_NO_MEMORY;
 513         }
 514         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg,
 515                              "name", groupname);
 516         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg,
 517                              "cn", groupname);
 518         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg,
 519                              "sAMAccountName", groupname);
 520         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg,
 521                              "objectClass", "group");
 522         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg,
 523                              "objectSid", sidstr);
 524         samdb_msg_set_ldaptime(d_state->sam_ctx, mem_ctx, &msg,
 525                                "whenCreated", now);
 526         samdb_msg_set_ldaptime(d_state->sam_ctx, mem_ctx, &msg,
 527                                "whenChanged", now);
 528
 529         /* create the group */
 530         ret = samdb_add(d_state->sam_ctx, mem_ctx, &msg);
 531         if (ret != 0) {
 532                 DEBUG(1,("Failed to create group record %s\n", msg.dn));
 533                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 534         }
 535
 536         /* create group state and new policy handle */
 537         mem_ctx2 = talloc_init("CreateDomainGroup(%s)", groupname);
 538         if (!mem_ctx2) {
 539                 return NT_STATUS_NO_MEMORY;
 540         }
 541
 542         a_state = talloc_p(mem_ctx2, struct samr_account_state);
 543         if (!a_state) {
 544                 return NT_STATUS_NO_MEMORY;
 545         }
 546         a_state->mem_ctx = mem_ctx2;
 547         a_state->sam_ctx = d_state->sam_ctx;
 548         a_state->access_mask = r->in.access_mask;
 549         a_state->domain_state = d_state;
 550         a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msg.dn);
 551         a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
 552         a_state->account_name = talloc_strdup(mem_ctx2, groupname);
 553         if (!a_state->account_name || !a_state->account_sid) {
 554                 return NT_STATUS_NO_MEMORY;
 555         }
 556
 557         /* create the policy handle */
 558         g_handle = dcesrv_handle_new(dce_call->conn, SAMR_HANDLE_GROUP);
 559         if (!g_handle) {
 560                 return NT_STATUS_NO_MEMORY;
 561         }
 562
 563         g_handle->data = a_state;
 564         g_handle->destroy = samr_Account_destroy;
 565
 566         /* the domain state is in use one more time */
 567         d_state->reference_count++;
 568
 569         *r->out.group_handle = g_handle->wire_handle;
 570         *r->out.rid = rid;
 571
 572         return NT_STATUS_OK;
 573 }
 574
 575
 576 /*
 577   samr_EnumDomainGroups
 578 */
 579 static NTSTATUS samr_EnumDomainGroups(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 580                                       struct samr_EnumDomainGroups *r)
 581 {
 582         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 583 }
 584
 585
 586 /*
 587   samr_CreateUser2
 588
 589   TODO: This should do some form of locking, especially around the rid allocation
 590 */
 591 static NTSTATUS samr_CreateUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 592                                  struct samr_CreateUser2 *r)
 593 {
 594         struct samr_domain_state *d_state;
 595         struct samr_account_state *a_state;
 596         struct dcesrv_handle *h;
 597         const char *name;
 598         struct ldb_message msg;
 599         uint32 rid;
 600         const char *username, *sidstr;
 601         time_t now = time(NULL);
 602         TALLOC_CTX *mem_ctx2;
 603         struct dcesrv_handle *u_handle;
 604         int ret;
 605         NTSTATUS status;
 606         const char *container;
 607
 608         ZERO_STRUCTP(r->out.acct_handle);
 609         *r->out.access_granted = 0;
 610         *r->out.rid = 0;
 611
 612         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_DOMAIN);
 613
 614         d_state = h->data;
 615
 616         username = r->in.username->name;
 617
 618         if (username == NULL) {
 619                 return NT_STATUS_INVALID_PARAMETER;
 620         }
 621
 622         /* check if the user already exists */
 623         name = samdb_search_string(d_state->sam_ctx, mem_ctx, d_state->domain_dn,
 624                                    "sAMAccountName",
 625                                    "(&(sAMAccountName=%s)(objectclass=user))", username);
 626         if (name != NULL) {
 627                 return NT_STATUS_USER_EXISTS;
 628         }
 629
 630         ZERO_STRUCT(msg);
 631
 632         /* This must be one of these values *only* */
 633         if (r->in.acct_flags == ACB_NORMAL) {
 634                 /* pull in all the template attributes */
 635                 ret = samdb_copy_template(d_state->sam_ctx, mem_ctx, &msg,
 636                                           "(&(name=TemplateUser)(objectclass=userTemplate))");
 637                 if (ret != 0) {
 638                         DEBUG(1,("Failed to load TemplateUser from samdb\n"));
 639                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 640                 }
 641
 642                 container = "Users";
 643
 644         } else if (r->in.acct_flags == ACB_WSTRUST) {
 645                 /* pull in all the template attributes */
 646                 ret = samdb_copy_template(d_state->sam_ctx, mem_ctx, &msg,
 647                                           "(&(name=TemplateMemberServer)(objectclass=userTemplate))");
 648                 if (ret != 0) {
 649                         DEBUG(1,("Failed to load TemplateMemberServer from samdb\n"));
 650                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 651                 }
 652
 653                 container = "Computers";
 654
 655         } else if (r->in.acct_flags == ACB_SVRTRUST) {
 656                 /* pull in all the template attributes */
 657                 ret = samdb_copy_template(d_state->sam_ctx, mem_ctx, &msg,
 658                                           "(&(name=TemplateDomainController)(objectclass=userTemplate))");
 659                 if (ret != 0) {
 660                         DEBUG(1,("Failed to load TemplateDomainController from samdb\n"));
 661                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 662                 }
 663
 664                 container = "DomainControllers";
 665
 666         } else if (r->in.acct_flags == ACB_DOMTRUST) {
 667                 /* pull in all the template attributes */
 668                 ret = samdb_copy_template(d_state->sam_ctx, mem_ctx, &msg,
 669                                           "(&(name=TemplateTrustingDomain)(objectclass=userTemplate))");
 670                 if (ret != 0) {
 671                         DEBUG(1,("Failed to load TemplateTrustingDomain from samdb\n"));
 672                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 673                 }
 674
 675                 container = "ForeignDomains";  /* FIXME: Is this correct?*/
 676
 677         } else {
 678                 return NT_STATUS_INVALID_PARAMETER;
 679         }
 680
 681         /* allocate a rid */
 682         status = samdb_allocate_next_id(d_state->sam_ctx, mem_ctx,
 683                                         d_state->domain_dn, "nextRid", &rid);
 684         if (!NT_STATUS_IS_OK(status)) {
 685                 return status;
 686         }
 687
 688         /* and the users SID */
 689         sidstr = talloc_asprintf(mem_ctx, "%s-%u", d_state->domain_sid, rid);
 690         if (!sidstr) {
 691                 return NT_STATUS_NO_MEMORY;
 692         }
 693
 694         /* add core elements to the ldb_message for the user */
 695         msg.dn = talloc_asprintf(mem_ctx, "CN=%s,CN=%s,%s", username, container, d_state->domain_dn);
 696         if (!msg.dn) {
 697                 return NT_STATUS_NO_MEMORY;
 698         }
 699         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg, "name", username);
 700         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg, "cn", username);
 701         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg, "sAMAccountName", username);
 702         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg, "objectClass", "user");
 703         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, &msg, "objectSid", sidstr);
 704         samdb_msg_set_ldaptime(d_state->sam_ctx, mem_ctx, &msg, "whenCreated", now);
 705         samdb_msg_set_ldaptime(d_state->sam_ctx, mem_ctx, &msg, "whenChanged", now);
 706
 707         /* create the user */
 708         ret = samdb_add(d_state->sam_ctx, mem_ctx, &msg);
 709         if (ret != 0) {
 710                 DEBUG(1,("Failed to create user record %s\n", msg.dn));
 711                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 712         }
 713
 714         /* create user state and new policy handle */
 715         mem_ctx2 = talloc_init("CreateUser(%s)", username);
 716         if (!mem_ctx2) {
 717                 return NT_STATUS_NO_MEMORY;
 718         }
 719
 720         a_state = talloc_p(mem_ctx2, struct samr_account_state);
 721         if (!a_state) {
 722                 return NT_STATUS_NO_MEMORY;
 723         }
 724         a_state->mem_ctx = mem_ctx2;
 725         a_state->sam_ctx = d_state->sam_ctx;
 726         a_state->access_mask = r->in.access_mask;
 727         a_state->domain_state = d_state;
 728         a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msg.dn);
 729         a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
 730         a_state->account_name = talloc_strdup(mem_ctx2, username);
 731         if (!a_state->account_name || !a_state->account_sid) {
 732                 return NT_STATUS_NO_MEMORY;
 733         }
 734
 735         /* create the policy handle */
 736         u_handle = dcesrv_handle_new(dce_call->conn, SAMR_HANDLE_USER);
 737         if (!u_handle) {
 738                 return NT_STATUS_NO_MEMORY;
 739         }
 740
 741         u_handle->data = a_state;
 742         u_handle->destroy = samr_Account_destroy;
 743
 744         /* the domain state is in use one more time */
 745         d_state->reference_count++;
 746
 747         *r->out.acct_handle = u_handle->wire_handle;
 748         *r->out.access_granted = 0xf07ff; /* TODO: fix access mask calculations */
 749         *r->out.rid = rid;
 750
 751         return NT_STATUS_OK;
 752 }
 753
 754
 755 /*
 756   samr_CreateUser
 757 */
 758 static NTSTATUS samr_CreateUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 759                                 struct samr_CreateUser *r)
 760 {
 761         struct samr_CreateUser2 r2;
 762         uint32 access_granted;
 763
 764
 765         /* a simple wrapper around samr_CreateUser2 works nicely */
 766         r2.in.handle = r->in.handle;
 767         r2.in.username = r->in.username;
 768         r2.in.acct_flags = ACB_NORMAL;
 769         r2.in.access_mask = r->in.access_mask;
 770         r2.out.acct_handle = r->out.acct_handle;
 771         r2.out.access_granted = &access_granted;
 772         r2.out.rid = r->out.rid;
 773
 774         return samr_CreateUser2(dce_call, mem_ctx, &r2);
 775 }
 776
 777 /*
 778   comparison function for sorting SamEntry array
 779 */
 780 static int compare_SamEntry(struct samr_SamEntry *e1, struct samr_SamEntry *e2)
 781 {
 782         return e1->idx - e2->idx;
 783 }
 784
 785 /*
 786   samr_EnumDomainUsers
 787 */
 788 static NTSTATUS samr_EnumDomainUsers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 789                                      struct samr_EnumDomainUsers *r)
 790 {
 791         struct dcesrv_handle *h;
 792         struct samr_domain_state *d_state;
 793         struct ldb_message **res;
 794         int count, i, first;
 795         struct samr_SamEntry *entries;
 796         const char * const attrs[3] = { "objectSid", "sAMAccountName", NULL };
 797
 798         *r->out.resume_handle = 0;
 799         r->out.sam = NULL;
 800         r->out.num_entries = 0;
 801
 802         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_DOMAIN);
 803
 804         d_state = h->data;
 805
 806         /* search for all users in this domain. This could possibly be cached and
 807            resumed based on resume_key */
 808         count = samdb_search(d_state->sam_ctx, mem_ctx, d_state->domain_dn, &res, attrs,
 809                              "objectclass=user");
 810         if (count == -1) {
 811                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 812         }
 813         if (count == 0 || r->in.max_size == 0) {
 814                 return NT_STATUS_OK;
 815         }
 816
 817         /* convert to SamEntry format */
 818         entries = talloc_array_p(mem_ctx, struct samr_SamEntry, count);
 819         if (!entries) {
 820                 return NT_STATUS_NO_MEMORY;
 821         }
 822         for (i=0;i<count;i++) {
 823                 entries[i].idx = samdb_result_rid_from_sid(mem_ctx, res[i], "objectSid", 0);
 824                 entries[i].name.name = samdb_result_string(res[i], "sAMAccountName", "");
 825         }
 826
 827         /* sort the results by rid */
 828         qsort(entries, count, sizeof(struct samr_SamEntry),
 829               (comparison_fn_t)compare_SamEntry);
 830
 831         /* find the first entry to return */
 832         for (first=0;
 833              first<count && entries[first].idx <= *r->in.resume_handle;
 834              first++) ;
 835
 836         if (first == count) {
 837                 return NT_STATUS_OK;
 838         }
 839
 840         /* return the rest, limit by max_size. Note that we
 841            use the w2k3 element size value of 54 */
 842         r->out.num_entries = count - first;
 843         r->out.num_entries = MIN(r->out.num_entries,
 844                                  1+(r->in.max_size/SAMR_ENUM_USERS_MULTIPLIER));
 845
 846         r->out.sam = talloc_p(mem_ctx, struct samr_SamArray);
 847         if (!r->out.sam) {
 848                 return NT_STATUS_NO_MEMORY;
 849         }
 850
 851         r->out.sam->entries = entries+first;
 852         r->out.sam->count = r->out.num_entries;
 853
 854         if (r->out.num_entries < count - first) {
 855                 *r->out.resume_handle = entries[first+r->out.num_entries-1].idx;
 856                 return STATUS_MORE_ENTRIES;
 857         }
 858
 859         return NT_STATUS_OK;
 860 }
 861
 862
 863 /*
 864   samr_CreateDomAlias
 865 */
 866 static NTSTATUS samr_CreateDomAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 867                        struct samr_CreateDomAlias *r)
 868 {
 869         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 870 }
 871
 872
 873 /*
 874   samr_EnumDomainAliases
 875 */
 876 static NTSTATUS samr_EnumDomainAliases(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 877                        struct samr_EnumDomainAliases *r)
 878 {
 879         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 880 }
 881
 882
 883 /*
 884   samr_GetAliasMembership
 885 */
 886 static NTSTATUS samr_GetAliasMembership(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 887                        struct samr_GetAliasMembership *r)
 888 {
 889         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 890 }
 891
 892
 893 /*
 894   samr_LookupNames
 895 */
 896 static NTSTATUS samr_LookupNames(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 897                                  struct samr_LookupNames *r)
 898 {
 899         struct dcesrv_handle *h;
 900         struct samr_domain_state *d_state;
 901         int i;
 902         NTSTATUS status = NT_STATUS_OK;
 903         const char * const attrs[] = { "sAMAccountType", "objectSid", NULL };
 904         int count;
 905
 906         ZERO_STRUCT(r->out.rids);
 907         ZERO_STRUCT(r->out.types);
 908
 909         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_DOMAIN);
 910
 911         d_state = h->data;
 912
 913         if (r->in.num_names == 0) {
 914                 return NT_STATUS_OK;
 915         }
 916
 917         r->out.rids.ids = talloc_array_p(mem_ctx, uint32, r->in.num_names);
 918         r->out.types.ids = talloc_array_p(mem_ctx, uint32, r->in.num_names);
 919         if (!r->out.rids.ids || !r->out.types.ids) {
 920                 return NT_STATUS_NO_MEMORY;
 921         }
 922         r->out.rids.count = r->in.num_names;
 923         r->out.types.count = r->in.num_names;
 924
 925         for (i=0;i<r->in.num_names;i++) {
 926                 struct ldb_message **res;
 927                 struct dom_sid2 *sid;
 928                 const char *sidstr;
 929                 uint32 atype, rtype;
 930
 931                 r->out.rids.ids[i] = 0;
 932                 r->out.types.ids[i] = SID_NAME_UNKNOWN;
 933
 934                 count = samdb_search(d_state->sam_ctx, mem_ctx, d_state->domain_dn, &res, attrs,
 935                                      "sAMAccountName=%s", r->in.names[i].name);
 936                 if (count != 1) {
 937                         status = STATUS_SOME_UNMAPPED;
 938                         continue;
 939                 }
 940
 941                 sidstr = samdb_result_string(res[0], "objectSid", NULL);
 942                 if (sidstr == NULL) {
 943                         status = STATUS_SOME_UNMAPPED;
 944                         continue;
 945                 }
 946
 947                 sid = dom_sid_parse_talloc(mem_ctx, sidstr);
 948                 if (sid == NULL) {
 949                         status = STATUS_SOME_UNMAPPED;
 950                         continue;
 951                 }
 952
 953                 atype = samdb_result_uint(res[0], "sAMAccountType", 0);
 954                 if (atype == 0) {
 955                         status = STATUS_SOME_UNMAPPED;
 956                         continue;
 957                 }
 958
 959                 rtype = samdb_atype_map(atype);
 960
 961                 if (rtype == SID_NAME_UNKNOWN) {
 962                         status = STATUS_SOME_UNMAPPED;
 963                         continue;
 964                 }
 965
 966                 r->out.rids.ids[i] = sid->sub_auths[sid->num_auths-1];
 967                 r->out.types.ids[i] = rtype;
 968         }
 969
 970
 971         return status;
 972 }
 973
 974
 975 /*
 976   samr_LookupRids
 977 */
 978 static NTSTATUS samr_LookupRids(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 979                        struct samr_LookupRids *r)
 980 {
 981         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 982 }
 983
 984
 985 /*
 986   samr_OpenGroup
 987 */
 988 static NTSTATUS samr_OpenGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 989                        struct samr_OpenGroup *r)
 990 {
 991         struct samr_domain_state *d_state;
 992         struct samr_account_state *a_state;
 993         struct dcesrv_handle *h;
 994         const char *groupname, *sidstr;
 995         TALLOC_CTX *mem_ctx2;
 996         struct ldb_message **msgs;
 997         struct dcesrv_handle *g_handle;
 998         const char * const attrs[2] = { "sAMAccountName", NULL };
 999         int ret;
1000
1001         ZERO_STRUCTP(r->out.acct_handle);
1002
1003         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_DOMAIN);
1004
1005         d_state = h->data;
1006
1007         /* form the group SID */
1008         sidstr = talloc_asprintf(mem_ctx, "%s-%u", d_state->domain_sid, r->in.rid);
1009         if (!sidstr) {
1010                 return NT_STATUS_NO_MEMORY;
1011         }
1012
1013         /* search for the group record */
1014         ret = samdb_search(d_state->sam_ctx,
1015                            mem_ctx, d_state->domain_dn, &msgs, attrs,
1016                            "(&(objectSid=%s)(objectclass=group))",
1017                            sidstr);
1018         if (ret == 0) {
1019                 return NT_STATUS_NO_SUCH_GROUP;
1020         }
1021         if (ret != 1) {
1022                 DEBUG(1,("Found %d records matching sid %s\n", ret, sidstr));
1023                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1024         }
1025
1026         groupname = samdb_result_string(msgs[0], "sAMAccountName", NULL);
1027         if (groupname == NULL) {
1028                 DEBUG(1,("sAMAccountName field missing for sid %s\n", sidstr));
1029                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1030         }
1031
1032         /* create group state and new policy handle */
1033         mem_ctx2 = talloc_init("OpenGroup(%u)", r->in.rid);
1034         if (!mem_ctx2) {
1035                 return NT_STATUS_NO_MEMORY;
1036         }
1037
1038         a_state = talloc_p(mem_ctx2, struct samr_account_state);
1039         if (!a_state) {
1040                 return NT_STATUS_NO_MEMORY;
1041         }
1042         a_state->mem_ctx = mem_ctx2;
1043         a_state->sam_ctx = d_state->sam_ctx;
1044         a_state->access_mask = r->in.access_mask;
1045         a_state->domain_state = d_state;
1046         a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msgs[0]->dn);
1047         a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
1048         a_state->account_name = talloc_strdup(mem_ctx2, groupname);
1049         if (!a_state->account_name || !a_state->account_sid) {
1050                 return NT_STATUS_NO_MEMORY;
1051         }
1052
1053         /* create the policy handle */
1054         g_handle = dcesrv_handle_new(dce_call->conn, SAMR_HANDLE_GROUP);
1055         if (!g_handle) {
1056                 return NT_STATUS_NO_MEMORY;
1057         }
1058
1059         g_handle->data = a_state;
1060         g_handle->destroy = samr_Account_destroy;
1061
1062         /* the domain state is in use one more time */
1063         d_state->reference_count++;
1064
1065         *r->out.acct_handle = g_handle->wire_handle;
1066
1067         return NT_STATUS_OK;
1068 }
1069
1070 /* these query macros make samr_Query[User|Group]Info a bit easier to read */
1071
1072 #define QUERY_STRING(msg, field, attr) \
1073         r->out.info->field = samdb_result_string(msg, attr, "");
1074 #define QUERY_UINT(msg, field, attr) \
1075         r->out.info->field = samdb_result_uint(msg, attr, 0);
1076 #define QUERY_RID(msg, field, attr) \
1077         r->out.info->field = samdb_result_rid_from_sid(mem_ctx, msg, attr, 0);
1078 #define QUERY_NTTIME(msg, field, attr) \
1079         r->out.info->field = samdb_result_nttime(msg, attr, 0);
1080 #define QUERY_APASSC(msg, field, attr) \
1081         r->out.info->field = samdb_result_allow_pwd_change(a_state->sam_ctx, mem_ctx, \
1082                                                            a_state->domain_state->domain_dn, msg, attr);
1083 #define QUERY_FPASSC(msg, field, attr) \
1084         r->out.info->field = samdb_result_force_pwd_change(a_state->sam_ctx, mem_ctx, \
1085                                                            a_state->domain_state->domain_dn, msg, attr);
1086 #define QUERY_LHOURS(msg, field, attr) \
1087         r->out.info->field = samdb_result_logon_hours(mem_ctx, msg, attr);
1088 #define QUERY_AFLAGS(msg, field, attr) \
1089         r->out.info->field = samdb_result_acct_flags(msg, attr);
1090
1091
1092 /* these are used to make the Set[User|Group]Info code easier to follow */
1093
1094 #define SET_STRING(mod, field, attr) do { \
1095         if (r->in.info->field == NULL) return NT_STATUS_INVALID_PARAMETER; \
1096         if (samdb_msg_add_string(a_state->sam_ctx, mem_ctx, mod, attr, r->in.info->field) != 0) { \
1097                 return NT_STATUS_NO_MEMORY; \
1098         } \
1099 } while (0)
1100
1101 #define SET_UINT(mod, field, attr) do { \
1102         if (samdb_msg_add_uint(a_state->sam_ctx, mem_ctx, mod, attr, r->in.info->field) != 0) { \
1103                 return NT_STATUS_NO_MEMORY; \
1104         } \
1105 } while (0)
1106
1107 #define SET_AFLAGS(msg, field, attr) do { \
1108         if (samdb_msg_add_acct_flags(a_state->sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
1109                 return NT_STATUS_NO_MEMORY; \
1110         } \
1111 } while (0)
1112
1113 #define SET_LHOURS(msg, field, attr) do { \
1114         if (samdb_msg_add_logon_hours(a_state->sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
1115                 return NT_STATUS_NO_MEMORY; \
1116         } \
1117 } while (0)
1118
1119 /*
1120   samr_QueryGroupInfo
1121 */
1122 static NTSTATUS samr_QueryGroupInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1123                        struct samr_QueryGroupInfo *r)
1124 {
1125         struct dcesrv_handle *h;
1126         struct samr_account_state *a_state;
1127         struct ldb_message *msg, **res;
1128         const char * const attrs[4] = { "sAMAccountName", "description",
1129                                         "numMembers", NULL };
1130         int ret;
1131
1132         r->out.info = NULL;
1133
1134         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_GROUP);
1135
1136         a_state = h->data;
1137
1138         /* pull all the group attributes */
1139         ret = samdb_search(a_state->sam_ctx, mem_ctx, NULL, &res, attrs,
1140                            "dn=%s", a_state->account_dn);
1141         if (ret != 1) {
1142                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1143         }
1144         msg = res[0];
1145
1146         /* allocate the info structure */
1147         r->out.info = talloc_p(mem_ctx, union samr_GroupInfo);
1148         if (r->out.info == NULL) {
1149                 return NT_STATUS_NO_MEMORY;
1150         }
1151         ZERO_STRUCTP(r->out.info);
1152
1153         /* Fill in the level */
1154         switch (r->in.level) {
1155         case GroupInfoAll:
1156                 QUERY_STRING(msg, all.name.name,        "sAMAccountName");
1157                 r->out.info->all.unknown = 7; /* Do like w2k3 */
1158                 QUERY_UINT  (msg, all.num_members,      "numMembers")
1159                 QUERY_STRING(msg, all.description.name, "description");
1160                 break;
1161         case GroupInfoName:
1162                 QUERY_STRING(msg, name.name,            "sAMAccountName");
1163                 break;
1164         case GroupInfoX:
1165                 r->out.info->unknown.unknown = 7;
1166                 break;
1167         case GroupInfoDescription:
1168                 QUERY_STRING(msg, description.name, "description");
1169                 break;
1170         default:
1171                 r->out.info = NULL;
1172                 return NT_STATUS_INVALID_INFO_CLASS;
1173         }
1174
1175         return NT_STATUS_OK;
1176 }
1177
1178
1179 /*
1180   samr_SetGroupInfo
1181 */
1182 static NTSTATUS samr_SetGroupInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1183                        struct samr_SetGroupInfo *r)
1184 {
1185         struct dcesrv_handle *h;
1186         struct samr_account_state *a_state;
1187         struct ldb_message mod, *msg = &mod;
1188         int i, ret;
1189
1190         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_GROUP);
1191
1192         a_state = h->data;
1193
1194         ZERO_STRUCT(mod);
1195         mod.dn = talloc_strdup(mem_ctx, a_state->account_dn);
1196         if (!mod.dn) {
1197                 return NT_STATUS_NO_MEMORY;
1198         }
1199
1200         switch (r->in.level) {
1201         case GroupInfoDescription:
1202                 SET_STRING(msg, description.name,         "description");
1203                 break;
1204         case GroupInfoName:
1205                 /* On W2k3 this does not change the name, it changes the
1206                  * sAMAccountName attribute */
1207                 SET_STRING(msg, name.name,                "sAMAccountName");
1208                 break;
1209         case GroupInfoX:
1210                 /* This does not do anything obviously visible in W2k3 LDAP */
1211                 break;
1212         default:
1213                 return NT_STATUS_INVALID_INFO_CLASS;
1214         }
1215
1216         /* mark all the message elements as LDB_FLAG_MOD_REPLACE */
1217         for (i=0;i<mod.num_elements;i++) {
1218                 mod.elements[i].flags = LDB_FLAG_MOD_REPLACE;
1219         }
1220
1221         /* modify the samdb record */
1222         ret = samdb_modify(a_state->sam_ctx, mem_ctx, &mod);
1223         if (ret != 0) {
1224                 /* we really need samdb.c to return NTSTATUS */
1225                 return NT_STATUS_UNSUCCESSFUL;
1226         }
1227
1228         return NT_STATUS_OK;
1229 }
1230
1231
1232 /*
1233   samr_AddGroupMember
1234 */
1235 static NTSTATUS samr_AddGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1236                        struct samr_AddGroupMember *r)
1237 {
1238         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1239 }
1240
1241
1242 /*
1243   samr_DeleteDomainGroup
1244 */
1245 static NTSTATUS samr_DeleteDomainGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1246                        struct samr_DeleteDomainGroup *r)
1247 {
1248         struct dcesrv_handle *h;
1249         struct samr_account_state *a_state;
1250         int ret;
1251
1252         *r->out.handle = *r->in.handle;
1253
1254         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_GROUP);
1255
1256         a_state = h->data;
1257
1258         ret = samdb_delete(a_state->sam_ctx, mem_ctx, a_state->account_dn);
1259         if (ret != 0) {
1260                 return NT_STATUS_UNSUCCESSFUL;
1261         }
1262
1263         ZERO_STRUCTP(r->out.handle);
1264
1265         return NT_STATUS_OK;
1266 }
1267
1268
1269 /*
1270   samr_DeleteGroupMember
1271 */
1272 static NTSTATUS samr_DeleteGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1273                        struct samr_DeleteGroupMember *r)
1274 {
1275         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1276 }
1277
1278
1279 /*
1280   samr_QueryGroupMember
1281 */
1282 static NTSTATUS samr_QueryGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1283                        struct samr_QueryGroupMember *r)
1284 {
1285         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1286 }
1287
1288
1289 /*
1290   samr_SetMemberAttributesOfGroup
1291 */
1292 static NTSTATUS samr_SetMemberAttributesOfGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1293                        struct samr_SetMemberAttributesOfGroup *r)
1294 {
1295         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1296 }
1297
1298
1299 /*
1300   samr_OpenAlias
1301 */
1302 static NTSTATUS samr_OpenAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1303                        struct samr_OpenAlias *r)
1304 {
1305         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1306 }
1307
1308
1309 /*
1310   samr_QueryAliasInfo
1311 */
1312 static NTSTATUS samr_QueryAliasInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1313                        struct samr_QueryAliasInfo *r)
1314 {
1315         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1316 }
1317
1318
1319 /*
1320   samr_SetAliasInfo
1321 */
1322 static NTSTATUS samr_SetAliasInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1323                        struct samr_SetAliasInfo *r)
1324 {
1325         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1326 }
1327
1328
1329 /*
1330   samr_DeleteDomAlias
1331 */
1332 static NTSTATUS samr_DeleteDomAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1333                        struct samr_DeleteDomAlias *r)
1334 {
1335         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1336 }
1337
1338
1339 /*
1340   samr_AddAliasMember
1341 */
1342 static NTSTATUS samr_AddAliasMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1343                        struct samr_AddAliasMember *r)
1344 {
1345         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1346 }
1347
1348
1349 /*
1350   samr_DeleteAliasMember
1351 */
1352 static NTSTATUS samr_DeleteAliasMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1353                        struct samr_DeleteAliasMember *r)
1354 {
1355         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1356 }
1357
1358
1359 /*
1360   samr_GetMembersInAlias
1361 */
1362 static NTSTATUS samr_GetMembersInAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1363                        struct samr_GetMembersInAlias *r)
1364 {
1365         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1366 }
1367
1368
1369 /*
1370   samr_OpenUser
1371 */
1372 static NTSTATUS samr_OpenUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1373                               struct samr_OpenUser *r)
1374 {
1375         struct samr_domain_state *d_state;
1376         struct samr_account_state *a_state;
1377         struct dcesrv_handle *h;
1378         const char *username, *sidstr;
1379         TALLOC_CTX *mem_ctx2;
1380         struct ldb_message **msgs;
1381         struct dcesrv_handle *u_handle;
1382         const char * const attrs[2] = { "sAMAccountName", NULL };
1383         int ret;
1384
1385         ZERO_STRUCTP(r->out.acct_handle);
1386
1387         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_DOMAIN);
1388
1389         d_state = h->data;
1390
1391         /* form the users SID */
1392         sidstr = talloc_asprintf(mem_ctx, "%s-%u", d_state->domain_sid, r->in.rid);
1393         if (!sidstr) {
1394                 return NT_STATUS_NO_MEMORY;
1395         }
1396
1397         /* search for the user record */
1398         ret = samdb_search(d_state->sam_ctx,
1399                            mem_ctx, d_state->domain_dn, &msgs, attrs,
1400                            "(&(objectSid=%s)(objectclass=user))",
1401                            sidstr);
1402         if (ret == 0) {
1403                 return NT_STATUS_NO_SUCH_USER;
1404         }
1405         if (ret != 1) {
1406                 DEBUG(1,("Found %d records matching sid %s\n", ret, sidstr));
1407                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1408         }
1409
1410         username = samdb_result_string(msgs[0], "sAMAccountName", NULL);
1411         if (username == NULL) {
1412                 DEBUG(1,("sAMAccountName field missing for sid %s\n", sidstr));
1413                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1414         }
1415
1416         /* create user state and new policy handle */
1417         mem_ctx2 = talloc_init("OpenUser(%u)", r->in.rid);
1418         if (!mem_ctx2) {
1419                 return NT_STATUS_NO_MEMORY;
1420         }
1421
1422         a_state = talloc_p(mem_ctx2, struct samr_account_state);
1423         if (!a_state) {
1424                 return NT_STATUS_NO_MEMORY;
1425         }
1426         a_state->mem_ctx = mem_ctx2;
1427         a_state->sam_ctx = d_state->sam_ctx;
1428         a_state->access_mask = r->in.access_mask;
1429         a_state->domain_state = d_state;
1430         a_state->account_dn = talloc_steal(mem_ctx, mem_ctx2, msgs[0]->dn);
1431         a_state->account_sid = talloc_strdup(mem_ctx2, sidstr);
1432         a_state->account_name = talloc_strdup(mem_ctx2, username);
1433         if (!a_state->account_name || !a_state->account_sid) {
1434                 return NT_STATUS_NO_MEMORY;
1435         }
1436
1437         /* create the policy handle */
1438         u_handle = dcesrv_handle_new(dce_call->conn, SAMR_HANDLE_USER);
1439         if (!u_handle) {
1440                 return NT_STATUS_NO_MEMORY;
1441         }
1442
1443         u_handle->data = a_state;
1444         u_handle->destroy = samr_Account_destroy;
1445
1446         /* the domain state is in use one more time */
1447         d_state->reference_count++;
1448
1449         *r->out.acct_handle = u_handle->wire_handle;
1450
1451         return NT_STATUS_OK;
1452
1453 }
1454
1455
1456 /*
1457   samr_DeleteUser
1458 */
1459 static NTSTATUS samr_DeleteUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1460                                 struct samr_DeleteUser *r)
1461 {
1462         struct dcesrv_handle *h;
1463         struct samr_account_state *a_state;
1464         int ret;
1465
1466         *r->out.handle = *r->in.handle;
1467
1468         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_USER);
1469
1470         a_state = h->data;
1471
1472         ret = samdb_delete(a_state->sam_ctx, mem_ctx, a_state->account_dn);
1473         if (ret != 0) {
1474                 return NT_STATUS_UNSUCCESSFUL;
1475         }
1476
1477         ZERO_STRUCTP(r->out.handle);
1478
1479         return NT_STATUS_OK;
1480 }
1481
1482
1483 /*
1484   samr_QueryUserInfo
1485 */
1486 static NTSTATUS samr_QueryUserInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1487                                    struct samr_QueryUserInfo *r)
1488 {
1489         struct dcesrv_handle *h;
1490         struct samr_account_state *a_state;
1491         struct ldb_message *msg, **res;
1492         int ret;
1493
1494         r->out.info = NULL;
1495
1496         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_USER);
1497
1498         a_state = h->data;
1499
1500         /* pull all the user attributes */
1501         ret = samdb_search(a_state->sam_ctx, mem_ctx, NULL, &res, NULL,
1502                            "dn=%s", a_state->account_dn);
1503         if (ret != 1) {
1504                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1505         }
1506         msg = res[0];
1507
1508         /* allocate the info structure */
1509         r->out.info = talloc_p(mem_ctx, union samr_UserInfo);
1510         if (r->out.info == NULL) {
1511                 return NT_STATUS_NO_MEMORY;
1512         }
1513         ZERO_STRUCTP(r->out.info);
1514
1515         /* fill in the reply */
1516         switch (r->in.level) {
1517         case 1:
1518                 QUERY_STRING(msg, info1.username.name,    "sAMAccountName");
1519                 QUERY_STRING(msg, info1.full_name.name,   "displayName");
1520                 QUERY_UINT  (msg, info1.primary_gid,      "primaryGroupID");
1521                 QUERY_STRING(msg, info1.description.name, "description");
1522                 QUERY_STRING(msg, info1.comment.name,     "comment");
1523                 break;
1524
1525         case 2:
1526                 QUERY_STRING(msg, info2.comment.name,     "comment");
1527                 QUERY_UINT  (msg, info2.country_code,     "countryCode");
1528                 QUERY_UINT  (msg, info2.code_page,        "codePage");
1529                 break;
1530
1531         case 3:
1532                 QUERY_STRING(msg, info3.username.name,       "sAMAccountName");
1533                 QUERY_STRING(msg, info3.full_name.name,      "displayName");
1534                 QUERY_RID   (msg, info3.rid,                 "objectSid");
1535                 QUERY_UINT  (msg, info3.primary_gid,         "primaryGroupID");
1536                 QUERY_STRING(msg, info3.home_directory.name, "homeDirectory");
1537                 QUERY_STRING(msg, info3.home_drive.name,     "homeDrive");
1538                 QUERY_STRING(msg, info3.logon_script.name,   "scriptPath");
1539                 QUERY_STRING(msg, info3.profile.name,        "profilePath");
1540                 QUERY_STRING(msg, info3.workstations.name,   "userWorkstations");
1541                 QUERY_NTTIME(msg, info3.last_logon,          "lastLogon");
1542                 QUERY_NTTIME(msg, info3.last_logoff,         "lastLogoff");
1543                 QUERY_NTTIME(msg, info3.last_pwd_change,     "pwdLastSet");
1544                 QUERY_APASSC(msg, info3.allow_pwd_change,    "pwdLastSet");
1545                 QUERY_FPASSC(msg, info3.force_pwd_change,    "pwdLastSet");
1546                 QUERY_LHOURS(msg, info3.logon_hours,         "logonHours");
1547                 QUERY_UINT  (msg, info3.bad_pwd_count,       "badPwdCount");
1548                 QUERY_UINT  (msg, info3.num_logons,          "logonCount");
1549                 QUERY_AFLAGS(msg, info3.acct_flags,          "userAccountControl");
1550                 break;
1551
1552         case 4:
1553                 QUERY_LHOURS(msg, info4.logon_hours,         "logonHours");
1554                 break;
1555
1556         case 5:
1557                 QUERY_STRING(msg, info5.username.name,       "sAMAccountName");
1558                 QUERY_STRING(msg, info5.full_name.name,      "displayName");
1559                 QUERY_RID   (msg, info5.rid,                 "objectSid");
1560                 QUERY_UINT  (msg, info5.primary_gid,         "primaryGroupID");
1561                 QUERY_STRING(msg, info5.home_directory.name, "homeDirectory");
1562                 QUERY_STRING(msg, info5.home_drive.name,     "homeDrive");
1563                 QUERY_STRING(msg, info5.logon_script.name,   "scriptPath");
1564                 QUERY_STRING(msg, info5.profile.name,        "profilePath");
1565                 QUERY_STRING(msg, info5.description.name,    "description");
1566                 QUERY_STRING(msg, info5.workstations.name,   "userWorkstations");
1567                 QUERY_NTTIME(msg, info5.last_logon,          "lastLogon");
1568                 QUERY_NTTIME(msg, info5.last_logoff,         "lastLogoff");
1569                 QUERY_LHOURS(msg, info5.logon_hours,         "logonHours");
1570                 QUERY_UINT  (msg, info5.bad_pwd_count,       "badPwdCount");
1571                 QUERY_UINT  (msg, info5.num_logons,          "logonCount");
1572                 QUERY_NTTIME(msg, info5.last_pwd_change,     "pwdLastSet");
1573                 QUERY_NTTIME(msg, info5.acct_expiry,         "accountExpires");
1574                 QUERY_AFLAGS(msg, info5.acct_flags,          "userAccountControl");
1575                 break;
1576
1577         case 6:
1578                 QUERY_STRING(msg, info6.username.name,       "sAMAccountName");
1579                 QUERY_STRING(msg, info6.full_name.name,      "displayName");
1580                 break;
1581
1582         case 7:
1583                 QUERY_STRING(msg, info7.username.name,       "sAMAccountName");
1584                 break;
1585
1586         case 8:
1587                 QUERY_STRING(msg, info8.full_name.name,      "displayName");
1588                 break;
1589
1590         case 9:
1591                 QUERY_UINT  (msg, info9.primary_gid,         "primaryGroupID");
1592                 break;
1593
1594         case 10:
1595                 QUERY_STRING(msg, info10.home_directory.name, "homeDirectory");
1596                 QUERY_STRING(msg, info10.home_drive.name,     "homeDrive");
1597                 break;
1598
1599         case 11:
1600                 QUERY_STRING(msg, info11.logon_script.name,   "scriptPath");
1601                 break;
1602
1603         case 12:
1604                 QUERY_STRING(msg, info12.profile.name,        "profilePath");
1605                 break;
1606
1607         case 13:
1608                 QUERY_STRING(msg, info13.description.name,    "description");
1609                 break;
1610
1611         case 14:
1612                 QUERY_STRING(msg, info14.workstations.name,   "userWorkstations");
1613                 break;
1614
1615         case 16:
1616                 QUERY_AFLAGS(msg, info16.acct_flags,          "userAccountControl");
1617                 break;
1618
1619         case 17:
1620                 QUERY_NTTIME(msg, info17.acct_expiry,         "accountExpires");
1621
1622         case 20:
1623                 QUERY_STRING(msg, info20.callback.name,       "userParameters");
1624                 break;
1625
1626         case 21:
1627                 QUERY_NTTIME(msg, info21.last_logon,          "lastLogon");
1628                 QUERY_NTTIME(msg, info21.last_logoff,         "lastLogoff");
1629                 QUERY_NTTIME(msg, info21.last_pwd_change,     "pwdLastSet");
1630                 QUERY_NTTIME(msg, info21.acct_expiry,         "accountExpires");
1631                 QUERY_APASSC(msg, info21.allow_pwd_change,    "pwdLastSet");
1632                 QUERY_FPASSC(msg, info21.force_pwd_change,    "pwdLastSet");
1633                 QUERY_STRING(msg, info21.username.name,       "sAMAccountName");
1634                 QUERY_STRING(msg, info21.full_name.name,      "displayName");
1635                 QUERY_STRING(msg, info21.home_directory.name, "homeDirectory");
1636                 QUERY_STRING(msg, info21.home_drive.name,     "homeDrive");
1637                 QUERY_STRING(msg, info21.logon_script.name,   "scriptPath");
1638                 QUERY_STRING(msg, info21.profile.name,        "profilePath");
1639                 QUERY_STRING(msg, info21.description.name,    "description");
1640                 QUERY_STRING(msg, info21.workstations.name,   "userWorkstations");
1641                 QUERY_STRING(msg, info21.comment.name,        "comment");
1642                 QUERY_STRING(msg, info21.callback.name,       "userParameters");
1643                 QUERY_RID   (msg, info21.rid,                 "objectSid");
1644                 QUERY_UINT  (msg, info21.primary_gid,         "primaryGroupID");
1645                 QUERY_AFLAGS(msg, info21.acct_flags,          "userAccountControl");
1646                 r->out.info->info21.fields_present = 0x00FFFFFF;
1647                 QUERY_LHOURS(msg, info21.logon_hours,         "logonHours");
1648                 QUERY_UINT  (msg, info21.bad_pwd_count,       "badPwdCount");
1649                 QUERY_UINT  (msg, info21.num_logons,          "logonCount");
1650                 QUERY_UINT  (msg, info21.country_code,        "countryCode");
1651                 QUERY_UINT  (msg, info21.code_page,           "codePage");
1652                 break;
1653
1654
1655         default:
1656                 r->out.info = NULL;
1657                 return NT_STATUS_INVALID_INFO_CLASS;
1658         }
1659
1660         return NT_STATUS_OK;
1661 }
1662
1663
1664 /*
1665   set password via a samr_CryptPassword buffer
1666   this will in the 'msg' with modify operations that will update the user
1667   password when applied
1668 */
1669 static NTSTATUS samr_set_password(struct dcesrv_call_state *dce_call,
1670                                   struct samr_account_state *a_state, TALLOC_CTX *mem_ctx,
1671                                   struct ldb_message *msg,
1672                                   struct samr_CryptPassword *pwbuf)
1673 {
1674         char new_pass[512];
1675         uint32 new_pass_len;
1676         DATA_BLOB session_key = dce_call->conn->session_key;
1677
1678         SamOEMhashBlob(pwbuf->data, 516, &session_key);
1679
1680         if (!decode_pw_buffer(pwbuf->data, new_pass, sizeof(new_pass),
1681                               &new_pass_len, STR_UNICODE)) {
1682                 DEBUG(3,("samr: failed to decode password buffer\n"));
1683                 return NT_STATUS_WRONG_PASSWORD;
1684         }
1685
1686         /* set the password - samdb needs to know both the domain and user DNs,
1687            so the domain password policy can be used */
1688         return samdb_set_password(a_state->sam_ctx, mem_ctx,
1689                                   a_state->account_dn, a_state->domain_state->domain_dn,
1690                                   msg, new_pass,
1691                                   NULL, NULL,
1692                                   False /* This is a password set, not change */);
1693 }
1694
1695 /*
1696   samr_SetUserInfo
1697 */
1698 static NTSTATUS samr_SetUserInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1699                                  struct samr_SetUserInfo *r)
1700 {
1701         struct dcesrv_handle *h;
1702         struct samr_account_state *a_state;
1703         struct ldb_message mod, *msg = &mod;
1704         int i, ret;
1705         NTSTATUS status = NT_STATUS_OK;
1706
1707         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_USER);
1708
1709         a_state = h->data;
1710
1711         ZERO_STRUCT(mod);
1712         mod.dn = talloc_strdup(mem_ctx, a_state->account_dn);
1713         if (!mod.dn) {
1714                 return NT_STATUS_NO_MEMORY;
1715         }
1716
1717         switch (r->in.level) {
1718         case 2:
1719                 SET_STRING(msg, info2.comment.name,         "comment");
1720                 SET_UINT  (msg, info2.country_code,         "countryCode");
1721                 SET_UINT  (msg, info2.code_page,            "codePage");
1722                 break;
1723
1724         case 4:
1725                 SET_LHOURS(msg, info4.logon_hours,          "logonHours");
1726                 break;
1727
1728         case 6:
1729                 SET_STRING(msg, info6.full_name.name,       "displayName");
1730                 break;
1731
1732         case 8:
1733                 SET_STRING(msg, info8.full_name.name,       "displayName");
1734                 break;
1735
1736         case 9:
1737                 SET_UINT(msg, info9.primary_gid,            "primaryGroupID");
1738                 break;
1739
1740         case 10:
1741                 SET_STRING(msg, info10.home_directory.name, "homeDirectory");
1742                 SET_STRING(msg, info10.home_drive.name,     "homeDrive");
1743                 break;
1744
1745         case 11:
1746                 SET_STRING(msg, info11.logon_script.name,   "scriptPath");
1747                 break;
1748
1749         case 12:
1750                 SET_STRING(msg, info12.profile.name,        "profilePath");
1751                 break;
1752
1753         case 13:
1754                 SET_STRING(msg, info13.description.name,    "description");
1755                 break;
1756
1757         case 14:
1758                 SET_STRING(msg, info14.workstations.name,   "userWorkstations");
1759                 break;
1760
1761         case 16:
1762                 SET_AFLAGS(msg, info16.acct_flags,          "userAccountControl");
1763                 break;
1764
1765         case 20:
1766                 SET_STRING(msg, info20.callback.name,       "userParameters");
1767                 break;
1768
1769         case 21:
1770 #define IFSET(bit) if (bit & r->in.info->info21.fields_present)
1771                 IFSET(SAMR_FIELD_NAME)
1772                         SET_STRING(msg, info21.full_name.name,    "displayName");
1773                 IFSET(SAMR_FIELD_DESCRIPTION)
1774                         SET_STRING(msg, info21.description.name,  "description");
1775                 IFSET(SAMR_FIELD_COMMENT)
1776                         SET_STRING(msg, info21.comment.name,      "comment");
1777                 IFSET(SAMR_FIELD_LOGON_SCRIPT)
1778                         SET_STRING(msg, info21.logon_script.name, "scriptPath");
1779                 IFSET(SAMR_FIELD_PROFILE)
1780                         SET_STRING(msg, info21.profile.name,      "profilePath");
1781                 IFSET(SAMR_FIELD_WORKSTATION)
1782                         SET_STRING(msg, info21.workstations.name, "userWorkstations");
1783                 IFSET(SAMR_FIELD_LOGON_HOURS)
1784                         SET_LHOURS(msg, info21.logon_hours,       "logonHours");
1785                 IFSET(SAMR_FIELD_CALLBACK)
1786                         SET_STRING(msg, info21.callback.name,     "userParameters");
1787                 IFSET(SAMR_FIELD_COUNTRY_CODE)
1788                         SET_UINT  (msg, info21.country_code,      "countryCode");
1789                 IFSET(SAMR_FIELD_CODE_PAGE)
1790                         SET_UINT  (msg, info21.code_page,         "codePage");
1791                 break;
1792
1793                 /* the set password levels are handled separately */
1794         case 24:
1795                 status = samr_set_password(dce_call, a_state, mem_ctx, msg,
1796                                            &r->in.info->info24.password);
1797                 break;
1798
1799
1800         default:
1801                 /* many info classes are not valid for SetUserInfo */
1802                 return NT_STATUS_INVALID_INFO_CLASS;
1803         }
1804
1805         if (!NT_STATUS_IS_OK(status)) {
1806                 return status;
1807         }
1808
1809         /* mark all the message elements as LDB_FLAG_MOD_REPLACE,
1810            unless they are already marked with some other flag */
1811         for (i=0;i<mod.num_elements;i++) {
1812                 if (mod.elements[i].flags == 0) {
1813                         mod.elements[i].flags = LDB_FLAG_MOD_REPLACE;
1814                 }
1815         }
1816
1817         /* modify the samdb record */
1818         ret = samdb_modify(a_state->sam_ctx, mem_ctx, msg);
1819         if (ret != 0) {
1820                 /* we really need samdb.c to return NTSTATUS */
1821                 return NT_STATUS_UNSUCCESSFUL;
1822         }
1823
1824         return NT_STATUS_OK;
1825 }
1826
1827
1828 /*
1829   samr_ChangePasswordUser
1830 */
1831 static NTSTATUS samr_ChangePasswordUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1832                        struct samr_ChangePasswordUser *r)
1833 {
1834         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1835 }
1836
1837
1838 /*
1839   samr_GetGroupsForUser
1840 */
1841 static NTSTATUS samr_GetGroupsForUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1842                        struct samr_GetGroupsForUser *r)
1843 {
1844         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1845 }
1846
1847
1848 /*
1849   samr_QueryDisplayInfo
1850 */
1851 static NTSTATUS samr_QueryDisplayInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1852                        struct samr_QueryDisplayInfo *r)
1853 {
1854         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1855 }
1856
1857
1858 /*
1859   samr_GetDisplayEnumerationIndex
1860 */
1861 static NTSTATUS samr_GetDisplayEnumerationIndex(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1862                        struct samr_GetDisplayEnumerationIndex *r)
1863 {
1864         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1865 }
1866
1867
1868 /*
1869   samr_TestPrivateFunctionsDomain
1870 */
1871 static NTSTATUS samr_TestPrivateFunctionsDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1872                        struct samr_TestPrivateFunctionsDomain *r)
1873 {
1874         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1875 }
1876
1877
1878 /*
1879   samr_TestPrivateFunctionsUser
1880 */
1881 static NTSTATUS samr_TestPrivateFunctionsUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1882                        struct samr_TestPrivateFunctionsUser *r)
1883 {
1884         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1885 }
1886
1887
1888 /*
1889   samr_GetUserPwInfo
1890 */
1891 static NTSTATUS samr_GetUserPwInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1892                                    struct samr_GetUserPwInfo *r)
1893 {
1894         struct dcesrv_handle *h;
1895         struct samr_account_state *a_state;
1896
1897         ZERO_STRUCT(r->out.info);
1898
1899         DCESRV_PULL_HANDLE(h, r->in.handle, SAMR_HANDLE_USER);
1900
1901         a_state = h->data;
1902
1903         r->out.info.min_pwd_len = samdb_search_uint(a_state->sam_ctx, mem_ctx, 0, NULL, "minPwdLength",
1904                                                     "dn=%s", a_state->domain_state->domain_dn);
1905         r->out.info.password_properties = samdb_search_uint(a_state->sam_ctx, mem_ctx, 0, NULL, "pwdProperties",
1906                                                             "dn=%s", a_state->account_dn);
1907         return NT_STATUS_OK;
1908 }
1909
1910
1911 /*
1912   samr_RemoveMemberFromForeignDomain
1913 */
1914 static NTSTATUS samr_RemoveMemberFromForeignDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1915                        struct samr_RemoveMemberFromForeignDomain *r)
1916 {
1917         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1918 }
1919
1920
1921 /*
1922   samr_QueryDomainInfo2
1923 */
1924 static NTSTATUS samr_QueryDomainInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1925                        struct samr_QueryDomainInfo2 *r)
1926 {
1927         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1928 }
1929
1930
1931 /*
1932   samr_QueryUserInfo2
1933
1934   just an alias for samr_QueryUserInfo
1935 */
1936 static NTSTATUS samr_QueryUserInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1937                                     struct samr_QueryUserInfo2 *r)
1938 {
1939         struct samr_QueryUserInfo r1;
1940         NTSTATUS status;
1941
1942         r1.in.handle = r->in.handle;
1943         r1.in.level  = r->in.level;
1944
1945         status = samr_QueryUserInfo(dce_call, mem_ctx, &r1);
1946
1947         r->out.info = r1.out.info;
1948
1949         return status;
1950 }
1951
1952
1953 /*
1954   samr_QueryDisplayInfo2
1955 */
1956 static NTSTATUS samr_QueryDisplayInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1957                        struct samr_QueryDisplayInfo2 *r)
1958 {
1959         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1960 }
1961
1962
1963 /*
1964   samr_GetDisplayEnumerationIndex2
1965 */
1966 static NTSTATUS samr_GetDisplayEnumerationIndex2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1967                        struct samr_GetDisplayEnumerationIndex2 *r)
1968 {
1969         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1970 }
1971
1972
1973 /*
1974   samr_QueryDisplayInfo3
1975 */
1976 static NTSTATUS samr_QueryDisplayInfo3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1977                        struct samr_QueryDisplayInfo3 *r)
1978 {
1979         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1980 }
1981
1982
1983 /*
1984   samr_AddMultipleMembersToAlias
1985 */
1986 static NTSTATUS samr_AddMultipleMembersToAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1987                        struct samr_AddMultipleMembersToAlias *r)
1988 {
1989         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1990 }
1991
1992
1993 /*
1994   samr_RemoveMultipleMembersFromAlias
1995 */
1996 static NTSTATUS samr_RemoveMultipleMembersFromAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1997                        struct samr_RemoveMultipleMembersFromAlias *r)
1998 {
1999         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2000 }
2001
2002
2003 /*
2004   samr_OemChangePasswordUser2
2005 */
2006 static NTSTATUS samr_OemChangePasswordUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2007                        struct samr_OemChangePasswordUser2 *r)
2008 {
2009         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2010 }
2011
2012
2013 /*
2014   samr_ChangePasswordUser2
2015 */
2016 static NTSTATUS samr_ChangePasswordUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2017                        struct samr_ChangePasswordUser2 *r)
2018 {
2019         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2020 }
2021
2022
2023 /*
2024   samr_GetDomPwInfo
2025
2026   this fetches the default password properties for a domain
2027 */
2028 static NTSTATUS samr_GetDomPwInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2029                                   struct samr_GetDomPwInfo *r)
2030 {
2031         struct ldb_message **msgs;
2032         int ret;
2033         const char * const attrs[] = {"minPwdLength", "pwdProperties", NULL };
2034         void *sam_ctx;
2035
2036         if (r->in.name == NULL || r->in.name->name == NULL) {
2037                 return NT_STATUS_NO_SUCH_DOMAIN;
2038         }
2039
2040         sam_ctx = samdb_connect();
2041         if (sam_ctx == NULL) {
2042                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
2043         }
2044
2045         ret = samdb_search(sam_ctx,
2046                            mem_ctx, NULL, &msgs, attrs,
2047                            "(&(name=%s)(objectclass=domain))",
2048                            r->in.name->name);
2049         if (ret <= 0) {
2050                 samdb_close(sam_ctx);
2051                 return NT_STATUS_NO_SUCH_DOMAIN;
2052         }
2053         if (ret > 1) {
2054                 samdb_search_free(sam_ctx, mem_ctx, msgs);
2055                 samdb_close(sam_ctx);
2056                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2057         }
2058
2059         r->out.info.min_pwd_len         = samdb_result_uint(msgs[0], "minPwdLength", 0);
2060         r->out.info.password_properties = samdb_result_uint(msgs[0], "pwdProperties", 1);
2061
2062         samdb_search_free(sam_ctx, mem_ctx, msgs);
2063
2064         samdb_close(sam_ctx);
2065         return NT_STATUS_OK;
2066 }
2067
2068
2069 /*
2070   samr_Connect2
2071 */
2072 static NTSTATUS samr_Connect2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2073                               struct samr_Connect2 *r)
2074 {
2075         struct samr_Connect c;
2076
2077         c.in.system_name = NULL;
2078         c.in.access_mask = r->in.access_mask;
2079         c.out.handle = r->out.handle;
2080
2081         return samr_Connect(dce_call, mem_ctx, &c);
2082 }
2083
2084
2085 /*
2086   samr_SetUserInfo2
2087
2088   just an alias for samr_SetUserInfo
2089 */
2090 static NTSTATUS samr_SetUserInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2091                                   struct samr_SetUserInfo2 *r)
2092 {
2093         struct samr_SetUserInfo r2;
2094
2095         r2.in.handle = r->in.handle;
2096         r2.in.level = r->in.level;
2097         r2.in.info = r->in.info;
2098
2099         return samr_SetUserInfo(dce_call, mem_ctx, &r2);
2100 }
2101
2102
2103 /*
2104   samr_SetBootKeyInformation
2105 */
2106 static NTSTATUS samr_SetBootKeyInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2107                        struct samr_SetBootKeyInformation *r)
2108 {
2109         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2110 }
2111
2112
2113 /*
2114   samr_GetBootKeyInformation
2115 */
2116 static NTSTATUS samr_GetBootKeyInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2117                        struct samr_GetBootKeyInformation *r)
2118 {
2119         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2120 }
2121
2122
2123 /*
2124   samr_Connect3
2125 */
2126 static NTSTATUS samr_Connect3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2127                        struct samr_Connect3 *r)
2128 {
2129         struct samr_Connect c;
2130
2131         c.in.system_name = NULL;
2132         c.in.access_mask = r->in.access_mask;
2133         c.out.handle = r->out.handle;
2134
2135         return samr_Connect(dce_call, mem_ctx, &c);
2136 }
2137
2138
2139 /*
2140   samr_Connect4
2141 */
2142 static NTSTATUS samr_Connect4(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2143                        struct samr_Connect4 *r)
2144 {
2145         struct samr_Connect c;
2146
2147         c.in.system_name = NULL;
2148         c.in.access_mask = r->in.access_mask;
2149         c.out.handle = r->out.handle;
2150
2151         return samr_Connect(dce_call, mem_ctx, &c);
2152 }
2153
2154
2155 /*
2156   samr_ChangePasswordUser3
2157 */
2158 static NTSTATUS samr_ChangePasswordUser3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2159                        struct samr_ChangePasswordUser3 *r)
2160 {
2161         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2162 }
2163
2164
2165 /*
2166   samr_Connect5
2167 */
2168 static NTSTATUS samr_Connect5(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2169                               struct samr_Connect5 *r)
2170 {
2171         struct samr_Connect c;
2172         NTSTATUS status;
2173
2174         c.in.system_name = NULL;
2175         c.in.access_mask = r->in.access_mask;
2176         c.out.handle = r->out.handle;
2177
2178         status = samr_Connect(dce_call, mem_ctx, &c);
2179
2180         r->out.info->info1.unknown1 = 3;
2181         r->out.info->info1.unknown2 = 0;
2182         r->out.level = r->in.level;
2183
2184         return status;
2185 }
2186
2187
2188 /*
2189   samr_RidToSid
2190 */
2191 static NTSTATUS samr_RidToSid(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2192                        struct samr_RidToSid *r)
2193 {
2194         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2195 }
2196
2197
2198 /*
2199   samr_SetDsrmPassword
2200 */
2201 static NTSTATUS samr_SetDsrmPassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2202                        struct samr_SetDsrmPassword *r)
2203 {
2204         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2205 }
2206
2207
2208 /*
2209   samr_ValidatePassword
2210 */
2211 static NTSTATUS samr_ValidatePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2212                        struct samr_ValidatePassword *r)
2213 {
2214         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2215 }
2216
2217
2218 /* include the generated boilerplate */
2219 #include "librpc/gen_ndr/ndr_samr_s.c"