source/librpc/gen_ndr/cli_lsa.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/cli_lsa.h"
   8
   9 NTSTATUS rpccli_lsa_Close(struct rpc_pipe_client *cli,
  10                           TALLOC_CTX *mem_ctx,
  11                           struct policy_handle *handle /* [in,out] [ref] */)
  12 {
  13         struct lsa_Close r;
  14         NTSTATUS status;
  15
  16         /* In parameters */
  17         r.in.handle = handle;
  18
  19         if (DEBUGLEVEL >= 10) {
  20                 NDR_PRINT_IN_DEBUG(lsa_Close, &r);
  21         }
  22
  23         status = cli_do_rpc_ndr(cli,
  24                                 mem_ctx,
  25                                 PI_LSARPC,
  26                                 &ndr_table_lsarpc,
  27                                 NDR_LSA_CLOSE,
  28                                 &r);
  29
  30         if (!NT_STATUS_IS_OK(status)) {
  31                 return status;
  32         }
  33
  34         if (DEBUGLEVEL >= 10) {
  35                 NDR_PRINT_OUT_DEBUG(lsa_Close, &r);
  36         }
  37
  38         if (NT_STATUS_IS_ERR(status)) {
  39                 return status;
  40         }
  41
  42         /* Return variables */
  43         *handle = *r.out.handle;
  44
  45         /* Return result */
  46         return r.out.result;
  47 }
  48
  49 NTSTATUS rpccli_lsa_Delete(struct rpc_pipe_client *cli,
  50                            TALLOC_CTX *mem_ctx,
  51                            struct policy_handle *handle /* [in] [ref] */)
  52 {
  53         struct lsa_Delete r;
  54         NTSTATUS status;
  55
  56         /* In parameters */
  57         r.in.handle = handle;
  58
  59         if (DEBUGLEVEL >= 10) {
  60                 NDR_PRINT_IN_DEBUG(lsa_Delete, &r);
  61         }
  62
  63         status = cli_do_rpc_ndr(cli,
  64                                 mem_ctx,
  65                                 PI_LSARPC,
  66                                 &ndr_table_lsarpc,
  67                                 NDR_LSA_DELETE,
  68                                 &r);
  69
  70         if (!NT_STATUS_IS_OK(status)) {
  71                 return status;
  72         }
  73
  74         if (DEBUGLEVEL >= 10) {
  75                 NDR_PRINT_OUT_DEBUG(lsa_Delete, &r);
  76         }
  77
  78         if (NT_STATUS_IS_ERR(status)) {
  79                 return status;
  80         }
  81
  82         /* Return variables */
  83
  84         /* Return result */
  85         return r.out.result;
  86 }
  87
  88 NTSTATUS rpccli_lsa_EnumPrivs(struct rpc_pipe_client *cli,
  89                               TALLOC_CTX *mem_ctx,
  90                               struct policy_handle *handle /* [in] [ref] */,
  91                               uint32_t *resume_handle /* [in,out] [ref] */,
  92                               struct lsa_PrivArray *privs /* [out] [ref] */,
  93                               uint32_t max_count /* [in]  */)
  94 {
  95         struct lsa_EnumPrivs r;
  96         NTSTATUS status;
  97
  98         /* In parameters */
  99         r.in.handle = handle;
 100         r.in.resume_handle = resume_handle;
 101         r.in.max_count = max_count;
 102
 103         if (DEBUGLEVEL >= 10) {
 104                 NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, &r);
 105         }
 106
 107         status = cli_do_rpc_ndr(cli,
 108                                 mem_ctx,
 109                                 PI_LSARPC,
 110                                 &ndr_table_lsarpc,
 111                                 NDR_LSA_ENUMPRIVS,
 112                                 &r);
 113
 114         if (!NT_STATUS_IS_OK(status)) {
 115                 return status;
 116         }
 117
 118         if (DEBUGLEVEL >= 10) {
 119                 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, &r);
 120         }
 121
 122         if (NT_STATUS_IS_ERR(status)) {
 123                 return status;
 124         }
 125
 126         /* Return variables */
 127         *resume_handle = *r.out.resume_handle;
 128         *privs = *r.out.privs;
 129
 130         /* Return result */
 131         return r.out.result;
 132 }
 133
 134 NTSTATUS rpccli_lsa_QuerySecurity(struct rpc_pipe_client *cli,
 135                                   TALLOC_CTX *mem_ctx,
 136                                   struct policy_handle *handle /* [in] [ref] */,
 137                                   uint32_t sec_info /* [in]  */,
 138                                   struct sec_desc_buf **sdbuf /* [out] [ref] */)
 139 {
 140         struct lsa_QuerySecurity r;
 141         NTSTATUS status;
 142
 143         /* In parameters */
 144         r.in.handle = handle;
 145         r.in.sec_info = sec_info;
 146
 147         if (DEBUGLEVEL >= 10) {
 148                 NDR_PRINT_IN_DEBUG(lsa_QuerySecurity, &r);
 149         }
 150
 151         status = cli_do_rpc_ndr(cli,
 152                                 mem_ctx,
 153                                 PI_LSARPC,
 154                                 &ndr_table_lsarpc,
 155                                 NDR_LSA_QUERYSECURITY,
 156                                 &r);
 157
 158         if (!NT_STATUS_IS_OK(status)) {
 159                 return status;
 160         }
 161
 162         if (DEBUGLEVEL >= 10) {
 163                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, &r);
 164         }
 165
 166         if (NT_STATUS_IS_ERR(status)) {
 167                 return status;
 168         }
 169
 170         /* Return variables */
 171         *sdbuf = *r.out.sdbuf;
 172
 173         /* Return result */
 174         return r.out.result;
 175 }
 176
 177 NTSTATUS rpccli_lsa_SetSecObj(struct rpc_pipe_client *cli,
 178                               TALLOC_CTX *mem_ctx,
 179                               struct policy_handle *handle /* [in] [ref] */,
 180                               uint32_t sec_info /* [in]  */,
 181                               struct sec_desc_buf *sdbuf /* [in] [ref] */)
 182 {
 183         struct lsa_SetSecObj r;
 184         NTSTATUS status;
 185
 186         /* In parameters */
 187         r.in.handle = handle;
 188         r.in.sec_info = sec_info;
 189         r.in.sdbuf = sdbuf;
 190
 191         if (DEBUGLEVEL >= 10) {
 192                 NDR_PRINT_IN_DEBUG(lsa_SetSecObj, &r);
 193         }
 194
 195         status = cli_do_rpc_ndr(cli,
 196                                 mem_ctx,
 197                                 PI_LSARPC,
 198                                 &ndr_table_lsarpc,
 199                                 NDR_LSA_SETSECOBJ,
 200                                 &r);
 201
 202         if (!NT_STATUS_IS_OK(status)) {
 203                 return status;
 204         }
 205
 206         if (DEBUGLEVEL >= 10) {
 207                 NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, &r);
 208         }
 209
 210         if (NT_STATUS_IS_ERR(status)) {
 211                 return status;
 212         }
 213
 214         /* Return variables */
 215
 216         /* Return result */
 217         return r.out.result;
 218 }
 219
 220 NTSTATUS rpccli_lsa_ChangePassword(struct rpc_pipe_client *cli,
 221                                    TALLOC_CTX *mem_ctx)
 222 {
 223         struct lsa_ChangePassword r;
 224         NTSTATUS status;
 225
 226         /* In parameters */
 227
 228         if (DEBUGLEVEL >= 10) {
 229                 NDR_PRINT_IN_DEBUG(lsa_ChangePassword, &r);
 230         }
 231
 232         status = cli_do_rpc_ndr(cli,
 233                                 mem_ctx,
 234                                 PI_LSARPC,
 235                                 &ndr_table_lsarpc,
 236                                 NDR_LSA_CHANGEPASSWORD,
 237                                 &r);
 238
 239         if (!NT_STATUS_IS_OK(status)) {
 240                 return status;
 241         }
 242
 243         if (DEBUGLEVEL >= 10) {
 244                 NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, &r);
 245         }
 246
 247         if (NT_STATUS_IS_ERR(status)) {
 248                 return status;
 249         }
 250
 251         /* Return variables */
 252
 253         /* Return result */
 254         return r.out.result;
 255 }
 256
 257 NTSTATUS rpccli_lsa_OpenPolicy(struct rpc_pipe_client *cli,
 258                                TALLOC_CTX *mem_ctx,
 259                                uint16_t *system_name /* [in] [unique] */,
 260                                struct lsa_ObjectAttribute *attr /* [in] [ref] */,
 261                                uint32_t access_mask /* [in]  */,
 262                                struct policy_handle *handle /* [out] [ref] */)
 263 {
 264         struct lsa_OpenPolicy r;
 265         NTSTATUS status;
 266
 267         /* In parameters */
 268         r.in.system_name = system_name;
 269         r.in.attr = attr;
 270         r.in.access_mask = access_mask;
 271
 272         if (DEBUGLEVEL >= 10) {
 273                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, &r);
 274         }
 275
 276         status = cli_do_rpc_ndr(cli,
 277                                 mem_ctx,
 278                                 PI_LSARPC,
 279                                 &ndr_table_lsarpc,
 280                                 NDR_LSA_OPENPOLICY,
 281                                 &r);
 282
 283         if (!NT_STATUS_IS_OK(status)) {
 284                 return status;
 285         }
 286
 287         if (DEBUGLEVEL >= 10) {
 288                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, &r);
 289         }
 290
 291         if (NT_STATUS_IS_ERR(status)) {
 292                 return status;
 293         }
 294
 295         /* Return variables */
 296         *handle = *r.out.handle;
 297
 298         /* Return result */
 299         return r.out.result;
 300 }
 301
 302 NTSTATUS rpccli_lsa_QueryInfoPolicy(struct rpc_pipe_client *cli,
 303                                     TALLOC_CTX *mem_ctx,
 304                                     struct policy_handle *handle /* [in] [ref] */,
 305                                     enum lsa_PolicyInfo level /* [in]  */,
 306                                     union lsa_PolicyInformation **info /* [out] [ref,switch_is(level)] */)
 307 {
 308         struct lsa_QueryInfoPolicy r;
 309         NTSTATUS status;
 310
 311         /* In parameters */
 312         r.in.handle = handle;
 313         r.in.level = level;
 314
 315         if (DEBUGLEVEL >= 10) {
 316                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy, &r);
 317         }
 318
 319         status = cli_do_rpc_ndr(cli,
 320                                 mem_ctx,
 321                                 PI_LSARPC,
 322                                 &ndr_table_lsarpc,
 323                                 NDR_LSA_QUERYINFOPOLICY,
 324                                 &r);
 325
 326         if (!NT_STATUS_IS_OK(status)) {
 327                 return status;
 328         }
 329
 330         if (DEBUGLEVEL >= 10) {
 331                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, &r);
 332         }
 333
 334         if (NT_STATUS_IS_ERR(status)) {
 335                 return status;
 336         }
 337
 338         /* Return variables */
 339         *info = *r.out.info;
 340
 341         /* Return result */
 342         return r.out.result;
 343 }
 344
 345 NTSTATUS rpccli_lsa_SetInfoPolicy(struct rpc_pipe_client *cli,
 346                                   TALLOC_CTX *mem_ctx,
 347                                   struct policy_handle *handle /* [in] [ref] */,
 348                                   enum lsa_PolicyInfo level /* [in]  */,
 349                                   union lsa_PolicyInformation *info /* [in] [ref,switch_is(level)] */)
 350 {
 351         struct lsa_SetInfoPolicy r;
 352         NTSTATUS status;
 353
 354         /* In parameters */
 355         r.in.handle = handle;
 356         r.in.level = level;
 357         r.in.info = info;
 358
 359         if (DEBUGLEVEL >= 10) {
 360                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, &r);
 361         }
 362
 363         status = cli_do_rpc_ndr(cli,
 364                                 mem_ctx,
 365                                 PI_LSARPC,
 366                                 &ndr_table_lsarpc,
 367                                 NDR_LSA_SETINFOPOLICY,
 368                                 &r);
 369
 370         if (!NT_STATUS_IS_OK(status)) {
 371                 return status;
 372         }
 373
 374         if (DEBUGLEVEL >= 10) {
 375                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, &r);
 376         }
 377
 378         if (NT_STATUS_IS_ERR(status)) {
 379                 return status;
 380         }
 381
 382         /* Return variables */
 383
 384         /* Return result */
 385         return r.out.result;
 386 }
 387
 388 NTSTATUS rpccli_lsa_ClearAuditLog(struct rpc_pipe_client *cli,
 389                                   TALLOC_CTX *mem_ctx)
 390 {
 391         struct lsa_ClearAuditLog r;
 392         NTSTATUS status;
 393
 394         /* In parameters */
 395
 396         if (DEBUGLEVEL >= 10) {
 397                 NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, &r);
 398         }
 399
 400         status = cli_do_rpc_ndr(cli,
 401                                 mem_ctx,
 402                                 PI_LSARPC,
 403                                 &ndr_table_lsarpc,
 404                                 NDR_LSA_CLEARAUDITLOG,
 405                                 &r);
 406
 407         if (!NT_STATUS_IS_OK(status)) {
 408                 return status;
 409         }
 410
 411         if (DEBUGLEVEL >= 10) {
 412                 NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, &r);
 413         }
 414
 415         if (NT_STATUS_IS_ERR(status)) {
 416                 return status;
 417         }
 418
 419         /* Return variables */
 420
 421         /* Return result */
 422         return r.out.result;
 423 }
 424
 425 NTSTATUS rpccli_lsa_CreateAccount(struct rpc_pipe_client *cli,
 426                                   TALLOC_CTX *mem_ctx,
 427                                   struct policy_handle *handle /* [in] [ref] */,
 428                                   struct dom_sid2 *sid /* [in] [ref] */,
 429                                   uint32_t access_mask /* [in]  */,
 430                                   struct policy_handle *acct_handle /* [out] [ref] */)
 431 {
 432         struct lsa_CreateAccount r;
 433         NTSTATUS status;
 434
 435         /* In parameters */
 436         r.in.handle = handle;
 437         r.in.sid = sid;
 438         r.in.access_mask = access_mask;
 439
 440         if (DEBUGLEVEL >= 10) {
 441                 NDR_PRINT_IN_DEBUG(lsa_CreateAccount, &r);
 442         }
 443
 444         status = cli_do_rpc_ndr(cli,
 445                                 mem_ctx,
 446                                 PI_LSARPC,
 447                                 &ndr_table_lsarpc,
 448                                 NDR_LSA_CREATEACCOUNT,
 449                                 &r);
 450
 451         if (!NT_STATUS_IS_OK(status)) {
 452                 return status;
 453         }
 454
 455         if (DEBUGLEVEL >= 10) {
 456                 NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, &r);
 457         }
 458
 459         if (NT_STATUS_IS_ERR(status)) {
 460                 return status;
 461         }
 462
 463         /* Return variables */
 464         *acct_handle = *r.out.acct_handle;
 465
 466         /* Return result */
 467         return r.out.result;
 468 }
 469
 470 NTSTATUS rpccli_lsa_EnumAccounts(struct rpc_pipe_client *cli,
 471                                  TALLOC_CTX *mem_ctx,
 472                                  struct policy_handle *handle /* [in] [ref] */,
 473                                  uint32_t *resume_handle /* [in,out] [ref] */,
 474                                  struct lsa_SidArray *sids /* [out] [ref] */,
 475                                  uint32_t num_entries /* [in] [range(0,8192)] */)
 476 {
 477         struct lsa_EnumAccounts r;
 478         NTSTATUS status;
 479
 480         /* In parameters */
 481         r.in.handle = handle;
 482         r.in.resume_handle = resume_handle;
 483         r.in.num_entries = num_entries;
 484
 485         if (DEBUGLEVEL >= 10) {
 486                 NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, &r);
 487         }
 488
 489         status = cli_do_rpc_ndr(cli,
 490                                 mem_ctx,
 491                                 PI_LSARPC,
 492                                 &ndr_table_lsarpc,
 493                                 NDR_LSA_ENUMACCOUNTS,
 494                                 &r);
 495
 496         if (!NT_STATUS_IS_OK(status)) {
 497                 return status;
 498         }
 499
 500         if (DEBUGLEVEL >= 10) {
 501                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, &r);
 502         }
 503
 504         if (NT_STATUS_IS_ERR(status)) {
 505                 return status;
 506         }
 507
 508         /* Return variables */
 509         *resume_handle = *r.out.resume_handle;
 510         *sids = *r.out.sids;
 511
 512         /* Return result */
 513         return r.out.result;
 514 }
 515
 516 NTSTATUS rpccli_lsa_CreateTrustedDomain(struct rpc_pipe_client *cli,
 517                                         TALLOC_CTX *mem_ctx,
 518                                         struct policy_handle *handle /* [in] [ref] */,
 519                                         struct lsa_DomainInfo *info /* [in] [ref] */,
 520                                         uint32_t access_mask /* [in]  */,
 521                                         struct policy_handle *trustdom_handle /* [out] [ref] */)
 522 {
 523         struct lsa_CreateTrustedDomain r;
 524         NTSTATUS status;
 525
 526         /* In parameters */
 527         r.in.handle = handle;
 528         r.in.info = info;
 529         r.in.access_mask = access_mask;
 530
 531         if (DEBUGLEVEL >= 10) {
 532                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain, &r);
 533         }
 534
 535         status = cli_do_rpc_ndr(cli,
 536                                 mem_ctx,
 537                                 PI_LSARPC,
 538                                 &ndr_table_lsarpc,
 539                                 NDR_LSA_CREATETRUSTEDDOMAIN,
 540                                 &r);
 541
 542         if (!NT_STATUS_IS_OK(status)) {
 543                 return status;
 544         }
 545
 546         if (DEBUGLEVEL >= 10) {
 547                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain, &r);
 548         }
 549
 550         if (NT_STATUS_IS_ERR(status)) {
 551                 return status;
 552         }
 553
 554         /* Return variables */
 555         *trustdom_handle = *r.out.trustdom_handle;
 556
 557         /* Return result */
 558         return r.out.result;
 559 }
 560
 561 NTSTATUS rpccli_lsa_EnumTrustDom(struct rpc_pipe_client *cli,
 562                                  TALLOC_CTX *mem_ctx,
 563                                  struct policy_handle *handle /* [in] [ref] */,
 564                                  uint32_t *resume_handle /* [in,out] [ref] */,
 565                                  struct lsa_DomainList *domains /* [out] [ref] */,
 566                                  uint32_t max_size /* [in]  */)
 567 {
 568         struct lsa_EnumTrustDom r;
 569         NTSTATUS status;
 570
 571         /* In parameters */
 572         r.in.handle = handle;
 573         r.in.resume_handle = resume_handle;
 574         r.in.max_size = max_size;
 575
 576         if (DEBUGLEVEL >= 10) {
 577                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, &r);
 578         }
 579
 580         status = cli_do_rpc_ndr(cli,
 581                                 mem_ctx,
 582                                 PI_LSARPC,
 583                                 &ndr_table_lsarpc,
 584                                 NDR_LSA_ENUMTRUSTDOM,
 585                                 &r);
 586
 587         if (!NT_STATUS_IS_OK(status)) {
 588                 return status;
 589         }
 590
 591         if (DEBUGLEVEL >= 10) {
 592                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, &r);
 593         }
 594
 595         if (NT_STATUS_IS_ERR(status)) {
 596                 return status;
 597         }
 598
 599         /* Return variables */
 600         *resume_handle = *r.out.resume_handle;
 601         *domains = *r.out.domains;
 602
 603         /* Return result */
 604         return r.out.result;
 605 }
 606
 607 NTSTATUS rpccli_lsa_LookupNames(struct rpc_pipe_client *cli,
 608                                 TALLOC_CTX *mem_ctx,
 609                                 struct policy_handle *handle /* [in] [ref] */,
 610                                 uint32_t num_names /* [in] [range(0,1000)] */,
 611                                 struct lsa_String *names /* [in] [size_is(num_names)] */,
 612                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
 613                                 struct lsa_TransSidArray *sids /* [in,out] [ref] */,
 614                                 enum lsa_LookupNamesLevel level /* [in]  */,
 615                                 uint32_t *count /* [in,out] [ref] */)
 616 {
 617         struct lsa_LookupNames r;
 618         NTSTATUS status;
 619
 620         /* In parameters */
 621         r.in.handle = handle;
 622         r.in.num_names = num_names;
 623         r.in.names = names;
 624         r.in.sids = sids;
 625         r.in.level = level;
 626         r.in.count = count;
 627
 628         if (DEBUGLEVEL >= 10) {
 629                 NDR_PRINT_IN_DEBUG(lsa_LookupNames, &r);
 630         }
 631
 632         status = cli_do_rpc_ndr(cli,
 633                                 mem_ctx,
 634                                 PI_LSARPC,
 635                                 &ndr_table_lsarpc,
 636                                 NDR_LSA_LOOKUPNAMES,
 637                                 &r);
 638
 639         if (!NT_STATUS_IS_OK(status)) {
 640                 return status;
 641         }
 642
 643         if (DEBUGLEVEL >= 10) {
 644                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames, &r);
 645         }
 646
 647         if (NT_STATUS_IS_ERR(status)) {
 648                 return status;
 649         }
 650
 651         /* Return variables */
 652         *domains = *r.out.domains;
 653         *sids = *r.out.sids;
 654         *count = *r.out.count;
 655
 656         /* Return result */
 657         return r.out.result;
 658 }
 659
 660 NTSTATUS rpccli_lsa_LookupSids(struct rpc_pipe_client *cli,
 661                                TALLOC_CTX *mem_ctx,
 662                                struct policy_handle *handle /* [in] [ref] */,
 663                                struct lsa_SidArray *sids /* [in] [ref] */,
 664                                struct lsa_RefDomainList **domains /* [out] [ref] */,
 665                                struct lsa_TransNameArray *names /* [in,out] [ref] */,
 666                                uint16_t level /* [in]  */,
 667                                uint32_t *count /* [in,out] [ref] */)
 668 {
 669         struct lsa_LookupSids r;
 670         NTSTATUS status;
 671
 672         /* In parameters */
 673         r.in.handle = handle;
 674         r.in.sids = sids;
 675         r.in.names = names;
 676         r.in.level = level;
 677         r.in.count = count;
 678
 679         if (DEBUGLEVEL >= 10) {
 680                 NDR_PRINT_IN_DEBUG(lsa_LookupSids, &r);
 681         }
 682
 683         status = cli_do_rpc_ndr(cli,
 684                                 mem_ctx,
 685                                 PI_LSARPC,
 686                                 &ndr_table_lsarpc,
 687                                 NDR_LSA_LOOKUPSIDS,
 688                                 &r);
 689
 690         if (!NT_STATUS_IS_OK(status)) {
 691                 return status;
 692         }
 693
 694         if (DEBUGLEVEL >= 10) {
 695                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids, &r);
 696         }
 697
 698         if (NT_STATUS_IS_ERR(status)) {
 699                 return status;
 700         }
 701
 702         /* Return variables */
 703         *domains = *r.out.domains;
 704         *names = *r.out.names;
 705         *count = *r.out.count;
 706
 707         /* Return result */
 708         return r.out.result;
 709 }
 710
 711 NTSTATUS rpccli_lsa_CreateSecret(struct rpc_pipe_client *cli,
 712                                  TALLOC_CTX *mem_ctx,
 713                                  struct policy_handle *handle /* [in] [ref] */,
 714                                  struct lsa_String name /* [in]  */,
 715                                  uint32_t access_mask /* [in]  */,
 716                                  struct policy_handle *sec_handle /* [out] [ref] */)
 717 {
 718         struct lsa_CreateSecret r;
 719         NTSTATUS status;
 720
 721         /* In parameters */
 722         r.in.handle = handle;
 723         r.in.name = name;
 724         r.in.access_mask = access_mask;
 725
 726         if (DEBUGLEVEL >= 10) {
 727                 NDR_PRINT_IN_DEBUG(lsa_CreateSecret, &r);
 728         }
 729
 730         status = cli_do_rpc_ndr(cli,
 731                                 mem_ctx,
 732                                 PI_LSARPC,
 733                                 &ndr_table_lsarpc,
 734                                 NDR_LSA_CREATESECRET,
 735                                 &r);
 736
 737         if (!NT_STATUS_IS_OK(status)) {
 738                 return status;
 739         }
 740
 741         if (DEBUGLEVEL >= 10) {
 742                 NDR_PRINT_OUT_DEBUG(lsa_CreateSecret, &r);
 743         }
 744
 745         if (NT_STATUS_IS_ERR(status)) {
 746                 return status;
 747         }
 748
 749         /* Return variables */
 750         *sec_handle = *r.out.sec_handle;
 751
 752         /* Return result */
 753         return r.out.result;
 754 }
 755
 756 NTSTATUS rpccli_lsa_OpenAccount(struct rpc_pipe_client *cli,
 757                                 TALLOC_CTX *mem_ctx,
 758                                 struct policy_handle *handle /* [in] [ref] */,
 759                                 struct dom_sid2 *sid /* [in] [ref] */,
 760                                 uint32_t access_mask /* [in]  */,
 761                                 struct policy_handle *acct_handle /* [out] [ref] */)
 762 {
 763         struct lsa_OpenAccount r;
 764         NTSTATUS status;
 765
 766         /* In parameters */
 767         r.in.handle = handle;
 768         r.in.sid = sid;
 769         r.in.access_mask = access_mask;
 770
 771         if (DEBUGLEVEL >= 10) {
 772                 NDR_PRINT_IN_DEBUG(lsa_OpenAccount, &r);
 773         }
 774
 775         status = cli_do_rpc_ndr(cli,
 776                                 mem_ctx,
 777                                 PI_LSARPC,
 778                                 &ndr_table_lsarpc,
 779                                 NDR_LSA_OPENACCOUNT,
 780                                 &r);
 781
 782         if (!NT_STATUS_IS_OK(status)) {
 783                 return status;
 784         }
 785
 786         if (DEBUGLEVEL >= 10) {
 787                 NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, &r);
 788         }
 789
 790         if (NT_STATUS_IS_ERR(status)) {
 791                 return status;
 792         }
 793
 794         /* Return variables */
 795         *acct_handle = *r.out.acct_handle;
 796
 797         /* Return result */
 798         return r.out.result;
 799 }
 800
 801 NTSTATUS rpccli_lsa_EnumPrivsAccount(struct rpc_pipe_client *cli,
 802                                      TALLOC_CTX *mem_ctx,
 803                                      struct policy_handle *handle /* [in] [ref] */,
 804                                      struct lsa_PrivilegeSet **privs /* [out] [ref] */)
 805 {
 806         struct lsa_EnumPrivsAccount r;
 807         NTSTATUS status;
 808
 809         /* In parameters */
 810         r.in.handle = handle;
 811
 812         if (DEBUGLEVEL >= 10) {
 813                 NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, &r);
 814         }
 815
 816         status = cli_do_rpc_ndr(cli,
 817                                 mem_ctx,
 818                                 PI_LSARPC,
 819                                 &ndr_table_lsarpc,
 820                                 NDR_LSA_ENUMPRIVSACCOUNT,
 821                                 &r);
 822
 823         if (!NT_STATUS_IS_OK(status)) {
 824                 return status;
 825         }
 826
 827         if (DEBUGLEVEL >= 10) {
 828                 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, &r);
 829         }
 830
 831         if (NT_STATUS_IS_ERR(status)) {
 832                 return status;
 833         }
 834
 835         /* Return variables */
 836         *privs = *r.out.privs;
 837
 838         /* Return result */
 839         return r.out.result;
 840 }
 841
 842 NTSTATUS rpccli_lsa_AddPrivilegesToAccount(struct rpc_pipe_client *cli,
 843                                            TALLOC_CTX *mem_ctx,
 844                                            struct policy_handle *handle /* [in] [ref] */,
 845                                            struct lsa_PrivilegeSet *privs /* [in] [ref] */)
 846 {
 847         struct lsa_AddPrivilegesToAccount r;
 848         NTSTATUS status;
 849
 850         /* In parameters */
 851         r.in.handle = handle;
 852         r.in.privs = privs;
 853
 854         if (DEBUGLEVEL >= 10) {
 855                 NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, &r);
 856         }
 857
 858         status = cli_do_rpc_ndr(cli,
 859                                 mem_ctx,
 860                                 PI_LSARPC,
 861                                 &ndr_table_lsarpc,
 862                                 NDR_LSA_ADDPRIVILEGESTOACCOUNT,
 863                                 &r);
 864
 865         if (!NT_STATUS_IS_OK(status)) {
 866                 return status;
 867         }
 868
 869         if (DEBUGLEVEL >= 10) {
 870                 NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount, &r);
 871         }
 872
 873         if (NT_STATUS_IS_ERR(status)) {
 874                 return status;
 875         }
 876
 877         /* Return variables */
 878
 879         /* Return result */
 880         return r.out.result;
 881 }
 882
 883 NTSTATUS rpccli_lsa_RemovePrivilegesFromAccount(struct rpc_pipe_client *cli,
 884                                                 TALLOC_CTX *mem_ctx,
 885                                                 struct policy_handle *handle /* [in] [ref] */,
 886                                                 uint8_t remove_all /* [in]  */,
 887                                                 struct lsa_PrivilegeSet *privs /* [in] [unique] */)
 888 {
 889         struct lsa_RemovePrivilegesFromAccount r;
 890         NTSTATUS status;
 891
 892         /* In parameters */
 893         r.in.handle = handle;
 894         r.in.remove_all = remove_all;
 895         r.in.privs = privs;
 896
 897         if (DEBUGLEVEL >= 10) {
 898                 NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, &r);
 899         }
 900
 901         status = cli_do_rpc_ndr(cli,
 902                                 mem_ctx,
 903                                 PI_LSARPC,
 904                                 &ndr_table_lsarpc,
 905                                 NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT,
 906                                 &r);
 907
 908         if (!NT_STATUS_IS_OK(status)) {
 909                 return status;
 910         }
 911
 912         if (DEBUGLEVEL >= 10) {
 913                 NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount, &r);
 914         }
 915
 916         if (NT_STATUS_IS_ERR(status)) {
 917                 return status;
 918         }
 919
 920         /* Return variables */
 921
 922         /* Return result */
 923         return r.out.result;
 924 }
 925
 926 NTSTATUS rpccli_lsa_GetQuotasForAccount(struct rpc_pipe_client *cli,
 927                                         TALLOC_CTX *mem_ctx)
 928 {
 929         struct lsa_GetQuotasForAccount r;
 930         NTSTATUS status;
 931
 932         /* In parameters */
 933
 934         if (DEBUGLEVEL >= 10) {
 935                 NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, &r);
 936         }
 937
 938         status = cli_do_rpc_ndr(cli,
 939                                 mem_ctx,
 940                                 PI_LSARPC,
 941                                 &ndr_table_lsarpc,
 942                                 NDR_LSA_GETQUOTASFORACCOUNT,
 943                                 &r);
 944
 945         if (!NT_STATUS_IS_OK(status)) {
 946                 return status;
 947         }
 948
 949         if (DEBUGLEVEL >= 10) {
 950                 NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount, &r);
 951         }
 952
 953         if (NT_STATUS_IS_ERR(status)) {
 954                 return status;
 955         }
 956
 957         /* Return variables */
 958
 959         /* Return result */
 960         return r.out.result;
 961 }
 962
 963 NTSTATUS rpccli_lsa_SetQuotasForAccount(struct rpc_pipe_client *cli,
 964                                         TALLOC_CTX *mem_ctx)
 965 {
 966         struct lsa_SetQuotasForAccount r;
 967         NTSTATUS status;
 968
 969         /* In parameters */
 970
 971         if (DEBUGLEVEL >= 10) {
 972                 NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, &r);
 973         }
 974
 975         status = cli_do_rpc_ndr(cli,
 976                                 mem_ctx,
 977                                 PI_LSARPC,
 978                                 &ndr_table_lsarpc,
 979                                 NDR_LSA_SETQUOTASFORACCOUNT,
 980                                 &r);
 981
 982         if (!NT_STATUS_IS_OK(status)) {
 983                 return status;
 984         }
 985
 986         if (DEBUGLEVEL >= 10) {
 987                 NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount, &r);
 988         }
 989
 990         if (NT_STATUS_IS_ERR(status)) {
 991                 return status;
 992         }
 993
 994         /* Return variables */
 995
 996         /* Return result */
 997         return r.out.result;
 998 }
 999
