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