source/rpc_server/lsa/dcesrv_lsa.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    endpoint server for the lsarpc pipe
   5
   6    Copyright (C) Andrew Tridgell 2004
   7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "librpc/gen_ndr/ndr_lsa.h"
  26 #include "librpc/gen_ndr/ndr_samr.h"
  27 #include "rpc_server/dcerpc_server.h"
  28 #include "rpc_server/common/common.h"
  29 #include "lib/ldb/include/ldb.h"
  30 #include "auth/auth.h"
  31 #include "system/time.h"
  32 #include "db_wrap.h"
  33
  34 /*
  35   this type allows us to distinguish handle types
  36 */
  37 enum lsa_handle {
  38         LSA_HANDLE_POLICY,
  39         LSA_HANDLE_ACCOUNT,
  40         LSA_HANDLE_SECRET,
  41         LSA_HANDLE_TRUSTED_DOMAIN
  42 };
  43
  44 /*
  45   state associated with a lsa_OpenPolicy() operation
  46 */
  47 struct lsa_policy_state {
  48         struct dcesrv_handle *handle;
  49         struct ldb_context *sam_ldb;
  50         struct sidmap_context *sidmap;
  51         uint32_t access_mask;
  52         const char *domain_dn;
  53         const char *builtin_dn;
  54         const char *system_dn;
  55         const char *domain_name;
  56         struct dom_sid *domain_sid;
  57         struct dom_sid *builtin_sid;
  58 };
  59
  60
  61 /*
  62   state associated with a lsa_OpenAccount() operation
  63 */
  64 struct lsa_account_state {
  65         struct lsa_policy_state *policy;
  66         uint32_t access_mask;
  67         struct dom_sid *account_sid;
  68         const char *account_dn;
  69 };
  70
  71
  72 /*
  73   state associated with a lsa_OpenSecret() operation
  74 */
  75 struct lsa_secret_state {
  76         struct lsa_policy_state *policy;
  77         uint32_t access_mask;
  78         const char *secret_dn;
  79         struct ldb_context *sam_ldb;
  80         BOOL global;
  81 };
  82
  83 /*
  84   state associated with a lsa_OpenTrustedDomain() operation
  85 */
  86 struct lsa_trusted_domain_state {
  87         struct lsa_policy_state *policy;
  88         uint32_t access_mask;
  89         const char *trusted_domain_dn;
  90 };
  91
  92 /*
  93   lsa_Close
  94 */
  95 static NTSTATUS lsa_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  96                           struct lsa_Close *r)
  97 {
  98         struct dcesrv_handle *h;
  99
 100         *r->out.handle = *r->in.handle;
 101
 102         DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
 103
 104         talloc_free(h);
 105
 106         ZERO_STRUCTP(r->out.handle);
 107
 108         return NT_STATUS_OK;
 109 }
 110
 111
 112 /*
 113   lsa_Delete
 114 */
 115 static NTSTATUS lsa_Delete(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 116                            struct lsa_Delete *r)
 117 {
 118         struct dcesrv_handle *h;
 119         int ret;
 120
 121         DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
 122         if (h->wire_handle.handle_type == LSA_HANDLE_SECRET) {
 123                 struct lsa_secret_state *secret_state = h->data;
 124                 ret = samdb_delete(secret_state->sam_ldb, mem_ctx, secret_state->secret_dn);
 125                 talloc_free(h);
 126                 if (ret != 0) {
 127                         return NT_STATUS_INVALID_HANDLE;
 128                 }
 129
 130                 return NT_STATUS_OK;
 131         } else if (h->wire_handle.handle_type == LSA_HANDLE_TRUSTED_DOMAIN) {
 132                 struct lsa_trusted_domain_state *trusted_domain_state = h->data;
 133                 ret = samdb_delete(trusted_domain_state->policy->sam_ldb, mem_ctx,
 134                                    trusted_domain_state->trusted_domain_dn);
 135                 talloc_free(h);
 136                 if (ret != 0) {
 137                         return NT_STATUS_INVALID_HANDLE;
 138                 }
 139
 140                 return NT_STATUS_OK;
 141         }
 142
 143         return NT_STATUS_INVALID_HANDLE;
 144 }
 145
 146
 147 /*
 148   lsa_EnumPrivs
 149 */
 150 static NTSTATUS lsa_EnumPrivs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 151                               struct lsa_EnumPrivs *r)
 152 {
 153         struct dcesrv_handle *h;
 154         struct lsa_policy_state *state;
 155         int i;
 156         const char *privname;
 157
 158         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 159
 160         state = h->data;
 161
 162         i = *r->in.resume_handle;
 163         if (i == 0) i = 1;
 164
 165         while ((privname = sec_privilege_name(i)) &&
 166                r->out.privs->count < r->in.max_count) {
 167                 struct lsa_PrivEntry *e;
 168
 169                 r->out.privs->privs = talloc_realloc(r->out.privs,
 170                                                        r->out.privs->privs,
 171                                                        struct lsa_PrivEntry,
 172                                                        r->out.privs->count+1);
 173                 if (r->out.privs->privs == NULL) {
 174                         return NT_STATUS_NO_MEMORY;
 175                 }
 176                 e = &r->out.privs->privs[r->out.privs->count];
 177                 e->luid.low = i;
 178                 e->luid.high = 0;
 179                 e->name.string = privname;
 180                 r->out.privs->count++;
 181                 i++;
 182         }
 183
 184         *r->out.resume_handle = i;
 185
 186         return NT_STATUS_OK;
 187 }
 188
 189
 190 /*
 191   lsa_QuerySecObj
 192 */
 193 static NTSTATUS lsa_QuerySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 194                                   struct lsa_QuerySecurity *r)
 195 {
 196         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 197 }
 198
 199
 200 /*
 201   lsa_SetSecObj
 202 */
 203 static NTSTATUS lsa_SetSecObj(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 204                               struct lsa_SetSecObj *r)
 205 {
 206         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 207 }
 208
 209
 210 /*
 211   lsa_ChangePassword
 212 */
 213 static NTSTATUS lsa_ChangePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 214                                    struct lsa_ChangePassword *r)
 215 {
 216         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 217 }
 218
 219 static NTSTATUS lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 220                                      struct lsa_policy_state **_state)
 221 {
 222         struct lsa_policy_state *state;
 223         const char *domain_attrs[] =  {"nETBIOSName", "nCName", NULL};
 224         int ret_domain;
 225         struct ldb_message **msgs_domain;
 226
 227         state = talloc(mem_ctx, struct lsa_policy_state);
 228         if (!state) {
 229                 return NT_STATUS_NO_MEMORY;
 230         }
 231
 232         /* make sure the sam database is accessible */
 233         state->sam_ldb = samdb_connect(state);
 234         if (state->sam_ldb == NULL) {
 235                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
 236         }
 237
 238         state->sidmap = sidmap_open(state);
 239         if (state->sidmap == NULL) {
 240                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
 241         }
 242
 243         ret_domain = gendb_search(state->sam_ldb, mem_ctx, NULL, &msgs_domain, domain_attrs,
 244                                   "(&(&(nETBIOSName=%s)(objectclass=crossRef))(ncName=*))",
 245                                   lp_workgroup());
 246
 247         if (ret_domain == -1) {
 248                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 249         }
 250
 251         if (ret_domain != 1) {
 252                 return NT_STATUS_NO_SUCH_DOMAIN;
 253         }
 254
 255         /* work out the domain_dn - useful for so many calls its worth
 256            fetching here */
 257         state->domain_dn = talloc_steal(state, samdb_result_string(msgs_domain[0], "nCName", NULL));
 258         if (!state->domain_dn) {
 259                 return NT_STATUS_NO_SUCH_DOMAIN;
 260         }
 261
 262         /* work out the builtin_dn - useful for so many calls its worth
 263            fetching here */
 264         state->builtin_dn = talloc_steal(state,
 265                                          samdb_search_string(state->sam_ldb, mem_ctx, NULL,
 266                                                              "dn", "objectClass=builtinDomain"));
 267         if (!state->builtin_dn) {
 268                 return NT_STATUS_NO_SUCH_DOMAIN;
 269         }
 270
 271         /* work out the system_dn - useful for so many calls its worth
 272            fetching here */
 273         state->system_dn = talloc_steal(state,
 274                                         samdb_search_string(state->sam_ldb, mem_ctx, state->domain_dn,
 275                                                             "dn", "(&(objectClass=container)(cn=System))"));
 276         if (!state->system_dn) {
 277                 return NT_STATUS_NO_SUCH_DOMAIN;
 278         }
 279
 280         state->domain_sid = talloc_steal(state,
 281                                          samdb_search_dom_sid(state->sam_ldb, state,
 282                                                               state->domain_dn, "objectSid",
 283                                                               "dn=%s", state->domain_dn));
 284         if (!state->domain_sid) {
 285                 return NT_STATUS_NO_SUCH_DOMAIN;
 286         }
 287
 288         state->builtin_sid = dom_sid_parse_talloc(state, SID_BUILTIN);
 289         if (!state->builtin_sid) {
 290                 return NT_STATUS_NO_SUCH_DOMAIN;
 291         }
 292
 293         state->domain_name = talloc_strdup(state,
 294                                            samdb_result_string(msgs_domain[0], "nETBIOSName",
 295                                                                lp_workgroup()));
 296
 297         *_state = state;
 298
 299         return NT_STATUS_OK;
 300 }
 301
 302 /*
 303   lsa_OpenPolicy2
 304 */
 305 static NTSTATUS lsa_OpenPolicy2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 306                                struct lsa_OpenPolicy2 *r)
 307 {
 308         NTSTATUS status;
 309         struct lsa_policy_state *state;
 310         struct dcesrv_handle *handle;
 311
 312         ZERO_STRUCTP(r->out.handle);
 313
 314         status = lsa_get_policy_state(dce_call, mem_ctx, &state);
 315         if (!NT_STATUS_IS_OK(status)) {
 316                 return status;
 317         }
 318
 319         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_POLICY);
 320         if (!handle) {
 321                 return NT_STATUS_NO_MEMORY;
 322         }
 323
 324         handle->data = talloc_steal(handle, state);
 325
 326         state->access_mask = r->in.access_mask;
 327         state->handle = handle;
 328         *r->out.handle = handle->wire_handle;
 329
 330         /* note that we have completely ignored the attr element of
 331            the OpenPolicy. As far as I can tell, this is what w2k3
 332            does */
 333
 334         return NT_STATUS_OK;
 335 }
 336
 337 /*
 338   lsa_OpenPolicy
 339   a wrapper around lsa_OpenPolicy2
 340 */
 341 static NTSTATUS lsa_OpenPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 342                                 struct lsa_OpenPolicy *r)
 343 {
 344         struct lsa_OpenPolicy2 r2;
 345
 346         r2.in.system_name = NULL;
 347         r2.in.attr = r->in.attr;
 348         r2.in.access_mask = r->in.access_mask;
 349         r2.out.handle = r->out.handle;
 350
 351         return lsa_OpenPolicy2(dce_call, mem_ctx, &r2);
 352 }
 353
 354
 355
 356
 357 /*
 358   fill in the AccountDomain info
 359 */
 360 static NTSTATUS lsa_info_AccountDomain(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 361                                        struct lsa_DomainInfo *info)
 362 {
 363         info->name.string = state->domain_name;
 364         info->sid         = state->domain_sid;
 365
 366         return NT_STATUS_OK;
 367 }
 368
 369 /*
 370   fill in the DNS domain info
 371 */
 372 static NTSTATUS lsa_info_DNS(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 373                              struct lsa_DnsDomainInfo *info)
 374 {
 375         const char * const attrs[] = { "dnsDomain", "objectGUID", "objectSid", NULL };
 376         int ret;
 377         struct ldb_message **res;
 378
 379         ret = gendb_search_dn(state->sam_ldb, mem_ctx, state->domain_dn, &res, attrs);
 380         if (ret != 1) {
 381                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 382         }
 383
 384         info->name.string = state->domain_name;
 385         info->sid         = state->domain_sid;
 386         info->dns_domain.string = samdb_result_string(res[0],           "dnsDomain", NULL);
 387         info->dns_forest.string = samdb_result_string(res[0],           "dnsDomain", NULL);
 388         info->domain_guid       = samdb_result_guid(res[0],             "objectGUID");
 389
 390         return NT_STATUS_OK;
 391 }
 392
 393 /*
 394   lsa_QueryInfoPolicy2
 395 */
 396 static NTSTATUS lsa_QueryInfoPolicy2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 397                                      struct lsa_QueryInfoPolicy2 *r)
 398 {
 399         struct lsa_policy_state *state;
 400         struct dcesrv_handle *h;
 401
 402         r->out.info = NULL;
 403
 404         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 405
 406         state = h->data;
 407
 408         r->out.info = talloc(mem_ctx, union lsa_PolicyInformation);
 409         if (!r->out.info) {
 410                 return NT_STATUS_NO_MEMORY;
 411         }
 412
 413         ZERO_STRUCTP(r->out.info);
 414
 415         switch (r->in.level) {
 416         case LSA_POLICY_INFO_DOMAIN:
 417         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
 418                 return lsa_info_AccountDomain(state, mem_ctx, &r->out.info->account_domain);
 419
 420         case LSA_POLICY_INFO_DNS:
 421                 return lsa_info_DNS(state, mem_ctx, &r->out.info->dns);
 422         }
 423
 424         return NT_STATUS_INVALID_INFO_CLASS;
 425 }
 426
 427 /*
 428   lsa_QueryInfoPolicy
 429 */
 430 static NTSTATUS lsa_QueryInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 431                                     struct lsa_QueryInfoPolicy *r)
 432 {
 433         struct lsa_QueryInfoPolicy2 r2;
 434         NTSTATUS status;
 435
 436         r2.in.handle = r->in.handle;
 437         r2.in.level = r->in.level;
 438
 439         status = lsa_QueryInfoPolicy2(dce_call, mem_ctx, &r2);
 440
 441         r->out.info = r2.out.info;
 442
 443         return status;
 444 }
 445
 446 /*
 447   lsa_SetInfoPolicy
 448 */
 449 static NTSTATUS lsa_SetInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 450                                   struct lsa_SetInfoPolicy *r)
 451 {
 452         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 453 }
 454
 455
 456 /*
 457   lsa_ClearAuditLog
 458 */
 459 static NTSTATUS lsa_ClearAuditLog(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 460                                   struct lsa_ClearAuditLog *r)
 461 {
 462         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 463 }
 464
 465
 466 /*
 467   lsa_CreateAccount
 468 */
 469 static NTSTATUS lsa_CreateAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 470                                   struct lsa_CreateAccount *r)
 471 {
 472         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 473 }
 474
 475
 476 /*
 477   lsa_EnumAccounts
 478 */
 479 static NTSTATUS lsa_EnumAccounts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 480                                  struct lsa_EnumAccounts *r)
 481 {
 482         struct dcesrv_handle *h;
 483         struct lsa_policy_state *state;
 484         int ret, i;
 485         struct ldb_message **res;
 486         const char * const attrs[] = { "objectSid", NULL};
 487         uint32_t count;
 488
 489         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 490
 491         state = h->data;
 492
 493         ret = gendb_search(state->sam_ldb, mem_ctx, state->builtin_dn, &res, attrs,
 494                            "privilege=*");
 495         if (ret <= 0) {
 496                 return NT_STATUS_NO_SUCH_USER;
 497         }
 498
 499         if (*r->in.resume_handle >= ret) {
 500                 return NT_STATUS_NO_MORE_ENTRIES;
 501         }
 502
 503         count = ret - *r->in.resume_handle;
 504         if (count > r->in.num_entries) {
 505                 count = r->in.num_entries;
 506         }
 507
 508         if (count == 0) {
 509                 return NT_STATUS_NO_MORE_ENTRIES;
 510         }
 511
 512         r->out.sids->sids = talloc_array(r->out.sids, struct lsa_SidPtr, count);
 513         if (r->out.sids->sids == NULL) {
 514                 return NT_STATUS_NO_MEMORY;
 515         }
 516
 517         for (i=0;i<count;i++) {
 518                 r->out.sids->sids[i].sid =
 519                         samdb_result_dom_sid(r->out.sids->sids,
 520                                              res[i + *r->in.resume_handle],
 521                                              "objectSid");
 522                 NT_STATUS_HAVE_NO_MEMORY(r->out.sids->sids[i].sid);
 523         }
 524
 525         r->out.sids->num_sids = count;
 526         *r->out.resume_handle = count + *r->in.resume_handle;
 527
 528         return NT_STATUS_OK;
 529
 530 }
 531
 532
 533 /*
 534   lsa_CreateTrustedDomainEx2
 535 */
 536 static NTSTATUS lsa_CreateTrustedDomainEx2(struct dcesrv_call_state *dce_call,
 537                                            TALLOC_CTX *mem_ctx,
 538                                            struct lsa_CreateTrustedDomainEx2 *r)
 539 {
 540         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 541 }
 542
 543 /*
 544   lsa_CreateTrustedDomainEx
 545 */
 546 static NTSTATUS lsa_CreateTrustedDomainEx(struct dcesrv_call_state *dce_call,
 547                                           TALLOC_CTX *mem_ctx,
 548                                           struct lsa_CreateTrustedDomainEx *r)
 549 {
 550         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 551 }
 552
 553 /*
 554   lsa_CreateTrustedDomain
 555 */
 556 static NTSTATUS lsa_CreateTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 557                                         struct lsa_CreateTrustedDomain *r)
 558 {
 559         struct dcesrv_handle *policy_handle;
 560         struct lsa_policy_state *policy_state;
 561         struct lsa_trusted_domain_state *trusted_domain_state;
 562         struct dcesrv_handle *handle;
 563         struct ldb_message **msgs, *msg;
 564         const char *attrs[] = {
 565                 NULL
 566         };
 567         const char *name;
 568         int ret;
 569
 570         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
 571         ZERO_STRUCTP(r->out.trustdom_handle);
 572
 573         policy_state = policy_handle->data;
 574
 575         if (!r->in.info->name.string) {
 576                 return NT_STATUS_INVALID_PARAMETER;
 577         }
 578         name = r->in.info->name.string;
 579
 580         trusted_domain_state = talloc(mem_ctx, struct lsa_trusted_domain_state);
 581         if (!trusted_domain_state) {
 582                 return NT_STATUS_NO_MEMORY;
 583         }
 584         trusted_domain_state->policy = policy_state;
 585
 586         msg = ldb_msg_new(mem_ctx);
 587         if (msg == NULL) {
 588                 return NT_STATUS_NO_MEMORY;
 589         }
 590
 591         /* search for the trusted_domain record */
 592         ret = gendb_search(trusted_domain_state->policy->sam_ldb,
 593                            mem_ctx, policy_state->system_dn, &msgs, attrs,
 594                            "(&(cn=%s)(objectclass=trustedDomain))",
 595                            r->in.info->name.string);
 596         if (ret > 0) {
 597                 return NT_STATUS_OBJECT_NAME_COLLISION;
 598         }
 599
 600         if (ret < 0 || ret > 1) {
 601                 DEBUG(0,("Found %d records matching DN %s\n", ret, policy_state->system_dn));
 602                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 603         }
 604
 605         msg->dn = talloc_asprintf(mem_ctx, "cn=%s,%s", r->in.info->name.string,
 606                                   policy_state->system_dn);
 607         if (!msg->dn) {
 608                 return NT_STATUS_NO_MEMORY;
 609         }
 610
 611         samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "cn", name);
 612         samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "flatname", name);
 613
 614         if (r->in.info->sid) {
 615                 const char *sid_string = dom_sid_string(mem_ctx, r->in.info->sid);
 616                 if (!sid_string) {
 617                         return NT_STATUS_NO_MEMORY;
 618                 }
 619
 620                 samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "securityIdentifier", sid_string);
 621         }
 622
 623         samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "objectClass", "trustedDomain");
 624
 625         trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msg->dn);
 626
 627         /* create the trusted_domain */
 628         ret = samdb_add(trusted_domain_state->policy->sam_ldb, mem_ctx, msg);
 629         if (ret != 0) {
 630                 DEBUG(0,("Failed to create trusted_domain record %s\n", msg->dn));
 631                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 632         }
 633
 634         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
 635         if (!handle) {
 636                 return NT_STATUS_NO_MEMORY;
 637         }
 638
 639         handle->data = talloc_steal(handle, trusted_domain_state);
 640
 641         trusted_domain_state->access_mask = r->in.access_mask;
 642         trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
 643
 644         *r->out.trustdom_handle = handle->wire_handle;
 645
 646         return NT_STATUS_OK;
 647 }
 648
 649 /*
 650   lsa_OpenTrustedDomain
 651 */
 652 static NTSTATUS lsa_OpenTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 653                                       struct lsa_OpenTrustedDomain *r)
 654 {
 655         struct dcesrv_handle *policy_handle;
 656
 657         struct lsa_policy_state *policy_state;
 658         struct lsa_trusted_domain_state *trusted_domain_state;
 659         struct dcesrv_handle *handle;
 660         struct ldb_message **msgs;
 661         const char *attrs[] = {
 662                 NULL
 663         };
 664
 665         const char *sid_string;
 666         int ret;
 667
 668         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
 669         ZERO_STRUCTP(r->out.trustdom_handle);
 670         policy_state = policy_handle->data;
 671
 672         trusted_domain_state = talloc(mem_ctx, struct lsa_trusted_domain_state);
 673         if (!trusted_domain_state) {
 674                 return NT_STATUS_NO_MEMORY;
 675         }
 676         trusted_domain_state->policy = policy_state;
 677
 678         sid_string = dom_sid_string(mem_ctx, r->in.sid);
 679         if (!sid_string) {
 680                 return NT_STATUS_NO_MEMORY;
 681         }
 682
 683         /* search for the trusted_domain record */
 684         ret = gendb_search(trusted_domain_state->policy->sam_ldb,
 685                            mem_ctx, policy_state->system_dn, &msgs, attrs,
 686                            "(&(securityIdentifier=%s)(objectclass=trustedDomain))",
 687                            sid_string);
 688         if (ret == 0) {
 689                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 690         }
 691
 692         if (ret != 1) {
 693                 DEBUG(0,("Found %d records matching DN %s\n", ret, policy_state->system_dn));
 694                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 695         }
 696
 697         trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msgs[0]->dn);
 698
 699         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
 700         if (!handle) {
 701                 return NT_STATUS_NO_MEMORY;
 702         }
 703
 704         handle->data = talloc_steal(handle, trusted_domain_state);
 705
 706         trusted_domain_state->access_mask = r->in.access_mask;
 707         trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
 708
 709         *r->out.trustdom_handle = handle->wire_handle;
 710
 711         return NT_STATUS_OK;
 712 }
 713
 714
 715 /*
 716   lsa_OpenTrustedDomainByName
 717 */
 718 static NTSTATUS lsa_OpenTrustedDomainByName(struct dcesrv_call_state *dce_call,
 719                                             TALLOC_CTX *mem_ctx,
 720                                             struct lsa_OpenTrustedDomainByName *r)
 721 {
 722         struct dcesrv_handle *policy_handle;
 723
 724         struct lsa_policy_state *policy_state;
 725         struct lsa_trusted_domain_state *trusted_domain_state;
 726         struct dcesrv_handle *handle;
 727         struct ldb_message **msgs;
 728         const char *attrs[] = {
 729                 NULL
 730         };
 731
 732         int ret;
 733
 734         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
 735         ZERO_STRUCTP(r->out.trustdom_handle);
 736         policy_state = policy_handle->data;
 737
 738         if (!r->in.name.string) {
 739                 return NT_STATUS_INVALID_PARAMETER;
 740         }
 741
 742         trusted_domain_state = talloc(mem_ctx, struct lsa_trusted_domain_state);
 743         if (!trusted_domain_state) {
 744                 return NT_STATUS_NO_MEMORY;
 745         }
 746         trusted_domain_state->policy = policy_state;
 747
 748         /* search for the trusted_domain record */
 749         ret = gendb_search(trusted_domain_state->policy->sam_ldb,
 750                            mem_ctx, policy_state->system_dn, &msgs, attrs,
 751                            "(&(flatname=%s)(objectclass=trustedDomain))",
 752                            r->in.name.string);
 753         if (ret == 0) {
 754                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 755         }
 756
 757         if (ret != 1) {
 758                 DEBUG(0,("Found %d records matching DN %s\n", ret, policy_state->system_dn));
 759                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 760         }
 761
 762         trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msgs[0]->dn);
 763
 764         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
 765         if (!handle) {
 766                 return NT_STATUS_NO_MEMORY;
 767         }
 768
 769         handle->data = talloc_steal(handle, trusted_domain_state);
 770
 771         trusted_domain_state->access_mask = r->in.access_mask;
 772         trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
 773
 774         *r->out.trustdom_handle = handle->wire_handle;
 775
 776         return NT_STATUS_OK;
 777 }
 778
 779
 780 /*
 781   lsa_QueryTrustedDomainInfoBySid
 782 */
 783 static NTSTATUS lsa_QueryTrustedDomainInfoBySid(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 784                                                 struct lsa_QueryTrustedDomainInfoBySid *r)
 785 {
 786         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 787 }
 788
 789
 790 /*
 791   lsa_SetTrustDomainInfo
 792 */
 793 static NTSTATUS lsa_SetTrustDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 794                        struct lsa_SetTrustDomainInfo *r)
 795 {
 796         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 797 }
 798
 799
 800 /*
 801   lsa_DeleteTrustDomain
 802 */
 803 static NTSTATUS lsa_DeleteTrustDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 804                                       struct lsa_DeleteTrustDomain *r)
 805 {
 806         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 807 }
 808
 809
 810 /*
 811   lsa_QueryTrustedDomainInfo
 812 */
 813 static NTSTATUS lsa_QueryTrustedDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 814                                            struct lsa_QueryTrustedDomainInfo *r)
 815 {
 816         struct dcesrv_handle *h;
 817         struct lsa_trusted_domain_state *trusted_domain_state;
 818         struct ldb_message *msg;
 819         int ret;
 820         struct ldb_message **res;
 821         const char *attrs[] = {
 822                 "cn",
 823                 "flatname",
 824                 "posixOffset",
 825                 "securityIdentifier",
 826                 NULL
 827         };
 828
 829         DCESRV_PULL_HANDLE(h, r->in.trustdom_handle, LSA_HANDLE_TRUSTED_DOMAIN);
 830
 831         trusted_domain_state = h->data;
 832
 833         /* pull all the user attributes */
 834         ret = gendb_search_dn(trusted_domain_state->policy->sam_ldb, mem_ctx,
 835                               trusted_domain_state->trusted_domain_dn, &res, attrs);
 836         if (ret != 1) {
 837                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 838         }
 839         msg = res[0];
 840
 841         r->out.info = talloc(mem_ctx, union lsa_TrustedDomainInfo);
 842         if (!r->out.info) {
 843                 return NT_STATUS_NO_MEMORY;
 844         }
 845         switch (r->in.level) {
 846         case LSA_TRUSTED_DOMAIN_INFO_NAME:
 847                 r->out.info->name.netbios_name.string
 848                         = samdb_result_string(msg, "flatname", NULL);
 849                 break;
 850         case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
 851                 r->out.info->posix_offset.posix_offset
 852                         = samdb_result_uint(msg, "posixOffset", 0);
 853                 break;
 854         default:
 855                 /* oops, we don't want to return the info after all */
 856                 talloc_free(r->out.info);
 857                 r->out.info = NULL;
 858                 return NT_STATUS_INVALID_INFO_CLASS;
 859         }
 860
 861         return NT_STATUS_OK;
 862 }
 863
 864
 865 /*
 866   lsa_SetInformationTrustedDomain
 867 */
 868 static NTSTATUS lsa_SetInformationTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 869                        struct lsa_SetInformationTrustedDomain *r)
 870 {
 871         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 872 }
 873
 874
 875 /*
 876   lsa_QueryTrustedDomainInfoByName
 877 */
 878 static NTSTATUS lsa_QueryTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
 879                                                  TALLOC_CTX *mem_ctx,
 880                                                  struct lsa_QueryTrustedDomainInfoByName *r)
 881 {
 882         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 883 }
 884
 885 /*
 886   lsa_SetTrustedDomainInfoByName
 887 */
 888 static NTSTATUS lsa_SetTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
 889                                                TALLOC_CTX *mem_ctx,
 890                                                struct lsa_SetTrustedDomainInfoByName *r)
 891 {
 892         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 893 }
 894
 895 /*
 896   lsa_EnumTrustedDomainsEx
 897 */
 898 static NTSTATUS lsa_EnumTrustedDomainsEx(struct dcesrv_call_state *dce_call,
 899                                          TALLOC_CTX *mem_ctx,
 900                                          struct lsa_EnumTrustedDomainsEx *r)
 901 {
 902         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 903 }
 904
 905 /*
 906   lsa_CloseTrustedDomainEx
 907 */
 908 static NTSTATUS lsa_CloseTrustedDomainEx(struct dcesrv_call_state *dce_call,
 909                                          TALLOC_CTX *mem_ctx,
 910                                          struct lsa_CloseTrustedDomainEx *r)
 911 {
 912         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 913 }
 914
 915
 916 /*
 917   comparison function for sorting lsa_DomainInformation array
 918 */
 919 static int compare_DomainInformation(struct lsa_DomainInformation *e1, struct lsa_DomainInformation *e2)
 920 {
 921         return strcasecmp(e1->name.string, e2->name.string);
 922 }
 923
 924 /*
 925   lsa_EnumTrustDom
 926 */
 927 static NTSTATUS lsa_EnumTrustDom(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 928                                  struct lsa_EnumTrustDom *r)
 929 {
 930         struct dcesrv_handle *policy_handle;
 931         struct lsa_DomainInformation *entries;
 932         struct lsa_policy_state *policy_state;
 933         struct ldb_message **domains;
 934         const char *attrs[] = {
 935                 "flatname",
 936                 "securityIdentifier",
 937                 NULL
 938         };
 939
 940
 941         int count, i;
 942
 943         *r->out.resume_handle = 0;
 944
 945         r->out.domains->domains = NULL;
 946         r->out.domains->count = 0;
 947
 948         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
 949
 950         policy_state = policy_handle->data;
 951
 952         /* search for all users in this domain. This could possibly be cached and
 953            resumed based on resume_key */
 954         count = gendb_search(policy_state->sam_ldb, mem_ctx, policy_state->system_dn, &domains, attrs,
 955                              "objectclass=trustedDomain");
 956         if (count == -1) {
 957                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 958         }
 959         if (count == 0 || r->in.max_size == 0) {
 960                 return NT_STATUS_OK;
 961         }
 962
 963         /* convert to lsa_DomainInformation format */
 964         entries = talloc_array(mem_ctx, struct lsa_DomainInformation, count);
 965         if (!entries) {
 966                 return NT_STATUS_NO_MEMORY;
 967         }
 968         for (i=0;i<count;i++) {
 969                 entries[i].sid = samdb_result_dom_sid(mem_ctx, domains[i], "securityIdentifier");
 970                 entries[i].name.string = samdb_result_string(domains[i], "flatname", NULL);
 971         }
 972
 973         /* sort the results by name */
 974         qsort(entries, count, sizeof(struct lsa_DomainInformation),
 975               (comparison_fn_t)compare_DomainInformation);
 976
 977         if (*r->in.resume_handle >= count) {
 978                 *r->out.resume_handle = -1;
 979
 980                 return NT_STATUS_NO_MORE_ENTRIES;
 981         }
 982
 983         /* return the rest, limit by max_size. Note that we
 984            use the w2k3 element size value of 60 */
 985         r->out.domains->count = count - *r->in.resume_handle;
 986         r->out.domains->count = MIN(r->out.domains->count,
 987                                  1+(r->in.max_size/LSA_ENUM_TRUST_DOMAIN_MULTIPLIER));
 988
 989         r->out.domains->domains = entries + *r->in.resume_handle;
 990         r->out.domains->count = r->out.domains->count;
 991
 992         if (r->out.domains->count < count - *r->in.resume_handle) {
 993                 *r->out.resume_handle = *r->in.resume_handle + r->out.domains->count;
 994                 return STATUS_MORE_ENTRIES;
 995         }
 996
 997         return NT_STATUS_OK;
 998 }
 999
