root/librpc/gen_ndr/srv_lsa.c

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

DEFINITIONS

This source file includes following definitions.
  1. api_lsa_Close
  2. api_lsa_Delete
  3. api_lsa_EnumPrivs
  4. api_lsa_QuerySecurity
  5. api_lsa_SetSecObj
  6. api_lsa_ChangePassword
  7. api_lsa_OpenPolicy
  8. api_lsa_QueryInfoPolicy
  9. api_lsa_SetInfoPolicy
  10. api_lsa_ClearAuditLog
  11. api_lsa_CreateAccount
  12. api_lsa_EnumAccounts
  13. api_lsa_CreateTrustedDomain
  14. api_lsa_EnumTrustDom
  15. api_lsa_LookupNames
  16. api_lsa_LookupSids
  17. api_lsa_CreateSecret
  18. api_lsa_OpenAccount
  19. api_lsa_EnumPrivsAccount
  20. api_lsa_AddPrivilegesToAccount
  21. api_lsa_RemovePrivilegesFromAccount
  22. api_lsa_GetQuotasForAccount
  23. api_lsa_SetQuotasForAccount
  24. api_lsa_GetSystemAccessAccount
  25. api_lsa_SetSystemAccessAccount
  26. api_lsa_OpenTrustedDomain
  27. api_lsa_QueryTrustedDomainInfo
  28. api_lsa_SetInformationTrustedDomain
  29. api_lsa_OpenSecret
  30. api_lsa_SetSecret
  31. api_lsa_QuerySecret
  32. api_lsa_LookupPrivValue
  33. api_lsa_LookupPrivName
  34. api_lsa_LookupPrivDisplayName
  35. api_lsa_DeleteObject
  36. api_lsa_EnumAccountsWithUserRight
  37. api_lsa_EnumAccountRights
  38. api_lsa_AddAccountRights
  39. api_lsa_RemoveAccountRights
  40. api_lsa_QueryTrustedDomainInfoBySid
  41. api_lsa_SetTrustedDomainInfo
  42. api_lsa_DeleteTrustedDomain
  43. api_lsa_StorePrivateData
  44. api_lsa_RetrievePrivateData
  45. api_lsa_OpenPolicy2
  46. api_lsa_GetUserName
  47. api_lsa_QueryInfoPolicy2
  48. api_lsa_SetInfoPolicy2
  49. api_lsa_QueryTrustedDomainInfoByName
  50. api_lsa_SetTrustedDomainInfoByName
  51. api_lsa_EnumTrustedDomainsEx
  52. api_lsa_CreateTrustedDomainEx
  53. api_lsa_CloseTrustedDomainEx
  54. api_lsa_QueryDomainInformationPolicy
  55. api_lsa_SetDomainInformationPolicy
  56. api_lsa_OpenTrustedDomainByName
  57. api_lsa_TestCall
  58. api_lsa_LookupSids2
  59. api_lsa_LookupNames2
  60. api_lsa_CreateTrustedDomainEx2
  61. api_lsa_CREDRWRITE
  62. api_lsa_CREDRREAD
  63. api_lsa_CREDRENUMERATE
  64. api_lsa_CREDRWRITEDOMAINCREDENTIALS
  65. api_lsa_CREDRREADDOMAINCREDENTIALS
  66. api_lsa_CREDRDELETE
  67. api_lsa_CREDRGETTARGETINFO
  68. api_lsa_CREDRPROFILELOADED
  69. api_lsa_LookupNames3
  70. api_lsa_CREDRGETSESSIONTYPES
  71. api_lsa_LSARREGISTERAUDITEVENT
  72. api_lsa_LSARGENAUDITEVENT
  73. api_lsa_LSARUNREGISTERAUDITEVENT
  74. api_lsa_lsaRQueryForestTrustInformation
  75. api_lsa_LSARSETFORESTTRUSTINFORMATION
  76. api_lsa_CREDRRENAME
  77. api_lsa_LookupSids3
  78. api_lsa_LookupNames4
  79. api_lsa_LSAROPENPOLICYSCE
  80. api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE
  81. api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
  82. api_lsa_LSARADTREPORTSECURITYEVENT
  83. lsarpc_get_pipe_fns
  84. rpc_lsarpc_dispatch
  85. rpc_lsarpc_init

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5 
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/srv_lsa.h"
   8 
   9 static bool api_lsa_Close(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         enum ndr_err_code ndr_err;
  15         DATA_BLOB blob;
  16         struct lsa_Close *r;
  17 
  18         call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSE];
  19 
  20         r = talloc(talloc_tos(), struct lsa_Close);
  21         if (r == NULL) {
  22                 return false;
  23         }
  24 
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return false;
  28         }
  29 
  30         pull = ndr_pull_init_blob(&blob, r, NULL);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return false;
  34         }
  35 
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  39                 talloc_free(r);
  40                 return false;
  41         }
  42 
  43         if (DEBUGLEVEL >= 10) {
  44                 NDR_PRINT_IN_DEBUG(lsa_Close, r);
  45         }
  46 
  47         ZERO_STRUCT(r->out);
  48         r->out.handle = r->in.handle;
  49         r->out.result = _lsa_Close(p, r);
  50 
  51         if (p->rng_fault_state) {
  52                 talloc_free(r);
  53                 /* Return true here, srv_pipe_hnd.c will take care */
  54                 return true;
  55         }
  56 
  57         if (DEBUGLEVEL >= 10) {
  58                 NDR_PRINT_OUT_DEBUG(lsa_Close, r);
  59         }
  60 
  61         push = ndr_push_init_ctx(r, NULL);
  62         if (push == NULL) {
  63                 talloc_free(r);
  64                 return false;
  65         }
  66 
  67         ndr_err = call->ndr_push(push, NDR_OUT, r);
  68         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  69                 talloc_free(r);
  70                 return false;
  71         }
  72 
  73         blob = ndr_push_blob(push);
  74         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  75                 talloc_free(r);
  76                 return false;
  77         }
  78 
  79         talloc_free(r);
  80 
  81         return true;
  82 }
  83 
  84 static bool api_lsa_Delete(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  85 {
  86         const struct ndr_interface_call *call;
  87         struct ndr_pull *pull;
  88         struct ndr_push *push;
  89         enum ndr_err_code ndr_err;
  90         DATA_BLOB blob;
  91         struct lsa_Delete *r;
  92 
  93         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETE];
  94 
  95         r = talloc(talloc_tos(), struct lsa_Delete);
  96         if (r == NULL) {
  97                 return false;
  98         }
  99 
 100         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 101                 talloc_free(r);
 102                 return false;
 103         }
 104 
 105         pull = ndr_pull_init_blob(&blob, r, NULL);
 106         if (pull == NULL) {
 107                 talloc_free(r);
 108                 return false;
 109         }
 110 
 111         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 112         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 113         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 114                 talloc_free(r);
 115                 return false;
 116         }
 117 
 118         if (DEBUGLEVEL >= 10) {
 119                 NDR_PRINT_IN_DEBUG(lsa_Delete, r);
 120         }
 121 
 122         r->out.result = _lsa_Delete(p, r);
 123 
 124         if (p->rng_fault_state) {
 125                 talloc_free(r);
 126                 /* Return true here, srv_pipe_hnd.c will take care */
 127                 return true;
 128         }
 129 
 130         if (DEBUGLEVEL >= 10) {
 131                 NDR_PRINT_OUT_DEBUG(lsa_Delete, r);
 132         }
 133 
 134         push = ndr_push_init_ctx(r, NULL);
 135         if (push == NULL) {
 136                 talloc_free(r);
 137                 return false;
 138         }
 139 
 140         ndr_err = call->ndr_push(push, NDR_OUT, r);
 141         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 142                 talloc_free(r);
 143                 return false;
 144         }
 145 
 146         blob = ndr_push_blob(push);
 147         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 148                 talloc_free(r);
 149                 return false;
 150         }
 151 
 152         talloc_free(r);
 153 
 154         return true;
 155 }
 156 
 157 static bool api_lsa_EnumPrivs(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 158 {
 159         const struct ndr_interface_call *call;
 160         struct ndr_pull *pull;
 161         struct ndr_push *push;
 162         enum ndr_err_code ndr_err;
 163         DATA_BLOB blob;
 164         struct lsa_EnumPrivs *r;
 165 
 166         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVS];
 167 
 168         r = talloc(talloc_tos(), struct lsa_EnumPrivs);
 169         if (r == NULL) {
 170                 return false;
 171         }
 172 
 173         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 174                 talloc_free(r);
 175                 return false;
 176         }
 177 
 178         pull = ndr_pull_init_blob(&blob, r, NULL);
 179         if (pull == NULL) {
 180                 talloc_free(r);
 181                 return false;
 182         }
 183 
 184         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 185         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 186         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 187                 talloc_free(r);
 188                 return false;
 189         }
 190 
 191         if (DEBUGLEVEL >= 10) {
 192                 NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, r);
 193         }
 194 
 195         ZERO_STRUCT(r->out);
 196         r->out.resume_handle = r->in.resume_handle;
 197         r->out.privs = talloc_zero(r, struct lsa_PrivArray);
 198         if (r->out.privs == NULL) {
 199                 talloc_free(r);
 200                 return false;
 201         }
 202 
 203         r->out.result = _lsa_EnumPrivs(p, r);
 204 
 205         if (p->rng_fault_state) {
 206                 talloc_free(r);
 207                 /* Return true here, srv_pipe_hnd.c will take care */
 208                 return true;
 209         }
 210 
 211         if (DEBUGLEVEL >= 10) {
 212                 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, r);
 213         }
 214 
 215         push = ndr_push_init_ctx(r, NULL);
 216         if (push == NULL) {
 217                 talloc_free(r);
 218                 return false;
 219         }
 220 
 221         ndr_err = call->ndr_push(push, NDR_OUT, r);
 222         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 223                 talloc_free(r);
 224                 return false;
 225         }
 226 
 227         blob = ndr_push_blob(push);
 228         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 229                 talloc_free(r);
 230                 return false;
 231         }
 232 
 233         talloc_free(r);
 234 
 235         return true;
 236 }
 237 
 238 static bool api_lsa_QuerySecurity(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 239 {
 240         const struct ndr_interface_call *call;
 241         struct ndr_pull *pull;
 242         struct ndr_push *push;
 243         enum ndr_err_code ndr_err;
 244         DATA_BLOB blob;
 245         struct lsa_QuerySecurity *r;
 246 
 247         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECURITY];
 248 
 249         r = talloc(talloc_tos(), struct lsa_QuerySecurity);
 250         if (r == NULL) {
 251                 return false;
 252         }
 253 
 254         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 255                 talloc_free(r);
 256                 return false;
 257         }
 258 
 259         pull = ndr_pull_init_blob(&blob, r, NULL);
 260         if (pull == NULL) {
 261                 talloc_free(r);
 262                 return false;
 263         }
 264 
 265         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 266         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 267         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 268                 talloc_free(r);
 269                 return false;
 270         }
 271 
 272         if (DEBUGLEVEL >= 10) {
 273                 NDR_PRINT_IN_DEBUG(lsa_QuerySecurity, r);
 274         }
 275 
 276         ZERO_STRUCT(r->out);
 277         r->out.sdbuf = talloc_zero(r, struct sec_desc_buf *);
 278         if (r->out.sdbuf == NULL) {
 279                 talloc_free(r);
 280                 return false;
 281         }
 282 
 283         r->out.result = _lsa_QuerySecurity(p, r);
 284 
 285         if (p->rng_fault_state) {
 286                 talloc_free(r);
 287                 /* Return true here, srv_pipe_hnd.c will take care */
 288                 return true;
 289         }
 290 
 291         if (DEBUGLEVEL >= 10) {
 292                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, r);
 293         }
 294 
 295         push = ndr_push_init_ctx(r, NULL);
 296         if (push == NULL) {
 297                 talloc_free(r);
 298                 return false;
 299         }
 300 
 301         ndr_err = call->ndr_push(push, NDR_OUT, r);
 302         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 303                 talloc_free(r);
 304                 return false;
 305         }
 306 
 307         blob = ndr_push_blob(push);
 308         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 309                 talloc_free(r);
 310                 return false;
 311         }
 312 
 313         talloc_free(r);
 314 
 315         return true;
 316 }
 317 
 318 static bool api_lsa_SetSecObj(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 319 {
 320         const struct ndr_interface_call *call;
 321         struct ndr_pull *pull;
 322         struct ndr_push *push;
 323         enum ndr_err_code ndr_err;
 324         DATA_BLOB blob;
 325         struct lsa_SetSecObj *r;
 326 
 327         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECOBJ];
 328 
 329         r = talloc(talloc_tos(), struct lsa_SetSecObj);
 330         if (r == NULL) {
 331                 return false;
 332         }
 333 
 334         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 335                 talloc_free(r);
 336                 return false;
 337         }
 338 
 339         pull = ndr_pull_init_blob(&blob, r, NULL);
 340         if (pull == NULL) {
 341                 talloc_free(r);
 342                 return false;
 343         }
 344 
 345         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 346         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 347         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 348                 talloc_free(r);
 349                 return false;
 350         }
 351 
 352         if (DEBUGLEVEL >= 10) {
 353                 NDR_PRINT_IN_DEBUG(lsa_SetSecObj, r);
 354         }
 355 
 356         r->out.result = _lsa_SetSecObj(p, r);
 357 
 358         if (p->rng_fault_state) {
 359                 talloc_free(r);
 360                 /* Return true here, srv_pipe_hnd.c will take care */
 361                 return true;
 362         }
 363 
 364         if (DEBUGLEVEL >= 10) {
 365                 NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, r);
 366         }
 367 
 368         push = ndr_push_init_ctx(r, NULL);
 369         if (push == NULL) {
 370                 talloc_free(r);
 371                 return false;
 372         }
 373 
 374         ndr_err = call->ndr_push(push, NDR_OUT, r);
 375         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 376                 talloc_free(r);
 377                 return false;
 378         }
 379 
 380         blob = ndr_push_blob(push);
 381         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 382                 talloc_free(r);
 383                 return false;
 384         }
 385 
 386         talloc_free(r);
 387 
 388         return true;
 389 }
 390 
 391 static bool api_lsa_ChangePassword(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 392 {
 393         const struct ndr_interface_call *call;
 394         struct ndr_pull *pull;
 395         struct ndr_push *push;
 396         enum ndr_err_code ndr_err;
 397         DATA_BLOB blob;
 398         struct lsa_ChangePassword *r;
 399 
 400         call = &ndr_table_lsarpc.calls[NDR_LSA_CHANGEPASSWORD];
 401 
 402         r = talloc(talloc_tos(), struct lsa_ChangePassword);
 403         if (r == NULL) {
 404                 return false;
 405         }
 406 
 407         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 408                 talloc_free(r);
 409                 return false;
 410         }
 411 
 412         pull = ndr_pull_init_blob(&blob, r, NULL);
 413         if (pull == NULL) {
 414                 talloc_free(r);
 415                 return false;
 416         }
 417 
 418         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 419         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 420         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 421                 talloc_free(r);
 422                 return false;
 423         }
 424 
 425         if (DEBUGLEVEL >= 10) {
 426                 NDR_PRINT_IN_DEBUG(lsa_ChangePassword, r);
 427         }
 428 
 429         r->out.result = _lsa_ChangePassword(p, r);
 430 
 431         if (p->rng_fault_state) {
 432                 talloc_free(r);
 433                 /* Return true here, srv_pipe_hnd.c will take care */
 434                 return true;
 435         }
 436 
 437         if (DEBUGLEVEL >= 10) {
 438                 NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, r);
 439         }
 440 
 441         push = ndr_push_init_ctx(r, NULL);
 442         if (push == NULL) {
 443                 talloc_free(r);
 444                 return false;
 445         }
 446 
 447         ndr_err = call->ndr_push(push, NDR_OUT, r);
 448         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 449                 talloc_free(r);
 450                 return false;
 451         }
 452 
 453         blob = ndr_push_blob(push);
 454         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 455                 talloc_free(r);
 456                 return false;
 457         }
 458 
 459         talloc_free(r);
 460 
 461         return true;
 462 }
 463 
 464 static bool api_lsa_OpenPolicy(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 465 {
 466         const struct ndr_interface_call *call;
 467         struct ndr_pull *pull;
 468         struct ndr_push *push;
 469         enum ndr_err_code ndr_err;
 470         DATA_BLOB blob;
 471         struct lsa_OpenPolicy *r;
 472 
 473         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY];
 474 
 475         r = talloc(talloc_tos(), struct lsa_OpenPolicy);
 476         if (r == NULL) {
 477                 return false;
 478         }
 479 
 480         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 481                 talloc_free(r);
 482                 return false;
 483         }
 484 
 485         pull = ndr_pull_init_blob(&blob, r, NULL);
 486         if (pull == NULL) {
 487                 talloc_free(r);
 488                 return false;
 489         }
 490 
 491         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 492         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 493         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 494                 talloc_free(r);
 495                 return false;
 496         }
 497 
 498         if (DEBUGLEVEL >= 10) {
 499                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, r);
 500         }
 501 
 502         ZERO_STRUCT(r->out);
 503         r->out.handle = talloc_zero(r, struct policy_handle);
 504         if (r->out.handle == NULL) {
 505                 talloc_free(r);
 506                 return false;
 507         }
 508 
 509         r->out.result = _lsa_OpenPolicy(p, r);
 510 
 511         if (p->rng_fault_state) {
 512                 talloc_free(r);
 513                 /* Return true here, srv_pipe_hnd.c will take care */
 514                 return true;
 515         }
 516 
 517         if (DEBUGLEVEL >= 10) {
 518                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, r);
 519         }
 520 
 521         push = ndr_push_init_ctx(r, NULL);
 522         if (push == NULL) {
 523                 talloc_free(r);
 524                 return false;
 525         }
 526 
 527         ndr_err = call->ndr_push(push, NDR_OUT, r);
 528         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 529                 talloc_free(r);
 530                 return false;
 531         }
 532 
 533         blob = ndr_push_blob(push);
 534         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 535                 talloc_free(r);
 536                 return false;
 537         }
 538 
 539         talloc_free(r);
 540 
 541         return true;
 542 }
 543 
 544 static bool api_lsa_QueryInfoPolicy(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 545 {
 546         const struct ndr_interface_call *call;
 547         struct ndr_pull *pull;
 548         struct ndr_push *push;
 549         enum ndr_err_code ndr_err;
 550         DATA_BLOB blob;
 551         struct lsa_QueryInfoPolicy *r;
 552 
 553         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY];
 554 
 555         r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy);
 556         if (r == NULL) {
 557                 return false;
 558         }
 559 
 560         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 561                 talloc_free(r);
 562                 return false;
 563         }
 564 
 565         pull = ndr_pull_init_blob(&blob, r, NULL);
 566         if (pull == NULL) {
 567                 talloc_free(r);
 568                 return false;
 569         }
 570 
 571         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 572         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 573         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 574                 talloc_free(r);
 575                 return false;
 576         }
 577 
 578         if (DEBUGLEVEL >= 10) {
 579                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy, r);
 580         }
 581 
 582         ZERO_STRUCT(r->out);
 583         r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
 584         if (r->out.info == NULL) {
 585                 talloc_free(r);
 586                 return false;
 587         }
 588 
 589         r->out.result = _lsa_QueryInfoPolicy(p, r);
 590 
 591         if (p->rng_fault_state) {
 592                 talloc_free(r);
 593                 /* Return true here, srv_pipe_hnd.c will take care */
 594                 return true;
 595         }
 596 
 597         if (DEBUGLEVEL >= 10) {
 598                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, r);
 599         }
 600 
 601         push = ndr_push_init_ctx(r, NULL);
 602         if (push == NULL) {
 603                 talloc_free(r);
 604                 return false;
 605         }
 606 
 607         ndr_err = call->ndr_push(push, NDR_OUT, r);
 608         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 609                 talloc_free(r);
 610                 return false;
 611         }
 612 
 613         blob = ndr_push_blob(push);
 614         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 615                 talloc_free(r);
 616                 return false;
 617         }
 618 
 619         talloc_free(r);
 620 
 621         return true;
 622 }
 623 
 624 static bool api_lsa_SetInfoPolicy(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 625 {
 626         const struct ndr_interface_call *call;
 627         struct ndr_pull *pull;
 628         struct ndr_push *push;
 629         enum ndr_err_code ndr_err;
 630         DATA_BLOB blob;
 631         struct lsa_SetInfoPolicy *r;
 632 
 633         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY];
 634 
 635         r = talloc(talloc_tos(), struct lsa_SetInfoPolicy);
 636         if (r == NULL) {
 637                 return false;
 638         }
 639 
 640         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 641                 talloc_free(r);
 642                 return false;
 643         }
 644 
 645         pull = ndr_pull_init_blob(&blob, r, NULL);
 646         if (pull == NULL) {
 647                 talloc_free(r);
 648                 return false;
 649         }
 650 
 651         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 652         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 653         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 654                 talloc_free(r);
 655                 return false;
 656         }
 657 
 658         if (DEBUGLEVEL >= 10) {
 659                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, r);
 660         }
 661 
 662         r->out.result = _lsa_SetInfoPolicy(p, r);
 663 
 664         if (p->rng_fault_state) {
 665                 talloc_free(r);
 666                 /* Return true here, srv_pipe_hnd.c will take care */
 667                 return true;
 668         }
 669 
 670         if (DEBUGLEVEL >= 10) {
 671                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, r);
 672         }
 673 
 674         push = ndr_push_init_ctx(r, NULL);
 675         if (push == NULL) {
 676                 talloc_free(r);
 677                 return false;
 678         }
 679 
 680         ndr_err = call->ndr_push(push, NDR_OUT, r);
 681         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 682                 talloc_free(r);
 683                 return false;
 684         }
 685 
 686         blob = ndr_push_blob(push);
 687         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 688                 talloc_free(r);
 689                 return false;
 690         }
 691 
 692         talloc_free(r);
 693 
 694         return true;
 695 }
 696 
 697 static bool api_lsa_ClearAuditLog(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 698 {
 699         const struct ndr_interface_call *call;
 700         struct ndr_pull *pull;
 701         struct ndr_push *push;
 702         enum ndr_err_code ndr_err;
 703         DATA_BLOB blob;
 704         struct lsa_ClearAuditLog *r;
 705 
 706         call = &ndr_table_lsarpc.calls[NDR_LSA_CLEARAUDITLOG];
 707 
 708         r = talloc(talloc_tos(), struct lsa_ClearAuditLog);
 709         if (r == NULL) {
 710                 return false;
 711         }
 712 
 713         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 714                 talloc_free(r);
 715                 return false;
 716         }
 717 
 718         pull = ndr_pull_init_blob(&blob, r, NULL);
 719         if (pull == NULL) {
 720                 talloc_free(r);
 721                 return false;
 722         }
 723 
 724         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 725         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 726         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 727                 talloc_free(r);
 728                 return false;
 729         }
 730 
 731         if (DEBUGLEVEL >= 10) {
 732                 NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, r);
 733         }
 734 
 735         r->out.result = _lsa_ClearAuditLog(p, r);
 736 
 737         if (p->rng_fault_state) {
 738                 talloc_free(r);
 739                 /* Return true here, srv_pipe_hnd.c will take care */
 740                 return true;
 741         }
 742 
 743         if (DEBUGLEVEL >= 10) {
 744                 NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, r);
 745         }
 746 
 747         push = ndr_push_init_ctx(r, NULL);
 748         if (push == NULL) {
 749                 talloc_free(r);
 750                 return false;
 751         }
 752 
 753         ndr_err = call->ndr_push(push, NDR_OUT, r);
 754         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 755                 talloc_free(r);
 756                 return false;
 757         }
 758 
 759         blob = ndr_push_blob(push);
 760         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 761                 talloc_free(r);
 762                 return false;
 763         }
 764 
 765         talloc_free(r);
 766 
 767         return true;
 768 }
 769 
 770 static bool api_lsa_CreateAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 771 {
 772         const struct ndr_interface_call *call;
 773         struct ndr_pull *pull;
 774         struct ndr_push *push;
 775         enum ndr_err_code ndr_err;
 776         DATA_BLOB blob;
 777         struct lsa_CreateAccount *r;
 778 
 779         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATEACCOUNT];
 780 
 781         r = talloc(talloc_tos(), struct lsa_CreateAccount);
 782         if (r == NULL) {
 783                 return false;
 784         }
 785 
 786         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 787                 talloc_free(r);
 788                 return false;
 789         }
 790 
 791         pull = ndr_pull_init_blob(&blob, r, NULL);
 792         if (pull == NULL) {
 793                 talloc_free(r);
 794                 return false;
 795         }
 796 
 797         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 798         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 799         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 800                 talloc_free(r);
 801                 return false;
 802         }
 803 
 804         if (DEBUGLEVEL >= 10) {
 805                 NDR_PRINT_IN_DEBUG(lsa_CreateAccount, r);
 806         }
 807 
 808         ZERO_STRUCT(r->out);
 809         r->out.acct_handle = talloc_zero(r, struct policy_handle);
 810         if (r->out.acct_handle == NULL) {
 811                 talloc_free(r);
 812                 return false;
 813         }
 814 
 815         r->out.result = _lsa_CreateAccount(p, r);
 816 
 817         if (p->rng_fault_state) {
 818                 talloc_free(r);
 819                 /* Return true here, srv_pipe_hnd.c will take care */
 820                 return true;
 821         }
 822 
 823         if (DEBUGLEVEL >= 10) {
 824                 NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, r);
 825         }
 826 
 827         push = ndr_push_init_ctx(r, NULL);
 828         if (push == NULL) {
 829                 talloc_free(r);
 830                 return false;
 831         }
 832 
 833         ndr_err = call->ndr_push(push, NDR_OUT, r);
 834         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 835                 talloc_free(r);
 836                 return false;
 837         }
 838 
 839         blob = ndr_push_blob(push);
 840         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 841                 talloc_free(r);
 842                 return false;
 843         }
 844 
 845         talloc_free(r);
 846 
 847         return true;
 848 }
 849 
 850 static bool api_lsa_EnumAccounts(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 851 {
 852         const struct ndr_interface_call *call;
 853         struct ndr_pull *pull;
 854         struct ndr_push *push;
 855         enum ndr_err_code ndr_err;
 856         DATA_BLOB blob;
 857         struct lsa_EnumAccounts *r;
 858 
 859         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTS];
 860 
 861         r = talloc(talloc_tos(), struct lsa_EnumAccounts);
 862         if (r == NULL) {
 863                 return false;
 864         }
 865 
 866         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 867                 talloc_free(r);
 868                 return false;
 869         }
 870 
 871         pull = ndr_pull_init_blob(&blob, r, NULL);
 872         if (pull == NULL) {
 873                 talloc_free(r);
 874                 return false;
 875         }
 876 
 877         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 878         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 879         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 880                 talloc_free(r);
 881                 return false;
 882         }
 883 
 884         if (DEBUGLEVEL >= 10) {
 885                 NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, r);
 886         }
 887 
 888         ZERO_STRUCT(r->out);
 889         r->out.resume_handle = r->in.resume_handle;
 890         r->out.sids = talloc_zero(r, struct lsa_SidArray);
 891         if (r->out.sids == NULL) {
 892                 talloc_free(r);
 893                 return false;
 894         }
 895 
 896         r->out.result = _lsa_EnumAccounts(p, r);
 897 
 898         if (p->rng_fault_state) {
 899                 talloc_free(r);
 900                 /* Return true here, srv_pipe_hnd.c will take care */
 901                 return true;
 902         }
 903 
 904         if (DEBUGLEVEL >= 10) {
 905                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, r);
 906         }
 907 
 908         push = ndr_push_init_ctx(r, NULL);
 909         if (push == NULL) {
 910                 talloc_free(r);
 911                 return false;
 912         }
 913 
 914         ndr_err = call->ndr_push(push, NDR_OUT, r);
 915         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 916                 talloc_free(r);
 917                 return false;
 918         }
 919 
 920         blob = ndr_push_blob(push);
 921         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 922                 talloc_free(r);
 923                 return false;
 924         }
 925 
 926         talloc_free(r);
 927 
 928         return true;
 929 }
 930 
 931 static bool api_lsa_CreateTrustedDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 932 {
 933         const struct ndr_interface_call *call;
 934         struct ndr_pull *pull;
 935         struct ndr_push *push;
 936         enum ndr_err_code ndr_err;
 937         DATA_BLOB blob;
 938         struct lsa_CreateTrustedDomain *r;
 939 
 940         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAIN];
 941 
 942         r = talloc(talloc_tos(), struct lsa_CreateTrustedDomain);
 943         if (r == NULL) {
 944                 return false;
 945         }
 946 
 947         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 948                 talloc_free(r);
 949                 return false;
 950         }
 951 
 952         pull = ndr_pull_init_blob(&blob, r, NULL);
 953         if (pull == NULL) {
 954                 talloc_free(r);
 955                 return false;
 956         }
 957 
 958         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 959         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 960         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 961                 talloc_free(r);
 962                 return false;
 963         }
 964 
 965         if (DEBUGLEVEL >= 10) {
 966                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain, r);
 967         }
 968 
 969         ZERO_STRUCT(r->out);
 970         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
 971         if (r->out.trustdom_handle == NULL) {
 972                 talloc_free(r);
 973                 return false;
 974         }
 975 
 976         r->out.result = _lsa_CreateTrustedDomain(p, r);
 977 
 978         if (p->rng_fault_state) {
 979                 talloc_free(r);
 980                 /* Return true here, srv_pipe_hnd.c will take care */
 981                 return true;
 982         }
 983 
 984         if (DEBUGLEVEL >= 10) {
 985                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain, r);
 986         }
 987 
 988         push = ndr_push_init_ctx(r, NULL);
 989         if (push == NULL) {
 990                 talloc_free(r);
 991                 return false;
 992         }
 993 
 994         ndr_err = call->ndr_push(push, NDR_OUT, r);
 995         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 996                 talloc_free(r);
 997                 return false;
 998         }
 999 
