source4/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
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "librpc/gen_ndr/ndr_lsa.h"
  25 #include "librpc/gen_ndr/ndr_samr.h"
  26 #include "rpc_server/dcerpc_server.h"
  27 #include "rpc_server/common/common.h"
  28 #include "lib/ldb/include/ldb.h"
  29
  30 /*
  31   this type allows us to distinguish handle types
  32 */
  33 enum lsa_handle {
  34         LSA_HANDLE_POLICY,
  35         LSA_HANDLE_ACCOUNT,
  36         LSA_HANDLE_SECRET
  37 };
  38
  39 /*
  40   state associated with a lsa_OpenPolicy() operation
  41 */
  42 struct lsa_policy_state {
  43         void *sam_ctx;
  44         struct sidmap_context *sidmap;
  45         uint32_t access_mask;
  46         const char *domain_dn;
  47         const char *domain_name;
  48         struct dom_sid *domain_sid;
  49         struct dom_sid *builtin_sid;
  50 };
  51
  52
  53 /*
  54   destroy an open policy. This closes the database connection
  55 */
  56 static void lsa_Policy_destroy(struct dcesrv_connection *conn, struct dcesrv_handle *h)
  57 {
  58         struct lsa_policy_state *state = h->data;
  59         talloc_free(state);
  60 }
  61
  62 /*
  63   lsa_Close
  64 */
  65 static NTSTATUS lsa_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  66                           struct lsa_Close *r)
  67 {
  68         struct dcesrv_handle *h;
  69
  70         *r->out.handle = *r->in.handle;
  71
  72         DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
  73
  74         /* this causes the callback samr_XXX_destroy() to be called by
  75            the handle destroy code which destroys the state associated
  76            with the handle */
  77         dcesrv_handle_destroy(dce_call->conn, h);
  78
  79         ZERO_STRUCTP(r->out.handle);
  80
  81         return NT_STATUS_OK;
  82 }
  83
  84
  85 /*
  86   lsa_Delete
  87 */
  88 static NTSTATUS lsa_Delete(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  89                            struct lsa_Delete *r)
  90 {
  91         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
  92 }
  93
  94
  95 /*
  96   lsa_EnumPrivs
  97 */
  98 static NTSTATUS lsa_EnumPrivs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  99                               struct lsa_EnumPrivs *r)
 100 {
 101         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 102 }
 103
 104
 105 /*
 106   lsa_QuerySecObj
 107 */
 108 static NTSTATUS lsa_QuerySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 109                                   struct lsa_QuerySecurity *r)
 110 {
 111         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 112 }
 113
 114
 115 /*
 116   lsa_SetSecObj
 117 */
 118 static NTSTATUS lsa_SetSecObj(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 119                               struct lsa_SetSecObj *r)
 120 {
 121         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 122 }
 123
 124
 125 /*
 126   lsa_ChangePassword
 127 */
 128 static NTSTATUS lsa_ChangePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 129                                    struct lsa_ChangePassword *r)
 130 {
 131         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 132 }
 133
 134
 135 /*
 136   lsa_OpenPolicy2
 137 */
 138 static NTSTATUS lsa_OpenPolicy2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 139                                struct lsa_OpenPolicy2 *r)
 140 {
 141         struct lsa_policy_state *state;
 142         struct dcesrv_handle *handle;
 143         const char *sid_str;
 144
 145         ZERO_STRUCTP(r->out.handle);
 146
 147         state = talloc_p(dce_call->conn, struct lsa_policy_state);
 148         if (!state) {
 149                 return NT_STATUS_NO_MEMORY;
 150         }
 151
 152         /* make sure the sam database is accessible */
 153         state->sam_ctx = samdb_connect(state);
 154         if (state->sam_ctx == NULL) {
 155                 talloc_free(state);
 156                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
 157         }
 158
 159         state->sidmap = sidmap_open(state);
 160         if (state->sidmap == NULL) {
 161                 talloc_free(state);
 162                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
 163         }
 164
 165         /* work out the domain_dn - useful for so many calls its worth
 166            fetching here */
 167         state->domain_dn = samdb_search_string(state->sam_ctx, state, NULL,
 168                                                "dn", "(&(objectClass=domain)(!(objectclass=builtinDomain)))");
 169         if (!state->domain_dn) {
 170                 talloc_free(state);
 171                 return NT_STATUS_NO_SUCH_DOMAIN;
 172         }
 173
 174         sid_str = samdb_search_string(state->sam_ctx, state, NULL,
 175                                       "objectSid", "dn=%s", state->domain_dn);
 176         if (!sid_str) {
 177                 talloc_free(state);
 178                 return NT_STATUS_NO_SUCH_DOMAIN;
 179         }
 180
 181         state->domain_sid = dom_sid_parse_talloc(state, sid_str);
 182         if (!state->domain_sid) {
 183                 talloc_free(state);
 184                 return NT_STATUS_NO_SUCH_DOMAIN;
 185         }
 186
 187         state->builtin_sid = dom_sid_parse_talloc(state, SID_BUILTIN);
 188         if (!state->builtin_sid) {
 189                 talloc_free(state);
 190                 return NT_STATUS_NO_SUCH_DOMAIN;
 191         }
 192
 193         state->domain_name = samdb_search_string(state->sam_ctx, state, NULL,
 194                                                  "name", "dn=%s", state->domain_dn);
 195         if (!state->domain_name) {
 196                 talloc_free(state);
 197                 return NT_STATUS_NO_SUCH_DOMAIN;
 198         }
 199
 200
 201         handle = dcesrv_handle_new(dce_call->conn, LSA_HANDLE_POLICY);
 202         if (!handle) {
 203                 talloc_free(state);
 204                 return NT_STATUS_NO_MEMORY;
 205         }
 206
 207         handle->data = state;
 208         handle->destroy = lsa_Policy_destroy;
 209
 210         state->access_mask = r->in.access_mask;
 211         *r->out.handle = handle->wire_handle;
 212
 213         /* note that we have completely ignored the attr element of
 214            the OpenPolicy. As far as I can tell, this is what w2k3
 215            does */
 216
 217         return NT_STATUS_OK;
 218 }
 219
 220 /*
 221   lsa_OpenPolicy
 222   a wrapper around lsa_OpenPolicy2
 223 */
 224 static NTSTATUS lsa_OpenPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 225                                 struct lsa_OpenPolicy *r)
 226 {
 227         struct lsa_OpenPolicy2 r2;
 228
 229         r2.in.system_name = NULL;
 230         r2.in.attr = r->in.attr;
 231         r2.in.access_mask = r->in.access_mask;
 232         r2.out.handle = r->out.handle;
 233
 234         return lsa_OpenPolicy2(dce_call, mem_ctx, &r2);
 235 }
 236
 237
 238
 239
 240 /*
 241   fill in the AccountDomain info
 242 */
 243 static NTSTATUS lsa_info_AccountDomain(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 244                                        struct lsa_DomainInfo *info)
 245 {
 246         const char * const attrs[] = { "objectSid", "name", NULL};
 247         int ret;
 248         struct ldb_message **res;
 249
 250         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs,
 251                            "dn=%s", state->domain_dn);
 252         if (ret != 1) {
 253                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 254         }
 255
 256         info->name.string = samdb_result_string(res[0], "name", NULL);
 257         info->sid         = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
 258
 259         return NT_STATUS_OK;
 260 }
 261
 262 /*
 263   fill in the DNS domain info
 264 */
 265 static NTSTATUS lsa_info_DNS(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 266                              struct lsa_DnsDomainInfo *info)
 267 {
 268         const char * const attrs[] = { "name", "dnsDomain", "objectGUID", "objectSid", NULL };
 269         int ret;
 270         struct ldb_message **res;
 271
 272         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs,
 273                            "dn=%s", state->domain_dn);
 274         if (ret != 1) {
 275                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 276         }
 277
 278         info->name.string       = samdb_result_string(res[0],           "name", NULL);
 279         info->dns_domain.string = samdb_result_string(res[0],           "dnsDomain", NULL);
 280         info->dns_forest.string = samdb_result_string(res[0],           "dnsDomain", NULL);
 281         info->domain_guid       = samdb_result_guid(res[0],             "objectGUID");
 282         info->sid               = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
 283
 284         return NT_STATUS_OK;
 285 }
 286
 287 /*
 288   lsa_QueryInfoPolicy2
 289 */
 290 static NTSTATUS lsa_QueryInfoPolicy2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 291                                      struct lsa_QueryInfoPolicy2 *r)
 292 {
 293         struct lsa_policy_state *state;
 294         struct dcesrv_handle *h;
 295
 296         r->out.info = NULL;
 297
 298         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 299
 300         state = h->data;
 301
 302         r->out.info = talloc_p(mem_ctx, union lsa_PolicyInformation);
 303         if (!r->out.info) {
 304                 return NT_STATUS_NO_MEMORY;
 305         }
 306
 307         ZERO_STRUCTP(r->out.info);
 308
 309         switch (r->in.level) {
 310         case LSA_POLICY_INFO_DOMAIN:
 311         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
 312                 return lsa_info_AccountDomain(state, mem_ctx, &r->out.info->account_domain);
 313
 314         case LSA_POLICY_INFO_DNS:
 315                 return lsa_info_DNS(state, mem_ctx, &r->out.info->dns);
 316         }
 317
 318         return NT_STATUS_INVALID_INFO_CLASS;
 319 }
 320
 321 /*
 322   lsa_QueryInfoPolicy
 323 */
 324 static NTSTATUS lsa_QueryInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 325                                     struct lsa_QueryInfoPolicy *r)
 326 {
 327         struct lsa_QueryInfoPolicy2 r2;
 328         NTSTATUS status;
 329
 330         r2.in.handle = r->in.handle;
 331         r2.in.level = r->in.level;
 332
 333         status = lsa_QueryInfoPolicy2(dce_call, mem_ctx, &r2);
 334
 335         r->out.info = r2.out.info;
 336
 337         return status;
 338 }
 339
 340 /*
 341   lsa_SetInfoPolicy
 342 */
 343 static NTSTATUS lsa_SetInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 344                                   struct lsa_SetInfoPolicy *r)
 345 {
 346         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 347 }
 348
 349
 350 /*
 351   lsa_ClearAuditLog
 352 */
 353 static NTSTATUS lsa_ClearAuditLog(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 354                                   struct lsa_ClearAuditLog *r)
 355 {
 356         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 357 }
 358
 359
 360 /*
 361   lsa_CreateAccount
 362 */
 363 static NTSTATUS lsa_CreateAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 364                                   struct lsa_CreateAccount *r)
 365 {
 366         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 367 }
 368
 369
 370 /*
 371   lsa_EnumAccounts
 372 */
 373 static NTSTATUS lsa_EnumAccounts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 374                                  struct lsa_EnumAccounts *r)
 375 {
 376         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 377 }
 378
 379
 380 /*
 381   lsa_CreateTrustedDomain
 382 */
 383 static NTSTATUS lsa_CreateTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 384                                         struct lsa_CreateTrustedDomain *r)
 385 {
 386         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 387 }
 388
 389
 390 /*
 391   lsa_EnumTrustDom
 392 */
 393 static NTSTATUS lsa_EnumTrustDom(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 394                        struct lsa_EnumTrustDom *r)
 395 {
 396         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 397 }
 398
 399
 400 /*
 401   return the authority name and authority sid, given a sid
 402 */
 403 static NTSTATUS lsa_authority_name(struct lsa_policy_state *state,
 404                                    TALLOC_CTX *mem_ctx, struct dom_sid *sid,
 405                                    const char **authority_name,
 406                                    struct dom_sid **authority_sid)
 407 {
 408         if (dom_sid_in_domain(state->domain_sid, sid)) {
 409                 *authority_name = state->domain_name;
 410                 *authority_sid = state->domain_sid;
 411                 return NT_STATUS_OK;
 412         }
 413
 414         if (dom_sid_in_domain(state->builtin_sid, sid)) {
 415                 *authority_name = "BUILTIN";
 416                 *authority_sid = state->builtin_sid;
 417                 return NT_STATUS_OK;
 418         }
 419
 420         *authority_sid = dom_sid_dup(mem_ctx, sid);
 421         if (*authority_sid == NULL) {
 422                 return NT_STATUS_NO_MEMORY;
 423         }
 424         (*authority_sid)->num_auths = 0;
 425         *authority_name = dom_sid_string(mem_ctx, *authority_sid);
 426         if (*authority_name == NULL) {
 427                 return NT_STATUS_NO_MEMORY;
 428         }
 429
 430         return NT_STATUS_OK;
 431 }
 432
 433 /*
 434   add to the lsa_RefDomainList for LookupSids and LookupNames
 435 */
 436 static NTSTATUS lsa_authority_list(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 437                                    struct dom_sid *sid,
 438                                    struct lsa_RefDomainList *domains,
 439                                    uint32_t *sid_index)
 440 {
 441         NTSTATUS status;
 442         const char *authority_name;
 443         struct dom_sid *authority_sid;
 444         int i;
 445
 446         /* work out the authority name */
 447         status = lsa_authority_name(state, mem_ctx, sid,
 448                                     &authority_name, &authority_sid);
 449         if (!NT_STATUS_IS_OK(status)) {
 450                 return status;
 451         }
 452
 453         /* see if we've already done this authority name */
 454         for (i=0;i<domains->count;i++) {
 455                 if (strcmp(authority_name, domains->domains[i].name.string) == 0) {
 456                         *sid_index = i;
 457                         return NT_STATUS_OK;
 458                 }
 459         }
 460
 461         domains->domains = talloc_realloc_p(domains,
 462                                             domains->domains,
 463                                             struct lsa_TrustInformation,
 464                                             domains->count+1);
 465         if (domains->domains == NULL) {
 466                 return NT_STATUS_NO_MEMORY;
 467         }
 468         domains->domains[i].name.string = authority_name;
 469         domains->domains[i].sid         = authority_sid;
 470         domains->count++;
 471         *sid_index = i;
 472
 473         return NT_STATUS_OK;
 474 }
 475
 476 /*
 477   lookup a name for 1 SID
 478 */
 479 static NTSTATUS lsa_lookup_sid(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 480                                struct dom_sid *sid, const char *sid_str,
 481                                const char **name, uint32_t *atype)
 482 {
 483         int ret;
 484         struct ldb_message **res;
 485         const char * const attrs[] = { "sAMAccountName", "sAMAccountType", NULL};
 486         NTSTATUS status;
 487
 488         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs,
 489                            "objectSid=%s", sid_str);
 490         if (ret == 1) {
 491                 *name = ldb_msg_find_string(res[0], "sAMAccountName", NULL);
 492                 if (*name == NULL) {
 493                         return NT_STATUS_NO_MEMORY;
 494                 }
 495
 496                 *atype = samdb_result_uint(res[0], "sAMAccountType", 0);
 497
 498                 return NT_STATUS_OK;
 499         }
 500
 501         status = sidmap_allocated_sid_lookup(state->sidmap, mem_ctx, sid, name, atype);
 502
 503         return status;
 504 }
 505
 506
 507 /*
 508   lsa_LookupSids2
 509 */
 510 static NTSTATUS lsa_LookupSids2(struct dcesrv_call_state *dce_call,
 511                                 TALLOC_CTX *mem_ctx,
 512                                 struct lsa_LookupSids2 *r)
 513 {
 514         struct lsa_policy_state *state;
 515         struct dcesrv_handle *h;
 516         int i;
 517         NTSTATUS status = NT_STATUS_OK;
 518
 519         r->out.domains = NULL;
 520
 521         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 522
 523         state = h->data;
 524
 525         r->out.domains = talloc_zero_p(mem_ctx,  struct lsa_RefDomainList);
 526         if (r->out.domains == NULL) {
 527                 return NT_STATUS_NO_MEMORY;
 528         }
 529
 530         r->out.names = talloc_zero_p(mem_ctx,  struct lsa_TransNameArray2);
 531         if (r->out.names == NULL) {
 532                 return NT_STATUS_NO_MEMORY;
 533         }
 534
 535         *r->out.count = 0;
 536
 537         r->out.names->names = talloc_array_p(r->out.names, struct lsa_TranslatedName2,
 538                                              r->in.sids->num_sids);
 539         if (r->out.names->names == NULL) {
 540                 return NT_STATUS_NO_MEMORY;
 541         }
 542
 543         for (i=0;i<r->in.sids->num_sids;i++) {
 544                 struct dom_sid *sid = r->in.sids->sids[i].sid;
 545                 char *sid_str = dom_sid_string(mem_ctx, sid);
 546                 const char *name;
 547                 uint32_t atype, rtype, sid_index;
 548                 NTSTATUS status2;
 549
 550                 r->out.names->count++;
 551                 (*r->out.count)++;
 552
 553                 r->out.names->names[i].sid_type    = SID_NAME_UNKNOWN;
 554                 r->out.names->names[i].name.string = sid_str;
 555                 r->out.names->names[i].sid_index   = 0xFFFFFFFF;
 556                 r->out.names->names[i].unknown     = 0;
 557
 558                 if (sid_str == NULL) {
 559                         r->out.names->names[i].name.string = "(SIDERROR)";
 560                         status = STATUS_SOME_UNMAPPED;
 561                         continue;
 562                 }
 563
 564                 /* work out the authority name */
 565                 status2 = lsa_authority_list(state, mem_ctx, sid, r->out.domains, &sid_index);
 566                 if (!NT_STATUS_IS_OK(status2)) {
 567                         return status2;
 568                 }
 569
 570                 status2 = lsa_lookup_sid(state, mem_ctx, sid, sid_str,
 571                                          &name, &atype);
 572                 if (!NT_STATUS_IS_OK(status2)) {
 573                         status = STATUS_SOME_UNMAPPED;
 574                         continue;
 575                 }
 576
 577                 rtype = samdb_atype_map(atype);
 578                 if (rtype == SID_NAME_UNKNOWN) {
 579                         status = STATUS_SOME_UNMAPPED;
 580                         continue;
 581                 }
 582
 583                 r->out.names->names[i].sid_type    = rtype;
 584                 r->out.names->names[i].name.string = name;
 585                 r->out.names->names[i].sid_index   = sid_index;
 586                 r->out.names->names[i].unknown     = 0;
 587         }
 588
 589         return status;
 590 }
 591
 592
 593 /*
 594   lsa_LookupSids
 595 */
 596 static NTSTATUS lsa_LookupSids(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 597                                struct lsa_LookupSids *r)
 598 {
 599         struct lsa_LookupSids2 r2;
 600         NTSTATUS status;
 601         int i;
 602
 603         r2.in.handle   = r->in.handle;
 604         r2.in.sids     = r->in.sids;
 605         r2.in.names    = NULL;
 606         r2.in.level    = r->in.level;
 607         r2.in.count    = r->in.count;
 608         r2.in.unknown1 = 0;
 609         r2.in.unknown2 = 0;
 610         r2.out.count   = r->out.count;
 611
 612         status = lsa_LookupSids2(dce_call, mem_ctx, &r2);
 613         if (dce_call->fault_code != 0) {
 614                 return status;
 615         }
 616
 617         r->out.domains = r2.out.domains;
 618         r->out.names = talloc_p(mem_ctx, struct lsa_TransNameArray);
 619         if (r->out.names == NULL) {
 620                 return NT_STATUS_NO_MEMORY;
 621         }
 622         r->out.names->count = r2.out.names->count;
 623         r->out.names->names = talloc_array_p(r->out.names, struct lsa_TranslatedName,
 624                                              r->out.names->count);
 625         if (r->out.names->names == NULL) {
 626                 return NT_STATUS_NO_MEMORY;
 627         }
 628         for (i=0;i<r->out.names->count;i++) {
 629                 r->out.names->names[i].sid_type    = r2.out.names->names[i].sid_type;
 630                 r->out.names->names[i].name.string = r2.out.names->names[i].name.string;
 631                 r->out.names->names[i].sid_index   = r2.out.names->names[i].sid_index;
 632         }
 633
 634         return status;
 635 }
 636
 637
 638 /*
 639   lsa_CreateSecret
 640 */
 641 static NTSTATUS lsa_CreateSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 642                        struct lsa_CreateSecret *r)
 643 {
 644         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 645 }
 646
 647
 648 /*
 649   lsa_OpenAccount
 650 */
 651 static NTSTATUS lsa_OpenAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 652                        struct lsa_OpenAccount *r)
 653 {
 654         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 655 }
 656
 657
 658 /*
 659   lsa_EnumPrivsAccount
 660 */
 661 static NTSTATUS lsa_EnumPrivsAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 662                        struct lsa_EnumPrivsAccount *r)
 663 {
 664         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 665 }
 666
 667
 668 /*
 669   lsa_AddPrivilegesToAccount
 670 */
 671 static NTSTATUS lsa_AddPrivilegesToAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 672                        struct lsa_AddPrivilegesToAccount *r)
 673 {
 674         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 675 }
 676
 677
 678 /*
 679   lsa_RemovePrivilegesFromAccount
 680 */
 681 static NTSTATUS lsa_RemovePrivilegesFromAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 682                        struct lsa_RemovePrivilegesFromAccount *r)
 683 {
 684         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 685 }
 686
 687
 688 /*
 689   lsa_GetQuotasForAccount
 690 */
 691 static NTSTATUS lsa_GetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 692                        struct lsa_GetQuotasForAccount *r)
 693 {
 694         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 695 }
 696
 697
 698 /*
 699   lsa_SetQuotasForAccount
 700 */
 701 static NTSTATUS lsa_SetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 702                        struct lsa_SetQuotasForAccount *r)
 703 {
 704         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 705 }
 706
 707
 708 /*
 709   lsa_GetSystemAccessAccount
 710 */
 711 static NTSTATUS lsa_GetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 712                        struct lsa_GetSystemAccessAccount *r)
 713 {
 714         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 715 }
 716
 717
 718 /*
 719   lsa_SetSystemAccessAccount
 720 */
 721 static NTSTATUS lsa_SetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 722                        struct lsa_SetSystemAccessAccount *r)
 723 {
 724         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 725 }
 726
 727
 728 /*
 729   lsa_OpenTrustedDomain
 730 */
 731 static NTSTATUS lsa_OpenTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 732                        struct lsa_OpenTrustedDomain *r)
 733 {
 734         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 735 }
 736
 737
 738 /*
 739   lsa_QueryTrustedDomainInfo
 740 */
 741 static NTSTATUS lsa_QueryTrustedDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 742                        struct lsa_QueryTrustedDomainInfo *r)
 743 {
 744         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 745 }
 746
 747
 748 /*
 749   lsa_SetInformationTrustedDomain
 750 */
 751 static NTSTATUS lsa_SetInformationTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 752                        struct lsa_SetInformationTrustedDomain *r)
 753 {
 754         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 755 }
 756
 757
 758 /*
 759   lsa_OpenSecret
 760 */
 761 static NTSTATUS lsa_OpenSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 762                        struct lsa_OpenSecret *r)
 763 {
 764         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 765 }
 766
 767
 768 /*
 769   lsa_SetSecret
 770 */
 771 static NTSTATUS lsa_SetSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 772                        struct lsa_SetSecret *r)
 773 {
 774         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 775 }
 776
 777
 778 /*
 779   lsa_QuerySecret
 780 */
 781 static NTSTATUS lsa_QuerySecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 782                        struct lsa_QuerySecret *r)
 783 {
 784         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 785 }
 786
 787
 788 /*
 789   lsa_LookupPrivValue
 790 */
 791 static NTSTATUS lsa_LookupPrivValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 792                        struct lsa_LookupPrivValue *r)
 793 {
 794         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 795 }
 796
 797
 798 /*
 799   lsa_LookupPrivName
 800 */
 801 static NTSTATUS lsa_LookupPrivName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 802                        struct lsa_LookupPrivName *r)
 803 {
 804         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 805 }
 806
 807
 808 /*
 809   lsa_LookupPrivDisplayName
 810 */
 811 static NTSTATUS lsa_LookupPrivDisplayName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 812                        struct lsa_LookupPrivDisplayName *r)
 813 {
 814         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 815 }
 816
 817
 818 /*
 819   lsa_DeleteObject
 820 */
 821 static NTSTATUS lsa_DeleteObject(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 822                        struct lsa_DeleteObject *r)
 823 {
 824         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 825 }
 826
 827
 828 /*
 829   lsa_EnumAccountsWithUserRight
 830 */
 831 static NTSTATUS lsa_EnumAccountsWithUserRight(struct dcesrv_call_state *dce_call,
 832                                               TALLOC_CTX *mem_ctx,
 833                                               struct lsa_EnumAccountsWithUserRight *r)
 834 {
 835         struct dcesrv_handle *h;
 836         struct lsa_policy_state *state;
 837         int ret, i;
 838         struct ldb_message **res;
 839         const char * const attrs[] = { "objectSid", NULL};
 840         const char *privname;
 841
 842         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 843
 844         state = h->data;
 845
 846         if (r->in.name == NULL) {
 847                 return NT_STATUS_NO_SUCH_PRIVILEGE;
 848         }
 849
 850         privname = r->in.name->string;
 851         if (sec_privilege_id(privname) == -1) {
 852                 return NT_STATUS_NO_SUCH_PRIVILEGE;
 853         }
 854
 855         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs,
 856                            "privilege=%s", privname);
 857         if (ret <= 0) {
 858                 return NT_STATUS_NO_SUCH_USER;
 859         }
 860
 861         r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_SidPtr, ret);
 862         if (r->out.sids->sids == NULL) {
 863                 return NT_STATUS_NO_MEMORY;
 864         }
 865         for (i=0;i<ret;i++) {
 866                 const char *sidstr;
 867                 sidstr = samdb_result_string(res[i], "objectSid", NULL);
 868                 if (sidstr == NULL) {
 869                         return NT_STATUS_NO_MEMORY;
 870                 }
 871                 r->out.sids->sids[i].sid = dom_sid_parse_talloc(r->out.sids->sids,
 872                                                                 sidstr);
 873                 if (r->out.sids->sids[i].sid == NULL) {
 874                         return NT_STATUS_NO_MEMORY;
 875                 }
 876         }
 877         r->out.sids->num_sids = ret;
 878
 879         return NT_STATUS_OK;
 880 }
 881
 882
 883 /*
 884   lsa_EnumAccountRights
 885 */
 886 static NTSTATUS lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
 887                                       TALLOC_CTX *mem_ctx,
 888                                       struct lsa_EnumAccountRights *r)
 889 {
 890         struct dcesrv_handle *h;
 891         struct lsa_policy_state *state;
 892         int ret, i;
 893         struct ldb_message **res;
 894         const char * const attrs[] = { "privilege", NULL};
 895         const char *sidstr;
 896         struct ldb_message_element *el;
 897
 898         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 899
 900         state = h->data;
 901
 902         sidstr = dom_sid_string(mem_ctx, r->in.sid);
 903         if (sidstr == NULL) {
 904                 return NT_STATUS_NO_MEMORY;
 905         }
 906
 907         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs,
 908                            "objectSid=%s", sidstr);
 909         if (ret != 1) {
 910                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 911         }
 912
 913         el = ldb_msg_find_element(res[0], "privilege");
 914         if (el == NULL || el->num_values == 0) {
 915                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 916         }
 917
 918         r->out.rights->count = el->num_values;
 919         r->out.rights->names = talloc_array_p(r->out.rights,
 920                                               struct lsa_String, r->out.rights->count);
 921         if (r->out.rights->names == NULL) {
 922                 return NT_STATUS_NO_MEMORY;
 923         }
 924
 925         for (i=0;i<el->num_values;i++) {
 926                 r->out.rights->names[i].string = el->values[i].data;
 927         }
 928
 929         return NT_STATUS_OK;
 930 }
 931
 932
 933 /*
 934   lsa_AddAccountRights
 935 */
 936 static NTSTATUS lsa_AddAccountRights(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 937                        struct lsa_AddAccountRights *r)
 938 {
 939         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 940 }
 941
 942
 943 /*
 944   lsa_RemoveAccountRights
 945 */
 946 static NTSTATUS lsa_RemoveAccountRights(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 947                        struct lsa_RemoveAccountRights *r)
 948 {
 949         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 950 }
 951
 952
 953 /*
 954   lsa_QueryTrustedDomainInfoBySid
 955 */
 956 static NTSTATUS lsa_QueryTrustedDomainInfoBySid(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 957                                                 struct lsa_QueryTrustedDomainInfoBySid *r)
 958 {
 959         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 960 }
 961
 962
 963 /*
 964   lsa_SetTrustDomainInfo
 965 */
 966 static NTSTATUS lsa_SetTrustDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 967                        struct lsa_SetTrustDomainInfo *r)
 968 {
 969         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 970 }
 971
 972
 973 /*
 974   lsa_DeleteTrustDomain
 975 */
 976 static NTSTATUS lsa_DeleteTrustDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 977                        struct lsa_DeleteTrustDomain *r)
 978 {
 979         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 980 }
 981
 982
 983 /*
 984   lsa_StorePrivateData
 985 */
 986 static NTSTATUS lsa_StorePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 987                        struct lsa_StorePrivateData *r)
 988 {
 989         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 990 }
 991
 992
 993 /*
 994   lsa_RetrievePrivateData
 995 */
 996 static NTSTATUS lsa_RetrievePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 997                        struct lsa_RetrievePrivateData *r)
 998 {
 999         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1000 }