1000
1001 /*
1002   return the authority name and authority sid, given a sid
1003 */
1004 static NTSTATUS lsa_authority_name(struct lsa_policy_state *state,
1005                                    TALLOC_CTX *mem_ctx, struct dom_sid *sid,
1006                                    const char **authority_name,
1007                                    struct dom_sid **authority_sid)
1008 {
1009         if (dom_sid_in_domain(state->domain_sid, sid)) {
1010                 *authority_name = state->domain_name;
1011                 *authority_sid = state->domain_sid;
1012                 return NT_STATUS_OK;
1013         }
1014
1015         if (dom_sid_in_domain(state->builtin_sid, sid)) {
1016                 *authority_name = "BUILTIN";
1017                 *authority_sid = state->builtin_sid;
1018                 return NT_STATUS_OK;
1019         }
1020
1021         *authority_sid = dom_sid_dup(mem_ctx, sid);
1022         if (*authority_sid == NULL) {
1023                 return NT_STATUS_NO_MEMORY;
1024         }
1025         (*authority_sid)->num_auths = 0;
1026         *authority_name = dom_sid_string(mem_ctx, *authority_sid);
1027         if (*authority_name == NULL) {
1028                 return NT_STATUS_NO_MEMORY;
1029         }
1030
1031         return NT_STATUS_OK;
1032 }
1033
1034 /*
1035   add to the lsa_RefDomainList for LookupSids and LookupNames
1036 */
1037 static NTSTATUS lsa_authority_list(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
1038                                    struct dom_sid *sid,
1039                                    struct lsa_RefDomainList *domains,
1040                                    uint32_t *sid_index)
1041 {
1042         NTSTATUS status;
1043         const char *authority_name;
1044         struct dom_sid *authority_sid;
1045         int i;
1046
1047         /* work out the authority name */
1048         status = lsa_authority_name(state, mem_ctx, sid,
1049                                     &authority_name, &authority_sid);
1050         if (!NT_STATUS_IS_OK(status)) {
1051                 return status;
1052         }
1053
1054         /* see if we've already done this authority name */
1055         for (i=0;i<domains->count;i++) {
1056                 if (strcmp(authority_name, domains->domains[i].name.string) == 0) {
1057                         *sid_index = i;
1058                         return NT_STATUS_OK;
1059                 }
1060         }
1061
1062         domains->domains = talloc_realloc(domains,
1063                                             domains->domains,
1064                                             struct lsa_TrustInformation,
1065                                             domains->count+1);
1066         if (domains->domains == NULL) {
1067                 return NT_STATUS_NO_MEMORY;
1068         }
1069         domains->domains[i].name.string = authority_name;
1070         domains->domains[i].sid         = authority_sid;
1071         domains->count++;
1072         *sid_index = i;
1073
1074         return NT_STATUS_OK;
1075 }
1076
1077 /*
1078   lookup a name for 1 SID
1079 */
1080 static NTSTATUS lsa_lookup_sid(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
1081                                struct dom_sid *sid, const char *sid_str,
1082                                const char **name, uint32_t *atype)
1083 {
1084         int ret;
1085         struct ldb_message **res;
1086         const char * const attrs[] = { "sAMAccountName", "sAMAccountType", "name", NULL};
1087         NTSTATUS status;
1088
1089         ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs,
1090                            "objectSid=%s", ldap_encode_ndr_dom_sid(mem_ctx, sid));
1091         if (ret == 1) {
1092                 *name = ldb_msg_find_string(res[0], "sAMAccountName", NULL);
1093                 if (!*name) {
1094                         *name = ldb_msg_find_string(res[0], "name", NULL);
1095                         if (!*name) {
1096                                 *name = talloc_strdup(mem_ctx, sid_str);
1097                                 NTSTATUS_TALLOC_CHECK(*name);
1098                         }
1099                 }
1100
1101                 *atype = samdb_result_uint(res[0], "sAMAccountType", 0);
1102
1103                 return NT_STATUS_OK;
1104         }
1105
1106         status = sidmap_allocated_sid_lookup(state->sidmap, mem_ctx, sid, name, atype);
1107
1108         return status;
1109 }
1110
1111
1112 /*
1113   lsa_LookupSids3
1114 */
1115 static NTSTATUS lsa_LookupSids3(struct dcesrv_call_state *dce_call,
1116                                 TALLOC_CTX *mem_ctx,
1117                                 struct lsa_LookupSids3 *r)
1118 {
1119         struct lsa_policy_state *state;
1120         int i;
1121         NTSTATUS status = NT_STATUS_OK;
1122
1123         r->out.domains = NULL;
1124
1125         status = lsa_get_policy_state(dce_call, mem_ctx, &state);
1126         if (!NT_STATUS_IS_OK(status)) {
1127                 return status;
1128         }
1129
1130         r->out.domains = talloc_zero(mem_ctx,  struct lsa_RefDomainList);
1131         if (r->out.domains == NULL) {
1132                 return NT_STATUS_NO_MEMORY;
1133         }
1134
1135         r->out.names = talloc_zero(mem_ctx,  struct lsa_TransNameArray2);
1136         if (r->out.names == NULL) {
1137                 return NT_STATUS_NO_MEMORY;
1138         }
1139
1140         *r->out.count = 0;
1141
1142         r->out.names->names = talloc_array(r->out.names, struct lsa_TranslatedName2,
1143                                              r->in.sids->num_sids);
1144         if (r->out.names->names == NULL) {
1145                 return NT_STATUS_NO_MEMORY;
1146         }
1147
1148         for (i=0;i<r->in.sids->num_sids;i++) {
1149                 struct dom_sid *sid = r->in.sids->sids[i].sid;
1150                 char *sid_str = dom_sid_string(mem_ctx, sid);
1151                 const char *name;
1152                 uint32_t atype, rtype, sid_index;
1153                 NTSTATUS status2;
1154
1155                 r->out.names->count++;
1156                 (*r->out.count)++;
1157
1158                 r->out.names->names[i].sid_type    = SID_NAME_UNKNOWN;
1159                 r->out.names->names[i].name.string = sid_str;
1160                 r->out.names->names[i].sid_index   = 0xFFFFFFFF;
1161                 r->out.names->names[i].unknown     = 0;
1162
1163                 if (sid_str == NULL) {
1164                         r->out.names->names[i].name.string = "(SIDERROR)";
1165                         status = STATUS_SOME_UNMAPPED;
1166                         continue;
1167                 }
1168
1169                 /* work out the authority name */
1170                 status2 = lsa_authority_list(state, mem_ctx, sid, r->out.domains, &sid_index);
1171                 if (!NT_STATUS_IS_OK(status2)) {
1172                         return status2;
1173                 }
1174
1175                 status2 = lsa_lookup_sid(state, mem_ctx, sid, sid_str,
1176                                          &name, &atype);
1177                 if (!NT_STATUS_IS_OK(status2)) {
1178                         status = STATUS_SOME_UNMAPPED;
1179                         continue;
1180                 }
1181
1182                 rtype = samdb_atype_map(atype);
1183                 if (rtype == SID_NAME_UNKNOWN) {
1184                         status = STATUS_SOME_UNMAPPED;
1185                         continue;
1186                 }
1187
1188                 r->out.names->names[i].sid_type    = rtype;
1189                 r->out.names->names[i].name.string = name;
1190                 r->out.names->names[i].sid_index   = sid_index;
1191                 r->out.names->names[i].unknown     = 0;
1192         }
1193
1194         return status;
1195 }
1196
1197
1198 /*
1199   lsa_LookupSids2
1200 */
1201 static NTSTATUS lsa_LookupSids2(struct dcesrv_call_state *dce_call,
1202                                 TALLOC_CTX *mem_ctx,
1203                                 struct lsa_LookupSids2 *r)
1204 {
1205         struct lsa_LookupSids3 r3;
1206         NTSTATUS status;
1207
1208         r3.in.sids     = r->in.sids;
1209         r3.in.names    = r->in.names;
1210         r3.in.level    = r->in.level;
1211         r3.in.count    = r->in.count;
1212         r3.in.unknown1 = r->in.unknown1;
1213         r3.in.unknown2 = r->in.unknown2;
1214         r3.out.count   = r->out.count;
1215         r3.out.names   = r->out.names;
1216
1217         status = lsa_LookupSids3(dce_call, mem_ctx, &r3);
1218         if (dce_call->fault_code != 0) {
1219                 return status;
1220         }
1221
1222         r->out.domains = r3.out.domains;
1223         r->out.names   = r3.out.names;
1224         r->out.count   = r3.out.count;
1225
1226         return status;
1227 }
1228
1229
1230 /*
1231   lsa_LookupSids
1232 */
1233 static NTSTATUS lsa_LookupSids(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1234                                struct lsa_LookupSids *r)
1235 {
1236         struct lsa_LookupSids3 r3;
1237         NTSTATUS status;
1238         int i;
1239
1240         r3.in.sids     = r->in.sids;
1241         r3.in.names    = NULL;
1242         r3.in.level    = r->in.level;
1243         r3.in.count    = r->in.count;
1244         r3.in.unknown1 = 0;
1245         r3.in.unknown2 = 0;
1246         r3.out.count   = r->out.count;
1247
1248         status = lsa_LookupSids3(dce_call, mem_ctx, &r3);
1249         if (dce_call->fault_code != 0) {
1250                 return status;
1251         }
1252
1253         r->out.domains = r3.out.domains;
1254         r->out.names = talloc(mem_ctx, struct lsa_TransNameArray);
1255         if (r->out.names == NULL) {
1256                 return NT_STATUS_NO_MEMORY;
1257         }
1258         r->out.names->count = r3.out.names->count;
1259         r->out.names->names = talloc_array(r->out.names, struct lsa_TranslatedName,
1260                                              r->out.names->count);
1261         if (r->out.names->names == NULL) {
1262                 return NT_STATUS_NO_MEMORY;
1263         }
1264         for (i=0;i<r->out.names->count;i++) {
1265                 r->out.names->names[i].sid_type    = r3.out.names->names[i].sid_type;
1266                 r->out.names->names[i].name.string = r3.out.names->names[i].name.string;
1267                 r->out.names->names[i].sid_index   = r3.out.names->names[i].sid_index;
1268         }
1269
1270         return status;
1271 }
1272
1273
1274 /*
1275   lsa_OpenAccount
1276 */
1277 static NTSTATUS lsa_OpenAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1278                                 struct lsa_OpenAccount *r)
1279 {
1280         struct dcesrv_handle *h, *ah;
1281         struct lsa_policy_state *state;
1282         struct lsa_account_state *astate;
1283
1284         ZERO_STRUCTP(r->out.acct_handle);
1285
1286         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
1287
1288         state = h->data;
1289
1290         astate = talloc(dce_call->conn, struct lsa_account_state);
1291         if (astate == NULL) {
1292                 return NT_STATUS_NO_MEMORY;
1293         }
1294
1295         astate->account_sid = dom_sid_dup(astate, r->in.sid);
1296         if (astate->account_sid == NULL) {
1297                 talloc_free(astate);
1298                 return NT_STATUS_NO_MEMORY;
1299         }
1300
1301         /* check it really exists */
1302         astate->account_dn =
1303                 samdb_search_string(state->sam_ldb, astate,
1304                                     NULL, "dn",
1305                                     "(&(objectSid=%s)(objectClass=group))",
1306                                     ldap_encode_ndr_dom_sid(mem_ctx,
1307                                                             astate->account_sid));
1308         if (astate->account_dn == NULL) {
1309                 talloc_free(astate);
1310                 return NT_STATUS_NO_SUCH_USER;
1311         }
1312
1313         astate->policy = talloc_reference(astate, state);
1314         astate->access_mask = r->in.access_mask;
1315
1316         ah = dcesrv_handle_new(dce_call->context, LSA_HANDLE_ACCOUNT);
1317         if (!ah) {
1318                 talloc_free(astate);
1319                 return NT_STATUS_NO_MEMORY;
1320         }
1321
1322         ah->data = talloc_steal(ah, astate);
1323
1324         *r->out.acct_handle = ah->wire_handle;
1325
1326         return NT_STATUS_OK;
1327 }
1328
1329
1330 /*
1331   lsa_EnumPrivsAccount
1332 */
1333 static NTSTATUS lsa_EnumPrivsAccount(struct dcesrv_call_state *dce_call,
1334                                      TALLOC_CTX *mem_ctx,
1335                                      struct lsa_EnumPrivsAccount *r)
1336 {
1337         struct dcesrv_handle *h;
1338         struct lsa_account_state *astate;
1339         int ret, i;
1340         struct ldb_message **res;
1341         const char * const attrs[] = { "privilege", NULL};
1342         struct ldb_message_element *el;
1343
1344         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
1345
1346         astate = h->data;
1347
1348         r->out.privs = talloc(mem_ctx, struct lsa_PrivilegeSet);
1349         r->out.privs->count = 0;
1350         r->out.privs->unknown = 0;
1351         r->out.privs->set = NULL;
1352
1353         ret = gendb_search_dn(astate->policy->sam_ldb, mem_ctx,
1354                               astate->account_dn, &res, attrs);
1355         if (ret != 1) {
1356                 return NT_STATUS_OK;
1357         }
1358
1359         el = ldb_msg_find_element(res[0], "privilege");
1360         if (el == NULL || el->num_values == 0) {
1361                 return NT_STATUS_OK;
1362         }
1363
1364         r->out.privs->set = talloc_array(r->out.privs,
1365                                            struct lsa_LUIDAttribute, el->num_values);
1366         if (r->out.privs->set == NULL) {
1367                 return NT_STATUS_NO_MEMORY;
1368         }
1369
1370         for (i=0;i<el->num_values;i++) {
1371                 int id = sec_privilege_id((const char *)el->values[i].data);
1372                 if (id == -1) {
1373                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
1374                 }
1375                 r->out.privs->set[i].attribute = 0;
1376                 r->out.privs->set[i].luid.low = id;
1377                 r->out.privs->set[i].luid.high = 0;
1378         }
1379
1380         r->out.privs->count = el->num_values;
1381
1382         return NT_STATUS_OK;
1383 }
1384
1385 /*
1386   lsa_EnumAccountRights
1387 */
1388 static NTSTATUS lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
1389                                       TALLOC_CTX *mem_ctx,
1390                                       struct lsa_EnumAccountRights *r)
1391 {
1392         struct dcesrv_handle *h;
1393         struct lsa_policy_state *state;
1394         int ret, i;
1395         struct ldb_message **res;
1396         const char * const attrs[] = { "privilege", NULL};
1397         const char *sidstr;
1398         struct ldb_message_element *el;
1399
1400         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
1401
1402         state = h->data;
1403
1404         sidstr = ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid);
1405         if (sidstr == NULL) {
1406                 return NT_STATUS_NO_MEMORY;
1407         }
1408
1409         ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs,
1410                            "objectSid=%s", sidstr);
1411         if (ret != 1) {
1412                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1413         }
1414
1415         el = ldb_msg_find_element(res[0], "privilege");
1416         if (el == NULL || el->num_values == 0) {
1417                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1418         }
1419
1420         r->out.rights->count = el->num_values;
1421         r->out.rights->names = talloc_array(r->out.rights,
1422                                               struct lsa_String, r->out.rights->count);
1423         if (r->out.rights->names == NULL) {
1424                 return NT_STATUS_NO_MEMORY;
1425         }
1426
1427         for (i=0;i<el->num_values;i++) {
1428                 r->out.rights->names[i].string = (const char *)el->values[i].data;
1429         }
1430
1431         return NT_STATUS_OK;
1432 }
1433
1434
1435
1436 /*
1437   helper for lsa_AddAccountRights and lsa_RemoveAccountRights
1438 */
1439 static NTSTATUS lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_call,
1440                                            TALLOC_CTX *mem_ctx,
1441                                            struct lsa_policy_state *state,
1442                                            int ldb_flag,
1443                                            struct dom_sid *sid,
1444                                            const struct lsa_RightSet *rights)
1445 {
1446         const char *sidstr;
1447         struct ldb_message *msg;
1448         struct ldb_message_element el;
1449         int i, ret;
1450         const char *dn;
1451         struct lsa_EnumAccountRights r2;
1452
1453         sidstr = ldap_encode_ndr_dom_sid(mem_ctx, sid);
1454         if (sidstr == NULL) {
1455                 return NT_STATUS_NO_MEMORY;
1456         }
1457
1458         msg = ldb_msg_new(mem_ctx);
1459         if (msg == NULL) {
1460                 return NT_STATUS_NO_MEMORY;
1461         }
1462
1463         dn = samdb_search_string(state->sam_ldb, mem_ctx, NULL, "dn",
1464                                  "objectSid=%s", sidstr);
1465         if (dn == NULL) {
1466                 return NT_STATUS_NO_SUCH_USER;
1467         }
1468
1469         msg->dn = talloc_strdup(mem_ctx, dn);
1470         if (msg->dn == NULL) {
1471                 return NT_STATUS_NO_MEMORY;
1472         }
1473
1474         if (ldb_msg_add_empty(state->sam_ldb, msg, "privilege", ldb_flag)) {
1475                 return NT_STATUS_NO_MEMORY;
1476         }
1477
1478         if (ldb_flag == LDB_FLAG_MOD_ADD) {
1479                 NTSTATUS status;
1480
1481                 r2.in.handle = &state->handle->wire_handle;
1482                 r2.in.sid = sid;
1483                 r2.out.rights = talloc(mem_ctx, struct lsa_RightSet);
1484
1485                 status = lsa_EnumAccountRights(dce_call, mem_ctx, &r2);
1486                 if (!NT_STATUS_IS_OK(status)) {
1487                         ZERO_STRUCTP(r2.out.rights);
1488                 }
1489         }
1490
1491         el.num_values = 0;
1492         el.values = talloc_array(mem_ctx, struct ldb_val, rights->count);
1493         if (el.values == NULL) {
1494                 return NT_STATUS_NO_MEMORY;
1495         }
1496         for (i=0;i<rights->count;i++) {
1497                 if (sec_privilege_id(rights->names[i].string) == -1) {
1498                         return NT_STATUS_NO_SUCH_PRIVILEGE;
1499                 }
1500
1501                 if (ldb_flag == LDB_FLAG_MOD_ADD) {
1502                         int j;
1503                         for (j=0;j<r2.out.rights->count;j++) {
1504                                 if (StrCaseCmp(r2.out.rights->names[j].string,
1505                                                rights->names[i].string) == 0) {
1506                                         break;
1507                                 }
1508                         }
1509                         if (j != r2.out.rights->count) continue;
1510                 }
1511
1512
1513                 el.values[el.num_values].length = strlen(rights->names[i].string);
1514                 el.values[el.num_values].data = (uint8_t *)talloc_strdup(mem_ctx, rights->names[i].string);
1515                 if (el.values[el.num_values].data == NULL) {
1516                         return NT_STATUS_NO_MEMORY;
1517                 }
1518                 el.num_values++;
1519         }
1520
1521         if (el.num_values == 0) {
1522                 return NT_STATUS_OK;
1523         }
1524
1525         ret = samdb_modify(state->sam_ldb, mem_ctx, msg);
1526         if (ret != 0) {
1527                 if (ldb_flag == LDB_FLAG_MOD_DELETE) {
1528                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1529                 }
1530                 return NT_STATUS_UNEXPECTED_IO_ERROR;
1531         }
1532
1533         return NT_STATUS_OK;
1534 }
1535
1536 /*
1537   lsa_AddPrivilegesToAccount
1538 */
1539 static NTSTATUS lsa_AddPrivilegesToAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1540                                            struct lsa_AddPrivilegesToAccount *r)
1541 {
1542         struct lsa_RightSet rights;
1543         struct dcesrv_handle *h;
1544         struct lsa_account_state *astate;
1545         int i;
1546
1547         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
1548
1549         astate = h->data;
1550
1551         rights.count = r->in.privs->count;
1552         rights.names = talloc_array(mem_ctx, struct lsa_String, rights.count);
1553         if (rights.names == NULL) {
1554                 return NT_STATUS_NO_MEMORY;
1555         }
1556         for (i=0;i<rights.count;i++) {
1557                 int id = r->in.privs->set[i].luid.low;
1558                 if (r->in.privs->set[i].luid.high) {
1559                         return NT_STATUS_NO_SUCH_PRIVILEGE;
1560                 }
1561                 rights.names[i].string = sec_privilege_name(id);
1562                 if (rights.names[i].string == NULL) {
1563                         return NT_STATUS_NO_SUCH_PRIVILEGE;
1564                 }
1565         }
1566
1567         return lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
1568                                           LDB_FLAG_MOD_ADD, astate->account_sid,
1569                                           &rights);
1570 }
1571
1572
1573 /*
1574   lsa_RemovePrivilegesFromAccount
1575 */
1576 static NTSTATUS lsa_RemovePrivilegesFromAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1577                                                 struct lsa_RemovePrivilegesFromAccount *r)
1578 {
1579         struct lsa_RightSet *rights;
1580         struct dcesrv_handle *h;
1581         struct lsa_account_state *astate;
1582         int i;
1583
1584         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
1585
1586         astate = h->data;
1587
1588         rights = talloc(mem_ctx, struct lsa_RightSet);
1589
1590         if (r->in.remove_all == 1 &&
1591             r->in.privs == NULL) {
1592                 struct lsa_EnumAccountRights r2;
1593                 NTSTATUS status;
1594
1595                 r2.in.handle = &astate->policy->handle->wire_handle;
1596                 r2.in.sid = astate->account_sid;
1597                 r2.out.rights = rights;
1598
1599                 status = lsa_EnumAccountRights(dce_call, mem_ctx, &r2);
1600                 if (!NT_STATUS_IS_OK(status)) {
1601                         return status;
1602                 }
1603
1604                 return lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
1605                                                   LDB_FLAG_MOD_DELETE, astate->account_sid,
1606                                                   r2.out.rights);
1607         }
1608
1609         if (r->in.remove_all != 0) {
1610                 return NT_STATUS_INVALID_PARAMETER;
1611         }
1612
1613         rights->count = r->in.privs->count;
1614         rights->names = talloc_array(mem_ctx, struct lsa_String, rights->count);
1615         if (rights->names == NULL) {
1616                 return NT_STATUS_NO_MEMORY;
1617         }
1618         for (i=0;i<rights->count;i++) {
1619                 int id = r->in.privs->set[i].luid.low;
1620                 if (r->in.privs->set[i].luid.high) {
1621                         return NT_STATUS_NO_SUCH_PRIVILEGE;
1622                 }
1623                 rights->names[i].string = sec_privilege_name(id);
1624                 if (rights->names[i].string == NULL) {
1625                         return NT_STATUS_NO_SUCH_PRIVILEGE;
1626                 }
1627         }
1628
1629         return lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
1630                                           LDB_FLAG_MOD_DELETE, astate->account_sid,
1631                                           rights);
1632 }
1633
1634
1635 /*
1636   lsa_GetQuotasForAccount
1637 */
1638 static NTSTATUS lsa_GetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1639                        struct lsa_GetQuotasForAccount *r)
1640 {
1641         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1642 }
1643
1644
1645 /*
1646   lsa_SetQuotasForAccount
1647 */
1648 static NTSTATUS lsa_SetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1649                        struct lsa_SetQuotasForAccount *r)
1650 {
1651         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1652 }
1653
1654
1655 /*
1656   lsa_GetSystemAccessAccount
1657 */
1658 static NTSTATUS lsa_GetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1659                        struct lsa_GetSystemAccessAccount *r)
1660 {
1661         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1662 }
1663
1664
1665 /*
1666   lsa_SetSystemAccessAccount
1667 */
1668 static NTSTATUS lsa_SetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1669                        struct lsa_SetSystemAccessAccount *r)
1670 {
1671         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1672 }
1673
1674
1675 /*
1676   lsa_CreateSecret
1677 */
1678 static NTSTATUS lsa_CreateSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1679                                  struct lsa_CreateSecret *r)
1680 {
1681         struct dcesrv_handle *policy_handle;
1682         struct lsa_policy_state *policy_state;
1683         struct lsa_secret_state *secret_state;
1684         struct dcesrv_handle *handle;
1685         struct ldb_message **msgs, *msg;
1686         const char *attrs[] = {
1687                 NULL
1688         };
1689
1690         const char *name;
1691
1692         int ret;
1693
1694         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
1695         ZERO_STRUCTP(r->out.sec_handle);
1696
1697         policy_state = policy_handle->data;
1698
1699         if (!r->in.name.string) {
1700                 return NT_STATUS_INVALID_PARAMETER;
1701         }
1702
1703         secret_state = talloc(mem_ctx, struct lsa_secret_state);
1704         if (!secret_state) {
1705                 return NT_STATUS_NO_MEMORY;
1706         }
1707         secret_state->policy = policy_state;
1708
1709         msg = ldb_msg_new(mem_ctx);
1710         if (msg == NULL) {
1711                 return NT_STATUS_NO_MEMORY;
1712         }
1713
1714         if (strncmp("G$", r->in.name.string, 2) == 0) {
1715                 const char *name2;
1716                 name = &r->in.name.string[2];
1717                 secret_state->sam_ldb = talloc_reference(secret_state, policy_state->sam_ldb);
1718                 secret_state->global = True;
1719
1720                 if (strlen(name) < 1) {
1721                         return NT_STATUS_INVALID_PARAMETER;
1722                 }
1723
1724                 name2 = talloc_asprintf(mem_ctx, "%s Secret", name);
1725                 /* search for the secret record */
1726                 ret = gendb_search(secret_state->sam_ldb,
1727                                    mem_ctx, policy_state->system_dn, &msgs, attrs,
1728                                    "(&(cn=%s)(objectclass=secret))",
1729                                    name2);
1730                 if (ret > 0) {
1731                         return NT_STATUS_OBJECT_NAME_COLLISION;
1732                 }
1733
1734                 if (ret < 0 || ret > 1) {
1735                         DEBUG(0,("Found %d records matching DN %s\n", ret, policy_state->system_dn));
1736                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
1737                 }
1738
1739                 msg->dn = talloc_asprintf(mem_ctx, "cn=%s,%s", name2, policy_state->system_dn);
1740                 if (!name2 || !msg->dn) {
1741                         return NT_STATUS_NO_MEMORY;
1742                 }
1743
1744                 samdb_msg_add_string(secret_state->sam_ldb, mem_ctx, msg, "cn", name2);
1745
1746         } else {
1747                 secret_state->global = False;
1748
1749                 name = r->in.name.string;
1750                 if (strlen(name) < 1) {
1751                         return NT_STATUS_INVALID_PARAMETER;
1752                 }
1753
1754                 secret_state->sam_ldb = talloc_reference(secret_state, secrets_db_connect(mem_ctx));
1755                 /* search for the secret record */
1756                 ret = gendb_search(secret_state->sam_ldb,
1757                                    mem_ctx, "cn=LSA Secrets", &msgs, attrs,
1758                                    "(&(cn=%s)(objectclass=secret))",
1759                                    name);
1760                 if (ret > 0) {
1761                         return NT_STATUS_OBJECT_NAME_COLLISION;
1762                 }
1763
1764                 if (ret < 0 || ret > 1) {
1765                         DEBUG(0,("Found %d records matching DN %s\n", ret, policy_state->system_dn));
1766                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
1767                 }
1768
1769                 msg->dn = talloc_asprintf(mem_ctx, "cn=%s,cn=LSA Secrets", name);
1770                 samdb_msg_add_string(secret_state->sam_ldb, mem_ctx, msg, "cn", name);
1771         }
1772
1773         /* pull in all the template attributes.  Note this is always from the global samdb */
1774         ret = samdb_copy_template(secret_state->policy->sam_ldb, mem_ctx, msg,
1775                                   "(&(name=TemplateSecret)(objectclass=secretTemplate))");
1776         if (ret != 0) {
1777                 DEBUG(0,("Failed to load TemplateSecret from samdb\n"));
1778                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1779         }
1780
1781         samdb_msg_add_string(secret_state->sam_ldb, mem_ctx, msg, "objectClass", "secret");
1782
1783         secret_state->secret_dn = talloc_reference(secret_state, msg->dn);
1784
1785         /* create the secret */
1786         ret = samdb_add(secret_state->sam_ldb, mem_ctx, msg);
1787         if (ret != 0) {
1788                 DEBUG(0,("Failed to create secret record %s\n", msg->dn));
1789                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1790         }
1791
1792         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_SECRET);
1793         if (!handle) {
1794                 return NT_STATUS_NO_MEMORY;
1795         }
1796
1797         handle->data = talloc_steal(handle, secret_state);
1798
1799         secret_state->access_mask = r->in.access_mask;
1800         secret_state->policy = talloc_reference(secret_state, policy_state);
1801
1802         *r->out.sec_handle = handle->wire_handle;
1803
1804         return NT_STATUS_OK;
1805 }
1806
1807
1808 /*
1809   lsa_OpenSecret
1810 */
1811 static NTSTATUS lsa_OpenSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1812                                struct lsa_OpenSecret *r)
1813 {
1814         struct dcesrv_handle *policy_handle;
1815
1816         struct lsa_policy_state *policy_state;
1817         struct lsa_secret_state *secret_state;
1818         struct dcesrv_handle *handle;
1819         struct ldb_message **msgs;
1820         const char *attrs[] = {
1821                 NULL
1822         };
1823
1824         const char *name;
1825
1826         int ret;
1827
1828         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
1829         ZERO_STRUCTP(r->out.sec_handle);
1830         policy_state = policy_handle->data;
1831
1832         if (!r->in.name.string) {
1833                 return NT_STATUS_INVALID_PARAMETER;
1834         }
1835
1836         secret_state = talloc(mem_ctx, struct lsa_secret_state);
1837         if (!secret_state) {
1838                 return NT_STATUS_NO_MEMORY;
1839         }
1840         secret_state->policy = policy_state;
1841
1842         if (strncmp("G$", r->in.name.string, 2) == 0) {
1843                 name = &r->in.name.string[2];
1844                 secret_state->sam_ldb = talloc_reference(secret_state, policy_state->sam_ldb);
1845                 secret_state->global = True;
1846
1847                 if (strlen(name) < 1) {
1848                         return NT_STATUS_INVALID_PARAMETER;
1849                 }
1850
1851                 /* search for the secret record */
1852                 ret = gendb_search(secret_state->sam_ldb,
1853                                    mem_ctx, policy_state->system_dn, &msgs, attrs,
1854                                    "(&(cn=%s Secret)(objectclass=secret))",
1855                                    name);
1856                 if (ret == 0) {
1857                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1858                 }
1859
1860                 if (ret != 1) {
1861                         DEBUG(0,("Found %d records matching DN %s\n", ret, policy_state->system_dn));
1862                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
1863                 }
1864
1865         } else {
1866                 secret_state->sam_ldb = talloc_reference(secret_state, secrets_db_connect(mem_ctx));
1867
1868                 secret_state->global = False;
1869                 name = r->in.name.string;
1870                 if (strlen(name) < 1) {
1871                         return NT_STATUS_INVALID_PARAMETER;
1872                 }
1873
1874                 /* search for the secret record */
1875                 ret = gendb_search(secret_state->sam_ldb,
1876                                    mem_ctx, "cn=LSA Secrets", &msgs, attrs,
1877                                    "(&(cn=%s)(objectclass=secret))",
1878                                    name);
1879                 if (ret == 0) {
1880                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1881                 }
1882
1883                 if (ret != 1) {
1884                         DEBUG(0,("Found %d records matching DN %s\n", ret, policy_state->system_dn));
1885                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
1886                 }
1887         }
1888
1889         secret_state->secret_dn = talloc_reference(secret_state, msgs[0]->dn);
1890
1891         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_SECRET);
1892         if (!handle) {
1893                 return NT_STATUS_NO_MEMORY;
1894         }
1895
1896         handle->data = talloc_steal(handle, secret_state);
1897
1898         secret_state->access_mask = r->in.access_mask;
1899         secret_state->policy = talloc_reference(secret_state, policy_state);
1900
1901         *r->out.sec_handle = handle->wire_handle;
1902
1903         return NT_STATUS_OK;
1904 }
1905
1906
1907 /*
1908   lsa_SetSecret
1909 */
1910 static NTSTATUS lsa_SetSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1911                               struct lsa_SetSecret *r)
1912 {
1913
1914         struct dcesrv_handle *h;
1915         struct lsa_secret_state *secret_state;
1916         struct ldb_message *msg;
1917         DATA_BLOB session_key;
1918         DATA_BLOB crypt_secret, secret;
1919         struct ldb_val val;
1920         int ret;
1921         NTSTATUS status = NT_STATUS_OK;
1922
1923         struct timeval now = timeval_current();
1924         NTTIME nt_now = timeval_to_nttime(&now);
1925
1926         DCESRV_PULL_HANDLE(h, r->in.sec_handle, LSA_HANDLE_SECRET);
1927
1928         secret_state = h->data;
1929
1930         msg = ldb_msg_new(mem_ctx);
1931         if (msg == NULL) {
1932                 return NT_STATUS_NO_MEMORY;
1933         }
1934
1935         msg->dn = talloc_reference(mem_ctx, secret_state->secret_dn);
1936         if (!msg->dn) {
1937                 return NT_STATUS_NO_MEMORY;
1938         }
1939         status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
1940         if (!NT_STATUS_IS_OK(status)) {
1941                 return status;
1942         }
1943
1944         if (r->in.old_val) {
1945                 /* Decrypt */
1946                 crypt_secret.data = r->in.old_val->data;
1947                 crypt_secret.length = r->in.old_val->size;
1948
1949                 status = sess_decrypt_blob(mem_ctx, &crypt_secret, &session_key, &secret);
1950                 if (!NT_STATUS_IS_OK(status)) {
1951                         return status;
1952                 }
1953
1954                 val.data = secret.data;
1955                 val.length = secret.length;
1956
1957                 /* set value */
1958                 if (samdb_msg_add_value(secret_state->sam_ldb,
1959                                         mem_ctx, msg, "priorSecret", &val) != 0) {
1960                         return NT_STATUS_NO_MEMORY;
1961                 }
1962
1963                 /* set old value mtime */
1964                 if (samdb_msg_add_uint64(secret_state->sam_ldb,
1965                                          mem_ctx, msg, "priorSetTime", nt_now) != 0) {
1966                         return NT_STATUS_NO_MEMORY;
1967                 }
1968
1969                 if (!r->in.new_val) {
1970                         /* This behaviour varies depending of if this is a local, or a global secret... */
1971                         if (secret_state->global) {
1972                                 /* set old value mtime */
1973                                 if (samdb_msg_add_uint64(secret_state->sam_ldb,
1974                                                          mem_ctx, msg, "lastSetTime", nt_now) != 0) {
1975                                         return NT_STATUS_NO_MEMORY;
1976                                 }
1977                         } else {
1978                                 if (samdb_msg_add_delete(secret_state->sam_ldb,
1979                                                          mem_ctx, msg, "secret")) {
1980                                         return NT_STATUS_NO_MEMORY;
1981                                 }
1982                                 if (samdb_msg_add_delete(secret_state->sam_ldb,
1983                                                          mem_ctx, msg, "lastSetTime")) {
1984                                         return NT_STATUS_NO_MEMORY;
1985                                 }
1986                         }
1987                 }
1988         }
1989
1990         if (r->in.new_val) {
1991                 /* Decrypt */
1992                 crypt_secret.data = r->in.new_val->data;
1993                 crypt_secret.length = r->in.new_val->size;
1994
1995                 status = sess_decrypt_blob(mem_ctx, &crypt_secret, &session_key, &secret);
1996                 if (!NT_STATUS_IS_OK(status)) {
1997                         return status;
1998                 }
1999
2000                 val.data = secret.data;
2001                 val.length = secret.length;
2002
2003                 /* set value */
2004                 if (samdb_msg_add_value(secret_state->sam_ldb,
2005                                         mem_ctx, msg, "secret", &val) != 0) {
2006                         return NT_STATUS_NO_MEMORY;
2007                 }
2008
2009                 /* set new value mtime */
2010                 if (samdb_msg_add_uint64(secret_state->sam_ldb,
2011                                          mem_ctx, msg, "lastSetTime", nt_now) != 0) {
2012                         return NT_STATUS_NO_MEMORY;
2013                 }
2014
2015                 /* If the old value is not set, then migrate the
2016                  * current value to the old value */
2017                 if (!r->in.old_val) {
2018                         const struct ldb_val *new_val;
2019                         NTTIME last_set_time;
2020                         struct ldb_message **res;
2021                         const char *attrs[] = {
2022                                 "secret",
2023                                 "lastSetTime",
2024                                 NULL
2025                         };
2026
2027                         /* search for the secret record */
2028                         ret = gendb_search_dn(secret_state->sam_ldb,mem_ctx,
2029                                               secret_state->secret_dn, &res, attrs);
2030                         if (ret == 0) {
2031                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2032                         }
2033
2034                         if (ret != 1) {
2035                                 DEBUG(0,("Found %d records matching dn=%s\n", ret, secret_state->secret_dn));
2036                                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2037                         }
2038
2039                         new_val = ldb_msg_find_ldb_val(res[0], "secret");
2040                         last_set_time = ldb_msg_find_uint64(res[0], "lastSetTime", 0);
2041
2042                         if (new_val) {
2043                                 /* set value */
2044                                 if (samdb_msg_add_value(secret_state->sam_ldb,
2045                                                         mem_ctx, msg, "priorSecret",
2046                                                         new_val) != 0) {
2047                                         return NT_STATUS_NO_MEMORY;
2048                                 }
2049                         }
2050
2051                         /* set new value mtime */
2052                         if (ldb_msg_find_ldb_val(res[0], "lastSetTime")) {
2053                                 if (samdb_msg_add_uint64(secret_state->sam_ldb,
2054                                                          mem_ctx, msg, "priorSetTime", last_set_time) != 0) {
2055                                         return NT_STATUS_NO_MEMORY;
2056                                 }
2057                         }
2058                 }
2059         }
2060
2061         /* modify the samdb record */
2062         ret = samdb_replace(secret_state->sam_ldb, mem_ctx, msg);
2063         if (ret != 0) {
2064                 /* we really need samdb.c to return NTSTATUS */
2065                 return NT_STATUS_UNSUCCESSFUL;
2066         }
2067
2068         return NT_STATUS_OK;
2069 }
2070
2071
2072 /*
2073   lsa_QuerySecret
2074 */
2075 static NTSTATUS lsa_QuerySecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2076                                 struct lsa_QuerySecret *r)
2077 {
2078         struct dcesrv_handle *h;
2079         struct lsa_secret_state *secret_state;
2080         struct ldb_message *msg;
2081         DATA_BLOB session_key;
2082         DATA_BLOB crypt_secret, secret;
2083         int ret;
2084         struct ldb_message **res;
2085         const char *attrs[] = {
2086                 "secret",
2087                 "priorSecret",
2088                 "lastSetTime",
2089                 "priorSetTime",
2090                 NULL
2091         };
2092
2093         NTSTATUS nt_status;
2094
2095         DCESRV_PULL_HANDLE(h, r->in.sec_handle, LSA_HANDLE_SECRET);
2096
2097         secret_state = h->data;
2098
2099         /* pull all the user attributes */
2100         ret = gendb_search_dn(secret_state->sam_ldb, mem_ctx,
2101                               secret_state->secret_dn, &res, attrs);
2102         if (ret != 1) {
2103                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2104         }
2105         msg = res[0];
2106
2107         nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
2108         if (!NT_STATUS_IS_OK(nt_status)) {
2109                 return nt_status;
2110         }
2111
2112         if (r->in.old_val) {
2113                 const struct ldb_val *prior_val;
2114                 r->out.old_val = talloc_zero(mem_ctx, struct lsa_DATA_BUF_PTR);
2115                 if (!r->out.old_val) {
2116                         return NT_STATUS_NO_MEMORY;
2117                 }
2118                 /* Decrypt */
2119                 prior_val = ldb_msg_find_ldb_val(res[0], "priorSecret");
2120
2121                 if (prior_val && prior_val->length) {
2122                         secret.data = prior_val->data;
2123                         secret.length = prior_val->length;
2124
2125                         crypt_secret = sess_encrypt_blob(mem_ctx, &secret, &session_key);
2126                         if (!crypt_secret.length) {
2127                                 return NT_STATUS_NO_MEMORY;
2128                         }
2129                         r->out.old_val->buf = talloc(mem_ctx, struct lsa_DATA_BUF);
2130                         if (!r->out.old_val->buf) {
2131                                 return NT_STATUS_NO_MEMORY;
2132                         }
2133                         r->out.old_val->buf->size = crypt_secret.length;
2134                         r->out.old_val->buf->length = crypt_secret.length;
2135                         r->out.old_val->buf->data = crypt_secret.data;
2136                 }
2137         }
2138
2139         if (r->in.old_mtime) {
2140                 r->out.old_mtime = talloc(mem_ctx, NTTIME);
2141                 if (!r->out.old_mtime) {
2142                         return NT_STATUS_NO_MEMORY;
2143                 }
2144                 *r->out.old_mtime = ldb_msg_find_uint64(res[0], "priorSetTime", 0);
2145         }
2146
2147         if (r->in.new_val) {
2148                 const struct ldb_val *new_val;
2149                 r->out.new_val = talloc_zero(mem_ctx, struct lsa_DATA_BUF_PTR);
2150                 if (!r->out.new_val) {
2151                         return NT_STATUS_NO_MEMORY;
2152                 }
2153
2154                 /* Decrypt */
2155                 new_val = ldb_msg_find_ldb_val(res[0], "secret");
2156
2157                 if (new_val && new_val->length) {
2158                         secret.data = new_val->data;
2159                         secret.length = new_val->length;
2160
2161                         crypt_secret = sess_encrypt_blob(mem_ctx, &secret, &session_key);
2162                         if (!crypt_secret.length) {
2163                                 return NT_STATUS_NO_MEMORY;
2164                         }
2165                         r->out.new_val->buf = talloc(mem_ctx, struct lsa_DATA_BUF);
2166                         if (!r->out.new_val->buf) {
2167                                 return NT_STATUS_NO_MEMORY;
2168                         }
2169                         r->out.new_val->buf->length = crypt_secret.length;
2170                         r->out.new_val->buf->size = crypt_secret.length;
2171                         r->out.new_val->buf->data = crypt_secret.data;
2172                 }
2173         }
2174
2175         if (r->in.new_mtime) {
2176                 r->out.new_mtime = talloc(mem_ctx, NTTIME);
2177                 if (!r->out.new_mtime) {
2178                         return NT_STATUS_NO_MEMORY;
2179                 }
2180                 *r->out.new_mtime = ldb_msg_find_uint64(res[0], "lastSetTime", 0);
2181         }
2182
2183         return NT_STATUS_OK;
2184 }
2185
2186
2187 /*
2188   lsa_LookupPrivValue
2189 */
2190 static NTSTATUS lsa_LookupPrivValue(struct dcesrv_call_state *dce_call,
2191                                     TALLOC_CTX *mem_ctx,
2192                                     struct lsa_LookupPrivValue *r)
2193 {
2194         struct dcesrv_handle *h;
2195         struct lsa_policy_state *state;
2196         int id;
2197
2198         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2199
2200         state = h->data;
2201
2202         id = sec_privilege_id(r->in.name->string);
2203         if (id == -1) {
2204                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2205         }
2206
2207         r->out.luid->low = id;
2208         r->out.luid->high = 0;
2209
2210         return NT_STATUS_OK;
2211 }
2212
2213
2214 /*
2215   lsa_LookupPrivName
2216 */
2217 static NTSTATUS lsa_LookupPrivName(struct dcesrv_call_state *dce_call,
2218                                    TALLOC_CTX *mem_ctx,
2219                                    struct lsa_LookupPrivName *r)
2220 {
2221         struct dcesrv_handle *h;
2222         struct lsa_policy_state *state;
2223         const char *privname;
2224
2225         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2226
2227         state = h->data;
2228
2229         if (r->in.luid->high != 0) {
2230                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2231         }
2232
2233         privname = sec_privilege_name(r->in.luid->low);
2234         if (privname == NULL) {
2235                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2236         }
2237
2238         r->out.name = talloc(mem_ctx, struct lsa_String);
2239         if (r->out.name == NULL) {
2240                 return NT_STATUS_NO_MEMORY;
2241         }
2242         r->out.name->string = privname;
2243
2244         return NT_STATUS_OK;
2245 }
2246
2247
2248 /*
2249   lsa_LookupPrivDisplayName
2250 */
2251 static NTSTATUS lsa_LookupPrivDisplayName(struct dcesrv_call_state *dce_call,
2252                                           TALLOC_CTX *mem_ctx,
2253                                           struct lsa_LookupPrivDisplayName *r)
2254 {
2255         struct dcesrv_handle *h;
2256         struct lsa_policy_state *state;
2257         int id;
2258
2259         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2260
2261         state = h->data;
2262
2263         id = sec_privilege_id(r->in.name->string);
2264         if (id == -1) {
2265                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2266         }
2267
2268         r->out.disp_name = talloc(mem_ctx, struct lsa_String);
2269         if (r->out.disp_name == NULL) {
2270                 return NT_STATUS_NO_MEMORY;
2271         }
2272
2273         r->out.disp_name->string = sec_privilege_display_name(id, r->in.language_id);
2274         if (r->out.disp_name->string == NULL) {
2275                 return NT_STATUS_INTERNAL_ERROR;
2276         }
2277
2278         return NT_STATUS_OK;
2279 }
2280
2281
2282 /*
2283   lsa_DeleteObject
2284 */
2285 static NTSTATUS lsa_DeleteObject(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2286                        struct lsa_DeleteObject *r)
2287 {
2288         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2289 }
2290
2291
2292 /*
2293   lsa_EnumAccountsWithUserRight
2294 */
2295 static NTSTATUS lsa_EnumAccountsWithUserRight(struct dcesrv_call_state *dce_call,
2296                                               TALLOC_CTX *mem_ctx,
2297                                               struct lsa_EnumAccountsWithUserRight *r)
2298 {
2299         struct dcesrv_handle *h;
2300         struct lsa_policy_state *state;
2301         int ret, i;
2302         struct ldb_message **res;
2303         const char * const attrs[] = { "objectSid", NULL};
2304         const char *privname;
2305
2306         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2307
2308         state = h->data;
2309
2310         if (r->in.name == NULL) {
2311                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2312         }
2313
2314         privname = r->in.name->string;
2315         if (sec_privilege_id(privname) == -1) {
2316                 return NT_STATUS_NO_SUCH_PRIVILEGE;
2317         }
2318
2319         ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs,
2320                            "privilege=%s", privname);
2321         if (ret <= 0) {
2322                 return NT_STATUS_NO_SUCH_USER;
2323         }
2324
2325         r->out.sids->sids = talloc_array(r->out.sids, struct lsa_SidPtr, ret);
2326         if (r->out.sids->sids == NULL) {
2327                 return NT_STATUS_NO_MEMORY;
2328         }
2329         for (i=0;i<ret;i++) {
2330                 r->out.sids->sids[i].sid = samdb_result_dom_sid(r->out.sids->sids,
2331                                                                 res[i], "objectSid");
2332                 NT_STATUS_HAVE_NO_MEMORY(r->out.sids->sids[i].sid);
2333         }
2334         r->out.sids->num_sids = ret;
2335
2336         return NT_STATUS_OK;
2337 }
2338
2339
2340 /*
2341   lsa_AddAccountRights
2342 */
2343 static NTSTATUS lsa_AddAccountRights(struct dcesrv_call_state *dce_call,
2344                                      TALLOC_CTX *mem_ctx,
2345                                      struct lsa_AddAccountRights *r)
2346 {
2347         struct dcesrv_handle *h;
2348         struct lsa_policy_state *state;
2349
2350         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2351
2352         state = h->data;
2353
2354         return lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
2355                                           LDB_FLAG_MOD_ADD,
2356                                           r->in.sid, r->in.rights);
2357 }
2358
2359
2360 /*
2361   lsa_RemoveAccountRights
2362 */
2363 static NTSTATUS lsa_RemoveAccountRights(struct dcesrv_call_state *dce_call,
2364                                         TALLOC_CTX *mem_ctx,
2365                                         struct lsa_RemoveAccountRights *r)
2366 {
2367         struct dcesrv_handle *h;
2368         struct lsa_policy_state *state;
2369
2370         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2371
2372         state = h->data;
2373
2374         return lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
2375                                           LDB_FLAG_MOD_DELETE,
2376                                           r->in.sid, r->in.rights);
2377 }
2378
2379
2380 /*
2381   lsa_StorePrivateData
2382 */
2383 static NTSTATUS lsa_StorePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2384                        struct lsa_StorePrivateData *r)
2385 {
2386         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2387 }
2388
2389
2390 /*
2391   lsa_RetrievePrivateData
2392 */
2393 static NTSTATUS lsa_RetrievePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2394                        struct lsa_RetrievePrivateData *r)
2395 {
2396         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2397 }
2398
2399
2400 /*
2401   lsa_GetUserName
2402 */
2403 static NTSTATUS lsa_GetUserName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2404                        struct lsa_GetUserName *r)
2405 {
2406         NTSTATUS status = NT_STATUS_OK;
2407         const char *account_name;
2408         const char *authority_name;
2409         struct lsa_String *_account_name;
2410         struct lsa_StringPointer *_authority_name = NULL;
2411
2412         /* this is what w2k3 does */
2413         r->out.account_name = r->in.account_name;
2414         r->out.authority_name = r->in.authority_name;
2415
2416         if (r->in.account_name && r->in.account_name->string) {
2417                 return NT_STATUS_INVALID_PARAMETER;
2418         }
2419
2420         if (r->in.authority_name &&
2421             r->in.authority_name->string &&
2422             r->in.authority_name->string->string) {
2423                 return NT_STATUS_INVALID_PARAMETER;
2424         }
2425
2426         /* TODO: this check should go and we should rely on the calling code that this is valid */
2427         if (!dce_call->conn->auth_state.session_info ||
2428             !dce_call->conn->auth_state.session_info->server_info ||
2429             !dce_call->conn->auth_state.session_info->server_info->account_name ||
2430             !dce_call->conn->auth_state.session_info->server_info->domain_name) {
2431                 return NT_STATUS_INTERNAL_ERROR;
2432         }
2433
2434         account_name = talloc_reference(mem_ctx, dce_call->conn->auth_state.session_info->server_info->account_name);
2435         authority_name = talloc_reference(mem_ctx, dce_call->conn->auth_state.session_info->server_info->domain_name);
2436
2437         _account_name = talloc(mem_ctx, struct lsa_String);
2438         NTSTATUS_TALLOC_CHECK(_account_name);
2439         _account_name->string = account_name;
2440
2441         if (r->in.authority_name) {
2442                 _authority_name = talloc(mem_ctx, struct lsa_StringPointer);
2443                 NTSTATUS_TALLOC_CHECK(_authority_name);
2444                 _authority_name->string = talloc(mem_ctx, struct lsa_String);
2445                 NTSTATUS_TALLOC_CHECK(_authority_name->string);
2446                 _authority_name->string->string = authority_name;
2447         }
2448
2449         r->out.account_name = _account_name;
2450         r->out.authority_name = _authority_name;
2451
2452         return status;
2453 }
2454
2455 /*
2456   lsa_SetInfoPolicy2
2457 */
2458 static NTSTATUS lsa_SetInfoPolicy2(struct dcesrv_call_state *dce_call,
2459                                    TALLOC_CTX *mem_ctx,
2460                                    struct lsa_SetInfoPolicy2 *r)
2461 {
2462         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2463 }
2464
2465 /*
2466   lsa_QueryDomainInformationPolicy
2467 */
2468 static NTSTATUS lsa_QueryDomainInformationPolicy(struct dcesrv_call_state *dce_call,
2469                                                  TALLOC_CTX *mem_ctx,
2470                                                  struct lsa_QueryDomainInformationPolicy *r)
2471 {
2472         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2473 }
2474
2475 /*
2476   lsa_SetDomInfoPolicy
2477 */
2478 static NTSTATUS lsa_SetDomInfoPolicy(struct dcesrv_call_state *dce_call,
2479                                      TALLOC_CTX *mem_ctx,
2480                                      struct lsa_SetDomInfoPolicy *r)
2481 {
2482         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2483 }
2484
2485 /*
2486   lsa_TestCall
2487 */
2488 static NTSTATUS lsa_TestCall(struct dcesrv_call_state *dce_call,
2489                              TALLOC_CTX *mem_ctx,
2490                              struct lsa_TestCall *r)
2491 {
2492         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2493 }
2494
2495 /*
2496   lookup a SID for 1 name
2497 */
2498 static NTSTATUS lsa_lookup_name(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
2499                                 const char *name, struct dom_sid **sid, uint32_t *atype)
2500 {
2501         int ret;
2502         struct ldb_message **res;
2503         const char * const attrs[] = { "objectSid", "sAMAccountType", NULL};
2504         const char *p;
2505
2506         p = strchr_m(name, '\\');
2507         if (p != NULL) {
2508                 /* TODO: properly parse the domain prefix here, and use it to
2509                    limit the search */
2510                 name = p + 1;
2511         }
2512
2513         ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs, "sAMAccountName=%s", name);
2514         if (ret == 1) {
2515                 *sid = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
2516                 if (*sid == NULL) {
2517                         return NT_STATUS_INVALID_SID;
2518                 }
2519
2520                 *atype = samdb_result_uint(res[0], "sAMAccountType", 0);
2521
2522                 return NT_STATUS_OK;
2523         }
2524
2525         /* need to add a call into sidmap to check for a allocated sid */
2526
2527         return NT_STATUS_INVALID_SID;
2528 }
2529
2530
2531 /*
2532   lsa_LookupNames3
2533 */
2534 static NTSTATUS lsa_LookupNames3(struct dcesrv_call_state *dce_call,
2535                                  TALLOC_CTX *mem_ctx,
2536                                  struct lsa_LookupNames3 *r)
2537 {
2538         struct lsa_policy_state *state;
2539         struct dcesrv_handle *h;
2540         int i;
2541         NTSTATUS status = NT_STATUS_OK;
2542
2543         r->out.domains = NULL;
2544
2545         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2546
2547         state = h->data;
2548
2549         r->out.domains = talloc_zero(mem_ctx,  struct lsa_RefDomainList);
2550         if (r->out.domains == NULL) {
2551                 return NT_STATUS_NO_MEMORY;
2552         }
2553
2554         r->out.sids = talloc_zero(mem_ctx,  struct lsa_TransSidArray3);
2555         if (r->out.sids == NULL) {
2556                 return NT_STATUS_NO_MEMORY;
2557         }
2558
2559         *r->out.count = 0;
2560
2561         r->out.sids->sids = talloc_array(r->out.sids, struct lsa_TranslatedSid3,
2562                                            r->in.num_names);
2563         if (r->out.sids->sids == NULL) {
2564                 return NT_STATUS_NO_MEMORY;
2565         }
2566
2567         for (i=0;i<r->in.num_names;i++) {
2568                 const char *name = r->in.names[i].string;
2569                 struct dom_sid *sid;
2570                 uint32_t atype, rtype, sid_index;
2571                 NTSTATUS status2;
2572
2573                 r->out.sids->count++;
2574                 (*r->out.count)++;
2575
2576                 r->out.sids->sids[i].sid_type    = SID_NAME_UNKNOWN;
2577                 r->out.sids->sids[i].sid         = NULL;
2578                 r->out.sids->sids[i].sid_index   = 0xFFFFFFFF;
2579                 r->out.sids->sids[i].unknown     = 0;
2580
2581                 status2 = lsa_lookup_name(state, mem_ctx, name, &sid, &atype);
2582                 if (!NT_STATUS_IS_OK(status2) || sid->num_auths == 0) {
2583                         status = STATUS_SOME_UNMAPPED;
2584                         continue;
2585                 }
2586
2587                 rtype = samdb_atype_map(atype);
2588                 if (rtype == SID_NAME_UNKNOWN) {
2589                         status = STATUS_SOME_UNMAPPED;
2590                         continue;
2591                 }
2592
2593                 status2 = lsa_authority_list(state, mem_ctx, sid, r->out.domains, &sid_index);
2594                 if (!NT_STATUS_IS_OK(status2)) {
2595                         return status2;
2596                 }
2597
2598                 r->out.sids->sids[i].sid_type    = rtype;
2599                 r->out.sids->sids[i].sid         = sid;
2600                 r->out.sids->sids[i].sid_index   = sid_index;
2601                 r->out.sids->sids[i].unknown     = 0;
2602         }
2603
2604         return status;
2605 }
2606
2607 /*
2608   lsa_LookupNames2
2609 */
2610 static NTSTATUS lsa_LookupNames2(struct dcesrv_call_state *dce_call,
2611                                  TALLOC_CTX *mem_ctx,
2612                                  struct lsa_LookupNames2 *r)
2613 {
2614         struct lsa_policy_state *state;
2615         struct dcesrv_handle *h;
2616         int i;
2617         NTSTATUS status = NT_STATUS_OK;
2618
2619         r->out.domains = NULL;
2620
2621         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2622
2623         state = h->data;
2624
2625         r->out.domains = talloc_zero(mem_ctx,  struct lsa_RefDomainList);
2626         if (r->out.domains == NULL) {
2627                 return NT_STATUS_NO_MEMORY;
2628         }
2629
2630         r->out.sids = talloc_zero(mem_ctx,  struct lsa_TransSidArray2);
2631         if (r->out.sids == NULL) {
2632                 return NT_STATUS_NO_MEMORY;
2633         }
2634
2635         *r->out.count = 0;
2636
2637         r->out.sids->sids = talloc_array(r->out.sids, struct lsa_TranslatedSid2,
2638                                            r->in.num_names);
2639         if (r->out.sids->sids == NULL) {
2640                 return NT_STATUS_NO_MEMORY;
2641         }
2642
2643         for (i=0;i<r->in.num_names;i++) {
2644                 const char *name = r->in.names[i].string;
2645                 struct dom_sid *sid;
2646                 uint32_t atype, rtype, sid_index;
2647                 NTSTATUS status2;
2648
2649                 r->out.sids->count++;
2650                 (*r->out.count)++;
2651
2652                 r->out.sids->sids[i].sid_type    = SID_NAME_UNKNOWN;
2653                 r->out.sids->sids[i].rid         = 0xFFFFFFFF;
2654                 r->out.sids->sids[i].sid_index   = 0xFFFFFFFF;
2655                 r->out.sids->sids[i].unknown     = 0;
2656
2657                 status2 = lsa_lookup_name(state, mem_ctx, name, &sid, &atype);
2658                 if (!NT_STATUS_IS_OK(status2) || sid->num_auths == 0) {
2659                         status = STATUS_SOME_UNMAPPED;
2660                         continue;
2661                 }
2662
2663                 rtype = samdb_atype_map(atype);
2664                 if (rtype == SID_NAME_UNKNOWN) {
2665                         status = STATUS_SOME_UNMAPPED;
2666                         continue;
2667                 }
2668
2669                 status2 = lsa_authority_list(state, mem_ctx, sid, r->out.domains, &sid_index);
2670                 if (!NT_STATUS_IS_OK(status2)) {
2671                         return status2;
2672                 }
2673
2674                 r->out.sids->sids[i].sid_type    = rtype;
2675                 r->out.sids->sids[i].rid         = sid->sub_auths[sid->num_auths-1];
2676                 r->out.sids->sids[i].sid_index   = sid_index;
2677                 r->out.sids->sids[i].unknown     = 0;
2678         }
2679
2680         return status;
2681 }
2682
2683 /*
2684   lsa_LookupNames
2685 */
2686 static NTSTATUS lsa_LookupNames(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2687                        struct lsa_LookupNames *r)
2688 {
2689         struct lsa_LookupNames2 r2;
2690         NTSTATUS status;
2691         int i;
2692
2693         r2.in.handle    = r->in.handle;
2694         r2.in.num_names = r->in.num_names;
2695         r2.in.names     = r->in.names;
2696         r2.in.sids      = NULL;
2697         r2.in.level     = r->in.level;
2698         r2.in.count     = r->in.count;
2699         r2.in.unknown1  = 0;
2700         r2.in.unknown2  = 0;
2701         r2.out.count    = r->out.count;
2702
2703         status = lsa_LookupNames2(dce_call, mem_ctx, &r2);
2704         if (dce_call->fault_code != 0) {
2705                 return status;
2706         }
2707
2708         r->out.domains = r2.out.domains;
2709         r->out.sids = talloc(mem_ctx, struct lsa_TransSidArray);
2710         if (r->out.sids == NULL) {
2711                 return NT_STATUS_NO_MEMORY;
2712         }
2713         r->out.sids->count = r2.out.sids->count;
2714         r->out.sids->sids = talloc_array(r->out.sids, struct lsa_TranslatedSid,
2715                                            r->out.sids->count);
2716         if (r->out.sids->sids == NULL) {
2717                 return NT_STATUS_NO_MEMORY;
2718         }
2719         for (i=0;i<r->out.sids->count;i++) {
2720                 r->out.sids->sids[i].sid_type    = r2.out.sids->sids[i].sid_type;
2721                 r->out.sids->sids[i].rid         = r2.out.sids->sids[i].rid;
2722                 r->out.sids->sids[i].sid_index   = r2.out.sids->sids[i].sid_index;
2723         }
2724
2725         return status;
2726 }
2727
2728 /*
2729   lsa_CREDRWRITE
2730 */
2731 static NTSTATUS lsa_CREDRWRITE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2732                        struct lsa_CREDRWRITE *r)
2733 {
2734         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2735 }
2736
2737
2738 /*
2739   lsa_CREDRREAD
2740 */
2741 static NTSTATUS lsa_CREDRREAD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2742                        struct lsa_CREDRREAD *r)
2743 {
2744         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2745 }
2746
2747
2748 /*
2749   lsa_CREDRENUMERATE
2750 */
2751 static NTSTATUS lsa_CREDRENUMERATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2752                        struct lsa_CREDRENUMERATE *r)
2753 {
2754         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2755 }
2756
2757
2758 /*
2759   lsa_CREDRWRITEDOMAINCREDENTIALS
2760 */
2761 static NTSTATUS lsa_CREDRWRITEDOMAINCREDENTIALS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2762                        struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
2763 {
2764         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2765 }
2766
2767
2768 /*
2769   lsa_CREDRREADDOMAINCREDENTIALS
2770 */
2771 static NTSTATUS lsa_CREDRREADDOMAINCREDENTIALS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2772                        struct lsa_CREDRREADDOMAINCREDENTIALS *r)
2773 {
2774         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2775 }
2776
2777
2778 /*
2779   lsa_CREDRDELETE
2780 */
2781 static NTSTATUS lsa_CREDRDELETE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2782                        struct lsa_CREDRDELETE *r)
2783 {
2784         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2785 }
2786
2787
2788 /*
2789   lsa_CREDRGETTARGETINFO
2790 */
2791 static NTSTATUS lsa_CREDRGETTARGETINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2792                        struct lsa_CREDRGETTARGETINFO *r)
2793 {
2794         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2795 }
2796
2797
2798 /*
2799   lsa_CREDRPROFILELOADED
2800 */
2801 static NTSTATUS lsa_CREDRPROFILELOADED(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2802                        struct lsa_CREDRPROFILELOADED *r)
2803 {
2804         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2805 }
2806
2807
2808 /*
2809   lsa_CREDRGETSESSIONTYPES
2810 */
2811 static NTSTATUS lsa_CREDRGETSESSIONTYPES(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2812                        struct lsa_CREDRGETSESSIONTYPES *r)
2813 {
2814         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2815 }
2816
2817
2818 /*
2819   lsa_LSARREGISTERAUDITEVENT
2820 */
2821 static NTSTATUS lsa_LSARREGISTERAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2822                        struct lsa_LSARREGISTERAUDITEVENT *r)
2823 {
2824         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2825 }
2826
2827
2828 /*
2829   lsa_LSARGENAUDITEVENT
2830 */
2831 static NTSTATUS lsa_LSARGENAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2832                        struct lsa_LSARGENAUDITEVENT *r)
2833 {
2834         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2835 }
2836
2837
2838 /*
2839   lsa_LSARUNREGISTERAUDITEVENT
2840 */
2841 static NTSTATUS lsa_LSARUNREGISTERAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2842                        struct lsa_LSARUNREGISTERAUDITEVENT *r)
2843 {
2844         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2845 }
2846
2847
2848 /*
2849   lsa_LSARQUERYFORESTTRUSTINFORMATION
2850 */
2851 static NTSTATUS lsa_LSARQUERYFORESTTRUSTINFORMATION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2852                        struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r)
2853 {
2854         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2855 }
2856
2857
2858 /*
2859   lsa_LSARSETFORESTTRUSTINFORMATION
2860 */
2861 static NTSTATUS lsa_LSARSETFORESTTRUSTINFORMATION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2862                        struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
2863 {
2864         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2865 }
2866
2867
2868 /*
2869   lsa_CREDRRENAME
2870 */
2871 static NTSTATUS lsa_CREDRRENAME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2872                        struct lsa_CREDRRENAME *r)
2873 {
2874         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2875 }
2876
2877
2878 /*
2879   lsa_LSARLOOKUPNAMES4
2880 */
2881 static NTSTATUS lsa_LSARLOOKUPNAMES4(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2882                        struct lsa_LSARLOOKUPNAMES4 *r)
2883 {
2884         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2885 }
2886
2887
2888 /*
2889   lsa_LSAROPENPOLICYSCE
2890 */
2891 static NTSTATUS lsa_LSAROPENPOLICYSCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2892                        struct lsa_LSAROPENPOLICYSCE *r)
2893 {
2894         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2895 }
2896
2897
2898 /*
2899   lsa_LSARADTREGISTERSECURITYEVENTSOURCE
2900 */
2901 static NTSTATUS lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2902                        struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
2903 {
2904         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2905 }
2906
2907
2908 /*
2909   lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
2910 */
2911 static NTSTATUS lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2912                        struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
2913 {
2914         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2915 }
2916
2917
2918 /*
2919   lsa_LSARADTREPORTSECURITYEVENT
2920 */
2921 static NTSTATUS lsa_LSARADTREPORTSECURITYEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2922                        struct lsa_LSARADTREPORTSECURITYEVENT *r)
2923 {
2924         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2925 }
2926
2927
2928 /* include the generated boilerplate */
2929 #include "librpc/gen_ndr/ndr_lsa_s.c"