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 "rpc_server/common/common.h"
  25
  26 /*
  27   this type allows us to distinguish handle types
  28 */
  29 enum lsa_handle {
  30         LSA_HANDLE_POLICY,
  31         LSA_HANDLE_ACCOUNT,
  32         LSA_HANDLE_SECRET
  33 };
  34
  35 /*
  36   state associated with a lsa_OpenPolicy() operation
  37 */
  38 struct lsa_policy_state {
  39         int reference_count;
  40         void *sam_ctx;
  41         TALLOC_CTX *mem_ctx;
  42         uint32_t access_mask;
  43         const char *domain_dn;
  44 };
  45
  46
  47 /*
  48   destroy policy state
  49 */
  50 static void lsa_Policy_close(struct lsa_policy_state *state)
  51 {
  52         state->reference_count--;
  53         if (state->reference_count == 0) {
  54                 samdb_close(state->sam_ctx);
  55                 talloc_destroy(state->mem_ctx);
  56         }
  57 }
  58
  59 /*
  60   destroy an open policy. This closes the database connection
  61 */
  62 static void lsa_Policy_destroy(struct dcesrv_connection *conn, struct dcesrv_handle *h)
  63 {
  64         struct lsa_policy_state *state = h->data;
  65         lsa_Policy_close(state);
  66 }
  67
  68 /*
  69   lsa_Close
  70 */
  71 static NTSTATUS lsa_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  72                           struct lsa_Close *r)
  73 {
  74         struct dcesrv_handle *h;
  75
  76         *r->out.handle = *r->in.handle;
  77
  78         DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
  79
  80         /* this causes the callback samr_XXX_destroy() to be called by
  81            the handle destroy code which destroys the state associated
  82            with the handle */
  83         dcesrv_handle_destroy(dce_call->conn, h);
  84
  85         ZERO_STRUCTP(r->out.handle);
  86
  87         return NT_STATUS_OK;
  88 }
  89
  90
  91 /*
  92   lsa_Delete
  93 */
  94 static NTSTATUS lsa_Delete(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  95                            struct lsa_Delete *r)
  96 {
  97         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
  98 }
  99
 100
 101 /*
 102   lsa_EnumPrivs
 103 */
 104 static NTSTATUS lsa_EnumPrivs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 105                               struct lsa_EnumPrivs *r)
 106 {
 107         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 108 }
 109
 110
 111 /*
 112   lsa_QuerySecObj
 113 */
 114 static NTSTATUS lsa_QuerySecObj(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 115                                 struct lsa_QuerySecObj *r)
 116 {
 117         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 118 }
 119
 120
 121 /*
 122   lsa_SetSecObj
 123 */
 124 static NTSTATUS lsa_SetSecObj(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 125                               struct lsa_SetSecObj *r)
 126 {
 127         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 128 }
 129
 130
 131 /*
 132   lsa_ChangePassword
 133 */
 134 static NTSTATUS lsa_ChangePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 135                                    struct lsa_ChangePassword *r)
 136 {
 137         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 138 }
 139
 140
 141 /*
 142   lsa_OpenPolicy2
 143 */
 144 static NTSTATUS lsa_OpenPolicy2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 145                                struct lsa_OpenPolicy2 *r)
 146 {
 147         struct lsa_policy_state *state;
 148         struct dcesrv_handle *handle;
 149         TALLOC_CTX *lsa_mem_ctx;
 150
 151         ZERO_STRUCTP(r->out.handle);
 152
 153         lsa_mem_ctx = talloc_init("lsa_OpenPolicy");
 154         if (!lsa_mem_ctx) {
 155                 return NT_STATUS_NO_MEMORY;
 156         }
 157
 158         state = talloc_p(lsa_mem_ctx, struct lsa_policy_state);
 159         if (!state) {
 160                 return NT_STATUS_NO_MEMORY;
 161         }
 162         state->mem_ctx = lsa_mem_ctx;
 163
 164         /* make sure the sam database is accessible */
 165         state->sam_ctx = samdb_connect();
 166         if (state->sam_ctx == NULL) {
 167                 talloc_destroy(state->mem_ctx);
 168                 return NT_STATUS_INVALID_SYSTEM_SERVICE;
 169         }
 170
 171         /* work out the domain_dn - useful for so many calls its worth
 172            fetching here */
 173         state->domain_dn = samdb_search_string(state->sam_ctx, state->mem_ctx, NULL,
 174                                                "dn", "(&(objectClass=domain)(!(objectclass=builtinDomain)))");
 175         if (!state->domain_dn) {
 176                 samdb_close(state->sam_ctx);
 177                 talloc_destroy(state->mem_ctx);
 178                 return NT_STATUS_NO_SUCH_DOMAIN;
 179         }
 180
 181         handle = dcesrv_handle_new(dce_call->conn, LSA_HANDLE_POLICY);
 182         if (!handle) {
 183                 talloc_destroy(state->mem_ctx);
 184                 return NT_STATUS_NO_MEMORY;
 185         }
 186
 187         handle->data = state;
 188         handle->destroy = lsa_Policy_destroy;
 189
 190         state->reference_count = 1;
 191         state->access_mask = r->in.access_mask;
 192         *r->out.handle = handle->wire_handle;
 193
 194         /* note that we have completely ignored the attr element of
 195            the OpenPolicy. As far as I can tell, this is what w2k3
 196            does */
 197
 198         return NT_STATUS_OK;
 199 }
 200
 201 /*
 202   lsa_OpenPolicy
 203   a wrapper around lsa_OpenPolicy2
 204 */
 205 static NTSTATUS lsa_OpenPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 206                                 struct lsa_OpenPolicy *r)
 207 {
 208         struct lsa_OpenPolicy2 r2;
 209
 210         r2.in.system_name = NULL;
 211         r2.in.attr = r->in.attr;
 212         r2.in.access_mask = r->in.access_mask;
 213         r2.out.handle = r->out.handle;
 214
 215         return lsa_OpenPolicy2(dce_call, mem_ctx, &r2);
 216 }
 217
 218
 219
 220
 221 /*
 222   fill in the AccountDomain info
 223 */
 224 static NTSTATUS lsa_info_AccountDomain(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 225                                        struct lsa_DomainInfo *info)
 226 {
 227         const char * const attrs[] = { "objectSid", "name", NULL};
 228         int ret;
 229         struct ldb_message **res;
 230
 231         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs,
 232                            "dn=%s", state->domain_dn);
 233         if (ret != 1) {
 234                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 235         }
 236
 237         info->name.name = samdb_result_string(res[0], "name", NULL);
 238         info->sid       = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
 239
 240         return NT_STATUS_OK;
 241 }
 242
 243 /*
 244   fill in the DNS domain info
 245 */
 246 static NTSTATUS lsa_info_DNS(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
 247                              struct lsa_DnsDomainInfo *info)
 248 {
 249         const char * const attrs[] = { "name", "dnsDomain", "objectGUID", "objectSid", NULL };
 250         int ret;
 251         struct ldb_message **res;
 252
 253         ret = samdb_search(state->sam_ctx, mem_ctx, NULL, &res, attrs,
 254                            "dn=%s", state->domain_dn);
 255         if (ret != 1) {
 256                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 257         }
 258
 259         info->name.name       = samdb_result_string(res[0],           "name", NULL);
 260         info->dns_domain.name = samdb_result_string(res[0],           "dnsDomain", NULL);
 261         info->dns_forest.name = samdb_result_string(res[0],           "dnsDomain", NULL);
 262         info->domain_guid     = samdb_result_guid(res[0],             "objectGUID");
 263         info->sid             = samdb_result_dom_sid(mem_ctx, res[0], "objectSid");
 264
 265         return NT_STATUS_OK;
 266 }
 267
 268 /*
 269   lsa_QueryInfoPolicy2
 270 */
 271 static NTSTATUS lsa_QueryInfoPolicy2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 272                                      struct lsa_QueryInfoPolicy2 *r)
 273 {
 274         struct lsa_policy_state *state;
 275         struct dcesrv_handle *h;
 276
 277         r->out.info = NULL;
 278
 279         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 280
 281         state = h->data;
 282
 283         r->out.info = talloc_p(mem_ctx, union lsa_PolicyInformation);
 284         if (!r->out.info) {
 285                 return NT_STATUS_NO_MEMORY;
 286         }
 287
 288         ZERO_STRUCTP(r->out.info);
 289
 290         switch (r->in.level) {
 291         case LSA_POLICY_INFO_DOMAIN:
 292         case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
 293                 return lsa_info_AccountDomain(state, mem_ctx, &r->out.info->account_domain);
 294
 295         case LSA_POLICY_INFO_DNS:
 296                 return lsa_info_DNS(state, mem_ctx, &r->out.info->dns);
 297         }
 298
 299         return NT_STATUS_INVALID_INFO_CLASS;
 300 }
 301
 302 /*
 303   lsa_QueryInfoPolicy
 304 */
 305 static NTSTATUS lsa_QueryInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 306                                     struct lsa_QueryInfoPolicy *r)
 307 {
 308         struct lsa_QueryInfoPolicy2 r2;
 309         NTSTATUS status;
 310
 311         r2.in.handle = r->in.handle;
 312         r2.in.level = r->in.level;
 313
 314         status = lsa_QueryInfoPolicy2(dce_call, mem_ctx, &r2);
 315
 316         r->out.info = r2.out.info;
 317
 318         return status;
 319 }
 320
 321 /*
 322   lsa_SetInfoPolicy
 323 */
 324 static NTSTATUS lsa_SetInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 325                                   struct lsa_SetInfoPolicy *r)
 326 {
 327         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 328 }
 329
 330
 331 /*
 332   lsa_ClearAuditLog
 333 */
 334 static NTSTATUS lsa_ClearAuditLog(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 335                                   struct lsa_ClearAuditLog *r)
 336 {
 337         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 338 }
 339
 340
 341 /*
 342   lsa_CreateAccount
 343 */
 344 static NTSTATUS lsa_CreateAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 345                                   struct lsa_CreateAccount *r)
 346 {
 347         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 348 }
 349
 350
 351 /*
 352   lsa_EnumAccounts
 353 */
 354 static NTSTATUS lsa_EnumAccounts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 355                                  struct lsa_EnumAccounts *r)
 356 {
 357         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 358 }
 359
 360
 361 /*
 362   lsa_CreateTrustedDomain
 363 */
 364 static NTSTATUS lsa_CreateTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 365                                         struct lsa_CreateTrustedDomain *r)
 366 {
 367         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 368 }
 369
 370
 371 /*
 372   lsa_EnumTrustDom
 373 */
 374 static NTSTATUS lsa_EnumTrustDom(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 375                        struct lsa_EnumTrustDom *r)
 376 {
 377         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 378 }
 379
 380
 381 /*
 382   lsa_LookupNames
 383 */
 384 static NTSTATUS lsa_LookupNames(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 385                        struct lsa_LookupNames *r)
 386 {
 387         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 388 }
 389
 390
 391 /*
 392   lsa_LookupSids
 393 */
 394 static NTSTATUS lsa_LookupSids(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 395                        struct lsa_LookupSids *r)
 396 {
 397         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 398 }
 399
 400
 401 /*
 402   lsa_CreateSecret
 403 */
 404 static NTSTATUS lsa_CreateSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 405                        struct lsa_CreateSecret *r)
 406 {
 407         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 408 }
 409
 410
 411 /*
 412   lsa_OpenAccount
 413 */
 414 static NTSTATUS lsa_OpenAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 415                        struct lsa_OpenAccount *r)
 416 {
 417         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 418 }
 419
 420
 421 /*
 422   lsa_EnumPrivsAccount
 423 */
 424 static NTSTATUS lsa_EnumPrivsAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 425                        struct lsa_EnumPrivsAccount *r)
 426 {
 427         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 428 }
 429
 430
 431 /*
 432   lsa_AddPrivilegesToAccount
 433 */
 434 static NTSTATUS lsa_AddPrivilegesToAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 435                        struct lsa_AddPrivilegesToAccount *r)
 436 {
 437         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 438 }
 439
 440
 441 /*
 442   lsa_RemovePrivilegesFromAccount
 443 */
 444 static NTSTATUS lsa_RemovePrivilegesFromAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 445                        struct lsa_RemovePrivilegesFromAccount *r)
 446 {
 447         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 448 }
 449
 450
 451 /*
 452   lsa_GetQuotasForAccount
 453 */
 454 static NTSTATUS lsa_GetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 455                        struct lsa_GetQuotasForAccount *r)
 456 {
 457         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 458 }
 459
 460
 461 /*
 462   lsa_SetQuotasForAccount
 463 */
 464 static NTSTATUS lsa_SetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 465                        struct lsa_SetQuotasForAccount *r)
 466 {
 467         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 468 }
 469
 470
 471 /*
 472   lsa_GetSystemAccessAccount
 473 */
 474 static NTSTATUS lsa_GetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 475                        struct lsa_GetSystemAccessAccount *r)
 476 {
 477         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 478 }
 479
 480
 481 /*
 482   lsa_SetSystemAccessAccount
 483 */
 484 static NTSTATUS lsa_SetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 485                        struct lsa_SetSystemAccessAccount *r)
 486 {
 487         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 488 }
 489
 490
 491 /*
 492   lsa_OpenTrustedDomain
 493 */
 494 static NTSTATUS lsa_OpenTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 495                        struct lsa_OpenTrustedDomain *r)
 496 {
 497         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 498 }
 499
 500
 501 /*
 502   lsa_QueryInfoTrustedDomain
 503 */
 504 static NTSTATUS lsa_QueryInfoTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 505                        struct lsa_QueryInfoTrustedDomain *r)
 506 {
 507         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 508 }
 509
 510
 511 /*
 512   lsa_SetInformationTrustedDomain
 513 */
 514 static NTSTATUS lsa_SetInformationTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 515                        struct lsa_SetInformationTrustedDomain *r)
 516 {
 517         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 518 }
 519
 520
 521 /*
 522   lsa_OpenSecret
 523 */
 524 static NTSTATUS lsa_OpenSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 525                        struct lsa_OpenSecret *r)
 526 {
 527         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 528 }
 529
 530
 531 /*
 532   lsa_SetSecret
 533 */
 534 static NTSTATUS lsa_SetSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 535                        struct lsa_SetSecret *r)
 536 {
 537         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 538 }
 539
 540
 541 /*
 542   lsa_QuerySecret
 543 */
 544 static NTSTATUS lsa_QuerySecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 545                        struct lsa_QuerySecret *r)
 546 {
 547         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 548 }
 549
 550
 551 /*
 552   lsa_LookupPrivValue
 553 */
 554 static NTSTATUS lsa_LookupPrivValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 555                        struct lsa_LookupPrivValue *r)
 556 {
 557         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 558 }
 559
 560
 561 /*
 562   lsa_LookupPrivName
 563 */
 564 static NTSTATUS lsa_LookupPrivName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 565                        struct lsa_LookupPrivName *r)
 566 {
 567         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 568 }
 569
 570
 571 /*
 572   lsa_LookupPrivDisplayName
 573 */
 574 static NTSTATUS lsa_LookupPrivDisplayName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 575                        struct lsa_LookupPrivDisplayName *r)
 576 {
 577         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 578 }
 579
 580
 581 /*
 582   lsa_DeleteObject
 583 */
 584 static NTSTATUS lsa_DeleteObject(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 585                        struct lsa_DeleteObject *r)
 586 {
 587         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 588 }
 589
 590
 591 /*
 592   lsa_EnumAccountsWithUserRight
 593 */
 594 static NTSTATUS lsa_EnumAccountsWithUserRight(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 595                        struct lsa_EnumAccountsWithUserRight *r)
 596 {
 597         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 598 }
 599
 600
 601 /*
 602   lsa_EnumAccountRights
 603 */
 604 static NTSTATUS lsa_EnumAccountRights(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 605                        struct lsa_EnumAccountRights *r)
 606 {
 607         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 608 }
 609
 610
 611 /*
 612   lsa_AddAccountRights
 613 */
 614 static NTSTATUS lsa_AddAccountRights(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 615                        struct lsa_AddAccountRights *r)
 616 {
 617         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 618 }
 619
 620
 621 /*
 622   lsa_RemoveAccountRights
 623 */
 624 static NTSTATUS lsa_RemoveAccountRights(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 625                        struct lsa_RemoveAccountRights *r)
 626 {
 627         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 628 }
 629
 630
 631 /*
 632   lsa_QueryTrustDomainInfo
 633 */
 634 static NTSTATUS lsa_QueryTrustDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 635                        struct lsa_QueryTrustDomainInfo *r)
 636 {
 637         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 638 }
 639
 640
 641 /*
 642   lsa_SetTrustDomainInfo
 643 */
 644 static NTSTATUS lsa_SetTrustDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 645                        struct lsa_SetTrustDomainInfo *r)
 646 {
 647         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 648 }
 649
 650
 651 /*
 652   lsa_DeleteTrustDomain
 653 */
 654 static NTSTATUS lsa_DeleteTrustDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 655                        struct lsa_DeleteTrustDomain *r)
 656 {
 657         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 658 }
 659
 660
 661 /*
 662   lsa_StorePrivateData
 663 */
 664 static NTSTATUS lsa_StorePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 665                        struct lsa_StorePrivateData *r)
 666 {
 667         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 668 }
 669
 670
 671 /*
 672   lsa_RetrievePrivateData
 673 */
 674 static NTSTATUS lsa_RetrievePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 675                        struct lsa_RetrievePrivateData *r)
 676 {
 677         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 678 }
 679
 680
 681 /*
 682   lsa_GetUserName
 683 */
 684 static NTSTATUS lsa_GetUserName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 685                        struct lsa_GetUserName *r)
 686 {
 687         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 688 }
 689
 690 /*
 691   lsa_SetInfoPolicy2
 692 */
 693 static NTSTATUS lsa_SetInfoPolicy2(struct dcesrv_call_state *dce_call,
 694                                    TALLOC_CTX *mem_ctx,
 695                                    struct lsa_SetInfoPolicy2 *r)
 696 {
 697         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 698 }
 699
 700 /*
 701   lsa_QueryTrustedDomainInfoByName
 702 */
 703 static NTSTATUS lsa_QueryTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
 704                                                  TALLOC_CTX *mem_ctx,
 705                                                  struct lsa_QueryTrustedDomainInfoByName *r)
 706 {
 707         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 708 }
 709
 710 /*
 711   lsa_SetTrustedDomainInfoByName
 712 */
 713 static NTSTATUS lsa_SetTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
 714                                                TALLOC_CTX *mem_ctx,
 715                                                struct lsa_SetTrustedDomainInfoByName *r)
 716 {
 717         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 718 }
 719
 720 /*
 721   lsa_EnumTrustedDomainsEx
 722 */
 723 static NTSTATUS lsa_EnumTrustedDomainsEx(struct dcesrv_call_state *dce_call,
 724                                          TALLOC_CTX *mem_ctx,
 725                                          struct lsa_EnumTrustedDomainsEx *r)
 726 {
 727         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 728 }
 729
 730 /*
 731   lsa_CreateTrustedDomainEx
 732 */
 733 static NTSTATUS lsa_CreateTrustedDomainEx(struct dcesrv_call_state *dce_call,
 734                                           TALLOC_CTX *mem_ctx,
 735                                           struct lsa_CreateTrustedDomainEx *r)
 736 {
 737         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 738 }
 739
 740 /*
 741   lsa_CloseTrustedDomainEx
 742 */
 743 static NTSTATUS lsa_CloseTrustedDomainEx(struct dcesrv_call_state *dce_call,
 744                                          TALLOC_CTX *mem_ctx,
 745                                          struct lsa_CloseTrustedDomainEx *r)
 746 {
 747         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 748 }
 749
 750 /*
 751   lsa_QueryDomainInformationPolicy
 752 */
 753 static NTSTATUS lsa_QueryDomainInformationPolicy(struct dcesrv_call_state *dce_call,
 754                                                  TALLOC_CTX *mem_ctx,
 755                                                  struct lsa_QueryDomainInformationPolicy *r)
 756 {
 757         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 758 }
 759
 760 /*
 761   lsa_SetDomInfoPolicy
 762 */
 763 static NTSTATUS lsa_SetDomInfoPolicy(struct dcesrv_call_state *dce_call,
 764                                      TALLOC_CTX *mem_ctx,
 765                                      struct lsa_SetDomInfoPolicy *r)
 766 {
 767         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 768 }
 769
 770 /*
 771   lsa_OpenTrustedDomainByName
 772 */
 773 static NTSTATUS lsa_OpenTrustedDomainByName(struct dcesrv_call_state *dce_call,
 774                                             TALLOC_CTX *mem_ctx,
 775                                             struct lsa_OpenTrustedDomainByName *r)
 776 {
 777         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 778 }
 779
 780 /*
 781   lsa_TestCall
 782 */
 783 static NTSTATUS lsa_TestCall(struct dcesrv_call_state *dce_call,
 784                              TALLOC_CTX *mem_ctx,
 785                              struct lsa_TestCall *r)
 786 {
 787         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 788 }
 789
 790 /*
 791   lsa_LookupSids2
 792 */
 793 static NTSTATUS lsa_LookupSids2(struct dcesrv_call_state *dce_call,
 794                                 TALLOC_CTX *mem_ctx,
 795                                 struct lsa_LookupSids2 *r)
 796 {
 797         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 798 }
 799
 800 /*
 801   lsa_LookupNames2
 802 */
 803 static NTSTATUS lsa_LookupNames2(struct dcesrv_call_state *dce_call,
 804                                  TALLOC_CTX *mem_ctx,
 805                                  struct lsa_LookupNames2 *r)
 806 {
 807         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 808 }
 809
 810 /*
 811   lsa_CreateTrustedDomainEx2
 812 */
 813 static NTSTATUS lsa_CreateTrustedDomainEx2(struct dcesrv_call_state *dce_call,
 814                                            TALLOC_CTX *mem_ctx,
 815                                            struct lsa_CreateTrustedDomainEx2 *r)
 816 {
 817         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 818 }
 819
 820 /* include the generated boilerplate */
 821 #include "librpc/gen_ndr/ndr_lsa_s.c"