1000         blob = ndr_push_blob(push);
1001         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1002                 talloc_free(r);
1003                 return false;
1004         }
1005 
1006         talloc_free(r);
1007 
1008         return true;
1009 }
1010 
1011 static bool api_lsa_EnumTrustDom(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1012 {
1013         const struct ndr_interface_call *call;
1014         struct ndr_pull *pull;
1015         struct ndr_push *push;
1016         enum ndr_err_code ndr_err;
1017         DATA_BLOB blob;
1018         struct lsa_EnumTrustDom *r;
1019 
1020         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTDOM];
1021 
1022         r = talloc(talloc_tos(), struct lsa_EnumTrustDom);
1023         if (r == NULL) {
1024                 return false;
1025         }
1026 
1027         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1028                 talloc_free(r);
1029                 return false;
1030         }
1031 
1032         pull = ndr_pull_init_blob(&blob, r, NULL);
1033         if (pull == NULL) {
1034                 talloc_free(r);
1035                 return false;
1036         }
1037 
1038         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1039         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1040         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1041                 talloc_free(r);
1042                 return false;
1043         }
1044 
1045         if (DEBUGLEVEL >= 10) {
1046                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, r);
1047         }
1048 
1049         ZERO_STRUCT(r->out);
1050         r->out.resume_handle = r->in.resume_handle;
1051         r->out.domains = talloc_zero(r, struct lsa_DomainList);
1052         if (r->out.domains == NULL) {
1053                 talloc_free(r);
1054                 return false;
1055         }
1056 
1057         r->out.result = _lsa_EnumTrustDom(p, r);
1058 
1059         if (p->rng_fault_state) {
1060                 talloc_free(r);
1061                 /* Return true here, srv_pipe_hnd.c will take care */
1062                 return true;
1063         }
1064 
1065         if (DEBUGLEVEL >= 10) {
1066                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, r);
1067         }
1068 
1069         push = ndr_push_init_ctx(r, NULL);
1070         if (push == NULL) {
1071                 talloc_free(r);
1072                 return false;
1073         }
1074 
1075         ndr_err = call->ndr_push(push, NDR_OUT, r);
1076         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1077                 talloc_free(r);
1078                 return false;
1079         }
1080 
1081         blob = ndr_push_blob(push);
1082         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1083                 talloc_free(r);
1084                 return false;
1085         }
1086 
1087         talloc_free(r);
1088 
1089         return true;
1090 }
1091 
1092 static bool api_lsa_LookupNames(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1093 {
1094         const struct ndr_interface_call *call;
1095         struct ndr_pull *pull;
1096         struct ndr_push *push;
1097         enum ndr_err_code ndr_err;
1098         DATA_BLOB blob;
1099         struct lsa_LookupNames *r;
1100 
1101         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES];
1102 
1103         r = talloc(talloc_tos(), struct lsa_LookupNames);
1104         if (r == NULL) {
1105                 return false;
1106         }
1107 
1108         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1109                 talloc_free(r);
1110                 return false;
1111         }
1112 
1113         pull = ndr_pull_init_blob(&blob, r, NULL);
1114         if (pull == NULL) {
1115                 talloc_free(r);
1116                 return false;
1117         }
1118 
1119         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1120         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1121         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1122                 talloc_free(r);
1123                 return false;
1124         }
1125 
1126         if (DEBUGLEVEL >= 10) {
1127                 NDR_PRINT_IN_DEBUG(lsa_LookupNames, r);
1128         }
1129 
1130         ZERO_STRUCT(r->out);
1131         r->out.sids = r->in.sids;
1132         r->out.count = r->in.count;
1133         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
1134         if (r->out.domains == NULL) {
1135                 talloc_free(r);
1136                 return false;
1137         }
1138 
1139         r->out.result = _lsa_LookupNames(p, r);
1140 
1141         if (p->rng_fault_state) {
1142                 talloc_free(r);
1143                 /* Return true here, srv_pipe_hnd.c will take care */
1144                 return true;
1145         }
1146 
1147         if (DEBUGLEVEL >= 10) {
1148                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames, r);
1149         }
1150 
1151         push = ndr_push_init_ctx(r, NULL);
1152         if (push == NULL) {
1153                 talloc_free(r);
1154                 return false;
1155         }
1156 
1157         ndr_err = call->ndr_push(push, NDR_OUT, r);
1158         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1159                 talloc_free(r);
1160                 return false;
1161         }
1162 
1163         blob = ndr_push_blob(push);
1164         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1165                 talloc_free(r);
1166                 return false;
1167         }
1168 
1169         talloc_free(r);
1170 
1171         return true;
1172 }
1173 
1174 static bool api_lsa_LookupSids(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1175 {
1176         const struct ndr_interface_call *call;
1177         struct ndr_pull *pull;
1178         struct ndr_push *push;
1179         enum ndr_err_code ndr_err;
1180         DATA_BLOB blob;
1181         struct lsa_LookupSids *r;
1182 
1183         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS];
1184 
1185         r = talloc(talloc_tos(), struct lsa_LookupSids);
1186         if (r == NULL) {
1187                 return false;
1188         }
1189 
1190         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1191                 talloc_free(r);
1192                 return false;
1193         }
1194 
1195         pull = ndr_pull_init_blob(&blob, r, NULL);
1196         if (pull == NULL) {
1197                 talloc_free(r);
1198                 return false;
1199         }
1200 
1201         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1202         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1203         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1204                 talloc_free(r);
1205                 return false;
1206         }
1207 
1208         if (DEBUGLEVEL >= 10) {
1209                 NDR_PRINT_IN_DEBUG(lsa_LookupSids, r);
1210         }
1211 
1212         ZERO_STRUCT(r->out);
1213         r->out.names = r->in.names;
1214         r->out.count = r->in.count;
1215         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
1216         if (r->out.domains == NULL) {
1217                 talloc_free(r);
1218                 return false;
1219         }
1220 
1221         r->out.result = _lsa_LookupSids(p, r);
1222 
1223         if (p->rng_fault_state) {
1224                 talloc_free(r);
1225                 /* Return true here, srv_pipe_hnd.c will take care */
1226                 return true;
1227         }
1228 
1229         if (DEBUGLEVEL >= 10) {
1230                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids, r);
1231         }
1232 
1233         push = ndr_push_init_ctx(r, NULL);
1234         if (push == NULL) {
1235                 talloc_free(r);
1236                 return false;
1237         }
1238 
1239         ndr_err = call->ndr_push(push, NDR_OUT, r);
1240         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1241                 talloc_free(r);
1242                 return false;
1243         }
1244 
1245         blob = ndr_push_blob(push);
1246         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1247                 talloc_free(r);
1248                 return false;
1249         }
1250 
1251         talloc_free(r);
1252 
1253         return true;
1254 }
1255 
1256 static bool api_lsa_CreateSecret(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1257 {
1258         const struct ndr_interface_call *call;
1259         struct ndr_pull *pull;
1260         struct ndr_push *push;
1261         enum ndr_err_code ndr_err;
1262         DATA_BLOB blob;
1263         struct lsa_CreateSecret *r;
1264 
1265         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATESECRET];
1266 
1267         r = talloc(talloc_tos(), struct lsa_CreateSecret);
1268         if (r == NULL) {
1269                 return false;
1270         }
1271 
1272         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1273                 talloc_free(r);
1274                 return false;
1275         }
1276 
1277         pull = ndr_pull_init_blob(&blob, r, NULL);
1278         if (pull == NULL) {
1279                 talloc_free(r);
1280                 return false;
1281         }
1282 
1283         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1284         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1285         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1286                 talloc_free(r);
1287                 return false;
1288         }
1289 
1290         if (DEBUGLEVEL >= 10) {
1291                 NDR_PRINT_IN_DEBUG(lsa_CreateSecret, r);
1292         }
1293 
1294         ZERO_STRUCT(r->out);
1295         r->out.sec_handle = talloc_zero(r, struct policy_handle);
1296         if (r->out.sec_handle == NULL) {
1297                 talloc_free(r);
1298                 return false;
1299         }
1300 
1301         r->out.result = _lsa_CreateSecret(p, r);
1302 
1303         if (p->rng_fault_state) {
1304                 talloc_free(r);
1305                 /* Return true here, srv_pipe_hnd.c will take care */
1306                 return true;
1307         }
1308 
1309         if (DEBUGLEVEL >= 10) {
1310                 NDR_PRINT_OUT_DEBUG(lsa_CreateSecret, r);
1311         }
1312 
1313         push = ndr_push_init_ctx(r, NULL);
1314         if (push == NULL) {
1315                 talloc_free(r);
1316                 return false;
1317         }
1318 
1319         ndr_err = call->ndr_push(push, NDR_OUT, r);
1320         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1321                 talloc_free(r);
1322                 return false;
1323         }
1324 
1325         blob = ndr_push_blob(push);
1326         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1327                 talloc_free(r);
1328                 return false;
1329         }
1330 
1331         talloc_free(r);
1332 
1333         return true;
1334 }
1335 
1336 static bool api_lsa_OpenAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1337 {
1338         const struct ndr_interface_call *call;
1339         struct ndr_pull *pull;
1340         struct ndr_push *push;
1341         enum ndr_err_code ndr_err;
1342         DATA_BLOB blob;
1343         struct lsa_OpenAccount *r;
1344 
1345         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENACCOUNT];
1346 
1347         r = talloc(talloc_tos(), struct lsa_OpenAccount);
1348         if (r == NULL) {
1349                 return false;
1350         }
1351 
1352         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1353                 talloc_free(r);
1354                 return false;
1355         }
1356 
1357         pull = ndr_pull_init_blob(&blob, r, NULL);
1358         if (pull == NULL) {
1359                 talloc_free(r);
1360                 return false;
1361         }
1362 
1363         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1364         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1365         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1366                 talloc_free(r);
1367                 return false;
1368         }
1369 
1370         if (DEBUGLEVEL >= 10) {
1371                 NDR_PRINT_IN_DEBUG(lsa_OpenAccount, r);
1372         }
1373 
1374         ZERO_STRUCT(r->out);
1375         r->out.acct_handle = talloc_zero(r, struct policy_handle);
1376         if (r->out.acct_handle == NULL) {
1377                 talloc_free(r);
1378                 return false;
1379         }
1380 
1381         r->out.result = _lsa_OpenAccount(p, r);
1382 
1383         if (p->rng_fault_state) {
1384                 talloc_free(r);
1385                 /* Return true here, srv_pipe_hnd.c will take care */
1386                 return true;
1387         }
1388 
1389         if (DEBUGLEVEL >= 10) {
1390                 NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, r);
1391         }
1392 
1393         push = ndr_push_init_ctx(r, NULL);
1394         if (push == NULL) {
1395                 talloc_free(r);
1396                 return false;
1397         }
1398 
1399         ndr_err = call->ndr_push(push, NDR_OUT, r);
1400         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1401                 talloc_free(r);
1402                 return false;
1403         }
1404 
1405         blob = ndr_push_blob(push);
1406         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1407                 talloc_free(r);
1408                 return false;
1409         }
1410 
1411         talloc_free(r);
1412 
1413         return true;
1414 }
1415 
1416 static bool api_lsa_EnumPrivsAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1417 {
1418         const struct ndr_interface_call *call;
1419         struct ndr_pull *pull;
1420         struct ndr_push *push;
1421         enum ndr_err_code ndr_err;
1422         DATA_BLOB blob;
1423         struct lsa_EnumPrivsAccount *r;
1424 
1425         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVSACCOUNT];
1426 
1427         r = talloc(talloc_tos(), struct lsa_EnumPrivsAccount);
1428         if (r == NULL) {
1429                 return false;
1430         }
1431 
1432         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1433                 talloc_free(r);
1434                 return false;
1435         }
1436 
1437         pull = ndr_pull_init_blob(&blob, r, NULL);
1438         if (pull == NULL) {
1439                 talloc_free(r);
1440                 return false;
1441         }
1442 
1443         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1444         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1445         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1446                 talloc_free(r);
1447                 return false;
1448         }
1449 
1450         if (DEBUGLEVEL >= 10) {
1451                 NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, r);
1452         }
1453 
1454         ZERO_STRUCT(r->out);
1455         r->out.privs = talloc_zero(r, struct lsa_PrivilegeSet *);
1456         if (r->out.privs == NULL) {
1457                 talloc_free(r);
1458                 return false;
1459         }
1460 
1461         r->out.result = _lsa_EnumPrivsAccount(p, r);
1462 
1463         if (p->rng_fault_state) {
1464                 talloc_free(r);
1465                 /* Return true here, srv_pipe_hnd.c will take care */
1466                 return true;
1467         }
1468 
1469         if (DEBUGLEVEL >= 10) {
1470                 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, r);
1471         }
1472 
1473         push = ndr_push_init_ctx(r, NULL);
1474         if (push == NULL) {
1475                 talloc_free(r);
1476                 return false;
1477         }
1478 
1479         ndr_err = call->ndr_push(push, NDR_OUT, r);
1480         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1481                 talloc_free(r);
1482                 return false;
1483         }
1484 
1485         blob = ndr_push_blob(push);
1486         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1487                 talloc_free(r);
1488                 return false;
1489         }
1490 
1491         talloc_free(r);
1492 
1493         return true;
1494 }
1495 
1496 static bool api_lsa_AddPrivilegesToAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1497 {
1498         const struct ndr_interface_call *call;
1499         struct ndr_pull *pull;
1500         struct ndr_push *push;
1501         enum ndr_err_code ndr_err;
1502         DATA_BLOB blob;
1503         struct lsa_AddPrivilegesToAccount *r;
1504 
1505         call = &ndr_table_lsarpc.calls[NDR_LSA_ADDPRIVILEGESTOACCOUNT];
1506 
1507         r = talloc(talloc_tos(), struct lsa_AddPrivilegesToAccount);
1508         if (r == NULL) {
1509                 return false;
1510         }
1511 
1512         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1513                 talloc_free(r);
1514                 return false;
1515         }
1516 
1517         pull = ndr_pull_init_blob(&blob, r, NULL);
1518         if (pull == NULL) {
1519                 talloc_free(r);
1520                 return false;
1521         }
1522 
1523         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1524         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1525         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1526                 talloc_free(r);
1527                 return false;
1528         }
1529 
1530         if (DEBUGLEVEL >= 10) {
1531                 NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, r);
1532         }
1533 
1534         r->out.result = _lsa_AddPrivilegesToAccount(p, r);
1535 
1536         if (p->rng_fault_state) {
1537                 talloc_free(r);
1538                 /* Return true here, srv_pipe_hnd.c will take care */
1539                 return true;
1540         }
1541 
1542         if (DEBUGLEVEL >= 10) {
1543                 NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount, r);
1544         }
1545 
1546         push = ndr_push_init_ctx(r, NULL);
1547         if (push == NULL) {
1548                 talloc_free(r);
1549                 return false;
1550         }
1551 
1552         ndr_err = call->ndr_push(push, NDR_OUT, r);
1553         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1554                 talloc_free(r);
1555                 return false;
1556         }
1557 
1558         blob = ndr_push_blob(push);
1559         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1560                 talloc_free(r);
1561                 return false;
1562         }
1563 
1564         talloc_free(r);
1565 
1566         return true;
1567 }
1568 
1569 static bool api_lsa_RemovePrivilegesFromAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1570 {
1571         const struct ndr_interface_call *call;
1572         struct ndr_pull *pull;
1573         struct ndr_push *push;
1574         enum ndr_err_code ndr_err;
1575         DATA_BLOB blob;
1576         struct lsa_RemovePrivilegesFromAccount *r;
1577 
1578         call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT];
1579 
1580         r = talloc(talloc_tos(), struct lsa_RemovePrivilegesFromAccount);
1581         if (r == NULL) {
1582                 return false;
1583         }
1584 
1585         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1586                 talloc_free(r);
1587                 return false;
1588         }
1589 
1590         pull = ndr_pull_init_blob(&blob, r, NULL);
1591         if (pull == NULL) {
1592                 talloc_free(r);
1593                 return false;
1594         }
1595 
1596         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1597         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1598         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1599                 talloc_free(r);
1600                 return false;
1601         }
1602 
1603         if (DEBUGLEVEL >= 10) {
1604                 NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1605         }
1606 
1607         r->out.result = _lsa_RemovePrivilegesFromAccount(p, r);
1608 
1609         if (p->rng_fault_state) {
1610                 talloc_free(r);
1611                 /* Return true here, srv_pipe_hnd.c will take care */
1612                 return true;
1613         }
1614 
1615         if (DEBUGLEVEL >= 10) {
1616                 NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1617         }
1618 
1619         push = ndr_push_init_ctx(r, NULL);
1620         if (push == NULL) {
1621                 talloc_free(r);
1622                 return false;
1623         }
1624 
1625         ndr_err = call->ndr_push(push, NDR_OUT, r);
1626         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1627                 talloc_free(r);
1628                 return false;
1629         }
1630 
1631         blob = ndr_push_blob(push);
1632         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1633                 talloc_free(r);
1634                 return false;
1635         }
1636 
1637         talloc_free(r);
1638 
1639         return true;
1640 }
1641 
1642 static bool api_lsa_GetQuotasForAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1643 {
1644         const struct ndr_interface_call *call;
1645         struct ndr_pull *pull;
1646         struct ndr_push *push;
1647         enum ndr_err_code ndr_err;
1648         DATA_BLOB blob;
1649         struct lsa_GetQuotasForAccount *r;
1650 
1651         call = &ndr_table_lsarpc.calls[NDR_LSA_GETQUOTASFORACCOUNT];
1652 
1653         r = talloc(talloc_tos(), struct lsa_GetQuotasForAccount);
1654         if (r == NULL) {
1655                 return false;
1656         }
1657 
1658         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1659                 talloc_free(r);
1660                 return false;
1661         }
1662 
1663         pull = ndr_pull_init_blob(&blob, r, NULL);
1664         if (pull == NULL) {
1665                 talloc_free(r);
1666                 return false;
1667         }
1668 
1669         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1670         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1671         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1672                 talloc_free(r);
1673                 return false;
1674         }
1675 
1676         if (DEBUGLEVEL >= 10) {
1677                 NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, r);
1678         }
1679 
1680         r->out.result = _lsa_GetQuotasForAccount(p, r);
1681 
1682         if (p->rng_fault_state) {
1683                 talloc_free(r);
1684                 /* Return true here, srv_pipe_hnd.c will take care */
1685                 return true;
1686         }
1687 
1688         if (DEBUGLEVEL >= 10) {
1689                 NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount, r);
1690         }
1691 
1692         push = ndr_push_init_ctx(r, NULL);
1693         if (push == NULL) {
1694                 talloc_free(r);
1695                 return false;
1696         }
1697 
1698         ndr_err = call->ndr_push(push, NDR_OUT, r);
1699         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1700                 talloc_free(r);
1701                 return false;
1702         }
1703 
1704         blob = ndr_push_blob(push);
1705         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1706                 talloc_free(r);
1707                 return false;
1708         }
1709 
1710         talloc_free(r);
1711 
1712         return true;
1713 }
1714 
1715 static bool api_lsa_SetQuotasForAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1716 {
1717         const struct ndr_interface_call *call;
1718         struct ndr_pull *pull;
1719         struct ndr_push *push;
1720         enum ndr_err_code ndr_err;
1721         DATA_BLOB blob;
1722         struct lsa_SetQuotasForAccount *r;
1723 
1724         call = &ndr_table_lsarpc.calls[NDR_LSA_SETQUOTASFORACCOUNT];
1725 
1726         r = talloc(talloc_tos(), struct lsa_SetQuotasForAccount);
1727         if (r == NULL) {
1728                 return false;
1729         }
1730 
1731         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1732                 talloc_free(r);
1733                 return false;
1734         }
1735 
1736         pull = ndr_pull_init_blob(&blob, r, NULL);
1737         if (pull == NULL) {
1738                 talloc_free(r);
1739                 return false;
1740         }
1741 
1742         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1743         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1744         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1745                 talloc_free(r);
1746                 return false;
1747         }
1748 
1749         if (DEBUGLEVEL >= 10) {
1750                 NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, r);
1751         }
1752 
1753         r->out.result = _lsa_SetQuotasForAccount(p, r);
1754 
1755         if (p->rng_fault_state) {
1756                 talloc_free(r);
1757                 /* Return true here, srv_pipe_hnd.c will take care */
1758                 return true;
1759         }
1760 
1761         if (DEBUGLEVEL >= 10) {
1762                 NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount, r);
1763         }
1764 
1765         push = ndr_push_init_ctx(r, NULL);
1766         if (push == NULL) {
1767                 talloc_free(r);
1768                 return false;
1769         }
1770 
1771         ndr_err = call->ndr_push(push, NDR_OUT, r);
1772         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1773                 talloc_free(r);
1774                 return false;
1775         }
1776 
1777         blob = ndr_push_blob(push);
1778         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1779                 talloc_free(r);
1780                 return false;
1781         }
1782 
1783         talloc_free(r);
1784 
1785         return true;
1786 }
1787 
1788 static bool api_lsa_GetSystemAccessAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1789 {
1790         const struct ndr_interface_call *call;
1791         struct ndr_pull *pull;
1792         struct ndr_push *push;
1793         enum ndr_err_code ndr_err;
1794         DATA_BLOB blob;
1795         struct lsa_GetSystemAccessAccount *r;
1796 
1797         call = &ndr_table_lsarpc.calls[NDR_LSA_GETSYSTEMACCESSACCOUNT];
1798 
1799         r = talloc(talloc_tos(), struct lsa_GetSystemAccessAccount);
1800         if (r == NULL) {
1801                 return false;
1802         }
1803 
1804         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1805                 talloc_free(r);
1806                 return false;
1807         }
1808 
1809         pull = ndr_pull_init_blob(&blob, r, NULL);
1810         if (pull == NULL) {
1811                 talloc_free(r);
1812                 return false;
1813         }
1814 
1815         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1816         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1817         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1818                 talloc_free(r);
1819                 return false;
1820         }
1821 
1822         if (DEBUGLEVEL >= 10) {
1823                 NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, r);
1824         }
1825 
1826         ZERO_STRUCT(r->out);
1827         r->out.access_mask = talloc_zero(r, uint32_t);
1828         if (r->out.access_mask == NULL) {
1829                 talloc_free(r);
1830                 return false;
1831         }
1832 
1833         r->out.result = _lsa_GetSystemAccessAccount(p, r);
1834 
1835         if (p->rng_fault_state) {
1836                 talloc_free(r);
1837                 /* Return true here, srv_pipe_hnd.c will take care */
1838                 return true;
1839         }
1840 
1841         if (DEBUGLEVEL >= 10) {
1842                 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, r);
1843         }
1844 
1845         push = ndr_push_init_ctx(r, NULL);
1846         if (push == NULL) {
1847                 talloc_free(r);
1848                 return false;
1849         }
1850 
1851         ndr_err = call->ndr_push(push, NDR_OUT, r);
1852         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1853                 talloc_free(r);
1854                 return false;
1855         }
1856 
1857         blob = ndr_push_blob(push);
1858         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1859                 talloc_free(r);
1860                 return false;
1861         }
1862 
1863         talloc_free(r);
1864 
1865         return true;
1866 }
1867 
1868 static bool api_lsa_SetSystemAccessAccount(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1869 {
1870         const struct ndr_interface_call *call;
1871         struct ndr_pull *pull;
1872         struct ndr_push *push;
1873         enum ndr_err_code ndr_err;
1874         DATA_BLOB blob;
1875         struct lsa_SetSystemAccessAccount *r;
1876 
1877         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSYSTEMACCESSACCOUNT];
1878 
1879         r = talloc(talloc_tos(), struct lsa_SetSystemAccessAccount);
1880         if (r == NULL) {
1881                 return false;
1882         }
1883 
1884         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1885                 talloc_free(r);
1886                 return false;
1887         }
1888 
1889         pull = ndr_pull_init_blob(&blob, r, NULL);
1890         if (pull == NULL) {
1891                 talloc_free(r);
1892                 return false;
1893         }
1894 
1895         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1896         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1897         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1898                 talloc_free(r);
1899                 return false;
1900         }
1901 
1902         if (DEBUGLEVEL >= 10) {
1903                 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, r);
1904         }
1905 
1906         r->out.result = _lsa_SetSystemAccessAccount(p, r);
1907 
1908         if (p->rng_fault_state) {
1909                 talloc_free(r);
1910                 /* Return true here, srv_pipe_hnd.c will take care */
1911                 return true;
1912         }
1913 
1914         if (DEBUGLEVEL >= 10) {
1915                 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, r);
1916         }
1917 
1918         push = ndr_push_init_ctx(r, NULL);
1919         if (push == NULL) {
1920                 talloc_free(r);
1921                 return false;
1922         }
1923 
1924         ndr_err = call->ndr_push(push, NDR_OUT, r);
1925         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1926                 talloc_free(r);
1927                 return false;
1928         }
1929 
1930         blob = ndr_push_blob(push);
1931         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1932                 talloc_free(r);
1933                 return false;
1934         }
1935 
1936         talloc_free(r);
1937 
1938         return true;
1939 }
1940 
1941 static bool api_lsa_OpenTrustedDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1942 {
1943         const struct ndr_interface_call *call;
1944         struct ndr_pull *pull;
1945         struct ndr_push *push;
1946         enum ndr_err_code ndr_err;
1947         DATA_BLOB blob;
1948         struct lsa_OpenTrustedDomain *r;
1949 
1950         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAIN];
1951 
1952         r = talloc(talloc_tos(), struct lsa_OpenTrustedDomain);
1953         if (r == NULL) {
1954                 return false;
1955         }
1956 
1957         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1958                 talloc_free(r);
1959                 return false;
1960         }
1961 
1962         pull = ndr_pull_init_blob(&blob, r, NULL);
1963         if (pull == NULL) {
1964                 talloc_free(r);
1965                 return false;
1966         }
1967 
1968         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1969         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1970         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1971                 talloc_free(r);
1972                 return false;
1973         }
1974 
1975         if (DEBUGLEVEL >= 10) {
1976                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, r);
1977         }
1978 
1979         ZERO_STRUCT(r->out);
1980         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
1981         if (r->out.trustdom_handle == NULL) {
1982                 talloc_free(r);
1983                 return false;
1984         }
1985 
1986         r->out.result = _lsa_OpenTrustedDomain(p, r);
1987 
1988         if (p->rng_fault_state) {
1989                 talloc_free(r);
1990                 /* Return true here, srv_pipe_hnd.c will take care */
1991                 return true;
1992         }
1993 
1994         if (DEBUGLEVEL >= 10) {
1995                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, r);
1996         }
1997 
1998         push = ndr_push_init_ctx(r, NULL);
1999         if (push == NULL) {
2000                 talloc_free(r);
2001                 return false;
2002         }
2003 
2004         ndr_err = call->ndr_push(push, NDR_OUT, r);
2005         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2006                 talloc_free(r);
2007                 return false;
2008         }
2009 
2010         blob = ndr_push_blob(push);
2011         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2012                 talloc_free(r);
2013                 return false;
2014         }
2015 
2016         talloc_free(r);
2017 
2018         return true;
2019 }
2020 
2021 static bool api_lsa_QueryTrustedDomainInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2022 {
2023         const struct ndr_interface_call *call;
2024         struct ndr_pull *pull;
2025         struct ndr_push *push;
2026         enum ndr_err_code ndr_err;
2027         DATA_BLOB blob;
2028         struct lsa_QueryTrustedDomainInfo *r;
2029 
2030         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFO];
2031 
2032         r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfo);
2033         if (r == NULL) {
2034                 return false;
2035         }
2036 
2037         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2038                 talloc_free(r);
2039                 return false;
2040         }
2041 
2042         pull = ndr_pull_init_blob(&blob, r, NULL);
2043         if (pull == NULL) {
2044                 talloc_free(r);
2045                 return false;
2046         }
2047 
2048         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2049         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2050         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2051                 talloc_free(r);
2052                 return false;
2053         }
2054 
2055         if (DEBUGLEVEL >= 10) {
2056                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo, r);
2057         }
2058 
2059         ZERO_STRUCT(r->out);
2060         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
2061         if (r->out.info == NULL) {
2062                 talloc_free(r);
2063                 return false;
2064         }
2065 
2066         r->out.result = _lsa_QueryTrustedDomainInfo(p, r);
2067 
2068         if (p->rng_fault_state) {
2069                 talloc_free(r);
2070                 /* Return true here, srv_pipe_hnd.c will take care */
2071                 return true;
2072         }
2073 
2074         if (DEBUGLEVEL >= 10) {
2075                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, r);
2076         }
2077 
2078         push = ndr_push_init_ctx(r, NULL);
2079         if (push == NULL) {
2080                 talloc_free(r);
2081                 return false;
2082         }
2083 
2084         ndr_err = call->ndr_push(push, NDR_OUT, r);
2085         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2086                 talloc_free(r);
2087                 return false;
2088         }
2089 
2090         blob = ndr_push_blob(push);
2091         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2092                 talloc_free(r);
2093                 return false;
2094         }
2095 
2096         talloc_free(r);
2097 
2098         return true;
2099 }
2100 
2101 static bool api_lsa_SetInformationTrustedDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2102 {
2103         const struct ndr_interface_call *call;
2104         struct ndr_pull *pull;
2105         struct ndr_push *push;
2106         enum ndr_err_code ndr_err;
2107         DATA_BLOB blob;
2108         struct lsa_SetInformationTrustedDomain *r;
2109 
2110         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN];
2111 
2112         r = talloc(talloc_tos(), struct lsa_SetInformationTrustedDomain);
2113         if (r == NULL) {
2114                 return false;
2115         }
2116 
2117         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2118                 talloc_free(r);
2119                 return false;
2120         }
2121 
2122         pull = ndr_pull_init_blob(&blob, r, NULL);
2123         if (pull == NULL) {
2124                 talloc_free(r);
2125                 return false;
2126         }
2127 
2128         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2129         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2130         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2131                 talloc_free(r);
2132                 return false;
2133         }
2134 
2135         if (DEBUGLEVEL >= 10) {
2136                 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, r);
2137         }
2138 
2139         r->out.result = _lsa_SetInformationTrustedDomain(p, r);
2140 
2141         if (p->rng_fault_state) {
2142                 talloc_free(r);
2143                 /* Return true here, srv_pipe_hnd.c will take care */
2144                 return true;
2145         }
2146 
2147         if (DEBUGLEVEL >= 10) {
2148                 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, r);
2149         }
2150 
2151         push = ndr_push_init_ctx(r, NULL);
2152         if (push == NULL) {
2153                 talloc_free(r);
2154                 return false;
2155         }
2156 
2157         ndr_err = call->ndr_push(push, NDR_OUT, r);
2158         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2159                 talloc_free(r);
2160                 return false;
2161         }
2162 
2163         blob = ndr_push_blob(push);
2164         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2165                 talloc_free(r);
2166                 return false;
2167         }
2168 
2169         talloc_free(r);
2170 
2171         return true;
2172 }
2173 
2174 static bool api_lsa_OpenSecret(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2175 {
2176         const struct ndr_interface_call *call;
2177         struct ndr_pull *pull;
2178         struct ndr_push *push;
2179         enum ndr_err_code ndr_err;
2180         DATA_BLOB blob;
2181         struct lsa_OpenSecret *r;
2182 
2183         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENSECRET];
2184 
2185         r = talloc(talloc_tos(), struct lsa_OpenSecret);
2186         if (r == NULL) {
2187                 return false;
2188         }
2189 
2190         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2191                 talloc_free(r);
2192                 return false;
2193         }
2194 
2195         pull = ndr_pull_init_blob(&blob, r, NULL);
2196         if (pull == NULL) {
2197                 talloc_free(r);
2198                 return false;
2199         }
2200 
2201         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2202         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2203         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2204                 talloc_free(r);
2205                 return false;
2206         }
2207 
2208         if (DEBUGLEVEL >= 10) {
2209                 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, r);
2210         }
2211 
2212         ZERO_STRUCT(r->out);
2213         r->out.sec_handle = talloc_zero(r, struct policy_handle);
2214         if (r->out.sec_handle == NULL) {
2215                 talloc_free(r);
2216                 return false;
2217         }
2218 
2219         r->out.result = _lsa_OpenSecret(p, r);
2220 
2221         if (p->rng_fault_state) {
2222                 talloc_free(r);
2223                 /* Return true here, srv_pipe_hnd.c will take care */
2224                 return true;
2225         }
2226 
2227         if (DEBUGLEVEL >= 10) {
2228                 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, r);
2229         }
2230 
2231         push = ndr_push_init_ctx(r, NULL);
2232         if (push == NULL) {
2233                 talloc_free(r);
2234                 return false;
2235         }
2236 
2237         ndr_err = call->ndr_push(push, NDR_OUT, r);
2238         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2239                 talloc_free(r);
2240                 return false;
2241         }
2242 
2243         blob = ndr_push_blob(push);
2244         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2245                 talloc_free(r);
2246                 return false;
2247         }
2248 
2249         talloc_free(r);
2250 
2251         return true;
2252 }
2253 
2254 static bool api_lsa_SetSecret(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2255 {
2256         const struct ndr_interface_call *call;
2257         struct ndr_pull *pull;
2258         struct ndr_push *push;
2259         enum ndr_err_code ndr_err;
2260         DATA_BLOB blob;
2261         struct lsa_SetSecret *r;
2262 
2263         call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECRET];
2264 
2265         r = talloc(talloc_tos(), struct lsa_SetSecret);
2266         if (r == NULL) {
2267                 return false;
2268         }
2269 
2270         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2271                 talloc_free(r);
2272                 return false;
2273         }
2274 
2275         pull = ndr_pull_init_blob(&blob, r, NULL);
2276         if (pull == NULL) {
2277                 talloc_free(r);
2278                 return false;
2279         }
2280 
2281         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2282         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2283         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2284                 talloc_free(r);
2285                 return false;
2286         }
2287 
2288         if (DEBUGLEVEL >= 10) {
2289                 NDR_PRINT_IN_DEBUG(lsa_SetSecret, r);
2290         }
2291 
2292         r->out.result = _lsa_SetSecret(p, r);
2293 
2294         if (p->rng_fault_state) {
2295                 talloc_free(r);
2296                 /* Return true here, srv_pipe_hnd.c will take care */
2297                 return true;
2298         }
2299 
2300         if (DEBUGLEVEL >= 10) {
2301                 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, r);
2302         }
2303 
2304         push = ndr_push_init_ctx(r, NULL);
2305         if (push == NULL) {
2306                 talloc_free(r);
2307                 return false;
2308         }
2309 
2310         ndr_err = call->ndr_push(push, NDR_OUT, r);
2311         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2312                 talloc_free(r);
2313                 return false;
2314         }
2315 
2316         blob = ndr_push_blob(push);
2317         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2318                 talloc_free(r);
2319                 return false;
2320         }
2321 
2322         talloc_free(r);
2323 
2324         return true;
2325 }
2326 
2327 static bool api_lsa_QuerySecret(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2328 {
2329         const struct ndr_interface_call *call;
2330         struct ndr_pull *pull;
2331         struct ndr_push *push;
2332         enum ndr_err_code ndr_err;
2333         DATA_BLOB blob;
2334         struct lsa_QuerySecret *r;
2335 
2336         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECRET];
2337 
2338         r = talloc(talloc_tos(), struct lsa_QuerySecret);
2339         if (r == NULL) {
2340                 return false;
2341         }
2342 
2343         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2344                 talloc_free(r);
2345                 return false;
2346         }
2347 
2348         pull = ndr_pull_init_blob(&blob, r, NULL);
2349         if (pull == NULL) {
2350                 talloc_free(r);
2351                 return false;
2352         }
2353 
2354         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2355         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2356         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2357                 talloc_free(r);
2358                 return false;
2359         }
2360 
2361         if (DEBUGLEVEL >= 10) {
2362                 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, r);
2363         }
2364 
2365         ZERO_STRUCT(r->out);
2366         r->out.new_val = r->in.new_val;
2367         r->out.new_mtime = r->in.new_mtime;
2368         r->out.old_val = r->in.old_val;
2369         r->out.old_mtime = r->in.old_mtime;
2370         r->out.result = _lsa_QuerySecret(p, r);
2371 
2372         if (p->rng_fault_state) {
2373                 talloc_free(r);
2374                 /* Return true here, srv_pipe_hnd.c will take care */
2375                 return true;
2376         }
2377 
2378         if (DEBUGLEVEL >= 10) {
2379                 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, r);
2380         }
2381 
2382         push = ndr_push_init_ctx(r, NULL);
2383         if (push == NULL) {
2384                 talloc_free(r);
2385                 return false;
2386         }
2387 
2388         ndr_err = call->ndr_push(push, NDR_OUT, r);
2389         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2390                 talloc_free(r);
2391                 return false;
2392         }
2393 
2394         blob = ndr_push_blob(push);
2395         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2396                 talloc_free(r);
2397                 return false;
2398         }
2399 
2400         talloc_free(r);
2401 
2402         return true;
2403 }
2404 
2405 static bool api_lsa_LookupPrivValue(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2406 {
2407         const struct ndr_interface_call *call;
2408         struct ndr_pull *pull;
2409         struct ndr_push *push;
2410         enum ndr_err_code ndr_err;
2411         DATA_BLOB blob;
2412         struct lsa_LookupPrivValue *r;
2413 
2414         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVVALUE];
2415 
2416         r = talloc(talloc_tos(), struct lsa_LookupPrivValue);
2417         if (r == NULL) {
2418                 return false;
2419         }
2420 
2421         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2422                 talloc_free(r);
2423                 return false;
2424         }
2425 
2426         pull = ndr_pull_init_blob(&blob, r, NULL);
2427         if (pull == NULL) {
2428                 talloc_free(r);
2429                 return false;
2430         }
2431 
2432         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2433         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2434         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2435                 talloc_free(r);
2436                 return false;
2437         }
2438 
2439         if (DEBUGLEVEL >= 10) {
2440                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, r);
2441         }
2442 
2443         ZERO_STRUCT(r->out);
2444         r->out.luid = talloc_zero(r, struct lsa_LUID);
2445         if (r->out.luid == NULL) {
2446                 talloc_free(r);
2447                 return false;
2448         }
2449 
2450         r->out.result = _lsa_LookupPrivValue(p, r);
2451 
2452         if (p->rng_fault_state) {
2453                 talloc_free(r);
2454                 /* Return true here, srv_pipe_hnd.c will take care */
2455                 return true;
2456         }
2457 
2458         if (DEBUGLEVEL >= 10) {
2459                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, r);
2460         }
2461 
2462         push = ndr_push_init_ctx(r, NULL);
2463         if (push == NULL) {
2464                 talloc_free(r);
2465                 return false;
2466         }
2467 
2468         ndr_err = call->ndr_push(push, NDR_OUT, r);
2469         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2470                 talloc_free(r);
2471                 return false;
2472         }
2473 
2474         blob = ndr_push_blob(push);
2475         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2476                 talloc_free(r);
2477                 return false;
2478         }
2479 
2480         talloc_free(r);
2481 
2482         return true;
2483 }
2484 
2485 static bool api_lsa_LookupPrivName(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2486 {
2487         const struct ndr_interface_call *call;
2488         struct ndr_pull *pull;
2489         struct ndr_push *push;
2490         enum ndr_err_code ndr_err;
2491         DATA_BLOB blob;
2492         struct lsa_LookupPrivName *r;
2493 
2494         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVNAME];
2495 
2496         r = talloc(talloc_tos(), struct lsa_LookupPrivName);
2497         if (r == NULL) {
2498                 return false;
2499         }
2500 
2501         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2502                 talloc_free(r);
2503                 return false;
2504         }
2505 
2506         pull = ndr_pull_init_blob(&blob, r, NULL);
2507         if (pull == NULL) {
2508                 talloc_free(r);
2509                 return false;
2510         }
2511 
2512         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2513         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2514         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2515                 talloc_free(r);
2516                 return false;
2517         }
2518 
2519         if (DEBUGLEVEL >= 10) {
2520                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, r);
2521         }
2522 
2523         ZERO_STRUCT(r->out);
2524         r->out.name = talloc_zero(r, struct lsa_StringLarge *);
2525         if (r->out.name == NULL) {
2526                 talloc_free(r);
2527                 return false;
2528         }
2529 
2530         r->out.result = _lsa_LookupPrivName(p, r);
2531 
2532         if (p->rng_fault_state) {
2533                 talloc_free(r);
2534                 /* Return true here, srv_pipe_hnd.c will take care */
2535                 return true;
2536         }
2537 
2538         if (DEBUGLEVEL >= 10) {
2539                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, r);
2540         }
2541 
2542         push = ndr_push_init_ctx(r, NULL);
2543         if (push == NULL) {
2544                 talloc_free(r);
2545                 return false;
2546         }
2547 
2548         ndr_err = call->ndr_push(push, NDR_OUT, r);
2549         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2550                 talloc_free(r);
2551                 return false;
2552         }
2553 
2554         blob = ndr_push_blob(push);
2555         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2556                 talloc_free(r);
2557                 return false;
2558         }
2559 
2560         talloc_free(r);
2561 
2562         return true;
2563 }
2564 
2565 static bool api_lsa_LookupPrivDisplayName(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2566 {
2567         const struct ndr_interface_call *call;
2568         struct ndr_pull *pull;
2569         struct ndr_push *push;
2570         enum ndr_err_code ndr_err;
2571         DATA_BLOB blob;
2572         struct lsa_LookupPrivDisplayName *r;
2573 
2574         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVDISPLAYNAME];
2575 
2576         r = talloc(talloc_tos(), struct lsa_LookupPrivDisplayName);
2577         if (r == NULL) {
2578                 return false;
2579         }
2580 
2581         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2582                 talloc_free(r);
2583                 return false;
2584         }
2585 
2586         pull = ndr_pull_init_blob(&blob, r, NULL);
2587         if (pull == NULL) {
2588                 talloc_free(r);
2589                 return false;
2590         }
2591 
2592         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2593         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2594         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2595                 talloc_free(r);
2596                 return false;
2597         }
2598 
2599         if (DEBUGLEVEL >= 10) {
2600                 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, r);
2601         }
2602 
2603         ZERO_STRUCT(r->out);
2604         r->out.disp_name = talloc_zero(r, struct lsa_StringLarge *);
2605         if (r->out.disp_name == NULL) {
2606                 talloc_free(r);
2607                 return false;
2608         }
2609 
2610         r->out.returned_language_id = talloc_zero(r, uint16_t);
2611         if (r->out.returned_language_id == NULL) {
2612                 talloc_free(r);
2613                 return false;
2614         }
2615 
2616         r->out.result = _lsa_LookupPrivDisplayName(p, r);
2617 
2618         if (p->rng_fault_state) {
2619                 talloc_free(r);
2620                 /* Return true here, srv_pipe_hnd.c will take care */
2621                 return true;
2622         }
2623 
2624         if (DEBUGLEVEL >= 10) {
2625                 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, r);
2626         }
2627 
2628         push = ndr_push_init_ctx(r, NULL);
2629         if (push == NULL) {
2630                 talloc_free(r);
2631                 return false;
2632         }
2633 
2634         ndr_err = call->ndr_push(push, NDR_OUT, r);
2635         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2636                 talloc_free(r);
2637                 return false;
2638         }
2639 
2640         blob = ndr_push_blob(push);
2641         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2642                 talloc_free(r);
2643                 return false;
2644         }
2645 
2646         talloc_free(r);
2647 
2648         return true;
2649 }
2650 
2651 static bool api_lsa_DeleteObject(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2652 {
2653         const struct ndr_interface_call *call;
2654         struct ndr_pull *pull;
2655         struct ndr_push *push;
2656         enum ndr_err_code ndr_err;
2657         DATA_BLOB blob;
2658         struct lsa_DeleteObject *r;
2659 
2660         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETEOBJECT];
2661 
2662         r = talloc(talloc_tos(), struct lsa_DeleteObject);
2663         if (r == NULL) {
2664                 return false;
2665         }
2666 
2667         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2668                 talloc_free(r);
2669                 return false;
2670         }
2671 
2672         pull = ndr_pull_init_blob(&blob, r, NULL);
2673         if (pull == NULL) {
2674                 talloc_free(r);
2675                 return false;
2676         }
2677 
2678         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2679         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2680         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2681                 talloc_free(r);
2682                 return false;
2683         }
2684 
2685         if (DEBUGLEVEL >= 10) {
2686                 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, r);
2687         }
2688 
2689         ZERO_STRUCT(r->out);
2690         r->out.handle = r->in.handle;
2691         r->out.result = _lsa_DeleteObject(p, r);
2692 
2693         if (p->rng_fault_state) {
2694                 talloc_free(r);
2695                 /* Return true here, srv_pipe_hnd.c will take care */
2696                 return true;
2697         }
2698 
2699         if (DEBUGLEVEL >= 10) {
2700                 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, r);
2701         }
2702 
2703         push = ndr_push_init_ctx(r, NULL);
2704         if (push == NULL) {
2705                 talloc_free(r);
2706                 return false;
2707         }
2708 
2709         ndr_err = call->ndr_push(push, NDR_OUT, r);
2710         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2711                 talloc_free(r);
2712                 return false;
2713         }
2714 
2715         blob = ndr_push_blob(push);
2716         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2717                 talloc_free(r);
2718                 return false;
2719         }
2720 
2721         talloc_free(r);
2722 
2723         return true;
2724 }
2725 
2726 static bool api_lsa_EnumAccountsWithUserRight(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2727 {
2728         const struct ndr_interface_call *call;
2729         struct ndr_pull *pull;
2730         struct ndr_push *push;
2731         enum ndr_err_code ndr_err;
2732         DATA_BLOB blob;
2733         struct lsa_EnumAccountsWithUserRight *r;
2734 
2735         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT];
2736 
2737         r = talloc(talloc_tos(), struct lsa_EnumAccountsWithUserRight);
2738         if (r == NULL) {
2739                 return false;
2740         }
2741 
2742         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2743                 talloc_free(r);
2744                 return false;
2745         }
2746 
2747         pull = ndr_pull_init_blob(&blob, r, NULL);
2748         if (pull == NULL) {
2749                 talloc_free(r);
2750                 return false;
2751         }
2752 
2753         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2754         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2755         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2756                 talloc_free(r);
2757                 return false;
2758         }
2759 
2760         if (DEBUGLEVEL >= 10) {
2761                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, r);
2762         }
2763 
2764         ZERO_STRUCT(r->out);
2765         r->out.sids = talloc_zero(r, struct lsa_SidArray);
2766         if (r->out.sids == NULL) {
2767                 talloc_free(r);
2768                 return false;
2769         }
2770 
2771         r->out.result = _lsa_EnumAccountsWithUserRight(p, r);
2772 
2773         if (p->rng_fault_state) {
2774                 talloc_free(r);
2775                 /* Return true here, srv_pipe_hnd.c will take care */
2776                 return true;
2777         }
2778 
2779         if (DEBUGLEVEL >= 10) {
2780                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, r);
2781         }
2782 
2783         push = ndr_push_init_ctx(r, NULL);
2784         if (push == NULL) {
2785                 talloc_free(r);
2786                 return false;
2787         }
2788 
2789         ndr_err = call->ndr_push(push, NDR_OUT, r);
2790         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2791                 talloc_free(r);
2792                 return false;
2793         }
2794 
2795         blob = ndr_push_blob(push);
2796         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2797                 talloc_free(r);
2798                 return false;
2799         }
2800 
2801         talloc_free(r);
2802 
2803         return true;
2804 }
2805 
2806 static bool api_lsa_EnumAccountRights(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2807 {
2808         const struct ndr_interface_call *call;
2809         struct ndr_pull *pull;
2810         struct ndr_push *push;
2811         enum ndr_err_code ndr_err;
2812         DATA_BLOB blob;
2813         struct lsa_EnumAccountRights *r;
2814 
2815         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTRIGHTS];
2816 
2817         r = talloc(talloc_tos(), struct lsa_EnumAccountRights);
2818         if (r == NULL) {
2819                 return false;
2820         }
2821 
2822         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2823                 talloc_free(r);
2824                 return false;
2825         }
2826 
2827         pull = ndr_pull_init_blob(&blob, r, NULL);
2828         if (pull == NULL) {
2829                 talloc_free(r);
2830                 return false;
2831         }
2832 
2833         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2834         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2835         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2836                 talloc_free(r);
2837                 return false;
2838         }
2839 
2840         if (DEBUGLEVEL >= 10) {
2841                 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, r);
2842         }
2843 
2844         ZERO_STRUCT(r->out);
2845         r->out.rights = talloc_zero(r, struct lsa_RightSet);
2846         if (r->out.rights == NULL) {
2847                 talloc_free(r);
2848                 return false;
2849         }
2850 
2851         r->out.result = _lsa_EnumAccountRights(p, r);
2852 
2853         if (p->rng_fault_state) {
2854                 talloc_free(r);
2855                 /* Return true here, srv_pipe_hnd.c will take care */
2856                 return true;
2857         }
2858 
2859         if (DEBUGLEVEL >= 10) {
2860                 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, r);
2861         }
2862 
2863         push = ndr_push_init_ctx(r, NULL);
2864         if (push == NULL) {
2865                 talloc_free(r);
2866                 return false;
2867         }
2868 
2869         ndr_err = call->ndr_push(push, NDR_OUT, r);
2870         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2871                 talloc_free(r);
2872                 return false;
2873         }
2874 
2875         blob = ndr_push_blob(push);
2876         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2877                 talloc_free(r);
2878                 return false;
2879         }
2880 
2881         talloc_free(r);
2882 
2883         return true;
2884 }
2885 
2886 static bool api_lsa_AddAccountRights(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2887 {
2888         const struct ndr_interface_call *call;
2889         struct ndr_pull *pull;
2890         struct ndr_push *push;
2891         enum ndr_err_code ndr_err;
2892         DATA_BLOB blob;
2893         struct lsa_AddAccountRights *r;
2894 
2895         call = &ndr_table_lsarpc.calls[NDR_LSA_ADDACCOUNTRIGHTS];
2896 
2897         r = talloc(talloc_tos(), struct lsa_AddAccountRights);
2898         if (r == NULL) {
2899                 return false;
2900         }
2901 
2902         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2903                 talloc_free(r);
2904                 return false;
2905         }
2906 
2907         pull = ndr_pull_init_blob(&blob, r, NULL);
2908         if (pull == NULL) {
2909                 talloc_free(r);
2910                 return false;
2911         }
2912 
2913         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2914         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2915         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2916                 talloc_free(r);
2917                 return false;
2918         }
2919 
2920         if (DEBUGLEVEL >= 10) {
2921                 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, r);
2922         }
2923 
2924         r->out.result = _lsa_AddAccountRights(p, r);
2925 
2926         if (p->rng_fault_state) {
2927                 talloc_free(r);
2928                 /* Return true here, srv_pipe_hnd.c will take care */
2929                 return true;
2930         }
2931 
2932         if (DEBUGLEVEL >= 10) {
2933                 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, r);
2934         }
2935 
2936         push = ndr_push_init_ctx(r, NULL);
2937         if (push == NULL) {
2938                 talloc_free(r);
2939                 return false;
2940         }
2941 
2942         ndr_err = call->ndr_push(push, NDR_OUT, r);
2943         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2944                 talloc_free(r);
2945                 return false;
2946         }
2947 
2948         blob = ndr_push_blob(push);
2949         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2950                 talloc_free(r);
2951                 return false;
2952         }
2953 
2954         talloc_free(r);
2955 
2956         return true;
2957 }
2958 
2959 static bool api_lsa_RemoveAccountRights(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2960 {
2961         const struct ndr_interface_call *call;
2962         struct ndr_pull *pull;
2963         struct ndr_push *push;
2964         enum ndr_err_code ndr_err;
2965         DATA_BLOB blob;
2966         struct lsa_RemoveAccountRights *r;
2967 
2968         call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEACCOUNTRIGHTS];
2969 
2970         r = talloc(talloc_tos(), struct lsa_RemoveAccountRights);
2971         if (r == NULL) {
2972                 return false;
2973         }
2974 
2975         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2976                 talloc_free(r);
2977                 return false;
2978         }
2979 
2980         pull = ndr_pull_init_blob(&blob, r, NULL);
2981         if (pull == NULL) {
2982                 talloc_free(r);
2983                 return false;
2984         }
2985 
2986         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2987         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2988         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2989                 talloc_free(r);
2990                 return false;
2991         }
2992 
2993         if (DEBUGLEVEL >= 10) {
2994                 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, r);
2995         }
2996 
2997         r->out.result = _lsa_RemoveAccountRights(p, r);
2998 
2999         if (p->rng_fault_state) {
3000                 talloc_free(r);
3001                 /* Return true here, srv_pipe_hnd.c will take care */
3002                 return true;
3003         }
3004 
3005         if (DEBUGLEVEL >= 10) {
3006                 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, r);
3007         }
3008 
3009         push = ndr_push_init_ctx(r, NULL);
3010         if (push == NULL) {
3011                 talloc_free(r);
3012                 return false;
3013         }
3014 
3015         ndr_err = call->ndr_push(push, NDR_OUT, r);
3016         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3017                 talloc_free(r);
3018                 return false;
3019         }
3020 
3021         blob = ndr_push_blob(push);
3022         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3023                 talloc_free(r);
3024                 return false;
3025         }
3026 
3027         talloc_free(r);
3028 
3029         return true;
3030 }
3031 
3032 static bool api_lsa_QueryTrustedDomainInfoBySid(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3033 {
3034         const struct ndr_interface_call *call;
3035         struct ndr_pull *pull;
3036         struct ndr_push *push;
3037         enum ndr_err_code ndr_err;
3038         DATA_BLOB blob;
3039         struct lsa_QueryTrustedDomainInfoBySid *r;
3040 
3041         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID];
3042 
3043         r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoBySid);
3044         if (r == NULL) {
3045                 return false;
3046         }
3047 
3048         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3049                 talloc_free(r);
3050                 return false;
3051         }
3052 
3053         pull = ndr_pull_init_blob(&blob, r, NULL);
3054         if (pull == NULL) {
3055                 talloc_free(r);
3056                 return false;
3057         }
3058 
3059         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3060         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3061         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3062                 talloc_free(r);
3063                 return false;
3064         }
3065 
3066         if (DEBUGLEVEL >= 10) {
3067                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3068         }
3069 
3070         ZERO_STRUCT(r->out);
3071         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3072         if (r->out.info == NULL) {
3073                 talloc_free(r);
3074                 return false;
3075         }
3076 
3077         r->out.result = _lsa_QueryTrustedDomainInfoBySid(p, r);
3078 
3079         if (p->rng_fault_state) {
3080                 talloc_free(r);
3081                 /* Return true here, srv_pipe_hnd.c will take care */
3082                 return true;
3083         }
3084 
3085         if (DEBUGLEVEL >= 10) {
3086                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3087         }
3088 
3089         push = ndr_push_init_ctx(r, NULL);
3090         if (push == NULL) {
3091                 talloc_free(r);
3092                 return false;
3093         }
3094 
3095         ndr_err = call->ndr_push(push, NDR_OUT, r);
3096         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3097                 talloc_free(r);
3098                 return false;
3099         }
3100 
3101         blob = ndr_push_blob(push);
3102         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3103                 talloc_free(r);
3104                 return false;
3105         }
3106 
3107         talloc_free(r);
3108 
3109         return true;
3110 }
3111 
3112 static bool api_lsa_SetTrustedDomainInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3113 {
3114         const struct ndr_interface_call *call;
3115         struct ndr_pull *pull;
3116         struct ndr_push *push;
3117         enum ndr_err_code ndr_err;
3118         DATA_BLOB blob;
3119         struct lsa_SetTrustedDomainInfo *r;
3120 
3121         call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFO];
3122 
3123         r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfo);
3124         if (r == NULL) {
3125                 return false;
3126         }
3127 
3128         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3129                 talloc_free(r);
3130                 return false;
3131         }
3132 
3133         pull = ndr_pull_init_blob(&blob, r, NULL);
3134         if (pull == NULL) {
3135                 talloc_free(r);
3136                 return false;
3137         }
3138 
3139         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3140         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3141         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3142                 talloc_free(r);
3143                 return false;
3144         }
3145 
3146         if (DEBUGLEVEL >= 10) {
3147                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, r);
3148         }
3149 
3150         r->out.result = _lsa_SetTrustedDomainInfo(p, r);
3151 
3152         if (p->rng_fault_state) {
3153                 talloc_free(r);
3154                 /* Return true here, srv_pipe_hnd.c will take care */
3155                 return true;
3156         }
3157 
3158         if (DEBUGLEVEL >= 10) {
3159                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, r);
3160         }
3161 
3162         push = ndr_push_init_ctx(r, NULL);
3163         if (push == NULL) {
3164                 talloc_free(r);
3165                 return false;
3166         }
3167 
3168         ndr_err = call->ndr_push(push, NDR_OUT, r);
3169         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3170                 talloc_free(r);
3171                 return false;
3172         }
3173 
3174         blob = ndr_push_blob(push);
3175         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3176                 talloc_free(r);
3177                 return false;
3178         }
3179 
3180         talloc_free(r);
3181 
3182         return true;
3183 }
3184 
3185 static bool api_lsa_DeleteTrustedDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3186 {
3187         const struct ndr_interface_call *call;
3188         struct ndr_pull *pull;
3189         struct ndr_push *push;
3190         enum ndr_err_code ndr_err;
3191         DATA_BLOB blob;
3192         struct lsa_DeleteTrustedDomain *r;
3193 
3194         call = &ndr_table_lsarpc.calls[NDR_LSA_DELETETRUSTEDDOMAIN];
3195 
3196         r = talloc(talloc_tos(), struct lsa_DeleteTrustedDomain);
3197         if (r == NULL) {
3198                 return false;
3199         }
3200 
3201         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3202                 talloc_free(r);
3203                 return false;
3204         }
3205 
3206         pull = ndr_pull_init_blob(&blob, r, NULL);
3207         if (pull == NULL) {
3208                 talloc_free(r);
3209                 return false;
3210         }
3211 
3212         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3213         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3214         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3215                 talloc_free(r);
3216                 return false;
3217         }
3218 
3219         if (DEBUGLEVEL >= 10) {
3220                 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, r);
3221         }
3222 
3223         r->out.result = _lsa_DeleteTrustedDomain(p, r);
3224 
3225         if (p->rng_fault_state) {
3226                 talloc_free(r);
3227                 /* Return true here, srv_pipe_hnd.c will take care */
3228                 return true;
3229         }
3230 
3231         if (DEBUGLEVEL >= 10) {
3232                 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, r);
3233         }
3234 
3235         push = ndr_push_init_ctx(r, NULL);
3236         if (push == NULL) {
3237                 talloc_free(r);
3238                 return false;
3239         }
3240 
3241         ndr_err = call->ndr_push(push, NDR_OUT, r);
3242         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3243                 talloc_free(r);
3244                 return false;
3245         }
3246 
3247         blob = ndr_push_blob(push);
3248         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3249                 talloc_free(r);
3250                 return false;
3251         }
3252 
3253         talloc_free(r);
3254 
3255         return true;
3256 }
3257 
3258 static bool api_lsa_StorePrivateData(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3259 {
3260         const struct ndr_interface_call *call;
3261         struct ndr_pull *pull;
3262         struct ndr_push *push;
3263         enum ndr_err_code ndr_err;
3264         DATA_BLOB blob;
3265         struct lsa_StorePrivateData *r;
3266 
3267         call = &ndr_table_lsarpc.calls[NDR_LSA_STOREPRIVATEDATA];
3268 
3269         r = talloc(talloc_tos(), struct lsa_StorePrivateData);
3270         if (r == NULL) {
3271                 return false;
3272         }
3273 
3274         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3275                 talloc_free(r);
3276                 return false;
3277         }
3278 
3279         pull = ndr_pull_init_blob(&blob, r, NULL);
3280         if (pull == NULL) {
3281                 talloc_free(r);
3282                 return false;
3283         }
3284 
3285         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3286         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3287         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3288                 talloc_free(r);
3289                 return false;
3290         }
3291 
3292         if (DEBUGLEVEL >= 10) {
3293                 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, r);
3294         }
3295 
3296         r->out.result = _lsa_StorePrivateData(p, r);
3297 
3298         if (p->rng_fault_state) {
3299                 talloc_free(r);
3300                 /* Return true here, srv_pipe_hnd.c will take care */
3301                 return true;
3302         }
3303 
3304         if (DEBUGLEVEL >= 10) {
3305                 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, r);
3306         }
3307 
3308         push = ndr_push_init_ctx(r, NULL);
3309         if (push == NULL) {
3310                 talloc_free(r);
3311                 return false;
3312         }
3313 
3314         ndr_err = call->ndr_push(push, NDR_OUT, r);
3315         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3316                 talloc_free(r);
3317                 return false;
3318         }
3319 
3320         blob = ndr_push_blob(push);
3321         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3322                 talloc_free(r);
3323                 return false;
3324         }
3325 
3326         talloc_free(r);
3327 
3328         return true;
3329 }
3330 
3331 static bool api_lsa_RetrievePrivateData(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3332 {
3333         const struct ndr_interface_call *call;
3334         struct ndr_pull *pull;
3335         struct ndr_push *push;
3336         enum ndr_err_code ndr_err;
3337         DATA_BLOB blob;
3338         struct lsa_RetrievePrivateData *r;
3339 
3340         call = &ndr_table_lsarpc.calls[NDR_LSA_RETRIEVEPRIVATEDATA];
3341 
3342         r = talloc(talloc_tos(), struct lsa_RetrievePrivateData);
3343         if (r == NULL) {
3344                 return false;
3345         }
3346 
3347         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3348                 talloc_free(r);
3349                 return false;
3350         }
3351 
3352         pull = ndr_pull_init_blob(&blob, r, NULL);
3353         if (pull == NULL) {
3354                 talloc_free(r);
3355                 return false;
3356         }
3357 
3358         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3359         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3360         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3361                 talloc_free(r);
3362                 return false;
3363         }
3364 
3365         if (DEBUGLEVEL >= 10) {
3366                 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, r);
3367         }
3368 
3369         r->out.result = _lsa_RetrievePrivateData(p, r);
3370 
3371         if (p->rng_fault_state) {
3372                 talloc_free(r);
3373                 /* Return true here, srv_pipe_hnd.c will take care */
3374                 return true;
3375         }
3376 
3377         if (DEBUGLEVEL >= 10) {
3378                 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, r);
3379         }
3380 
3381         push = ndr_push_init_ctx(r, NULL);
3382         if (push == NULL) {
3383                 talloc_free(r);
3384                 return false;
3385         }
3386 
3387         ndr_err = call->ndr_push(push, NDR_OUT, r);
3388         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3389                 talloc_free(r);
3390                 return false;
3391         }
3392 
3393         blob = ndr_push_blob(push);
3394         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3395                 talloc_free(r);
3396                 return false;
3397         }
3398 
3399         talloc_free(r);
3400 
3401         return true;
3402 }
3403 
3404 static bool api_lsa_OpenPolicy2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3405 {
3406         const struct ndr_interface_call *call;
3407         struct ndr_pull *pull;
3408         struct ndr_push *push;
3409         enum ndr_err_code ndr_err;
3410         DATA_BLOB blob;
3411         struct lsa_OpenPolicy2 *r;
3412 
3413         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY2];
3414 
3415         r = talloc(talloc_tos(), struct lsa_OpenPolicy2);
3416         if (r == NULL) {
3417                 return false;
3418         }
3419 
3420         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3421                 talloc_free(r);
3422                 return false;
3423         }
3424 
3425         pull = ndr_pull_init_blob(&blob, r, NULL);
3426         if (pull == NULL) {
3427                 talloc_free(r);
3428                 return false;
3429         }
3430 
3431         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3432         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3433         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3434                 talloc_free(r);
3435                 return false;
3436         }
3437 
3438         if (DEBUGLEVEL >= 10) {
3439                 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, r);
3440         }
3441 
3442         ZERO_STRUCT(r->out);
3443         r->out.handle = talloc_zero(r, struct policy_handle);
3444         if (r->out.handle == NULL) {
3445                 talloc_free(r);
3446                 return false;
3447         }
3448 
3449         r->out.result = _lsa_OpenPolicy2(p, r);
3450 
3451         if (p->rng_fault_state) {
3452                 talloc_free(r);
3453                 /* Return true here, srv_pipe_hnd.c will take care */
3454                 return true;
3455         }
3456 
3457         if (DEBUGLEVEL >= 10) {
3458                 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, r);
3459         }
3460 
3461         push = ndr_push_init_ctx(r, NULL);
3462         if (push == NULL) {
3463                 talloc_free(r);
3464                 return false;
3465         }
3466 
3467         ndr_err = call->ndr_push(push, NDR_OUT, r);
3468         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3469                 talloc_free(r);
3470                 return false;
3471         }
3472 
3473         blob = ndr_push_blob(push);
3474         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3475                 talloc_free(r);
3476                 return false;
3477         }
3478 
3479         talloc_free(r);
3480 
3481         return true;
3482 }
3483 
3484 static bool api_lsa_GetUserName(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3485 {
3486         const struct ndr_interface_call *call;
3487         struct ndr_pull *pull;
3488         struct ndr_push *push;
3489         enum ndr_err_code ndr_err;
3490         DATA_BLOB blob;
3491         struct lsa_GetUserName *r;
3492 
3493         call = &ndr_table_lsarpc.calls[NDR_LSA_GETUSERNAME];
3494 
3495         r = talloc(talloc_tos(), struct lsa_GetUserName);
3496         if (r == NULL) {
3497                 return false;
3498         }
3499 
3500         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3501                 talloc_free(r);
3502                 return false;
3503         }
3504 
3505         pull = ndr_pull_init_blob(&blob, r, NULL);
3506         if (pull == NULL) {
3507                 talloc_free(r);
3508                 return false;
3509         }
3510 
3511         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3512         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3513         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3514                 talloc_free(r);
3515                 return false;
3516         }
3517 
3518         if (DEBUGLEVEL >= 10) {
3519                 NDR_PRINT_IN_DEBUG(lsa_GetUserName, r);
3520         }
3521 
3522         ZERO_STRUCT(r->out);
3523         r->out.account_name = r->in.account_name;
3524         r->out.authority_name = r->in.authority_name;
3525         r->out.result = _lsa_GetUserName(p, r);
3526 
3527         if (p->rng_fault_state) {
3528                 talloc_free(r);
3529                 /* Return true here, srv_pipe_hnd.c will take care */
3530                 return true;
3531         }
3532 
3533         if (DEBUGLEVEL >= 10) {
3534                 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, r);
3535         }
3536 
3537         push = ndr_push_init_ctx(r, NULL);
3538         if (push == NULL) {
3539                 talloc_free(r);
3540                 return false;
3541         }
3542 
3543         ndr_err = call->ndr_push(push, NDR_OUT, r);
3544         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3545                 talloc_free(r);
3546                 return false;
3547         }
3548 
3549         blob = ndr_push_blob(push);
3550         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3551                 talloc_free(r);
3552                 return false;
3553         }
3554 
3555         talloc_free(r);
3556 
3557         return true;
3558 }
3559 
3560 static bool api_lsa_QueryInfoPolicy2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3561 {
3562         const struct ndr_interface_call *call;
3563         struct ndr_pull *pull;
3564         struct ndr_push *push;
3565         enum ndr_err_code ndr_err;
3566         DATA_BLOB blob;
3567         struct lsa_QueryInfoPolicy2 *r;
3568 
3569         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY2];
3570 
3571         r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy2);
3572         if (r == NULL) {
3573                 return false;
3574         }
3575 
3576         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3577                 talloc_free(r);
3578                 return false;
3579         }
3580 
3581         pull = ndr_pull_init_blob(&blob, r, NULL);
3582         if (pull == NULL) {
3583                 talloc_free(r);
3584                 return false;
3585         }
3586 
3587         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3588         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3589         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3590                 talloc_free(r);
3591                 return false;
3592         }
3593 
3594         if (DEBUGLEVEL >= 10) {
3595                 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, r);
3596         }
3597 
3598         ZERO_STRUCT(r->out);
3599         r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
3600         if (r->out.info == NULL) {
3601                 talloc_free(r);
3602                 return false;
3603         }
3604 
3605         r->out.result = _lsa_QueryInfoPolicy2(p, r);
3606 
3607         if (p->rng_fault_state) {
3608                 talloc_free(r);
3609                 /* Return true here, srv_pipe_hnd.c will take care */
3610                 return true;
3611         }
3612 
3613         if (DEBUGLEVEL >= 10) {
3614                 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, r);
3615         }
3616 
3617         push = ndr_push_init_ctx(r, NULL);
3618         if (push == NULL) {
3619                 talloc_free(r);
3620                 return false;
3621         }
3622 
3623         ndr_err = call->ndr_push(push, NDR_OUT, r);
3624         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3625                 talloc_free(r);
3626                 return false;
3627         }
3628 
3629         blob = ndr_push_blob(push);
3630         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3631                 talloc_free(r);
3632                 return false;
3633         }
3634 
3635         talloc_free(r);
3636 
3637         return true;
3638 }
3639 
3640 static bool api_lsa_SetInfoPolicy2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3641 {
3642         const struct ndr_interface_call *call;
3643         struct ndr_pull *pull;
3644         struct ndr_push *push;
3645         enum ndr_err_code ndr_err;
3646         DATA_BLOB blob;
3647         struct lsa_SetInfoPolicy2 *r;
3648 
3649         call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY2];
3650 
3651         r = talloc(talloc_tos(), struct lsa_SetInfoPolicy2);
3652         if (r == NULL) {
3653                 return false;
3654         }
3655 
3656         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3657                 talloc_free(r);
3658                 return false;
3659         }
3660 
3661         pull = ndr_pull_init_blob(&blob, r, NULL);
3662         if (pull == NULL) {
3663                 talloc_free(r);
3664                 return false;
3665         }
3666 
3667         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3668         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3669         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3670                 talloc_free(r);
3671                 return false;
3672         }
3673 
3674         if (DEBUGLEVEL >= 10) {
3675                 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, r);
3676         }
3677 
3678         r->out.result = _lsa_SetInfoPolicy2(p, r);
3679 
3680         if (p->rng_fault_state) {
3681                 talloc_free(r);
3682                 /* Return true here, srv_pipe_hnd.c will take care */
3683                 return true;
3684         }
3685 
3686         if (DEBUGLEVEL >= 10) {
3687                 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, r);
3688         }
3689 
3690         push = ndr_push_init_ctx(r, NULL);
3691         if (push == NULL) {
3692                 talloc_free(r);
3693                 return false;
3694         }
3695 
3696         ndr_err = call->ndr_push(push, NDR_OUT, r);
3697         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3698                 talloc_free(r);
3699                 return false;
3700         }
3701 
3702         blob = ndr_push_blob(push);
3703         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3704                 talloc_free(r);
3705                 return false;
3706         }
3707 
3708         talloc_free(r);
3709 
3710         return true;
3711 }
3712 
3713 static bool api_lsa_QueryTrustedDomainInfoByName(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3714 {
3715         const struct ndr_interface_call *call;
3716         struct ndr_pull *pull;
3717         struct ndr_push *push;
3718         enum ndr_err_code ndr_err;
3719         DATA_BLOB blob;
3720         struct lsa_QueryTrustedDomainInfoByName *r;
3721 
3722         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME];
3723 
3724         r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoByName);
3725         if (r == NULL) {
3726                 return false;
3727         }
3728 
3729         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3730                 talloc_free(r);
3731                 return false;
3732         }
3733 
3734         pull = ndr_pull_init_blob(&blob, r, NULL);
3735         if (pull == NULL) {
3736                 talloc_free(r);
3737                 return false;
3738         }
3739 
3740         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3741         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3742         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3743                 talloc_free(r);
3744                 return false;
3745         }
3746 
3747         if (DEBUGLEVEL >= 10) {
3748                 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3749         }
3750 
3751         ZERO_STRUCT(r->out);
3752         r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3753         if (r->out.info == NULL) {
3754                 talloc_free(r);
3755                 return false;
3756         }
3757 
3758         r->out.result = _lsa_QueryTrustedDomainInfoByName(p, r);
3759 
3760         if (p->rng_fault_state) {
3761                 talloc_free(r);
3762                 /* Return true here, srv_pipe_hnd.c will take care */
3763                 return true;
3764         }
3765 
3766         if (DEBUGLEVEL >= 10) {
3767                 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3768         }
3769 
3770         push = ndr_push_init_ctx(r, NULL);
3771         if (push == NULL) {
3772                 talloc_free(r);
3773                 return false;
3774         }
3775 
3776         ndr_err = call->ndr_push(push, NDR_OUT, r);
3777         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3778                 talloc_free(r);
3779                 return false;
3780         }
3781 
3782         blob = ndr_push_blob(push);
3783         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3784                 talloc_free(r);
3785                 return false;
3786         }
3787 
3788         talloc_free(r);
3789 
3790         return true;
3791 }
3792 
3793 static bool api_lsa_SetTrustedDomainInfoByName(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3794 {
3795         const struct ndr_interface_call *call;
3796         struct ndr_pull *pull;
3797         struct ndr_push *push;
3798         enum ndr_err_code ndr_err;
3799         DATA_BLOB blob;
3800         struct lsa_SetTrustedDomainInfoByName *r;
3801 
3802         call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFOBYNAME];
3803 
3804         r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfoByName);
3805         if (r == NULL) {
3806                 return false;
3807         }
3808 
3809         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3810                 talloc_free(r);
3811                 return false;
3812         }
3813 
3814         pull = ndr_pull_init_blob(&blob, r, NULL);
3815         if (pull == NULL) {
3816                 talloc_free(r);
3817                 return false;
3818         }
3819 
3820         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3821         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3822         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3823                 talloc_free(r);
3824                 return false;
3825         }
3826 
3827         if (DEBUGLEVEL >= 10) {
3828                 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3829         }
3830 
3831         r->out.result = _lsa_SetTrustedDomainInfoByName(p, r);
3832 
3833         if (p->rng_fault_state) {
3834                 talloc_free(r);
3835                 /* Return true here, srv_pipe_hnd.c will take care */
3836                 return true;
3837         }
3838 
3839         if (DEBUGLEVEL >= 10) {
3840                 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3841         }
3842 
3843         push = ndr_push_init_ctx(r, NULL);
3844         if (push == NULL) {
3845                 talloc_free(r);
3846                 return false;
3847         }
3848 
3849         ndr_err = call->ndr_push(push, NDR_OUT, r);
3850         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3851                 talloc_free(r);
3852                 return false;
3853         }
3854 
3855         blob = ndr_push_blob(push);
3856         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3857                 talloc_free(r);
3858                 return false;
3859         }
3860 
3861         talloc_free(r);
3862 
3863         return true;
3864 }
3865 
3866 static bool api_lsa_EnumTrustedDomainsEx(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3867 {
3868         const struct ndr_interface_call *call;
3869         struct ndr_pull *pull;
3870         struct ndr_push *push;
3871         enum ndr_err_code ndr_err;
3872         DATA_BLOB blob;
3873         struct lsa_EnumTrustedDomainsEx *r;
3874 
3875         call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTEDDOMAINSEX];
3876 
3877         r = talloc(talloc_tos(), struct lsa_EnumTrustedDomainsEx);
3878         if (r == NULL) {
3879                 return false;
3880         }
3881 
3882         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3883                 talloc_free(r);
3884                 return false;
3885         }
3886 
3887         pull = ndr_pull_init_blob(&blob, r, NULL);
3888         if (pull == NULL) {
3889                 talloc_free(r);
3890                 return false;
3891         }
3892 
3893         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3894         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3895         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3896                 talloc_free(r);
3897                 return false;
3898         }
3899 
3900         if (DEBUGLEVEL >= 10) {
3901                 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, r);
3902         }
3903 
3904         ZERO_STRUCT(r->out);
3905         r->out.resume_handle = r->in.resume_handle;
3906         r->out.domains = talloc_zero(r, struct lsa_DomainListEx);
3907         if (r->out.domains == NULL) {
3908                 talloc_free(r);
3909                 return false;
3910         }
3911 
3912         r->out.result = _lsa_EnumTrustedDomainsEx(p, r);
3913 
3914         if (p->rng_fault_state) {
3915                 talloc_free(r);
3916                 /* Return true here, srv_pipe_hnd.c will take care */
3917                 return true;
3918         }
3919 
3920         if (DEBUGLEVEL >= 10) {
3921                 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, r);
3922         }
3923 
3924         push = ndr_push_init_ctx(r, NULL);
3925         if (push == NULL) {
3926                 talloc_free(r);
3927                 return false;
3928         }
3929 
3930         ndr_err = call->ndr_push(push, NDR_OUT, r);
3931         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3932                 talloc_free(r);
3933                 return false;
3934         }
3935 
3936         blob = ndr_push_blob(push);
3937         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3938                 talloc_free(r);
3939                 return false;
3940         }
3941 
3942         talloc_free(r);
3943 
3944         return true;
3945 }
3946 
3947 static bool api_lsa_CreateTrustedDomainEx(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3948 {
3949         const struct ndr_interface_call *call;
3950         struct ndr_pull *pull;
3951         struct ndr_push *push;
3952         enum ndr_err_code ndr_err;
3953         DATA_BLOB blob;
3954         struct lsa_CreateTrustedDomainEx *r;
3955 
3956         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX];
3957 
3958         r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx);
3959         if (r == NULL) {
3960                 return false;
3961         }
3962 
3963         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3964                 talloc_free(r);
3965                 return false;
3966         }
3967 
3968         pull = ndr_pull_init_blob(&blob, r, NULL);
3969         if (pull == NULL) {
3970                 talloc_free(r);
3971                 return false;
3972         }
3973 
3974         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3975         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3976         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3977                 talloc_free(r);
3978                 return false;
3979         }
3980 
3981         if (DEBUGLEVEL >= 10) {
3982                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, r);
3983         }
3984 
3985         ZERO_STRUCT(r->out);
3986         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
3987         if (r->out.trustdom_handle == NULL) {
3988                 talloc_free(r);
3989                 return false;
3990         }
3991 
3992         r->out.result = _lsa_CreateTrustedDomainEx(p, r);
3993 
3994         if (p->rng_fault_state) {
3995                 talloc_free(r);
3996                 /* Return true here, srv_pipe_hnd.c will take care */
3997                 return true;
3998         }
3999 
4000         if (DEBUGLEVEL >= 10) {
4001                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, r);
4002         }
4003 
4004         push = ndr_push_init_ctx(r, NULL);
4005         if (push == NULL) {
4006                 talloc_free(r);
4007                 return false;
4008         }
4009 
4010         ndr_err = call->ndr_push(push, NDR_OUT, r);
4011         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4012                 talloc_free(r);
4013                 return false;
4014         }
4015 
4016         blob = ndr_push_blob(push);
4017         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4018                 talloc_free(r);
4019                 return false;
4020         }
4021 
4022         talloc_free(r);
4023 
4024         return true;
4025 }
4026 
4027 static bool api_lsa_CloseTrustedDomainEx(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4028 {
4029         const struct ndr_interface_call *call;
4030         struct ndr_pull *pull;
4031         struct ndr_push *push;
4032         enum ndr_err_code ndr_err;
4033         DATA_BLOB blob;
4034         struct lsa_CloseTrustedDomainEx *r;
4035 
4036         call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSETRUSTEDDOMAINEX];
4037 
4038         r = talloc(talloc_tos(), struct lsa_CloseTrustedDomainEx);
4039         if (r == NULL) {
4040                 return false;
4041         }
4042 
4043         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4044                 talloc_free(r);
4045                 return false;
4046         }
4047 
4048         pull = ndr_pull_init_blob(&blob, r, NULL);
4049         if (pull == NULL) {
4050                 talloc_free(r);
4051                 return false;
4052         }
4053 
4054         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4055         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4056         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4057                 talloc_free(r);
4058                 return false;
4059         }
4060 
4061         if (DEBUGLEVEL >= 10) {
4062                 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, r);
4063         }
4064 
4065         ZERO_STRUCT(r->out);
4066         r->out.handle = r->in.handle;
4067         r->out.result = _lsa_CloseTrustedDomainEx(p, r);
4068 
4069         if (p->rng_fault_state) {
4070                 talloc_free(r);
4071                 /* Return true here, srv_pipe_hnd.c will take care */
4072                 return true;
4073         }
4074 
4075         if (DEBUGLEVEL >= 10) {
4076                 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, r);
4077         }
4078 
4079         push = ndr_push_init_ctx(r, NULL);
4080         if (push == NULL) {
4081                 talloc_free(r);
4082                 return false;
4083         }
4084 
4085         ndr_err = call->ndr_push(push, NDR_OUT, r);
4086         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4087                 talloc_free(r);
4088                 return false;
4089         }
4090 
4091         blob = ndr_push_blob(push);
4092         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4093                 talloc_free(r);
4094                 return false;
4095         }
4096 
4097         talloc_free(r);
4098 
4099         return true;
4100 }
4101 
4102 static bool api_lsa_QueryDomainInformationPolicy(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4103 {
4104         const struct ndr_interface_call *call;
4105         struct ndr_pull *pull;
4106         struct ndr_push *push;
4107         enum ndr_err_code ndr_err;
4108         DATA_BLOB blob;
4109         struct lsa_QueryDomainInformationPolicy *r;
4110 
4111         call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYDOMAININFORMATIONPOLICY];
4112 
4113         r = talloc(talloc_tos(), struct lsa_QueryDomainInformationPolicy);
4114         if (r == NULL) {
4115                 return false;
4116         }
4117 
4118         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4119                 talloc_free(r);
4120                 return false;
4121         }
4122 
4123         pull = ndr_pull_init_blob(&blob, r, NULL);
4124         if (pull == NULL) {
4125                 talloc_free(r);
4126                 return false;
4127         }
4128 
4129         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4130         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4131         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4132                 talloc_free(r);
4133                 return false;
4134         }
4135 
4136         if (DEBUGLEVEL >= 10) {
4137                 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, r);
4138         }
4139 
4140         ZERO_STRUCT(r->out);
4141         r->out.info = talloc_zero(r, union lsa_DomainInformationPolicy *);
4142         if (r->out.info == NULL) {
4143                 talloc_free(r);
4144                 return false;
4145         }
4146 
4147         r->out.result = _lsa_QueryDomainInformationPolicy(p, r);
4148 
4149         if (p->rng_fault_state) {
4150                 talloc_free(r);
4151                 /* Return true here, srv_pipe_hnd.c will take care */
4152                 return true;
4153         }
4154 
4155         if (DEBUGLEVEL >= 10) {
4156                 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, r);
4157         }
4158 
4159         push = ndr_push_init_ctx(r, NULL);
4160         if (push == NULL) {
4161                 talloc_free(r);
4162                 return false;
4163         }
4164 
4165         ndr_err = call->ndr_push(push, NDR_OUT, r);
4166         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4167                 talloc_free(r);
4168                 return false;
4169         }
4170 
4171         blob = ndr_push_blob(push);
4172         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4173                 talloc_free(r);
4174                 return false;
4175         }
4176 
4177         talloc_free(r);
4178 
4179         return true;
4180 }
4181 
4182 static bool api_lsa_SetDomainInformationPolicy(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4183 {
4184         const struct ndr_interface_call *call;
4185         struct ndr_pull *pull;
4186         struct ndr_push *push;
4187         enum ndr_err_code ndr_err;
4188         DATA_BLOB blob;
4189         struct lsa_SetDomainInformationPolicy *r;
4190 
4191         call = &ndr_table_lsarpc.calls[NDR_LSA_SETDOMAININFORMATIONPOLICY];
4192 
4193         r = talloc(talloc_tos(), struct lsa_SetDomainInformationPolicy);
4194         if (r == NULL) {
4195                 return false;
4196         }
4197 
4198         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4199                 talloc_free(r);
4200                 return false;
4201         }
4202 
4203         pull = ndr_pull_init_blob(&blob, r, NULL);
4204         if (pull == NULL) {
4205                 talloc_free(r);
4206                 return false;
4207         }
4208 
4209         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4210         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4211         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4212                 talloc_free(r);
4213                 return false;
4214         }
4215 
4216         if (DEBUGLEVEL >= 10) {
4217                 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, r);
4218         }
4219 
4220         r->out.result = _lsa_SetDomainInformationPolicy(p, r);
4221 
4222         if (p->rng_fault_state) {
4223                 talloc_free(r);
4224                 /* Return true here, srv_pipe_hnd.c will take care */
4225                 return true;
4226         }
4227 
4228         if (DEBUGLEVEL >= 10) {
4229                 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, r);
4230         }
4231 
4232         push = ndr_push_init_ctx(r, NULL);
4233         if (push == NULL) {
4234                 talloc_free(r);
4235                 return false;
4236         }
4237 
4238         ndr_err = call->ndr_push(push, NDR_OUT, r);
4239         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4240                 talloc_free(r);
4241                 return false;
4242         }
4243 
4244         blob = ndr_push_blob(push);
4245         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4246                 talloc_free(r);
4247                 return false;
4248         }
4249 
4250         talloc_free(r);
4251 
4252         return true;
4253 }
4254 
4255 static bool api_lsa_OpenTrustedDomainByName(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4256 {
4257         const struct ndr_interface_call *call;
4258         struct ndr_pull *pull;
4259         struct ndr_push *push;
4260         enum ndr_err_code ndr_err;
4261         DATA_BLOB blob;
4262         struct lsa_OpenTrustedDomainByName *r;
4263 
4264         call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAINBYNAME];
4265 
4266         r = talloc(talloc_tos(), struct lsa_OpenTrustedDomainByName);
4267         if (r == NULL) {
4268                 return false;
4269         }
4270 
4271         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4272                 talloc_free(r);
4273                 return false;
4274         }
4275 
4276         pull = ndr_pull_init_blob(&blob, r, NULL);
4277         if (pull == NULL) {
4278                 talloc_free(r);
4279                 return false;
4280         }
4281 
4282         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4283         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4284         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4285                 talloc_free(r);
4286                 return false;
4287         }
4288 
4289         if (DEBUGLEVEL >= 10) {
4290                 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, r);
4291         }
4292 
4293         ZERO_STRUCT(r->out);
4294         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4295         if (r->out.trustdom_handle == NULL) {
4296                 talloc_free(r);
4297                 return false;
4298         }
4299 
4300         r->out.result = _lsa_OpenTrustedDomainByName(p, r);
4301 
4302         if (p->rng_fault_state) {
4303                 talloc_free(r);
4304                 /* Return true here, srv_pipe_hnd.c will take care */
4305                 return true;
4306         }
4307 
4308         if (DEBUGLEVEL >= 10) {
4309                 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, r);
4310         }
4311 
4312         push = ndr_push_init_ctx(r, NULL);
4313         if (push == NULL) {
4314                 talloc_free(r);
4315                 return false;
4316         }
4317 
4318         ndr_err = call->ndr_push(push, NDR_OUT, r);
4319         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4320                 talloc_free(r);
4321                 return false;
4322         }
4323 
4324         blob = ndr_push_blob(push);
4325         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4326                 talloc_free(r);
4327                 return false;
4328         }
4329 
4330         talloc_free(r);
4331 
4332         return true;
4333 }
4334 
4335 static bool api_lsa_TestCall(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4336 {
4337         const struct ndr_interface_call *call;
4338         struct ndr_pull *pull;
4339         struct ndr_push *push;
4340         enum ndr_err_code ndr_err;
4341         DATA_BLOB blob;
4342         struct lsa_TestCall *r;
4343 
4344         call = &ndr_table_lsarpc.calls[NDR_LSA_TESTCALL];
4345 
4346         r = talloc(talloc_tos(), struct lsa_TestCall);
4347         if (r == NULL) {
4348                 return false;
4349         }
4350 
4351         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4352                 talloc_free(r);
4353                 return false;
4354         }
4355 
4356         pull = ndr_pull_init_blob(&blob, r, NULL);
4357         if (pull == NULL) {
4358                 talloc_free(r);
4359                 return false;
4360         }
4361 
4362         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4363         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4364         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4365                 talloc_free(r);
4366                 return false;
4367         }
4368 
4369         if (DEBUGLEVEL >= 10) {
4370                 NDR_PRINT_IN_DEBUG(lsa_TestCall, r);
4371         }
4372 
4373         r->out.result = _lsa_TestCall(p, r);
4374 
4375         if (p->rng_fault_state) {
4376                 talloc_free(r);
4377                 /* Return true here, srv_pipe_hnd.c will take care */
4378                 return true;
4379         }
4380 
4381         if (DEBUGLEVEL >= 10) {
4382                 NDR_PRINT_OUT_DEBUG(lsa_TestCall, r);
4383         }
4384 
4385         push = ndr_push_init_ctx(r, NULL);
4386         if (push == NULL) {
4387                 talloc_free(r);
4388                 return false;
4389         }
4390 
4391         ndr_err = call->ndr_push(push, NDR_OUT, r);
4392         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4393                 talloc_free(r);
4394                 return false;
4395         }
4396 
4397         blob = ndr_push_blob(push);
4398         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4399                 talloc_free(r);
4400                 return false;
4401         }
4402 
4403         talloc_free(r);
4404 
4405         return true;
4406 }
4407 
4408 static bool api_lsa_LookupSids2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4409 {
4410         const struct ndr_interface_call *call;
4411         struct ndr_pull *pull;
4412         struct ndr_push *push;
4413         enum ndr_err_code ndr_err;
4414         DATA_BLOB blob;
4415         struct lsa_LookupSids2 *r;
4416 
4417         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS2];
4418 
4419         r = talloc(talloc_tos(), struct lsa_LookupSids2);
4420         if (r == NULL) {
4421                 return false;
4422         }
4423 
4424         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4425                 talloc_free(r);
4426                 return false;
4427         }
4428 
4429         pull = ndr_pull_init_blob(&blob, r, NULL);
4430         if (pull == NULL) {
4431                 talloc_free(r);
4432                 return false;
4433         }
4434 
4435         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4436         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4437         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4438                 talloc_free(r);
4439                 return false;
4440         }
4441 
4442         if (DEBUGLEVEL >= 10) {
4443                 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, r);
4444         }
4445 
4446         ZERO_STRUCT(r->out);
4447         r->out.names = r->in.names;
4448         r->out.count = r->in.count;
4449         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4450         if (r->out.domains == NULL) {
4451                 talloc_free(r);
4452                 return false;
4453         }
4454 
4455         r->out.result = _lsa_LookupSids2(p, r);
4456 
4457         if (p->rng_fault_state) {
4458                 talloc_free(r);
4459                 /* Return true here, srv_pipe_hnd.c will take care */
4460                 return true;
4461         }
4462 
4463         if (DEBUGLEVEL >= 10) {
4464                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, r);
4465         }
4466 
4467         push = ndr_push_init_ctx(r, NULL);
4468         if (push == NULL) {
4469                 talloc_free(r);
4470                 return false;
4471         }
4472 
4473         ndr_err = call->ndr_push(push, NDR_OUT, r);
4474         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4475                 talloc_free(r);
4476                 return false;
4477         }
4478 
4479         blob = ndr_push_blob(push);
4480         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4481                 talloc_free(r);
4482                 return false;
4483         }
4484 
4485         talloc_free(r);
4486 
4487         return true;
4488 }
4489 
4490 static bool api_lsa_LookupNames2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4491 {
4492         const struct ndr_interface_call *call;
4493         struct ndr_pull *pull;
4494         struct ndr_push *push;
4495         enum ndr_err_code ndr_err;
4496         DATA_BLOB blob;
4497         struct lsa_LookupNames2 *r;
4498 
4499         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES2];
4500 
4501         r = talloc(talloc_tos(), struct lsa_LookupNames2);
4502         if (r == NULL) {
4503                 return false;
4504         }
4505 
4506         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4507                 talloc_free(r);
4508                 return false;
4509         }
4510 
4511         pull = ndr_pull_init_blob(&blob, r, NULL);
4512         if (pull == NULL) {
4513                 talloc_free(r);
4514                 return false;
4515         }
4516 
4517         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4518         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4519         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4520                 talloc_free(r);
4521                 return false;
4522         }
4523 
4524         if (DEBUGLEVEL >= 10) {
4525                 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, r);
4526         }
4527 
4528         ZERO_STRUCT(r->out);
4529         r->out.sids = r->in.sids;
4530         r->out.count = r->in.count;
4531         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4532         if (r->out.domains == NULL) {
4533                 talloc_free(r);
4534                 return false;
4535         }
4536 
4537         r->out.result = _lsa_LookupNames2(p, r);
4538 
4539         if (p->rng_fault_state) {
4540                 talloc_free(r);
4541                 /* Return true here, srv_pipe_hnd.c will take care */
4542                 return true;
4543         }
4544 
4545         if (DEBUGLEVEL >= 10) {
4546                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, r);
4547         }
4548 
4549         push = ndr_push_init_ctx(r, NULL);
4550         if (push == NULL) {
4551                 talloc_free(r);
4552                 return false;
4553         }
4554 
4555         ndr_err = call->ndr_push(push, NDR_OUT, r);
4556         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4557                 talloc_free(r);
4558                 return false;
4559         }
4560 
4561         blob = ndr_push_blob(push);
4562         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4563                 talloc_free(r);
4564                 return false;
4565         }
4566 
4567         talloc_free(r);
4568 
4569         return true;
4570 }
4571 
4572 static bool api_lsa_CreateTrustedDomainEx2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4573 {
4574         const struct ndr_interface_call *call;
4575         struct ndr_pull *pull;
4576         struct ndr_push *push;
4577         enum ndr_err_code ndr_err;
4578         DATA_BLOB blob;
4579         struct lsa_CreateTrustedDomainEx2 *r;
4580 
4581         call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX2];
4582 
4583         r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx2);
4584         if (r == NULL) {
4585                 return false;
4586         }
4587 
4588         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4589                 talloc_free(r);
4590                 return false;
4591         }
4592 
4593         pull = ndr_pull_init_blob(&blob, r, NULL);
4594         if (pull == NULL) {
4595                 talloc_free(r);
4596                 return false;
4597         }
4598 
4599         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4600         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4601         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4602                 talloc_free(r);
4603                 return false;
4604         }
4605 
4606         if (DEBUGLEVEL >= 10) {
4607                 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, r);
4608         }
4609 
4610         ZERO_STRUCT(r->out);
4611         r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4612         if (r->out.trustdom_handle == NULL) {
4613                 talloc_free(r);
4614                 return false;
4615         }
4616 
4617         r->out.result = _lsa_CreateTrustedDomainEx2(p, r);
4618 
4619         if (p->rng_fault_state) {
4620                 talloc_free(r);
4621                 /* Return true here, srv_pipe_hnd.c will take care */
4622                 return true;
4623         }
4624 
4625         if (DEBUGLEVEL >= 10) {
4626                 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, r);
4627         }
4628 
4629         push = ndr_push_init_ctx(r, NULL);
4630         if (push == NULL) {
4631                 talloc_free(r);
4632                 return false;
4633         }
4634 
4635         ndr_err = call->ndr_push(push, NDR_OUT, r);
4636         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4637                 talloc_free(r);
4638                 return false;
4639         }
4640 
4641         blob = ndr_push_blob(push);
4642         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4643                 talloc_free(r);
4644                 return false;
4645         }
4646 
4647         talloc_free(r);
4648 
4649         return true;
4650 }
4651 
4652 static bool api_lsa_CREDRWRITE(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4653 {
4654         const struct ndr_interface_call *call;
4655         struct ndr_pull *pull;
4656         struct ndr_push *push;
4657         enum ndr_err_code ndr_err;
4658         DATA_BLOB blob;
4659         struct lsa_CREDRWRITE *r;
4660 
4661         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITE];
4662 
4663         r = talloc(talloc_tos(), struct lsa_CREDRWRITE);
4664         if (r == NULL) {
4665                 return false;
4666         }
4667 
4668         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4669                 talloc_free(r);
4670                 return false;
4671         }
4672 
4673         pull = ndr_pull_init_blob(&blob, r, NULL);
4674         if (pull == NULL) {
4675                 talloc_free(r);
4676                 return false;
4677         }
4678 
4679         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4680         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4681         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4682                 talloc_free(r);
4683                 return false;
4684         }
4685 
4686         if (DEBUGLEVEL >= 10) {
4687                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, r);
4688         }
4689 
4690         r->out.result = _lsa_CREDRWRITE(p, r);
4691 
4692         if (p->rng_fault_state) {
4693                 talloc_free(r);
4694                 /* Return true here, srv_pipe_hnd.c will take care */
4695                 return true;
4696         }
4697 
4698         if (DEBUGLEVEL >= 10) {
4699                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, r);
4700         }
4701 
4702         push = ndr_push_init_ctx(r, NULL);
4703         if (push == NULL) {
4704                 talloc_free(r);
4705                 return false;
4706         }
4707 
4708         ndr_err = call->ndr_push(push, NDR_OUT, r);
4709         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4710                 talloc_free(r);
4711                 return false;
4712         }
4713 
4714         blob = ndr_push_blob(push);
4715         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4716                 talloc_free(r);
4717                 return false;
4718         }
4719 
4720         talloc_free(r);
4721 
4722         return true;
4723 }
4724 
4725 static bool api_lsa_CREDRREAD(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4726 {
4727         const struct ndr_interface_call *call;
4728         struct ndr_pull *pull;
4729         struct ndr_push *push;
4730         enum ndr_err_code ndr_err;
4731         DATA_BLOB blob;
4732         struct lsa_CREDRREAD *r;
4733 
4734         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREAD];
4735 
4736         r = talloc(talloc_tos(), struct lsa_CREDRREAD);
4737         if (r == NULL) {
4738                 return false;
4739         }
4740 
4741         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4742                 talloc_free(r);
4743                 return false;
4744         }
4745 
4746         pull = ndr_pull_init_blob(&blob, r, NULL);
4747         if (pull == NULL) {
4748                 talloc_free(r);
4749                 return false;
4750         }
4751 
4752         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4753         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4754         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4755                 talloc_free(r);
4756                 return false;
4757         }
4758 
4759         if (DEBUGLEVEL >= 10) {
4760                 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, r);
4761         }
4762 
4763         r->out.result = _lsa_CREDRREAD(p, r);
4764 
4765         if (p->rng_fault_state) {
4766                 talloc_free(r);
4767                 /* Return true here, srv_pipe_hnd.c will take care */
4768                 return true;
4769         }
4770 
4771         if (DEBUGLEVEL >= 10) {
4772                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, r);
4773         }
4774 
4775         push = ndr_push_init_ctx(r, NULL);
4776         if (push == NULL) {
4777                 talloc_free(r);
4778                 return false;
4779         }
4780 
4781         ndr_err = call->ndr_push(push, NDR_OUT, r);
4782         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4783                 talloc_free(r);
4784                 return false;
4785         }
4786 
4787         blob = ndr_push_blob(push);
4788         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4789                 talloc_free(r);
4790                 return false;
4791         }
4792 
4793         talloc_free(r);
4794 
4795         return true;
4796 }
4797 
4798 static bool api_lsa_CREDRENUMERATE(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4799 {
4800         const struct ndr_interface_call *call;
4801         struct ndr_pull *pull;
4802         struct ndr_push *push;
4803         enum ndr_err_code ndr_err;
4804         DATA_BLOB blob;
4805         struct lsa_CREDRENUMERATE *r;
4806 
4807         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRENUMERATE];
4808 
4809         r = talloc(talloc_tos(), struct lsa_CREDRENUMERATE);
4810         if (r == NULL) {
4811                 return false;
4812         }
4813 
4814         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4815                 talloc_free(r);
4816                 return false;
4817         }
4818 
4819         pull = ndr_pull_init_blob(&blob, r, NULL);
4820         if (pull == NULL) {
4821                 talloc_free(r);
4822                 return false;
4823         }
4824 
4825         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4826         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4827         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4828                 talloc_free(r);
4829                 return false;
4830         }
4831 
4832         if (DEBUGLEVEL >= 10) {
4833                 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, r);
4834         }
4835 
4836         r->out.result = _lsa_CREDRENUMERATE(p, r);
4837 
4838         if (p->rng_fault_state) {
4839                 talloc_free(r);
4840                 /* Return true here, srv_pipe_hnd.c will take care */
4841                 return true;
4842         }
4843 
4844         if (DEBUGLEVEL >= 10) {
4845                 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, r);
4846         }
4847 
4848         push = ndr_push_init_ctx(r, NULL);
4849         if (push == NULL) {
4850                 talloc_free(r);
4851                 return false;
4852         }
4853 
4854         ndr_err = call->ndr_push(push, NDR_OUT, r);
4855         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4856                 talloc_free(r);
4857                 return false;
4858         }
4859 
4860         blob = ndr_push_blob(push);
4861         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4862                 talloc_free(r);
4863                 return false;
4864         }
4865 
4866         talloc_free(r);
4867 
4868         return true;
4869 }
4870 
4871 static bool api_lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4872 {
4873         const struct ndr_interface_call *call;
4874         struct ndr_pull *pull;
4875         struct ndr_push *push;
4876         enum ndr_err_code ndr_err;
4877         DATA_BLOB blob;
4878         struct lsa_CREDRWRITEDOMAINCREDENTIALS *r;
4879 
4880         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITEDOMAINCREDENTIALS];
4881 
4882         r = talloc(talloc_tos(), struct lsa_CREDRWRITEDOMAINCREDENTIALS);
4883         if (r == NULL) {
4884                 return false;
4885         }
4886 
4887         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4888                 talloc_free(r);
4889                 return false;
4890         }
4891 
4892         pull = ndr_pull_init_blob(&blob, r, NULL);
4893         if (pull == NULL) {
4894                 talloc_free(r);
4895                 return false;
4896         }
4897 
4898         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4899         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4900         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4901                 talloc_free(r);
4902                 return false;
4903         }
4904 
4905         if (DEBUGLEVEL >= 10) {
4906                 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4907         }
4908 
4909         r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p, r);
4910 
4911         if (p->rng_fault_state) {
4912                 talloc_free(r);
4913                 /* Return true here, srv_pipe_hnd.c will take care */
4914                 return true;
4915         }
4916 
4917         if (DEBUGLEVEL >= 10) {
4918                 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4919         }
4920 
4921         push = ndr_push_init_ctx(r, NULL);
4922         if (push == NULL) {
4923                 talloc_free(r);
4924                 return false;
4925         }
4926 
4927         ndr_err = call->ndr_push(push, NDR_OUT, r);
4928         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4929                 talloc_free(r);
4930                 return false;
4931         }
4932 
4933         blob = ndr_push_blob(push);
4934         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4935                 talloc_free(r);
4936                 return false;
4937         }
4938 
4939         talloc_free(r);
4940 
4941         return true;
4942 }
4943 
4944 static bool api_lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4945 {
4946         const struct ndr_interface_call *call;
4947         struct ndr_pull *pull;
4948         struct ndr_push *push;
4949         enum ndr_err_code ndr_err;
4950         DATA_BLOB blob;
4951         struct lsa_CREDRREADDOMAINCREDENTIALS *r;
4952 
4953         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREADDOMAINCREDENTIALS];
4954 
4955         r = talloc(talloc_tos(), struct lsa_CREDRREADDOMAINCREDENTIALS);
4956         if (r == NULL) {
4957                 return false;
4958         }
4959 
4960         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4961                 talloc_free(r);
4962                 return false;
4963         }
4964 
4965         pull = ndr_pull_init_blob(&blob, r, NULL);
4966         if (pull == NULL) {
4967                 talloc_free(r);
4968                 return false;
4969         }
4970 
4971         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4972         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4973         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4974                 talloc_free(r);
4975                 return false;
4976         }
4977 
4978         if (DEBUGLEVEL >= 10) {
4979                 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4980         }
4981 
4982         r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p, r);
4983 
4984         if (p->rng_fault_state) {
4985                 talloc_free(r);
4986                 /* Return true here, srv_pipe_hnd.c will take care */
4987                 return true;
4988         }
4989 
4990         if (DEBUGLEVEL >= 10) {
4991                 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4992         }
4993 
4994         push = ndr_push_init_ctx(r, NULL);
4995         if (push == NULL) {
4996                 talloc_free(r);
4997                 return false;
4998         }
4999 
5000         ndr_err = call->ndr_push(push, NDR_OUT, r);
5001         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5002                 talloc_free(r);
5003                 return false;
5004         }
5005 
5006         blob = ndr_push_blob(push);
5007         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5008                 talloc_free(r);
5009                 return false;
5010         }
5011 
5012         talloc_free(r);
5013 
5014         return true;
5015 }
5016 
5017 static bool api_lsa_CREDRDELETE(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5018 {
5019         const struct ndr_interface_call *call;
5020         struct ndr_pull *pull;
5021         struct ndr_push *push;
5022         enum ndr_err_code ndr_err;
5023         DATA_BLOB blob;
5024         struct lsa_CREDRDELETE *r;
5025 
5026         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRDELETE];
5027 
5028         r = talloc(talloc_tos(), struct lsa_CREDRDELETE);
5029         if (r == NULL) {
5030                 return false;
5031         }
5032 
5033         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5034                 talloc_free(r);
5035                 return false;
5036         }
5037 
5038         pull = ndr_pull_init_blob(&blob, r, NULL);
5039         if (pull == NULL) {
5040                 talloc_free(r);
5041                 return false;
5042         }
5043 
5044         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5045         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5046         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5047                 talloc_free(r);
5048                 return false;
5049         }
5050 
5051         if (DEBUGLEVEL >= 10) {
5052                 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, r);
5053         }
5054 
5055         r->out.result = _lsa_CREDRDELETE(p, r);
5056 
5057         if (p->rng_fault_state) {
5058                 talloc_free(r);
5059                 /* Return true here, srv_pipe_hnd.c will take care */
5060                 return true;
5061         }
5062 
5063         if (DEBUGLEVEL >= 10) {
5064                 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, r);
5065         }
5066 
5067         push = ndr_push_init_ctx(r, NULL);
5068         if (push == NULL) {
5069                 talloc_free(r);
5070                 return false;
5071         }
5072 
5073         ndr_err = call->ndr_push(push, NDR_OUT, r);
5074         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5075                 talloc_free(r);
5076                 return false;
5077         }
5078 
5079         blob = ndr_push_blob(push);
5080         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5081                 talloc_free(r);
5082                 return false;
5083         }
5084 
5085         talloc_free(r);
5086 
5087         return true;
5088 }
5089 
5090 static bool api_lsa_CREDRGETTARGETINFO(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5091 {
5092         const struct ndr_interface_call *call;
5093         struct ndr_pull *pull;
5094         struct ndr_push *push;
5095         enum ndr_err_code ndr_err;
5096         DATA_BLOB blob;
5097         struct lsa_CREDRGETTARGETINFO *r;
5098 
5099         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETTARGETINFO];
5100 
5101         r = talloc(talloc_tos(), struct lsa_CREDRGETTARGETINFO);
5102         if (r == NULL) {
5103                 return false;
5104         }
5105 
5106         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5107                 talloc_free(r);
5108                 return false;
5109         }
5110 
5111         pull = ndr_pull_init_blob(&blob, r, NULL);
5112         if (pull == NULL) {
5113                 talloc_free(r);
5114                 return false;
5115         }
5116 
5117         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5118         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5119         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5120                 talloc_free(r);
5121                 return false;
5122         }
5123 
5124         if (DEBUGLEVEL >= 10) {
5125                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, r);
5126         }
5127 
5128         r->out.result = _lsa_CREDRGETTARGETINFO(p, r);
5129 
5130         if (p->rng_fault_state) {
5131                 talloc_free(r);
5132                 /* Return true here, srv_pipe_hnd.c will take care */
5133                 return true;
5134         }
5135 
5136         if (DEBUGLEVEL >= 10) {
5137                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, r);
5138         }
5139 
5140         push = ndr_push_init_ctx(r, NULL);
5141         if (push == NULL) {
5142                 talloc_free(r);
5143                 return false;
5144         }
5145 
5146         ndr_err = call->ndr_push(push, NDR_OUT, r);
5147         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5148                 talloc_free(r);
5149                 return false;
5150         }
5151 
5152         blob = ndr_push_blob(push);
5153         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5154                 talloc_free(r);
5155                 return false;
5156         }
5157 
5158         talloc_free(r);
5159 
5160         return true;
5161 }
5162 
5163 static bool api_lsa_CREDRPROFILELOADED(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5164 {
5165         const struct ndr_interface_call *call;
5166         struct ndr_pull *pull;
5167         struct ndr_push *push;
5168         enum ndr_err_code ndr_err;
5169         DATA_BLOB blob;
5170         struct lsa_CREDRPROFILELOADED *r;
5171 
5172         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRPROFILELOADED];
5173 
5174         r = talloc(talloc_tos(), struct lsa_CREDRPROFILELOADED);
5175         if (r == NULL) {
5176                 return false;
5177         }
5178 
5179         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5180                 talloc_free(r);
5181                 return false;
5182         }
5183 
5184         pull = ndr_pull_init_blob(&blob, r, NULL);
5185         if (pull == NULL) {
5186                 talloc_free(r);
5187                 return false;
5188         }
5189 
5190         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5191         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5192         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5193                 talloc_free(r);
5194                 return false;
5195         }
5196 
5197         if (DEBUGLEVEL >= 10) {
5198                 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, r);
5199         }
5200 
5201         r->out.result = _lsa_CREDRPROFILELOADED(p, r);
5202 
5203         if (p->rng_fault_state) {
5204                 talloc_free(r);
5205                 /* Return true here, srv_pipe_hnd.c will take care */
5206                 return true;
5207         }
5208 
5209         if (DEBUGLEVEL >= 10) {
5210                 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, r);
5211         }
5212 
5213         push = ndr_push_init_ctx(r, NULL);
5214         if (push == NULL) {
5215                 talloc_free(r);
5216                 return false;
5217         }
5218 
5219         ndr_err = call->ndr_push(push, NDR_OUT, r);
5220         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5221                 talloc_free(r);
5222                 return false;
5223         }
5224 
5225         blob = ndr_push_blob(push);
5226         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5227                 talloc_free(r);
5228                 return false;
5229         }
5230 
5231         talloc_free(r);
5232 
5233         return true;
5234 }
5235 
5236 static bool api_lsa_LookupNames3(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5237 {
5238         const struct ndr_interface_call *call;
5239         struct ndr_pull *pull;
5240         struct ndr_push *push;
5241         enum ndr_err_code ndr_err;
5242         DATA_BLOB blob;
5243         struct lsa_LookupNames3 *r;
5244 
5245         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES3];
5246 
5247         r = talloc(talloc_tos(), struct lsa_LookupNames3);
5248         if (r == NULL) {
5249                 return false;
5250         }
5251 
5252         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5253                 talloc_free(r);
5254                 return false;
5255         }
5256 
5257         pull = ndr_pull_init_blob(&blob, r, NULL);
5258         if (pull == NULL) {
5259                 talloc_free(r);
5260                 return false;
5261         }
5262 
5263         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5264         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5265         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5266                 talloc_free(r);
5267                 return false;
5268         }
5269 
5270         if (DEBUGLEVEL >= 10) {
5271                 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, r);
5272         }
5273 
5274         ZERO_STRUCT(r->out);
5275         r->out.sids = r->in.sids;
5276         r->out.count = r->in.count;
5277         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5278         if (r->out.domains == NULL) {
5279                 talloc_free(r);
5280                 return false;
5281         }
5282 
5283         r->out.result = _lsa_LookupNames3(p, r);
5284 
5285         if (p->rng_fault_state) {
5286                 talloc_free(r);
5287                 /* Return true here, srv_pipe_hnd.c will take care */
5288                 return true;
5289         }
5290 
5291         if (DEBUGLEVEL >= 10) {
5292                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, r);
5293         }
5294 
5295         push = ndr_push_init_ctx(r, NULL);
5296         if (push == NULL) {
5297                 talloc_free(r);
5298                 return false;
5299         }
5300 
5301         ndr_err = call->ndr_push(push, NDR_OUT, r);
5302         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5303                 talloc_free(r);
5304                 return false;
5305         }
5306 
5307         blob = ndr_push_blob(push);
5308         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5309                 talloc_free(r);
5310                 return false;
5311         }
5312 
5313         talloc_free(r);
5314 
5315         return true;
5316 }
5317 
5318 static bool api_lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5319 {
5320         const struct ndr_interface_call *call;
5321         struct ndr_pull *pull;
5322         struct ndr_push *push;
5323         enum ndr_err_code ndr_err;
5324         DATA_BLOB blob;
5325         struct lsa_CREDRGETSESSIONTYPES *r;
5326 
5327         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETSESSIONTYPES];
5328 
5329         r = talloc(talloc_tos(), struct lsa_CREDRGETSESSIONTYPES);
5330         if (r == NULL) {
5331                 return false;
5332         }
5333 
5334         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5335                 talloc_free(r);
5336                 return false;
5337         }
5338 
5339         pull = ndr_pull_init_blob(&blob, r, NULL);
5340         if (pull == NULL) {
5341                 talloc_free(r);
5342                 return false;
5343         }
5344 
5345         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5346         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5347         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5348                 talloc_free(r);
5349                 return false;
5350         }
5351 
5352         if (DEBUGLEVEL >= 10) {
5353                 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5354         }
5355 
5356         r->out.result = _lsa_CREDRGETSESSIONTYPES(p, r);
5357 
5358         if (p->rng_fault_state) {
5359                 talloc_free(r);
5360                 /* Return true here, srv_pipe_hnd.c will take care */
5361                 return true;
5362         }
5363 
5364         if (DEBUGLEVEL >= 10) {
5365                 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5366         }
5367 
5368         push = ndr_push_init_ctx(r, NULL);
5369         if (push == NULL) {
5370                 talloc_free(r);
5371                 return false;
5372         }
5373 
5374         ndr_err = call->ndr_push(push, NDR_OUT, r);
5375         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5376                 talloc_free(r);
5377                 return false;
5378         }
5379 
5380         blob = ndr_push_blob(push);
5381         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5382                 talloc_free(r);
5383                 return false;
5384         }
5385 
5386         talloc_free(r);
5387 
5388         return true;
5389 }
5390 
5391 static bool api_lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5392 {
5393         const struct ndr_interface_call *call;
5394         struct ndr_pull *pull;
5395         struct ndr_push *push;
5396         enum ndr_err_code ndr_err;
5397         DATA_BLOB blob;
5398         struct lsa_LSARREGISTERAUDITEVENT *r;
5399 
5400         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARREGISTERAUDITEVENT];
5401 
5402         r = talloc(talloc_tos(), struct lsa_LSARREGISTERAUDITEVENT);
5403         if (r == NULL) {
5404                 return false;
5405         }
5406 
5407         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5408                 talloc_free(r);
5409                 return false;
5410         }
5411 
5412         pull = ndr_pull_init_blob(&blob, r, NULL);
5413         if (pull == NULL) {
5414                 talloc_free(r);
5415                 return false;
5416         }
5417 
5418         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5419         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5420         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5421                 talloc_free(r);
5422                 return false;
5423         }
5424 
5425         if (DEBUGLEVEL >= 10) {
5426                 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5427         }
5428 
5429         r->out.result = _lsa_LSARREGISTERAUDITEVENT(p, r);
5430 
5431         if (p->rng_fault_state) {
5432                 talloc_free(r);
5433                 /* Return true here, srv_pipe_hnd.c will take care */
5434                 return true;
5435         }
5436 
5437         if (DEBUGLEVEL >= 10) {
5438                 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5439         }
5440 
5441         push = ndr_push_init_ctx(r, NULL);
5442         if (push == NULL) {
5443                 talloc_free(r);
5444                 return false;
5445         }
5446 
5447         ndr_err = call->ndr_push(push, NDR_OUT, r);
5448         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5449                 talloc_free(r);
5450                 return false;
5451         }
5452 
5453         blob = ndr_push_blob(push);
5454         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5455                 talloc_free(r);
5456                 return false;
5457         }
5458 
5459         talloc_free(r);
5460 
5461         return true;
5462 }
5463 
5464 static bool api_lsa_LSARGENAUDITEVENT(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5465 {
5466         const struct ndr_interface_call *call;
5467         struct ndr_pull *pull;
5468         struct ndr_push *push;
5469         enum ndr_err_code ndr_err;
5470         DATA_BLOB blob;
5471         struct lsa_LSARGENAUDITEVENT *r;
5472 
5473         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARGENAUDITEVENT];
5474 
5475         r = talloc(talloc_tos(), struct lsa_LSARGENAUDITEVENT);
5476         if (r == NULL) {
5477                 return false;
5478         }
5479 
5480         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5481                 talloc_free(r);
5482                 return false;
5483         }
5484 
5485         pull = ndr_pull_init_blob(&blob, r, NULL);
5486         if (pull == NULL) {
5487                 talloc_free(r);
5488                 return false;
5489         }
5490 
5491         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5492         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5493         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5494                 talloc_free(r);
5495                 return false;
5496         }
5497 
5498         if (DEBUGLEVEL >= 10) {
5499                 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, r);
5500         }
5501 
5502         r->out.result = _lsa_LSARGENAUDITEVENT(p, r);
5503 
5504         if (p->rng_fault_state) {
5505                 talloc_free(r);
5506                 /* Return true here, srv_pipe_hnd.c will take care */
5507                 return true;
5508         }
5509 
5510         if (DEBUGLEVEL >= 10) {
5511                 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, r);
5512         }
5513 
5514         push = ndr_push_init_ctx(r, NULL);
5515         if (push == NULL) {
5516                 talloc_free(r);
5517                 return false;
5518         }
5519 
5520         ndr_err = call->ndr_push(push, NDR_OUT, r);
5521         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5522                 talloc_free(r);
5523                 return false;
5524         }
5525 
5526         blob = ndr_push_blob(push);
5527         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5528                 talloc_free(r);
5529                 return false;
5530         }
5531 
5532         talloc_free(r);
5533 
5534         return true;
5535 }
5536 
5537 static bool api_lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5538 {
5539         const struct ndr_interface_call *call;
5540         struct ndr_pull *pull;
5541         struct ndr_push *push;
5542         enum ndr_err_code ndr_err;
5543         DATA_BLOB blob;
5544         struct lsa_LSARUNREGISTERAUDITEVENT *r;
5545 
5546         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARUNREGISTERAUDITEVENT];
5547 
5548         r = talloc(talloc_tos(), struct lsa_LSARUNREGISTERAUDITEVENT);
5549         if (r == NULL) {
5550                 return false;
5551         }
5552 
5553         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5554                 talloc_free(r);
5555                 return false;
5556         }
5557 
5558         pull = ndr_pull_init_blob(&blob, r, NULL);
5559         if (pull == NULL) {
5560                 talloc_free(r);
5561                 return false;
5562         }
5563 
5564         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5565         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5566         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5567                 talloc_free(r);
5568                 return false;
5569         }
5570 
5571         if (DEBUGLEVEL >= 10) {
5572                 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5573         }
5574 
5575         r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(p, r);
5576 
5577         if (p->rng_fault_state) {
5578                 talloc_free(r);
5579                 /* Return true here, srv_pipe_hnd.c will take care */
5580                 return true;
5581         }
5582 
5583         if (DEBUGLEVEL >= 10) {
5584                 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5585         }
5586 
5587         push = ndr_push_init_ctx(r, NULL);
5588         if (push == NULL) {
5589                 talloc_free(r);
5590                 return false;
5591         }
5592 
5593         ndr_err = call->ndr_push(push, NDR_OUT, r);
5594         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5595                 talloc_free(r);
5596                 return false;
5597         }
5598 
5599         blob = ndr_push_blob(push);
5600         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5601                 talloc_free(r);
5602                 return false;
5603         }
5604 
5605         talloc_free(r);
5606 
5607         return true;
5608 }
5609 
5610 static bool api_lsa_lsaRQueryForestTrustInformation(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5611 {
5612         const struct ndr_interface_call *call;
5613         struct ndr_pull *pull;
5614         struct ndr_push *push;
5615         enum ndr_err_code ndr_err;
5616         DATA_BLOB blob;
5617         struct lsa_lsaRQueryForestTrustInformation *r;
5618 
5619         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION];
5620 
5621         r = talloc(talloc_tos(), struct lsa_lsaRQueryForestTrustInformation);
5622         if (r == NULL) {
5623                 return false;
5624         }
5625 
5626         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5627                 talloc_free(r);
5628                 return false;
5629         }
5630 
5631         pull = ndr_pull_init_blob(&blob, r, NULL);
5632         if (pull == NULL) {
5633                 talloc_free(r);
5634                 return false;
5635         }
5636 
5637         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5638         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5639         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5640                 talloc_free(r);
5641                 return false;
5642         }
5643 
5644         if (DEBUGLEVEL >= 10) {
5645                 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5646         }
5647 
5648         ZERO_STRUCT(r->out);
5649         r->out.forest_trust_info = talloc_zero(r, struct lsa_ForestTrustInformation *);
5650         if (r->out.forest_trust_info == NULL) {
5651                 talloc_free(r);
5652                 return false;
5653         }
5654 
5655         r->out.result = _lsa_lsaRQueryForestTrustInformation(p, r);
5656 
5657         if (p->rng_fault_state) {
5658                 talloc_free(r);
5659                 /* Return true here, srv_pipe_hnd.c will take care */
5660                 return true;
5661         }
5662 
5663         if (DEBUGLEVEL >= 10) {
5664                 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5665         }
5666 
5667         push = ndr_push_init_ctx(r, NULL);
5668         if (push == NULL) {
5669                 talloc_free(r);
5670                 return false;
5671         }
5672 
5673         ndr_err = call->ndr_push(push, NDR_OUT, r);
5674         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5675                 talloc_free(r);
5676                 return false;
5677         }
5678 
5679         blob = ndr_push_blob(push);
5680         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5681                 talloc_free(r);
5682                 return false;
5683         }
5684 
5685         talloc_free(r);
5686 
5687         return true;
5688 }
5689 
5690 static bool api_lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5691 {
5692         const struct ndr_interface_call *call;
5693         struct ndr_pull *pull;
5694         struct ndr_push *push;
5695         enum ndr_err_code ndr_err;
5696         DATA_BLOB blob;
5697         struct lsa_LSARSETFORESTTRUSTINFORMATION *r;
5698 
5699         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARSETFORESTTRUSTINFORMATION];
5700 
5701         r = talloc(talloc_tos(), struct lsa_LSARSETFORESTTRUSTINFORMATION);
5702         if (r == NULL) {
5703                 return false;
5704         }
5705 
5706         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5707                 talloc_free(r);
5708                 return false;
5709         }
5710 
5711         pull = ndr_pull_init_blob(&blob, r, NULL);
5712         if (pull == NULL) {
5713                 talloc_free(r);
5714                 return false;
5715         }
5716 
5717         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5718         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5719         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5720                 talloc_free(r);
5721                 return false;
5722         }
5723 
5724         if (DEBUGLEVEL >= 10) {
5725                 NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5726         }
5727 
5728         r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(p, r);
5729 
5730         if (p->rng_fault_state) {
5731                 talloc_free(r);
5732                 /* Return true here, srv_pipe_hnd.c will take care */
5733                 return true;
5734         }
5735 
5736         if (DEBUGLEVEL >= 10) {
5737                 NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5738         }
5739 
5740         push = ndr_push_init_ctx(r, NULL);
5741         if (push == NULL) {
5742                 talloc_free(r);
5743                 return false;
5744         }
5745 
5746         ndr_err = call->ndr_push(push, NDR_OUT, r);
5747         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5748                 talloc_free(r);
5749                 return false;
5750         }
5751 
5752         blob = ndr_push_blob(push);
5753         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5754                 talloc_free(r);
5755                 return false;
5756         }
5757 
5758         talloc_free(r);
5759 
5760         return true;
5761 }
5762 
5763 static bool api_lsa_CREDRRENAME(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5764 {
5765         const struct ndr_interface_call *call;
5766         struct ndr_pull *pull;
5767         struct ndr_push *push;
5768         enum ndr_err_code ndr_err;
5769         DATA_BLOB blob;
5770         struct lsa_CREDRRENAME *r;
5771 
5772         call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRRENAME];
5773 
5774         r = talloc(talloc_tos(), struct lsa_CREDRRENAME);
5775         if (r == NULL) {
5776                 return false;
5777         }
5778 
5779         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5780                 talloc_free(r);
5781                 return false;
5782         }
5783 
5784         pull = ndr_pull_init_blob(&blob, r, NULL);
5785         if (pull == NULL) {
5786                 talloc_free(r);
5787                 return false;
5788         }
5789 
5790         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5791         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5792         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5793                 talloc_free(r);
5794                 return false;
5795         }
5796 
5797         if (DEBUGLEVEL >= 10) {
5798                 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, r);
5799         }
5800 
5801         r->out.result = _lsa_CREDRRENAME(p, r);
5802 
5803         if (p->rng_fault_state) {
5804                 talloc_free(r);
5805                 /* Return true here, srv_pipe_hnd.c will take care */
5806                 return true;
5807         }
5808 
5809         if (DEBUGLEVEL >= 10) {
5810                 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, r);
5811         }
5812 
5813         push = ndr_push_init_ctx(r, NULL);
5814         if (push == NULL) {
5815                 talloc_free(r);
5816                 return false;
5817         }
5818 
5819         ndr_err = call->ndr_push(push, NDR_OUT, r);
5820         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5821                 talloc_free(r);
5822                 return false;
5823         }
5824 
5825         blob = ndr_push_blob(push);
5826         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5827                 talloc_free(r);
5828                 return false;
5829         }
5830 
5831         talloc_free(r);
5832 
5833         return true;
5834 }
5835 
5836 static bool api_lsa_LookupSids3(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5837 {
5838         const struct ndr_interface_call *call;
5839         struct ndr_pull *pull;
5840         struct ndr_push *push;
5841         enum ndr_err_code ndr_err;
5842         DATA_BLOB blob;
5843         struct lsa_LookupSids3 *r;
5844 
5845         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS3];
5846 
5847         r = talloc(talloc_tos(), struct lsa_LookupSids3);
5848         if (r == NULL) {
5849                 return false;
5850         }
5851 
5852         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5853                 talloc_free(r);
5854                 return false;
5855         }
5856 
5857         pull = ndr_pull_init_blob(&blob, r, NULL);
5858         if (pull == NULL) {
5859                 talloc_free(r);
5860                 return false;
5861         }
5862 
5863         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5864         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5865         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5866                 talloc_free(r);
5867                 return false;
5868         }
5869 
5870         if (DEBUGLEVEL >= 10) {
5871                 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, r);
5872         }
5873 
5874         ZERO_STRUCT(r->out);
5875         r->out.names = r->in.names;
5876         r->out.count = r->in.count;
5877         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5878         if (r->out.domains == NULL) {
5879                 talloc_free(r);
5880                 return false;
5881         }
5882 
5883         r->out.result = _lsa_LookupSids3(p, r);
5884 
5885         if (p->rng_fault_state) {
5886                 talloc_free(r);
5887                 /* Return true here, srv_pipe_hnd.c will take care */
5888                 return true;
5889         }
5890 
5891         if (DEBUGLEVEL >= 10) {
5892                 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, r);
5893         }
5894 
5895         push = ndr_push_init_ctx(r, NULL);
5896         if (push == NULL) {
5897                 talloc_free(r);
5898                 return false;
5899         }
5900 
5901         ndr_err = call->ndr_push(push, NDR_OUT, r);
5902         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5903                 talloc_free(r);
5904                 return false;
5905         }
5906 
5907         blob = ndr_push_blob(push);
5908         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5909                 talloc_free(r);
5910                 return false;
5911         }
5912 
5913         talloc_free(r);
5914 
5915         return true;
5916 }
5917 
5918 static bool api_lsa_LookupNames4(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5919 {
5920         const struct ndr_interface_call *call;
5921         struct ndr_pull *pull;
5922         struct ndr_push *push;
5923         enum ndr_err_code ndr_err;
5924         DATA_BLOB blob;
5925         struct lsa_LookupNames4 *r;
5926 
5927         call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES4];
5928 
5929         r = talloc(talloc_tos(), struct lsa_LookupNames4);
5930         if (r == NULL) {
5931                 return false;
5932         }
5933 
5934         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5935                 talloc_free(r);
5936                 return false;
5937         }
5938 
5939         pull = ndr_pull_init_blob(&blob, r, NULL);
5940         if (pull == NULL) {
5941                 talloc_free(r);
5942                 return false;
5943         }
5944 
5945         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5946         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5947         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5948                 talloc_free(r);
5949                 return false;
5950         }
5951 
5952         if (DEBUGLEVEL >= 10) {
5953                 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, r);
5954         }
5955 
5956         ZERO_STRUCT(r->out);
5957         r->out.sids = r->in.sids;
5958         r->out.count = r->in.count;
5959         r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5960         if (r->out.domains == NULL) {
5961                 talloc_free(r);
5962                 return false;
5963         }
5964 
5965         r->out.result = _lsa_LookupNames4(p, r);
5966 
5967         if (p->rng_fault_state) {
5968                 talloc_free(r);
5969                 /* Return true here, srv_pipe_hnd.c will take care */
5970                 return true;
5971         }
5972 
5973         if (DEBUGLEVEL >= 10) {
5974                 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, r);
5975         }
5976 
5977         push = ndr_push_init_ctx(r, NULL);
5978         if (push == NULL) {
5979                 talloc_free(r);
5980                 return false;
5981         }
5982 
5983         ndr_err = call->ndr_push(push, NDR_OUT, r);
5984         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5985                 talloc_free(r);
5986                 return false;
5987         }
5988 
5989         blob = ndr_push_blob(push);
5990         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5991                 talloc_free(r);
5992                 return false;
5993         }
5994 
5995         talloc_free(r);
5996 
5997         return true;
5998 }
5999 
6000 static bool api_lsa_LSAROPENPOLICYSCE(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
6001 {
6002         const struct ndr_interface_call *call;
6003         struct ndr_pull *pull;
6004         struct ndr_push *push;
6005         enum ndr_err_code ndr_err;
6006         DATA_BLOB blob;
6007         struct lsa_LSAROPENPOLICYSCE *r;
6008 
6009         call = &ndr_table_lsarpc.calls[NDR_LSA_LSAROPENPOLICYSCE];
6010 
6011         r = talloc(talloc_tos(), struct lsa_LSAROPENPOLICYSCE);
6012         if (r == NULL) {
6013                 return false;
6014         }
6015 
6016         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6017                 talloc_free(r);
6018                 return false;
6019         }
6020 
6021         pull = ndr_pull_init_blob(&blob, r, NULL);
6022         if (pull == NULL) {
6023                 talloc_free(r);
6024                 return false;
6025         }
6026 
6027         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6028         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6029         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6030                 talloc_free(r);
6031                 return false;
6032         }
6033 
6034         if (DEBUGLEVEL >= 10) {
6035                 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6036         }
6037 
6038         r->out.result = _lsa_LSAROPENPOLICYSCE(p, r);
6039 
6040         if (p->rng_fault_state) {
6041                 talloc_free(r);
6042                 /* Return true here, srv_pipe_hnd.c will take care */
6043                 return true;
6044         }
6045 
6046         if (DEBUGLEVEL >= 10) {
6047                 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6048         }
6049 
6050         push = ndr_push_init_ctx(r, NULL);
6051         if (push == NULL) {
6052                 talloc_free(r);
6053                 return false;
6054         }
6055 
6056         ndr_err = call->ndr_push(push, NDR_OUT, r);
6057         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6058                 talloc_free(r);
6059                 return false;
6060         }
6061 
6062         blob = ndr_push_blob(push);
6063         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6064                 talloc_free(r);
6065                 return false;
6066         }
6067 
6068         talloc_free(r);
6069 
6070         return true;
6071 }
6072 
6073 static bool api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
6074 {
6075         const struct ndr_interface_call *call;
6076         struct ndr_pull *pull;
6077         struct ndr_push *push;
6078         enum ndr_err_code ndr_err;
6079         DATA_BLOB blob;
6080         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r;
6081 
6082         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE];
6083 
6084         r = talloc(talloc_tos(), struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE);
6085         if (r == NULL) {
6086                 return false;
6087         }
6088 
6089         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6090                 talloc_free(r);
6091                 return false;
6092         }
6093 
6094         pull = ndr_pull_init_blob(&blob, r, NULL);
6095         if (pull == NULL) {
6096                 talloc_free(r);
6097                 return false;
6098         }
6099 
6100         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6101         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6102         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6103                 talloc_free(r);
6104                 return false;
6105         }
6106 
6107         if (DEBUGLEVEL >= 10) {
6108                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6109         }
6110 
6111         r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p, r);
6112 
6113         if (p->rng_fault_state) {
6114                 talloc_free(r);
6115                 /* Return true here, srv_pipe_hnd.c will take care */
6116                 return true;
6117         }
6118 
6119         if (DEBUGLEVEL >= 10) {
6120                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6121         }
6122 
6123         push = ndr_push_init_ctx(r, NULL);
6124         if (push == NULL) {
6125                 talloc_free(r);
6126                 return false;
6127         }
6128 
6129         ndr_err = call->ndr_push(push, NDR_OUT, r);
6130         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6131                 talloc_free(r);
6132                 return false;
6133         }
6134 
6135         blob = ndr_push_blob(push);
6136         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6137                 talloc_free(r);
6138                 return false;
6139         }
6140 
6141         talloc_free(r);
6142 
6143         return true;
6144 }
6145 
6146 static bool api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
6147 {
6148         const struct ndr_interface_call *call;
6149         struct ndr_pull *pull;
6150         struct ndr_push *push;
6151         enum ndr_err_code ndr_err;
6152         DATA_BLOB blob;
6153         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r;
6154 
6155         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE];
6156 
6157         r = talloc(talloc_tos(), struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE);
6158         if (r == NULL) {
6159                 return false;
6160         }
6161 
6162         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6163                 talloc_free(r);
6164                 return false;
6165         }
6166 
6167         pull = ndr_pull_init_blob(&blob, r, NULL);
6168         if (pull == NULL) {
6169                 talloc_free(r);
6170                 return false;
6171         }
6172 
6173         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6174         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6175         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6176                 talloc_free(r);
6177                 return false;
6178         }
6179 
6180         if (DEBUGLEVEL >= 10) {
6181                 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6182         }
6183 
6184         r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p, r);
6185 
6186         if (p->rng_fault_state) {
6187                 talloc_free(r);
6188                 /* Return true here, srv_pipe_hnd.c will take care */
6189                 return true;
6190         }
6191 
6192         if (DEBUGLEVEL >= 10) {
6193                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6194         }
6195 
6196         push = ndr_push_init_ctx(r, NULL);
6197         if (push == NULL) {
6198                 talloc_free(r);
6199                 return false;
6200         }
6201 
6202         ndr_err = call->ndr_push(push, NDR_OUT, r);
6203         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6204                 talloc_free(r);
6205                 return false;
6206         }
6207 
6208         blob = ndr_push_blob(push);
6209         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6210                 talloc_free(r);
6211                 return false;
6212         }
6213 
6214         talloc_free(r);
6215 
6216         return true;
6217 }
6218 
6219 static bool api_lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
6220 {
6221         const struct ndr_interface_call *call;
6222         struct ndr_pull *pull;
6223         struct ndr_push *push;
6224         enum ndr_err_code ndr_err;
6225         DATA_BLOB blob;
6226         struct lsa_LSARADTREPORTSECURITYEVENT *r;
6227 
6228         call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREPORTSECURITYEVENT];
6229 
6230         r = talloc(talloc_tos(), struct lsa_LSARADTREPORTSECURITYEVENT);
6231         if (r == NULL) {
6232                 return false;
6233         }
6234 
6235         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6236                 talloc_free(r);
6237                 return false;
6238         }
6239 
6240         pull = ndr_pull_init_blob(&blob, r, NULL);
6241         if (pull == NULL) {
6242                 talloc_free(r);
6243                 return false;
6244         }
6245 
6246         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6247         ndr_err = call->ndr_pull(pull, NDR_IN, r);
6248         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6249                 talloc_free(r);
6250                 return false;
6251         }
6252 
6253         if (DEBUGLEVEL >= 10) {
6254                 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6255         }
6256 
6257         r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(p, r);
6258 
6259         if (p->rng_fault_state) {
6260                 talloc_free(r);
6261                 /* Return true here, srv_pipe_hnd.c will take care */
6262                 return true;
6263         }
6264 
6265         if (DEBUGLEVEL >= 10) {
6266                 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6267         }
6268 
6269         push = ndr_push_init_ctx(r, NULL);
6270         if (push == NULL) {
6271                 talloc_free(r);
6272                 return false;
6273         }
6274 
6275         ndr_err = call->ndr_push(push, NDR_OUT, r);
6276         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6277                 talloc_free(r);
6278                 return false;
6279         }
6280 
6281         blob = ndr_push_blob(push);
6282         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6283                 talloc_free(r);
6284                 return false;
6285         }
6286 
6287         talloc_free(r);
6288 
6289         return true;
6290 }
6291 
6292 
6293 /* Tables */
6294 static struct api_struct api_lsarpc_cmds[] = 
6295 {
6296         {"LSA_CLOSE", NDR_LSA_CLOSE, api_lsa_Close},
6297         {"LSA_DELETE", NDR_LSA_DELETE, api_lsa_Delete},
6298         {"LSA_ENUMPRIVS", NDR_LSA_ENUMPRIVS, api_lsa_EnumPrivs},
6299         {"LSA_QUERYSECURITY", NDR_LSA_QUERYSECURITY, api_lsa_QuerySecurity},
6300         {"LSA_SETSECOBJ", NDR_LSA_SETSECOBJ, api_lsa_SetSecObj},
6301         {"LSA_CHANGEPASSWORD", NDR_LSA_CHANGEPASSWORD, api_lsa_ChangePassword},
6302         {"LSA_OPENPOLICY", NDR_LSA_OPENPOLICY, api_lsa_OpenPolicy},
6303         {"LSA_QUERYINFOPOLICY", NDR_LSA_QUERYINFOPOLICY, api_lsa_QueryInfoPolicy},
6304         {"LSA_SETINFOPOLICY", NDR_LSA_SETINFOPOLICY, api_lsa_SetInfoPolicy},
6305         {"LSA_CLEARAUDITLOG", NDR_LSA_CLEARAUDITLOG, api_lsa_ClearAuditLog},
6306         {"LSA_CREATEACCOUNT", NDR_LSA_CREATEACCOUNT, api_lsa_CreateAccount},
6307         {"LSA_ENUMACCOUNTS", NDR_LSA_ENUMACCOUNTS, api_lsa_EnumAccounts},
6308         {"LSA_CREATETRUSTEDDOMAIN", NDR_LSA_CREATETRUSTEDDOMAIN, api_lsa_CreateTrustedDomain},
6309         {"LSA_ENUMTRUSTDOM", NDR_LSA_ENUMTRUSTDOM, api_lsa_EnumTrustDom},
6310         {"LSA_LOOKUPNAMES", NDR_LSA_LOOKUPNAMES, api_lsa_LookupNames},
6311         {"LSA_LOOKUPSIDS", NDR_LSA_LOOKUPSIDS, api_lsa_LookupSids},
6312         {"LSA_CREATESECRET", NDR_LSA_CREATESECRET, api_lsa_CreateSecret},
6313         {"LSA_OPENACCOUNT", NDR_LSA_OPENACCOUNT, api_lsa_OpenAccount},
6314         {"LSA_ENUMPRIVSACCOUNT", NDR_LSA_ENUMPRIVSACCOUNT, api_lsa_EnumPrivsAccount},
6315         {"LSA_ADDPRIVILEGESTOACCOUNT", NDR_LSA_ADDPRIVILEGESTOACCOUNT, api_lsa_AddPrivilegesToAccount},
6316         {"LSA_REMOVEPRIVILEGESFROMACCOUNT", NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT, api_lsa_RemovePrivilegesFromAccount},
6317         {"LSA_GETQUOTASFORACCOUNT", NDR_LSA_GETQUOTASFORACCOUNT, api_lsa_GetQuotasForAccount},
6318         {"LSA_SETQUOTASFORACCOUNT", NDR_LSA_SETQUOTASFORACCOUNT, api_lsa_SetQuotasForAccount},
6319         {"LSA_GETSYSTEMACCESSACCOUNT", NDR_LSA_GETSYSTEMACCESSACCOUNT, api_lsa_GetSystemAccessAccount},
6320         {"LSA_SETSYSTEMACCESSACCOUNT", NDR_LSA_SETSYSTEMACCESSACCOUNT, api_lsa_SetSystemAccessAccount},
6321         {"LSA_OPENTRUSTEDDOMAIN", NDR_LSA_OPENTRUSTEDDOMAIN, api_lsa_OpenTrustedDomain},
6322         {"LSA_QUERYTRUSTEDDOMAININFO", NDR_LSA_QUERYTRUSTEDDOMAININFO, api_lsa_QueryTrustedDomainInfo},
6323         {"LSA_SETINFORMATIONTRUSTEDDOMAIN", NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN, api_lsa_SetInformationTrustedDomain},
6324         {"LSA_OPENSECRET", NDR_LSA_OPENSECRET, api_lsa_OpenSecret},
6325         {"LSA_SETSECRET", NDR_LSA_SETSECRET, api_lsa_SetSecret},
6326         {"LSA_QUERYSECRET", NDR_LSA_QUERYSECRET, api_lsa_QuerySecret},
6327         {"LSA_LOOKUPPRIVVALUE", NDR_LSA_LOOKUPPRIVVALUE, api_lsa_LookupPrivValue},
6328         {"LSA_LOOKUPPRIVNAME", NDR_LSA_LOOKUPPRIVNAME, api_lsa_LookupPrivName},
6329         {"LSA_LOOKUPPRIVDISPLAYNAME", NDR_LSA_LOOKUPPRIVDISPLAYNAME, api_lsa_LookupPrivDisplayName},
6330         {"LSA_DELETEOBJECT", NDR_LSA_DELETEOBJECT, api_lsa_DeleteObject},
6331         {"LSA_ENUMACCOUNTSWITHUSERRIGHT", NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT, api_lsa_EnumAccountsWithUserRight},
6332         {"LSA_ENUMACCOUNTRIGHTS", NDR_LSA_ENUMACCOUNTRIGHTS, api_lsa_EnumAccountRights},
6333         {"LSA_ADDACCOUNTRIGHTS", NDR_LSA_ADDACCOUNTRIGHTS, api_lsa_AddAccountRights},
6334         {"LSA_REMOVEACCOUNTRIGHTS", NDR_LSA_REMOVEACCOUNTRIGHTS, api_lsa_RemoveAccountRights},
6335         {"LSA_QUERYTRUSTEDDOMAININFOBYSID", NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID, api_lsa_QueryTrustedDomainInfoBySid},
6336         {"LSA_SETTRUSTEDDOMAININFO", NDR_LSA_SETTRUSTEDDOMAININFO, api_lsa_SetTrustedDomainInfo},
6337         {"LSA_DELETETRUSTEDDOMAIN", NDR_LSA_DELETETRUSTEDDOMAIN, api_lsa_DeleteTrustedDomain},
6338         {"LSA_STOREPRIVATEDATA", NDR_LSA_STOREPRIVATEDATA, api_lsa_StorePrivateData},
6339         {"LSA_RETRIEVEPRIVATEDATA", NDR_LSA_RETRIEVEPRIVATEDATA, api_lsa_RetrievePrivateData},
6340         {"LSA_OPENPOLICY2", NDR_LSA_OPENPOLICY2, api_lsa_OpenPolicy2},
6341         {"LSA_GETUSERNAME", NDR_LSA_GETUSERNAME, api_lsa_GetUserName},
6342         {"LSA_QUERYINFOPOLICY2", NDR_LSA_QUERYINFOPOLICY2, api_lsa_QueryInfoPolicy2},
6343         {"LSA_SETINFOPOLICY2", NDR_LSA_SETINFOPOLICY2, api_lsa_SetInfoPolicy2},
6344         {"LSA_QUERYTRUSTEDDOMAININFOBYNAME", NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME, api_lsa_QueryTrustedDomainInfoByName},
6345         {"LSA_SETTRUSTEDDOMAININFOBYNAME", NDR_LSA_SETTRUSTEDDOMAININFOBYNAME, api_lsa_SetTrustedDomainInfoByName},
6346         {"LSA_ENUMTRUSTEDDOMAINSEX", NDR_LSA_ENUMTRUSTEDDOMAINSEX, api_lsa_EnumTrustedDomainsEx},
6347         {"LSA_CREATETRUSTEDDOMAINEX", NDR_LSA_CREATETRUSTEDDOMAINEX, api_lsa_CreateTrustedDomainEx},
6348         {"LSA_CLOSETRUSTEDDOMAINEX", NDR_LSA_CLOSETRUSTEDDOMAINEX, api_lsa_CloseTrustedDomainEx},
6349         {"LSA_QUERYDOMAININFORMATIONPOLICY", NDR_LSA_QUERYDOMAININFORMATIONPOLICY, api_lsa_QueryDomainInformationPolicy},
6350         {"LSA_SETDOMAININFORMATIONPOLICY", NDR_LSA_SETDOMAININFORMATIONPOLICY, api_lsa_SetDomainInformationPolicy},
6351         {"LSA_OPENTRUSTEDDOMAINBYNAME", NDR_LSA_OPENTRUSTEDDOMAINBYNAME, api_lsa_OpenTrustedDomainByName},
6352         {"LSA_TESTCALL", NDR_LSA_TESTCALL, api_lsa_TestCall},
6353         {"LSA_LOOKUPSIDS2", NDR_LSA_LOOKUPSIDS2, api_lsa_LookupSids2},
6354         {"LSA_LOOKUPNAMES2", NDR_LSA_LOOKUPNAMES2, api_lsa_LookupNames2},
6355         {"LSA_CREATETRUSTEDDOMAINEX2", NDR_LSA_CREATETRUSTEDDOMAINEX2, api_lsa_CreateTrustedDomainEx2},
6356         {"LSA_CREDRWRITE", NDR_LSA_CREDRWRITE, api_lsa_CREDRWRITE},
6357         {"LSA_CREDRREAD", NDR_LSA_CREDRREAD, api_lsa_CREDRREAD},
6358         {"LSA_CREDRENUMERATE", NDR_LSA_CREDRENUMERATE, api_lsa_CREDRENUMERATE},
6359         {"LSA_CREDRWRITEDOMAINCREDENTIALS", NDR_LSA_CREDRWRITEDOMAINCREDENTIALS, api_lsa_CREDRWRITEDOMAINCREDENTIALS},
6360         {"LSA_CREDRREADDOMAINCREDENTIALS", NDR_LSA_CREDRREADDOMAINCREDENTIALS, api_lsa_CREDRREADDOMAINCREDENTIALS},
6361         {"LSA_CREDRDELETE", NDR_LSA_CREDRDELETE, api_lsa_CREDRDELETE},
6362         {"LSA_CREDRGETTARGETINFO", NDR_LSA_CREDRGETTARGETINFO, api_lsa_CREDRGETTARGETINFO},
6363         {"LSA_CREDRPROFILELOADED", NDR_LSA_CREDRPROFILELOADED, api_lsa_CREDRPROFILELOADED},
6364         {"LSA_LOOKUPNAMES3", NDR_LSA_LOOKUPNAMES3, api_lsa_LookupNames3},
6365         {"LSA_CREDRGETSESSIONTYPES", NDR_LSA_CREDRGETSESSIONTYPES, api_lsa_CREDRGETSESSIONTYPES},
6366         {"LSA_LSARREGISTERAUDITEVENT", NDR_LSA_LSARREGISTERAUDITEVENT, api_lsa_LSARREGISTERAUDITEVENT},
6367         {"LSA_LSARGENAUDITEVENT", NDR_LSA_LSARGENAUDITEVENT, api_lsa_LSARGENAUDITEVENT},
6368         {"LSA_LSARUNREGISTERAUDITEVENT", NDR_LSA_LSARUNREGISTERAUDITEVENT, api_lsa_LSARUNREGISTERAUDITEVENT},
6369         {"LSA_LSARQUERYFORESTTRUSTINFORMATION", NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION, api_lsa_lsaRQueryForestTrustInformation},
6370         {"LSA_LSARSETFORESTTRUSTINFORMATION", NDR_LSA_LSARSETFORESTTRUSTINFORMATION, api_lsa_LSARSETFORESTTRUSTINFORMATION},
6371         {"LSA_CREDRRENAME", NDR_LSA_CREDRRENAME, api_lsa_CREDRRENAME},
6372         {"LSA_LOOKUPSIDS3", NDR_LSA_LOOKUPSIDS3, api_lsa_LookupSids3},
6373         {"LSA_LOOKUPNAMES4", NDR_LSA_LOOKUPNAMES4, api_lsa_LookupNames4},
6374         {"LSA_LSAROPENPOLICYSCE", NDR_LSA_LSAROPENPOLICYSCE, api_lsa_LSAROPENPOLICYSCE},
6375         {"LSA_LSARADTREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE},
6376         {"LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE},
6377         {"LSA_LSARADTREPORTSECURITYEVENT", NDR_LSA_LSARADTREPORTSECURITYEVENT, api_lsa_LSARADTREPORTSECURITYEVENT},
6378 };
6379 
6380 void lsarpc_get_pipe_fns(struct api_struct **fns, int *n_fns)
     /* [<][>][^][v][top][bottom][index][help] */
6381 {
6382         *fns = api_lsarpc_cmds;
6383         *n_fns = sizeof(api_lsarpc_cmds) / sizeof(struct api_struct);
6384 }
6385 
6386 NTSTATUS rpc_lsarpc_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
     /* [<][>][^][v][top][bottom][index][help] */
6387 {
6388         if (cli->pipes_struct == NULL) {
6389                 return NT_STATUS_INVALID_PARAMETER;
6390         }
6391 
6392         switch (opnum)
6393         {
6394                 case NDR_LSA_CLOSE: {
6395                         struct lsa_Close *r = (struct lsa_Close *)_r;
6396                         ZERO_STRUCT(r->out);
6397                         r->out.handle = r->in.handle;
6398                         r->out.result = _lsa_Close(cli->pipes_struct, r);
6399                         return NT_STATUS_OK;
6400                 }
6401 
6402                 case NDR_LSA_DELETE: {
6403                         struct lsa_Delete *r = (struct lsa_Delete *)_r;
6404                         r->out.result = _lsa_Delete(cli->pipes_struct, r);
6405                         return NT_STATUS_OK;
6406                 }
6407 
6408                 case NDR_LSA_ENUMPRIVS: {
6409                         struct lsa_EnumPrivs *r = (struct lsa_EnumPrivs *)_r;
6410                         ZERO_STRUCT(r->out);
6411                         r->out.resume_handle = r->in.resume_handle;
6412                         r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivArray);
6413                         if (r->out.privs == NULL) {
6414                         return NT_STATUS_NO_MEMORY;
6415                         }
6416 
6417                         r->out.result = _lsa_EnumPrivs(cli->pipes_struct, r);
6418                         return NT_STATUS_OK;
6419                 }
6420 
6421                 case NDR_LSA_QUERYSECURITY: {
6422                         struct lsa_QuerySecurity *r = (struct lsa_QuerySecurity *)_r;
6423                         ZERO_STRUCT(r->out);
6424                         r->out.sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf *);
6425                         if (r->out.sdbuf == NULL) {
6426                         return NT_STATUS_NO_MEMORY;
6427                         }
6428 
6429                         r->out.result = _lsa_QuerySecurity(cli->pipes_struct, r);
6430                         return NT_STATUS_OK;
6431                 }
6432 
6433                 case NDR_LSA_SETSECOBJ: {
6434                         struct lsa_SetSecObj *r = (struct lsa_SetSecObj *)_r;
6435                         r->out.result = _lsa_SetSecObj(cli->pipes_struct, r);
6436                         return NT_STATUS_OK;
6437                 }
6438 
6439                 case NDR_LSA_CHANGEPASSWORD: {
6440                         struct lsa_ChangePassword *r = (struct lsa_ChangePassword *)_r;
6441                         r->out.result = _lsa_ChangePassword(cli->pipes_struct, r);
6442                         return NT_STATUS_OK;
6443                 }
6444 
6445                 case NDR_LSA_OPENPOLICY: {
6446                         struct lsa_OpenPolicy *r = (struct lsa_OpenPolicy *)_r;
6447                         ZERO_STRUCT(r->out);
6448                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6449                         if (r->out.handle == NULL) {
6450                         return NT_STATUS_NO_MEMORY;
6451                         }
6452 
6453                         r->out.result = _lsa_OpenPolicy(cli->pipes_struct, r);
6454                         return NT_STATUS_OK;
6455                 }
6456 
6457                 case NDR_LSA_QUERYINFOPOLICY: {
6458                         struct lsa_QueryInfoPolicy *r = (struct lsa_QueryInfoPolicy *)_r;
6459                         ZERO_STRUCT(r->out);
6460                         r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6461                         if (r->out.info == NULL) {
6462                         return NT_STATUS_NO_MEMORY;
6463                         }
6464 
6465                         r->out.result = _lsa_QueryInfoPolicy(cli->pipes_struct, r);
6466                         return NT_STATUS_OK;
6467                 }
6468 
6469                 case NDR_LSA_SETINFOPOLICY: {
6470                         struct lsa_SetInfoPolicy *r = (struct lsa_SetInfoPolicy *)_r;
6471                         r->out.result = _lsa_SetInfoPolicy(cli->pipes_struct, r);
6472                         return NT_STATUS_OK;
6473                 }
6474 
6475                 case NDR_LSA_CLEARAUDITLOG: {
6476                         struct lsa_ClearAuditLog *r = (struct lsa_ClearAuditLog *)_r;
6477                         r->out.result = _lsa_ClearAuditLog(cli->pipes_struct, r);
6478                         return NT_STATUS_OK;
6479                 }
6480 
6481                 case NDR_LSA_CREATEACCOUNT: {
6482                         struct lsa_CreateAccount *r = (struct lsa_CreateAccount *)_r;
6483                         ZERO_STRUCT(r->out);
6484                         r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6485                         if (r->out.acct_handle == NULL) {
6486                         return NT_STATUS_NO_MEMORY;
6487                         }
6488 
6489                         r->out.result = _lsa_CreateAccount(cli->pipes_struct, r);
6490                         return NT_STATUS_OK;
6491                 }
6492 
6493                 case NDR_LSA_ENUMACCOUNTS: {
6494                         struct lsa_EnumAccounts *r = (struct lsa_EnumAccounts *)_r;
6495                         ZERO_STRUCT(r->out);
6496                         r->out.resume_handle = r->in.resume_handle;
6497                         r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6498                         if (r->out.sids == NULL) {
6499                         return NT_STATUS_NO_MEMORY;
6500                         }
6501 
6502                         r->out.result = _lsa_EnumAccounts(cli->pipes_struct, r);
6503                         return NT_STATUS_OK;
6504                 }
6505 
6506                 case NDR_LSA_CREATETRUSTEDDOMAIN: {
6507                         struct lsa_CreateTrustedDomain *r = (struct lsa_CreateTrustedDomain *)_r;
6508                         ZERO_STRUCT(r->out);
6509                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6510                         if (r->out.trustdom_handle == NULL) {
6511                         return NT_STATUS_NO_MEMORY;
6512                         }
6513 
6514                         r->out.result = _lsa_CreateTrustedDomain(cli->pipes_struct, r);
6515                         return NT_STATUS_OK;
6516                 }
6517 
6518                 case NDR_LSA_ENUMTRUSTDOM: {
6519                         struct lsa_EnumTrustDom *r = (struct lsa_EnumTrustDom *)_r;
6520                         ZERO_STRUCT(r->out);
6521                         r->out.resume_handle = r->in.resume_handle;
6522                         r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainList);
6523                         if (r->out.domains == NULL) {
6524                         return NT_STATUS_NO_MEMORY;
6525                         }
6526 
6527                         r->out.result = _lsa_EnumTrustDom(cli->pipes_struct, r);
6528                         return NT_STATUS_OK;
6529                 }
6530 
6531                 case NDR_LSA_LOOKUPNAMES: {
6532                         struct lsa_LookupNames *r = (struct lsa_LookupNames *)_r;
6533                         ZERO_STRUCT(r->out);
6534                         r->out.sids = r->in.sids;
6535                         r->out.count = r->in.count;
6536                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6537                         if (r->out.domains == NULL) {
6538                         return NT_STATUS_NO_MEMORY;
6539                         }
6540 
6541                         r->out.result = _lsa_LookupNames(cli->pipes_struct, r);
6542                         return NT_STATUS_OK;
6543                 }
6544 
6545                 case NDR_LSA_LOOKUPSIDS: {
6546                         struct lsa_LookupSids *r = (struct lsa_LookupSids *)_r;
6547                         ZERO_STRUCT(r->out);
6548                         r->out.names = r->in.names;
6549                         r->out.count = r->in.count;
6550                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6551                         if (r->out.domains == NULL) {
6552                         return NT_STATUS_NO_MEMORY;
6553                         }
6554 
6555                         r->out.result = _lsa_LookupSids(cli->pipes_struct, r);
6556                         return NT_STATUS_OK;
6557                 }
6558 
6559                 case NDR_LSA_CREATESECRET: {
6560                         struct lsa_CreateSecret *r = (struct lsa_CreateSecret *)_r;
6561                         ZERO_STRUCT(r->out);
6562                         r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6563                         if (r->out.sec_handle == NULL) {
6564                         return NT_STATUS_NO_MEMORY;
6565                         }
6566 
6567                         r->out.result = _lsa_CreateSecret(cli->pipes_struct, r);
6568                         return NT_STATUS_OK;
6569                 }
6570 
6571                 case NDR_LSA_OPENACCOUNT: {
6572                         struct lsa_OpenAccount *r = (struct lsa_OpenAccount *)_r;
6573                         ZERO_STRUCT(r->out);
6574                         r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6575                         if (r->out.acct_handle == NULL) {
6576                         return NT_STATUS_NO_MEMORY;
6577                         }
6578 
6579                         r->out.result = _lsa_OpenAccount(cli->pipes_struct, r);
6580                         return NT_STATUS_OK;
6581                 }
6582 
6583                 case NDR_LSA_ENUMPRIVSACCOUNT: {
6584                         struct lsa_EnumPrivsAccount *r = (struct lsa_EnumPrivsAccount *)_r;
6585                         ZERO_STRUCT(r->out);
6586                         r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivilegeSet *);
6587                         if (r->out.privs == NULL) {
6588                         return NT_STATUS_NO_MEMORY;
6589                         }
6590 
6591                         r->out.result = _lsa_EnumPrivsAccount(cli->pipes_struct, r);
6592                         return NT_STATUS_OK;
6593                 }
6594 
6595                 case NDR_LSA_ADDPRIVILEGESTOACCOUNT: {
6596                         struct lsa_AddPrivilegesToAccount *r = (struct lsa_AddPrivilegesToAccount *)_r;
6597                         r->out.result = _lsa_AddPrivilegesToAccount(cli->pipes_struct, r);
6598                         return NT_STATUS_OK;
6599                 }
6600 
6601                 case NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT: {
6602                         struct lsa_RemovePrivilegesFromAccount *r = (struct lsa_RemovePrivilegesFromAccount *)_r;
6603                         r->out.result = _lsa_RemovePrivilegesFromAccount(cli->pipes_struct, r);
6604                         return NT_STATUS_OK;
6605                 }
6606 
6607                 case NDR_LSA_GETQUOTASFORACCOUNT: {
6608                         struct lsa_GetQuotasForAccount *r = (struct lsa_GetQuotasForAccount *)_r;
6609                         r->out.result = _lsa_GetQuotasForAccount(cli->pipes_struct, r);
6610                         return NT_STATUS_OK;
6611                 }
6612 
6613                 case NDR_LSA_SETQUOTASFORACCOUNT: {
6614                         struct lsa_SetQuotasForAccount *r = (struct lsa_SetQuotasForAccount *)_r;
6615                         r->out.result = _lsa_SetQuotasForAccount(cli->pipes_struct, r);
6616                         return NT_STATUS_OK;
6617                 }
6618 
6619                 case NDR_LSA_GETSYSTEMACCESSACCOUNT: {
6620                         struct lsa_GetSystemAccessAccount *r = (struct lsa_GetSystemAccessAccount *)_r;
6621                         ZERO_STRUCT(r->out);
6622                         r->out.access_mask = talloc_zero(mem_ctx, uint32_t);
6623                         if (r->out.access_mask == NULL) {
6624                         return NT_STATUS_NO_MEMORY;
6625                         }
6626 
6627                         r->out.result = _lsa_GetSystemAccessAccount(cli->pipes_struct, r);
6628                         return NT_STATUS_OK;
6629                 }
6630 
6631                 case NDR_LSA_SETSYSTEMACCESSACCOUNT: {
6632                         struct lsa_SetSystemAccessAccount *r = (struct lsa_SetSystemAccessAccount *)_r;
6633                         r->out.result = _lsa_SetSystemAccessAccount(cli->pipes_struct, r);
6634                         return NT_STATUS_OK;
6635                 }
6636 
6637                 case NDR_LSA_OPENTRUSTEDDOMAIN: {
6638                         struct lsa_OpenTrustedDomain *r = (struct lsa_OpenTrustedDomain *)_r;
6639                         ZERO_STRUCT(r->out);
6640                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6641                         if (r->out.trustdom_handle == NULL) {
6642                         return NT_STATUS_NO_MEMORY;
6643                         }
6644 
6645                         r->out.result = _lsa_OpenTrustedDomain(cli->pipes_struct, r);
6646                         return NT_STATUS_OK;
6647                 }
6648 
6649                 case NDR_LSA_QUERYTRUSTEDDOMAININFO: {
6650                         struct lsa_QueryTrustedDomainInfo *r = (struct lsa_QueryTrustedDomainInfo *)_r;
6651                         ZERO_STRUCT(r->out);
6652                         r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6653                         if (r->out.info == NULL) {
6654                         return NT_STATUS_NO_MEMORY;
6655                         }
6656 
6657                         r->out.result = _lsa_QueryTrustedDomainInfo(cli->pipes_struct, r);
6658                         return NT_STATUS_OK;
6659                 }
6660 
6661                 case NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN: {
6662                         struct lsa_SetInformationTrustedDomain *r = (struct lsa_SetInformationTrustedDomain *)_r;
6663                         r->out.result = _lsa_SetInformationTrustedDomain(cli->pipes_struct, r);
6664                         return NT_STATUS_OK;
6665                 }
6666 
6667                 case NDR_LSA_OPENSECRET: {
6668                         struct lsa_OpenSecret *r = (struct lsa_OpenSecret *)_r;
6669                         ZERO_STRUCT(r->out);
6670                         r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6671                         if (r->out.sec_handle == NULL) {
6672                         return NT_STATUS_NO_MEMORY;
6673                         }
6674 
6675                         r->out.result = _lsa_OpenSecret(cli->pipes_struct, r);
6676                         return NT_STATUS_OK;
6677                 }
6678 
6679                 case NDR_LSA_SETSECRET: {
6680                         struct lsa_SetSecret *r = (struct lsa_SetSecret *)_r;
6681                         r->out.result = _lsa_SetSecret(cli->pipes_struct, r);
6682                         return NT_STATUS_OK;
6683                 }
6684 
6685                 case NDR_LSA_QUERYSECRET: {
6686                         struct lsa_QuerySecret *r = (struct lsa_QuerySecret *)_r;
6687                         ZERO_STRUCT(r->out);
6688                         r->out.new_val = r->in.new_val;
6689                         r->out.new_mtime = r->in.new_mtime;
6690                         r->out.old_val = r->in.old_val;
6691                         r->out.old_mtime = r->in.old_mtime;
6692                         r->out.result = _lsa_QuerySecret(cli->pipes_struct, r);
6693                         return NT_STATUS_OK;
6694                 }
6695 
6696                 case NDR_LSA_LOOKUPPRIVVALUE: {
6697                         struct lsa_LookupPrivValue *r = (struct lsa_LookupPrivValue *)_r;
6698                         ZERO_STRUCT(r->out);
6699                         r->out.luid = talloc_zero(mem_ctx, struct lsa_LUID);
6700                         if (r->out.luid == NULL) {
6701                         return NT_STATUS_NO_MEMORY;
6702                         }
6703 
6704                         r->out.result = _lsa_LookupPrivValue(cli->pipes_struct, r);
6705                         return NT_STATUS_OK;
6706                 }
6707 
6708                 case NDR_LSA_LOOKUPPRIVNAME: {
6709                         struct lsa_LookupPrivName *r = (struct lsa_LookupPrivName *)_r;
6710                         ZERO_STRUCT(r->out);
6711                         r->out.name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6712                         if (r->out.name == NULL) {
6713                         return NT_STATUS_NO_MEMORY;
6714                         }
6715 
6716                         r->out.result = _lsa_LookupPrivName(cli->pipes_struct, r);
6717                         return NT_STATUS_OK;
6718                 }
6719 
6720                 case NDR_LSA_LOOKUPPRIVDISPLAYNAME: {
6721                         struct lsa_LookupPrivDisplayName *r = (struct lsa_LookupPrivDisplayName *)_r;
6722                         ZERO_STRUCT(r->out);
6723                         r->out.disp_name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6724                         if (r->out.disp_name == NULL) {
6725                         return NT_STATUS_NO_MEMORY;
6726                         }
6727 
6728                         r->out.returned_language_id = talloc_zero(mem_ctx, uint16_t);
6729                         if (r->out.returned_language_id == NULL) {
6730                         return NT_STATUS_NO_MEMORY;
6731                         }
6732 
6733                         r->out.result = _lsa_LookupPrivDisplayName(cli->pipes_struct, r);
6734                         return NT_STATUS_OK;
6735                 }
6736 
6737                 case NDR_LSA_DELETEOBJECT: {
6738                         struct lsa_DeleteObject *r = (struct lsa_DeleteObject *)_r;
6739                         ZERO_STRUCT(r->out);
6740                         r->out.handle = r->in.handle;
6741                         r->out.result = _lsa_DeleteObject(cli->pipes_struct, r);
6742                         return NT_STATUS_OK;
6743                 }
6744 
6745                 case NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT: {
6746                         struct lsa_EnumAccountsWithUserRight *r = (struct lsa_EnumAccountsWithUserRight *)_r;
6747                         ZERO_STRUCT(r->out);
6748                         r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6749                         if (r->out.sids == NULL) {
6750                         return NT_STATUS_NO_MEMORY;
6751                         }
6752 
6753                         r->out.result = _lsa_EnumAccountsWithUserRight(cli->pipes_struct, r);
6754                         return NT_STATUS_OK;
6755                 }
6756 
6757                 case NDR_LSA_ENUMACCOUNTRIGHTS: {
6758                         struct lsa_EnumAccountRights *r = (struct lsa_EnumAccountRights *)_r;
6759                         ZERO_STRUCT(r->out);
6760                         r->out.rights = talloc_zero(mem_ctx, struct lsa_RightSet);
6761                         if (r->out.rights == NULL) {
6762                         return NT_STATUS_NO_MEMORY;
6763                         }
6764 
6765                         r->out.result = _lsa_EnumAccountRights(cli->pipes_struct, r);
6766                         return NT_STATUS_OK;
6767                 }
6768 
6769                 case NDR_LSA_ADDACCOUNTRIGHTS: {
6770                         struct lsa_AddAccountRights *r = (struct lsa_AddAccountRights *)_r;
6771                         r->out.result = _lsa_AddAccountRights(cli->pipes_struct, r);
6772                         return NT_STATUS_OK;
6773                 }
6774 
6775                 case NDR_LSA_REMOVEACCOUNTRIGHTS: {
6776                         struct lsa_RemoveAccountRights *r = (struct lsa_RemoveAccountRights *)_r;
6777                         r->out.result = _lsa_RemoveAccountRights(cli->pipes_struct, r);
6778                         return NT_STATUS_OK;
6779                 }
6780 
6781                 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID: {
6782                         struct lsa_QueryTrustedDomainInfoBySid *r = (struct lsa_QueryTrustedDomainInfoBySid *)_r;
6783                         ZERO_STRUCT(r->out);
6784                         r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6785                         if (r->out.info == NULL) {
6786                         return NT_STATUS_NO_MEMORY;
6787                         }
6788 
6789                         r->out.result = _lsa_QueryTrustedDomainInfoBySid(cli->pipes_struct, r);
6790                         return NT_STATUS_OK;
6791                 }
6792 
6793                 case NDR_LSA_SETTRUSTEDDOMAININFO: {
6794                         struct lsa_SetTrustedDomainInfo *r = (struct lsa_SetTrustedDomainInfo *)_r;
6795                         r->out.result = _lsa_SetTrustedDomainInfo(cli->pipes_struct, r);
6796                         return NT_STATUS_OK;
6797                 }
6798 
6799                 case NDR_LSA_DELETETRUSTEDDOMAIN: {
6800                         struct lsa_DeleteTrustedDomain *r = (struct lsa_DeleteTrustedDomain *)_r;
6801                         r->out.result = _lsa_DeleteTrustedDomain(cli->pipes_struct, r);
6802                         return NT_STATUS_OK;
6803                 }
6804 
6805                 case NDR_LSA_STOREPRIVATEDATA: {
6806                         struct lsa_StorePrivateData *r = (struct lsa_StorePrivateData *)_r;
6807                         r->out.result = _lsa_StorePrivateData(cli->pipes_struct, r);
6808                         return NT_STATUS_OK;
6809                 }
6810 
6811                 case NDR_LSA_RETRIEVEPRIVATEDATA: {
6812                         struct lsa_RetrievePrivateData *r = (struct lsa_RetrievePrivateData *)_r;
6813                         r->out.result = _lsa_RetrievePrivateData(cli->pipes_struct, r);
6814                         return NT_STATUS_OK;
6815                 }
6816 
6817                 case NDR_LSA_OPENPOLICY2: {
6818                         struct lsa_OpenPolicy2 *r = (struct lsa_OpenPolicy2 *)_r;
6819                         ZERO_STRUCT(r->out);
6820                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6821                         if (r->out.handle == NULL) {
6822                         return NT_STATUS_NO_MEMORY;
6823                         }
6824 
6825                         r->out.result = _lsa_OpenPolicy2(cli->pipes_struct, r);
6826                         return NT_STATUS_OK;
6827                 }
6828 
6829                 case NDR_LSA_GETUSERNAME: {
6830                         struct lsa_GetUserName *r = (struct lsa_GetUserName *)_r;
6831                         ZERO_STRUCT(r->out);
6832                         r->out.account_name = r->in.account_name;
6833                         r->out.authority_name = r->in.authority_name;
6834                         r->out.result = _lsa_GetUserName(cli->pipes_struct, r);
6835                         return NT_STATUS_OK;
6836                 }
6837 
6838                 case NDR_LSA_QUERYINFOPOLICY2: {
6839                         struct lsa_QueryInfoPolicy2 *r = (struct lsa_QueryInfoPolicy2 *)_r;
6840                         ZERO_STRUCT(r->out);
6841                         r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6842                         if (r->out.info == NULL) {
6843                         return NT_STATUS_NO_MEMORY;
6844                         }
6845 
6846                         r->out.result = _lsa_QueryInfoPolicy2(cli->pipes_struct, r);
6847                         return NT_STATUS_OK;
6848                 }
6849 
6850                 case NDR_LSA_SETINFOPOLICY2: {
6851                         struct lsa_SetInfoPolicy2 *r = (struct lsa_SetInfoPolicy2 *)_r;
6852                         r->out.result = _lsa_SetInfoPolicy2(cli->pipes_struct, r);
6853                         return NT_STATUS_OK;
6854                 }
6855 
6856                 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME: {
6857                         struct lsa_QueryTrustedDomainInfoByName *r = (struct lsa_QueryTrustedDomainInfoByName *)_r;
6858                         ZERO_STRUCT(r->out);
6859                         r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6860                         if (r->out.info == NULL) {
6861                         return NT_STATUS_NO_MEMORY;
6862                         }
6863 
6864                         r->out.result = _lsa_QueryTrustedDomainInfoByName(cli->pipes_struct, r);
6865                         return NT_STATUS_OK;
6866                 }
6867 
6868                 case NDR_LSA_SETTRUSTEDDOMAININFOBYNAME: {
6869                         struct lsa_SetTrustedDomainInfoByName *r = (struct lsa_SetTrustedDomainInfoByName *)_r;
6870                         r->out.result = _lsa_SetTrustedDomainInfoByName(cli->pipes_struct, r);
6871                         return NT_STATUS_OK;
6872                 }
6873 
6874                 case NDR_LSA_ENUMTRUSTEDDOMAINSEX: {
6875                         struct lsa_EnumTrustedDomainsEx *r = (struct lsa_EnumTrustedDomainsEx *)_r;
6876                         ZERO_STRUCT(r->out);
6877                         r->out.resume_handle = r->in.resume_handle;
6878                         r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainListEx);
6879                         if (r->out.domains == NULL) {
6880                         return NT_STATUS_NO_MEMORY;
6881                         }
6882 
6883                         r->out.result = _lsa_EnumTrustedDomainsEx(cli->pipes_struct, r);
6884                         return NT_STATUS_OK;
6885                 }
6886 
6887                 case NDR_LSA_CREATETRUSTEDDOMAINEX: {
6888                         struct lsa_CreateTrustedDomainEx *r = (struct lsa_CreateTrustedDomainEx *)_r;
6889                         ZERO_STRUCT(r->out);
6890                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6891                         if (r->out.trustdom_handle == NULL) {
6892                         return NT_STATUS_NO_MEMORY;
6893                         }
6894 
6895                         r->out.result = _lsa_CreateTrustedDomainEx(cli->pipes_struct, r);
6896                         return NT_STATUS_OK;
6897                 }
6898 
6899                 case NDR_LSA_CLOSETRUSTEDDOMAINEX: {
6900                         struct lsa_CloseTrustedDomainEx *r = (struct lsa_CloseTrustedDomainEx *)_r;
6901                         ZERO_STRUCT(r->out);
6902                         r->out.handle = r->in.handle;
6903                         r->out.result = _lsa_CloseTrustedDomainEx(cli->pipes_struct, r);
6904                         return NT_STATUS_OK;
6905                 }
6906 
6907                 case NDR_LSA_QUERYDOMAININFORMATIONPOLICY: {
6908                         struct lsa_QueryDomainInformationPolicy *r = (struct lsa_QueryDomainInformationPolicy *)_r;
6909                         ZERO_STRUCT(r->out);
6910                         r->out.info = talloc_zero(mem_ctx, union lsa_DomainInformationPolicy *);
6911                         if (r->out.info == NULL) {
6912                         return NT_STATUS_NO_MEMORY;
6913                         }
6914 
6915                         r->out.result = _lsa_QueryDomainInformationPolicy(cli->pipes_struct, r);
6916                         return NT_STATUS_OK;
6917                 }
6918 
6919                 case NDR_LSA_SETDOMAININFORMATIONPOLICY: {
6920                         struct lsa_SetDomainInformationPolicy *r = (struct lsa_SetDomainInformationPolicy *)_r;
6921                         r->out.result = _lsa_SetDomainInformationPolicy(cli->pipes_struct, r);
6922                         return NT_STATUS_OK;
6923                 }
6924 
6925                 case NDR_LSA_OPENTRUSTEDDOMAINBYNAME: {
6926                         struct lsa_OpenTrustedDomainByName *r = (struct lsa_OpenTrustedDomainByName *)_r;
6927                         ZERO_STRUCT(r->out);
6928                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6929                         if (r->out.trustdom_handle == NULL) {
6930                         return NT_STATUS_NO_MEMORY;
6931                         }
6932 
6933                         r->out.result = _lsa_OpenTrustedDomainByName(cli->pipes_struct, r);
6934                         return NT_STATUS_OK;
6935                 }
6936 
6937                 case NDR_LSA_TESTCALL: {
6938                         struct lsa_TestCall *r = (struct lsa_TestCall *)_r;
6939                         r->out.result = _lsa_TestCall(cli->pipes_struct, r);
6940                         return NT_STATUS_OK;
6941                 }
6942 
6943                 case NDR_LSA_LOOKUPSIDS2: {
6944                         struct lsa_LookupSids2 *r = (struct lsa_LookupSids2 *)_r;
6945                         ZERO_STRUCT(r->out);
6946                         r->out.names = r->in.names;
6947                         r->out.count = r->in.count;
6948                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6949                         if (r->out.domains == NULL) {
6950                         return NT_STATUS_NO_MEMORY;
6951                         }
6952 
6953                         r->out.result = _lsa_LookupSids2(cli->pipes_struct, r);
6954                         return NT_STATUS_OK;
6955                 }
6956 
6957                 case NDR_LSA_LOOKUPNAMES2: {
6958                         struct lsa_LookupNames2 *r = (struct lsa_LookupNames2 *)_r;
6959                         ZERO_STRUCT(r->out);
6960                         r->out.sids = r->in.sids;
6961                         r->out.count = r->in.count;
6962                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6963                         if (r->out.domains == NULL) {
6964                         return NT_STATUS_NO_MEMORY;
6965                         }
6966 
6967                         r->out.result = _lsa_LookupNames2(cli->pipes_struct, r);
6968                         return NT_STATUS_OK;
6969                 }
6970 
6971                 case NDR_LSA_CREATETRUSTEDDOMAINEX2: {
6972                         struct lsa_CreateTrustedDomainEx2 *r = (struct lsa_CreateTrustedDomainEx2 *)_r;
6973                         ZERO_STRUCT(r->out);
6974                         r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6975                         if (r->out.trustdom_handle == NULL) {
6976                         return NT_STATUS_NO_MEMORY;
6977                         }
6978 
6979                         r->out.result = _lsa_CreateTrustedDomainEx2(cli->pipes_struct, r);
6980                         return NT_STATUS_OK;
6981                 }
6982 
6983                 case NDR_LSA_CREDRWRITE: {
6984                         struct lsa_CREDRWRITE *r = (struct lsa_CREDRWRITE *)_r;
6985                         r->out.result = _lsa_CREDRWRITE(cli->pipes_struct, r);
6986                         return NT_STATUS_OK;
6987                 }
6988 
6989                 case NDR_LSA_CREDRREAD: {
6990                         struct lsa_CREDRREAD *r = (struct lsa_CREDRREAD *)_r;
6991                         r->out.result = _lsa_CREDRREAD(cli->pipes_struct, r);
6992                         return NT_STATUS_OK;
6993                 }
6994 
6995                 case NDR_LSA_CREDRENUMERATE: {
6996                         struct lsa_CREDRENUMERATE *r = (struct lsa_CREDRENUMERATE *)_r;
6997                         r->out.result = _lsa_CREDRENUMERATE(cli->pipes_struct, r);
6998                         return NT_STATUS_OK;
6999                 }
7000 
7001                 case NDR_LSA_CREDRWRITEDOMAINCREDENTIALS: {
7002                         struct lsa_CREDRWRITEDOMAINCREDENTIALS *r = (struct lsa_CREDRWRITEDOMAINCREDENTIALS *)_r;
7003                         r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(cli->pipes_struct, r);
7004                         return NT_STATUS_OK;
7005                 }
7006 
7007                 case NDR_LSA_CREDRREADDOMAINCREDENTIALS: {
7008                         struct lsa_CREDRREADDOMAINCREDENTIALS *r = (struct lsa_CREDRREADDOMAINCREDENTIALS *)_r;
7009                         r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(cli->pipes_struct, r);
7010                         return NT_STATUS_OK;
7011                 }
7012 
7013                 case NDR_LSA_CREDRDELETE: {
7014                         struct lsa_CREDRDELETE *r = (struct lsa_CREDRDELETE *)_r;
7015                         r->out.result = _lsa_CREDRDELETE(cli->pipes_struct, r);
7016                         return NT_STATUS_OK;
7017                 }
7018 
7019                 case NDR_LSA_CREDRGETTARGETINFO: {
7020                         struct lsa_CREDRGETTARGETINFO *r = (struct lsa_CREDRGETTARGETINFO *)_r;
7021                         r->out.result = _lsa_CREDRGETTARGETINFO(cli->pipes_struct, r);
7022                         return NT_STATUS_OK;
7023                 }
7024 
7025                 case NDR_LSA_CREDRPROFILELOADED: {
7026                         struct lsa_CREDRPROFILELOADED *r = (struct lsa_CREDRPROFILELOADED *)_r;
7027                         r->out.result = _lsa_CREDRPROFILELOADED(cli->pipes_struct, r);
7028                         return NT_STATUS_OK;
7029                 }
7030 
7031                 case NDR_LSA_LOOKUPNAMES3: {
7032                         struct lsa_LookupNames3 *r = (struct lsa_LookupNames3 *)_r;
7033                         ZERO_STRUCT(r->out);
7034                         r->out.sids = r->in.sids;
7035                         r->out.count = r->in.count;
7036                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7037                         if (r->out.domains == NULL) {
7038                         return NT_STATUS_NO_MEMORY;
7039                         }
7040 
7041                         r->out.result = _lsa_LookupNames3(cli->pipes_struct, r);
7042                         return NT_STATUS_OK;
7043                 }
7044 
7045                 case NDR_LSA_CREDRGETSESSIONTYPES: {
7046                         struct lsa_CREDRGETSESSIONTYPES *r = (struct lsa_CREDRGETSESSIONTYPES *)_r;
7047                         r->out.result = _lsa_CREDRGETSESSIONTYPES(cli->pipes_struct, r);
7048                         return NT_STATUS_OK;
7049                 }
7050 
7051                 case NDR_LSA_LSARREGISTERAUDITEVENT: {
7052                         struct lsa_LSARREGISTERAUDITEVENT *r = (struct lsa_LSARREGISTERAUDITEVENT *)_r;
7053                         r->out.result = _lsa_LSARREGISTERAUDITEVENT(cli->pipes_struct, r);
7054                         return NT_STATUS_OK;
7055                 }
7056 
7057                 case NDR_LSA_LSARGENAUDITEVENT: {
7058                         struct lsa_LSARGENAUDITEVENT *r = (struct lsa_LSARGENAUDITEVENT *)_r;
7059                         r->out.result = _lsa_LSARGENAUDITEVENT(cli->pipes_struct, r);
7060                         return NT_STATUS_OK;
7061                 }
7062 
7063                 case NDR_LSA_LSARUNREGISTERAUDITEVENT: {
7064                         struct lsa_LSARUNREGISTERAUDITEVENT *r = (struct lsa_LSARUNREGISTERAUDITEVENT *)_r;
7065                         r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(cli->pipes_struct, r);
7066                         return NT_STATUS_OK;
7067                 }
7068 
7069                 case NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION: {
7070                         struct lsa_lsaRQueryForestTrustInformation *r = (struct lsa_lsaRQueryForestTrustInformation *)_r;
7071                         ZERO_STRUCT(r->out);
7072                         r->out.forest_trust_info = talloc_zero(mem_ctx, struct lsa_ForestTrustInformation *);
7073                         if (r->out.forest_trust_info == NULL) {
7074                         return NT_STATUS_NO_MEMORY;
7075                         }
7076 
7077                         r->out.result = _lsa_lsaRQueryForestTrustInformation(cli->pipes_struct, r);
7078                         return NT_STATUS_OK;
7079                 }
7080 
7081                 case NDR_LSA_LSARSETFORESTTRUSTINFORMATION: {
7082                         struct lsa_LSARSETFORESTTRUSTINFORMATION *r = (struct lsa_LSARSETFORESTTRUSTINFORMATION *)_r;
7083                         r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(cli->pipes_struct, r);
7084                         return NT_STATUS_OK;
7085                 }
7086 
7087                 case NDR_LSA_CREDRRENAME: {
7088                         struct lsa_CREDRRENAME *r = (struct lsa_CREDRRENAME *)_r;
7089                         r->out.result = _lsa_CREDRRENAME(cli->pipes_struct, r);
7090                         return NT_STATUS_OK;
7091                 }
7092 
7093                 case NDR_LSA_LOOKUPSIDS3: {
7094                         struct lsa_LookupSids3 *r = (struct lsa_LookupSids3 *)_r;
7095                         ZERO_STRUCT(r->out);
7096                         r->out.names = r->in.names;
7097                         r->out.count = r->in.count;
7098                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7099                         if (r->out.domains == NULL) {
7100                         return NT_STATUS_NO_MEMORY;
7101                         }
7102 
7103                         r->out.result = _lsa_LookupSids3(cli->pipes_struct, r);
7104                         return NT_STATUS_OK;
7105                 }
7106 
7107                 case NDR_LSA_LOOKUPNAMES4: {
7108                         struct lsa_LookupNames4 *r = (struct lsa_LookupNames4 *)_r;
7109                         ZERO_STRUCT(r->out);
7110                         r->out.sids = r->in.sids;
7111                         r->out.count = r->in.count;
7112                         r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7113                         if (r->out.domains == NULL) {
7114                         return NT_STATUS_NO_MEMORY;
7115                         }
7116 
7117                         r->out.result = _lsa_LookupNames4(cli->pipes_struct, r);
7118                         return NT_STATUS_OK;
7119                 }
7120 
7121                 case NDR_LSA_LSAROPENPOLICYSCE: {
7122                         struct lsa_LSAROPENPOLICYSCE *r = (struct lsa_LSAROPENPOLICYSCE *)_r;
7123                         r->out.result = _lsa_LSAROPENPOLICYSCE(cli->pipes_struct, r);
7124                         return NT_STATUS_OK;
7125                 }
7126 
7127                 case NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE: {
7128                         struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *)_r;
7129                         r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7130                         return NT_STATUS_OK;
7131                 }
7132 
7133                 case NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE: {
7134                         struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *)_r;
7135                         r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7136                         return NT_STATUS_OK;
7137                 }
7138 
7139                 case NDR_LSA_LSARADTREPORTSECURITYEVENT: {
7140                         struct lsa_LSARADTREPORTSECURITYEVENT *r = (struct lsa_LSARADTREPORTSECURITYEVENT *)_r;
7141                         r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(cli->pipes_struct, r);
7142                         return NT_STATUS_OK;
7143                 }
7144 
7145                 default:
7146                         return NT_STATUS_NOT_IMPLEMENTED;
7147         }
7148 }
7149 
7150 NTSTATUS rpc_lsarpc_init(void)
     /* [<][>][^][v][top][bottom][index][help] */
7151 {
7152         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "lsarpc", "lsarpc", &ndr_table_lsarpc, api_lsarpc_cmds, sizeof(api_lsarpc_cmds) / sizeof(struct api_struct));
7153 }

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