1001
1002
1003 /*
1004   lsa_GetUserName
1005 */
1006 static NTSTATUS lsa_GetUserName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1007                        struct lsa_GetUserName *r)
1008 {
1009         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1010 }
1011
1012 /*
1013   lsa_SetInfoPolicy2
1014 */
1015 static NTSTATUS lsa_SetInfoPolicy2(struct dcesrv_call_state *dce_call,
1016                                    TALLOC_CTX *mem_ctx,
1017                                    struct lsa_SetInfoPolicy2 *r)
1018 {
1019         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1020 }
1021
1022 /*
1023   lsa_QueryTrustedDomainInfoByName
1024 */
1025 static NTSTATUS lsa_QueryTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
1026                                                  TALLOC_CTX *mem_ctx,
1027                                                  struct lsa_QueryTrustedDomainInfoByName *r)
1028 {
1029         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1030 }
1031
1032 /*
1033   lsa_SetTrustedDomainInfoByName
1034 */
1035 static NTSTATUS lsa_SetTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
1036                                                TALLOC_CTX *mem_ctx,
1037                                                struct lsa_SetTrustedDomainInfoByName *r)
1038 {
1039         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1040 }
1041
1042 /*
1043   lsa_EnumTrustedDomainsEx
1044 */
1045 static NTSTATUS lsa_EnumTrustedDomainsEx(struct dcesrv_call_state *dce_call,
1046                                          TALLOC_CTX *mem_ctx,
1047                                          struct lsa_EnumTrustedDomainsEx *r)
1048 {
1049         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1050 }
1051
1052 /*
1053   lsa_CreateTrustedDomainEx
1054 */
1055 static NTSTATUS lsa_CreateTrustedDomainEx(struct dcesrv_call_state *dce_call,
1056                                           TALLOC_CTX *mem_ctx,
1057                                           struct lsa_CreateTrustedDomainEx *r)
1058 {
1059         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1060 }
1061
1062 /*
1063   lsa_CloseTrustedDomainEx
1064 */
1065 static NTSTATUS lsa_CloseTrustedDomainEx(struct dcesrv_call_state *dce_call,
1066                                          TALLOC_CTX *mem_ctx,
1067                                          struct lsa_CloseTrustedDomainEx *r)
1068 {
1069         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1070 }
1071
1072 /*
1073   lsa_QueryDomainInformationPolicy
1074 */
1075 static NTSTATUS lsa_QueryDomainInformationPolicy(struct dcesrv_call_state *dce_call,
1076                                                  TALLOC_CTX *mem_ctx,
1077                                                  struct lsa_QueryDomainInformationPolicy *r)
1078 {
1079         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1080 }
1081
1082 /*
1083   lsa_SetDomInfoPolicy
1084 */
1085 static NTSTATUS lsa_SetDomInfoPolicy(struct dcesrv_call_state *dce_call,
1086                                      TALLOC_CTX *mem_ctx,
1087                                      struct lsa_SetDomInfoPolicy *r)
1088 {
1089         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1090 }
1091
1092 /*
1093   lsa_OpenTrustedDomainByName
1094 */
1095 static NTSTATUS lsa_OpenTrustedDomainByName(struct dcesrv_call_state *dce_call,
1096                                             TALLOC_CTX *mem_ctx,
1097                                             struct lsa_OpenTrustedDomainByName *r)
1098 {
1099         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1100 }
1101
1102 /*
1103   lsa_TestCall
1104 */
1105 static NTSTATUS lsa_TestCall(struct dcesrv_call_state *dce_call,
1106                              TALLOC_CTX *mem_ctx,
1107                              struct lsa_TestCall *r)
1108 {
1109         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1110 }
1111
1112 /*
1113   lookup a SID for 1 name
1114 */
1115 static NTSTATUS lsa_lookup_name(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
1116                                 const char *name, struct dom_sid **sid, uint32_t *atype)
1117 {
1118         int ret;
1119         struct ldb_message **res;
1120         const char * const attrs[] = { "objectSid", "sAMAccountType", NULL};
1121
1122         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs, "sAMAccountName=%s", name);
1123         if (ret == 1) {
1124                 const char *sid_str = ldb_msg_find_string(res[0], "objectSid", NULL);
1125                 if (sid_str == NULL) {
1126                         return NT_STATUS_INVALID_SID;
1127                 }
1128
1129                 *sid = dom_sid_parse_talloc(mem_ctx, sid_str);
1130                 if (*sid == NULL) {
1131                         return NT_STATUS_INVALID_SID;
1132                 }
1133
1134                 *atype = samdb_result_uint(res[0], "sAMAccountType", 0);
1135
1136                 return NT_STATUS_OK;
1137         }
1138
1139         /* need to add a call into sidmap to check for a allocated sid */
1140
1141         return NT_STATUS_INVALID_SID;
1142 }
1143
1144 /*
1145   lsa_LookupNames2
1146 */
1147 static NTSTATUS lsa_LookupNames2(struct dcesrv_call_state *dce_call,
1148                                  TALLOC_CTX *mem_ctx,
1149                                  struct lsa_LookupNames2 *r)
1150 {
1151         struct lsa_policy_state *state;
1152         struct dcesrv_handle *h;
1153         int i;
1154         NTSTATUS status = NT_STATUS_OK;
1155
1156         r->out.domains = NULL;
1157
1158         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
1159
1160         state = h->data;
1161
1162         r->out.domains = talloc_zero_p(mem_ctx,  struct lsa_RefDomainList);
1163         if (r->out.domains == NULL) {
1164                 return NT_STATUS_NO_MEMORY;
1165         }
1166
1167         r->out.sids = talloc_zero_p(mem_ctx,  struct lsa_TransSidArray2);
1168         if (r->out.sids == NULL) {
1169                 return NT_STATUS_NO_MEMORY;
1170         }
1171
1172         *r->out.count = 0;
1173
1174         r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_TranslatedSid2,
1175                                            r->in.num_names);
1176         if (r->out.sids->sids == NULL) {
1177                 return NT_STATUS_NO_MEMORY;
1178         }
1179
1180         for (i=0;i<r->in.num_names;i++) {
1181                 const char *name = r->in.names[i].string;
1182                 struct dom_sid *sid;
1183                 uint32_t atype, rtype, sid_index;
1184                 NTSTATUS status2;
1185
1186                 r->out.sids->count++;
1187                 (*r->out.count)++;
1188
1189                 r->out.sids->sids[i].sid_type    = SID_NAME_UNKNOWN;
1190                 r->out.sids->sids[i].rid         = 0xFFFFFFFF;
1191                 r->out.sids->sids[i].sid_index   = 0xFFFFFFFF;
1192                 r->out.sids->sids[i].unknown     = 0;
1193
1194                 status2 = lsa_lookup_name(state, mem_ctx, name, &sid, &atype);
1195                 if (!NT_STATUS_IS_OK(status) || sid->num_auths == 0) {
1196                         status = STATUS_SOME_UNMAPPED;
1197                         continue;
1198                 }
1199
1200                 rtype = samdb_atype_map(atype);
1201                 if (rtype == SID_NAME_UNKNOWN) {
1202                         status = STATUS_SOME_UNMAPPED;
1203                         continue;
1204                 }
1205
1206                 status2 = lsa_authority_list(state, mem_ctx, sid, r->out.domains, &sid_index);
1207                 if (!NT_STATUS_IS_OK(status2)) {
1208                         return status2;
1209                 }
1210
1211                 r->out.sids->sids[i].sid_type    = rtype;
1212                 r->out.sids->sids[i].rid         = sid->sub_auths[sid->num_auths-1];
1213                 r->out.sids->sids[i].sid_index   = sid_index;
1214                 r->out.sids->sids[i].unknown     = 0;
1215         }
1216
1217         return status;
1218 }
1219
1220 /*
1221   lsa_LookupNames
1222 */
1223 static NTSTATUS lsa_LookupNames(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1224                        struct lsa_LookupNames *r)
1225 {
1226         struct lsa_LookupNames2 r2;
1227         NTSTATUS status;
1228         int i;
1229
1230         r2.in.handle    = r->in.handle;
1231         r2.in.num_names = r->in.num_names;
1232         r2.in.names     = r->in.names;
1233         r2.in.sids      = NULL;
1234         r2.in.level     = r->in.level;
1235         r2.in.count     = r->in.count;
1236         r2.in.unknown1  = 0;
1237         r2.in.unknown2  = 0;
1238         r2.out.count    = r->out.count;
1239
1240         status = lsa_LookupNames2(dce_call, mem_ctx, &r2);
1241         if (dce_call->fault_code != 0) {
1242                 return status;
1243         }
1244
1245         r->out.domains = r2.out.domains;
1246         r->out.sids = talloc_p(mem_ctx, struct lsa_TransSidArray);
1247         if (r->out.sids == NULL) {
1248                 return NT_STATUS_NO_MEMORY;
1249         }
1250         r->out.sids->count = r2.out.sids->count;
1251         r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_TranslatedSid,
1252                                            r->out.sids->count);
1253         if (r->out.sids->sids == NULL) {
1254                 return NT_STATUS_NO_MEMORY;
1255         }
1256         for (i=0;i<r->out.sids->count;i++) {
1257                 r->out.sids->sids[i].sid_type    = r2.out.sids->sids[i].sid_type;
1258                 r->out.sids->sids[i].rid         = r2.out.sids->sids[i].rid;
1259                 r->out.sids->sids[i].sid_index   = r2.out.sids->sids[i].sid_index;
1260         }
1261
1262         return status;
1263 }
1264
1265
1266
1267 /*
1268   lsa_CreateTrustedDomainEx2
1269 */
1270 static NTSTATUS lsa_CreateTrustedDomainEx2(struct dcesrv_call_state *dce_call,
1271                                            TALLOC_CTX *mem_ctx,
1272                                            struct lsa_CreateTrustedDomainEx2 *r)
1273 {
1274         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1275 }
1276
1277 /* include the generated boilerplate */
1278 #include "librpc/gen_ndr/ndr_lsa_s.c"