source/librpc/gen_ndr/cli_lsa.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/cli_lsa.h"
   8
   9 NTSTATUS rpccli_lsa_Close(struct rpc_pipe_client *cli,
  10                           TALLOC_CTX *mem_ctx,
  11                           struct policy_handle *handle /* [in,out] [ref] */)
  12 {
  13         struct lsa_Close r;
  14         NTSTATUS status;
  15
  16         /* In parameters */
  17         r.in.handle = handle;
  18
  19         if (DEBUGLEVEL >= 10) {
  20                 NDR_PRINT_IN_DEBUG(lsa_Close, &r);
  21         }
  22
  23         status = cli_do_rpc_ndr(cli,
  24                                 mem_ctx,
  25                                 &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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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 *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.handle = 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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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_do_rpc_ndr(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 {
1146         struct lsa_SetInformationTrustedDomain r;
1147         NTSTATUS status;
1148
1149         /* In parameters */
1150
1151         if (DEBUGLEVEL >= 10) {
1152                 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, &r);
1153         }
1154
1155         status = cli_do_rpc_ndr(cli,
1156                                 mem_ctx,
1157                                 &ndr_table_lsarpc,
1158                                 NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN,
1159                                 &r);
1160
1161         if (!NT_STATUS_IS_OK(status)) {
1162                 return status;
1163         }
1164
1165         if (DEBUGLEVEL >= 10) {
1166                 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, &r);
1167         }
1168
1169         if (NT_STATUS_IS_ERR(status)) {
1170                 return status;
1171         }
1172
1173         /* Return variables */
1174
1175         /* Return result */
1176         return r.out.result;
1177 }
1178
1179 NTSTATUS rpccli_lsa_OpenSecret(struct rpc_pipe_client *cli,
1180                                TALLOC_CTX *mem_ctx,
1181                                struct policy_handle *handle /* [in] [ref] */,
1182                                struct lsa_String name /* [in]  */,
1183                                uint32_t access_mask /* [in]  */,
1184                                struct policy_handle *sec_handle /* [out] [ref] */)
1185 {
1186         struct lsa_OpenSecret r;
1187         NTSTATUS status;
1188
1189         /* In parameters */
1190         r.in.handle = handle;
1191         r.in.name = name;
1192         r.in.access_mask = access_mask;
1193
1194         if (DEBUGLEVEL >= 10) {
1195                 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, &r);
1196         }
1197
1198         status = cli_do_rpc_ndr(cli,
1199                                 mem_ctx,
1200                                 &ndr_table_lsarpc,
1201                                 NDR_LSA_OPENSECRET,
1202                                 &r);
1203
1204         if (!NT_STATUS_IS_OK(status)) {
1205                 return status;
1206         }
1207
1208         if (DEBUGLEVEL >= 10) {
1209                 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, &r);
1210         }
1211
1212         if (NT_STATUS_IS_ERR(status)) {
1213                 return status;
1214         }
1215
1216         /* Return variables */
1217         *sec_handle = *r.out.sec_handle;
1218
1219         /* Return result */
1220         return r.out.result;
1221 }
1222
1223 NTSTATUS rpccli_lsa_SetSecret(struct rpc_pipe_client *cli,
1224                               TALLOC_CTX *mem_ctx,
1225                               struct policy_handle *sec_handle /* [in] [ref] */,
1226                               struct lsa_DATA_BUF *new_val /* [in] [unique] */,
1227                               struct lsa_DATA_BUF *old_val /* [in] [unique] */)
1228 {
1229         struct lsa_SetSecret r;
1230         NTSTATUS status;
1231
1232         /* In parameters */
1233         r.in.sec_handle = sec_handle;
1234         r.in.new_val = new_val;
1235         r.in.old_val = old_val;
1236
1237         if (DEBUGLEVEL >= 10) {
1238                 NDR_PRINT_IN_DEBUG(lsa_SetSecret, &r);
1239         }
1240
1241         status = cli_do_rpc_ndr(cli,
1242                                 mem_ctx,
1243                                 &ndr_table_lsarpc,
1244                                 NDR_LSA_SETSECRET,
1245                                 &r);
1246
1247         if (!NT_STATUS_IS_OK(status)) {
1248                 return status;
1249         }
1250
1251         if (DEBUGLEVEL >= 10) {
1252                 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, &r);
1253         }
1254
1255         if (NT_STATUS_IS_ERR(status)) {
1256                 return status;
1257         }
1258
1259         /* Return variables */
1260
1261         /* Return result */
1262         return r.out.result;
1263 }
1264
1265 NTSTATUS rpccli_lsa_QuerySecret(struct rpc_pipe_client *cli,
1266                                 TALLOC_CTX *mem_ctx,
1267                                 struct policy_handle *sec_handle /* [in] [ref] */,
1268                                 struct lsa_DATA_BUF_PTR *new_val /* [in,out] [unique] */,
1269                                 NTTIME *new_mtime /* [in,out] [unique] */,
1270                                 struct lsa_DATA_BUF_PTR *old_val /* [in,out] [unique] */,
1271                                 NTTIME *old_mtime /* [in,out] [unique] */)
1272 {
1273         struct lsa_QuerySecret r;
1274         NTSTATUS status;
1275
1276         /* In parameters */
1277         r.in.sec_handle = sec_handle;
1278         r.in.new_val = new_val;
1279         r.in.new_mtime = new_mtime;
1280         r.in.old_val = old_val;
1281         r.in.old_mtime = old_mtime;
1282
1283         if (DEBUGLEVEL >= 10) {
1284                 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, &r);
1285         }
1286
1287         status = cli_do_rpc_ndr(cli,
1288                                 mem_ctx,
1289                                 &ndr_table_lsarpc,
1290                                 NDR_LSA_QUERYSECRET,
1291                                 &r);
1292
1293         if (!NT_STATUS_IS_OK(status)) {
1294                 return status;
1295         }
1296
1297         if (DEBUGLEVEL >= 10) {
1298                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, &r);
1299         }
1300
1301         if (NT_STATUS_IS_ERR(status)) {
1302                 return status;
1303         }
1304
1305         /* Return variables */
1306         if (new_val && r.out.new_val) {
1307                 *new_val = *r.out.new_val;
1308         }
1309         if (new_mtime && r.out.new_mtime) {
1310                 *new_mtime = *r.out.new_mtime;
1311         }
1312         if (old_val && r.out.old_val) {
1313                 *old_val = *r.out.old_val;
1314         }
1315         if (old_mtime && r.out.old_mtime) {
1316                 *old_mtime = *r.out.old_mtime;
1317         }
1318
1319         /* Return result */
1320         return r.out.result;
1321 }
1322
1323 NTSTATUS rpccli_lsa_LookupPrivValue(struct rpc_pipe_client *cli,
1324                                     TALLOC_CTX *mem_ctx,
1325                                     struct policy_handle *handle /* [in] [ref] */,
1326                                     struct lsa_String *name /* [in] [ref] */,
1327                                     struct lsa_LUID *luid /* [out] [ref] */)
1328 {
1329         struct lsa_LookupPrivValue r;
1330         NTSTATUS status;
1331
1332         /* In parameters */
1333         r.in.handle = handle;
1334         r.in.name = name;
1335
1336         if (DEBUGLEVEL >= 10) {
1337                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, &r);
1338         }
1339
1340         status = cli_do_rpc_ndr(cli,
1341                                 mem_ctx,
1342                                 &ndr_table_lsarpc,
1343                                 NDR_LSA_LOOKUPPRIVVALUE,
1344                                 &r);
1345
1346         if (!NT_STATUS_IS_OK(status)) {
1347                 return status;
1348         }
1349
1350         if (DEBUGLEVEL >= 10) {
1351                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, &r);
1352         }
1353
1354         if (NT_STATUS_IS_ERR(status)) {
1355                 return status;
1356         }
1357
1358         /* Return variables */
1359         *luid = *r.out.luid;
1360
1361         /* Return result */
1362         return r.out.result;
1363 }
1364
1365 NTSTATUS rpccli_lsa_LookupPrivName(struct rpc_pipe_client *cli,
1366                                    TALLOC_CTX *mem_ctx,
1367                                    struct policy_handle *handle /* [in] [ref] */,
1368                                    struct lsa_LUID *luid /* [in] [ref] */,
1369                                    struct lsa_StringLarge **name /* [out] [ref] */)
1370 {
1371         struct lsa_LookupPrivName r;
1372         NTSTATUS status;
1373
1374         /* In parameters */
1375         r.in.handle = handle;
1376         r.in.luid = luid;
1377
1378         if (DEBUGLEVEL >= 10) {
1379                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, &r);
1380         }
1381
1382         status = cli_do_rpc_ndr(cli,
1383                                 mem_ctx,
1384                                 &ndr_table_lsarpc,
1385                                 NDR_LSA_LOOKUPPRIVNAME,
1386                                 &r);
1387
1388         if (!NT_STATUS_IS_OK(status)) {
1389                 return status;
1390         }
1391
1392         if (DEBUGLEVEL >= 10) {
1393                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, &r);
1394         }
1395
1396         if (NT_STATUS_IS_ERR(status)) {
1397                 return status;
1398         }
1399
1400         /* Return variables */
1401         *name = *r.out.name;
1402
1403         /* Return result */
1404         return r.out.result;
1405 }
1406
1407 NTSTATUS rpccli_lsa_LookupPrivDisplayName(struct rpc_pipe_client *cli,
1408                                           TALLOC_CTX *mem_ctx,
1409                                           struct policy_handle *handle /* [in] [ref] */,
1410                                           struct lsa_String *name /* [in] [ref] */,
1411                                           uint16_t language_id /* [in]  */,
1412                                           uint16_t language_id_sys /* [in]  */,
1413                                           struct lsa_StringLarge **disp_name /* [out] [ref] */,
1414                                           uint16_t *returned_language_id /* [out] [ref] */)
1415 {
1416         struct lsa_LookupPrivDisplayName r;
1417         NTSTATUS status;
1418
1419         /* In parameters */
1420         r.in.handle = handle;
1421         r.in.name = name;
1422         r.in.language_id = language_id;
1423         r.in.language_id_sys = language_id_sys;
1424
1425         if (DEBUGLEVEL >= 10) {
1426                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, &r);
1427         }
1428
1429         status = cli_do_rpc_ndr(cli,
1430                                 mem_ctx,
1431                                 &ndr_table_lsarpc,
1432                                 NDR_LSA_LOOKUPPRIVDISPLAYNAME,
1433                                 &r);
1434
1435         if (!NT_STATUS_IS_OK(status)) {
1436                 return status;
1437         }
1438
1439         if (DEBUGLEVEL >= 10) {
1440                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, &r);
1441         }
1442
1443         if (NT_STATUS_IS_ERR(status)) {
1444                 return status;
1445         }
1446
1447         /* Return variables */
1448         *disp_name = *r.out.disp_name;
1449         *returned_language_id = *r.out.returned_language_id;
1450
1451         /* Return result */
1452         return r.out.result;
1453 }
1454
1455 NTSTATUS rpccli_lsa_DeleteObject(struct rpc_pipe_client *cli,
1456                                  TALLOC_CTX *mem_ctx,
1457                                  struct policy_handle *handle /* [in,out] [ref] */)
1458 {
1459         struct lsa_DeleteObject r;
1460         NTSTATUS status;
1461
1462         /* In parameters */
1463         r.in.handle = handle;
1464
1465         if (DEBUGLEVEL >= 10) {
1466                 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, &r);
1467         }
1468
1469         status = cli_do_rpc_ndr(cli,
1470                                 mem_ctx,
1471                                 &ndr_table_lsarpc,
1472                                 NDR_LSA_DELETEOBJECT,
1473                                 &r);
1474
1475         if (!NT_STATUS_IS_OK(status)) {
1476                 return status;
1477         }
1478
1479         if (DEBUGLEVEL >= 10) {
1480                 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, &r);
1481         }
1482
1483         if (NT_STATUS_IS_ERR(status)) {
1484                 return status;
1485         }
1486
1487         /* Return variables */
1488         *handle = *r.out.handle;
1489
1490         /* Return result */
1491         return r.out.result;
1492 }
1493
1494 NTSTATUS rpccli_lsa_EnumAccountsWithUserRight(struct rpc_pipe_client *cli,
1495                                               TALLOC_CTX *mem_ctx,
1496                                               struct policy_handle *handle /* [in] [ref] */,
1497                                               struct lsa_String *name /* [in] [unique] */,
1498                                               struct lsa_SidArray *sids /* [out] [ref] */)
1499 {
1500         struct lsa_EnumAccountsWithUserRight r;
1501         NTSTATUS status;
1502
1503         /* In parameters */
1504         r.in.handle = handle;
1505         r.in.name = name;
1506
1507         if (DEBUGLEVEL >= 10) {
1508                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, &r);
1509         }
1510
1511         status = cli_do_rpc_ndr(cli,
1512                                 mem_ctx,
1513                                 &ndr_table_lsarpc,
1514                                 NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT,
1515                                 &r);
1516
1517         if (!NT_STATUS_IS_OK(status)) {
1518                 return status;
1519         }
1520
1521         if (DEBUGLEVEL >= 10) {
1522                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, &r);
1523         }
1524
1525         if (NT_STATUS_IS_ERR(status)) {
1526                 return status;
1527         }
1528
1529         /* Return variables */
1530         *sids = *r.out.sids;
1531
1532         /* Return result */
1533         return r.out.result;
1534 }
1535
1536 NTSTATUS rpccli_lsa_EnumAccountRights(struct rpc_pipe_client *cli,
1537                                       TALLOC_CTX *mem_ctx,
1538                                       struct policy_handle *handle /* [in] [ref] */,
1539                                       struct dom_sid2 *sid /* [in] [ref] */,
1540                                       struct lsa_RightSet *rights /* [out] [ref] */)
1541 {
1542         struct lsa_EnumAccountRights r;
1543         NTSTATUS status;
1544
1545         /* In parameters */
1546         r.in.handle = handle;
1547         r.in.sid = sid;
1548
1549         if (DEBUGLEVEL >= 10) {
1550                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, &r);
1551         }
1552
1553         status = cli_do_rpc_ndr(cli,
1554                                 mem_ctx,
1555                                 &ndr_table_lsarpc,
1556                                 NDR_LSA_ENUMACCOUNTRIGHTS,
1557                                 &r);
1558
1559         if (!NT_STATUS_IS_OK(status)) {
1560                 return status;
1561         }
1562
1563         if (DEBUGLEVEL >= 10) {
1564                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, &r);
1565         }
1566
1567         if (NT_STATUS_IS_ERR(status)) {
1568                 return status;
1569         }
1570
1571         /* Return variables */
1572         *rights = *r.out.rights;
1573
1574         /* Return result */
1575         return r.out.result;
1576 }
1577
1578 NTSTATUS rpccli_lsa_AddAccountRights(struct rpc_pipe_client *cli,
1579                                      TALLOC_CTX *mem_ctx,
1580                                      struct policy_handle *handle /* [in] [ref] */,
1581                                      struct dom_sid2 *sid /* [in] [ref] */,
1582                                      struct lsa_RightSet *rights /* [in] [ref] */)
1583 {
1584         struct lsa_AddAccountRights r;
1585         NTSTATUS status;
1586
1587         /* In parameters */
1588         r.in.handle = handle;
1589         r.in.sid = sid;
1590         r.in.rights = rights;
1591
1592         if (DEBUGLEVEL >= 10) {
1593                 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, &r);
1594         }
1595
1596         status = cli_do_rpc_ndr(cli,
1597                                 mem_ctx,
1598                                 &ndr_table_lsarpc,
1599                                 NDR_LSA_ADDACCOUNTRIGHTS,
1600                                 &r);
1601
1602         if (!NT_STATUS_IS_OK(status)) {
1603                 return status;
1604         }
1605
1606         if (DEBUGLEVEL >= 10) {
1607                 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, &r);
1608         }
1609
1610         if (NT_STATUS_IS_ERR(status)) {
1611                 return status;
1612         }
1613
1614         /* Return variables */
1615
1616         /* Return result */
1617         return r.out.result;
1618 }
1619
1620 NTSTATUS rpccli_lsa_RemoveAccountRights(struct rpc_pipe_client *cli,
1621                                         TALLOC_CTX *mem_ctx,
1622                                         struct policy_handle *handle /* [in] [ref] */,
1623                                         struct dom_sid2 *sid /* [in] [ref] */,
1624                                         uint8_t remove_all /* [in]  */,
1625                                         struct lsa_RightSet *rights /* [in] [ref] */)
1626 {
1627         struct lsa_RemoveAccountRights r;
1628         NTSTATUS status;
1629
1630         /* In parameters */
1631         r.in.handle = handle;
1632         r.in.sid = sid;
1633         r.in.remove_all = remove_all;
1634         r.in.rights = rights;
1635
1636         if (DEBUGLEVEL >= 10) {
1637                 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, &r);
1638         }
1639
1640         status = cli_do_rpc_ndr(cli,
1641                                 mem_ctx,
1642                                 &ndr_table_lsarpc,
1643                                 NDR_LSA_REMOVEACCOUNTRIGHTS,
1644                                 &r);
1645
1646         if (!NT_STATUS_IS_OK(status)) {
1647                 return status;
1648         }
1649
1650         if (DEBUGLEVEL >= 10) {
1651                 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, &r);
1652         }
1653
1654         if (NT_STATUS_IS_ERR(status)) {
1655                 return status;
1656         }
1657
1658         /* Return variables */
1659
1660         /* Return result */
1661         return r.out.result;
1662 }
1663
1664 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoBySid(struct rpc_pipe_client *cli,
1665                                                 TALLOC_CTX *mem_ctx,
1666                                                 struct policy_handle *handle /* [in] [ref] */,
1667                                                 struct dom_sid2 *dom_sid /* [in] [ref] */,
1668                                                 enum lsa_TrustDomInfoEnum level /* [in]  */,
1669                                                 union lsa_TrustedDomainInfo **info /* [out] [ref,switch_is(level)] */)
1670 {
1671         struct lsa_QueryTrustedDomainInfoBySid r;
1672         NTSTATUS status;
1673
1674         /* In parameters */
1675         r.in.handle = handle;
1676         r.in.dom_sid = dom_sid;
1677         r.in.level = level;
1678
1679         if (DEBUGLEVEL >= 10) {
1680                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, &r);
1681         }
1682
1683         status = cli_do_rpc_ndr(cli,
1684                                 mem_ctx,
1685                                 &ndr_table_lsarpc,
1686                                 NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID,
1687                                 &r);
1688
1689         if (!NT_STATUS_IS_OK(status)) {
1690                 return status;
1691         }
1692
1693         if (DEBUGLEVEL >= 10) {
1694                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, &r);
1695         }
1696
1697         if (NT_STATUS_IS_ERR(status)) {
1698                 return status;
1699         }
1700
1701         /* Return variables */
1702         *info = *r.out.info;
1703
1704         /* Return result */
1705         return r.out.result;
1706 }
1707
1708 NTSTATUS rpccli_lsa_SetTrustedDomainInfo(struct rpc_pipe_client *cli,
1709                                          TALLOC_CTX *mem_ctx)
1710 {
1711         struct lsa_SetTrustedDomainInfo r;
1712         NTSTATUS status;
1713
1714         /* In parameters */
1715
1716         if (DEBUGLEVEL >= 10) {
1717                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, &r);
1718         }
1719
1720         status = cli_do_rpc_ndr(cli,
1721                                 mem_ctx,
1722                                 &ndr_table_lsarpc,
1723                                 NDR_LSA_SETTRUSTEDDOMAININFO,
1724                                 &r);
1725
1726         if (!NT_STATUS_IS_OK(status)) {
1727                 return status;
1728         }
1729
1730         if (DEBUGLEVEL >= 10) {
1731                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, &r);
1732         }
1733
1734         if (NT_STATUS_IS_ERR(status)) {
1735                 return status;
1736         }
1737
1738         /* Return variables */
1739
1740         /* Return result */
1741         return r.out.result;
1742 }
1743
1744 NTSTATUS rpccli_lsa_DeleteTrustedDomain(struct rpc_pipe_client *cli,
1745                                         TALLOC_CTX *mem_ctx,
1746                                         struct policy_handle *handle /* [in] [ref] */,
1747                                         struct dom_sid2 *dom_sid /* [in] [ref] */)
1748 {
1749         struct lsa_DeleteTrustedDomain r;
1750         NTSTATUS status;
1751
1752         /* In parameters */
1753         r.in.handle = handle;
1754         r.in.dom_sid = dom_sid;
1755
1756         if (DEBUGLEVEL >= 10) {
1757                 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, &r);
1758         }
1759
1760         status = cli_do_rpc_ndr(cli,
1761                                 mem_ctx,
1762                                 &ndr_table_lsarpc,
1763                                 NDR_LSA_DELETETRUSTEDDOMAIN,
1764                                 &r);
1765
1766         if (!NT_STATUS_IS_OK(status)) {
1767                 return status;
1768         }
1769
1770         if (DEBUGLEVEL >= 10) {
1771                 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, &r);
1772         }
1773
1774         if (NT_STATUS_IS_ERR(status)) {
1775                 return status;
1776         }
1777
1778         /* Return variables */
1779
1780         /* Return result */
1781         return r.out.result;
1782 }
1783
1784 NTSTATUS rpccli_lsa_StorePrivateData(struct rpc_pipe_client *cli,
1785                                      TALLOC_CTX *mem_ctx)
1786 {
1787         struct lsa_StorePrivateData r;
1788         NTSTATUS status;
1789
1790         /* In parameters */
1791
1792         if (DEBUGLEVEL >= 10) {
1793                 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, &r);
1794         }
1795
1796         status = cli_do_rpc_ndr(cli,
1797                                 mem_ctx,
1798                                 &ndr_table_lsarpc,
1799                                 NDR_LSA_STOREPRIVATEDATA,
1800                                 &r);
1801
1802         if (!NT_STATUS_IS_OK(status)) {
1803                 return status;
1804         }
1805
1806         if (DEBUGLEVEL >= 10) {
1807                 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, &r);
1808         }
1809
1810         if (NT_STATUS_IS_ERR(status)) {
1811                 return status;
1812         }
1813
1814         /* Return variables */
1815
1816         /* Return result */
1817         return r.out.result;
1818 }
1819
1820 NTSTATUS rpccli_lsa_RetrievePrivateData(struct rpc_pipe_client *cli,
1821                                         TALLOC_CTX *mem_ctx)
1822 {
1823         struct lsa_RetrievePrivateData r;
1824         NTSTATUS status;
1825
1826         /* In parameters */
1827
1828         if (DEBUGLEVEL >= 10) {
1829                 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, &r);
1830         }
1831
1832         status = cli_do_rpc_ndr(cli,
1833                                 mem_ctx,
1834                                 &ndr_table_lsarpc,
1835                                 NDR_LSA_RETRIEVEPRIVATEDATA,
1836                                 &r);
1837
1838         if (!NT_STATUS_IS_OK(status)) {
1839                 return status;
1840         }
1841
1842         if (DEBUGLEVEL >= 10) {
1843                 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, &r);
1844         }
1845
1846         if (NT_STATUS_IS_ERR(status)) {
1847                 return status;
1848         }
1849
1850         /* Return variables */
1851
1852         /* Return result */
1853         return r.out.result;
1854 }
1855
1856 NTSTATUS rpccli_lsa_OpenPolicy2(struct rpc_pipe_client *cli,
1857                                 TALLOC_CTX *mem_ctx,
1858                                 const char *system_name /* [in] [unique,charset(UTF16)] */,
1859                                 struct lsa_ObjectAttribute *attr /* [in] [ref] */,
1860                                 uint32_t access_mask /* [in]  */,
1861                                 struct policy_handle *handle /* [out] [ref] */)
1862 {
1863         struct lsa_OpenPolicy2 r;
1864         NTSTATUS status;
1865
1866         /* In parameters */
1867         r.in.system_name = system_name;
1868         r.in.attr = attr;
1869         r.in.access_mask = access_mask;
1870
1871         if (DEBUGLEVEL >= 10) {
1872                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, &r);
1873         }
1874
1875         status = cli_do_rpc_ndr(cli,
1876                                 mem_ctx,
1877                                 &ndr_table_lsarpc,
1878                                 NDR_LSA_OPENPOLICY2,
1879                                 &r);
1880
1881         if (!NT_STATUS_IS_OK(status)) {
1882                 return status;
1883         }
1884
1885         if (DEBUGLEVEL >= 10) {
1886                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, &r);
1887         }
1888
1889         if (NT_STATUS_IS_ERR(status)) {
1890                 return status;
1891         }
1892
1893         /* Return variables */
1894         *handle = *r.out.handle;
1895
1896         /* Return result */
1897         return r.out.result;
1898 }
1899
1900 NTSTATUS rpccli_lsa_GetUserName(struct rpc_pipe_client *cli,
1901                                 TALLOC_CTX *mem_ctx,
1902                                 const char *system_name /* [in] [unique,charset(UTF16)] */,
1903                                 struct lsa_String **account_name /* [in,out] [ref] */,
1904                                 struct lsa_String **authority_name /* [in,out] [unique] */)
1905 {
1906         struct lsa_GetUserName r;
1907         NTSTATUS status;
1908
1909         /* In parameters */
1910         r.in.system_name = system_name;
1911         r.in.account_name = account_name;
1912         r.in.authority_name = authority_name;
1913
1914         if (DEBUGLEVEL >= 10) {
1915                 NDR_PRINT_IN_DEBUG(lsa_GetUserName, &r);
1916         }
1917
1918         status = cli_do_rpc_ndr(cli,
1919                                 mem_ctx,
1920                                 &ndr_table_lsarpc,
1921                                 NDR_LSA_GETUSERNAME,
1922                                 &r);
1923
1924         if (!NT_STATUS_IS_OK(status)) {
1925                 return status;
1926         }
1927
1928         if (DEBUGLEVEL >= 10) {
1929                 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, &r);
1930         }
1931
1932         if (NT_STATUS_IS_ERR(status)) {
1933                 return status;
1934         }
1935
1936         /* Return variables */
1937         *account_name = *r.out.account_name;
1938         if (authority_name && r.out.authority_name) {
1939                 *authority_name = *r.out.authority_name;
1940         }
1941
1942         /* Return result */
1943         return r.out.result;
1944 }
1945
1946 NTSTATUS rpccli_lsa_QueryInfoPolicy2(struct rpc_pipe_client *cli,
1947                                      TALLOC_CTX *mem_ctx,
1948                                      struct policy_handle *handle /* [in] [ref] */,
1949                                      enum lsa_PolicyInfo level /* [in]  */,
1950                                      union lsa_PolicyInformation **info /* [out] [ref,switch_is(level)] */)
1951 {
1952         struct lsa_QueryInfoPolicy2 r;
1953         NTSTATUS status;
1954
1955         /* In parameters */
1956         r.in.handle = handle;
1957         r.in.level = level;
1958
1959         if (DEBUGLEVEL >= 10) {
1960                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, &r);
1961         }
1962
1963         status = cli_do_rpc_ndr(cli,
1964                                 mem_ctx,
1965                                 &ndr_table_lsarpc,
1966                                 NDR_LSA_QUERYINFOPOLICY2,
1967                                 &r);
1968
1969         if (!NT_STATUS_IS_OK(status)) {
1970                 return status;
1971         }
1972
1973         if (DEBUGLEVEL >= 10) {
1974                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, &r);
1975         }
1976
1977         if (NT_STATUS_IS_ERR(status)) {
1978                 return status;
1979         }
1980
1981         /* Return variables */
1982         *info = *r.out.info;
1983
1984         /* Return result */
1985         return r.out.result;
1986 }
1987
1988 NTSTATUS rpccli_lsa_SetInfoPolicy2(struct rpc_pipe_client *cli,
1989                                    TALLOC_CTX *mem_ctx,
1990                                    struct policy_handle *handle /* [in] [ref] */,
1991                                    enum lsa_PolicyInfo level /* [in]  */,
1992                                    union lsa_PolicyInformation *info /* [in] [ref,switch_is(level)] */)
1993 {
1994         struct lsa_SetInfoPolicy2 r;
1995         NTSTATUS status;
1996
1997         /* In parameters */
1998         r.in.handle = handle;
1999         r.in.level = level;
2000         r.in.info = info;
2001
2002         if (DEBUGLEVEL >= 10) {
2003                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, &r);
2004         }
2005
2006         status = cli_do_rpc_ndr(cli,
2007                                 mem_ctx,
2008                                 &ndr_table_lsarpc,
2009                                 NDR_LSA_SETINFOPOLICY2,
2010                                 &r);
2011
2012         if (!NT_STATUS_IS_OK(status)) {
2013                 return status;
2014         }
2015
2016         if (DEBUGLEVEL >= 10) {
2017                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, &r);
2018         }
2019
2020         if (NT_STATUS_IS_ERR(status)) {
2021                 return status;
2022         }
2023
2024         /* Return variables */
2025
2026         /* Return result */
2027         return r.out.result;
2028 }
2029
2030 NTSTATUS rpccli_lsa_QueryTrustedDomainInfoByName(struct rpc_pipe_client *cli,
2031                                                  TALLOC_CTX *mem_ctx,
2032                                                  struct policy_handle *handle /* [in] [ref] */,
2033                                                  struct lsa_String *trusted_domain /* [in] [ref] */,
2034                                                  enum lsa_TrustDomInfoEnum level /* [in]  */,
2035                                                  union lsa_TrustedDomainInfo **info /* [out] [ref,switch_is(level)] */)
2036 {
2037         struct lsa_QueryTrustedDomainInfoByName r;
2038         NTSTATUS status;
2039
2040         /* In parameters */
2041         r.in.handle = handle;
2042         r.in.trusted_domain = trusted_domain;
2043         r.in.level = level;
2044
2045         if (DEBUGLEVEL >= 10) {
2046                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, &r);
2047         }
2048
2049         status = cli_do_rpc_ndr(cli,
2050                                 mem_ctx,
2051                                 &ndr_table_lsarpc,
2052                                 NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME,
2053                                 &r);
2054
2055         if (!NT_STATUS_IS_OK(status)) {
2056                 return status;
2057         }
2058
2059         if (DEBUGLEVEL >= 10) {
2060                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, &r);
2061         }
2062
2063         if (NT_STATUS_IS_ERR(status)) {
2064                 return status;
2065         }
2066
2067         /* Return variables */
2068         *info = *r.out.info;
2069
2070         /* Return result */
2071         return r.out.result;
2072 }
2073
2074 NTSTATUS rpccli_lsa_SetTrustedDomainInfoByName(struct rpc_pipe_client *cli,
2075                                                TALLOC_CTX *mem_ctx,
2076                                                struct policy_handle *handle /* [in] [ref] */,
2077                                                struct lsa_String trusted_domain /* [in]  */,
2078                                                enum lsa_TrustDomInfoEnum level /* [in]  */,
2079                                                union lsa_TrustedDomainInfo *info /* [in] [unique,switch_is(level)] */)
2080 {
2081         struct lsa_SetTrustedDomainInfoByName r;
2082         NTSTATUS status;
2083
2084         /* In parameters */
2085         r.in.handle = handle;
2086         r.in.trusted_domain = trusted_domain;
2087         r.in.level = level;
2088         r.in.info = info;
2089
2090         if (DEBUGLEVEL >= 10) {
2091                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, &r);
2092         }
2093
2094         status = cli_do_rpc_ndr(cli,
2095                                 mem_ctx,
2096                                 &ndr_table_lsarpc,
2097                                 NDR_LSA_SETTRUSTEDDOMAININFOBYNAME,
2098                                 &r);
2099
2100         if (!NT_STATUS_IS_OK(status)) {
2101                 return status;
2102         }
2103
2104         if (DEBUGLEVEL >= 10) {
2105                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, &r);
2106         }
2107
2108         if (NT_STATUS_IS_ERR(status)) {
2109                 return status;
2110         }
2111
2112         /* Return variables */
2113
2114         /* Return result */
2115         return r.out.result;
2116 }
2117
2118 NTSTATUS rpccli_lsa_EnumTrustedDomainsEx(struct rpc_pipe_client *cli,
2119                                          TALLOC_CTX *mem_ctx,
2120                                          struct policy_handle *handle /* [in] [ref] */,
2121                                          uint32_t *resume_handle /* [in,out] [ref] */,
2122                                          struct lsa_DomainListEx *domains /* [out] [ref] */,
2123                                          uint32_t max_size /* [in]  */)
2124 {
2125         struct lsa_EnumTrustedDomainsEx r;
2126         NTSTATUS status;
2127
2128         /* In parameters */
2129         r.in.handle = handle;
2130         r.in.resume_handle = resume_handle;
2131         r.in.max_size = max_size;
2132
2133         if (DEBUGLEVEL >= 10) {
2134                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, &r);
2135         }
2136
2137         status = cli_do_rpc_ndr(cli,
2138                                 mem_ctx,
2139                                 &ndr_table_lsarpc,
2140                                 NDR_LSA_ENUMTRUSTEDDOMAINSEX,
2141                                 &r);
2142
2143         if (!NT_STATUS_IS_OK(status)) {
2144                 return status;
2145         }
2146
2147         if (DEBUGLEVEL >= 10) {
2148                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, &r);
2149         }
2150
2151         if (NT_STATUS_IS_ERR(status)) {
2152                 return status;
2153         }
2154
2155         /* Return variables */
2156         *resume_handle = *r.out.resume_handle;
2157         *domains = *r.out.domains;
2158
2159         /* Return result */
2160         return r.out.result;
2161 }
2162
2163 NTSTATUS rpccli_lsa_CreateTrustedDomainEx(struct rpc_pipe_client *cli,
2164                                           TALLOC_CTX *mem_ctx)
2165 {
2166         struct lsa_CreateTrustedDomainEx r;
2167         NTSTATUS status;
2168
2169         /* In parameters */
2170
2171         if (DEBUGLEVEL >= 10) {
2172                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, &r);
2173         }
2174
2175         status = cli_do_rpc_ndr(cli,
2176                                 mem_ctx,
2177                                 &ndr_table_lsarpc,
2178                                 NDR_LSA_CREATETRUSTEDDOMAINEX,
2179                                 &r);
2180
2181         if (!NT_STATUS_IS_OK(status)) {
2182                 return status;
2183         }
2184
2185         if (DEBUGLEVEL >= 10) {
2186                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, &r);
2187         }
2188
2189         if (NT_STATUS_IS_ERR(status)) {
2190                 return status;
2191         }
2192
2193         /* Return variables */
2194
2195         /* Return result */
2196         return r.out.result;
2197 }
2198
2199 NTSTATUS rpccli_lsa_CloseTrustedDomainEx(struct rpc_pipe_client *cli,
2200                                          TALLOC_CTX *mem_ctx,
2201                                          struct policy_handle *handle /* [in,out] [ref] */)
2202 {
2203         struct lsa_CloseTrustedDomainEx r;
2204         NTSTATUS status;
2205
2206         /* In parameters */
2207         r.in.handle = handle;
2208
2209         if (DEBUGLEVEL >= 10) {
2210                 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, &r);
2211         }
2212
2213         status = cli_do_rpc_ndr(cli,
2214                                 mem_ctx,
2215                                 &ndr_table_lsarpc,
2216                                 NDR_LSA_CLOSETRUSTEDDOMAINEX,
2217                                 &r);
2218
2219         if (!NT_STATUS_IS_OK(status)) {
2220                 return status;
2221         }
2222
2223         if (DEBUGLEVEL >= 10) {
2224                 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, &r);
2225         }
2226
2227         if (NT_STATUS_IS_ERR(status)) {
2228                 return status;
2229         }
2230
2231         /* Return variables */
2232         *handle = *r.out.handle;
2233
2234         /* Return result */
2235         return r.out.result;
2236 }
2237
2238 NTSTATUS rpccli_lsa_QueryDomainInformationPolicy(struct rpc_pipe_client *cli,
2239                                                  TALLOC_CTX *mem_ctx,
2240                                                  struct policy_handle *handle /* [in] [ref] */,
2241                                                  uint16_t level /* [in]  */,
2242                                                  union lsa_DomainInformationPolicy **info /* [out] [ref,switch_is(level)] */)
2243 {
2244         struct lsa_QueryDomainInformationPolicy r;
2245         NTSTATUS status;
2246
2247         /* In parameters */
2248         r.in.handle = handle;
2249         r.in.level = level;
2250
2251         if (DEBUGLEVEL >= 10) {
2252                 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, &r);
2253         }
2254
2255         status = cli_do_rpc_ndr(cli,
2256                                 mem_ctx,
2257                                 &ndr_table_lsarpc,
2258                                 NDR_LSA_QUERYDOMAININFORMATIONPOLICY,
2259                                 &r);
2260
2261         if (!NT_STATUS_IS_OK(status)) {
2262                 return status;
2263         }
2264
2265         if (DEBUGLEVEL >= 10) {
2266                 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, &r);
2267         }
2268
2269         if (NT_STATUS_IS_ERR(status)) {
2270                 return status;
2271         }
2272
2273         /* Return variables */
2274         *info = *r.out.info;
2275
2276         /* Return result */
2277         return r.out.result;
2278 }
2279
2280 NTSTATUS rpccli_lsa_SetDomainInformationPolicy(struct rpc_pipe_client *cli,
2281                                                TALLOC_CTX *mem_ctx,
2282                                                struct policy_handle *handle /* [in] [ref] */,
2283                                                uint16_t level /* [in]  */,
2284                                                union lsa_DomainInformationPolicy *info /* [in] [unique,switch_is(level)] */)
2285 {
2286         struct lsa_SetDomainInformationPolicy r;
2287         NTSTATUS status;
2288
2289         /* In parameters */
2290         r.in.handle = handle;
2291         r.in.level = level;
2292         r.in.info = info;
2293
2294         if (DEBUGLEVEL >= 10) {
2295                 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, &r);
2296         }
2297
2298         status = cli_do_rpc_ndr(cli,
2299                                 mem_ctx,
2300                                 &ndr_table_lsarpc,
2301                                 NDR_LSA_SETDOMAININFORMATIONPOLICY,
2302                                 &r);
2303
2304         if (!NT_STATUS_IS_OK(status)) {
2305                 return status;
2306         }
2307
2308         if (DEBUGLEVEL >= 10) {
2309                 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, &r);
2310         }
2311
2312         if (NT_STATUS_IS_ERR(status)) {
2313                 return status;
2314         }
2315
2316         /* Return variables */
2317
2318         /* Return result */
2319         return r.out.result;
2320 }
2321
2322 NTSTATUS rpccli_lsa_OpenTrustedDomainByName(struct rpc_pipe_client *cli,
2323                                             TALLOC_CTX *mem_ctx,
2324                                             struct policy_handle *handle /* [in] [ref] */,
2325                                             struct lsa_String name /* [in]  */,
2326                                             uint32_t access_mask /* [in]  */,
2327                                             struct policy_handle *trustdom_handle /* [out] [ref] */)
2328 {
2329         struct lsa_OpenTrustedDomainByName r;
2330         NTSTATUS status;
2331
2332         /* In parameters */
2333         r.in.handle = handle;
2334         r.in.name = name;
2335         r.in.access_mask = access_mask;
2336
2337         if (DEBUGLEVEL >= 10) {
2338                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, &r);
2339         }
2340
2341         status = cli_do_rpc_ndr(cli,
2342                                 mem_ctx,
2343                                 &ndr_table_lsarpc,
2344                                 NDR_LSA_OPENTRUSTEDDOMAINBYNAME,
2345                                 &r);
2346
2347         if (!NT_STATUS_IS_OK(status)) {
2348                 return status;
2349         }
2350
2351         if (DEBUGLEVEL >= 10) {
2352                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, &r);
2353         }
2354
2355         if (NT_STATUS_IS_ERR(status)) {
2356                 return status;
2357         }
2358
2359         /* Return variables */
2360         *trustdom_handle = *r.out.trustdom_handle;
2361
2362         /* Return result */
2363         return r.out.result;
2364 }
2365
2366 NTSTATUS rpccli_lsa_TestCall(struct rpc_pipe_client *cli,
2367                              TALLOC_CTX *mem_ctx)
2368 {
2369         struct lsa_TestCall r;
2370         NTSTATUS status;
2371
2372         /* In parameters */
2373
2374         if (DEBUGLEVEL >= 10) {
2375                 NDR_PRINT_IN_DEBUG(lsa_TestCall, &r);
2376         }
2377
2378         status = cli_do_rpc_ndr(cli,
2379                                 mem_ctx,
2380                                 &ndr_table_lsarpc,
2381                                 NDR_LSA_TESTCALL,
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_TestCall, &r);
2390         }
2391
2392         if (NT_STATUS_IS_ERR(status)) {
2393                 return status;
2394         }
2395
2396         /* Return variables */
2397
2398         /* Return result */
2399         return r.out.result;
2400 }
2401
2402 NTSTATUS rpccli_lsa_LookupSids2(struct rpc_pipe_client *cli,
2403                                 TALLOC_CTX *mem_ctx,
2404                                 struct policy_handle *handle /* [in] [ref] */,
2405                                 struct lsa_SidArray *sids /* [in] [ref] */,
2406                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
2407                                 struct lsa_TransNameArray2 *names /* [in,out] [ref] */,
2408                                 uint16_t level /* [in]  */,
2409                                 uint32_t *count /* [in,out] [ref] */,
2410                                 uint32_t unknown1 /* [in]  */,
2411                                 uint32_t unknown2 /* [in]  */)
2412 {
2413         struct lsa_LookupSids2 r;
2414         NTSTATUS status;
2415
2416         /* In parameters */
2417         r.in.handle = handle;
2418         r.in.sids = sids;
2419         r.in.names = names;
2420         r.in.level = level;
2421         r.in.count = count;
2422         r.in.unknown1 = unknown1;
2423         r.in.unknown2 = unknown2;
2424
2425         if (DEBUGLEVEL >= 10) {
2426                 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, &r);
2427         }
2428
2429         status = cli_do_rpc_ndr(cli,
2430                                 mem_ctx,
2431                                 &ndr_table_lsarpc,
2432                                 NDR_LSA_LOOKUPSIDS2,
2433                                 &r);
2434
2435         if (!NT_STATUS_IS_OK(status)) {
2436                 return status;
2437         }
2438
2439         if (DEBUGLEVEL >= 10) {
2440                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, &r);
2441         }
2442
2443         if (NT_STATUS_IS_ERR(status)) {
2444                 return status;
2445         }
2446
2447         /* Return variables */
2448         *domains = *r.out.domains;
2449         *names = *r.out.names;
2450         *count = *r.out.count;
2451
2452         /* Return result */
2453         return r.out.result;
2454 }
2455
2456 NTSTATUS rpccli_lsa_LookupNames2(struct rpc_pipe_client *cli,
2457                                  TALLOC_CTX *mem_ctx,
2458                                  struct policy_handle *handle /* [in] [ref] */,
2459                                  uint32_t num_names /* [in] [range(0,1000)] */,
2460                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
2461                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
2462                                  struct lsa_TransSidArray2 *sids /* [in,out] [ref] */,
2463                                  enum lsa_LookupNamesLevel level /* [in]  */,
2464                                  uint32_t *count /* [in,out] [ref] */,
2465                                  uint32_t unknown1 /* [in]  */,
2466                                  uint32_t unknown2 /* [in]  */)
2467 {
2468         struct lsa_LookupNames2 r;
2469         NTSTATUS status;
2470
2471         /* In parameters */
2472         r.in.handle = handle;
2473         r.in.num_names = num_names;
2474         r.in.names = names;
2475         r.in.sids = sids;
2476         r.in.level = level;
2477         r.in.count = count;
2478         r.in.unknown1 = unknown1;
2479         r.in.unknown2 = unknown2;
2480
2481         if (DEBUGLEVEL >= 10) {
2482                 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, &r);
2483         }
2484
2485         status = cli_do_rpc_ndr(cli,
2486                                 mem_ctx,
2487                                 &ndr_table_lsarpc,
2488                                 NDR_LSA_LOOKUPNAMES2,
2489                                 &r);
2490
2491         if (!NT_STATUS_IS_OK(status)) {
2492                 return status;
2493         }
2494
2495         if (DEBUGLEVEL >= 10) {
2496                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, &r);
2497         }
2498
2499         if (NT_STATUS_IS_ERR(status)) {
2500                 return status;
2501         }
2502
2503         /* Return variables */
2504         *domains = *r.out.domains;
2505         *sids = *r.out.sids;
2506         *count = *r.out.count;
2507
2508         /* Return result */
2509         return r.out.result;
2510 }
2511
2512 NTSTATUS rpccli_lsa_CreateTrustedDomainEx2(struct rpc_pipe_client *cli,
2513                                            TALLOC_CTX *mem_ctx)
2514 {
2515         struct lsa_CreateTrustedDomainEx2 r;
2516         NTSTATUS status;
2517
2518         /* In parameters */
2519
2520         if (DEBUGLEVEL >= 10) {
2521                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, &r);
2522         }
2523
2524         status = cli_do_rpc_ndr(cli,
2525                                 mem_ctx,
2526                                 &ndr_table_lsarpc,
2527                                 NDR_LSA_CREATETRUSTEDDOMAINEX2,
2528                                 &r);
2529
2530         if (!NT_STATUS_IS_OK(status)) {
2531                 return status;
2532         }
2533
2534         if (DEBUGLEVEL >= 10) {
2535                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, &r);
2536         }
2537
2538         if (NT_STATUS_IS_ERR(status)) {
2539                 return status;
2540         }
2541
2542         /* Return variables */
2543
2544         /* Return result */
2545         return r.out.result;
2546 }
2547
2548 NTSTATUS rpccli_lsa_CREDRWRITE(struct rpc_pipe_client *cli,
2549                                TALLOC_CTX *mem_ctx)
2550 {
2551         struct lsa_CREDRWRITE r;
2552         NTSTATUS status;
2553
2554         /* In parameters */
2555
2556         if (DEBUGLEVEL >= 10) {
2557                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, &r);
2558         }
2559
2560         status = cli_do_rpc_ndr(cli,
2561                                 mem_ctx,
2562                                 &ndr_table_lsarpc,
2563                                 NDR_LSA_CREDRWRITE,
2564                                 &r);
2565
2566         if (!NT_STATUS_IS_OK(status)) {
2567                 return status;
2568         }
2569
2570         if (DEBUGLEVEL >= 10) {
2571                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, &r);
2572         }
2573
2574         if (NT_STATUS_IS_ERR(status)) {
2575                 return status;
2576         }
2577
2578         /* Return variables */
2579
2580         /* Return result */
2581         return r.out.result;
2582 }
2583
2584 NTSTATUS rpccli_lsa_CREDRREAD(struct rpc_pipe_client *cli,
2585                               TALLOC_CTX *mem_ctx)
2586 {
2587         struct lsa_CREDRREAD r;
2588         NTSTATUS status;
2589
2590         /* In parameters */
2591
2592         if (DEBUGLEVEL >= 10) {
2593                 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, &r);
2594         }
2595
2596         status = cli_do_rpc_ndr(cli,
2597                                 mem_ctx,
2598                                 &ndr_table_lsarpc,
2599                                 NDR_LSA_CREDRREAD,
2600                                 &r);
2601
2602         if (!NT_STATUS_IS_OK(status)) {
2603                 return status;
2604         }
2605
2606         if (DEBUGLEVEL >= 10) {
2607                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, &r);
2608         }
2609
2610         if (NT_STATUS_IS_ERR(status)) {
2611                 return status;
2612         }
2613
2614         /* Return variables */
2615
2616         /* Return result */
2617         return r.out.result;
2618 }
2619
2620 NTSTATUS rpccli_lsa_CREDRENUMERATE(struct rpc_pipe_client *cli,
2621                                    TALLOC_CTX *mem_ctx)
2622 {
2623         struct lsa_CREDRENUMERATE r;
2624         NTSTATUS status;
2625
2626         /* In parameters */
2627
2628         if (DEBUGLEVEL >= 10) {
2629                 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, &r);
2630         }
2631
2632         status = cli_do_rpc_ndr(cli,
2633                                 mem_ctx,
2634                                 &ndr_table_lsarpc,
2635                                 NDR_LSA_CREDRENUMERATE,
2636                                 &r);
2637
2638         if (!NT_STATUS_IS_OK(status)) {
2639                 return status;
2640         }
2641
2642         if (DEBUGLEVEL >= 10) {
2643                 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, &r);
2644         }
2645
2646         if (NT_STATUS_IS_ERR(status)) {
2647                 return status;
2648         }
2649
2650         /* Return variables */
2651
2652         /* Return result */
2653         return r.out.result;
2654 }
2655
2656 NTSTATUS rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS(struct rpc_pipe_client *cli,
2657                                                 TALLOC_CTX *mem_ctx)
2658 {
2659         struct lsa_CREDRWRITEDOMAINCREDENTIALS r;
2660         NTSTATUS status;
2661
2662         /* In parameters */
2663
2664         if (DEBUGLEVEL >= 10) {
2665                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, &r);
2666         }
2667
2668         status = cli_do_rpc_ndr(cli,
2669                                 mem_ctx,
2670                                 &ndr_table_lsarpc,
2671                                 NDR_LSA_CREDRWRITEDOMAINCREDENTIALS,
2672                                 &r);
2673
2674         if (!NT_STATUS_IS_OK(status)) {
2675                 return status;
2676         }
2677
2678         if (DEBUGLEVEL >= 10) {
2679                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, &r);
2680         }
2681
2682         if (NT_STATUS_IS_ERR(status)) {
2683                 return status;
2684         }
2685
2686         /* Return variables */
2687
2688         /* Return result */
2689         return r.out.result;
2690 }
2691
2692 NTSTATUS rpccli_lsa_CREDRREADDOMAINCREDENTIALS(struct rpc_pipe_client *cli,
2693                                                TALLOC_CTX *mem_ctx)
2694 {
2695         struct lsa_CREDRREADDOMAINCREDENTIALS r;
2696         NTSTATUS status;
2697
2698         /* In parameters */
2699
2700         if (DEBUGLEVEL >= 10) {
2701                 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, &r);
2702         }
2703
2704         status = cli_do_rpc_ndr(cli,
2705                                 mem_ctx,
2706                                 &ndr_table_lsarpc,
2707                                 NDR_LSA_CREDRREADDOMAINCREDENTIALS,
2708                                 &r);
2709
2710         if (!NT_STATUS_IS_OK(status)) {
2711                 return status;
2712         }
2713
2714         if (DEBUGLEVEL >= 10) {
2715                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, &r);
2716         }
2717
2718         if (NT_STATUS_IS_ERR(status)) {
2719                 return status;
2720         }
2721
2722         /* Return variables */
2723
2724         /* Return result */
2725         return r.out.result;
2726 }
2727
2728 NTSTATUS rpccli_lsa_CREDRDELETE(struct rpc_pipe_client *cli,
2729                                 TALLOC_CTX *mem_ctx)
2730 {
2731         struct lsa_CREDRDELETE r;
2732         NTSTATUS status;
2733
2734         /* In parameters */
2735
2736         if (DEBUGLEVEL >= 10) {
2737                 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, &r);
2738         }
2739
2740         status = cli_do_rpc_ndr(cli,
2741                                 mem_ctx,
2742                                 &ndr_table_lsarpc,
2743                                 NDR_LSA_CREDRDELETE,
2744                                 &r);
2745
2746         if (!NT_STATUS_IS_OK(status)) {
2747                 return status;
2748         }
2749
2750         if (DEBUGLEVEL >= 10) {
2751                 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, &r);
2752         }
2753
2754         if (NT_STATUS_IS_ERR(status)) {
2755                 return status;
2756         }
2757
2758         /* Return variables */
2759
2760         /* Return result */
2761         return r.out.result;
2762 }
2763
2764 NTSTATUS rpccli_lsa_CREDRGETTARGETINFO(struct rpc_pipe_client *cli,
2765                                        TALLOC_CTX *mem_ctx)
2766 {
2767         struct lsa_CREDRGETTARGETINFO r;
2768         NTSTATUS status;
2769
2770         /* In parameters */
2771
2772         if (DEBUGLEVEL >= 10) {
2773                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, &r);
2774         }
2775
2776         status = cli_do_rpc_ndr(cli,
2777                                 mem_ctx,
2778                                 &ndr_table_lsarpc,
2779                                 NDR_LSA_CREDRGETTARGETINFO,
2780                                 &r);
2781
2782         if (!NT_STATUS_IS_OK(status)) {
2783                 return status;
2784         }
2785
2786         if (DEBUGLEVEL >= 10) {
2787                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, &r);
2788         }
2789
2790         if (NT_STATUS_IS_ERR(status)) {
2791                 return status;
2792         }
2793
2794         /* Return variables */
2795
2796         /* Return result */
2797         return r.out.result;
2798 }
2799
2800 NTSTATUS rpccli_lsa_CREDRPROFILELOADED(struct rpc_pipe_client *cli,
2801                                        TALLOC_CTX *mem_ctx)
2802 {
2803         struct lsa_CREDRPROFILELOADED r;
2804         NTSTATUS status;
2805
2806         /* In parameters */
2807
2808         if (DEBUGLEVEL >= 10) {
2809                 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, &r);
2810         }
2811
2812         status = cli_do_rpc_ndr(cli,
2813                                 mem_ctx,
2814                                 &ndr_table_lsarpc,
2815                                 NDR_LSA_CREDRPROFILELOADED,
2816                                 &r);
2817
2818         if (!NT_STATUS_IS_OK(status)) {
2819                 return status;
2820         }
2821
2822         if (DEBUGLEVEL >= 10) {
2823                 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, &r);
2824         }
2825
2826         if (NT_STATUS_IS_ERR(status)) {
2827                 return status;
2828         }
2829
2830         /* Return variables */
2831
2832         /* Return result */
2833         return r.out.result;
2834 }
2835
2836 NTSTATUS rpccli_lsa_LookupNames3(struct rpc_pipe_client *cli,
2837                                  TALLOC_CTX *mem_ctx,
2838                                  struct policy_handle *handle /* [in] [ref] */,
2839                                  uint32_t num_names /* [in] [range(0,1000)] */,
2840                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
2841                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
2842                                  struct lsa_TransSidArray3 *sids /* [in,out] [ref] */,
2843                                  enum lsa_LookupNamesLevel level /* [in]  */,
2844                                  uint32_t *count /* [in,out] [ref] */,
2845                                  uint32_t unknown1 /* [in]  */,
2846                                  uint32_t unknown2 /* [in]  */)
2847 {
2848         struct lsa_LookupNames3 r;
2849         NTSTATUS status;
2850
2851         /* In parameters */
2852         r.in.handle = handle;
2853         r.in.num_names = num_names;
2854         r.in.names = names;
2855         r.in.sids = sids;
2856         r.in.level = level;
2857         r.in.count = count;
2858         r.in.unknown1 = unknown1;
2859         r.in.unknown2 = unknown2;
2860
2861         if (DEBUGLEVEL >= 10) {
2862                 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, &r);
2863         }
2864
2865         status = cli_do_rpc_ndr(cli,
2866                                 mem_ctx,
2867                                 &ndr_table_lsarpc,
2868                                 NDR_LSA_LOOKUPNAMES3,
2869                                 &r);
2870
2871         if (!NT_STATUS_IS_OK(status)) {
2872                 return status;
2873         }
2874
2875         if (DEBUGLEVEL >= 10) {
2876                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, &r);
2877         }
2878
2879         if (NT_STATUS_IS_ERR(status)) {
2880                 return status;
2881         }
2882
2883         /* Return variables */
2884         *domains = *r.out.domains;
2885         *sids = *r.out.sids;
2886         *count = *r.out.count;
2887
2888         /* Return result */
2889         return r.out.result;
2890 }
2891
2892 NTSTATUS rpccli_lsa_CREDRGETSESSIONTYPES(struct rpc_pipe_client *cli,
2893                                          TALLOC_CTX *mem_ctx)
2894 {
2895         struct lsa_CREDRGETSESSIONTYPES r;
2896         NTSTATUS status;
2897
2898         /* In parameters */
2899
2900         if (DEBUGLEVEL >= 10) {
2901                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, &r);
2902         }
2903
2904         status = cli_do_rpc_ndr(cli,
2905                                 mem_ctx,
2906                                 &ndr_table_lsarpc,
2907                                 NDR_LSA_CREDRGETSESSIONTYPES,
2908                                 &r);
2909
2910         if (!NT_STATUS_IS_OK(status)) {
2911                 return status;
2912         }
2913
2914         if (DEBUGLEVEL >= 10) {
2915                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, &r);
2916         }
2917
2918         if (NT_STATUS_IS_ERR(status)) {
2919                 return status;
2920         }
2921
2922         /* Return variables */
2923
2924         /* Return result */
2925         return r.out.result;
2926 }
2927
2928 NTSTATUS rpccli_lsa_LSARREGISTERAUDITEVENT(struct rpc_pipe_client *cli,
2929                                            TALLOC_CTX *mem_ctx)
2930 {
2931         struct lsa_LSARREGISTERAUDITEVENT r;
2932         NTSTATUS status;
2933
2934         /* In parameters */
2935
2936         if (DEBUGLEVEL >= 10) {
2937                 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, &r);
2938         }
2939
2940         status = cli_do_rpc_ndr(cli,
2941                                 mem_ctx,
2942                                 &ndr_table_lsarpc,
2943                                 NDR_LSA_LSARREGISTERAUDITEVENT,
2944                                 &r);
2945
2946         if (!NT_STATUS_IS_OK(status)) {
2947                 return status;
2948         }
2949
2950         if (DEBUGLEVEL >= 10) {
2951                 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, &r);
2952         }
2953
2954         if (NT_STATUS_IS_ERR(status)) {
2955                 return status;
2956         }
2957
2958         /* Return variables */
2959
2960         /* Return result */
2961         return r.out.result;
2962 }
2963
2964 NTSTATUS rpccli_lsa_LSARGENAUDITEVENT(struct rpc_pipe_client *cli,
2965                                       TALLOC_CTX *mem_ctx)
2966 {
2967         struct lsa_LSARGENAUDITEVENT r;
2968         NTSTATUS status;
2969
2970         /* In parameters */
2971
2972         if (DEBUGLEVEL >= 10) {
2973                 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, &r);
2974         }
2975
2976         status = cli_do_rpc_ndr(cli,
2977                                 mem_ctx,
2978                                 &ndr_table_lsarpc,
2979                                 NDR_LSA_LSARGENAUDITEVENT,
2980                                 &r);
2981
2982         if (!NT_STATUS_IS_OK(status)) {
2983                 return status;
2984         }
2985
2986         if (DEBUGLEVEL >= 10) {
2987                 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, &r);
2988         }
2989
2990         if (NT_STATUS_IS_ERR(status)) {
2991                 return status;
2992         }
2993
2994         /* Return variables */
2995
2996         /* Return result */
2997         return r.out.result;
2998 }
2999
3000 NTSTATUS rpccli_lsa_LSARUNREGISTERAUDITEVENT(struct rpc_pipe_client *cli,
3001                                              TALLOC_CTX *mem_ctx)
3002 {
3003         struct lsa_LSARUNREGISTERAUDITEVENT r;
3004         NTSTATUS status;
3005
3006         /* In parameters */
3007
3008         if (DEBUGLEVEL >= 10) {
3009                 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, &r);
3010         }
3011
3012         status = cli_do_rpc_ndr(cli,
3013                                 mem_ctx,
3014                                 &ndr_table_lsarpc,
3015                                 NDR_LSA_LSARUNREGISTERAUDITEVENT,
3016                                 &r);
3017
3018         if (!NT_STATUS_IS_OK(status)) {
3019                 return status;
3020         }
3021
3022         if (DEBUGLEVEL >= 10) {
3023                 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, &r);
3024         }
3025
3026         if (NT_STATUS_IS_ERR(status)) {
3027                 return status;
3028         }
3029
3030         /* Return variables */
3031
3032         /* Return result */
3033         return r.out.result;
3034 }
3035
3036 NTSTATUS rpccli_lsa_lsaRQueryForestTrustInformation(struct rpc_pipe_client *cli,
3037                                                     TALLOC_CTX *mem_ctx,
3038                                                     struct policy_handle *handle /* [in] [ref] */,
3039                                                     struct lsa_String *trusted_domain_name /* [in] [ref] */,
3040                                                     uint16_t unknown /* [in]  */,
3041                                                     struct lsa_ForestTrustInformation **forest_trust_info /* [out] [ref] */)
3042 {
3043         struct lsa_lsaRQueryForestTrustInformation r;
3044         NTSTATUS status;
3045
3046         /* In parameters */
3047         r.in.handle = handle;
3048         r.in.trusted_domain_name = trusted_domain_name;
3049         r.in.unknown = unknown;
3050
3051         if (DEBUGLEVEL >= 10) {
3052                 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, &r);
3053         }
3054
3055         status = cli_do_rpc_ndr(cli,
3056                                 mem_ctx,
3057                                 &ndr_table_lsarpc,
3058                                 NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION,
3059                                 &r);
3060
3061         if (!NT_STATUS_IS_OK(status)) {
3062                 return status;
3063         }
3064
3065         if (DEBUGLEVEL >= 10) {
3066                 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation, &r);
3067         }
3068
3069         if (NT_STATUS_IS_ERR(status)) {
3070                 return status;
3071         }
3072
3073         /* Return variables */
3074         *forest_trust_info = *r.out.forest_trust_info;
3075
3076         /* Return result */
3077         return r.out.result;
3078 }
3079
3080 NTSTATUS rpccli_lsa_LSARSETFORESTTRUSTINFORMATION(struct rpc_pipe_client *cli,
3081                                                   TALLOC_CTX *mem_ctx)
3082 {
3083         struct lsa_LSARSETFORESTTRUSTINFORMATION r;
3084         NTSTATUS status;
3085
3086         /* In parameters */
3087
3088         if (DEBUGLEVEL >= 10) {
3089                 NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, &r);
3090         }
3091
3092         status = cli_do_rpc_ndr(cli,
3093                                 mem_ctx,
3094                                 &ndr_table_lsarpc,
3095                                 NDR_LSA_LSARSETFORESTTRUSTINFORMATION,
3096                                 &r);
3097
3098         if (!NT_STATUS_IS_OK(status)) {
3099                 return status;
3100         }
3101
3102         if (DEBUGLEVEL >= 10) {
3103                 NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, &r);
3104         }
3105
3106         if (NT_STATUS_IS_ERR(status)) {
3107                 return status;
3108         }
3109
3110         /* Return variables */
3111
3112         /* Return result */
3113         return r.out.result;
3114 }
3115
3116 NTSTATUS rpccli_lsa_CREDRRENAME(struct rpc_pipe_client *cli,
3117                                 TALLOC_CTX *mem_ctx)
3118 {
3119         struct lsa_CREDRRENAME r;
3120         NTSTATUS status;
3121
3122         /* In parameters */
3123
3124         if (DEBUGLEVEL >= 10) {
3125                 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, &r);
3126         }
3127
3128         status = cli_do_rpc_ndr(cli,
3129                                 mem_ctx,
3130                                 &ndr_table_lsarpc,
3131                                 NDR_LSA_CREDRRENAME,
3132                                 &r);
3133
3134         if (!NT_STATUS_IS_OK(status)) {
3135                 return status;
3136         }
3137
3138         if (DEBUGLEVEL >= 10) {
3139                 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, &r);
3140         }
3141
3142         if (NT_STATUS_IS_ERR(status)) {
3143                 return status;
3144         }
3145
3146         /* Return variables */
3147
3148         /* Return result */
3149         return r.out.result;
3150 }
3151
3152 NTSTATUS rpccli_lsa_LookupSids3(struct rpc_pipe_client *cli,
3153                                 TALLOC_CTX *mem_ctx,
3154                                 struct lsa_SidArray *sids /* [in] [ref] */,
3155                                 struct lsa_RefDomainList **domains /* [out] [ref] */,
3156                                 struct lsa_TransNameArray2 *names /* [in,out] [ref] */,
3157                                 uint16_t level /* [in]  */,
3158                                 uint32_t *count /* [in,out] [ref] */,
3159                                 uint32_t unknown1 /* [in]  */,
3160                                 uint32_t unknown2 /* [in]  */)
3161 {
3162         struct lsa_LookupSids3 r;
3163         NTSTATUS status;
3164
3165         /* In parameters */
3166         r.in.sids = sids;
3167         r.in.names = names;
3168         r.in.level = level;
3169         r.in.count = count;
3170         r.in.unknown1 = unknown1;
3171         r.in.unknown2 = unknown2;
3172
3173         if (DEBUGLEVEL >= 10) {
3174                 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, &r);
3175         }
3176
3177         status = cli_do_rpc_ndr(cli,
3178                                 mem_ctx,
3179                                 &ndr_table_lsarpc,
3180                                 NDR_LSA_LOOKUPSIDS3,
3181                                 &r);
3182
3183         if (!NT_STATUS_IS_OK(status)) {
3184                 return status;
3185         }
3186
3187         if (DEBUGLEVEL >= 10) {
3188                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, &r);
3189         }
3190
3191         if (NT_STATUS_IS_ERR(status)) {
3192                 return status;
3193         }
3194
3195         /* Return variables */
3196         *domains = *r.out.domains;
3197         *names = *r.out.names;
3198         *count = *r.out.count;
3199
3200         /* Return result */
3201         return r.out.result;
3202 }
3203
3204 NTSTATUS rpccli_lsa_LookupNames4(struct rpc_pipe_client *cli,
3205                                  TALLOC_CTX *mem_ctx,
3206                                  uint32_t num_names /* [in] [range(0,1000)] */,
3207                                  struct lsa_String *names /* [in] [size_is(num_names)] */,
3208                                  struct lsa_RefDomainList **domains /* [out] [ref] */,
3209                                  struct lsa_TransSidArray3 *sids /* [in,out] [ref] */,
3210                                  enum lsa_LookupNamesLevel level /* [in]  */,
3211                                  uint32_t *count /* [in,out] [ref] */,
3212                                  uint32_t unknown1 /* [in]  */,
3213                                  uint32_t unknown2 /* [in]  */)
3214 {
3215         struct lsa_LookupNames4 r;
3216         NTSTATUS status;
3217
3218         /* In parameters */
3219         r.in.num_names = num_names;
3220         r.in.names = names;
3221         r.in.sids = sids;
3222         r.in.level = level;
3223         r.in.count = count;
3224         r.in.unknown1 = unknown1;
3225         r.in.unknown2 = unknown2;
3226
3227         if (DEBUGLEVEL >= 10) {
3228                 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, &r);
3229         }
3230
3231         status = cli_do_rpc_ndr(cli,
3232                                 mem_ctx,
3233                                 &ndr_table_lsarpc,
3234                                 NDR_LSA_LOOKUPNAMES4,
3235                                 &r);
3236
3237         if (!NT_STATUS_IS_OK(status)) {
3238                 return status;
3239         }
3240
3241         if (DEBUGLEVEL >= 10) {
3242                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, &r);
3243         }
3244
3245         if (NT_STATUS_IS_ERR(status)) {
3246                 return status;
3247         }
3248
3249         /* Return variables */
3250         *domains = *r.out.domains;
3251         *sids = *r.out.sids;
3252         *count = *r.out.count;
3253
3254         /* Return result */
3255         return r.out.result;
3256 }
3257
3258 NTSTATUS rpccli_lsa_LSAROPENPOLICYSCE(struct rpc_pipe_client *cli,
3259                                       TALLOC_CTX *mem_ctx)
3260 {
3261         struct lsa_LSAROPENPOLICYSCE r;
3262         NTSTATUS status;
3263
3264         /* In parameters */
3265
3266         if (DEBUGLEVEL >= 10) {
3267                 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, &r);
3268         }
3269
3270         status = cli_do_rpc_ndr(cli,
3271                                 mem_ctx,
3272                                 &ndr_table_lsarpc,
3273                                 NDR_LSA_LSAROPENPOLICYSCE,
3274                                 &r);
3275
3276         if (!NT_STATUS_IS_OK(status)) {
3277                 return status;
3278         }
3279
3280         if (DEBUGLEVEL >= 10) {
3281                 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, &r);
3282         }
3283
3284         if (NT_STATUS_IS_ERR(status)) {
3285                 return status;
3286         }
3287
3288         /* Return variables */
3289
3290         /* Return result */
3291         return r.out.result;
3292 }
3293
3294 NTSTATUS rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli,
3295                                                        TALLOC_CTX *mem_ctx)
3296 {
3297         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE r;
3298         NTSTATUS status;
3299
3300         /* In parameters */
3301
3302         if (DEBUGLEVEL >= 10) {
3303                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &r);
3304         }
3305
3306         status = cli_do_rpc_ndr(cli,
3307                                 mem_ctx,
3308                                 &ndr_table_lsarpc,
3309                                 NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE,
3310                                 &r);
3311
3312         if (!NT_STATUS_IS_OK(status)) {
3313                 return status;
3314         }
3315
3316         if (DEBUGLEVEL >= 10) {
3317                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &r);
3318         }
3319
3320         if (NT_STATUS_IS_ERR(status)) {
3321                 return status;
3322         }
3323
3324         /* Return variables */
3325
3326         /* Return result */
3327         return r.out.result;
3328 }
3329
3330 NTSTATUS rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli,
3331                                                          TALLOC_CTX *mem_ctx)
3332 {
3333         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE r;
3334         NTSTATUS status;
3335
3336         /* In parameters */
3337
3338         if (DEBUGLEVEL >= 10) {
3339                 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &r);
3340         }
3341
3342         status = cli_do_rpc_ndr(cli,
3343                                 mem_ctx,
3344                                 &ndr_table_lsarpc,
3345                                 NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE,
3346                                 &r);
3347
3348         if (!NT_STATUS_IS_OK(status)) {
3349                 return status;
3350         }
3351
3352         if (DEBUGLEVEL >= 10) {
3353                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &r);
3354         }
3355
3356         if (NT_STATUS_IS_ERR(status)) {
3357                 return status;
3358         }
3359
3360         /* Return variables */
3361
3362         /* Return result */
3363         return r.out.result;
3364 }
3365
3366 NTSTATUS rpccli_lsa_LSARADTREPORTSECURITYEVENT(struct rpc_pipe_client *cli,
3367                                                TALLOC_CTX *mem_ctx)
3368 {
3369         struct lsa_LSARADTREPORTSECURITYEVENT r;
3370         NTSTATUS status;
3371
3372         /* In parameters */
3373
3374         if (DEBUGLEVEL >= 10) {
3375                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, &r);
3376         }
3377
3378         status = cli_do_rpc_ndr(cli,
3379                                 mem_ctx,
3380                                 &ndr_table_lsarpc,
3381                                 NDR_LSA_LSARADTREPORTSECURITYEVENT,
3382                                 &r);
3383
3384         if (!NT_STATUS_IS_OK(status)) {
3385                 return status;
3386         }
3387
3388         if (DEBUGLEVEL >= 10) {
3389                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, &r);
3390         }
3391
3392         if (NT_STATUS_IS_ERR(status)) {
3393                 return status;
3394         }
3395
3396         /* Return variables */
3397
3398         /* Return result */
3399         return r.out.result;
3400 }
3401