root/librpc/gen_ndr/cli_lsa.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. rpccli_lsa_Close
  2. rpccli_lsa_Delete
  3. rpccli_lsa_EnumPrivs
  4. rpccli_lsa_QuerySecurity
  5. rpccli_lsa_SetSecObj
  6. rpccli_lsa_ChangePassword
  7. rpccli_lsa_OpenPolicy
  8. rpccli_lsa_QueryInfoPolicy
  9. rpccli_lsa_SetInfoPolicy
  10. rpccli_lsa_ClearAuditLog
  11. rpccli_lsa_CreateAccount
  12. rpccli_lsa_EnumAccounts
  13. rpccli_lsa_CreateTrustedDomain
  14. rpccli_lsa_EnumTrustDom
  15. rpccli_lsa_LookupNames
  16. rpccli_lsa_LookupSids
  17. rpccli_lsa_CreateSecret
  18. rpccli_lsa_OpenAccount
  19. rpccli_lsa_EnumPrivsAccount
  20. rpccli_lsa_AddPrivilegesToAccount
  21. rpccli_lsa_RemovePrivilegesFromAccount
  22. rpccli_lsa_GetQuotasForAccount
  23. rpccli_lsa_SetQuotasForAccount
  24. rpccli_lsa_GetSystemAccessAccount
  25. rpccli_lsa_SetSystemAccessAccount
  26. rpccli_lsa_OpenTrustedDomain
  27. rpccli_lsa_QueryTrustedDomainInfo
  28. rpccli_lsa_SetInformationTrustedDomain
  29. rpccli_lsa_OpenSecret
  30. rpccli_lsa_SetSecret
  31. rpccli_lsa_QuerySecret
  32. rpccli_lsa_LookupPrivValue
  33. rpccli_lsa_LookupPrivName
  34. rpccli_lsa_LookupPrivDisplayName
  35. rpccli_lsa_DeleteObject
  36. rpccli_lsa_EnumAccountsWithUserRight
  37. rpccli_lsa_EnumAccountRights
  38. rpccli_lsa_AddAccountRights
  39. rpccli_lsa_RemoveAccountRights
  40. rpccli_lsa_QueryTrustedDomainInfoBySid
  41. rpccli_lsa_SetTrustedDomainInfo
  42. rpccli_lsa_DeleteTrustedDomain
  43. rpccli_lsa_StorePrivateData
  44. rpccli_lsa_RetrievePrivateData
  45. rpccli_lsa_OpenPolicy2
  46. rpccli_lsa_GetUserName
  47. rpccli_lsa_QueryInfoPolicy2
  48. rpccli_lsa_SetInfoPolicy2
  49. rpccli_lsa_QueryTrustedDomainInfoByName
  50. rpccli_lsa_SetTrustedDomainInfoByName
  51. rpccli_lsa_EnumTrustedDomainsEx
  52. rpccli_lsa_CreateTrustedDomainEx
  53. rpccli_lsa_CloseTrustedDomainEx
  54. rpccli_lsa_QueryDomainInformationPolicy
  55. rpccli_lsa_SetDomainInformationPolicy
  56. rpccli_lsa_OpenTrustedDomainByName
  57. rpccli_lsa_TestCall
  58. rpccli_lsa_LookupSids2
  59. rpccli_lsa_LookupNames2
  60. rpccli_lsa_CreateTrustedDomainEx2
  61. rpccli_lsa_CREDRWRITE
  62. rpccli_lsa_CREDRREAD
  63. rpccli_lsa_CREDRENUMERATE
  64. rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS
  65. rpccli_lsa_CREDRREADDOMAINCREDENTIALS
  66. rpccli_lsa_CREDRDELETE
  67. rpccli_lsa_CREDRGETTARGETINFO
  68. rpccli_lsa_CREDRPROFILELOADED
  69. rpccli_lsa_LookupNames3
  70. rpccli_lsa_CREDRGETSESSIONTYPES
  71. rpccli_lsa_LSARREGISTERAUDITEVENT
  72. rpccli_lsa_LSARGENAUDITEVENT
  73. rpccli_lsa_LSARUNREGISTERAUDITEVENT
  74. rpccli_lsa_lsaRQueryForestTrustInformation
  75. rpccli_lsa_LSARSETFORESTTRUSTINFORMATION
  76. rpccli_lsa_CREDRRENAME
  77. rpccli_lsa_LookupSids3
  78. rpccli_lsa_LookupNames4
  79. rpccli_lsa_LSAROPENPOLICYSCE
  80. rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE
  81. rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
  82. rpccli_lsa_LSARADTREPORTSECURITYEVENT

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

/* [<][>][^][v][top][bottom][index][help] */