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    Copyright (C) Volker Lendecke 2004
   8    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
   9    Copyright (C) Matthias Dieter Wallnöfer 2009
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "librpc/gen_ndr/ndr_samr.h"
  27 #include "rpc_server/dcerpc_server.h"
  28 #include "rpc_server/common/common.h"
  29 #include "rpc_server/samr/dcesrv_samr.h"
  30 #include "system/time.h"
  31 #include "lib/ldb/include/ldb.h"
  32 #include "lib/ldb/include/ldb_errors.h"
  33 #include "../libds/common/flags.h"
  34 #include "dsdb/samdb/samdb.h"
  35 #include "libcli/ldap/ldap_ndr.h"
  36 #include "libcli/security/security.h"
  37 #include "rpc_server/samr/proto.h"
  38 #include "../lib/util/util_ldb.h"
  39 #include "param/param.h"
  40
  41 /* these query macros make samr_Query[User|Group|Alias]Info a bit easier to read */
  42
  43 #define QUERY_STRING(msg, field, attr) \
  44         info->field.string = samdb_result_string(msg, attr, "");
  45 #define QUERY_UINT(msg, field, attr) \
  46         info->field = samdb_result_uint(msg, attr, 0);
  47 #define QUERY_RID(msg, field, attr) \
  48         info->field = samdb_result_rid_from_sid(mem_ctx, msg, attr, 0);
  49 #define QUERY_UINT64(msg, field, attr) \
  50         info->field = samdb_result_uint64(msg, attr, 0);
  51 #define QUERY_APASSC(msg, field, attr) \
  52         info->field = samdb_result_allow_password_change(sam_ctx, mem_ctx, \
  53                                                          a_state->domain_state->domain_dn, msg, attr);
  54 #define QUERY_FPASSC(msg, field, attr) \
  55         info->field = samdb_result_force_password_change(sam_ctx, mem_ctx, \
  56                                                          a_state->domain_state->domain_dn, msg);
  57 #define QUERY_LHOURS(msg, field, attr) \
  58         info->field = samdb_result_logon_hours(mem_ctx, msg, attr);
  59 #define QUERY_AFLAGS(msg, field, attr) \
  60         info->field = samdb_result_acct_flags(sam_ctx, mem_ctx, msg, a_state->domain_state->domain_dn);
  61 #define QUERY_PARAMETERS(msg, field, attr) \
  62         info->field = samdb_result_parameters(mem_ctx, msg, attr);
  63
  64
  65 /* these are used to make the Set[User|Group]Info code easier to follow */
  66
  67 #define SET_STRING(msg, field, attr) do {                               \
  68         struct ldb_message_element *set_el;                             \
  69         if (r->in.info->field.string == NULL) return NT_STATUS_INVALID_PARAMETER; \
  70         if (r->in.info->field.string[0] == '\0') {                      \
  71                 if (ldb_msg_add_empty(msg, attr, LDB_FLAG_MOD_DELETE, NULL)) { \
  72                         return NT_STATUS_NO_MEMORY;                     \
  73                 }                                                       \
  74         }                                                               \
  75         if (ldb_msg_add_string(msg, attr, r->in.info->field.string) != 0) { \
  76                 return NT_STATUS_NO_MEMORY;                             \
  77         }                                                               \
  78         set_el = ldb_msg_find_element(msg, attr);                       \
  79         set_el->flags = LDB_FLAG_MOD_REPLACE;                           \
  80 } while (0)
  81
  82 #define SET_UINT(msg, field, attr) do {                                 \
  83         struct ldb_message_element *set_el;                             \
  84         if (samdb_msg_add_uint(sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
  85                 return NT_STATUS_NO_MEMORY;                             \
  86         }                                                               \
  87         set_el = ldb_msg_find_element(msg, attr);                       \
  88         set_el->flags = LDB_FLAG_MOD_REPLACE;                           \
  89 } while (0)
  90
  91 #define SET_INT64(msg, field, attr) do {                                \
  92         struct ldb_message_element *set_el;                             \
  93         if (samdb_msg_add_int64(sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
  94                 return NT_STATUS_NO_MEMORY;                             \
  95         }                                                               \
  96         set_el = ldb_msg_find_element(msg, attr);                       \
  97         set_el->flags = LDB_FLAG_MOD_REPLACE;                           \
  98 } while (0)
  99
 100 #define SET_UINT64(msg, field, attr) do {                               \
 101         struct ldb_message_element *set_el;                             \
 102         if (samdb_msg_add_uint64(sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
 103                 return NT_STATUS_NO_MEMORY;                             \
 104         }                                                               \
 105         set_el = ldb_msg_find_element(msg, attr);                       \
 106         set_el->flags = LDB_FLAG_MOD_REPLACE;                           \
 107 } while (0)
 108
 109 #define CHECK_FOR_MULTIPLES(value, flag, poss_flags)    \
 110         do { \
 111                 if ((value & flag) && ((value & flag) != (value & (poss_flags)))) { \
 112                         return NT_STATUS_INVALID_PARAMETER;             \
 113                 }                                                       \
 114         } while (0)                                                     \
 115
 116 /* Set account flags, discarding flags that cannot be set with SAMR */
 117 #define SET_AFLAGS(msg, field, attr) do {                               \
 118         struct ldb_message_element *set_el;                             \
 119         if ((r->in.info->field & (ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST)) == 0) { \
 120                 return NT_STATUS_INVALID_PARAMETER; \
 121         }                                                               \
 122         CHECK_FOR_MULTIPLES(r->in.info->field, ACB_NORMAL, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
 123         CHECK_FOR_MULTIPLES(r->in.info->field, ACB_DOMTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
 124         CHECK_FOR_MULTIPLES(r->in.info->field, ACB_WSTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
 125         CHECK_FOR_MULTIPLES(r->in.info->field, ACB_SVRTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
 126         if (samdb_msg_add_acct_flags(sam_ctx, mem_ctx, msg, attr, (r->in.info->field & ~(ACB_AUTOLOCK|ACB_PW_EXPIRED))) != 0) { \
 127                 return NT_STATUS_NO_MEMORY;                             \
 128         }                                                               \
 129         set_el = ldb_msg_find_element(msg, attr);                       \
 130         set_el->flags = LDB_FLAG_MOD_REPLACE;                           \
 131 } while (0)
 132
 133 #define SET_LHOURS(msg, field, attr) do {                               \
 134         struct ldb_message_element *set_el;                             \
 135         if (samdb_msg_add_logon_hours(sam_ctx, mem_ctx, msg, attr, &r->in.info->field) != 0) { \
 136                 return NT_STATUS_NO_MEMORY;                             \
 137         }                                                               \
 138         set_el = ldb_msg_find_element(msg, attr);                       \
 139         set_el->flags = LDB_FLAG_MOD_REPLACE;                           \
 140 } while (0)
 141
 142 #define SET_PARAMETERS(msg, field, attr) do {                           \
 143         struct ldb_message_element *set_el;                             \
 144         if (r->in.info->field.length != 0) {                            \
 145                 if (samdb_msg_add_parameters(sam_ctx, mem_ctx, msg, attr, &r->in.info->field) != 0) { \
 146                         return NT_STATUS_NO_MEMORY;                     \
 147                 }                                                       \
 148                 set_el = ldb_msg_find_element(msg, attr);               \
 149                 set_el->flags = LDB_FLAG_MOD_REPLACE;                   \
 150         }                                                               \
 151 } while (0)
 152
 153
 154
 155 /*
 156   samr_Connect
 157
 158   create a connection to the SAM database
 159 */
 160 static NTSTATUS dcesrv_samr_Connect(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 161                              struct samr_Connect *r)
 162 {
 163         struct samr_connect_state *c_state;
 164         struct dcesrv_handle *handle;
 165
 166         ZERO_STRUCTP(r->out.connect_handle);
 167
 168         c_state = talloc(dce_call->conn, struct samr_connect_state);
 169         if (!c_state) {
 170                 return NT_STATUS_NO_MEMORY;
 171         }
 172
 173         /* make sure the sam database is accessible */
 174         c_state->sam_ctx = samdb_connect(c_state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
 175         if (c_state->sam_ctx == NULL) {
 176                 talloc_free(c_state);
 177                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
 178         }
 179
 180
 181         handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_CONNECT);
 182         if (!handle) {
 183                 talloc_free(c_state);
 184                 return NT_STATUS_NO_MEMORY;
 185         }
 186
 187         handle->data = talloc_steal(handle, c_state);
 188
 189         c_state->access_mask = r->in.access_mask;
 190         *r->out.connect_handle = handle->wire_handle;
 191
 192         return NT_STATUS_OK;
 193 }
 194
 195
 196 /*
 197   samr_Close
 198 */
 199 static NTSTATUS dcesrv_samr_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 200                            struct samr_Close *r)
 201 {
 202         struct dcesrv_handle *h;
 203
 204         *r->out.handle = *r->in.handle;
 205
 206         DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
 207
 208         talloc_free(h);
 209
 210         ZERO_STRUCTP(r->out.handle);
 211
 212         return NT_STATUS_OK;
 213 }
 214
 215
 216 /*
 217   samr_SetSecurity
 218 */
 219 static NTSTATUS dcesrv_samr_SetSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 220                                  struct samr_SetSecurity *r)
 221 {
 222         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 223 }
 224
 225
 226 /*
 227   samr_QuerySecurity
 228 */
 229 static NTSTATUS dcesrv_samr_QuerySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 230                                    struct samr_QuerySecurity *r)
 231 {
 232         struct dcesrv_handle *h;
 233         struct sec_desc_buf *sd;
 234
 235         *r->out.sdbuf = NULL;
 236
 237         DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
 238
 239         sd = talloc(mem_ctx, struct sec_desc_buf);
 240         if (sd == NULL) {
 241                 return NT_STATUS_NO_MEMORY;
 242         }
 243
 244         sd->sd = samdb_default_security_descriptor(mem_ctx);
 245
 246         *r->out.sdbuf = sd;
 247
 248         return NT_STATUS_OK;
 249 }
 250
 251
 252 /*
 253   samr_Shutdown
 254
 255   we refuse this operation completely. If a admin wants to shutdown samr
 256   in Samba then they should use the samba admin tools to disable the samr pipe
 257 */
 258 static NTSTATUS dcesrv_samr_Shutdown(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 259                               struct samr_Shutdown *r)
 260 {
 261         return NT_STATUS_ACCESS_DENIED;
 262 }
 263
 264
 265 /*
 266   samr_LookupDomain
 267
 268   this maps from a domain name to a SID
 269 */
 270 static NTSTATUS dcesrv_samr_LookupDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 271                                   struct samr_LookupDomain *r)
 272 {
 273         struct samr_connect_state *c_state;
 274         struct dcesrv_handle *h;
 275         struct dom_sid *sid;
 276         const char * const dom_attrs[] = { "objectSid", NULL};
 277         struct ldb_message **dom_msgs;
 278         int ret;
 279
 280         *r->out.sid = NULL;
 281
 282         DCESRV_PULL_HANDLE(h, r->in.connect_handle, SAMR_HANDLE_CONNECT);
 283
 284         c_state = h->data;
 285
 286         if (r->in.domain_name->string == NULL) {
 287                 return NT_STATUS_INVALID_PARAMETER;
 288         }
 289
 290         if (strcasecmp(r->in.domain_name->string, "BUILTIN") == 0) {
 291                 ret = gendb_search(c_state->sam_ctx,
 292                                    mem_ctx, NULL, &dom_msgs, dom_attrs,
 293                                    "(objectClass=builtinDomain)");
 294         } else if (strcasecmp_m(r->in.domain_name->string, lp_sam_name(dce_call->conn->dce_ctx->lp_ctx)) == 0) {
 295                 ret = gendb_search_dn(c_state->sam_ctx,
 296                                       mem_ctx, ldb_get_default_basedn(c_state->sam_ctx),
 297                                       &dom_msgs, dom_attrs);
 298         } else {
 299                 return NT_STATUS_NO_SUCH_DOMAIN;
 300         }
 301         if (ret != 1) {
 302                 return NT_STATUS_NO_SUCH_DOMAIN;
 303         }
 304
 305         sid = samdb_result_dom_sid(mem_ctx, dom_msgs[0],
 306                                    "objectSid");
 307
 308         if (sid == NULL) {
 309                 return NT_STATUS_NO_SUCH_DOMAIN;
 310         }
 311
 312         *r->out.sid = sid;
 313
 314         return NT_STATUS_OK;
 315 }
 316
 317
 318 /*
 319   samr_EnumDomains
 320
 321   list the domains in the SAM
 322 */
 323 static NTSTATUS dcesrv_samr_EnumDomains(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 324                                  struct samr_EnumDomains *r)
 325 {
 326         struct samr_connect_state *c_state;
 327         struct dcesrv_handle *h;
 328         struct samr_SamArray *array;
 329         int i, start_i;
 330
 331         *r->out.resume_handle = 0;
 332         *r->out.sam = NULL;
 333         *r->out.num_entries = 0;
 334
 335         DCESRV_PULL_HANDLE(h, r->in.connect_handle, SAMR_HANDLE_CONNECT);
 336
 337         c_state = h->data;
 338
 339         *r->out.resume_handle = 2;
 340
 341         start_i = *r->in.resume_handle;
 342
 343         if (start_i >= 2) {
 344                 /* search past end of list is not an error for this call */
 345                 return NT_STATUS_OK;
 346         }
 347
 348         array = talloc(mem_ctx, struct samr_SamArray);
 349         if (array == NULL) {
 350                 return NT_STATUS_NO_MEMORY;
 351         }
 352
 353         array->count = 0;
 354         array->entries = NULL;
 355
 356         array->entries = talloc_array(mem_ctx, struct samr_SamEntry, 2 - start_i);
 357         if (array->entries == NULL) {
 358                 return NT_STATUS_NO_MEMORY;
 359         }
 360
 361         for (i=0;i<2-start_i;i++) {
 362                 array->entries[i].idx = start_i + i;
 363                 if (i == 0) {
 364                         array->entries[i].name.string = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
 365                 } else {
 366                         array->entries[i].name.string = "BUILTIN";
 367                 }
 368         }
 369
 370         *r->out.sam = array;
 371         *r->out.num_entries = i;
 372         array->count = *r->out.num_entries;
 373
 374         return NT_STATUS_OK;
 375 }
 376
 377
 378 /*
 379   samr_OpenDomain
 380 */
 381 static NTSTATUS dcesrv_samr_OpenDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 382                                 struct samr_OpenDomain *r)
 383 {
 384         struct dcesrv_handle *h_conn, *h_domain;
 385         struct samr_connect_state *c_state;
 386         struct samr_domain_state *d_state;
 387         const char * const dom_attrs[] = { "cn", NULL};
 388         struct ldb_message **dom_msgs;
 389         int ret;
 390
 391         ZERO_STRUCTP(r->out.domain_handle);
 392
 393         DCESRV_PULL_HANDLE(h_conn, r->in.connect_handle, SAMR_HANDLE_CONNECT);
 394
 395         c_state = h_conn->data;
 396
 397         if (r->in.sid == NULL) {
 398                 return NT_STATUS_INVALID_PARAMETER;
 399         }
 400
 401         d_state = talloc(c_state, struct samr_domain_state);
 402         if (!d_state) {
 403                 return NT_STATUS_NO_MEMORY;
 404         }
 405
 406         d_state->domain_sid = talloc_steal(d_state, r->in.sid);
 407
 408         if (dom_sid_equal(d_state->domain_sid, dom_sid_parse_talloc(mem_ctx, SID_BUILTIN))) {
 409                 d_state->builtin = true;
 410                 d_state->domain_name = "BUILTIN";
 411         } else {
 412                 d_state->builtin = false;
 413                 d_state->domain_name = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
 414         }
 415
 416         ret = gendb_search(c_state->sam_ctx,
 417                            mem_ctx, ldb_get_default_basedn(c_state->sam_ctx), &dom_msgs, dom_attrs,
 418                            "(objectSid=%s)",
 419                            ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
 420
 421         if (ret == 0) {
 422                 talloc_free(d_state);
 423                 return NT_STATUS_NO_SUCH_DOMAIN;
 424         } else if (ret > 1) {
 425                 talloc_free(d_state);
 426                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 427         } else if (ret == -1) {
 428                 talloc_free(d_state);
 429                 DEBUG(1, ("Failed to open domain %s: %s\n", dom_sid_string(mem_ctx, r->in.sid), ldb_errstring(c_state->sam_ctx)));
 430                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 431         }
 432
 433         d_state->domain_dn = talloc_steal(d_state, dom_msgs[0]->dn);
 434         d_state->role = lp_server_role(dce_call->conn->dce_ctx->lp_ctx);
 435         d_state->connect_state = talloc_reference(d_state, c_state);
 436         d_state->sam_ctx = c_state->sam_ctx;
 437         d_state->access_mask = r->in.access_mask;
 438
 439         d_state->lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
 440
 441         h_domain = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_DOMAIN);
 442         if (!h_domain) {
 443                 talloc_free(d_state);
 444                 return NT_STATUS_NO_MEMORY;
 445         }
 446
 447         h_domain->data = talloc_steal(h_domain, d_state);
 448
 449         *r->out.domain_handle = h_domain->wire_handle;
 450
 451         return NT_STATUS_OK;
 452 }
 453
 454 /*
 455   return DomInfo1
 456 */
 457 static NTSTATUS dcesrv_samr_info_DomInfo1(struct samr_domain_state *state,
 458                                    TALLOC_CTX *mem_ctx,
 459                                     struct ldb_message **dom_msgs,
 460                                    struct samr_DomInfo1 *info)
 461 {
 462         info->min_password_length =
 463                 samdb_result_uint(dom_msgs[0], "minPwdLength", 0);
 464         info->password_history_length =
 465                 samdb_result_uint(dom_msgs[0], "pwdHistoryLength", 0);
 466         info->password_properties =
 467                 samdb_result_uint(dom_msgs[0], "pwdProperties", 0);
 468         info->max_password_age =
 469                 samdb_result_int64(dom_msgs[0], "maxPwdAge", 0);
 470         info->min_password_age =
 471                 samdb_result_int64(dom_msgs[0], "minPwdAge", 0);
 472
 473         return NT_STATUS_OK;
 474 }
 475
 476 /*
 477   return DomInfo2
 478 */
 479 static NTSTATUS dcesrv_samr_info_DomGeneralInformation(struct samr_domain_state *state,
 480                                                        TALLOC_CTX *mem_ctx,
 481                                                        struct ldb_message **dom_msgs,
 482                                                        struct samr_DomGeneralInformation *info)
 483 {
 484         /* This pulls the NetBIOS name from the
 485            cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
 486            string */
 487         info->primary.string = samdb_result_fsmo_name(state->sam_ctx, mem_ctx, dom_msgs[0], "fSMORoleOwner");
 488
 489         if (!info->primary.string) {
 490                 info->primary.string = lp_netbios_name(state->lp_ctx);
 491         }
 492
 493         info->force_logoff_time = ldb_msg_find_attr_as_uint64(dom_msgs[0], "forceLogoff",
 494                                                             0x8000000000000000LL);
 495
 496         info->oem_information.string = samdb_result_string(dom_msgs[0], "oEMInformation", NULL);
 497         info->domain_name.string  = state->domain_name;
 498
 499         info->sequence_num = ldb_msg_find_attr_as_uint64(dom_msgs[0], "modifiedCount",
 500                                                  0);
 501         switch (state->role) {
 502         case ROLE_DOMAIN_CONTROLLER:
 503                 /* This pulls the NetBIOS name from the
 504                    cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
 505                    string */
 506                 if (samdb_is_pdc(state->sam_ctx)) {
 507                         info->role = SAMR_ROLE_DOMAIN_PDC;
 508                 } else {
 509                         info->role = SAMR_ROLE_DOMAIN_BDC;
 510                 }
 511                 break;
 512         case ROLE_DOMAIN_MEMBER:
 513                 info->role = SAMR_ROLE_DOMAIN_MEMBER;
 514                 break;
 515         case ROLE_STANDALONE:
 516                 info->role = SAMR_ROLE_STANDALONE;
 517                 break;
 518         }
 519
 520         /* No users in BUILTIN, and the LOCAL group types are only in builtin, and the global group type is never in BUILTIN */
 521         info->num_users = samdb_search_count(state->sam_ctx, mem_ctx, state->domain_dn,
 522                                              "(objectClass=user)");
 523         info->num_groups = samdb_search_count(state->sam_ctx, mem_ctx, state->domain_dn,
 524                                               "(&(objectClass=group)(sAMAccountType=%u))",
 525                                               ATYPE_GLOBAL_GROUP);
 526         info->num_aliases = samdb_search_count(state->sam_ctx, mem_ctx, state->domain_dn,
 527                                                "(&(objectClass=group)(sAMAccountType=%u))",
 528                                                ATYPE_LOCAL_GROUP);
 529
 530         return NT_STATUS_OK;
 531 }
 532
 533 /*
 534   return DomInfo3
 535 */
 536 static NTSTATUS dcesrv_samr_info_DomInfo3(struct samr_domain_state *state,
 537                                    TALLOC_CTX *mem_ctx,
 538                                     struct ldb_message **dom_msgs,
 539                                    struct samr_DomInfo3 *info)
 540 {
 541         info->force_logoff_time = ldb_msg_find_attr_as_uint64(dom_msgs[0], "forceLogoff",
 542                                                       0x8000000000000000LL);
 543
 544         return NT_STATUS_OK;
 545 }
 546
 547 /*
 548   return DomInfo4
 549 */
 550 static NTSTATUS dcesrv_samr_info_DomOEMInformation(struct samr_domain_state *state,
 551                                    TALLOC_CTX *mem_ctx,
 552                                     struct ldb_message **dom_msgs,
 553                                    struct samr_DomOEMInformation *info)
 554 {
 555         info->oem_information.string = samdb_result_string(dom_msgs[0], "oEMInformation", NULL);
 556
 557         return NT_STATUS_OK;
 558 }
 559
 560 /*
 561   return DomInfo5
 562 */
 563 static NTSTATUS dcesrv_samr_info_DomInfo5(struct samr_domain_state *state,
 564                                    TALLOC_CTX *mem_ctx,
 565                                     struct ldb_message **dom_msgs,
 566                                    struct samr_DomInfo5 *info)
 567 {
 568         info->domain_name.string  = state->domain_name;
 569
 570         return NT_STATUS_OK;
 571 }
 572
 573 /*
 574   return DomInfo6
 575 */
 576 static NTSTATUS dcesrv_samr_info_DomInfo6(struct samr_domain_state *state,
 577                                    TALLOC_CTX *mem_ctx,
 578                                    struct ldb_message **dom_msgs,
 579                                    struct samr_DomInfo6 *info)
 580 {
 581         /* This pulls the NetBIOS name from the
 582            cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
 583            string */
 584         info->primary.string = samdb_result_fsmo_name(state->sam_ctx, mem_ctx,
 585                                                       dom_msgs[0], "fSMORoleOwner");
 586
 587         if (!info->primary.string) {
 588                 info->primary.string = lp_netbios_name(state->lp_ctx);
 589         }
 590
 591         return NT_STATUS_OK;
 592 }
 593
 594 /*
 595   return DomInfo7
 596 */
 597 static NTSTATUS dcesrv_samr_info_DomInfo7(struct samr_domain_state *state,
 598                                    TALLOC_CTX *mem_ctx,
 599                                     struct ldb_message **dom_msgs,
 600                                    struct samr_DomInfo7 *info)
 601 {
 602
 603         switch (state->role) {
 604         case ROLE_DOMAIN_CONTROLLER:
 605                 /* This pulls the NetBIOS name from the
 606                    cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
 607                    string */
 608                 if (samdb_is_pdc(state->sam_ctx)) {
 609                         info->role = SAMR_ROLE_DOMAIN_PDC;
 610                 } else {
 611                         info->role = SAMR_ROLE_DOMAIN_BDC;
 612                 }
 613                 break;
 614         case ROLE_DOMAIN_MEMBER:
 615                 info->role = SAMR_ROLE_DOMAIN_MEMBER;
 616                 break;
 617         case ROLE_STANDALONE:
 618                 info->role = SAMR_ROLE_STANDALONE;
 619                 break;
 620         }
 621
 622         return NT_STATUS_OK;
 623 }
 624
 625 /*
 626   return DomInfo8
 627 */
 628 static NTSTATUS dcesrv_samr_info_DomInfo8(struct samr_domain_state *state,
 629                                    TALLOC_CTX *mem_ctx,
 630                                     struct ldb_message **dom_msgs,
 631                                    struct samr_DomInfo8 *info)
 632 {
 633         info->sequence_num = ldb_msg_find_attr_as_uint64(dom_msgs[0], "modifiedCount",
 634                                                time(NULL));
 635
 636         info->domain_create_time = ldb_msg_find_attr_as_uint(dom_msgs[0], "creationTime",
 637                                                      0x0LL);
 638
 639         return NT_STATUS_OK;
 640 }
 641
 642 /*
 643   return DomInfo9
 644 */
 645 static NTSTATUS dcesrv_samr_info_DomInfo9(struct samr_domain_state *state,
 646                                    TALLOC_CTX *mem_ctx,
 647                                     struct ldb_message **dom_msgs,
 648                                    struct samr_DomInfo9 *info)
 649 {
 650         info->domain_server_state = DOMAIN_SERVER_ENABLED;
 651
 652         return NT_STATUS_OK;
 653 }
 654
 655 /*
 656   return DomInfo11
 657 */
 658 static NTSTATUS dcesrv_samr_info_DomGeneralInformation2(struct samr_domain_state *state,
 659                                     TALLOC_CTX *mem_ctx,
 660                                     struct ldb_message **dom_msgs,
 661                                     struct samr_DomGeneralInformation2 *info)
 662 {
 663         NTSTATUS status;
 664         status = dcesrv_samr_info_DomGeneralInformation(state, mem_ctx, dom_msgs, &info->general);
 665         if (!NT_STATUS_IS_OK(status)) {
 666                 return status;
 667         }
 668
 669         info->lockout_duration = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutDuration",
 670                                                     -18000000000LL);
 671         info->lockout_window = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockOutObservationWindow",
 672                                                     -18000000000LL);
 673         info->lockout_threshold = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutThreshold", 0);
 674
 675         return NT_STATUS_OK;
 676 }
 677
 678 /*
 679   return DomInfo12
 680 */
 681 static NTSTATUS dcesrv_samr_info_DomInfo12(struct samr_domain_state *state,
 682                                    TALLOC_CTX *mem_ctx,
 683                                     struct ldb_message **dom_msgs,
 684                                    struct samr_DomInfo12 *info)
 685 {
 686         info->lockout_duration = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutDuration",
 687                                                     -18000000000LL);
 688         info->lockout_window = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockOutObservationWindow",
 689                                                     -18000000000LL);
 690         info->lockout_threshold = ldb_msg_find_attr_as_int64(dom_msgs[0], "lockoutThreshold", 0);
 691
 692         return NT_STATUS_OK;
 693 }
 694
 695 /*
 696   return DomInfo13
 697 */
 698 static NTSTATUS dcesrv_samr_info_DomInfo13(struct samr_domain_state *state,
 699                                     TALLOC_CTX *mem_ctx,
 700                                     struct ldb_message **dom_msgs,
 701                                     struct samr_DomInfo13 *info)
 702 {
 703         info->sequence_num = ldb_msg_find_attr_as_uint64(dom_msgs[0], "modifiedCount",
 704                                                time(NULL));
 705
 706         info->domain_create_time = ldb_msg_find_attr_as_uint(dom_msgs[0], "creationTime",
 707                                                      0x0LL);
 708
 709         info->modified_count_at_last_promotion = 0;
 710
 711         return NT_STATUS_OK;
 712 }
 713
 714 /*
 715   samr_QueryDomainInfo
 716 */
 717 static NTSTATUS dcesrv_samr_QueryDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 718                                      struct samr_QueryDomainInfo *r)
 719 {
 720         struct dcesrv_handle *h;
 721         struct samr_domain_state *d_state;
 722         union samr_DomainInfo *info;
 723
 724         struct ldb_message **dom_msgs;
 725         const char * const *attrs = NULL;
 726
 727         *r->out.info = NULL;
 728
 729         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
 730
 731         d_state = h->data;
 732
 733         info = talloc(mem_ctx, union samr_DomainInfo);
 734         if (!info) {
 735                 return NT_STATUS_NO_MEMORY;
 736         }
 737
 738         switch (r->in.level) {
 739         case 1:
 740         {
 741                 static const char * const attrs2[] = { "minPwdLength",
 742                                                        "pwdHistoryLength",
 743                                                        "pwdProperties",
 744                                                        "maxPwdAge",
 745                                                        "minPwdAge",
 746                                                        NULL };
 747                 attrs = attrs2;
 748                 break;
 749         }
 750         case 2:
 751         {
 752                 static const char * const attrs2[] = {"forceLogoff",
 753                                                       "oEMInformation",
 754                                                       "modifiedCount",
 755                                                       "fSMORoleOwner",
 756                                                       NULL};
 757                 attrs = attrs2;
 758                 break;
 759         }
 760         case 3:
 761         {
 762                 static const char * const attrs2[] = {"forceLogoff",
 763                                                       NULL};
 764                 attrs = attrs2;
 765                 break;
 766         }
 767         case 4:
 768         {
 769                 static const char * const attrs2[] = {"oEMInformation",
 770                                                       NULL};
 771                 attrs = attrs2;
 772                 break;
 773         }
 774         case 5:
 775         {
 776                 attrs = NULL;
 777                 break;
 778         }
 779         case 6:
 780         {
 781                 static const char * const attrs2[] = {"fSMORoleOwner",
 782                                                       NULL};
 783                 attrs = attrs2;
 784                 break;
 785         }
 786         case 7:
 787         {
 788                 attrs = NULL;
 789                 break;
 790         }
 791         case 8:
 792         {
 793                 static const char * const attrs2[] = { "modifiedCount",
 794                                                        "creationTime",
 795                                                        NULL };
 796                 attrs = attrs2;
 797                 break;
 798         }
 799         case 9:
 800                 attrs = NULL;
 801                 break;
 802         case 11:
 803         {
 804                 static const char * const attrs2[] = { "oEMInformation",
 805                                                        "forceLogoff",
 806                                                        "modifiedCount",
 807                                                        "lockoutDuration",
 808                                                        "lockOutObservationWindow",
 809                                                        "lockoutThreshold",
 810                                                        NULL};
 811                 attrs = attrs2;
 812                 break;
 813         }
 814         case 12:
 815         {
 816                 static const char * const attrs2[] = { "lockoutDuration",
 817                                                        "lockOutObservationWindow",
 818                                                        "lockoutThreshold",
 819                                                        NULL};
 820                 attrs = attrs2;
 821                 break;
 822         }
 823         case 13:
 824         {
 825                 static const char * const attrs2[] = { "modifiedCount",
 826                                                        "creationTime",
 827                                                        NULL };
 828                 attrs = attrs2;
 829                 break;
 830         }
 831         }
 832
 833         /* some levels don't need a search */
 834         if (attrs) {
 835                 int ret;
 836                 ret = gendb_search_dn(d_state->sam_ctx, mem_ctx,
 837                                       d_state->domain_dn, &dom_msgs, attrs);
 838                 if (ret != 1) {
 839                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 840                 }
 841         }
 842
 843         *r->out.info = info;
 844
 845         ZERO_STRUCTP(info);
 846
 847         switch (r->in.level) {
 848         case 1:
 849                 return dcesrv_samr_info_DomInfo1(d_state, mem_ctx, dom_msgs,
 850                                                  &info->info1);
 851         case 2:
 852                 return dcesrv_samr_info_DomGeneralInformation(d_state, mem_ctx, dom_msgs,
 853                                                               &info->general);
 854         case 3:
 855                 return dcesrv_samr_info_DomInfo3(d_state, mem_ctx, dom_msgs,
 856                                                  &info->info3);
 857         case 4:
 858                 return dcesrv_samr_info_DomOEMInformation(d_state, mem_ctx, dom_msgs,
 859                                                           &info->oem);
 860         case 5:
 861                 return dcesrv_samr_info_DomInfo5(d_state, mem_ctx, dom_msgs,
 862                                                  &info->info5);
 863         case 6:
 864                 return dcesrv_samr_info_DomInfo6(d_state, mem_ctx, dom_msgs,
 865                                                  &info->info6);
 866         case 7:
 867                 return dcesrv_samr_info_DomInfo7(d_state, mem_ctx, dom_msgs,
 868                                                  &info->info7);
 869         case 8:
 870                 return dcesrv_samr_info_DomInfo8(d_state, mem_ctx, dom_msgs,
 871                                                  &info->info8);
 872         case 9:
 873                 return dcesrv_samr_info_DomInfo9(d_state, mem_ctx, dom_msgs,
 874                                                  &info->info9);
 875         case 11:
 876                 return dcesrv_samr_info_DomGeneralInformation2(d_state, mem_ctx, dom_msgs,
 877                                                                &info->general2);
 878         case 12:
 879                 return dcesrv_samr_info_DomInfo12(d_state, mem_ctx, dom_msgs,
 880                                                   &info->info12);
 881         case 13:
 882                 return dcesrv_samr_info_DomInfo13(d_state, mem_ctx, dom_msgs,
 883                                                   &info->info13);
 884         }
 885
 886         return NT_STATUS_INVALID_INFO_CLASS;
 887 }
 888
 889
 890 /*
 891   samr_SetDomainInfo
 892 */
 893 static NTSTATUS dcesrv_samr_SetDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 894                        struct samr_SetDomainInfo *r)
 895 {
 896         struct dcesrv_handle *h;
 897         struct samr_domain_state *d_state;
 898         struct ldb_message *msg;
 899         int ret;
 900         struct ldb_context *sam_ctx;
 901
 902         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
 903
 904         d_state = h->data;
 905         sam_ctx = d_state->sam_ctx;
 906
 907         msg = ldb_msg_new(mem_ctx);
 908         if (msg == NULL) {
 909                 return NT_STATUS_NO_MEMORY;
 910         }
 911
 912         msg->dn = talloc_reference(mem_ctx, d_state->domain_dn);
 913         if (!msg->dn) {
 914                 return NT_STATUS_NO_MEMORY;
 915         }
 916
 917         switch (r->in.level) {
 918         case 1:
 919                 SET_UINT  (msg, info1.min_password_length,     "minPwdLength");
 920                 SET_UINT  (msg, info1.password_history_length, "pwdHistoryLength");
 921                 SET_UINT  (msg, info1.password_properties,     "pwdProperties");
 922                 SET_INT64  (msg, info1.max_password_age,       "maxPwdAge");
 923                 SET_INT64  (msg, info1.min_password_age,       "minPwdAge");
 924                 break;
 925         case 3:
 926                 SET_UINT64  (msg, info3.force_logoff_time,     "forceLogoff");
 927                 break;
 928         case 4:
 929                 SET_STRING(msg, oem.oem_information,           "oEMInformation");
 930                 break;
 931
 932         case 6:
 933         case 7:
 934         case 9:
 935                 /* No op, we don't know where to set these */
 936                 return NT_STATUS_OK;
 937
 938         case 12:
 939
 940                 SET_INT64  (msg, info12.lockout_duration,      "lockoutDuration");
 941                 SET_INT64  (msg, info12.lockout_window,        "lockOutObservationWindow");
 942                 SET_INT64  (msg, info12.lockout_threshold,     "lockoutThreshold");
 943                 break;
 944
 945         default:
 946                 /* many info classes are not valid for SetDomainInfo */
 947                 return NT_STATUS_INVALID_INFO_CLASS;
 948         }
 949
 950         /* modify the samdb record */
 951         ret = ldb_modify(sam_ctx, msg);
 952         if (ret != LDB_SUCCESS) {
 953                 DEBUG(1,("Failed to modify record %s: %s\n",
 954                          ldb_dn_get_linearized(d_state->domain_dn),
 955                          ldb_errstring(sam_ctx)));
 956
 957                 /* we really need samdb.c to return NTSTATUS */
 958                 return NT_STATUS_UNSUCCESSFUL;
 959         }
 960
 961         return NT_STATUS_OK;
 962 }
 963
 964 /*
 965   samr_CreateDomainGroup
 966 */
 967 static NTSTATUS dcesrv_samr_CreateDomainGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 968                                        struct samr_CreateDomainGroup *r)
 969 {
 970         struct samr_domain_state *d_state;
 971         struct samr_account_state *a_state;
 972         struct dcesrv_handle *h;
 973         const char *name;
 974         struct ldb_message *msg;
 975         struct dom_sid *sid;
 976         const char *groupname;
 977         struct dcesrv_handle *g_handle;
 978         int ret;
 979
 980         ZERO_STRUCTP(r->out.group_handle);
 981         *r->out.rid = 0;
 982
 983         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
 984
 985         d_state = h->data;
 986
 987         if (d_state->builtin) {
 988                 DEBUG(5, ("Cannot create a domain group in the BUILTIN domain"));
 989                 return NT_STATUS_ACCESS_DENIED;
 990         }
 991
 992         groupname = r->in.name->string;
 993
 994         if (groupname == NULL) {
 995                 return NT_STATUS_INVALID_PARAMETER;
 996         }
 997
 998         /* check if the group already exists */
 999         name = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
1000                                    "sAMAccountName",
1001                                    "(&(sAMAccountName=%s)(objectclass=group))",
1002                                    ldb_binary_encode_string(mem_ctx, groupname));
1003         if (name != NULL) {
1004                 return NT_STATUS_GROUP_EXISTS;
1005         }
1006
1007         msg = ldb_msg_new(mem_ctx);
1008         if (msg == NULL) {
1009                 return NT_STATUS_NO_MEMORY;
1010         }
1011
1012         /* add core elements to the ldb_message for the user */
1013         msg->dn = ldb_dn_copy(mem_ctx, d_state->domain_dn);
1014         ldb_dn_add_child_fmt(msg->dn, "CN=%s,CN=Users", groupname);
1015         if (!msg->dn) {
1016                 return NT_STATUS_NO_MEMORY;
1017         }
1018         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "sAMAccountName", groupname);
1019         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "objectClass", "group");
1020
1021         /* create the group */
1022         ret = ldb_add(d_state->sam_ctx, msg);
1023         switch (ret) {
1024         case  LDB_SUCCESS:
1025                 break;
1026         case  LDB_ERR_ENTRY_ALREADY_EXISTS:
1027                 DEBUG(0,("Failed to create group record %s: %s\n",
1028                          ldb_dn_get_linearized(msg->dn),
1029                          ldb_errstring(d_state->sam_ctx)));
1030                 return NT_STATUS_GROUP_EXISTS;
1031         case  LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
1032                 DEBUG(0,("Failed to create group record %s: %s\n",
1033                          ldb_dn_get_linearized(msg->dn),
1034                          ldb_errstring(d_state->sam_ctx)));
1035                 return NT_STATUS_ACCESS_DENIED;
1036         default:
1037                 DEBUG(0,("Failed to create group record %s: %s\n",
1038                          ldb_dn_get_linearized(msg->dn),
1039                          ldb_errstring(d_state->sam_ctx)));
1040                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1041         }
1042
1043         a_state = talloc(d_state, struct samr_account_state);
1044         if (!a_state) {
1045                 return NT_STATUS_NO_MEMORY;
1046         }
1047         a_state->sam_ctx = d_state->sam_ctx;
1048         a_state->access_mask = r->in.access_mask;
1049         a_state->domain_state = talloc_reference(a_state, d_state);
1050         a_state->account_dn = talloc_steal(a_state, msg->dn);
1051
1052         /* retrieve the sid for the group just created */
1053         sid = samdb_search_dom_sid(d_state->sam_ctx, a_state,
1054                                    msg->dn, "objectSid", NULL);
1055         if (sid == NULL) {
1056                 return NT_STATUS_UNSUCCESSFUL;
1057         }
1058
1059         a_state->account_name = talloc_strdup(a_state, groupname);
1060         if (!a_state->account_name) {
1061                 return NT_STATUS_NO_MEMORY;
1062         }
1063
1064         /* create the policy handle */
1065         g_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_GROUP);
1066         if (!g_handle) {
1067                 return NT_STATUS_NO_MEMORY;
1068         }
1069
1070         g_handle->data = talloc_steal(g_handle, a_state);
1071
1072         *r->out.group_handle = g_handle->wire_handle;
1073         *r->out.rid = sid->sub_auths[sid->num_auths-1];
1074
1075         return NT_STATUS_OK;
1076 }
1077
1078
1079 /*
1080   comparison function for sorting SamEntry array
1081 */
1082 static int compare_SamEntry(struct samr_SamEntry *e1, struct samr_SamEntry *e2)
1083 {
1084         return e1->idx - e2->idx;
1085 }
1086
1087 /*
1088   samr_EnumDomainGroups
1089 */
1090 static NTSTATUS dcesrv_samr_EnumDomainGroups(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1091                                       struct samr_EnumDomainGroups *r)
1092 {
1093         struct dcesrv_handle *h;
1094         struct samr_domain_state *d_state;
1095         struct ldb_message **res;
1096         int ldb_cnt, count, i, first;
1097         struct samr_SamEntry *entries;
1098         const char * const attrs[3] = { "objectSid", "sAMAccountName", NULL };
1099         struct samr_SamArray *sam;
1100
1101         *r->out.resume_handle = 0;
1102         *r->out.sam = NULL;
1103         *r->out.num_entries = 0;
1104
1105         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1106
1107         d_state = h->data;
1108
1109         /* search for all domain groups in this domain. This could possibly be
1110            cached and resumed based on resume_key */
1111         ldb_cnt = samdb_search_domain(d_state->sam_ctx, mem_ctx,
1112                                       d_state->domain_dn, &res, attrs,
1113                                       d_state->domain_sid,
1114                                       "(&(grouptype=%d)(objectclass=group))",
1115                                       GTYPE_SECURITY_GLOBAL_GROUP);
1116         if (ldb_cnt == -1) {
1117                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1118         }
1119
1120         /* convert to SamEntry format */
1121         entries = talloc_array(mem_ctx, struct samr_SamEntry, ldb_cnt);
1122         if (!entries) {
1123                 return NT_STATUS_NO_MEMORY;
1124         }
1125
1126         count = 0;
1127
1128         for (i=0;i<ldb_cnt;i++) {
1129                 struct dom_sid *group_sid;
1130
1131                 group_sid = samdb_result_dom_sid(mem_ctx, res[i],
1132                                                  "objectSid");
1133                 if (group_sid == NULL)
1134                         continue;
1135
1136                 entries[count].idx =
1137                         group_sid->sub_auths[group_sid->num_auths-1];
1138                 entries[count].name.string =
1139                         samdb_result_string(res[i], "sAMAccountName", "");
1140                 count += 1;
1141         }
1142
1143         /* sort the results by rid */
1144         qsort(entries, count, sizeof(struct samr_SamEntry),
1145               (comparison_fn_t)compare_SamEntry);
1146
1147         /* find the first entry to return */
1148         for (first=0;
1149              first<count && entries[first].idx <= *r->in.resume_handle;
1150              first++) ;
1151
1152         /* return the rest, limit by max_size. Note that we
1153            use the w2k3 element size value of 54 */
1154         *r->out.num_entries = count - first;
1155         *r->out.num_entries = MIN(*r->out.num_entries,
1156                                  1+(r->in.max_size/SAMR_ENUM_USERS_MULTIPLIER));
1157
1158         sam = talloc(mem_ctx, struct samr_SamArray);
1159         if (!sam) {
1160                 return NT_STATUS_NO_MEMORY;
1161         }
1162
1163         sam->entries = entries+first;
1164         sam->count = *r->out.num_entries;
1165
1166         *r->out.sam = sam;
1167
1168         if (*r->out.num_entries < count - first) {
1169                 *r->out.resume_handle = entries[first+*r->out.num_entries-1].idx;
1170                 return STATUS_MORE_ENTRIES;
1171         }
1172
1173         return NT_STATUS_OK;
1174 }
1175
1176
1177 /*
1178   samr_CreateUser2
1179
1180   This call uses transactions to ensure we don't get a new conflicting
1181   user while we are processing this, and to ensure the user either
1182   completly exists, or does not.
1183 */
1184 static NTSTATUS dcesrv_samr_CreateUser2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1185                                  struct samr_CreateUser2 *r)
1186 {
1187         struct samr_domain_state *d_state;
1188         struct samr_account_state *a_state;
1189         struct dcesrv_handle *h;
1190         const char *name;
1191         struct ldb_message *msg;
1192         struct dom_sid *sid;
1193         const char *account_name;
1194         struct dcesrv_handle *u_handle;
1195         int ret;
1196         const char *container, *obj_class=NULL;
1197         char *cn_name;
1198         int cn_name_len;
1199
1200         const char *attrs[] = {
1201                 "objectSid",
1202                 "userAccountControl",
1203                 NULL
1204         };
1205
1206         uint32_t user_account_control;
1207
1208         struct ldb_message **msgs;
1209
1210         ZERO_STRUCTP(r->out.user_handle);
1211         *r->out.access_granted = 0;
1212         *r->out.rid = 0;
1213
1214         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1215
1216         d_state = h->data;
1217
1218         if (d_state->builtin) {
1219                 DEBUG(5, ("Cannot create a user in the BUILTIN domain"));
1220                 return NT_STATUS_ACCESS_DENIED;
1221         } else if (r->in.acct_flags == ACB_DOMTRUST) {
1222                 /* Domain trust accounts must be created by the LSA calls */
1223                 return NT_STATUS_ACCESS_DENIED;
1224         }
1225         account_name = r->in.account_name->string;
1226
1227         if (account_name == NULL) {
1228                 return NT_STATUS_INVALID_PARAMETER;
1229         }
1230
1231         /*
1232          * Start a transaction, so we can query and do a subsequent atomic
1233          * modify
1234          */
1235
1236         ret = ldb_transaction_start(d_state->sam_ctx);
1237         if (ret != LDB_SUCCESS) {
1238                 DEBUG(0,("Failed to start a transaction for user creation: %s\n",
1239                          ldb_errstring(d_state->sam_ctx)));
1240                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1241         }
1242
1243         /* check if the user already exists */
1244         name = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
1245                                    "sAMAccountName",
1246                                    "(&(sAMAccountName=%s)(objectclass=user))",
1247                                    ldb_binary_encode_string(mem_ctx, account_name));
1248         if (name != NULL) {
1249                 ldb_transaction_cancel(d_state->sam_ctx);
1250                 return NT_STATUS_USER_EXISTS;
1251         }
1252
1253         msg = ldb_msg_new(mem_ctx);
1254         if (msg == NULL) {
1255                 ldb_transaction_cancel(d_state->sam_ctx);
1256                 return NT_STATUS_NO_MEMORY;
1257         }
1258
1259         cn_name   = talloc_strdup(mem_ctx, account_name);
1260         if (!cn_name) {
1261                 ldb_transaction_cancel(d_state->sam_ctx);
1262                 return NT_STATUS_NO_MEMORY;
1263         }
1264
1265         cn_name_len = strlen(cn_name);
1266
1267         /* This must be one of these values *only* */
1268         if (r->in.acct_flags == ACB_NORMAL) {
1269                 container = "CN=Users";
1270                 obj_class = "user";
1271
1272         } else if (r->in.acct_flags == ACB_WSTRUST) {
1273                 if (cn_name[cn_name_len - 1] != '$') {
1274                         ldb_transaction_cancel(d_state->sam_ctx);
1275                         return NT_STATUS_FOOBAR;
1276                 }
1277                 cn_name[cn_name_len - 1] = '\0';
1278                 container = "CN=Computers";
1279                 obj_class = "computer";
1280                 samdb_msg_add_int(d_state->sam_ctx, mem_ctx, msg,
1281                         "primaryGroupID", DOMAIN_RID_DOMAIN_MEMBERS);
1282
1283         } else if (r->in.acct_flags == ACB_SVRTRUST) {
1284                 if (cn_name[cn_name_len - 1] != '$') {
1285                         ldb_transaction_cancel(d_state->sam_ctx);
1286                         return NT_STATUS_FOOBAR;
1287                 }
1288                 cn_name[cn_name_len - 1] = '\0';
1289                 container = "OU=Domain Controllers";
1290                 obj_class = "computer";
1291                 samdb_msg_add_int(d_state->sam_ctx, mem_ctx, msg,
1292                         "primaryGroupID", DOMAIN_RID_DCS);
1293         } else {
1294                 ldb_transaction_cancel(d_state->sam_ctx);
1295                 return NT_STATUS_INVALID_PARAMETER;
1296         }
1297
1298         /* add core elements to the ldb_message for the user */
1299         msg->dn = ldb_dn_copy(msg, d_state->domain_dn);
1300         if ( ! ldb_dn_add_child_fmt(msg->dn, "CN=%s,%s", cn_name, container)) {
1301                 ldb_transaction_cancel(d_state->sam_ctx);
1302                 return NT_STATUS_FOOBAR;
1303         }
1304
1305         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "sAMAccountName",
1306                 account_name);
1307         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "objectClass",
1308                 obj_class);
1309
1310         /* create the user */
1311         ret = ldb_add(d_state->sam_ctx, msg);
1312         switch (ret) {
1313         case LDB_SUCCESS:
1314                 break;
1315         case LDB_ERR_ENTRY_ALREADY_EXISTS:
1316                 ldb_transaction_cancel(d_state->sam_ctx);
1317                 DEBUG(0,("Failed to create user record %s: %s\n",
1318                          ldb_dn_get_linearized(msg->dn),
1319                          ldb_errstring(d_state->sam_ctx)));
1320                 return NT_STATUS_USER_EXISTS;
1321         case LDB_ERR_UNWILLING_TO_PERFORM:
1322         case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
1323                 ldb_transaction_cancel(d_state->sam_ctx);
1324                 DEBUG(0,("Failed to create user record %s: %s\n",
1325                          ldb_dn_get_linearized(msg->dn),
1326                          ldb_errstring(d_state->sam_ctx)));
1327                 return NT_STATUS_ACCESS_DENIED;
1328         default:
1329                 ldb_transaction_cancel(d_state->sam_ctx);
1330                 DEBUG(0,("Failed to create user record %s: %s\n",
1331                          ldb_dn_get_linearized(msg->dn),
1332                          ldb_errstring(d_state->sam_ctx)));
1333                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1334         }
1335
1336         a_state = talloc(d_state, struct samr_account_state);
1337         if (!a_state) {
1338                 ldb_transaction_cancel(d_state->sam_ctx);
1339                 return NT_STATUS_NO_MEMORY;
1340         }
1341         a_state->sam_ctx = d_state->sam_ctx;
1342         a_state->access_mask = r->in.access_mask;
1343         a_state->domain_state = talloc_reference(a_state, d_state);
1344         a_state->account_dn = talloc_steal(a_state, msg->dn);
1345
1346         /* retrieve the sid and account control bits for the user just created */
1347         ret = gendb_search_dn(d_state->sam_ctx, mem_ctx,
1348                               msg->dn, &msgs, attrs);
1349
1350         if (ret != 1) {
1351                 ldb_transaction_cancel(d_state->sam_ctx);
1352                 DEBUG(0,("Apparently we failed to create an account record, as %s now doesn't exist\n",
1353                          ldb_dn_get_linearized(msg->dn)));
1354                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1355         }
1356         sid = samdb_result_dom_sid(mem_ctx, msgs[0], "objectSid");
1357         if (sid == NULL) {
1358                 ldb_transaction_cancel(d_state->sam_ctx);
1359                 DEBUG(0,("Apparently we failed to get the objectSid of the just created account record %s\n",
1360                          ldb_dn_get_linearized(msg->dn)));
1361                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1362         }
1363
1364         /* Change the account control to be the correct account type.
1365          * The default is for a workstation account */
1366         user_account_control = samdb_result_uint(msgs[0], "userAccountControl", 0);
1367         user_account_control = (user_account_control &
1368                                 ~(UF_NORMAL_ACCOUNT |
1369                                   UF_INTERDOMAIN_TRUST_ACCOUNT |
1370                                   UF_WORKSTATION_TRUST_ACCOUNT |
1371                                   UF_SERVER_TRUST_ACCOUNT));
1372         user_account_control |= ds_acb2uf(r->in.acct_flags);
1373
1374         talloc_free(msg);
1375         msg = ldb_msg_new(mem_ctx);
1376         if (msg == NULL) {
1377                 ldb_transaction_cancel(d_state->sam_ctx);
1378                 return NT_STATUS_NO_MEMORY;
1379         }
1380
1381         msg->dn = ldb_dn_copy(msg, a_state->account_dn);
1382
1383         if (samdb_msg_add_uint(a_state->sam_ctx, mem_ctx, msg,
1384                                "userAccountControl",
1385                                user_account_control) != 0) {
1386                 ldb_transaction_cancel(d_state->sam_ctx);
1387                 return NT_STATUS_NO_MEMORY;
1388         }
1389
1390         /* modify the samdb record */
1391         ret = samdb_replace(a_state->sam_ctx, mem_ctx, msg);
1392         if (ret != LDB_SUCCESS) {
1393                 DEBUG(0,("Failed to modify account record %s to set userAccountControl: %s\n",
1394                          ldb_dn_get_linearized(msg->dn),
1395                          ldb_errstring(d_state->sam_ctx)));
1396                 ldb_transaction_cancel(d_state->sam_ctx);
1397
1398                 /* we really need samdb.c to return NTSTATUS */
1399                 return NT_STATUS_UNSUCCESSFUL;
1400         }
1401
1402         ret = ldb_transaction_commit(d_state->sam_ctx);
1403         if (ret != LDB_SUCCESS) {
1404                 DEBUG(0,("Failed to commit transaction to add and modify account record %s: %s\n",
1405                          ldb_dn_get_linearized(msg->dn),
1406                          ldb_errstring(d_state->sam_ctx)));
1407                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1408         }
1409
1410         a_state->account_name = talloc_steal(a_state, account_name);
1411         if (!a_state->account_name) {
1412                 return NT_STATUS_NO_MEMORY;
1413         }
1414
1415         /* create the policy handle */
1416         u_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_USER);
1417         if (!u_handle) {
1418                 return NT_STATUS_NO_MEMORY;
1419         }
1420
1421         u_handle->data = talloc_steal(u_handle, a_state);
1422
1423         *r->out.user_handle = u_handle->wire_handle;
1424         *r->out.access_granted = 0xf07ff; /* TODO: fix access mask calculations */
1425
1426         *r->out.rid = sid->sub_auths[sid->num_auths-1];
1427
1428         return NT_STATUS_OK;
1429 }
1430
1431
1432 /*
1433   samr_CreateUser
1434 */
1435 static NTSTATUS dcesrv_samr_CreateUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1436                                 struct samr_CreateUser *r)
1437 {
1438         struct samr_CreateUser2 r2;
1439         uint32_t access_granted = 0;
1440
1441
1442         /* a simple wrapper around samr_CreateUser2 works nicely */
1443         r2.in.domain_handle = r->in.domain_handle;
1444         r2.in.account_name = r->in.account_name;
1445         r2.in.acct_flags = ACB_NORMAL;
1446         r2.in.access_mask = r->in.access_mask;
1447         r2.out.user_handle = r->out.user_handle;
1448         r2.out.access_granted = &access_granted;
1449         r2.out.rid = r->out.rid;
1450
1451         return dcesrv_samr_CreateUser2(dce_call, mem_ctx, &r2);
1452 }
1453
1454 /*
1455   samr_EnumDomainUsers
1456 */
1457 static NTSTATUS dcesrv_samr_EnumDomainUsers(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1458                                      struct samr_EnumDomainUsers *r)
1459 {
1460         struct dcesrv_handle *h;
1461         struct samr_domain_state *d_state;
1462         struct ldb_result *res;
1463         int ret, num_filtered_entries, i, first;
1464         struct samr_SamEntry *entries;
1465         const char * const attrs[] = { "objectSid", "sAMAccountName",
1466                 "userAccountControl", NULL };
1467         struct samr_SamArray *sam;
1468
1469         *r->out.resume_handle = 0;
1470         *r->out.sam = NULL;
1471         *r->out.num_entries = 0;
1472
1473         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1474
1475         d_state = h->data;
1476
1477         /* don't have to worry about users in the builtin domain, as there are none */
1478         ret = ldb_search(d_state->sam_ctx, mem_ctx, &res, d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs, "objectClass=user");
1479
1480         if (ret != LDB_SUCCESS) {
1481                 DEBUG(3, ("Failed to search for Domain Users in %s: %s\n",
1482                           ldb_dn_get_linearized(d_state->domain_dn), ldb_errstring(d_state->sam_ctx)));
1483                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1484         }
1485
1486         /* convert to SamEntry format */
1487         entries = talloc_array(mem_ctx, struct samr_SamEntry, res->count);
1488         if (!entries) {
1489                 return NT_STATUS_NO_MEMORY;
1490         }
1491         num_filtered_entries = 0;
1492         for (i=0;i<res->count;i++) {
1493                 /* Check if a mask has been requested */
1494                 if (r->in.acct_flags
1495                     && ((samdb_result_acct_flags(d_state->sam_ctx, mem_ctx, res->msgs[i],
1496                                                  d_state->domain_dn) & r->in.acct_flags) == 0)) {
1497                         continue;
1498                 }
1499                 entries[num_filtered_entries].idx = samdb_result_rid_from_sid(mem_ctx, res->msgs[i], "objectSid", 0);
1500                 entries[num_filtered_entries].name.string = samdb_result_string(res->msgs[i], "sAMAccountName", "");
1501                 num_filtered_entries++;
1502         }
1503
1504         /* sort the results by rid */
1505         qsort(entries, num_filtered_entries, sizeof(struct samr_SamEntry),
1506               (comparison_fn_t)compare_SamEntry);
1507
1508         /* find the first entry to return */
1509         for (first=0;
1510              first<num_filtered_entries && entries[first].idx <= *r->in.resume_handle;
1511              first++) ;
1512
1513         /* return the rest, limit by max_size. Note that we
1514            use the w2k3 element size value of 54 */
1515         *r->out.num_entries = num_filtered_entries - first;
1516         *r->out.num_entries = MIN(*r->out.num_entries,
1517                                  1+(r->in.max_size/SAMR_ENUM_USERS_MULTIPLIER));
1518
1519         sam = talloc(mem_ctx, struct samr_SamArray);
1520         if (!sam) {
1521                 return NT_STATUS_NO_MEMORY;
1522         }
1523
1524         sam->entries = entries+first;
1525         sam->count = *r->out.num_entries;
1526
1527         *r->out.sam = sam;
1528
1529         if (first == num_filtered_entries) {
1530                 return NT_STATUS_OK;
1531         }
1532
1533         if (*r->out.num_entries < num_filtered_entries - first) {
1534                 *r->out.resume_handle = entries[first+*r->out.num_entries-1].idx;
1535                 return STATUS_MORE_ENTRIES;
1536         }
1537
1538         return NT_STATUS_OK;
1539 }
1540
1541
1542 /*
1543   samr_CreateDomAlias
1544 */
1545 static NTSTATUS dcesrv_samr_CreateDomAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1546                        struct samr_CreateDomAlias *r)
1547 {
1548         struct samr_domain_state *d_state;
1549         struct samr_account_state *a_state;
1550         struct dcesrv_handle *h;
1551         const char *alias_name, *name;
1552         struct ldb_message *msg;
1553         struct dom_sid *sid;
1554         struct dcesrv_handle *a_handle;
1555         int ret;
1556
1557         ZERO_STRUCTP(r->out.alias_handle);
1558         *r->out.rid = 0;
1559
1560         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1561
1562         d_state = h->data;
1563
1564         if (d_state->builtin) {
1565                 DEBUG(5, ("Cannot create a domain alias in the BUILTIN domain"));
1566                 return NT_STATUS_ACCESS_DENIED;
1567         }
1568
1569         alias_name = r->in.alias_name->string;
1570
1571         if (alias_name == NULL) {
1572                 return NT_STATUS_INVALID_PARAMETER;
1573         }
1574
1575         /* Check if alias already exists */
1576         name = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
1577                                    "sAMAccountName",
1578                                    "(sAMAccountName=%s)(objectclass=group))",
1579                                    ldb_binary_encode_string(mem_ctx, alias_name));
1580
1581         if (name != NULL) {
1582                 return NT_STATUS_ALIAS_EXISTS;
1583         }
1584
1585         msg = ldb_msg_new(mem_ctx);
1586         if (msg == NULL) {
1587                 return NT_STATUS_NO_MEMORY;
1588         }
1589
1590         /* add core elements to the ldb_message for the alias */
1591         msg->dn = ldb_dn_copy(mem_ctx, d_state->domain_dn);
1592         ldb_dn_add_child_fmt(msg->dn, "CN=%s,CN=Users", alias_name);
1593         if (!msg->dn) {
1594                 return NT_STATUS_NO_MEMORY;
1595         }
1596
1597         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "sAMAccountName", alias_name);
1598         samdb_msg_add_string(d_state->sam_ctx, mem_ctx, msg, "objectClass", "group");
1599         samdb_msg_add_int(d_state->sam_ctx, mem_ctx, msg, "groupType", GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1600
1601         /* create the alias */
1602         ret = ldb_add(d_state->sam_ctx, msg);
1603         switch (ret) {
1604         case LDB_SUCCESS:
1605                 break;
1606         case LDB_ERR_ENTRY_ALREADY_EXISTS:
1607                 return NT_STATUS_ALIAS_EXISTS;
1608         case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
1609                 return NT_STATUS_ACCESS_DENIED;
1610         default:
1611                 DEBUG(0,("Failed to create alias record %s: %s\n",
1612                          ldb_dn_get_linearized(msg->dn),
1613                          ldb_errstring(d_state->sam_ctx)));
1614                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1615         }
1616
1617         a_state = talloc(d_state, struct samr_account_state);
1618         if (!a_state) {
1619                 return NT_STATUS_NO_MEMORY;
1620         }
1621
1622         a_state->sam_ctx = d_state->sam_ctx;
1623         a_state->access_mask = r->in.access_mask;
1624         a_state->domain_state = talloc_reference(a_state, d_state);
1625         a_state->account_dn = talloc_steal(a_state, msg->dn);
1626
1627         /* retrieve the sid for the alias just created */
1628         sid = samdb_search_dom_sid(d_state->sam_ctx, a_state,
1629                                    msg->dn, "objectSid", NULL);
1630
1631         a_state->account_name = talloc_strdup(a_state, alias_name);
1632         if (!a_state->account_name) {
1633                 return NT_STATUS_NO_MEMORY;
1634         }
1635
1636         /* create the policy handle */
1637         a_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_ALIAS);
1638         if (a_handle == NULL)
1639                 return NT_STATUS_NO_MEMORY;
1640
1641         a_handle->data = talloc_steal(a_handle, a_state);
1642
1643         *r->out.alias_handle = a_handle->wire_handle;
1644
1645         *r->out.rid = sid->sub_auths[sid->num_auths-1];
1646
1647         return NT_STATUS_OK;
1648 }
1649
1650
1651 /*
1652   samr_EnumDomainAliases
1653 */
1654 static NTSTATUS dcesrv_samr_EnumDomainAliases(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1655                        struct samr_EnumDomainAliases *r)
1656 {
1657         struct dcesrv_handle *h;
1658         struct samr_domain_state *d_state;
1659         struct ldb_message **res;
1660         int ldb_cnt, count, i, first;
1661         struct samr_SamEntry *entries;
1662         const char * const attrs[3] = { "objectSid", "sAMAccountName", NULL };
1663         struct samr_SamArray *sam;
1664
1665         *r->out.resume_handle = 0;
1666         *r->out.sam = NULL;
1667         *r->out.num_entries = 0;
1668
1669         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1670
1671         d_state = h->data;
1672
1673         /* search for all domain groups in this domain. This could possibly be
1674            cached and resumed based on resume_key */
1675         ldb_cnt = samdb_search_domain(d_state->sam_ctx, mem_ctx,
1676                                       d_state->domain_dn,
1677                                       &res, attrs,
1678                                       d_state->domain_sid,
1679                                       "(&(|(grouptype=%d)(grouptype=%d)))"
1680                                       "(objectclass=group))",
1681                                       GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
1682                                       GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1683         if (ldb_cnt == -1) {
1684                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1685         }
1686         if (ldb_cnt == 0) {
1687                 return NT_STATUS_OK;
1688         }
1689
1690         /* convert to SamEntry format */
1691         entries = talloc_array(mem_ctx, struct samr_SamEntry, ldb_cnt);
1692         if (!entries) {
1693                 return NT_STATUS_NO_MEMORY;
1694         }
1695
1696         count = 0;
1697
1698         for (i=0;i<ldb_cnt;i++) {
1699                 struct dom_sid *alias_sid;
1700
1701                 alias_sid = samdb_result_dom_sid(mem_ctx, res[i],
1702                                                  "objectSid");
1703
1704                 if (alias_sid == NULL)
1705                         continue;
1706
1707                 entries[count].idx =
1708                         alias_sid->sub_auths[alias_sid->num_auths-1];
1709                 entries[count].name.string =
1710                         samdb_result_string(res[i], "sAMAccountName", "");
1711                 count += 1;
1712         }
1713
1714         /* sort the results by rid */
1715         qsort(entries, count, sizeof(struct samr_SamEntry),
1716               (comparison_fn_t)compare_SamEntry);
1717
1718         /* find the first entry to return */
1719         for (first=0;
1720              first<count && entries[first].idx <= *r->in.resume_handle;
1721              first++) ;
1722
1723         if (first == count) {
1724                 return NT_STATUS_OK;
1725         }
1726
1727         *r->out.num_entries = count - first;
1728         *r->out.num_entries = MIN(*r->out.num_entries, 1000);
1729
1730         sam = talloc(mem_ctx, struct samr_SamArray);
1731         if (!sam) {
1732                 return NT_STATUS_NO_MEMORY;
1733         }
1734
1735         sam->entries = entries+first;
1736         sam->count = *r->out.num_entries;
1737
1738         *r->out.sam = sam;
1739
1740         if (*r->out.num_entries < count - first) {
1741                 *r->out.resume_handle =
1742                         entries[first+*r->out.num_entries-1].idx;
1743                 return STATUS_MORE_ENTRIES;
1744         }
1745
1746         return NT_STATUS_OK;
1747 }
1748
1749
1750 /*
1751   samr_GetAliasMembership
1752 */
1753 static NTSTATUS dcesrv_samr_GetAliasMembership(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1754                        struct samr_GetAliasMembership *r)
1755 {
1756         struct dcesrv_handle *h;
1757         struct samr_domain_state *d_state;
1758         struct ldb_message **res;
1759         int i, count = 0;
1760
1761         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1762
1763         d_state = h->data;
1764
1765         if (r->in.sids->num_sids > 0) {
1766                 const char *filter;
1767                 const char * const attrs[2] = { "objectSid", NULL };
1768
1769                 filter = talloc_asprintf(mem_ctx,
1770                                          "(&(|(grouptype=%d)(grouptype=%d))"
1771                                          "(objectclass=group)(|",
1772                                          GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
1773                                          GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1774                 if (filter == NULL)
1775                         return NT_STATUS_NO_MEMORY;
1776
1777                 for (i=0; i<r->in.sids->num_sids; i++) {
1778                         const char *memberdn;
1779
1780                         memberdn =
1781                                 samdb_search_string(d_state->sam_ctx,
1782                                                     mem_ctx, NULL,
1783                                                     "distinguishedName",
1784                                                     "(objectSid=%s)",
1785                                                     ldap_encode_ndr_dom_sid(mem_ctx,
1786                                                                             r->in.sids->sids[i].sid));
1787
1788                         if (memberdn == NULL)
1789                                 continue;
1790
1791                         filter = talloc_asprintf(mem_ctx, "%s(member=%s)",
1792                                                  filter, memberdn);
1793                         if (filter == NULL)
1794                                 return NT_STATUS_NO_MEMORY;
1795                 }
1796
1797                 count = samdb_search_domain(d_state->sam_ctx, mem_ctx,
1798                                             d_state->domain_dn, &res, attrs,
1799                                             d_state->domain_sid, "%s))", filter);
1800                 if (count < 0)
1801                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
1802         }
1803
1804         r->out.rids->count = 0;
1805         r->out.rids->ids = talloc_array(mem_ctx, uint32_t, count);
1806         if (r->out.rids->ids == NULL)
1807                 return NT_STATUS_NO_MEMORY;
1808
1809         for (i=0; i<count; i++) {
1810                 struct dom_sid *alias_sid;
1811
1812                 alias_sid = samdb_result_dom_sid(mem_ctx, res[i], "objectSid");
1813
1814                 if (alias_sid == NULL) {
1815                         DEBUG(0, ("Could not find objectSid\n"));
1816                         continue;
1817                 }
1818
1819                 r->out.rids->ids[r->out.rids->count] =
1820                         alias_sid->sub_auths[alias_sid->num_auths-1];
1821                 r->out.rids->count += 1;
1822         }
1823
1824         return NT_STATUS_OK;
1825 }
1826
1827
1828 /*
1829   samr_LookupNames
1830 */
1831 static NTSTATUS dcesrv_samr_LookupNames(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1832                                  struct samr_LookupNames *r)
1833 {
1834         struct dcesrv_handle *h;
1835         struct samr_domain_state *d_state;
1836         int i, num_mapped;
1837         NTSTATUS status = NT_STATUS_OK;
1838         const char * const attrs[] = { "sAMAccountType", "objectSid", NULL };
1839         int count;
1840
1841         ZERO_STRUCTP(r->out.rids);
1842         ZERO_STRUCTP(r->out.types);
1843
1844         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1845
1846         d_state = h->data;
1847
1848         if (r->in.num_names == 0) {
1849                 return NT_STATUS_OK;
1850         }
1851
1852         r->out.rids->ids = talloc_array(mem_ctx, uint32_t, r->in.num_names);
1853         r->out.types->ids = talloc_array(mem_ctx, uint32_t, r->in.num_names);
1854         if (!r->out.rids->ids || !r->out.types->ids) {
1855                 return NT_STATUS_NO_MEMORY;
1856         }
1857         r->out.rids->count = r->in.num_names;
1858         r->out.types->count = r->in.num_names;
1859
1860         num_mapped = 0;
1861
1862         for (i=0;i<r->in.num_names;i++) {
1863                 struct ldb_message **res;
1864                 struct dom_sid *sid;
1865                 uint32_t atype, rtype;
1866
1867                 r->out.rids->ids[i] = 0;
1868                 r->out.types->ids[i] = SID_NAME_UNKNOWN;
1869
1870                 count = gendb_search(d_state->sam_ctx, mem_ctx, d_state->domain_dn, &res, attrs,
1871                                      "sAMAccountName=%s",
1872                                      ldb_binary_encode_string(mem_ctx, r->in.names[i].string));
1873                 if (count != 1) {
1874                         status = STATUS_SOME_UNMAPPED;
1875                         continue;
1876                 }
1877
1878                 sid = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
1879                 if (sid == NULL) {
1880                         status = STATUS_SOME_UNMAPPED;
1881                         continue;
1882                 }
1883
1884                 atype = samdb_result_uint(res[0], "sAMAccountType", 0);
1885                 if (atype == 0) {
1886                         status = STATUS_SOME_UNMAPPED;
1887                         continue;
1888                 }
1889
1890                 rtype = ds_atype_map(atype);
1891
1892                 if (rtype == SID_NAME_UNKNOWN) {
1893                         status = STATUS_SOME_UNMAPPED;
1894                         continue;
1895                 }
1896
1897                 r->out.rids->ids[i] = sid->sub_auths[sid->num_auths-1];
1898                 r->out.types->ids[i] = rtype;
1899                 num_mapped++;
1900         }
1901
1902         if (num_mapped == 0) {
1903                 return NT_STATUS_NONE_MAPPED;
1904         }
1905         return status;
1906 }
1907
1908
1909 /*
1910   samr_LookupRids
1911 */
1912 static NTSTATUS dcesrv_samr_LookupRids(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1913                        struct samr_LookupRids *r)
1914 {
1915         struct dcesrv_handle *h;
1916         struct samr_domain_state *d_state;
1917         int i, total;
1918         NTSTATUS status = NT_STATUS_OK;
1919         struct lsa_String *names;
1920         uint32_t *ids;
1921
1922         ZERO_STRUCTP(r->out.names);
1923         ZERO_STRUCTP(r->out.types);
1924
1925         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
1926
1927         d_state = h->data;
1928
1929         if (r->in.num_rids == 0)
1930                 return NT_STATUS_OK;
1931
1932         names = talloc_array(mem_ctx, struct lsa_String, r->in.num_rids);
1933         ids = talloc_array(mem_ctx, uint32_t, r->in.num_rids);
1934
1935         if ((names == NULL) || (ids == NULL))
1936                 return NT_STATUS_NO_MEMORY;
1937
1938         total = 0;
1939
1940         for (i=0; i<r->in.num_rids; i++) {
1941                 struct ldb_message **res;
1942                 int count;
1943                 const char * const attrs[] = {  "sAMAccountType",
1944                                                 "sAMAccountName", NULL };
1945                 uint32_t atype;
1946                 struct dom_sid *sid;
1947
1948                 ids[i] = SID_NAME_UNKNOWN;
1949
1950                 sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid,
1951                         r->in.rids[i]);
1952                 if (sid == NULL) {
1953                         names[i].string = NULL;
1954                         status = STATUS_SOME_UNMAPPED;
1955                         continue;
1956                 }
1957
1958                 count = gendb_search(d_state->sam_ctx, mem_ctx,
1959                                      d_state->domain_dn, &res, attrs,
1960                                      "(objectSid=%s)",
1961                                      ldap_encode_ndr_dom_sid(mem_ctx, sid));
1962                 if (count != 1) {
1963                         names[i].string = NULL;
1964                         status = STATUS_SOME_UNMAPPED;
1965                         continue;
1966                 }
1967
1968                 names[i].string = samdb_result_string(res[0], "sAMAccountName",
1969                                                       NULL);
1970
1971                 atype = samdb_result_uint(res[0], "sAMAccountType", 0);
1972                 if (atype == 0) {
1973                         status = STATUS_SOME_UNMAPPED;
1974                         continue;
1975                 }
1976
1977                 ids[i] = ds_atype_map(atype);
1978
1979                 if (ids[i] == SID_NAME_UNKNOWN) {
1980                         status = STATUS_SOME_UNMAPPED;
1981                         continue;
1982                 }
1983         }
1984
1985         r->out.names->names = names;
1986         r->out.names->count = r->in.num_rids;
1987
1988         r->out.types->ids = ids;
1989         r->out.types->count = r->in.num_rids;
1990
1991         return status;
1992 }
1993
1994
1995 /*
1996   samr_OpenGroup
1997 */
1998 static NTSTATUS dcesrv_samr_OpenGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1999                        struct samr_OpenGroup *r)
2000 {
2001         struct samr_domain_state *d_state;
2002         struct samr_account_state *a_state;
2003         struct dcesrv_handle *h;
2004         const char *groupname;
2005         struct dom_sid *sid;
2006         struct ldb_message **msgs;
2007         struct dcesrv_handle *g_handle;
2008         const char * const attrs[2] = { "sAMAccountName", NULL };
2009         int ret;
2010
2011         ZERO_STRUCTP(r->out.group_handle);
2012
2013         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
2014
2015         d_state = h->data;
2016
2017         /* form the group SID */
2018         sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2019         if (!sid) {
2020                 return NT_STATUS_NO_MEMORY;
2021         }
2022
2023         /* search for the group record */
2024         ret = gendb_search(d_state->sam_ctx,
2025                            mem_ctx, d_state->domain_dn, &msgs, attrs,
2026                            "(&(objectSid=%s)(objectclass=group)"
2027                            "(grouptype=%d))",
2028                            ldap_encode_ndr_dom_sid(mem_ctx, sid),
2029                            GTYPE_SECURITY_GLOBAL_GROUP);
2030         if (ret == 0) {
2031                 return NT_STATUS_NO_SUCH_GROUP;
2032         }
2033         if (ret != 1) {
2034                 DEBUG(0,("Found %d records matching sid %s\n",
2035                          ret, dom_sid_string(mem_ctx, sid)));
2036                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2037         }
2038
2039         groupname = samdb_result_string(msgs[0], "sAMAccountName", NULL);
2040         if (groupname == NULL) {
2041                 DEBUG(0,("sAMAccountName field missing for sid %s\n",
2042                          dom_sid_string(mem_ctx, sid)));
2043                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2044         }
2045
2046         a_state = talloc(d_state, struct samr_account_state);
2047         if (!a_state) {
2048                 return NT_STATUS_NO_MEMORY;
2049         }
2050         a_state->sam_ctx = d_state->sam_ctx;
2051         a_state->access_mask = r->in.access_mask;
2052         a_state->domain_state = talloc_reference(a_state, d_state);
2053         a_state->account_dn = talloc_steal(a_state, msgs[0]->dn);
2054         a_state->account_sid = talloc_steal(a_state, sid);
2055         a_state->account_name = talloc_strdup(a_state, groupname);
2056         if (!a_state->account_name) {
2057                 return NT_STATUS_NO_MEMORY;
2058         }
2059
2060         /* create the policy handle */
2061         g_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_GROUP);
2062         if (!g_handle) {
2063                 return NT_STATUS_NO_MEMORY;
2064         }
2065
2066         g_handle->data = talloc_steal(g_handle, a_state);
2067
2068         *r->out.group_handle = g_handle->wire_handle;
2069
2070         return NT_STATUS_OK;
2071 }
2072
2073 /*
2074   samr_QueryGroupInfo
2075 */
2076 static NTSTATUS dcesrv_samr_QueryGroupInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2077                        struct samr_QueryGroupInfo *r)
2078 {
2079         struct dcesrv_handle *h;
2080         struct samr_account_state *a_state;
2081         struct ldb_message *msg;
2082         struct ldb_result *res;
2083         const char * const attrs[4] = { "sAMAccountName", "description",
2084                                         "numMembers", NULL };
2085         int ret;
2086         union samr_GroupInfo *info;
2087
2088         *r->out.info = NULL;
2089
2090         DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2091
2092         a_state = h->data;
2093
2094         ret = ldb_search(a_state->sam_ctx, mem_ctx, &res, a_state->account_dn,
2095                 LDB_SCOPE_SUBTREE, attrs, "objectClass=*");
2096
2097         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
2098                 return NT_STATUS_NO_SUCH_GROUP;
2099         } else if (ret != LDB_SUCCESS) {
2100                 DEBUG(2, ("Error reading group info: %s\n", ldb_errstring(a_state->sam_ctx)));
2101                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2102         }
2103
2104         if (res->count != 1) {
2105                 DEBUG(2, ("Error finding group info, got %d entries\n", res->count));
2106
2107                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2108         }
2109         msg = res->msgs[0];
2110
2111         /* allocate the info structure */
2112         info = talloc_zero(mem_ctx, union samr_GroupInfo);
2113         if (info == NULL) {
2114                 return NT_STATUS_NO_MEMORY;
2115         }
2116
2117         /* Fill in the level */
2118         switch (r->in.level) {
2119         case GROUPINFOALL:
2120                 QUERY_STRING(msg, all.name,        "sAMAccountName");
2121                 info->all.attributes = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED; /* Do like w2k3 */
2122                 QUERY_UINT  (msg, all.num_members,      "numMembers")
2123                 QUERY_STRING(msg, all.description, "description");
2124                 break;
2125         case GROUPINFONAME:
2126                 QUERY_STRING(msg, name,            "sAMAccountName");
2127                 break;
2128         case GROUPINFOATTRIBUTES:
2129                 info->attributes.attributes = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED; /* Do like w2k3 */
2130                 break;
2131         case GROUPINFODESCRIPTION:
2132                 QUERY_STRING(msg, description, "description");
2133                 break;
2134         case GROUPINFOALL2:
2135                 QUERY_STRING(msg, all2.name,        "sAMAccountName");
2136                 info->all.attributes = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED; /* Do like w2k3 */
2137                 QUERY_UINT  (msg, all2.num_members,      "numMembers")
2138                 QUERY_STRING(msg, all2.description, "description");
2139                 break;
2140         default:
2141                 talloc_free(info);
2142                 return NT_STATUS_INVALID_INFO_CLASS;
2143         }
2144
2145         *r->out.info = info;
2146
2147         return NT_STATUS_OK;
2148 }
2149
2150
2151 /*
2152   samr_SetGroupInfo
2153 */
2154 static NTSTATUS dcesrv_samr_SetGroupInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2155                                   struct samr_SetGroupInfo *r)
2156 {
2157         struct dcesrv_handle *h;
2158         struct samr_account_state *g_state;
2159         struct ldb_message *msg;
2160         struct ldb_context *sam_ctx;
2161         int ret;
2162
2163         DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2164
2165         g_state = h->data;
2166         sam_ctx = g_state->sam_ctx;
2167
2168         msg = ldb_msg_new(mem_ctx);
2169         if (msg == NULL) {
2170                 return NT_STATUS_NO_MEMORY;
2171         }
2172
2173         msg->dn = ldb_dn_copy(mem_ctx, g_state->account_dn);
2174         if (!msg->dn) {
2175                 return NT_STATUS_NO_MEMORY;
2176         }
2177
2178         switch (r->in.level) {
2179         case GROUPINFODESCRIPTION:
2180                 SET_STRING(msg, description,         "description");
2181                 break;
2182         case GROUPINFONAME:
2183                 /* On W2k3 this does not change the name, it changes the
2184                  * sAMAccountName attribute */
2185                 SET_STRING(msg, name,                "sAMAccountName");
2186                 break;
2187         case GROUPINFOATTRIBUTES:
2188                 /* This does not do anything obviously visible in W2k3 LDAP */
2189                 return NT_STATUS_OK;
2190         default:
2191                 return NT_STATUS_INVALID_INFO_CLASS;
2192         }
2193
2194         /* modify the samdb record */
2195         ret = ldb_modify(g_state->sam_ctx, msg);
2196         if (ret != LDB_SUCCESS) {
2197                 /* we really need samdb.c to return NTSTATUS */
2198                 return NT_STATUS_UNSUCCESSFUL;
2199         }
2200
2201         return NT_STATUS_OK;
2202 }
2203
2204
2205 /*
2206   samr_AddGroupMember
2207 */
2208 static NTSTATUS dcesrv_samr_AddGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2209                        struct samr_AddGroupMember *r)
2210 {
2211         struct dcesrv_handle *h;
2212         struct samr_account_state *a_state;
2213         struct samr_domain_state *d_state;
2214         struct ldb_message *mod;
2215         struct dom_sid *membersid;
2216         const char *memberdn;
2217         struct ldb_result *res;
2218         const char * const attrs[] = { NULL };
2219         int ret;
2220
2221         DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2222
2223         a_state = h->data;
2224         d_state = a_state->domain_state;
2225
2226         membersid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2227         if (membersid == NULL) {
2228                 return NT_STATUS_NO_MEMORY;
2229         }
2230
2231         /* In native mode, AD can also nest domain groups. Not sure yet
2232          * whether this is also available via RPC. */
2233         ret = ldb_search(d_state->sam_ctx, mem_ctx, &res,
2234                                  d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs,
2235                                  "(&(objectSid=%s)(objectclass=user))",
2236                                  ldap_encode_ndr_dom_sid(mem_ctx, membersid));
2237
2238         if (ret != LDB_SUCCESS) {
2239                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2240         }
2241
2242         if (res->count == 0) {
2243                 return NT_STATUS_NO_SUCH_USER;
2244         }
2245
2246         if (res->count > 1) {
2247                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2248         }
2249
2250         memberdn = ldb_dn_alloc_linearized(mem_ctx, res->msgs[0]->dn);
2251
2252         if (memberdn == NULL)
2253                 return NT_STATUS_NO_MEMORY;
2254
2255         mod = ldb_msg_new(mem_ctx);
2256         if (mod == NULL) {
2257                 return NT_STATUS_NO_MEMORY;
2258         }
2259
2260         mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2261
2262         ret = samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
2263                                                                 memberdn);
2264         if (ret != LDB_SUCCESS) {
2265                 return NT_STATUS_UNSUCCESSFUL;
2266         }
2267
2268         ret = ldb_modify(a_state->sam_ctx, mod);
2269         switch (ret) {
2270         case LDB_SUCCESS:
2271                 return NT_STATUS_OK;
2272         case LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS:
2273                 return NT_STATUS_MEMBER_IN_GROUP;
2274         case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
2275                 return NT_STATUS_ACCESS_DENIED;
2276         default:
2277                 return NT_STATUS_UNSUCCESSFUL;
2278         }
2279 }
2280
2281
2282 /*
2283   samr_DeleteDomainGroup
2284 */
2285 static NTSTATUS dcesrv_samr_DeleteDomainGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2286                        struct samr_DeleteDomainGroup *r)
2287 {
2288         struct dcesrv_handle *h;
2289         struct samr_account_state *a_state;
2290         int ret;
2291
2292         *r->out.group_handle = *r->in.group_handle;
2293
2294         DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2295
2296         a_state = h->data;
2297
2298         ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
2299         if (ret != LDB_SUCCESS) {
2300                 return NT_STATUS_UNSUCCESSFUL;
2301         }
2302
2303         ZERO_STRUCTP(r->out.group_handle);
2304
2305         return NT_STATUS_OK;
2306 }
2307
2308
2309 /*
2310   samr_DeleteGroupMember
2311 */
2312 static NTSTATUS dcesrv_samr_DeleteGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2313                        struct samr_DeleteGroupMember *r)
2314 {
2315         struct dcesrv_handle *h;
2316         struct samr_account_state *a_state;
2317         struct samr_domain_state *d_state;
2318         struct ldb_message *mod;
2319         struct dom_sid *membersid;
2320         const char *memberdn;
2321         struct ldb_result *res;
2322         const char * const attrs[] = { NULL };
2323         int ret;
2324
2325         DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2326
2327         a_state = h->data;
2328         d_state = a_state->domain_state;
2329
2330         membersid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2331         if (membersid == NULL)
2332                 return NT_STATUS_NO_MEMORY;
2333
2334         /* In native mode, AD can also nest domain groups. Not sure yet
2335          * whether this is also available via RPC. */
2336         ret = ldb_search(d_state->sam_ctx, mem_ctx, &res,
2337                                  d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs,
2338                                  "(&(objectSid=%s)(objectclass=user))",
2339                                  ldap_encode_ndr_dom_sid(mem_ctx, membersid));
2340
2341         if (ret != LDB_SUCCESS) {
2342                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2343         }
2344
2345         if (res->count == 0) {
2346                 return NT_STATUS_NO_SUCH_USER;
2347         }
2348
2349         if (res->count > 1) {
2350                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2351         }
2352
2353         memberdn = ldb_dn_alloc_linearized(mem_ctx, res->msgs[0]->dn);
2354
2355         if (memberdn == NULL)
2356                 return NT_STATUS_NO_MEMORY;
2357
2358         mod = ldb_msg_new(mem_ctx);
2359         if (mod == NULL) {
2360                 return NT_STATUS_NO_MEMORY;
2361         }
2362
2363         mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2364
2365         ret = samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
2366                                                                 memberdn);
2367         if (ret != LDB_SUCCESS) {
2368                 return NT_STATUS_NO_MEMORY;
2369         }
2370
2371         ret = ldb_modify(a_state->sam_ctx, mod);
2372         switch (ret) {
2373         case LDB_SUCCESS:
2374                 return NT_STATUS_OK;
2375         case LDB_ERR_NO_SUCH_ATTRIBUTE:
2376                 return NT_STATUS_MEMBER_NOT_IN_GROUP;
2377         case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
2378                 return NT_STATUS_ACCESS_DENIED;
2379         default:
2380                 return NT_STATUS_UNSUCCESSFUL;
2381         }
2382 }
2383
2384
2385 /*
2386   samr_QueryGroupMember
2387 */
2388 static NTSTATUS dcesrv_samr_QueryGroupMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2389                                       struct samr_QueryGroupMember *r)
2390 {
2391         struct dcesrv_handle *h;
2392         struct samr_account_state *a_state;
2393         struct ldb_message **res;
2394         struct ldb_message_element *el;
2395         struct samr_RidTypeArray *array;
2396         const char * const attrs[2] = { "member", NULL };
2397         int ret;
2398
2399         DCESRV_PULL_HANDLE(h, r->in.group_handle, SAMR_HANDLE_GROUP);
2400
2401         a_state = h->data;
2402
2403         /* pull the member attribute */
2404         ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2405                               a_state->account_dn, &res, attrs);
2406
2407         if (ret != 1) {
2408                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2409         }
2410
2411         array = talloc(mem_ctx, struct samr_RidTypeArray);
2412
2413         if (array == NULL)
2414                 return NT_STATUS_NO_MEMORY;
2415
2416         ZERO_STRUCTP(array);
2417
2418         el = ldb_msg_find_element(res[0], "member");
2419
2420         if (el != NULL) {
2421                 int i;
2422
2423                 array->count = el->num_values;
2424
2425                 array->rids = talloc_array(mem_ctx, uint32_t,
2426                                              el->num_values);
2427                 if (array->rids == NULL)
2428                         return NT_STATUS_NO_MEMORY;
2429
2430                 array->types = talloc_array(mem_ctx, uint32_t,
2431                                             el->num_values);
2432                 if (array->types == NULL)
2433                         return NT_STATUS_NO_MEMORY;
2434
2435                 for (i=0; i<el->num_values; i++) {
2436                         struct ldb_message **res2;
2437                         const char * const attrs2[2] = { "objectSid", NULL };
2438                         ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2439                                            ldb_dn_from_ldb_val(mem_ctx, a_state->sam_ctx, &el->values[i]),
2440                                            &res2, attrs2);
2441                         if (ret != 1)
2442                                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2443
2444                         array->rids[i] =
2445                                 samdb_result_rid_from_sid(mem_ctx, res2[0],
2446                                                           "objectSid", 0);
2447
2448                         if (array->rids[i] == 0)
2449                                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2450
2451                         array->types[i] = 7; /* RID type of some kind, not sure what the value means. */
2452                 }
2453         }
2454
2455         *r->out.rids = array;
2456
2457         return NT_STATUS_OK;
2458 }
2459
2460
2461 /*
2462   samr_SetMemberAttributesOfGroup
2463 */
2464 static NTSTATUS dcesrv_samr_SetMemberAttributesOfGroup(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2465                        struct samr_SetMemberAttributesOfGroup *r)
2466 {
2467         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2468 }
2469
2470
2471 /*
2472   samr_OpenAlias
2473 */
2474 static NTSTATUS dcesrv_samr_OpenAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2475                        struct samr_OpenAlias *r)
2476 {
2477         struct samr_domain_state *d_state;
2478         struct samr_account_state *a_state;
2479         struct dcesrv_handle *h;
2480         const char *alias_name;
2481         struct dom_sid *sid;
2482         struct ldb_message **msgs;
2483         struct dcesrv_handle *g_handle;
2484         const char * const attrs[2] = { "sAMAccountName", NULL };
2485         int ret;
2486
2487         ZERO_STRUCTP(r->out.alias_handle);
2488
2489         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
2490
2491         d_state = h->data;
2492
2493         /* form the alias SID */
2494         sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2495         if (sid == NULL)
2496                 return NT_STATUS_NO_MEMORY;
2497
2498         /* search for the group record */
2499         ret = gendb_search(d_state->sam_ctx,
2500                            mem_ctx, d_state->domain_dn, &msgs, attrs,
2501                            "(&(objectSid=%s)(objectclass=group)"
2502                            "(|(grouptype=%d)(grouptype=%d)))",
2503                            ldap_encode_ndr_dom_sid(mem_ctx, sid),
2504                            GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
2505                            GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
2506         if (ret == 0) {
2507                 return NT_STATUS_NO_SUCH_ALIAS;
2508         }
2509         if (ret != 1) {
2510                 DEBUG(0,("Found %d records matching sid %s\n",
2511                          ret, dom_sid_string(mem_ctx, sid)));
2512                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2513         }
2514
2515         alias_name = samdb_result_string(msgs[0], "sAMAccountName", NULL);
2516         if (alias_name == NULL) {
2517                 DEBUG(0,("sAMAccountName field missing for sid %s\n",
2518                          dom_sid_string(mem_ctx, sid)));
2519                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2520         }
2521
2522         a_state = talloc(d_state, struct samr_account_state);
2523         if (!a_state) {
2524                 return NT_STATUS_NO_MEMORY;
2525         }
2526         a_state->sam_ctx = d_state->sam_ctx;
2527         a_state->access_mask = r->in.access_mask;
2528         a_state->domain_state = talloc_reference(a_state, d_state);
2529         a_state->account_dn = talloc_steal(a_state, msgs[0]->dn);
2530         a_state->account_sid = talloc_steal(a_state, sid);
2531         a_state->account_name = talloc_strdup(a_state, alias_name);
2532         if (!a_state->account_name) {
2533                 return NT_STATUS_NO_MEMORY;
2534         }
2535
2536         /* create the policy handle */
2537         g_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_ALIAS);
2538         if (!g_handle) {
2539                 return NT_STATUS_NO_MEMORY;
2540         }
2541
2542         g_handle->data = talloc_steal(g_handle, a_state);
2543
2544         *r->out.alias_handle = g_handle->wire_handle;
2545
2546         return NT_STATUS_OK;
2547 }
2548
2549
2550 /*
2551   samr_QueryAliasInfo
2552 */
2553 static NTSTATUS dcesrv_samr_QueryAliasInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2554                        struct samr_QueryAliasInfo *r)
2555 {
2556         struct dcesrv_handle *h;
2557         struct samr_account_state *a_state;
2558         struct ldb_message *msg, **res;
2559         const char * const attrs[4] = { "sAMAccountName", "description",
2560                                         "numMembers", NULL };
2561         int ret;
2562         union samr_AliasInfo *info;
2563
2564         *r->out.info = NULL;
2565
2566         DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2567
2568         a_state = h->data;
2569
2570         /* pull all the alias attributes */
2571         ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2572                               a_state->account_dn ,&res, attrs);
2573         if (ret != 1) {
2574                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2575         }
2576         msg = res[0];
2577
2578         /* allocate the info structure */
2579         info = talloc_zero(mem_ctx, union samr_AliasInfo);
2580         if (info == NULL) {
2581                 return NT_STATUS_NO_MEMORY;
2582         }
2583
2584         switch(r->in.level) {
2585         case ALIASINFOALL:
2586                 QUERY_STRING(msg, all.name, "sAMAccountName");
2587                 QUERY_UINT  (msg, all.num_members, "numMembers");
2588                 QUERY_STRING(msg, all.description, "description");
2589                 break;
2590         case ALIASINFONAME:
2591                 QUERY_STRING(msg, name, "sAMAccountName");
2592                 break;
2593         case ALIASINFODESCRIPTION:
2594                 QUERY_STRING(msg, description, "description");
2595                 break;
2596         default:
2597                 talloc_free(info);
2598                 return NT_STATUS_INVALID_INFO_CLASS;
2599         }
2600
2601         *r->out.info = info;
2602
2603         return NT_STATUS_OK;
2604 }
2605
2606
2607 /*
2608   samr_SetAliasInfo
2609 */
2610 static NTSTATUS dcesrv_samr_SetAliasInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2611                        struct samr_SetAliasInfo *r)
2612 {
2613         struct dcesrv_handle *h;
2614         struct samr_account_state *a_state;
2615         struct ldb_message *msg;
2616         struct ldb_context *sam_ctx;
2617         int ret;
2618
2619         DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2620
2621         a_state = h->data;
2622         sam_ctx = a_state->sam_ctx;
2623
2624         msg = ldb_msg_new(mem_ctx);
2625         if (msg == NULL) {
2626                 return NT_STATUS_NO_MEMORY;
2627         }
2628
2629         msg->dn = ldb_dn_copy(mem_ctx, a_state->account_dn);
2630         if (!msg->dn) {
2631                 return NT_STATUS_NO_MEMORY;
2632         }
2633
2634         switch (r->in.level) {
2635         case ALIASINFODESCRIPTION:
2636                 SET_STRING(msg, description,         "description");
2637                 break;
2638         case ALIASINFONAME:
2639                 /* On W2k3 this does not change the name, it changes the
2640                  * sAMAccountName attribute */
2641                 SET_STRING(msg, name,                "sAMAccountName");
2642                 break;
2643         default:
2644                 return NT_STATUS_INVALID_INFO_CLASS;
2645         }
2646
2647         /* modify the samdb record */
2648         ret = ldb_modify(a_state->sam_ctx, msg);
2649         if (ret != LDB_SUCCESS) {
2650                 /* we really need samdb.c to return NTSTATUS */
2651                 return NT_STATUS_UNSUCCESSFUL;
2652         }
2653
2654         return NT_STATUS_OK;
2655 }
2656
2657
2658 /*
2659   samr_DeleteDomAlias
2660 */
2661 static NTSTATUS dcesrv_samr_DeleteDomAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2662                        struct samr_DeleteDomAlias *r)
2663 {
2664         struct dcesrv_handle *h;
2665         struct samr_account_state *a_state;
2666         int ret;
2667
2668         *r->out.alias_handle = *r->in.alias_handle;
2669
2670         DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2671
2672         a_state = h->data;
2673
2674         ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
2675         if (ret != 0) {
2676                 return NT_STATUS_UNSUCCESSFUL;
2677         }
2678
2679         ZERO_STRUCTP(r->out.alias_handle);
2680
2681         return NT_STATUS_OK;
2682 }
2683
2684
2685 /*
2686   samr_AddAliasMember
2687 */
2688 static NTSTATUS dcesrv_samr_AddAliasMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2689                        struct samr_AddAliasMember *r)
2690 {
2691         struct dcesrv_handle *h;
2692         struct samr_account_state *a_state;
2693         struct samr_domain_state *d_state;
2694         struct ldb_message *mod;
2695         struct ldb_message **msgs;
2696         const char * const attrs[] = { NULL };
2697         struct ldb_dn *memberdn = NULL;
2698         int ret;
2699         NTSTATUS status;
2700
2701         DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2702
2703         a_state = h->data;
2704         d_state = a_state->domain_state;
2705
2706         ret = gendb_search(d_state->sam_ctx, mem_ctx, NULL,
2707                            &msgs, attrs, "(objectsid=%s)",
2708                            ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
2709
2710         if (ret == 1) {
2711                 memberdn = msgs[0]->dn;
2712         } else  if (ret > 1) {
2713                 DEBUG(0,("Found %d records matching sid %s\n",
2714                          ret, dom_sid_string(mem_ctx, r->in.sid)));
2715                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2716         } else if (ret == 0) {
2717                 status = samdb_create_foreign_security_principal(
2718                         d_state->sam_ctx, mem_ctx, r->in.sid, &memberdn);
2719                 if (!NT_STATUS_IS_OK(status)) {
2720                         return status;
2721                 }
2722         } else {
2723                 DEBUG(0, ("samdb_search returned %d: %s\n", ret, ldb_errstring(d_state->sam_ctx)));
2724         }
2725
2726         if (memberdn == NULL) {
2727                 DEBUG(0, ("Could not find memberdn\n"));
2728                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2729         }
2730
2731         mod = ldb_msg_new(mem_ctx);
2732         if (mod == NULL) {
2733                 return NT_STATUS_NO_MEMORY;
2734         }
2735
2736         mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2737
2738         ret = samdb_msg_add_addval(d_state->sam_ctx, mem_ctx, mod, "member",
2739                                  ldb_dn_alloc_linearized(mem_ctx, memberdn));
2740         if (ret != LDB_SUCCESS) {
2741                 return NT_STATUS_UNSUCCESSFUL;
2742         }
2743
2744         if (ldb_modify(a_state->sam_ctx, mod) != LDB_SUCCESS) {
2745                 return NT_STATUS_UNSUCCESSFUL;
2746         }
2747
2748         return NT_STATUS_OK;
2749 }
2750
2751
2752 /*
2753   samr_DeleteAliasMember
2754 */
2755 static NTSTATUS dcesrv_samr_DeleteAliasMember(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2756                        struct samr_DeleteAliasMember *r)
2757 {
2758         struct dcesrv_handle *h;
2759         struct samr_account_state *a_state;
2760         struct samr_domain_state *d_state;
2761         struct ldb_message *mod;
2762         const char *memberdn;
2763         int ret;
2764
2765         DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2766
2767         a_state = h->data;
2768         d_state = a_state->domain_state;
2769
2770         memberdn = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
2771                                        "distinguishedName", "(objectSid=%s)",
2772                                        ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
2773
2774         if (memberdn == NULL)
2775                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2776
2777         mod = ldb_msg_new(mem_ctx);
2778         if (mod == NULL) {
2779                 return NT_STATUS_NO_MEMORY;
2780         }
2781
2782         mod->dn = talloc_reference(mem_ctx, a_state->account_dn);
2783
2784         ret = samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod, "member",
2785                                                                  memberdn);
2786         if (ret != LDB_SUCCESS)
2787                 return NT_STATUS_UNSUCCESSFUL;
2788
2789         if (ldb_modify(a_state->sam_ctx, mod) != LDB_SUCCESS)
2790                 return NT_STATUS_UNSUCCESSFUL;
2791
2792         return NT_STATUS_OK;
2793 }
2794
2795
2796 /*
2797   samr_GetMembersInAlias
2798 */
2799 static NTSTATUS dcesrv_samr_GetMembersInAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2800                        struct samr_GetMembersInAlias *r)
2801 {
2802         struct dcesrv_handle *h;
2803         struct samr_account_state *a_state;
2804         struct samr_domain_state *d_state;
2805         struct ldb_message **msgs;
2806         struct lsa_SidPtr *sids;
2807         struct ldb_message_element *el;
2808         const char * const attrs[2] = { "member", NULL};
2809         int ret;
2810
2811         DCESRV_PULL_HANDLE(h, r->in.alias_handle, SAMR_HANDLE_ALIAS);
2812
2813         a_state = h->data;
2814         d_state = a_state->domain_state;
2815
2816         ret = gendb_search_dn(d_state->sam_ctx, mem_ctx,
2817                               a_state->account_dn, &msgs, attrs);
2818
2819         if (ret == -1) {
2820                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2821         } else if (ret == 0) {
2822                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2823         } else if (ret != 1) {
2824                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2825         }
2826
2827         r->out.sids->num_sids = 0;
2828         r->out.sids->sids = NULL;
2829
2830         el = ldb_msg_find_element(msgs[0], "member");
2831
2832         if (el != NULL) {
2833                 int i;
2834
2835                 sids = talloc_array(mem_ctx, struct lsa_SidPtr,
2836                                       el->num_values);
2837
2838                 if (sids == NULL)
2839                         return NT_STATUS_NO_MEMORY;
2840
2841                 for (i=0; i<el->num_values; i++) {
2842                         struct ldb_message **msgs2;
2843                         const char * const attrs2[2] = { "objectSid", NULL };
2844                         ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
2845                                               ldb_dn_from_ldb_val(mem_ctx, a_state->sam_ctx, &el->values[i]),
2846                                               &msgs2, attrs2);
2847                         if (ret != 1)
2848                                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2849
2850                         sids[i].sid = samdb_result_dom_sid(mem_ctx, msgs2[0],
2851                                                            "objectSid");
2852
2853                         if (sids[i].sid == NULL)
2854                                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2855                 }
2856                 r->out.sids->num_sids = el->num_values;
2857                 r->out.sids->sids = sids;
2858         }
2859
2860         return NT_STATUS_OK;
2861 }
2862
2863 /*
2864   samr_OpenUser
2865 */
2866 static NTSTATUS dcesrv_samr_OpenUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2867                               struct samr_OpenUser *r)
2868 {
2869         struct samr_domain_state *d_state;
2870         struct samr_account_state *a_state;
2871         struct dcesrv_handle *h;
2872         const char *account_name;
2873         struct dom_sid *sid;
2874         struct ldb_message **msgs;
2875         struct dcesrv_handle *u_handle;
2876         const char * const attrs[2] = { "sAMAccountName", NULL };
2877         int ret;
2878
2879         ZERO_STRUCTP(r->out.user_handle);
2880
2881         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
2882
2883         d_state = h->data;
2884
2885         /* form the users SID */
2886         sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
2887         if (!sid) {
2888                 return NT_STATUS_NO_MEMORY;
2889         }
2890
2891         /* search for the user record */
2892         ret = gendb_search(d_state->sam_ctx,
2893                            mem_ctx, d_state->domain_dn, &msgs, attrs,
2894                            "(&(objectSid=%s)(objectclass=user))",
2895                            ldap_encode_ndr_dom_sid(mem_ctx, sid));
2896         if (ret == 0) {
2897                 return NT_STATUS_NO_SUCH_USER;
2898         }
2899         if (ret != 1) {
2900                 DEBUG(0,("Found %d records matching sid %s\n", ret,
2901                          dom_sid_string(mem_ctx, sid)));
2902                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2903         }
2904
2905         account_name = samdb_result_string(msgs[0], "sAMAccountName", NULL);
2906         if (account_name == NULL) {
2907                 DEBUG(0,("sAMAccountName field missing for sid %s\n",
2908                          dom_sid_string(mem_ctx, sid)));
2909                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2910         }
2911
2912         a_state = talloc(mem_ctx, struct samr_account_state);
2913         if (!a_state) {
2914                 return NT_STATUS_NO_MEMORY;
2915         }
2916         a_state->sam_ctx = d_state->sam_ctx;
2917         a_state->access_mask = r->in.access_mask;
2918         a_state->domain_state = talloc_reference(a_state, d_state);
2919         a_state->account_dn = talloc_steal(a_state, msgs[0]->dn);
2920         a_state->account_sid = talloc_steal(a_state, sid);
2921         a_state->account_name = talloc_strdup(a_state, account_name);
2922         if (!a_state->account_name) {
2923                 return NT_STATUS_NO_MEMORY;
2924         }
2925
2926         /* create the policy handle */
2927         u_handle = dcesrv_handle_new(dce_call->context, SAMR_HANDLE_USER);
2928         if (!u_handle) {
2929                 return NT_STATUS_NO_MEMORY;
2930         }
2931
2932         u_handle->data = talloc_steal(u_handle, a_state);
2933
2934         *r->out.user_handle = u_handle->wire_handle;
2935
2936         return NT_STATUS_OK;
2937
2938 }
2939
2940
2941 /*
2942   samr_DeleteUser
2943 */
2944 static NTSTATUS dcesrv_samr_DeleteUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2945                                 struct samr_DeleteUser *r)
2946 {
2947         struct dcesrv_handle *h;
2948         struct samr_account_state *a_state;
2949         int ret;
2950
2951         *r->out.user_handle = *r->in.user_handle;
2952
2953         DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
2954
2955         a_state = h->data;
2956
2957         ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
2958         if (ret != LDB_SUCCESS) {
2959                 DEBUG(1, ("Failed to delete user: %s: %s\n",
2960                           ldb_dn_get_linearized(a_state->account_dn),
2961                           ldb_errstring(a_state->sam_ctx)));
2962                 return NT_STATUS_UNSUCCESSFUL;
2963         }
2964
2965         ZERO_STRUCTP(r->out.user_handle);
2966
2967         return NT_STATUS_OK;
2968 }
2969
2970
2971 /*
2972   samr_QueryUserInfo
2973 */
2974 static NTSTATUS dcesrv_samr_QueryUserInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2975                                    struct samr_QueryUserInfo *r)
2976 {
2977         struct dcesrv_handle *h;
2978         struct samr_account_state *a_state;
2979         struct ldb_message *msg, **res;
2980         int ret;
2981         struct ldb_context *sam_ctx;
2982
2983         const char * const *attrs = NULL;
2984         union samr_UserInfo *info;
2985
2986         *r->out.info = NULL;
2987
2988         DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
2989
2990         a_state = h->data;
2991         sam_ctx = a_state->sam_ctx;
2992
2993         /* fill in the reply */
2994         switch (r->in.level) {
2995         case 1:
2996         {
2997                 static const char * const attrs2[] = {"sAMAccountName",
2998                                                       "displayName",
2999                                                       "primaryroupID",
3000                                                       "description",
3001                                                       "comment",
3002                                                       NULL};
3003                 attrs = attrs2;
3004                 break;
3005         }
3006         case 2:
3007         {
3008                 static const char * const attrs2[] = {"comment",
3009                                                       "countryCode",
3010                                                       "codePage",
3011                                                       NULL};
3012                 attrs = attrs2;
3013                 break;
3014         }
3015         case 3:
3016         {
3017                 static const char * const attrs2[] = {"sAMAccountName",
3018                                                       "displayName",
3019                                                       "objectSid",
3020                                                       "primaryGroupID",
3021                                                       "homeDirectory",
3022                                                       "homeDrive",
3023                                                       "scriptPath",
3024                                                       "profilePath",
3025                                                       "userWorkstations",
3026                                                       "lastLogon",
3027                                                       "lastLogoff",
3028                                                       "pwdLastSet",
3029                                                       "logonHours",
3030                                                       "badPwdCount",
3031                                                       "logonCount",
3032                                                       "userAccountControl",
3033                                                       NULL};
3034                 attrs = attrs2;
3035                 break;
3036         }
3037         case 4:
3038         {
3039                 static const char * const attrs2[] = {"logonHours",
3040                                                       NULL};
3041                 attrs = attrs2;
3042                 break;
3043         }
3044         case 5:
3045         {
3046                 static const char * const attrs2[] = {"sAMAccountName",
3047                                                       "displayName",
3048                                                       "objectSid",
3049                                                       "primaryGroupID",
3050                                                       "homeDirectory",
3051                                                       "homeDrive",
3052                                                       "scriptPath",
3053                                                       "profilePath",
3054                                                       "description",
3055                                                       "userWorkstations",
3056                                                       "lastLogon",
3057                                                       "lastLogoff",
3058                                                       "logonHours",
3059                                                       "badPwdCount",
3060                                                       "logonCount",
3061                                                       "pwdLastSet",
3062                                                       "accountExpires",
3063                                                       "userAccountControl",
3064                                                       NULL};
3065                 attrs = attrs2;
3066                 break;
3067         }
3068         case 6:
3069         {
3070                 static const char * const attrs2[] = {"sAMAccountName",
3071                                                       "displayName",
3072                                                       NULL};
3073                 attrs = attrs2;
3074                 break;
3075         }
3076         case 7:
3077         {
3078                 static const char * const attrs2[] = {"sAMAccountName",
3079                                                       NULL};
3080                 attrs = attrs2;
3081                 break;
3082         }
3083         case 8:
3084         {
3085                 static const char * const attrs2[] = {"displayName",
3086                                                       NULL};
3087                 attrs = attrs2;
3088                 break;
3089         }
3090         case 9:
3091         {
3092                 static const char * const attrs2[] = {"primaryGroupID",
3093                                                       NULL};
3094                 attrs = attrs2;
3095                 break;
3096         }
3097         case 10:
3098         {
3099                 static const char * const attrs2[] = {"homeDirectory",
3100                                                       "homeDrive",
3101                                                       NULL};
3102                 attrs = attrs2;
3103                 break;
3104         }
3105         case 11:
3106         {
3107                 static const char * const attrs2[] = {"scriptPath",
3108                                                       NULL};
3109                 attrs = attrs2;
3110                 break;
3111         }
3112         case 12:
3113         {
3114                 static const char * const attrs2[] = {"profilePath",
3115                                                       NULL};
3116                 attrs = attrs2;
3117                 break;
3118         }
3119         case 13:
3120         {
3121                 static const char * const attrs2[] = {"description",
3122                                                       NULL};
3123                 attrs = attrs2;
3124                 break;
3125         }
3126         case 14:
3127         {
3128                 static const char * const attrs2[] = {"userWorkstations",
3129                                                       NULL};
3130                 attrs = attrs2;
3131                 break;
3132         }
3133         case 16:
3134         {
3135                 static const char * const attrs2[] = {"userAccountControl",
3136                                                       "pwdLastSet",
3137                                                       NULL};
3138                 attrs = attrs2;
3139                 break;
3140         }
3141         case 17:
3142         {
3143                 static const char * const attrs2[] = {"accountExpires",
3144                                                       NULL};
3145                 attrs = attrs2;
3146                 break;
3147         }
3148         case 20:
3149         {
3150                 static const char * const attrs2[] = {"userParameters",
3151                                                       NULL};
3152                 attrs = attrs2;
3153                 break;
3154         }
3155         case 21:
3156         {
3157                 static const char * const attrs2[] = {"lastLogon",
3158                                                       "lastLogoff",
3159                                                       "pwdLastSet",
3160                                                       "accountExpires",
3161                                                       "sAMAccountName",
3162                                                       "displayName",
3163                                                       "homeDirectory",
3164                                                       "homeDrive",
3165                                                       "scriptPath",
3166                                                       "profilePath",
3167                                                       "description",
3168                                                       "userWorkstations",
3169                                                       "comment",
3170                                                       "userParameters",
3171                                                       "objectSid",
3172                                                       "primaryGroupID",
3173                                                       "userAccountControl",
3174                                                       "logonHours",
3175                                                       "badPwdCount",
3176                                                       "logonCount",
3177                                                       "countryCode",
3178                                                       "codePage",
3179                                                       NULL};
3180                 attrs = attrs2;
3181                 break;
3182         }
3183         }
3184
3185         /* pull all the user attributes */
3186         ret = gendb_search_dn(a_state->sam_ctx, mem_ctx,
3187                               a_state->account_dn ,&res, attrs);
3188         if (ret != 1) {
3189                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
3190         }
3191         msg = res[0];
3192
3193         /* allocate the info structure */
3194         info = talloc_zero(mem_ctx, union samr_UserInfo);
3195         if (info == NULL) {
3196                 return NT_STATUS_NO_MEMORY;
3197         }
3198
3199         /* fill in the reply */
3200         switch (r->in.level) {
3201         case 1:
3202                 QUERY_STRING(msg, info1.account_name,          "sAMAccountName");
3203                 QUERY_STRING(msg, info1.full_name,             "displayName");
3204                 QUERY_UINT  (msg, info1.primary_gid,           "primaryGroupID");
3205                 QUERY_STRING(msg, info1.description,           "description");
3206                 QUERY_STRING(msg, info1.comment,               "comment");
3207                 break;
3208
3209         case 2:
3210                 QUERY_STRING(msg, info2.comment,               "comment");
3211                 QUERY_UINT  (msg, info2.country_code,          "countryCode");
3212                 QUERY_UINT  (msg, info2.code_page,             "codePage");
3213                 break;
3214
3215         case 3:
3216                 QUERY_STRING(msg, info3.account_name,          "sAMAccountName");
3217                 QUERY_STRING(msg, info3.full_name,             "displayName");
3218                 QUERY_RID   (msg, info3.rid,                   "objectSid");
3219                 QUERY_UINT  (msg, info3.primary_gid,           "primaryGroupID");
3220                 QUERY_STRING(msg, info3.home_directory,        "homeDirectory");
3221                 QUERY_STRING(msg, info3.home_drive,            "homeDrive");
3222                 QUERY_STRING(msg, info3.logon_script,          "scriptPath");
3223                 QUERY_STRING(msg, info3.profile_path,          "profilePath");
3224                 QUERY_STRING(msg, info3.workstations,          "userWorkstations");
3225                 QUERY_UINT64(msg, info3.last_logon,            "lastLogon");
3226                 QUERY_UINT64(msg, info3.last_logoff,           "lastLogoff");
3227                 QUERY_UINT64(msg, info3.last_password_change,  "pwdLastSet");
3228                 QUERY_APASSC(msg, info3.allow_password_change, "pwdLastSet");
3229                 QUERY_FPASSC(msg, info3.force_password_change, "pwdLastSet");
3230                 QUERY_LHOURS(msg, info3.logon_hours,           "logonHours");
3231                 QUERY_UINT  (msg, info3.bad_password_count,    "badPwdCount");
3232                 QUERY_UINT  (msg, info3.logon_count,           "logonCount");
3233                 QUERY_AFLAGS(msg, info3.acct_flags,            "userAccountControl");
3234                 break;
3235
3236         case 4:
3237                 QUERY_LHOURS(msg, info4.logon_hours,           "logonHours");
3238                 break;
3239
3240         case 5:
3241                 QUERY_STRING(msg, info5.account_name,          "sAMAccountName");
3242                 QUERY_STRING(msg, info5.full_name,             "displayName");
3243                 QUERY_RID   (msg, info5.rid,                   "objectSid");
3244                 QUERY_UINT  (msg, info5.primary_gid,           "primaryGroupID");
3245                 QUERY_STRING(msg, info5.home_directory,        "homeDirectory");
3246                 QUERY_STRING(msg, info5.home_drive,            "homeDrive");
3247                 QUERY_STRING(msg, info5.logon_script,          "scriptPath");
3248                 QUERY_STRING(msg, info5.profile_path,          "profilePath");
3249                 QUERY_STRING(msg, info5.description,           "description");
3250                 QUERY_STRING(msg, info5.workstations,          "userWorkstations");
3251                 QUERY_UINT64(msg, info5.last_logon,            "lastLogon");
3252                 QUERY_UINT64(msg, info5.last_logoff,           "lastLogoff");
3253                 QUERY_LHOURS(msg, info5.logon_hours,           "logonHours");
3254                 QUERY_UINT  (msg, info5.bad_password_count,    "badPwdCount");
3255                 QUERY_UINT  (msg, info5.logon_count,           "logonCount");
3256                 QUERY_UINT64(msg, info5.last_password_change,  "pwdLastSet");
3257                 QUERY_UINT64(msg, info5.acct_expiry,           "accountExpires");
3258                 QUERY_AFLAGS(msg, info5.acct_flags,            "userAccountControl");
3259                 break;
3260
3261         case 6:
3262                 QUERY_STRING(msg, info6.account_name,   "sAMAccountName");
3263                 QUERY_STRING(msg, info6.full_name,      "displayName");
3264                 break;
3265
3266         case 7:
3267                 QUERY_STRING(msg, info7.account_name,   "sAMAccountName");
3268                 break;
3269
3270         case 8:
3271                 QUERY_STRING(msg, info8.full_name,      "displayName");
3272                 break;
3273
3274         case 9:
3275                 QUERY_UINT  (msg, info9.primary_gid,    "primaryGroupID");
3276                 break;
3277
3278         case 10:
3279                 QUERY_STRING(msg, info10.home_directory,"homeDirectory");
3280                 QUERY_STRING(msg, info10.home_drive,    "homeDrive");
3281                 break;
3282
3283         case 11:
3284                 QUERY_STRING(msg, info11.logon_script,  "scriptPath");
3285                 break;
3286
3287         case 12:
3288                 QUERY_STRING(msg, info12.profile_path,  "profilePath");
3289                 break;
3290
3291         case 13:
3292                 QUERY_STRING(msg, info13.description,   "description");
3293                 break;
3294
3295         case 14:
3296                 QUERY_STRING(msg, info14.workstations,  "userWorkstations");
3297                 break;
3298
3299         case 16:
3300                 QUERY_AFLAGS(msg, info16.acct_flags,    "userAccountControl");
3301                 break;
3302
3303         case 17:
3304                 QUERY_UINT64(msg, info17.acct_expiry,   "accountExpires");
3305                 break;
3306
3307         case 20:
3308                 QUERY_PARAMETERS(msg, info20.parameters,    "userParameters");
3309                 break;
3310
3311         case 21:
3312                 QUERY_UINT64(msg, info21.last_logon,           "lastLogon");
3313                 QUERY_UINT64(msg, info21.last_logoff,          "lastLogoff");
3314                 QUERY_UINT64(msg, info21.last_password_change, "pwdLastSet");
3315                 QUERY_UINT64(msg, info21.acct_expiry,          "accountExpires");
3316                 QUERY_APASSC(msg, info21.allow_password_change,"pwdLastSet");
3317                 QUERY_FPASSC(msg, info21.force_password_change,"pwdLastSet");
3318                 QUERY_STRING(msg, info21.account_name,         "sAMAccountName");
3319                 QUERY_STRING(msg, info21.full_name,            "displayName");
3320                 QUERY_STRING(msg, info21.home_directory,       "homeDirectory");
3321                 QUERY_STRING(msg, info21.home_drive,           "homeDrive");
3322                 QUERY_STRING(msg, info21.logon_script,         "scriptPath");
3323                 QUERY_STRING(msg, info21.profile_path,         "profilePath");
3324                 QUERY_STRING(msg, info21.description,          "description");
3325                 QUERY_STRING(msg, info21.workstations,         "userWorkstations");
3326                 QUERY_STRING(msg, info21.comment,              "comment");
3327                 QUERY_PARAMETERS(msg, info21.parameters,       "userParameters");
3328                 QUERY_RID   (msg, info21.rid,                  "objectSid");
3329                 QUERY_UINT  (msg, info21.primary_gid,          "primaryGroupID");
3330                 QUERY_AFLAGS(msg, info21.acct_flags,           "userAccountControl");
3331                 info->info21.fields_present = 0x00FFFFFF;
3332                 QUERY_LHOURS(msg, info21.logon_hours,          "logonHours");
3333                 QUERY_UINT  (msg, info21.bad_password_count,   "badPwdCount");
3334                 QUERY_UINT  (msg, info21.logon_count,          "logonCount");
3335                 QUERY_UINT  (msg, info21.country_code,         "countryCode");
3336                 QUERY_UINT  (msg, info21.code_page,            "codePage");
3337                 break;
3338
3339
3340         default:
3341                 talloc_free(info);
3342                 return NT_STATUS_INVALID_INFO_CLASS;
3343         }
3344
3345         *r->out.info = info;
3346
3347         return NT_STATUS_OK;
3348 }
3349
3350
3351 /*
3352   samr_SetUserInfo
3353 */
3354 static NTSTATUS dcesrv_samr_SetUserInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3355                                  struct samr_SetUserInfo *r)
3356 {
3357         struct dcesrv_handle *h;
3358         struct samr_account_state *a_state;
3359         struct ldb_message *msg;
3360         int ret;
3361         NTSTATUS status = NT_STATUS_OK;
3362         struct ldb_context *sam_ctx;
3363
3364         DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
3365
3366         a_state = h->data;
3367         sam_ctx = a_state->sam_ctx;
3368
3369         msg = ldb_msg_new(mem_ctx);
3370         if (msg == NULL) {
3371                 return NT_STATUS_NO_MEMORY;
3372         }
3373
3374         msg->dn = talloc_reference(mem_ctx, a_state->account_dn);
3375         if (!msg->dn) {
3376                 return NT_STATUS_NO_MEMORY;
3377         }
3378
3379         switch (r->in.level) {
3380         case 2:
3381                 SET_STRING(msg, info2.comment,          "comment");
3382                 SET_UINT  (msg, info2.country_code,     "countryCode");
3383                 SET_UINT  (msg, info2.code_page,        "codePage");
3384                 break;
3385
3386         case 4:
3387                 SET_LHOURS(msg, info4.logon_hours,      "logonHours");
3388                 break;
3389
3390         case 6:
3391                 SET_STRING(msg, info6.account_name,     "samAccountName");
3392                 SET_STRING(msg, info6.full_name,        "displayName");
3393                 break;
3394
3395         case 7:
3396                 SET_STRING(msg, info7.account_name,     "samAccountName");
3397                 break;
3398
3399         case 8:
3400                 SET_STRING(msg, info8.full_name,        "displayName");
3401                 break;
3402
3403         case 9:
3404                 SET_UINT(msg, info9.primary_gid,        "primaryGroupID");
3405                 break;
3406
3407         case 10:
3408                 SET_STRING(msg, info10.home_directory,  "homeDirectory");
3409                 SET_STRING(msg, info10.home_drive,      "homeDrive");
3410                 break;
3411
3412         case 11:
3413                 SET_STRING(msg, info11.logon_script,    "scriptPath");
3414                 break;
3415
3416         case 12:
3417                 SET_STRING(msg, info12.profile_path,    "profilePath");
3418                 break;
3419
3420         case 13:
3421                 SET_STRING(msg, info13.description,     "description");
3422                 break;
3423
3424         case 14:
3425                 SET_STRING(msg, info14.workstations,    "userWorkstations");
3426                 break;
3427
3428         case 16:
3429                 SET_AFLAGS(msg, info16.acct_flags,      "userAccountControl");
3430                 break;
3431
3432         case 17:
3433                 SET_UINT64(msg, info17.acct_expiry,     "accountExpires");
3434                 break;
3435
3436         case 20:
3437                 SET_PARAMETERS(msg, info20.parameters,      "userParameters");
3438                 break;
3439
3440         case 21:
3441 #define IFSET(bit) if (bit & r->in.info->info21.fields_present)
3442                 IFSET(SAMR_FIELD_ACCT_EXPIRY)
3443                         SET_UINT64(msg, info21.acct_expiry,    "accountExpires");
3444                 IFSET(SAMR_FIELD_ACCOUNT_NAME)
3445                         SET_STRING(msg, info21.account_name,   "samAccountName");
3446                 IFSET(SAMR_FIELD_FULL_NAME)
3447                         SET_STRING(msg, info21.full_name,      "displayName");
3448                 IFSET(SAMR_FIELD_HOME_DIRECTORY)
3449                         SET_STRING(msg, info21.home_directory, "homeDirectory");
3450                 IFSET(SAMR_FIELD_HOME_DRIVE)
3451                         SET_STRING(msg, info21.home_drive,     "homeDrive");
3452                 IFSET(SAMR_FIELD_LOGON_SCRIPT)
3453                         SET_STRING(msg, info21.logon_script,   "scriptPath");
3454                 IFSET(SAMR_FIELD_PROFILE_PATH)
3455                         SET_STRING(msg, info21.profile_path,   "profilePath");
3456                 IFSET(SAMR_FIELD_DESCRIPTION)
3457                         SET_STRING(msg, info21.description,    "description");
3458                 IFSET(SAMR_FIELD_WORKSTATIONS)
3459                         SET_STRING(msg, info21.workstations,   "userWorkstations");
3460                 IFSET(SAMR_FIELD_COMMENT)
3461                         SET_STRING(msg, info21.comment,        "comment");
3462                 IFSET(SAMR_FIELD_PARAMETERS)
3463                         SET_PARAMETERS(msg, info21.parameters, "userParameters");
3464                 IFSET(SAMR_FIELD_PRIMARY_GID)
3465                         SET_UINT(msg, info21.primary_gid,      "primaryGroupID");
3466                 IFSET(SAMR_FIELD_ACCT_FLAGS)
3467                         SET_AFLAGS(msg, info21.acct_flags,     "userAccountControl");
3468                 IFSET(SAMR_FIELD_LOGON_HOURS)
3469                         SET_LHOURS(msg, info21.logon_hours,    "logonHours");
3470                 IFSET(SAMR_FIELD_COUNTRY_CODE)
3471                         SET_UINT  (msg, info21.country_code,   "countryCode");
3472                 IFSET(SAMR_FIELD_CODE_PAGE)
3473                         SET_UINT  (msg, info21.code_page,      "codePage");
3474 #undef IFSET
3475                 break;
3476
3477         case 23:
3478 #define IFSET(bit) if (bit & r->in.info->info23.info.fields_present)
3479                 IFSET(SAMR_FIELD_ACCT_EXPIRY)
3480                         SET_UINT64(msg, info23.info.acct_expiry,    "accountExpires");
3481                 IFSET(SAMR_FIELD_ACCOUNT_NAME)
3482                         SET_STRING(msg, info23.info.account_name,   "samAccountName");
3483                 IFSET(SAMR_FIELD_FULL_NAME)
3484                         SET_STRING(msg, info23.info.full_name,      "displayName");
3485                 IFSET(SAMR_FIELD_HOME_DIRECTORY)
3486                         SET_STRING(msg, info23.info.home_directory, "homeDirectory");
3487                 IFSET(SAMR_FIELD_HOME_DRIVE)
3488                         SET_STRING(msg, info23.info.home_drive,     "homeDrive");
3489                 IFSET(SAMR_FIELD_LOGON_SCRIPT)
3490                         SET_STRING(msg, info23.info.logon_script,   "scriptPath");
3491                 IFSET(SAMR_FIELD_PROFILE_PATH)
3492                         SET_STRING(msg, info23.info.profile_path,   "profilePath");
3493                 IFSET(SAMR_FIELD_DESCRIPTION)
3494                         SET_STRING(msg, info23.info.description,    "description");
3495                 IFSET(SAMR_FIELD_WORKSTATIONS)
3496                         SET_STRING(msg, info23.info.workstations,   "userWorkstations");
3497                 IFSET(SAMR_FIELD_COMMENT)
3498                         SET_STRING(msg, info23.info.comment,        "comment");
3499                 IFSET(SAMR_FIELD_PARAMETERS)
3500                         SET_PARAMETERS(msg, info23.info.parameters, "userParameters");
3501                 IFSET(SAMR_FIELD_PRIMARY_GID)
3502                         SET_UINT(msg, info23.info.primary_gid,      "primaryGroupID");
3503                 IFSET(SAMR_FIELD_ACCT_FLAGS)
3504                         SET_AFLAGS(msg, info23.info.acct_flags,     "userAccountControl");
3505                 IFSET(SAMR_FIELD_LOGON_HOURS)
3506                         SET_LHOURS(msg, info23.info.logon_hours,    "logonHours");
3507                 IFSET(SAMR_FIELD_COUNTRY_CODE)
3508                         SET_UINT  (msg, info23.info.country_code,   "countryCode");
3509                 IFSET(SAMR_FIELD_CODE_PAGE)
3510                         SET_UINT  (msg, info23.info.code_page,      "codePage");
3511
3512                 IFSET(SAMR_FIELD_NT_PASSWORD_PRESENT) {
3513                         status = samr_set_password(dce_call,
3514                                                    a_state->sam_ctx,
3515                                                    a_state->account_dn,
3516                                                    a_state->domain_state->domain_dn,
3517                                                    mem_ctx, msg,
3518                                                    &r->in.info->info23.password);
3519                 } else IFSET(SAMR_FIELD_LM_PASSWORD_PRESENT) {
3520                         status = samr_set_password(dce_call,
3521                                                    a_state->sam_ctx,
3522                                                    a_state->account_dn,
3523                                                    a_state->domain_state->domain_dn,
3524                                                    mem_ctx, msg,
3525                                                    &r->in.info->info23.password);
3526                 }
3527 #undef IFSET
3528                 break;
3529
3530                 /* the set password levels are handled separately */
3531         case 24:
3532                 status = samr_set_password(dce_call,
3533                                            a_state->sam_ctx,
3534                                            a_state->account_dn,
3535                                            a_state->domain_state->domain_dn,
3536                                            mem_ctx, msg,
3537                                            &r->in.info->info24.password);
3538                 break;
3539
3540         case 25:
3541 #define IFSET(bit) if (bit & r->in.info->info25.info.fields_present)
3542                 IFSET(SAMR_FIELD_ACCT_EXPIRY)
3543                         SET_UINT64(msg, info25.info.acct_expiry,    "accountExpires");
3544                 IFSET(SAMR_FIELD_ACCOUNT_NAME)
3545                         SET_STRING(msg, info25.info.account_name,   "samAccountName");
3546                 IFSET(SAMR_FIELD_FULL_NAME)
3547                         SET_STRING(msg, info25.info.full_name,      "displayName");
3548                 IFSET(SAMR_FIELD_HOME_DIRECTORY)
3549                         SET_STRING(msg, info25.info.home_directory, "homeDirectory");
3550                 IFSET(SAMR_FIELD_HOME_DRIVE)
3551                         SET_STRING(msg, info25.info.home_drive,     "homeDrive");
3552                 IFSET(SAMR_FIELD_LOGON_SCRIPT)
3553                         SET_STRING(msg, info25.info.logon_script,   "scriptPath");
3554                 IFSET(SAMR_FIELD_PROFILE_PATH)
3555                         SET_STRING(msg, info25.info.profile_path,   "profilePath");
3556                 IFSET(SAMR_FIELD_DESCRIPTION)
3557                         SET_STRING(msg, info25.info.description,    "description");
3558                 IFSET(SAMR_FIELD_WORKSTATIONS)
3559                         SET_STRING(msg, info25.info.workstations,   "userWorkstations");
3560                 IFSET(SAMR_FIELD_COMMENT)
3561                         SET_STRING(msg, info25.info.comment,        "comment");
3562                 IFSET(SAMR_FIELD_PARAMETERS)
3563                         SET_PARAMETERS(msg, info25.info.parameters, "userParameters");
3564                 IFSET(SAMR_FIELD_PRIMARY_GID)
3565                         SET_UINT(msg, info25.info.primary_gid,      "primaryGroupID");
3566                 IFSET(SAMR_FIELD_ACCT_FLAGS)
3567                         SET_AFLAGS(msg, info25.info.acct_flags,     "userAccountControl");
3568                 IFSET(SAMR_FIELD_LOGON_HOURS)
3569                         SET_LHOURS(msg, info25.info.logon_hours,    "logonHours");
3570                 IFSET(SAMR_FIELD_COUNTRY_CODE)
3571                         SET_UINT  (msg, info25.info.country_code,   "countryCode");
3572                 IFSET(SAMR_FIELD_CODE_PAGE)
3573                         SET_UINT  (msg, info25.info.code_page,      "codePage");
3574
3575                 IFSET(SAMR_FIELD_NT_PASSWORD_PRESENT) {
3576                         status = samr_set_password_ex(dce_call,
3577                                                       a_state->sam_ctx,
3578                                                       a_state->account_dn,
3579                                                       a_state->domain_state->domain_dn,
3580                                                       mem_ctx, msg,
3581                                                       &r->in.info->info25.password);
3582                 } else IFSET(SAMR_FIELD_LM_PASSWORD_PRESENT) {
3583                         status = samr_set_password_ex(dce_call,
3584                                                       a_state->sam_ctx,
3585                                                       a_state->account_dn,
3586                                                       a_state->domain_state->domain_dn,
3587                                                       mem_ctx, msg,
3588                                                       &r->in.info->info25.password);
3589                 }
3590 #undef IFSET
3591                 break;
3592
3593                 /* the set password levels are handled separately */
3594         case 26:
3595                 status = samr_set_password_ex(dce_call,
3596                                               a_state->sam_ctx,
3597                                               a_state->account_dn,
3598                                               a_state->domain_state->domain_dn,
3599                                               mem_ctx, msg,
3600                                               &r->in.info->info26.password);
3601                 break;
3602
3603
3604         default:
3605                 /* many info classes are not valid for SetUserInfo */
3606                 return NT_STATUS_INVALID_INFO_CLASS;
3607         }
3608
3609         if (!NT_STATUS_IS_OK(status)) {
3610                 return status;
3611         }
3612
3613         /* modify the samdb record */
3614         if (msg->num_elements > 0) {
3615                 ret = ldb_modify(a_state->sam_ctx, msg);
3616                 if (ret != LDB_SUCCESS) {
3617                         DEBUG(1,("Failed to modify record %s: %s\n",
3618                                  ldb_dn_get_linearized(a_state->account_dn),
3619                                  ldb_errstring(a_state->sam_ctx)));
3620
3621                         /* we really need samdb.c to return NTSTATUS */
3622                         return NT_STATUS_UNSUCCESSFUL;
3623                 }
3624         }
3625
3626         return NT_STATUS_OK;
3627 }
3628
3629
3630 /*
3631   samr_GetGroupsForUser
3632 */
3633 static NTSTATUS dcesrv_samr_GetGroupsForUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3634                        struct samr_GetGroupsForUser *r)
3635 {
3636         struct dcesrv_handle *h;
3637         struct samr_account_state *a_state;
3638         struct samr_domain_state *d_state;
3639         struct ldb_message **res;
3640         const char * const attrs[2] = { "objectSid", NULL };
3641         struct samr_RidWithAttributeArray *array;
3642         int i, count;
3643
3644         DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
3645
3646         a_state = h->data;
3647         d_state = a_state->domain_state;
3648
3649         count = samdb_search_domain(a_state->sam_ctx, mem_ctx,
3650                                     d_state->domain_dn, &res,
3651                                     attrs, d_state->domain_sid,
3652                                     "(&(member=%s)(grouptype=%d)(objectclass=group))",
3653                                     ldb_dn_get_linearized(a_state->account_dn),
3654                                     GTYPE_SECURITY_GLOBAL_GROUP);
3655         if (count < 0)
3656                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
3657
3658         array = talloc(mem_ctx, struct samr_RidWithAttributeArray);
3659         if (array == NULL)
3660                 return NT_STATUS_NO_MEMORY;
3661
3662         array->count = 0;
3663         array->rids = NULL;
3664
3665         array->rids = talloc_array(mem_ctx, struct samr_RidWithAttribute,
3666                                             count + 1);
3667         if (array->rids == NULL)
3668                 return NT_STATUS_NO_MEMORY;
3669
3670         /* Adds the primary group */
3671         array->rids[0].rid = samdb_search_uint(a_state->sam_ctx, mem_ctx,
3672                                                ~0, a_state->account_dn,
3673                                                "primaryGroupID", NULL);
3674         array->rids[0].attributes = SE_GROUP_MANDATORY
3675                         | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED;
3676         array->count += 1;
3677
3678         /* Adds the additional groups */
3679         for (i = 0; i < count; i++) {
3680                 struct dom_sid *group_sid;
3681
3682                 group_sid = samdb_result_dom_sid(mem_ctx, res[i], "objectSid");
3683                 if (group_sid == NULL) {
3684                         DEBUG(0, ("Couldn't find objectSid attrib\n"));
3685                         continue;
3686                 }
3687
3688                 array->rids[i + 1].rid =
3689                         group_sid->sub_auths[group_sid->num_auths-1];
3690                 array->rids[i + 1].attributes = SE_GROUP_MANDATORY
3691                         | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED;
3692                 array->count += 1;
3693         }
3694
3695         *r->out.rids = array;
3696
3697         return NT_STATUS_OK;
3698 }
3699
3700
3701 /*
3702   samr_QueryDisplayInfo
3703 */
3704 static NTSTATUS dcesrv_samr_QueryDisplayInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3705                        struct samr_QueryDisplayInfo *r)
3706 {
3707         struct dcesrv_handle *h;
3708         struct samr_domain_state *d_state;
3709         struct ldb_message **res;
3710         int ldb_cnt, count, i;
3711         const char * const attrs[] = { "objectSid", "sAMAccountName",
3712                 "displayName", "description", "userAccountControl",
3713                 "pwdLastSet", NULL };
3714         struct samr_DispEntryFull *entriesFull = NULL;
3715         struct samr_DispEntryFullGroup *entriesFullGroup = NULL;
3716         struct samr_DispEntryAscii *entriesAscii = NULL;
3717         struct samr_DispEntryGeneral *entriesGeneral = NULL;
3718         const char *filter;
3719
3720         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
3721
3722         d_state = h->data;
3723
3724         switch (r->in.level) {
3725         case 1:
3726         case 4:
3727                 filter = talloc_asprintf(mem_ctx, "(&(objectclass=user)"
3728                                          "(sAMAccountType=%u))",
3729                                          ATYPE_NORMAL_ACCOUNT);
3730                 break;
3731         case 2:
3732                 filter = talloc_asprintf(mem_ctx, "(&(objectclass=user)"
3733                                          "(sAMAccountType=%u))",
3734                                          ATYPE_WORKSTATION_TRUST);
3735                 break;
3736         case 3:
3737         case 5:
3738                 filter = talloc_asprintf(mem_ctx, "(&(grouptype=%d)"
3739                                          "(objectclass=group))",
3740                                          GTYPE_SECURITY_GLOBAL_GROUP);
3741                 break;
3742         default:
3743                 return NT_STATUS_INVALID_INFO_CLASS;
3744         }
3745
3746         /* search for all requested objects in this domain. This could
3747            possibly be cached and resumed based on resume_key */
3748         ldb_cnt = samdb_search_domain(d_state->sam_ctx, mem_ctx,
3749                                       d_state->domain_dn, &res, attrs,
3750                                       d_state->domain_sid, "%s", filter);
3751         if (ldb_cnt == -1) {
3752                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
3753         }
3754         if (ldb_cnt == 0 || r->in.max_entries == 0) {
3755                 return NT_STATUS_OK;
3756         }
3757
3758         switch (r->in.level) {
3759         case 1:
3760                 entriesGeneral = talloc_array(mem_ctx,
3761                                              struct samr_DispEntryGeneral,
3762                                              ldb_cnt);
3763                 break;
3764         case 2:
3765                 entriesFull = talloc_array(mem_ctx,
3766                                              struct samr_DispEntryFull,
3767                                              ldb_cnt);
3768                 break;
3769         case 3:
3770                 entriesFullGroup = talloc_array(mem_ctx,
3771                                              struct samr_DispEntryFullGroup,
3772                                              ldb_cnt);
3773                 break;
3774         case 4:
3775         case 5:
3776                 entriesAscii = talloc_array(mem_ctx,
3777                                               struct samr_DispEntryAscii,
3778                                               ldb_cnt);
3779                 break;
3780         }
3781
3782         if ((entriesGeneral == NULL) && (entriesFull == NULL) &&
3783             (entriesAscii == NULL) && (entriesFullGroup == NULL))
3784                 return NT_STATUS_NO_MEMORY;
3785
3786         count = 0;
3787
3788         for (i=0; i<ldb_cnt; i++) {
3789                 struct dom_sid *objectsid;
3790
3791                 objectsid = samdb_result_dom_sid(mem_ctx, res[i],
3792                                                  "objectSid");
3793                 if (objectsid == NULL)
3794                         continue;
3795
3796                 switch(r->in.level) {
3797                 case 1:
3798                         entriesGeneral[count].idx = count + 1;
3799                         entriesGeneral[count].rid =
3800                                 objectsid->sub_auths[objectsid->num_auths-1];
3801                         entriesGeneral[count].acct_flags =
3802                                 samdb_result_acct_flags(d_state->sam_ctx, mem_ctx,
3803                                                         res[i],
3804                                                         d_state->domain_dn);
3805                         entriesGeneral[count].account_name.string =
3806                                 samdb_result_string(res[i],
3807                                                     "sAMAccountName", "");
3808                         entriesGeneral[count].full_name.string =
3809                                 samdb_result_string(res[i], "displayName", "");
3810                         entriesGeneral[count].description.string =
3811                                 samdb_result_string(res[i], "description", "");
3812                         break;
3813                 case 2:
3814                         entriesFull[count].idx = count + 1;
3815                         entriesFull[count].rid =
3816                                 objectsid->sub_auths[objectsid->num_auths-1];
3817
3818                         /* No idea why we need to or in ACB_NORMAL here, but this is what Win2k3 seems to do... */
3819                         entriesFull[count].acct_flags =
3820                                 samdb_result_acct_flags(d_state->sam_ctx, mem_ctx,
3821                                                         res[i],
3822                                                         d_state->domain_dn) | ACB_NORMAL;
3823                         entriesFull[count].account_name.string =
3824                                 samdb_result_string(res[i], "sAMAccountName",
3825                                                     "");
3826                         entriesFull[count].description.string =
3827                                 samdb_result_string(res[i], "description", "");
3828                         break;
3829                 case 3:
3830                         entriesFullGroup[count].idx = count + 1;
3831                         entriesFullGroup[count].rid =
3832                                 objectsid->sub_auths[objectsid->num_auths-1];
3833                         /* We get a "7" here for groups */
3834                         entriesFullGroup[count].acct_flags
3835                                 = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED;
3836                         entriesFullGroup[count].account_name.string =
3837                                 samdb_result_string(res[i], "sAMAccountName",
3838                                                     "");
3839                         entriesFullGroup[count].description.string =
3840                                 samdb_result_string(res[i], "description", "");
3841                         break;
3842                 case 4:
3843                 case 5:
3844                         entriesAscii[count].idx = count + 1;
3845                         entriesAscii[count].account_name.string =
3846                                 samdb_result_string(res[i], "sAMAccountName",
3847                                                     "");
3848                         break;
3849                 }
3850
3851                 count += 1;
3852         }
3853
3854         *r->out.total_size = count;
3855
3856         if (r->in.start_idx >= count) {
3857                 *r->out.returned_size = 0;
3858                 switch(r->in.level) {
3859                 case 1:
3860                         r->out.info->info1.count = *r->out.returned_size;
3861                         r->out.info->info1.entries = NULL;
3862                         break;
3863                 case 2:
3864                         r->out.info->info2.count = *r->out.returned_size;
3865                         r->out.info->info2.entries = NULL;
3866                         break;
3867                 case 3:
3868                         r->out.info->info3.count = *r->out.returned_size;
3869                         r->out.info->info3.entries = NULL;
3870                         break;
3871                 case 4:
3872                         r->out.info->info4.count = *r->out.returned_size;
3873                         r->out.info->info4.entries = NULL;
3874                         break;
3875                 case 5:
3876                         r->out.info->info5.count = *r->out.returned_size;
3877                         r->out.info->info5.entries = NULL;
3878                         break;
3879                 }
3880         } else {
3881                 *r->out.returned_size = MIN(count - r->in.start_idx,
3882                                            r->in.max_entries);
3883                 switch(r->in.level) {
3884                 case 1:
3885                         r->out.info->info1.count = *r->out.returned_size;
3886                         r->out.info->info1.entries =
3887                                 &(entriesGeneral[r->in.start_idx]);
3888                         break;
3889                 case 2:
3890                         r->out.info->info2.count = *r->out.returned_size;
3891                         r->out.info->info2.entries =
3892                                 &(entriesFull[r->in.start_idx]);
3893                         break;
3894                 case 3:
3895                         r->out.info->info3.count = *r->out.returned_size;
3896                         r->out.info->info3.entries =
3897                                 &(entriesFullGroup[r->in.start_idx]);
3898                         break;
3899                 case 4:
3900                         r->out.info->info4.count = *r->out.returned_size;
3901                         r->out.info->info4.entries =
3902                                 &(entriesAscii[r->in.start_idx]);
3903                         break;
3904                 case 5:
3905                         r->out.info->info5.count = *r->out.returned_size;
3906                         r->out.info->info5.entries =
3907                                 &(entriesAscii[r->in.start_idx]);
3908                         break;
3909                 }
3910         }
3911
3912         return (*r->out.returned_size < (count - r->in.start_idx)) ?
3913                 STATUS_MORE_ENTRIES : NT_STATUS_OK;
3914 }
3915
3916
3917 /*
3918   samr_GetDisplayEnumerationIndex
3919 */
3920 static NTSTATUS dcesrv_samr_GetDisplayEnumerationIndex(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3921                        struct samr_GetDisplayEnumerationIndex *r)
3922 {
3923         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3924 }
3925
3926
3927 /*
3928   samr_TestPrivateFunctionsDomain
3929 */
3930 static NTSTATUS dcesrv_samr_TestPrivateFunctionsDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3931                        struct samr_TestPrivateFunctionsDomain *r)
3932 {
3933         return NT_STATUS_NOT_IMPLEMENTED;
3934 }
3935
3936
3937 /*
3938   samr_TestPrivateFunctionsUser
3939 */
3940 static NTSTATUS dcesrv_samr_TestPrivateFunctionsUser(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3941                        struct samr_TestPrivateFunctionsUser *r)
3942 {
3943         return NT_STATUS_NOT_IMPLEMENTED;
3944 }
3945
3946
3947 /*
3948   samr_GetUserPwInfo
3949 */
3950 static NTSTATUS dcesrv_samr_GetUserPwInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3951                                    struct samr_GetUserPwInfo *r)
3952 {
3953         struct dcesrv_handle *h;
3954         struct samr_account_state *a_state;
3955
3956         ZERO_STRUCTP(r->out.info);
3957
3958         DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
3959
3960         a_state = h->data;
3961
3962         r->out.info->min_password_length = samdb_search_uint(a_state->sam_ctx,
3963                 mem_ctx, 0, a_state->domain_state->domain_dn, "minPwdLength",
3964                 NULL);
3965         r->out.info->password_properties = samdb_search_uint(a_state->sam_ctx,
3966                 mem_ctx, 0, a_state->account_dn, "pwdProperties", NULL);
3967
3968         return NT_STATUS_OK;
3969 }
3970
3971
3972 /*
3973   samr_RemoveMemberFromForeignDomain
3974 */
3975 static NTSTATUS dcesrv_samr_RemoveMemberFromForeignDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3976                        struct samr_RemoveMemberFromForeignDomain *r)
3977 {
3978         struct dcesrv_handle *h;
3979         struct samr_domain_state *d_state;
3980         const char *memberdn;
3981         struct ldb_message **res;
3982         const char * const attrs[3] = { "distinguishedName", "objectSid", NULL };
3983         int i, count;
3984
3985         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
3986
3987         d_state = h->data;
3988
3989         memberdn = samdb_search_string(d_state->sam_ctx, mem_ctx, NULL,
3990                                        "distinguishedName", "(objectSid=%s)",
3991                                        ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid));
3992         /* Nothing to do */
3993         if (memberdn == NULL) {
3994                 return NT_STATUS_OK;
3995         }
3996
3997         /* TODO: Does this call only remove alias members, or does it do this
3998          * for domain groups as well? */
3999
4000         count = samdb_search_domain(d_state->sam_ctx, mem_ctx,
4001                                     d_state->domain_dn, &res, attrs,
4002                                     d_state->domain_sid,
4003                                     "(&(member=%s)(objectClass=group)"
4004                                     "(|(groupType=%d)(groupType=%d)))",
4005                                     memberdn,
4006                                     GTYPE_SECURITY_BUILTIN_LOCAL_GROUP,
4007                                     GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
4008
4009         if (count < 0)
4010                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
4011
4012         for (i=0; i<count; i++) {
4013                 struct ldb_message *mod;
4014
4015                 mod = ldb_msg_new(mem_ctx);
4016                 if (mod == NULL) {
4017                         return NT_STATUS_NO_MEMORY;
4018                 }
4019
4020                 mod->dn = samdb_result_dn(d_state->sam_ctx, mod, res[i], "distinguishedName", NULL);
4021                 if (mod->dn == NULL) {
4022                         talloc_free(mod);
4023                         continue;
4024                 }
4025
4026                 if (samdb_msg_add_delval(d_state->sam_ctx, mem_ctx, mod,
4027                                          "member", memberdn) != 0)
4028                         return NT_STATUS_NO_MEMORY;
4029
4030                 if (ldb_modify(d_state->sam_ctx, mod) != 0)
4031                         return NT_STATUS_UNSUCCESSFUL;
4032
4033                 talloc_free(mod);
4034         }
4035
4036         return NT_STATUS_OK;
4037 }
4038
4039
4040 /*
4041   samr_QueryDomainInfo2
4042
4043   just an alias for samr_QueryDomainInfo
4044 */
4045 static NTSTATUS dcesrv_samr_QueryDomainInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4046                        struct samr_QueryDomainInfo2 *r)
4047 {
4048         struct samr_QueryDomainInfo r1;
4049         NTSTATUS status;
4050
4051         ZERO_STRUCT(r1.out);
4052         r1.in.domain_handle = r->in.domain_handle;
4053         r1.in.level  = r->in.level;
4054         r1.out.info  = r->out.info;
4055
4056         status = dcesrv_samr_QueryDomainInfo(dce_call, mem_ctx, &r1);
4057
4058         return status;
4059 }
4060
4061
4062 /*
4063   samr_QueryUserInfo2
4064
4065   just an alias for samr_QueryUserInfo
4066 */
4067 static NTSTATUS dcesrv_samr_QueryUserInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4068                                     struct samr_QueryUserInfo2 *r)
4069 {
4070         struct samr_QueryUserInfo r1;
4071         NTSTATUS status;
4072
4073         r1.in.user_handle = r->in.user_handle;
4074         r1.in.level  = r->in.level;
4075         r1.out.info  = r->out.info;
4076
4077         status = dcesrv_samr_QueryUserInfo(dce_call, mem_ctx, &r1);
4078
4079         return status;
4080 }
4081
4082
4083 /*
4084   samr_QueryDisplayInfo2
4085 */
4086 static NTSTATUS dcesrv_samr_QueryDisplayInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4087                                        struct samr_QueryDisplayInfo2 *r)
4088 {
4089         struct samr_QueryDisplayInfo q;
4090         NTSTATUS result;
4091
4092         q.in.domain_handle = r->in.domain_handle;
4093         q.in.level = r->in.level;
4094         q.in.start_idx = r->in.start_idx;
4095         q.in.max_entries = r->in.max_entries;
4096         q.in.buf_size = r->in.buf_size;
4097         q.out.total_size = r->out.total_size;
4098         q.out.returned_size = r->out.returned_size;
4099         q.out.info = r->out.info;
4100
4101         result = dcesrv_samr_QueryDisplayInfo(dce_call, mem_ctx, &q);
4102
4103         return result;
4104 }
4105
4106
4107 /*
4108   samr_GetDisplayEnumerationIndex2
4109 */
4110 static NTSTATUS dcesrv_samr_GetDisplayEnumerationIndex2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4111                        struct samr_GetDisplayEnumerationIndex2 *r)
4112 {
4113         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4114 }
4115
4116
4117 /*
4118   samr_QueryDisplayInfo3
4119 */
4120 static NTSTATUS dcesrv_samr_QueryDisplayInfo3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4121                        struct samr_QueryDisplayInfo3 *r)
4122 {
4123         struct samr_QueryDisplayInfo q;
4124         NTSTATUS result;
4125
4126         q.in.domain_handle = r->in.domain_handle;
4127         q.in.level = r->in.level;
4128         q.in.start_idx = r->in.start_idx;
4129         q.in.max_entries = r->in.max_entries;
4130         q.in.buf_size = r->in.buf_size;
4131         q.out.total_size = r->out.total_size;
4132         q.out.returned_size = r->out.returned_size;
4133         q.out.info = r->out.info;
4134
4135         result = dcesrv_samr_QueryDisplayInfo(dce_call, mem_ctx, &q);
4136
4137         return result;
4138 }
4139
4140
4141 /*
4142   samr_AddMultipleMembersToAlias
4143 */
4144 static NTSTATUS dcesrv_samr_AddMultipleMembersToAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4145                        struct samr_AddMultipleMembersToAlias *r)
4146 {
4147         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4148 }
4149
4150
4151 /*
4152   samr_RemoveMultipleMembersFromAlias
4153 */
4154 static NTSTATUS dcesrv_samr_RemoveMultipleMembersFromAlias(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4155                        struct samr_RemoveMultipleMembersFromAlias *r)
4156 {
4157         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4158 }
4159
4160
4161 /*
4162   samr_GetDomPwInfo
4163
4164   this fetches the default password properties for a domain
4165
4166   note that w2k3 completely ignores the domain name in this call, and
4167   always returns the information for the servers primary domain
4168 */
4169 static NTSTATUS dcesrv_samr_GetDomPwInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4170                                   struct samr_GetDomPwInfo *r)
4171 {
4172         struct ldb_message **msgs;
4173         int ret;
4174         const char * const attrs[] = {"minPwdLength", "pwdProperties", NULL };
4175         struct ldb_context *sam_ctx;
4176
4177         ZERO_STRUCTP(r->out.info);
4178
4179         sam_ctx = samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
4180         if (sam_ctx == NULL) {
4181                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
4182         }
4183
4184         /* The domain name in this call is ignored */
4185         ret = gendb_search_dn(sam_ctx,
4186                            mem_ctx, NULL, &msgs, attrs);
4187         if (ret <= 0) {
4188                 talloc_free(sam_ctx);
4189
4190                 return NT_STATUS_NO_SUCH_DOMAIN;
4191         }
4192         if (ret > 1) {
4193                 talloc_free(msgs);
4194                 talloc_free(sam_ctx);
4195
4196                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
4197         }
4198
4199         r->out.info->min_password_length = samdb_result_uint(msgs[0],
4200                 "minPwdLength", 0);
4201         r->out.info->password_properties = samdb_result_uint(msgs[0],
4202                 "pwdProperties", 1);
4203
4204         talloc_free(msgs);
4205         talloc_free(sam_ctx);
4206
4207         return NT_STATUS_OK;
4208 }
4209
4210
4211 /*
4212   samr_Connect2
4213 */
4214 static NTSTATUS dcesrv_samr_Connect2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4215                               struct samr_Connect2 *r)
4216 {
4217         struct samr_Connect c;
4218
4219         c.in.system_name = NULL;
4220         c.in.access_mask = r->in.access_mask;
4221         c.out.connect_handle = r->out.connect_handle;
4222
4223         return dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4224 }
4225
4226
4227 /*
4228   samr_SetUserInfo2
4229
4230   just an alias for samr_SetUserInfo
4231 */
4232 static NTSTATUS dcesrv_samr_SetUserInfo2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4233                                   struct samr_SetUserInfo2 *r)
4234 {
4235         struct samr_SetUserInfo r2;
4236
4237         r2.in.user_handle = r->in.user_handle;
4238         r2.in.level = r->in.level;
4239         r2.in.info = r->in.info;
4240
4241         return dcesrv_samr_SetUserInfo(dce_call, mem_ctx, &r2);
4242 }
4243
4244
4245 /*
4246   samr_SetBootKeyInformation
4247 */
4248 static NTSTATUS dcesrv_samr_SetBootKeyInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4249                        struct samr_SetBootKeyInformation *r)
4250 {
4251         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4252 }
4253
4254
4255 /*
4256   samr_GetBootKeyInformation
4257 */
4258 static NTSTATUS dcesrv_samr_GetBootKeyInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4259                        struct samr_GetBootKeyInformation *r)
4260 {
4261         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4262 }
4263
4264
4265 /*
4266   samr_Connect3
4267 */
4268 static NTSTATUS dcesrv_samr_Connect3(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4269                        struct samr_Connect3 *r)
4270 {
4271         struct samr_Connect c;
4272
4273         c.in.system_name = NULL;
4274         c.in.access_mask = r->in.access_mask;
4275         c.out.connect_handle = r->out.connect_handle;
4276
4277         return dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4278 }
4279
4280
4281 /*
4282   samr_Connect4
4283 */
4284 static NTSTATUS dcesrv_samr_Connect4(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4285                        struct samr_Connect4 *r)
4286 {
4287         struct samr_Connect c;
4288
4289         c.in.system_name = NULL;
4290         c.in.access_mask = r->in.access_mask;
4291         c.out.connect_handle = r->out.connect_handle;
4292
4293         return dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4294 }
4295
4296
4297 /*
4298   samr_Connect5
4299 */
4300 static NTSTATUS dcesrv_samr_Connect5(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4301                               struct samr_Connect5 *r)
4302 {
4303         struct samr_Connect c;
4304         NTSTATUS status;
4305
4306         c.in.system_name = NULL;
4307         c.in.access_mask = r->in.access_mask;
4308         c.out.connect_handle = r->out.connect_handle;
4309
4310         status = dcesrv_samr_Connect(dce_call, mem_ctx, &c);
4311
4312         r->out.info_out->info1.client_version = SAMR_CONNECT_AFTER_W2K;
4313         r->out.info_out->info1.unknown2 = 0;
4314         *r->out.level_out = r->in.level_in;
4315
4316         return status;
4317 }
4318
4319
4320 /*
4321   samr_RidToSid
4322 */
4323 static NTSTATUS dcesrv_samr_RidToSid(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4324                               struct samr_RidToSid *r)
4325 {
4326         struct samr_domain_state *d_state;
4327         struct dcesrv_handle *h;
4328
4329         DCESRV_PULL_HANDLE(h, r->in.domain_handle, SAMR_HANDLE_DOMAIN);
4330
4331         d_state = h->data;
4332
4333         /* form the users SID */
4334         *r->out.sid = dom_sid_add_rid(mem_ctx, d_state->domain_sid, r->in.rid);
4335         if (!*r->out.sid) {
4336                 return NT_STATUS_NO_MEMORY;
4337         }
4338
4339         return NT_STATUS_OK;
4340 }
4341
4342
4343 /*
4344   samr_SetDsrmPassword
4345 */
4346 static NTSTATUS dcesrv_samr_SetDsrmPassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4347                        struct samr_SetDsrmPassword *r)
4348 {
4349         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
4350 }
4351
4352
4353 /*
4354   samr_ValidatePassword
4355 */
4356 static NTSTATUS dcesrv_samr_ValidatePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
4357                                       struct samr_ValidatePassword *r)
4358 {
4359         /* just say it's OK for now - we need to hook this into our
4360            password strength code later */
4361         DEBUG(0,(__location__ ": Faking samr_ValidatePassword reply\n"));
4362         (*r->out.rep) = talloc_zero(mem_ctx, union samr_ValidatePasswordRep);
4363         return NT_STATUS_OK;
4364 }
4365
4366
4367 /* include the generated boilerplate */
4368 #include "librpc/gen_ndr/ndr_samr_s.c"