1000 NTSTATUS rpccli_lsa_GetSystemAccessAccount(struct rpc_pipe_client *cli,
1001                                            TALLOC_CTX *mem_ctx,
1002                                            struct policy_handle *handle /* [in] [ref] */,
1003                                            uint32_t *access_mask /* [out] [ref] */)
1004 {
1005         struct lsa_GetSystemAccessAccount r;
1006         NTSTATUS status;
1007
1008         /* In parameters */
1009         r.in.handle = handle;
1010
1011         if (DEBUGLEVEL >= 10) {
1012                 NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, &r);
1013         }
1014
1015         status = cli_do_rpc_ndr(cli,
1016                                 mem_ctx,
1017                                 PI_LSARPC,
1018                                 &ndr_table_lsarpc,
1019                                 NDR_LSA_GETSYSTEMACCESSACCOUNT,
1020                                 &r);
1021
1022         if (!NT_STATUS_IS_OK(status)) {
1023                 return status;
1024         }
1025
1026         if (DEBUGLEVEL >= 10) {
1027                 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, &r);
1028         }
1029
1030         if (NT_STATUS_IS_ERR(status)) {
1031                 return status;
1032         }
1033
1034         /* Return variables */
1035         *access_mask = *r.out.access_mask;
1036
1037         /* Return result */
1038         return r.out.result;
1039 }
1040
1041 NTSTATUS rpccli_lsa_SetSystemAccessAccount(struct rpc_pipe_client *cli,
1042                                            TALLOC_CTX *mem_ctx,
1043                                            struct policy_handle *handle /* [in] [ref] */,
1044                                            uint32_t access_mask /* [in]  */)
1045 {
1046         struct lsa_SetSystemAccessAccount r;
1047         NTSTATUS status;
1048
1049         /* In parameters */
1050         r.in.handle = handle;
1051         r.in.access_mask = access_mask;
1052
1053         if (DEBUGLEVEL >= 10) {
1054                 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, &r);
1055         }
1056
1057         status = cli_do_rpc_ndr(cli,
1058                                 mem_ctx,
1059                                 PI_LSARPC,
1060                                 &ndr_table_lsarpc,
1061                                 NDR_LSA_SETSYSTEMACCESSACCOUNT,
1062                                 &r);
1063
1064         if (!NT_STATUS_IS_OK(status)) {
1065                 return status;
1066         }
1067
1068         if (DEBUGLEVEL >= 10) {
1069                 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, &r);
1070         }
1071
1072         if (NT_STATUS_IS_ERR(status)) {
1073                 return status;
1074         }
1075
1076         /* Return variables */
1077
1078         /* Return result */
1079         return r.out.result;
1080 }
1081
1082 NTSTATUS rpccli_lsa_OpenTrustedDomain(struct rpc_pipe_client *cli,
1083                                       TALLOC_CTX *mem_ctx,
1084                                       struct policy_handle *handle /* [in] [ref] */,
1085                                       struct dom_sid2 *sid /* [in] [ref] */,
1086                                       uint32_t access_mask /* [in]  */,
1087                                       struct policy_handle *trustdom_handle /* [out] [ref] */)
1088 {
1089         struct lsa_OpenTrustedDomain r;
1090         NTSTATUS status;
1091
1092         /* In parameters */
1093         r.in.handle = handle;
1094         r.in.sid = sid;
1095         r.in.access_mask = access_mask;
1096
1097         if (DEBUGLEVEL >= 10) {
1098                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, &r);
1099         }
1100
1101         status = cli_do_rpc_ndr(cli,
1102                                 mem_ctx,
1103                                 PI_LSARPC,
1104                                 &ndr_table_lsarpc,
1105                                 NDR_LSA_OPENTRUSTEDDOMAIN,
1106                                 &r);
1107
1108         if (!NT_STATUS_IS_OK(status)) {
1109                 return status;
1110         }
1111
1112         if (DEBUGLEVEL >= 10) {
1113                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, &r);
1114         }
1115
1116         if (NT_STATUS_IS_ERR(status)) {
1117                 return status;
1118         }
1119
1120         /* Return variables */
1121         *trustdom_handle = *r.out.trustdom_handle;
1122
1123         /* Return result */
1124         return r.out.result;
1125 }
1126
1127 NTSTATUS rpccli_lsa_QueryTrustedDomainInfo(struct rpc_pipe_client *cli,
1128                                            TALLOC_CTX *mem_ctx,
1129                                            struct policy_handle *trustdom_handle /* [in] [ref] */,
1130                                            enum lsa_TrustDomInfoEnum level /* [in]  */,
1131                                            union lsa_TrustedDomainInfo *info /* [out] [unique,switch_is(level)] */)
1132 {
1133         struct lsa_QueryTrustedDomainInfo r;
1134         NTSTATUS status;
1135
1136         /* In parameters */
1137         r.in.trustdom_handle = trustdom_handle;
1138         r.in.level = level;
1139
1140         if (DEBUGLEVEL >= 10) {
1141                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo, &r);
1142         }
1143
1144         status = cli_do_rpc_ndr(cli,
1145                                 mem_ctx,
1146                                 PI_LSARPC,
1147                                 &ndr_table_lsarpc,
1148                                 NDR_LSA_QUERYTRUSTEDDOMAININFO,
1149                                 &r);
1150
1151         if (!NT_STATUS_IS_OK(status)) {
1152                 return status;
1153         }
1154
1155         if (DEBUGLEVEL >= 10) {
1156                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, &r);
1157         }
1158
1159         if (NT_STATUS_IS_ERR(status)) {
1160                 return status;
1161         }
1162
1163         /* Return variables */
1164         if (info && r.out.info) {
1165                 *info = *r.out.info;
1166         }
1167
1168         /* Return result */
1169         return r.out.result;
1170 }
1171
1172 NTSTATUS rpccli_lsa_SetInformationTrustedDomain(struct rpc_pipe_client *cli,
1173                                                 TALLOC_CTX *mem_ctx)
1174 {
1175         struct lsa_SetInformationTrustedDomain r;
1176         NTSTATUS status;
1177
1178         /* In parameters */
1179
1180         if (DEBUGLEVEL >= 10) {
1181                 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, &r);
1182         }
1183
1184         status = cli_do_rpc_ndr(cli,
1185                                 mem_ctx,
1186                                 PI_LSARPC,
1187                                 &ndr_table_lsarpc,
1188                                 NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN,
1189                                 &r);
1190
1191         if (!NT_STATUS_IS_OK(status)) {
1192                 return status;
1193         }
1194
1195         if (DEBUGLEVEL >= 10) {
1196                 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, &r);
1197         }
1198
1199         if (NT_STATUS_IS_ERR(status)) {
1200                 return status;
1201         }
1202
1203         /* Return variables */
1204
1205         /* Return result */
1206         return r.out.result;
1207 }
1208
1209 NTSTATUS rpccli_lsa_OpenSecret(struct rpc_pipe_client *cli,
1210                                TALLOC_CTX *mem_ctx,
1211                                struct policy_handle *handle /* [in] [ref] */,
1212                                struct lsa_String name /* [in]  */,
1213                                uint32_t access_mask /* [in]  */,
1214                                struct policy_handle *sec_handle /* [out] [ref] */)
1215 {
1216         struct lsa_OpenSecret r;
1217         NTSTATUS status;
1218
1219         /* In parameters */
1220         r.in.handle = handle;
1221         r.in.name = name;
1222         r.in.access_mask = access_mask;
1223
1224         if (DEBUGLEVEL >= 10) {
1225                 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, &r);
1226         }
1227
1228         status = cli_do_rpc_ndr(cli,
1229                                 mem_ctx,
1230                                 PI_LSARPC,
1231                                 &ndr_table_lsarpc,
1232                                 NDR_LSA_OPENSECRET,
1233                                 &r);
1234
1235         if (!NT_STATUS_IS_OK(status)) {
1236                 return status;
1237         }
1238
1239         if (DEBUGLEVEL >= 10) {
1240                 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, &r);
1241         }
1242
1243         if (NT_STATUS_IS_ERR(status)) {
1244                 return status;
1245         }
1246
1247         /* Return variables */
1248         *sec_handle = *r.out.sec_handle;
1249
1250         /* Return result */
1251         return r.out.result;
1252 }
1253
1254 NTSTATUS rpccli_lsa_SetSecret(struct rpc_pipe_client *cli,
1255                               TALLOC_CTX *mem_ctx,
1256                               struct policy_handle *sec_handle /* [in] [ref] */,
1257                               struct lsa_DATA_BUF *new_val /* [in] [unique] */,
1258                               struct lsa_DATA_BUF *old_val /* [in] [unique] */)
1259 {
1260         struct lsa_SetSecret r;
1261         NTSTATUS status;
1262
1263         /* In parameters */
1264         r.in.sec_handle = sec_handle;
1265         r.in.new_val = new_val;
1266         r.in.old_val = old_val;
1267
1268         if (DEBUGLEVEL >= 10) {
1269                 NDR_PRINT_IN_DEBUG(lsa_SetSecret, &r);
1270         }
1271
1272         status = cli_do_rpc_ndr(cli,
1273                                 mem_ctx,
1274                                 PI_LSARPC,
1275                                 &ndr_table_lsarpc,
1276                                 NDR_LSA_SETSECRET,
1277                                 &r);
1278
1279         if (!NT_STATUS_IS_OK(status)) {
1280                 return status;
1281         }
1282
1283         if (DEBUGLEVEL >= 10) {
1284                 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, &r);
1285         }
1286
1287         if (NT_STATUS_IS_ERR(status)) {
1288                 return status;
1289         }
1290
1291         /* Return variables */
1292
1293         /* Return result */
1294         return r.out.result;
1295 }
1296
1297 NTSTATUS rpccli_lsa_QuerySecret(struct rpc_pipe_client *cli,
1298                                 TALLOC_CTX *mem_ctx,
1299                                 struct policy_handle *sec_handle /* [in] [ref] */,
1300                                 struct lsa_DATA_BUF_PTR *new_val /* [in,out] [unique] */,
1301                                 NTTIME *new_mtime /* [in,out] [unique] */,
1302                                 struct lsa_DATA_BUF_PTR *old_val /* [in,out] [unique] */,
1303                                 NTTIME *old_mtime /* [in,out] [unique] */)
1304 {
1305         struct lsa_QuerySecret r;
1306         NTSTATUS status;
1307
1308         /* In parameters */
1309         r.in.sec_handle = sec_handle;
1310         r.in.new_val = new_val;
1311         r.in.new_mtime = new_mtime;
1312         r.in.old_val = old_val;
1313         r.in.old_mtime = old_mtime;
1314
1315         if (DEBUGLEVEL >= 10) {
1316                 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, &r);
1317         }
1318
1319         status = cli_do_rpc_ndr(cli,
1320                                 mem_ctx,
1321                                 PI_LSARPC,
1322                                 &ndr_table_lsarpc,
1323                                 NDR_LSA_QUERYSECRET,
1324                                 &r);
1325
1326         if (!NT_STATUS_IS_OK(status)) {
1327                 return status;
1328         }
1329
1330         if (DEBUGLEVEL >= 10) {
1331                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, &r);
1332         }
1333
1334         if (NT_STATUS_IS_ERR(status)) {
1335                 return status;
1336         }
1337
1338         /* Return variables */
1339         if (new_val && r.out.new_val) {
1340                 *new_val = *r.out.new_val;
1341         }
1342         if (new_mtime && r.out.new_mtime) {
1343                 *new_mtime = *r.out.new_mtime;
1344         }
1345         if (old_val && r.out.old_val) {
1346                 *old_val = *r.out.old_val;
1347         }
1348         if (old_mtime && r.out.old_mtime) {
1349                 *old_mtime = *r.out.old_mtime;
1350         }
1351
1352         /* Return result */
1353         return r.out.result;
1354 }
1355
1356 NTSTATUS rpccli_lsa_LookupPrivValue(struct rpc_pipe_client *cli,
1357                                     TALLOC_CTX *mem_ctx,
1358                                     struct policy_handle *handle /* [in] [ref] */,
1359                                     struct lsa_String *name /* [in] [ref] */,
1360                                     struct lsa_LUID *luid /* [out] [ref] */)
1361 {
1362         struct lsa_LookupPrivValue r;
1363         NTSTATUS status;
1364
1365         /* In parameters */
1366         r.in.handle = handle;
1367         r.in.name = name;
1368
1369         if (DEBUGLEVEL >= 10) {
1370                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, &r);
1371         }
1372
1373         status = cli_do_rpc_ndr(cli,
1374                                 mem_ctx,
1375                                 PI_LSARPC,
1376                                 &ndr_table_lsarpc,
1377                                 NDR_LSA_LOOKUPPRIVVALUE,
1378                                 &r);
1379
1380         if (!NT_STATUS_IS_OK(status)) {
1381                 return status;
1382         }
1383
1384         if (DEBUGLEVEL >= 10) {
1385                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, &r);
1386         }
1387
1388         if (NT_STATUS_IS_ERR(status)) {
1389                 return status;
1390         }
1391
1392         /* Return variables */
1393         *luid = *r.out.luid;
1394
1395         /* Return result */
1396         return r.out.result;
1397 }
1398
1399 NTSTATUS rpccli_lsa_LookupPrivName(struct rpc_pipe_client *cli,
1400                                    TALLOC_CTX *mem_ctx,
1401                                    struct policy_handle *handle /* [in] [ref] */,
1402                                    struct lsa_LUID *luid /* [in] [ref] */,
1403                                    struct lsa_StringLarge *name /* [out] [unique] */)
1404 {
1405         struct lsa_LookupPrivName r;
1406         NTSTATUS status;
1407
1408         /* In parameters */
1409         r.in.handle = handle;
1410         r.in.luid = luid;
1411
1412         if (DEBUGLEVEL >= 10) {
1413                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, &r);
1414         }
1415
1416         status = cli_do_rpc_ndr(cli,
1417                                 mem_ctx,
1418                                 PI_LSARPC,
1419                                 &ndr_table_lsarpc,
1420                                 NDR_LSA_LOOKUPPRIVNAME,
1421                                 &r);
1422
1423         if (!NT_STATUS_IS_OK(status)) {
1424                 return status;
1425         }
1426
1427         if (DEBUGLEVEL >= 10) {
1428                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, &r);
1429         }
1430
1431         if (NT_STATUS_IS_ERR(status)) {
1432                 return status;
1433         }
1434
1435         /* Return variables */
1436         if (name && r.out.name) {
1437                 *name = *r.out.name;
1438         }
1439
1440         /* Return result */
1441         return r.out.result;
1442 }
1443
1444 NTSTATUS rpccli_lsa_LookupPrivDisplayName(struct rpc_pipe_client *cli,
1445                                           TALLOC_CTX *mem_ctx,
1446                                           struct policy_handle *handle /* [in] [ref] */,
1447                                           struct lsa_String *name /* [in] [ref] */,
1448                                           uint16_t language_id /* [in]  */,
1449                                           uint16_t language_id_sys /* [in]  */,
1450                                           struct lsa_StringLarge **disp_name /* [out] [ref] */,
1451                                           uint16_t *returned_language_id /* [out] [ref] */)
1452 {
1453         struct lsa_LookupPrivDisplayName r;
1454         NTSTATUS status;
1455
1456         /* In parameters */
1457         r.in.handle = handle;
1458         r.in.name = name;
1459         r.in.language_id = language_id;
1460         r.in.language_id_sys = language_id_sys;
1461
1462         if (DEBUGLEVEL >= 10) {
1463                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, &r);
1464         }
1465
1466         status = cli_do_rpc_ndr(cli,
1467                                 mem_ctx,
1468                                 PI_LSARPC,
1469                                 &ndr_table_lsarpc,
1470                                 NDR_LSA_LOOKUPPRIVDISPLAYNAME,
1471                                 &r);
1472
1473         if (!NT_STATUS_IS_OK(status)) {
1474                 return status;
1475         }
1476
1477         if (DEBUGLEVEL >= 10) {
1478                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, &r);
1479         }
1480
1481         if (NT_STATUS_IS_ERR(status)) {
1482                 return status;
1483         }
1484
1485         /* Return variables */
1486         *disp_name = *r.out.disp_name;
1487         *returned_language_id = *r.out.returned_language_id;
1488
1489         /* Return result */
1490         return r.out.result;
1491 }
1492
1493 NTSTATUS rpccli_lsa_DeleteObject(struct rpc_pipe_client *cli,
1494                                  TALLOC_CTX *mem_ctx,
1495                                  struct policy_handle *handle /* [in,out] [ref] */)
1496 {
1497         struct lsa_DeleteObject r;
1498         NTSTATUS status;
1499
1500         /* In parameters */
1501         r.in.handle = handle;
1502
1503         if (DEBUGLEVEL >= 10) {
1504                 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, &r);
1505         }
1506
1507         status = cli_do_rpc_ndr(cli,
1508                                 mem_ctx,
1509                                 PI_LSARPC,
1510                                 &ndr_table_lsarpc,
1511                                 NDR_LSA_DELETEOBJECT,
1512                                 &r);
1513
1514         if (!NT_STATUS_IS_OK(status)) {
1515                 return status;
1516         }
1517
1518         if (DEBUGLEVEL >= 10) {
1519                 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, &r);
1520         }
1521
1522         if (NT_STATUS_IS_ERR(status)) {
1523                 return status;
1524         }
1525
1526         /* Return variables */
1527         *handle = *r.out.handle;
1528
1529         /* Return result */
1530         return r.out.result;
1531 }
1532
1533 NTSTATUS rpccli_lsa_EnumAccountsWithUserRight(struct rpc_pipe_client *cli,
1534                                               TALLOC_CTX *mem_ctx,
1535                                               struct policy_handle *handle /* [in] [ref] */,
1536                                               struct lsa_String *name /* [in] [unique] */,
1537                                               struct lsa_SidArray *sids /* [out] [ref] */)
1538 {
1539         struct lsa_EnumAccountsWithUserRight r;
1540         NTSTATUS status;
1541
1542         /* In parameters */
1543         r.in.handle = handle;
1544         r.in.name = name;
1545
1546         if (DEBUGLEVEL >= 10) {
1547                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, &r);
1548         }
1549
1550         status = cli_do_rpc_ndr(cli,
1551                                 mem_ctx,
1552                                 PI_LSARPC,
1553                                 &ndr_table_lsarpc,
1554                                 NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT,
1555                                 &r);
1556
1557         if (!NT_STATUS_IS_OK(status)) {
1558                 return status;
1559         }
1560
1561         if (DEBUGLEVEL >= 10) {
1562                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, &r);
1563         }
1564
1565         if (NT_STATUS_IS_ERR(status)) {
1566                 return status;
1567         }
1568
1569         /* Return variables */
1570         *sids = *r.out.sids;
1571
1572         /* Return result */
1573         return r.out.result;
1574 }
1575
1576 NTSTATUS rpccli_lsa_EnumAccountRights(struct rpc_pipe_client *cli,
1577                                       TALLOC_CTX *mem_ctx,
1578                                       struct policy_handle *handle /* [in] [ref] */,
1579                                       struct dom_sid2 *sid /* [in] [ref] */,
1580                                       struct lsa_RightSet *rights /* [out] [ref] */)
1581 {
1582         struct lsa_EnumAccountRights r;
1583         NTSTATUS status;
1584
1585         /* In parameters */
1586         r.in.handle = handle;
1587         r.in.sid = sid;
1588
1589         if (DEBUGLEVEL >= 10) {
1590                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, &r);
1591         }
1592
1593         status = cli_do_rpc_ndr(cli,
1594                                 mem_ctx,
1595                                 PI_LSARPC,
1596                                 &ndr_table_lsarpc,
1597                                 NDR_LSA_ENUMACCOUNTRIGHTS,
1598                                 &r);
1599
1600         if (!NT_STATUS_IS_OK(status)) {
1601                 return status;
1602         }
1603
1604         if (DEBUGLEVEL >= 10) {
1605                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, &r);
1606         }
1607
1608         if (NT_STATUS_IS_ERR(status)) {
1609                 return status;
1610         }
1611
1612         /* Return variables */
1613         *rights = *r.out.rights;
1614
1615         /* Return result */
1616         return r.out.result;
1617 }
1618
1619 NTSTATUS rpccli_lsa_AddAccountRights(struct rpc_pipe_client *cli,
1620                                      TALLOC_CTX *mem_ctx,
1621                                      struct policy_handle *handle /* [in] [ref] */,
1622                                      struct dom_sid2 *sid /* [in] [ref] */,
1623                                      struct lsa_RightSet *rights /* [in] [ref] */)
1624 {
1625         struct lsa_AddAccountRights r;
1626         NTSTATUS status;
1627
1628         /* In parameters */
1629         r.in.handle = handle;
1630         r.in.sid = sid;
1631         r.in.rights = rights;
1632
1633         if (DEBUGLEVEL >= 10) {
1634                 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, &r);
1635         }
1636
1637         status = cli_do_rpc_ndr(cli,
1638                                 mem_ctx,
1639                                 PI_LSARPC,
1640                                 &ndr_table_lsarpc,
1641                                 NDR_LSA_ADDACCOUNTRIGHTS,
1642                                 &r);
1643
1644         if (!NT_STATUS_IS_OK(status)) {
1645                 return status;
1646         }
1647
1648         if (DEBUGLEVEL >= 10) {
1649                 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, &r);
1650         }
1651
1652         if (NT_STATUS_IS_ERR(status)) {
1653                 return status;
1654         }
1655
1656         /* Return variables */
1657
1658         /* Return result */
1659         return r.out.result;
1660 }
1661
1662 NTSTATUS rpccli_lsa_RemoveAccountRights(struct rpc_pipe_client *cli,
1663                                         TALLOC_CTX *mem_ctx,
1664                                         struct policy_handle *handle /* [in] [ref] */,
1665                                         struct dom_sid2 *sid /* [in] [ref] */,
1666                                         uint8_t remove_all /* [in]  */,
1667                                         struct lsa_RightSet *rights /* [in] [ref] */)
1668 {
1669         struct lsa_RemoveAccountRights r;
1670         NTSTATUS status;
1671
1672         /* In parameters */
1673         r.in.handle = handle;
1674         r.in.sid = sid;
1675         r.in.remove_all = remove_all;
1676         r.in.rights = rights;
1677
1678         if (DEBUGLEVEL >= 10) {
1679                 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, &r);
1680         }
1681
1682         status = cli_do_rpc_ndr(cli,
1683                                 mem_ctx,
1684                                 PI_LSARPC,
1685                                 &ndr_table_lsarpc,
1686                                 NDR_LSA_REMOVEACCOUNTRIGHTS,
1687                                 &r);
1688
1689         if (!NT_STATUS_IS_OK(status)) {
1690                 return status;
1691         }
1692
1693         if (DEBUGLEVEL >= 10) {
1694                 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, &r);
1695         }
1696
1697         if (NT_STATUS_IS_ERR(status)) {
1698                 return status;
1699         }
1700
1701         /* Return variables */
1702
1703         /* Return result */
1704         return r.out.result;
1705 }
1706
1707 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoBySid(struct rpc_pipe_client *cli,
1708                                                 TALLOC_CTX *mem_ctx,
1709                                                 struct policy_handle *handle /* [in] [ref] */,
1710                                                 struct dom_sid2 *dom_sid /* [in] [ref] */,
1711                                                 enum lsa_TrustDomInfoEnum level /* [in]  */,
1712                                                 union lsa_TrustedDomainInfo **info /* [out] [ref,switch_is(level)] */)
1713 {
1714         struct lsa_QueryTrustedDomainInfoBySid r;
1715         NTSTATUS status;
1716
1717         /* In parameters */
1718         r.in.handle = handle;
1719         r.in.dom_sid = dom_sid;
1720         r.in.level = level;
1721
1722         if (DEBUGLEVEL >= 10) {
1723                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, &r);
1724         }
1725
1726         status = cli_do_rpc_ndr(cli,
1727                                 mem_ctx,
1728                                 PI_LSARPC,
1729                                 &ndr_table_lsarpc,
1730                                 NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID,
1731                                 &r);
1732
1733         if (!NT_STATUS_IS_OK(status)) {
1734                 return status;
1735         }
1736
1737         if (DEBUGLEVEL >= 10) {
1738                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, &r);
1739         }
1740
1741         if (NT_STATUS_IS_ERR(status)) {
1742                 return status;
1743         }
1744
1745         /* Return variables */
1746         *info = *r.out.info;
1747
1748         /* Return result */
1749         return r.out.result;
1750 }
1751
1752 NTSTATUS rpccli_lsa_SetTrustedDomainInfo(struct rpc_pipe_client *cli,
1753                                          TALLOC_CTX *mem_ctx)
1754 {
1755         struct lsa_SetTrustedDomainInfo r;
1756         NTSTATUS status;
1757
1758         /* In parameters */
1759
1760         if (DEBUGLEVEL >= 10) {
1761                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, &r);
1762         }
1763
1764         status = cli_do_rpc_ndr(cli,
1765                                 mem_ctx,
1766                                 PI_LSARPC,
1767                                 &ndr_table_lsarpc,
1768                                 NDR_LSA_SETTRUSTEDDOMAININFO,
1769                                 &r);
1770
1771         if (!NT_STATUS_IS_OK(status)) {
1772                 return status;
1773         }
1774
1775         if (DEBUGLEVEL >= 10) {
1776                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, &r);
1777         }
1778
1779         if (NT_STATUS_IS_ERR(status)) {
1780                 return status;
1781         }
1782
1783         /* Return variables */
1784
1785         /* Return result */
1786         return r.out.result;
1787 }
1788
1789 NTSTATUS rpccli_lsa_DeleteTrustedDomain(struct rpc_pipe_client *cli,
1790                                         TALLOC_CTX *mem_ctx,
1791                                         struct policy_handle *handle /* [in] [ref] */,
1792                                         struct dom_sid2 *dom_sid /* [in] [ref] */)
1793 {
1794         struct lsa_DeleteTrustedDomain r;
1795         NTSTATUS status;
1796
1797         /* In parameters */
1798         r.in.handle = handle;
1799         r.in.dom_sid = dom_sid;
1800
1801         if (DEBUGLEVEL >= 10) {
1802                 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, &r);
1803         }
1804
1805         status = cli_do_rpc_ndr(cli,
1806                                 mem_ctx,
1807                                 PI_LSARPC,
1808                                 &ndr_table_lsarpc,
1809                                 NDR_LSA_DELETETRUSTEDDOMAIN,
1810                                 &r);
1811
1812         if (!NT_STATUS_IS_OK(status)) {
1813                 return status;
1814         }
1815
1816         if (DEBUGLEVEL >= 10) {
1817                 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, &r);
1818         }
1819
1820         if (NT_STATUS_IS_ERR(status)) {
1821                 return status;
1822         }
1823
1824         /* Return variables */
1825
1826         /* Return result */
1827         return r.out.result;
1828 }
1829
1830 NTSTATUS rpccli_lsa_StorePrivateData(struct rpc_pipe_client *cli,
1831                                      TALLOC_CTX *mem_ctx)
1832 {
1833         struct lsa_StorePrivateData r;
1834         NTSTATUS status;
1835
1836         /* In parameters */
1837
1838         if (DEBUGLEVEL >= 10) {
1839                 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, &r);
1840         }
1841
1842         status = cli_do_rpc_ndr(cli,
1843                                 mem_ctx,
1844                                 PI_LSARPC,
1845                                 &ndr_table_lsarpc,
1846                                 NDR_LSA_STOREPRIVATEDATA,
1847                                 &r);
1848
1849         if (!NT_STATUS_IS_OK(status)) {
1850                 return status;
1851         }
1852
1853         if (DEBUGLEVEL >= 10) {
1854                 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, &r);
1855         }
1856
1857         if (NT_STATUS_IS_ERR(status)) {
1858                 return status;
1859         }
1860
1861         /* Return variables */
1862
1863         /* Return result */
1864         return r.out.result;
1865 }
1866
1867 NTSTATUS rpccli_lsa_RetrievePrivateData(struct rpc_pipe_client *cli,
1868                                         TALLOC_CTX *mem_ctx)
1869 {
1870         struct lsa_RetrievePrivateData r;
1871         NTSTATUS status;
1872
1873         /* In parameters */
1874
1875         if (DEBUGLEVEL >= 10) {
1876                 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, &r);
1877         }
1878
1879         status = cli_do_rpc_ndr(cli,
1880                                 mem_ctx,
1881                                 PI_LSARPC,
1882                                 &ndr_table_lsarpc,
1883                                 NDR_LSA_RETRIEVEPRIVATEDATA,
1884                                 &r);
1885
1886         if (!NT_STATUS_IS_OK(status)) {
1887                 return status;
1888         }
1889
1890         if (DEBUGLEVEL >= 10) {
1891                 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, &r);
1892         }
1893
1894         if (NT_STATUS_IS_ERR(status)) {
1895                 return status;
1896         }
1897
1898         /* Return variables */
1899
1900         /* Return result */
1901         return r.out.result;
1902 }
1903
1904 NTSTATUS rpccli_lsa_OpenPolicy2(struct rpc_pipe_client *cli,
1905                                 TALLOC_CTX *mem_ctx,
1906                                 const char *system_name /* [in] [unique,charset(UTF16)] */,
1907                                 struct lsa_ObjectAttribute *attr /* [in] [ref] */,
1908                                 uint32_t access_mask /* [in]  */,
1909                                 struct policy_handle *handle /* [out] [ref] */)
1910 {
1911         struct lsa_OpenPolicy2 r;
1912         NTSTATUS status;
1913
1914         /* In parameters */
1915         r.in.system_name = system_name;
1916         r.in.attr = attr;
1917         r.in.access_mask = access_mask;
1918
1919         if (DEBUGLEVEL >= 10) {
1920                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, &r);
1921         }
1922
1923         status = cli_do_rpc_ndr(cli,
1924                                 mem_ctx,
1925                                 PI_LSARPC,
1926                                 &ndr_table_lsarpc,
1927                                 NDR_LSA_OPENPOLICY2,
1928                                 &r);
1929
1930         if (!NT_STATUS_IS_OK(status)) {
1931                 return status;
1932         }
1933
1934         if (DEBUGLEVEL >= 10) {
1935                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, &r);
1936         }
1937
1938         if (NT_STATUS_IS_ERR(status)) {
1939                 return status;
1940         }
1941
1942         /* Return variables */
1943         *handle = *r.out.handle;
1944
1945         /* Return result */
1946         return r.out.result;
1947 }
1948
1949 NTSTATUS rpccli_lsa_GetUserName(struct rpc_pipe_client *cli,
1950                                 TALLOC_CTX *mem_ctx,
1951                                 const char *system_name /* [in] [unique,charset(UTF16)] */,
1952                                 struct lsa_String **account_name /* [in,out] [ref] */,
1953                                 struct lsa_String **authority_name /* [in,out] [unique] */)
1954 {
1955         struct lsa_GetUserName r;
1956         NTSTATUS status;
1957
1958         /* In parameters */
1959         r.in.system_name = system_name;
1960         r.in.account_name = account_name;
1961         r.in.authority_name = authority_name;
1962
1963         if (DEBUGLEVEL >= 10) {
1964                 NDR_PRINT_IN_DEBUG(lsa_GetUserName, &r);
1965         }
1966
1967         status = cli_do_rpc_ndr(cli,
1968                                 mem_ctx,
1969                                 PI_LSARPC,
1970                                 &ndr_table_lsarpc,
1971                                 NDR_LSA_GETUSERNAME,
1972                                 &r);
1973
1974         if (!NT_STATUS_IS_OK(status)) {
1975                 return status;
1976         }
1977
1978         if (DEBUGLEVEL >= 10) {
1979                 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, &r);
1980         }
1981
1982         if (NT_STATUS_IS_ERR(status)) {
1983                 return status;
1984         }
1985
1986         /* Return variables */
1987         *account_name = *r.out.account_name;
1988         if (authority_name && r.out.authority_name) {
1989                 *authority_name = *r.out.authority_name;
1990         }
1991
1992         /* Return result */
1993         return r.out.result;
1994 }
1995
1996 NTSTATUS rpccli_lsa_QueryInfoPolicy2(struct rpc_pipe_client *cli,
1997                                      TALLOC_CTX *mem_ctx,
1998                                      struct policy_handle *handle /* [in] [ref] */,
1999                                      enum lsa_PolicyInfo level /* [in]  */,
2000                                      union lsa_PolicyInformation **info /* [out] [ref,switch_is(level)] */)
2001 {
2002         struct lsa_QueryInfoPolicy2 r;
2003         NTSTATUS status;
2004
2005         /* In parameters */
2006         r.in.handle = handle;
2007         r.in.level = level;
2008
2009         if (DEBUGLEVEL >= 10) {
2010                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, &r);
2011         }
2012
2013         status = cli_do_rpc_ndr(cli,
2014                                 mem_ctx,
2015                                 PI_LSARPC,
2016                                 &ndr_table_lsarpc,
2017                                 NDR_LSA_QUERYINFOPOLICY2,
2018                                 &r);
2019
2020         if (!NT_STATUS_IS_OK(status)) {
2021                 return status;
2022         }
2023
2024         if (DEBUGLEVEL >= 10) {
2025                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, &r);
2026         }
2027
2028         if (NT_STATUS_IS_ERR(status)) {
2029                 return status;
2030         }
2031
2032         /* Return variables */
2033         *info = *r.out.info;
2034
2035         /* Return result */
2036         return r.out.result;
2037 }
2038
2039 NTSTATUS rpccli_lsa_SetInfoPolicy2(struct rpc_pipe_client *cli,
2040                                    TALLOC_CTX *mem_ctx,
2041                                    struct policy_handle *handle /* [in] [ref] */,
2042                                    enum lsa_PolicyInfo level /* [in]  */,
2043                                    union lsa_PolicyInformation *info /* [in] [ref,switch_is(level)] */)
2044 {
2045         struct lsa_SetInfoPolicy2 r;
2046         NTSTATUS status;
2047
2048         /* In parameters */
2049         r.in.handle = handle;
2050         r.in.level = level;
2051         r.in.info = info;
2052
2053         if (DEBUGLEVEL >= 10) {
2054                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, &r);
2055         }
2056
2057         status = cli_do_rpc_ndr(cli,
2058                                 mem_ctx,
2059                                 PI_LSARPC,
2060                                 &ndr_table_lsarpc,
2061                                 NDR_LSA_SETINFOPOLICY2,
2062                                 &r);
2063
2064         if (!NT_STATUS_IS_OK(status)) {
2065                 return status;
2066         }
2067
2068         if (DEBUGLEVEL >= 10) {
2069                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, &r);
2070         }
2071
2072         if (NT_STATUS_IS_ERR(status)) {
2073                 return status;
2074         }
2075
2076         /* Return variables */
2077
2078         /* Return result */
2079         return r.out.result;
2080 }
2081
2082 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoByName(struct rpc_pipe_client *cli,
2083                                                  TALLOC_CTX *mem_ctx,
2084                                                  struct policy_handle *handle /* [in] [ref] */,
2085                                                  struct lsa_String *trusted_domain /* [in] [ref] */,
2086                                                  enum lsa_TrustDomInfoEnum level /* [in]  */,
2087                                                  union lsa_TrustedDomainInfo **info /* [out] [ref,switch_is(level)] */)
2088 {
2089         struct lsa_QueryTrustedDomainInfoByName r;
2090         NTSTATUS status;
2091
2092         /* In parameters */
2093         r.in.handle = handle;
2094         r.in.trusted_domain = trusted_domain;
2095         r.in.level = level;
2096
2097         if (DEBUGLEVEL >= 10) {
2098                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, &r);
2099         }
2100
2101         status = cli_do_rpc_ndr(cli,
2102                                 mem_ctx,
2103                                 PI_LSARPC,
2104                                 &ndr_table_lsarpc,
2105                                 NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME,
2106                                 &r);
2107
2108         if (!NT_STATUS_IS_OK(status)) {
2109                 return status;
2110         }
2111
2112         if (DEBUGLEVEL >= 10) {
2113                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, &r);
2114         }
2115
2116         if (NT_STATUS_IS_ERR(status)) {
2117                 return status;
2118         }
2119
2120         /* Return variables */
2121         *info = *r.out.info;
2122
2123         /* Return result */
2124         return r.out.result;
2125 }
2126
2127 NTSTATUS rpccli_lsa_SetTrustedDomainInfoByName(struct rpc_pipe_client *cli,
2128                                                TALLOC_CTX *mem_ctx,
2129                                                struct policy_handle *handle /* [in] [ref] */,
2130                                                struct lsa_String trusted_domain /* [in]  */,
2131                                                enum lsa_TrustDomInfoEnum level /* [in]  */,
2132                                                union lsa_TrustedDomainInfo *info /* [in] [unique,switch_is(level)] */)
2133 {
2134         struct lsa_SetTrustedDomainInfoByName r;
2135         NTSTATUS status;
2136
2137         /* In parameters */
2138         r.in.handle = handle;
2139         r.in.trusted_domain = trusted_domain;
2140         r.in.level = level;
2141         r.in.info = info;
2142
2143         if (DEBUGLEVEL >= 10) {
2144                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, &r);
2145         }
2146
2147         status = cli_do_rpc_ndr(cli,
2148                                 mem_ctx,
2149                                 PI_LSARPC,
2150                                 &ndr_table_lsarpc,
2151                                 NDR_LSA_SETTRUSTEDDOMAININFOBYNAME,
2152                                 &r);
2153
2154         if (!NT_STATUS_IS_OK(status)) {
2155                 return status;
2156         }
2157
2158         if (DEBUGLEVEL >= 10) {
2159                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, &r);
2160         }
2161
2162         if (NT_STATUS_IS_ERR(status)) {
2163                 return status;
2164         }
2165
2166         /* Return variables */
2167
2168         /* Return result */
2169         return r.out.result;
2170 }
2171
2172 NTSTATUS rpccli_lsa_EnumTrustedDomainsEx(struct rpc_pipe_client *cli,
2173                                          TALLOC_CTX *mem_ctx,
2174                                          struct policy_handle *handle /* [in] [ref] */,
2175                                          uint32_t *resume_handle /* [in,out] [ref] */,
2176                                          struct lsa_DomainListEx *domains /* [out] [ref] */,
2177                                          uint32_t max_size /* [in]  */)
2178 {
2179         struct lsa_EnumTrustedDomainsEx r;
2180         NTSTATUS status;
2181
2182         /* In parameters */
2183         r.in.handle = handle;
2184         r.in.resume_handle = resume_handle;
2185         r.in.max_size = max_size;
2186
2187         if (DEBUGLEVEL >= 10) {
2188                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, &r);
2189         }
2190
2191         status = cli_do_rpc_ndr(cli,
2192                                 mem_ctx,
2193                                 PI_LSARPC,
2194                                 &ndr_table_lsarpc,
2195                                 NDR_LSA_ENUMTRUSTEDDOMAINSEX,
2196                                 &r);
2197
2198         if (!NT_STATUS_IS_OK(status)) {
2199                 return status;
2200         }
2201
2202         if (DEBUGLEVEL >= 10) {
2203                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, &r);
2204         }
2205
2206         if (NT_STATUS_IS_ERR(status)) {
2207                 return status;
2208         }
2209
2210         /* Return variables */
2211         *resume_handle = *r.out.resume_handle;
2212         *domains = *r.out.domains;
2213
2214         /* Return result */
2215         return r.out.result;
2216 }
2217
2218 NTSTATUS rpccli_lsa_CreateTrustedDomainEx(struct rpc_pipe_client *cli,
2219                                           TALLOC_CTX *mem_ctx)
2220 {
2221         struct lsa_CreateTrustedDomainEx r;
2222         NTSTATUS status;
2223
2224         /* In parameters */
2225
2226         if (DEBUGLEVEL >= 10) {
2227                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, &r);
2228         }
2229
2230         status = cli_do_rpc_ndr(cli,
2231                                 mem_ctx,
2232                                 PI_LSARPC,
2233                                 &ndr_table_lsarpc,
2234                                 NDR_LSA_CREATETRUSTEDDOMAINEX,
2235                                 &r);
2236
2237         if (!NT_STATUS_IS_OK(status)) {
2238                 return status;
2239         }
2240
2241         if (DEBUGLEVEL >= 10) {
2242                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, &r);
2243         }
2244
2245         if (NT_STATUS_IS_ERR(status)) {
2246                 return status;
2247         }
2248
2249         /* Return variables */
2250
2251         /* Return result */
2252         return r.out.result;
2253 }
2254
2255 NTSTATUS rpccli_lsa_CloseTrustedDomainEx(struct rpc_pipe_client *cli,
2256                                          TALLOC_CTX *mem_ctx,
2257                                          struct policy_handle *handle /* [in,out] [ref] */)
2258 {
2259         struct lsa_CloseTrustedDomainEx r;
2260         NTSTATUS status;
2261
2262         /* In parameters */
2263         r.in.handle = handle;
2264
2265         if (DEBUGLEVEL >= 10) {
2266                 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, &r);
2267         }
2268
2269         status = cli_do_rpc_ndr(cli,
2270                                 mem_ctx,
2271                                 PI_LSARPC,
2272                                 &ndr_table_lsarpc,
2273                                 NDR_LSA_CLOSETRUSTEDDOMAINEX,
2274                                 &r);
2275
2276         if (!NT_STATUS_IS_OK(status)) {
2277                 return status;
2278         }
2279
2280         if (DEBUGLEVEL >= 10) {
2281                 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, &r);
2282         }
2283
2284         if (NT_STATUS_IS_ERR(status)) {
2285                 return status;
2286         }
2287
2288         /* Return variables */
2289         *handle = *r.out.handle;
2290
2291         /* Return result */
2292         return r.out.result;
2293 }
2294
2295 NTSTATUS rpccli_lsa_QueryDomainInformationPolicy(struct rpc_pipe_client *cli,
2296                                                  TALLOC_CTX *mem_ctx,
2297                                                  struct policy_handle *handle /* [in] [ref] */,
2298                                                  uint16_t level /* [in]  */,
2299                                                  union lsa_DomainInformationPolicy **info /* [out] [ref,switch_is(level)] */)
2300 {
2301         struct lsa_QueryDomainInformationPolicy r;
2302         NTSTATUS status;
2303
2304         /* In parameters */
2305         r.in.handle = handle;
2306         r.in.level = level;
2307
2308         if (DEBUGLEVEL >= 10) {
2309                 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, &r);
2310         }
2311
2312         status = cli_do_rpc_ndr(cli,
2313                                 mem_ctx,
2314                                 PI_LSARPC,
2315                                 &ndr_table_lsarpc,
2316                                 NDR_LSA_QUERYDOMAININFORMATIONPOLICY,
2317                                 &r);
2318
2319         if (!NT_STATUS_IS_OK(status)) {
2320                 return status;
2321         }
2322
2323         if (DEBUGLEVEL >= 10) {
2324                 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, &r);
2325         }
2326
2327         if (NT_STATUS_IS_ERR(status)) {
2328                 return status;
2329         }
2330
2331         /* Return variables */
2332         *info = *r.out.info;
2333
2334         /* Return result */
2335         return r.out.result;
2336 }
2337
2338 NTSTATUS rpccli_lsa_SetDomainInformationPolicy(struct rpc_pipe_client *cli,
2339                                                TALLOC_CTX *mem_ctx,
2340                                                struct policy_handle *handle /* [in] [ref] */,
2341                                                uint16_t level /* [in]  */,
2342                                                union lsa_DomainInformationPolicy *info /* [in] [unique,switch_is(level)] */)
2343 {
2344         struct lsa_SetDomainInformationPolicy r;
2345         NTSTATUS status;
2346
2347         /* In parameters */
2348         r.in.handle = handle;
2349         r.in.level = level;
2350         r.in.info = info;
2351
2352         if (DEBUGLEVEL >= 10) {
2353                 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, &r);
2354         }
2355
2356         status = cli_do_rpc_ndr(cli,
2357                                 mem_ctx,
2358                                 PI_LSARPC,
2359                                 &ndr_table_lsarpc,
2360                                 NDR_LSA_SETDOMAININFORMATIONPOLICY,
2361                                 &r);
2362
2363         if (!NT_STATUS_IS_OK(status)) {
2364                 return status;
2365         }
2366
2367         if (DEBUGLEVEL >= 10) {
2368                 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, &r);
2369         }
2370
2371         if (NT_STATUS_IS_ERR(status)) {
2372                 return status;
2373         }
2374
2375         /* Return variables */
2376
2377         /* Return result */
2378         return r.out.result;
2379 }
2380
2381 NTSTATUS rpccli_lsa_OpenTrustedDomainByName(struct rpc_pipe_client *cli,
2382                                             TALLOC_CTX *mem_ctx,
2383                                             struct policy_handle *handle /* [in] [ref] */,
2384                                             struct lsa_String name /* [in]  */,
2385                                             uint32_t access_mask /* [in]  */,
2386                                             struct policy_handle *trustdom_handle /* [out] [ref] */)
2387 {
2388         struct lsa_OpenTrustedDomainByName r;
2389         NTSTATUS status;
2390
2391         /* In parameters */
2392         r.in.handle = handle;
2393         r.in.name = name;
2394         r.in.access_mask = access_mask;
2395
2396         if (DEBUGLEVEL >= 10) {
2397                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, &r);
2398         }
2399
2400         status = cli_do_rpc_ndr(cli,
2401                                 mem_ctx,
2402                                 PI_LSARPC,
2403                                 &ndr_table_lsarpc,
2404                                 NDR_LSA_OPENTRUSTEDDOMAINBYNAME,
2405                                 &r);
2406
2407         if (!NT_STATUS_IS_OK(status)) {
2408                 return status;
2409         }
2410
2411         if (DEBUGLEVEL >= 10) {
2412                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, &r);
2413         }
2414
2415         if (NT_STATUS_IS_ERR(status)) {
2416                 return status;
2417         }
2418
2419         /* Return variables */
2420         *trustdom_handle = *r.out.trustdom_handle;
2421
2422         /* Return result */
2423         return r.out.result;
2424 }
2425
2426 NTSTATUS rpccli_lsa_TestCall(struct rpc_pipe_client *cli,
2427                              TALLOC_CTX *mem_ctx)
2428 {
2429         struct lsa_TestCall r;
2430         NTSTATUS status;
2431
2432         /* In parameters */
2433
2434         if (DEBUGLEVEL >= 10) {
2435                 NDR_PRINT_IN_DEBUG(lsa_TestCall, &r);
2436         }
2437
2438         status = cli_do_rpc_ndr(cli,
2439                                 mem_ctx,
2440                                 PI_LSARPC,
2441                                 &ndr_table_lsarpc,
2442                                 NDR_LSA_TESTCALL,
2443                                 &r);
2444
2445         if (!NT_STATUS_IS_OK(status)) {
2446                 return status;
2447         }
2448
2449         if (DEBUGLEVEL >= 10) {
2450                 NDR_PRINT_OUT_DEBUG(lsa_TestCall, &r);
2451         }
2452
2453         if (NT_STATUS_IS_ERR(status)) {
2454                 return status;
2455         }
2456
2457         /* Return variables */
2458
2459         /* Return result */
2460         return r.out.result;
2461 }
2462
2463 NTSTATUS rpccli_lsa_LookupSids2(struct rpc_pipe_client *cli,
2464                                 TALLOC_CTX *mem_ctx,
2465                                 struct policy_handle *handle /* [in] [ref] */,
2466                                 struct lsa_SidArray *sids /* [in] [ref] */,
2467                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
2468                                 struct lsa_TransNameArray2 *names /* [in,out] [ref] */,
2469                                 uint16_t level /* [in]  */,
2470                                 uint32_t *count /* [in,out] [ref] */,
2471                                 uint32_t unknown1 /* [in]  */,
2472                                 uint32_t unknown2 /* [in]  */)
2473 {
2474         struct lsa_LookupSids2 r;
2475         NTSTATUS status;
2476
2477         /* In parameters */
2478         r.in.handle = handle;
2479         r.in.sids = sids;
2480         r.in.names = names;
2481         r.in.level = level;
2482         r.in.count = count;
2483         r.in.unknown1 = unknown1;
2484         r.in.unknown2 = unknown2;
2485
2486         if (DEBUGLEVEL >= 10) {
2487                 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, &r);
2488         }
2489
2490         status = cli_do_rpc_ndr(cli,
2491                                 mem_ctx,
2492                                 PI_LSARPC,
2493                                 &ndr_table_lsarpc,
2494                                 NDR_LSA_LOOKUPSIDS2,
2495                                 &r);
2496
2497         if (!NT_STATUS_IS_OK(status)) {
2498                 return status;
2499         }
2500
2501         if (DEBUGLEVEL >= 10) {
2502                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, &r);
2503         }
2504
2505         if (NT_STATUS_IS_ERR(status)) {
2506                 return status;
2507         }
2508
2509         /* Return variables */
2510         *domains = *r.out.domains;
2511         *names = *r.out.names;
2512         *count = *r.out.count;
2513
2514         /* Return result */
2515         return r.out.result;
2516 }
2517
2518 NTSTATUS rpccli_lsa_LookupNames2(struct rpc_pipe_client *cli,
2519                                  TALLOC_CTX *mem_ctx,
2520                                  struct policy_handle *handle /* [in] [ref] */,
2521                                  uint32_t num_names /* [in] [range(0,1000)] */,
2522                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
2523                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
2524                                  struct lsa_TransSidArray2 *sids /* [in,out] [ref] */,
2525                                  enum lsa_LookupNamesLevel level /* [in]  */,
2526                                  uint32_t *count /* [in,out] [ref] */,
2527                                  uint32_t unknown1 /* [in]  */,
2528                                  uint32_t unknown2 /* [in]  */)
2529 {
2530         struct lsa_LookupNames2 r;
2531         NTSTATUS status;
2532
2533         /* In parameters */
2534         r.in.handle = handle;
2535         r.in.num_names = num_names;
2536         r.in.names = names;
2537         r.in.sids = sids;
2538         r.in.level = level;
2539         r.in.count = count;
2540         r.in.unknown1 = unknown1;
2541         r.in.unknown2 = unknown2;
2542
2543         if (DEBUGLEVEL >= 10) {
2544                 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, &r);
2545         }
2546
2547         status = cli_do_rpc_ndr(cli,
2548                                 mem_ctx,
2549                                 PI_LSARPC,
2550                                 &ndr_table_lsarpc,
2551                                 NDR_LSA_LOOKUPNAMES2,
2552                                 &r);
2553
2554         if (!NT_STATUS_IS_OK(status)) {
2555                 return status;
2556         }
2557
2558         if (DEBUGLEVEL >= 10) {
2559                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, &r);
2560         }
2561
2562         if (NT_STATUS_IS_ERR(status)) {
2563                 return status;
2564         }
2565
2566         /* Return variables */
2567         *domains = *r.out.domains;
2568         *sids = *r.out.sids;
2569         *count = *r.out.count;
2570
2571         /* Return result */
2572         return r.out.result;
2573 }
2574
2575 NTSTATUS rpccli_lsa_CreateTrustedDomainEx2(struct rpc_pipe_client *cli,
2576                                            TALLOC_CTX *mem_ctx)
2577 {
2578         struct lsa_CreateTrustedDomainEx2 r;
2579         NTSTATUS status;
2580
2581         /* In parameters */
2582
2583         if (DEBUGLEVEL >= 10) {
2584                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, &r);
2585         }
2586
2587         status = cli_do_rpc_ndr(cli,
2588                                 mem_ctx,
2589                                 PI_LSARPC,
2590                                 &ndr_table_lsarpc,
2591                                 NDR_LSA_CREATETRUSTEDDOMAINEX2,
2592                                 &r);
2593
2594         if (!NT_STATUS_IS_OK(status)) {
2595                 return status;
2596         }
2597
2598         if (DEBUGLEVEL >= 10) {
2599                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, &r);
2600         }
2601
2602         if (NT_STATUS_IS_ERR(status)) {
2603                 return status;
2604         }
2605
2606         /* Return variables */
2607
2608         /* Return result */
2609         return r.out.result;
2610 }
2611
2612 NTSTATUS rpccli_lsa_CREDRWRITE(struct rpc_pipe_client *cli,
2613                                TALLOC_CTX *mem_ctx)
2614 {
2615         struct lsa_CREDRWRITE r;
2616         NTSTATUS status;
2617
2618         /* In parameters */
2619
2620         if (DEBUGLEVEL >= 10) {
2621                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, &r);
2622         }
2623
2624         status = cli_do_rpc_ndr(cli,
2625                                 mem_ctx,
2626                                 PI_LSARPC,
2627                                 &ndr_table_lsarpc,
2628                                 NDR_LSA_CREDRWRITE,
2629                                 &r);
2630
2631         if (!NT_STATUS_IS_OK(status)) {
2632                 return status;
2633         }
2634
2635         if (DEBUGLEVEL >= 10) {
2636                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, &r);
2637         }
2638
2639         if (NT_STATUS_IS_ERR(status)) {
2640                 return status;
2641         }
2642
2643         /* Return variables */
2644
2645         /* Return result */
2646         return r.out.result;
2647 }
2648
2649 NTSTATUS rpccli_lsa_CREDRREAD(struct rpc_pipe_client *cli,
2650                               TALLOC_CTX *mem_ctx)
2651 {
2652         struct lsa_CREDRREAD r;
2653         NTSTATUS status;
2654
2655         /* In parameters */
2656
2657         if (DEBUGLEVEL >= 10) {
2658                 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, &r);
2659         }
2660
2661         status = cli_do_rpc_ndr(cli,
2662                                 mem_ctx,
2663                                 PI_LSARPC,
2664                                 &ndr_table_lsarpc,
2665                                 NDR_LSA_CREDRREAD,
2666                                 &r);
2667
2668         if (!NT_STATUS_IS_OK(status)) {
2669                 return status;
2670         }
2671
2672         if (DEBUGLEVEL >= 10) {
2673                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, &r);
2674         }
2675
2676         if (NT_STATUS_IS_ERR(status)) {
2677                 return status;
2678         }
2679
2680         /* Return variables */
2681
2682         /* Return result */
2683         return r.out.result;
2684 }
2685
2686 NTSTATUS rpccli_lsa_CREDRENUMERATE(struct rpc_pipe_client *cli,
2687                                    TALLOC_CTX *mem_ctx)
2688 {
2689         struct lsa_CREDRENUMERATE r;
2690         NTSTATUS status;
2691
2692         /* In parameters */
2693
2694         if (DEBUGLEVEL >= 10) {
2695                 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, &r);
2696         }
2697
2698         status = cli_do_rpc_ndr(cli,
2699                                 mem_ctx,
2700                                 PI_LSARPC,
2701                                 &ndr_table_lsarpc,
2702                                 NDR_LSA_CREDRENUMERATE,
2703                                 &r);
2704
2705         if (!NT_STATUS_IS_OK(status)) {
2706                 return status;
2707         }
2708
2709         if (DEBUGLEVEL >= 10) {
2710                 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, &r);
2711         }
2712
2713         if (NT_STATUS_IS_ERR(status)) {
2714                 return status;
2715         }
2716
2717         /* Return variables */
2718
2719         /* Return result */
2720         return r.out.result;
2721 }
2722
2723 NTSTATUS rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS(struct rpc_pipe_client *cli,
2724                                                 TALLOC_CTX *mem_ctx)
2725 {
2726         struct lsa_CREDRWRITEDOMAINCREDENTIALS r;
2727         NTSTATUS status;
2728
2729         /* In parameters */
2730
2731         if (DEBUGLEVEL >= 10) {
2732                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, &r);
2733         }
2734
2735         status = cli_do_rpc_ndr(cli,
2736                                 mem_ctx,
2737                                 PI_LSARPC,
2738                                 &ndr_table_lsarpc,
2739                                 NDR_LSA_CREDRWRITEDOMAINCREDENTIALS,
2740                                 &r);
2741
2742         if (!NT_STATUS_IS_OK(status)) {
2743                 return status;
2744         }
2745
2746         if (DEBUGLEVEL >= 10) {
2747                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, &r);
2748         }
2749
2750         if (NT_STATUS_IS_ERR(status)) {
2751                 return status;
2752         }
2753
2754         /* Return variables */
2755
2756         /* Return result */
2757         return r.out.result;
2758 }
2759
2760 NTSTATUS rpccli_lsa_CREDRREADDOMAINCREDENTIALS(struct rpc_pipe_client *cli,
2761                                                TALLOC_CTX *mem_ctx)
2762 {
2763         struct lsa_CREDRREADDOMAINCREDENTIALS r;
2764         NTSTATUS status;
2765
2766         /* In parameters */
2767
2768         if (DEBUGLEVEL >= 10) {
2769                 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, &r);
2770         }
2771
2772         status = cli_do_rpc_ndr(cli,
2773                                 mem_ctx,
2774                                 PI_LSARPC,
2775                                 &ndr_table_lsarpc,
2776                                 NDR_LSA_CREDRREADDOMAINCREDENTIALS,
2777                                 &r);
2778
2779         if (!NT_STATUS_IS_OK(status)) {
2780                 return status;
2781         }
2782
2783         if (DEBUGLEVEL >= 10) {
2784                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, &r);
2785         }
2786
2787         if (NT_STATUS_IS_ERR(status)) {
2788                 return status;
2789         }
2790
2791         /* Return variables */
2792
2793         /* Return result */
2794         return r.out.result;
2795 }
2796
2797 NTSTATUS rpccli_lsa_CREDRDELETE(struct rpc_pipe_client *cli,
2798                                 TALLOC_CTX *mem_ctx)
2799 {
2800         struct lsa_CREDRDELETE r;
2801         NTSTATUS status;
2802
2803         /* In parameters */
2804
2805         if (DEBUGLEVEL >= 10) {
2806                 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, &r);
2807         }
2808
2809         status = cli_do_rpc_ndr(cli,
2810                                 mem_ctx,
2811                                 PI_LSARPC,
2812                                 &ndr_table_lsarpc,
2813                                 NDR_LSA_CREDRDELETE,
2814                                 &r);
2815
2816         if (!NT_STATUS_IS_OK(status)) {
2817                 return status;
2818         }
2819
2820         if (DEBUGLEVEL >= 10) {
2821                 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, &r);
2822         }
2823
2824         if (NT_STATUS_IS_ERR(status)) {
2825                 return status;
2826         }
2827
2828         /* Return variables */
2829
2830         /* Return result */
2831         return r.out.result;
2832 }
2833
2834 NTSTATUS rpccli_lsa_CREDRGETTARGETINFO(struct rpc_pipe_client *cli,
2835                                        TALLOC_CTX *mem_ctx)
2836 {
2837         struct lsa_CREDRGETTARGETINFO r;
2838         NTSTATUS status;
2839
2840         /* In parameters */
2841
2842         if (DEBUGLEVEL >= 10) {
2843                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, &r);
2844         }
2845
2846         status = cli_do_rpc_ndr(cli,
2847                                 mem_ctx,
2848                                 PI_LSARPC,
2849                                 &ndr_table_lsarpc,
2850                                 NDR_LSA_CREDRGETTARGETINFO,
2851                                 &r);
2852
2853         if (!NT_STATUS_IS_OK(status)) {
2854                 return status;
2855         }
2856
2857         if (DEBUGLEVEL >= 10) {
2858                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, &r);
2859         }
2860
2861         if (NT_STATUS_IS_ERR(status)) {
2862                 return status;
2863         }
2864
2865         /* Return variables */
2866
2867         /* Return result */
2868         return r.out.result;
2869 }
2870
2871 NTSTATUS rpccli_lsa_CREDRPROFILELOADED(struct rpc_pipe_client *cli,
2872                                        TALLOC_CTX *mem_ctx)
2873 {
2874         struct lsa_CREDRPROFILELOADED r;
2875         NTSTATUS status;
2876
2877         /* In parameters */
2878
2879         if (DEBUGLEVEL >= 10) {
2880                 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, &r);
2881         }
2882
2883         status = cli_do_rpc_ndr(cli,
2884                                 mem_ctx,
2885                                 PI_LSARPC,
2886                                 &ndr_table_lsarpc,
2887                                 NDR_LSA_CREDRPROFILELOADED,
2888                                 &r);
2889
2890         if (!NT_STATUS_IS_OK(status)) {
2891                 return status;
2892         }
2893
2894         if (DEBUGLEVEL >= 10) {
2895                 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, &r);
2896         }
2897
2898         if (NT_STATUS_IS_ERR(status)) {
2899                 return status;
2900         }
2901
2902         /* Return variables */
2903
2904         /* Return result */
2905         return r.out.result;
2906 }
2907
2908 NTSTATUS rpccli_lsa_LookupNames3(struct rpc_pipe_client *cli,
2909                                  TALLOC_CTX *mem_ctx,
2910                                  struct policy_handle *handle /* [in] [ref] */,
2911                                  uint32_t num_names /* [in] [range(0,1000)] */,
2912                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
2913                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
2914                                  struct lsa_TransSidArray3 *sids /* [in,out] [ref] */,
2915                                  enum lsa_LookupNamesLevel level /* [in]  */,
2916                                  uint32_t *count /* [in,out] [ref] */,
2917                                  uint32_t unknown1 /* [in]  */,
2918                                  uint32_t unknown2 /* [in]  */)
2919 {
2920         struct lsa_LookupNames3 r;
2921         NTSTATUS status;
2922
2923         /* In parameters */
2924         r.in.handle = handle;
2925         r.in.num_names = num_names;
2926         r.in.names = names;
2927         r.in.sids = sids;
2928         r.in.level = level;
2929         r.in.count = count;
2930         r.in.unknown1 = unknown1;
2931         r.in.unknown2 = unknown2;
2932
2933         if (DEBUGLEVEL >= 10) {
2934                 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, &r);
2935         }
2936
2937         status = cli_do_rpc_ndr(cli,
2938                                 mem_ctx,
2939                                 PI_LSARPC,
2940                                 &ndr_table_lsarpc,
2941                                 NDR_LSA_LOOKUPNAMES3,
2942                                 &r);
2943
2944         if (!NT_STATUS_IS_OK(status)) {
2945                 return status;
2946         }
2947
2948         if (DEBUGLEVEL >= 10) {
2949                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, &r);
2950         }
2951
2952         if (NT_STATUS_IS_ERR(status)) {
2953                 return status;
2954         }
2955
2956         /* Return variables */
2957         *domains = *r.out.domains;
2958         *sids = *r.out.sids;
2959         *count = *r.out.count;
2960
2961         /* Return result */
2962         return r.out.result;
2963 }
2964
2965 NTSTATUS rpccli_lsa_CREDRGETSESSIONTYPES(struct rpc_pipe_client *cli,
2966                                          TALLOC_CTX *mem_ctx)
2967 {
2968         struct lsa_CREDRGETSESSIONTYPES r;
2969         NTSTATUS status;
2970
2971         /* In parameters */
2972
2973         if (DEBUGLEVEL >= 10) {
2974                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, &r);
2975         }
2976
2977         status = cli_do_rpc_ndr(cli,
2978                                 mem_ctx,
2979                                 PI_LSARPC,
2980                                 &ndr_table_lsarpc,
2981                                 NDR_LSA_CREDRGETSESSIONTYPES,
2982                                 &r);
2983
2984         if (!NT_STATUS_IS_OK(status)) {
2985                 return status;
2986         }
2987
2988         if (DEBUGLEVEL >= 10) {
2989                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, &r);
2990         }
2991
2992         if (NT_STATUS_IS_ERR(status)) {
2993                 return status;
2994         }
2995
2996         /* Return variables */
2997
2998         /* Return result */
2999         return r.out.result;
3000 }
3001
3002 NTSTATUS rpccli_lsa_LSARREGISTERAUDITEVENT(struct rpc_pipe_client *cli,
3003                                            TALLOC_CTX *mem_ctx)
3004 {
3005         struct lsa_LSARREGISTERAUDITEVENT r;
3006         NTSTATUS status;
3007
3008         /* In parameters */
3009
3010         if (DEBUGLEVEL >= 10) {
3011                 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, &r);
3012         }
3013
3014         status = cli_do_rpc_ndr(cli,
3015                                 mem_ctx,
3016                                 PI_LSARPC,
3017                                 &ndr_table_lsarpc,
3018                                 NDR_LSA_LSARREGISTERAUDITEVENT,
3019                                 &r);
3020
3021         if (!NT_STATUS_IS_OK(status)) {
3022                 return status;
3023         }
3024
3025         if (DEBUGLEVEL >= 10) {
3026                 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, &r);
3027         }
3028
3029         if (NT_STATUS_IS_ERR(status)) {
3030                 return status;
3031         }
3032
3033         /* Return variables */
3034
3035         /* Return result */
3036         return r.out.result;
3037 }
3038
3039 NTSTATUS rpccli_lsa_LSARGENAUDITEVENT(struct rpc_pipe_client *cli,
3040                                       TALLOC_CTX *mem_ctx)
3041 {
3042         struct lsa_LSARGENAUDITEVENT r;
3043         NTSTATUS status;
3044
3045         /* In parameters */
3046
3047         if (DEBUGLEVEL >= 10) {
3048                 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, &r);
3049         }
3050
3051         status = cli_do_rpc_ndr(cli,
3052                                 mem_ctx,
3053                                 PI_LSARPC,
3054                                 &ndr_table_lsarpc,
3055                                 NDR_LSA_LSARGENAUDITEVENT,
3056                                 &r);
3057
3058         if (!NT_STATUS_IS_OK(status)) {
3059                 return status;
3060         }
3061
3062         if (DEBUGLEVEL >= 10) {
3063                 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, &r);
3064         }
3065
3066         if (NT_STATUS_IS_ERR(status)) {
3067                 return status;
3068         }
3069
3070         /* Return variables */
3071
3072         /* Return result */
3073         return r.out.result;
3074 }
3075
3076 NTSTATUS rpccli_lsa_LSARUNREGISTERAUDITEVENT(struct rpc_pipe_client *cli,
3077                                              TALLOC_CTX *mem_ctx)
3078 {
3079         struct lsa_LSARUNREGISTERAUDITEVENT r;
3080         NTSTATUS status;
3081
3082         /* In parameters */
3083
3084         if (DEBUGLEVEL >= 10) {
3085                 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, &r);
3086         }
3087
3088         status = cli_do_rpc_ndr(cli,
3089                                 mem_ctx,
3090                                 PI_LSARPC,
3091                                 &ndr_table_lsarpc,
3092                                 NDR_LSA_LSARUNREGISTERAUDITEVENT,
3093                                 &r);
3094
3095         if (!NT_STATUS_IS_OK(status)) {
3096                 return status;
3097         }
3098
3099         if (DEBUGLEVEL >= 10) {
3100                 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, &r);
3101         }
3102
3103         if (NT_STATUS_IS_ERR(status)) {
3104                 return status;
3105         }
3106
3107         /* Return variables */
3108
3109         /* Return result */
3110         return r.out.result;
3111 }
3112
3113 NTSTATUS rpccli_lsa_lsaRQueryForestTrustInformation(struct rpc_pipe_client *cli,
3114                                                     TALLOC_CTX *mem_ctx,
3115                                                     struct policy_handle *handle /* [in] [ref] */,
3116                                                     struct lsa_String *trusted_domain_name /* [in] [ref] */,
3117                                                     uint16_t unknown /* [in]  */,
3118                                                     struct lsa_ForestTrustInformation **forest_trust_info /* [out] [ref] */)
3119 {
3120         struct lsa_lsaRQueryForestTrustInformation r;
3121         NTSTATUS status;
3122
3123         /* In parameters */
3124         r.in.handle = handle;
3125         r.in.trusted_domain_name = trusted_domain_name;
3126         r.in.unknown = unknown;
3127
3128         if (DEBUGLEVEL >= 10) {
3129                 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, &r);
3130         }
3131
3132         status = cli_do_rpc_ndr(cli,
3133                                 mem_ctx,
3134                                 PI_LSARPC,
3135                                 &ndr_table_lsarpc,
3136                                 NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION,
3137                                 &r);
3138
3139         if (!NT_STATUS_IS_OK(status)) {
3140                 return status;
3141         }
3142
3143         if (DEBUGLEVEL >= 10) {
3144                 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation, &r);
3145         }
3146
3147         if (NT_STATUS_IS_ERR(status)) {
3148                 return status;
3149         }
3150
3151         /* Return variables */
3152         *forest_trust_info = *r.out.forest_trust_info;
3153
3154         /* Return result */
3155         return r.out.result;
3156 }
3157
3158 NTSTATUS rpccli_lsa_LSARSETFORESTTRUSTINFORMATION(struct rpc_pipe_client *cli,
3159                                                   TALLOC_CTX *mem_ctx)
3160 {
3161         struct lsa_LSARSETFORESTTRUSTINFORMATION r;
3162         NTSTATUS status;
3163
3164         /* In parameters */
3165
3166         if (DEBUGLEVEL >= 10) {
3167                 NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, &r);
3168         }
3169
3170         status = cli_do_rpc_ndr(cli,
3171                                 mem_ctx,
3172                                 PI_LSARPC,
3173                                 &ndr_table_lsarpc,
3174                                 NDR_LSA_LSARSETFORESTTRUSTINFORMATION,
3175                                 &r);
3176
3177         if (!NT_STATUS_IS_OK(status)) {
3178                 return status;
3179         }
3180
3181         if (DEBUGLEVEL >= 10) {
3182                 NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, &r);
3183         }
3184
3185         if (NT_STATUS_IS_ERR(status)) {
3186                 return status;
3187         }
3188
3189         /* Return variables */
3190
3191         /* Return result */
3192         return r.out.result;
3193 }
3194
3195 NTSTATUS rpccli_lsa_CREDRRENAME(struct rpc_pipe_client *cli,
3196                                 TALLOC_CTX *mem_ctx)
3197 {
3198         struct lsa_CREDRRENAME r;
3199         NTSTATUS status;
3200
3201         /* In parameters */
3202
3203         if (DEBUGLEVEL >= 10) {
3204                 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, &r);
3205         }
3206
3207         status = cli_do_rpc_ndr(cli,
3208                                 mem_ctx,
3209                                 PI_LSARPC,
3210                                 &ndr_table_lsarpc,
3211                                 NDR_LSA_CREDRRENAME,
3212                                 &r);
3213
3214         if (!NT_STATUS_IS_OK(status)) {
3215                 return status;
3216         }
3217
3218         if (DEBUGLEVEL >= 10) {
3219                 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, &r);
3220         }
3221
3222         if (NT_STATUS_IS_ERR(status)) {
3223                 return status;
3224         }
3225
3226         /* Return variables */
3227
3228         /* Return result */
3229         return r.out.result;
3230 }
3231
3232 NTSTATUS rpccli_lsa_LookupSids3(struct rpc_pipe_client *cli,
3233                                 TALLOC_CTX *mem_ctx,
3234                                 struct lsa_SidArray *sids /* [in] [ref] */,
3235                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
3236                                 struct lsa_TransNameArray2 *names /* [in,out] [ref] */,
3237                                 uint16_t level /* [in]  */,
3238                                 uint32_t *count /* [in,out] [ref] */,
3239                                 uint32_t unknown1 /* [in]  */,
3240                                 uint32_t unknown2 /* [in]  */)
3241 {
3242         struct lsa_LookupSids3 r;
3243         NTSTATUS status;
3244
3245         /* In parameters */
3246         r.in.sids = sids;
3247         r.in.names = names;
3248         r.in.level = level;
3249         r.in.count = count;
3250         r.in.unknown1 = unknown1;
3251         r.in.unknown2 = unknown2;
3252
3253         if (DEBUGLEVEL >= 10) {
3254                 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, &r);
3255         }
3256
3257         status = cli_do_rpc_ndr(cli,
3258                                 mem_ctx,
3259                                 PI_LSARPC,
3260                                 &ndr_table_lsarpc,
3261                                 NDR_LSA_LOOKUPSIDS3,
3262                                 &r);
3263
3264         if (!NT_STATUS_IS_OK(status)) {
3265                 return status;
3266         }
3267
3268         if (DEBUGLEVEL >= 10) {
3269                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, &r);
3270         }
3271
3272         if (NT_STATUS_IS_ERR(status)) {
3273                 return status;
3274         }
3275
3276         /* Return variables */
3277         *domains = *r.out.domains;
3278         *names = *r.out.names;
3279         *count = *r.out.count;
3280
3281         /* Return result */
3282         return r.out.result;
3283 }
3284
3285 NTSTATUS rpccli_lsa_LookupNames4(struct rpc_pipe_client *cli,
3286                                  TALLOC_CTX *mem_ctx,
3287                                  uint32_t num_names /* [in] [range(0,1000)] */,
3288                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
3289                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
3290                                  struct lsa_TransSidArray3 *sids /* [in,out] [ref] */,
3291                                  enum lsa_LookupNamesLevel level /* [in]  */,
3292                                  uint32_t *count /* [in,out] [ref] */,
3293                                  uint32_t unknown1 /* [in]  */,
3294                                  uint32_t unknown2 /* [in]  */)
3295 {
3296         struct lsa_LookupNames4 r;
3297         NTSTATUS status;
3298
3299         /* In parameters */
3300         r.in.num_names = num_names;
3301         r.in.names = names;
3302         r.in.sids = sids;
3303         r.in.level = level;
3304         r.in.count = count;
3305         r.in.unknown1 = unknown1;
3306         r.in.unknown2 = unknown2;
3307
3308         if (DEBUGLEVEL >= 10) {
3309                 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, &r);
3310         }
3311
3312         status = cli_do_rpc_ndr(cli,
3313                                 mem_ctx,
3314                                 PI_LSARPC,
3315                                 &ndr_table_lsarpc,
3316                                 NDR_LSA_LOOKUPNAMES4,
3317                                 &r);
3318
3319         if (!NT_STATUS_IS_OK(status)) {
3320                 return status;
3321         }
3322
3323         if (DEBUGLEVEL >= 10) {
3324                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, &r);
3325         }
3326
3327         if (NT_STATUS_IS_ERR(status)) {
3328                 return status;
3329         }
3330
3331         /* Return variables */
3332         *domains = *r.out.domains;
3333         *sids = *r.out.sids;
3334         *count = *r.out.count;
3335
3336         /* Return result */
3337         return r.out.result;
3338 }
3339
3340 NTSTATUS rpccli_lsa_LSAROPENPOLICYSCE(struct rpc_pipe_client *cli,
3341                                       TALLOC_CTX *mem_ctx)
3342 {
3343         struct lsa_LSAROPENPOLICYSCE r;
3344         NTSTATUS status;
3345
3346         /* In parameters */
3347
3348         if (DEBUGLEVEL >= 10) {
3349                 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, &r);
3350         }
3351
3352         status = cli_do_rpc_ndr(cli,
3353                                 mem_ctx,
3354                                 PI_LSARPC,
3355                                 &ndr_table_lsarpc,
3356                                 NDR_LSA_LSAROPENPOLICYSCE,
3357                                 &r);
3358
3359         if (!NT_STATUS_IS_OK(status)) {
3360                 return status;
3361         }
3362
3363         if (DEBUGLEVEL >= 10) {
3364                 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, &r);
3365         }
3366
3367         if (NT_STATUS_IS_ERR(status)) {
3368                 return status;
3369         }
3370
3371         /* Return variables */
3372
3373         /* Return result */
3374         return r.out.result;
3375 }
3376
3377 NTSTATUS rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli,
3378                                                        TALLOC_CTX *mem_ctx)
3379 {
3380         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE r;
3381         NTSTATUS status;
3382
3383         /* In parameters */
3384
3385         if (DEBUGLEVEL >= 10) {
3386                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &r);
3387         }
3388
3389         status = cli_do_rpc_ndr(cli,
3390                                 mem_ctx,
3391                                 PI_LSARPC,
3392                                 &ndr_table_lsarpc,
3393                                 NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE,
3394                                 &r);
3395
3396         if (!NT_STATUS_IS_OK(status)) {
3397                 return status;
3398         }
3399
3400         if (DEBUGLEVEL >= 10) {
3401                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &r);
3402         }
3403
3404         if (NT_STATUS_IS_ERR(status)) {
3405                 return status;
3406         }
3407
3408         /* Return variables */
3409
3410         /* Return result */
3411         return r.out.result;
3412 }
3413
3414 NTSTATUS rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli,
3415                                                          TALLOC_CTX *mem_ctx)
3416 {
3417         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE r;
3418         NTSTATUS status;
3419
3420         /* In parameters */
3421
3422         if (DEBUGLEVEL >= 10) {
3423                 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &r);
3424         }
3425
3426         status = cli_do_rpc_ndr(cli,
3427                                 mem_ctx,
3428                                 PI_LSARPC,
3429                                 &ndr_table_lsarpc,
3430                                 NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE,
3431                                 &r);
3432
3433         if (!NT_STATUS_IS_OK(status)) {
3434                 return status;
3435         }
3436
3437         if (DEBUGLEVEL >= 10) {
3438                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &r);
3439         }
3440
3441         if (NT_STATUS_IS_ERR(status)) {
3442                 return status;
3443         }
3444
3445         /* Return variables */
3446
3447         /* Return result */
3448         return r.out.result;
3449 }
3450
3451 NTSTATUS rpccli_lsa_LSARADTREPORTSECURITYEVENT(struct rpc_pipe_client *cli,
3452                                                TALLOC_CTX *mem_ctx)
3453 {
3454         struct lsa_LSARADTREPORTSECURITYEVENT r;
3455         NTSTATUS status;
3456
3457         /* In parameters */
3458
3459         if (DEBUGLEVEL >= 10) {
3460                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, &r);
3461         }
3462
3463         status = cli_do_rpc_ndr(cli,
3464                                 mem_ctx,
3465                                 PI_LSARPC,
3466                                 &ndr_table_lsarpc,
3467                                 NDR_LSA_LSARADTREPORTSECURITYEVENT,
3468                                 &r);
3469
3470         if (!NT_STATUS_IS_OK(status)) {
3471                 return status;
3472         }
3473
3474         if (DEBUGLEVEL >= 10) {
3475                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, &r);
3476         }
3477
3478         if (NT_STATUS_IS_ERR(status)) {
3479                 return status;
3480         }
3481
3482         /* Return variables */
3483
3484         /* Return result */
3485         return r.out.result;
3486 }
3487