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