root/librpc/gen_ndr/srv_samr.c

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

DEFINITIONS

This source file includes following definitions.
  1. api_samr_Connect
  2. api_samr_Close
  3. api_samr_SetSecurity
  4. api_samr_QuerySecurity
  5. api_samr_Shutdown
  6. api_samr_LookupDomain
  7. api_samr_EnumDomains
  8. api_samr_OpenDomain
  9. api_samr_QueryDomainInfo
  10. api_samr_SetDomainInfo
  11. api_samr_CreateDomainGroup
  12. api_samr_EnumDomainGroups
  13. api_samr_CreateUser
  14. api_samr_EnumDomainUsers
  15. api_samr_CreateDomAlias
  16. api_samr_EnumDomainAliases
  17. api_samr_GetAliasMembership
  18. api_samr_LookupNames
  19. api_samr_LookupRids
  20. api_samr_OpenGroup
  21. api_samr_QueryGroupInfo
  22. api_samr_SetGroupInfo
  23. api_samr_AddGroupMember
  24. api_samr_DeleteDomainGroup
  25. api_samr_DeleteGroupMember
  26. api_samr_QueryGroupMember
  27. api_samr_SetMemberAttributesOfGroup
  28. api_samr_OpenAlias
  29. api_samr_QueryAliasInfo
  30. api_samr_SetAliasInfo
  31. api_samr_DeleteDomAlias
  32. api_samr_AddAliasMember
  33. api_samr_DeleteAliasMember
  34. api_samr_GetMembersInAlias
  35. api_samr_OpenUser
  36. api_samr_DeleteUser
  37. api_samr_QueryUserInfo
  38. api_samr_SetUserInfo
  39. api_samr_ChangePasswordUser
  40. api_samr_GetGroupsForUser
  41. api_samr_QueryDisplayInfo
  42. api_samr_GetDisplayEnumerationIndex
  43. api_samr_TestPrivateFunctionsDomain
  44. api_samr_TestPrivateFunctionsUser
  45. api_samr_GetUserPwInfo
  46. api_samr_RemoveMemberFromForeignDomain
  47. api_samr_QueryDomainInfo2
  48. api_samr_QueryUserInfo2
  49. api_samr_QueryDisplayInfo2
  50. api_samr_GetDisplayEnumerationIndex2
  51. api_samr_CreateUser2
  52. api_samr_QueryDisplayInfo3
  53. api_samr_AddMultipleMembersToAlias
  54. api_samr_RemoveMultipleMembersFromAlias
  55. api_samr_OemChangePasswordUser2
  56. api_samr_ChangePasswordUser2
  57. api_samr_GetDomPwInfo
  58. api_samr_Connect2
  59. api_samr_SetUserInfo2
  60. api_samr_SetBootKeyInformation
  61. api_samr_GetBootKeyInformation
  62. api_samr_Connect3
  63. api_samr_Connect4
  64. api_samr_ChangePasswordUser3
  65. api_samr_Connect5
  66. api_samr_RidToSid
  67. api_samr_SetDsrmPassword
  68. api_samr_ValidatePassword
  69. samr_get_pipe_fns
  70. rpc_samr_dispatch
  71. rpc_samr_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_samr.h"
   8 
   9 static bool api_samr_Connect(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 samr_Connect *r;
  17 
  18         call = &ndr_table_samr.calls[NDR_SAMR_CONNECT];
  19 
  20         r = talloc(talloc_tos(), struct samr_Connect);
  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(samr_Connect, r);
  45         }
  46 
  47         ZERO_STRUCT(r->out);
  48         r->out.connect_handle = talloc_zero(r, struct policy_handle);
  49         if (r->out.connect_handle == NULL) {
  50                 talloc_free(r);
  51                 return false;
  52         }
  53 
  54         r->out.result = _samr_Connect(p, r);
  55 
  56         if (p->rng_fault_state) {
  57                 talloc_free(r);
  58                 /* Return true here, srv_pipe_hnd.c will take care */
  59                 return true;
  60         }
  61 
  62         if (DEBUGLEVEL >= 10) {
  63                 NDR_PRINT_OUT_DEBUG(samr_Connect, r);
  64         }
  65 
  66         push = ndr_push_init_ctx(r, NULL);
  67         if (push == NULL) {
  68                 talloc_free(r);
  69                 return false;
  70         }
  71 
  72         ndr_err = call->ndr_push(push, NDR_OUT, r);
  73         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  74                 talloc_free(r);
  75                 return false;
  76         }
  77 
  78         blob = ndr_push_blob(push);
  79         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  80                 talloc_free(r);
  81                 return false;
  82         }
  83 
  84         talloc_free(r);
  85 
  86         return true;
  87 }
  88 
  89 static bool api_samr_Close(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  90 {
  91         const struct ndr_interface_call *call;
  92         struct ndr_pull *pull;
  93         struct ndr_push *push;
  94         enum ndr_err_code ndr_err;
  95         DATA_BLOB blob;
  96         struct samr_Close *r;
  97 
  98         call = &ndr_table_samr.calls[NDR_SAMR_CLOSE];
  99 
 100         r = talloc(talloc_tos(), struct samr_Close);
 101         if (r == NULL) {
 102                 return false;
 103         }
 104 
 105         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 106                 talloc_free(r);
 107                 return false;
 108         }
 109 
 110         pull = ndr_pull_init_blob(&blob, r, NULL);
 111         if (pull == NULL) {
 112                 talloc_free(r);
 113                 return false;
 114         }
 115 
 116         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 117         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 118         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 119                 talloc_free(r);
 120                 return false;
 121         }
 122 
 123         if (DEBUGLEVEL >= 10) {
 124                 NDR_PRINT_IN_DEBUG(samr_Close, r);
 125         }
 126 
 127         ZERO_STRUCT(r->out);
 128         r->out.handle = r->in.handle;
 129         r->out.result = _samr_Close(p, r);
 130 
 131         if (p->rng_fault_state) {
 132                 talloc_free(r);
 133                 /* Return true here, srv_pipe_hnd.c will take care */
 134                 return true;
 135         }
 136 
 137         if (DEBUGLEVEL >= 10) {
 138                 NDR_PRINT_OUT_DEBUG(samr_Close, r);
 139         }
 140 
 141         push = ndr_push_init_ctx(r, NULL);
 142         if (push == NULL) {
 143                 talloc_free(r);
 144                 return false;
 145         }
 146 
 147         ndr_err = call->ndr_push(push, NDR_OUT, r);
 148         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 149                 talloc_free(r);
 150                 return false;
 151         }
 152 
 153         blob = ndr_push_blob(push);
 154         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 155                 talloc_free(r);
 156                 return false;
 157         }
 158 
 159         talloc_free(r);
 160 
 161         return true;
 162 }
 163 
 164 static bool api_samr_SetSecurity(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 165 {
 166         const struct ndr_interface_call *call;
 167         struct ndr_pull *pull;
 168         struct ndr_push *push;
 169         enum ndr_err_code ndr_err;
 170         DATA_BLOB blob;
 171         struct samr_SetSecurity *r;
 172 
 173         call = &ndr_table_samr.calls[NDR_SAMR_SETSECURITY];
 174 
 175         r = talloc(talloc_tos(), struct samr_SetSecurity);
 176         if (r == NULL) {
 177                 return false;
 178         }
 179 
 180         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 181                 talloc_free(r);
 182                 return false;
 183         }
 184 
 185         pull = ndr_pull_init_blob(&blob, r, NULL);
 186         if (pull == NULL) {
 187                 talloc_free(r);
 188                 return false;
 189         }
 190 
 191         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 192         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 193         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 194                 talloc_free(r);
 195                 return false;
 196         }
 197 
 198         if (DEBUGLEVEL >= 10) {
 199                 NDR_PRINT_IN_DEBUG(samr_SetSecurity, r);
 200         }
 201 
 202         r->out.result = _samr_SetSecurity(p, r);
 203 
 204         if (p->rng_fault_state) {
 205                 talloc_free(r);
 206                 /* Return true here, srv_pipe_hnd.c will take care */
 207                 return true;
 208         }
 209 
 210         if (DEBUGLEVEL >= 10) {
 211                 NDR_PRINT_OUT_DEBUG(samr_SetSecurity, r);
 212         }
 213 
 214         push = ndr_push_init_ctx(r, NULL);
 215         if (push == NULL) {
 216                 talloc_free(r);
 217                 return false;
 218         }
 219 
 220         ndr_err = call->ndr_push(push, NDR_OUT, r);
 221         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 222                 talloc_free(r);
 223                 return false;
 224         }
 225 
 226         blob = ndr_push_blob(push);
 227         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 228                 talloc_free(r);
 229                 return false;
 230         }
 231 
 232         talloc_free(r);
 233 
 234         return true;
 235 }
 236 
 237 static bool api_samr_QuerySecurity(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 238 {
 239         const struct ndr_interface_call *call;
 240         struct ndr_pull *pull;
 241         struct ndr_push *push;
 242         enum ndr_err_code ndr_err;
 243         DATA_BLOB blob;
 244         struct samr_QuerySecurity *r;
 245 
 246         call = &ndr_table_samr.calls[NDR_SAMR_QUERYSECURITY];
 247 
 248         r = talloc(talloc_tos(), struct samr_QuerySecurity);
 249         if (r == NULL) {
 250                 return false;
 251         }
 252 
 253         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 254                 talloc_free(r);
 255                 return false;
 256         }
 257 
 258         pull = ndr_pull_init_blob(&blob, r, NULL);
 259         if (pull == NULL) {
 260                 talloc_free(r);
 261                 return false;
 262         }
 263 
 264         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 265         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 266         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 267                 talloc_free(r);
 268                 return false;
 269         }
 270 
 271         if (DEBUGLEVEL >= 10) {
 272                 NDR_PRINT_IN_DEBUG(samr_QuerySecurity, r);
 273         }
 274 
 275         ZERO_STRUCT(r->out);
 276         r->out.sdbuf = talloc_zero(r, struct sec_desc_buf *);
 277         if (r->out.sdbuf == NULL) {
 278                 talloc_free(r);
 279                 return false;
 280         }
 281 
 282         r->out.result = _samr_QuerySecurity(p, r);
 283 
 284         if (p->rng_fault_state) {
 285                 talloc_free(r);
 286                 /* Return true here, srv_pipe_hnd.c will take care */
 287                 return true;
 288         }
 289 
 290         if (DEBUGLEVEL >= 10) {
 291                 NDR_PRINT_OUT_DEBUG(samr_QuerySecurity, r);
 292         }
 293 
 294         push = ndr_push_init_ctx(r, NULL);
 295         if (push == NULL) {
 296                 talloc_free(r);
 297                 return false;
 298         }
 299 
 300         ndr_err = call->ndr_push(push, NDR_OUT, r);
 301         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 302                 talloc_free(r);
 303                 return false;
 304         }
 305 
 306         blob = ndr_push_blob(push);
 307         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 308                 talloc_free(r);
 309                 return false;
 310         }
 311 
 312         talloc_free(r);
 313 
 314         return true;
 315 }
 316 
 317 static bool api_samr_Shutdown(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 318 {
 319         const struct ndr_interface_call *call;
 320         struct ndr_pull *pull;
 321         struct ndr_push *push;
 322         enum ndr_err_code ndr_err;
 323         DATA_BLOB blob;
 324         struct samr_Shutdown *r;
 325 
 326         call = &ndr_table_samr.calls[NDR_SAMR_SHUTDOWN];
 327 
 328         r = talloc(talloc_tos(), struct samr_Shutdown);
 329         if (r == NULL) {
 330                 return false;
 331         }
 332 
 333         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 334                 talloc_free(r);
 335                 return false;
 336         }
 337 
 338         pull = ndr_pull_init_blob(&blob, r, NULL);
 339         if (pull == NULL) {
 340                 talloc_free(r);
 341                 return false;
 342         }
 343 
 344         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 345         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 346         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 347                 talloc_free(r);
 348                 return false;
 349         }
 350 
 351         if (DEBUGLEVEL >= 10) {
 352                 NDR_PRINT_IN_DEBUG(samr_Shutdown, r);
 353         }
 354 
 355         r->out.result = _samr_Shutdown(p, r);
 356 
 357         if (p->rng_fault_state) {
 358                 talloc_free(r);
 359                 /* Return true here, srv_pipe_hnd.c will take care */
 360                 return true;
 361         }
 362 
 363         if (DEBUGLEVEL >= 10) {
 364                 NDR_PRINT_OUT_DEBUG(samr_Shutdown, r);
 365         }
 366 
 367         push = ndr_push_init_ctx(r, NULL);
 368         if (push == NULL) {
 369                 talloc_free(r);
 370                 return false;
 371         }
 372 
 373         ndr_err = call->ndr_push(push, NDR_OUT, r);
 374         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 375                 talloc_free(r);
 376                 return false;
 377         }
 378 
 379         blob = ndr_push_blob(push);
 380         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 381                 talloc_free(r);
 382                 return false;
 383         }
 384 
 385         talloc_free(r);
 386 
 387         return true;
 388 }
 389 
 390 static bool api_samr_LookupDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 391 {
 392         const struct ndr_interface_call *call;
 393         struct ndr_pull *pull;
 394         struct ndr_push *push;
 395         enum ndr_err_code ndr_err;
 396         DATA_BLOB blob;
 397         struct samr_LookupDomain *r;
 398 
 399         call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPDOMAIN];
 400 
 401         r = talloc(talloc_tos(), struct samr_LookupDomain);
 402         if (r == NULL) {
 403                 return false;
 404         }
 405 
 406         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 407                 talloc_free(r);
 408                 return false;
 409         }
 410 
 411         pull = ndr_pull_init_blob(&blob, r, NULL);
 412         if (pull == NULL) {
 413                 talloc_free(r);
 414                 return false;
 415         }
 416 
 417         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 418         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 419         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 420                 talloc_free(r);
 421                 return false;
 422         }
 423 
 424         if (DEBUGLEVEL >= 10) {
 425                 NDR_PRINT_IN_DEBUG(samr_LookupDomain, r);
 426         }
 427 
 428         ZERO_STRUCT(r->out);
 429         r->out.sid = talloc_zero(r, struct dom_sid2 *);
 430         if (r->out.sid == NULL) {
 431                 talloc_free(r);
 432                 return false;
 433         }
 434 
 435         r->out.result = _samr_LookupDomain(p, r);
 436 
 437         if (p->rng_fault_state) {
 438                 talloc_free(r);
 439                 /* Return true here, srv_pipe_hnd.c will take care */
 440                 return true;
 441         }
 442 
 443         if (DEBUGLEVEL >= 10) {
 444                 NDR_PRINT_OUT_DEBUG(samr_LookupDomain, r);
 445         }
 446 
 447         push = ndr_push_init_ctx(r, NULL);
 448         if (push == NULL) {
 449                 talloc_free(r);
 450                 return false;
 451         }
 452 
 453         ndr_err = call->ndr_push(push, NDR_OUT, r);
 454         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 455                 talloc_free(r);
 456                 return false;
 457         }
 458 
 459         blob = ndr_push_blob(push);
 460         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 461                 talloc_free(r);
 462                 return false;
 463         }
 464 
 465         talloc_free(r);
 466 
 467         return true;
 468 }
 469 
 470 static bool api_samr_EnumDomains(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 471 {
 472         const struct ndr_interface_call *call;
 473         struct ndr_pull *pull;
 474         struct ndr_push *push;
 475         enum ndr_err_code ndr_err;
 476         DATA_BLOB blob;
 477         struct samr_EnumDomains *r;
 478 
 479         call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINS];
 480 
 481         r = talloc(talloc_tos(), struct samr_EnumDomains);
 482         if (r == NULL) {
 483                 return false;
 484         }
 485 
 486         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 487                 talloc_free(r);
 488                 return false;
 489         }
 490 
 491         pull = ndr_pull_init_blob(&blob, r, NULL);
 492         if (pull == NULL) {
 493                 talloc_free(r);
 494                 return false;
 495         }
 496 
 497         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 498         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 499         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 500                 talloc_free(r);
 501                 return false;
 502         }
 503 
 504         if (DEBUGLEVEL >= 10) {
 505                 NDR_PRINT_IN_DEBUG(samr_EnumDomains, r);
 506         }
 507 
 508         ZERO_STRUCT(r->out);
 509         r->out.resume_handle = r->in.resume_handle;
 510         r->out.sam = talloc_zero(r, struct samr_SamArray *);
 511         if (r->out.sam == NULL) {
 512                 talloc_free(r);
 513                 return false;
 514         }
 515 
 516         r->out.num_entries = talloc_zero(r, uint32_t);
 517         if (r->out.num_entries == NULL) {
 518                 talloc_free(r);
 519                 return false;
 520         }
 521 
 522         r->out.result = _samr_EnumDomains(p, r);
 523 
 524         if (p->rng_fault_state) {
 525                 talloc_free(r);
 526                 /* Return true here, srv_pipe_hnd.c will take care */
 527                 return true;
 528         }
 529 
 530         if (DEBUGLEVEL >= 10) {
 531                 NDR_PRINT_OUT_DEBUG(samr_EnumDomains, r);
 532         }
 533 
 534         push = ndr_push_init_ctx(r, NULL);
 535         if (push == NULL) {
 536                 talloc_free(r);
 537                 return false;
 538         }
 539 
 540         ndr_err = call->ndr_push(push, NDR_OUT, r);
 541         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 542                 talloc_free(r);
 543                 return false;
 544         }
 545 
 546         blob = ndr_push_blob(push);
 547         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 548                 talloc_free(r);
 549                 return false;
 550         }
 551 
 552         talloc_free(r);
 553 
 554         return true;
 555 }
 556 
 557 static bool api_samr_OpenDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 558 {
 559         const struct ndr_interface_call *call;
 560         struct ndr_pull *pull;
 561         struct ndr_push *push;
 562         enum ndr_err_code ndr_err;
 563         DATA_BLOB blob;
 564         struct samr_OpenDomain *r;
 565 
 566         call = &ndr_table_samr.calls[NDR_SAMR_OPENDOMAIN];
 567 
 568         r = talloc(talloc_tos(), struct samr_OpenDomain);
 569         if (r == NULL) {
 570                 return false;
 571         }
 572 
 573         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 574                 talloc_free(r);
 575                 return false;
 576         }
 577 
 578         pull = ndr_pull_init_blob(&blob, r, NULL);
 579         if (pull == NULL) {
 580                 talloc_free(r);
 581                 return false;
 582         }
 583 
 584         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 585         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 586         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 587                 talloc_free(r);
 588                 return false;
 589         }
 590 
 591         if (DEBUGLEVEL >= 10) {
 592                 NDR_PRINT_IN_DEBUG(samr_OpenDomain, r);
 593         }
 594 
 595         ZERO_STRUCT(r->out);
 596         r->out.domain_handle = talloc_zero(r, struct policy_handle);
 597         if (r->out.domain_handle == NULL) {
 598                 talloc_free(r);
 599                 return false;
 600         }
 601 
 602         r->out.result = _samr_OpenDomain(p, r);
 603 
 604         if (p->rng_fault_state) {
 605                 talloc_free(r);
 606                 /* Return true here, srv_pipe_hnd.c will take care */
 607                 return true;
 608         }
 609 
 610         if (DEBUGLEVEL >= 10) {
 611                 NDR_PRINT_OUT_DEBUG(samr_OpenDomain, r);
 612         }
 613 
 614         push = ndr_push_init_ctx(r, NULL);
 615         if (push == NULL) {
 616                 talloc_free(r);
 617                 return false;
 618         }
 619 
 620         ndr_err = call->ndr_push(push, NDR_OUT, r);
 621         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 622                 talloc_free(r);
 623                 return false;
 624         }
 625 
 626         blob = ndr_push_blob(push);
 627         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 628                 talloc_free(r);
 629                 return false;
 630         }
 631 
 632         talloc_free(r);
 633 
 634         return true;
 635 }
 636 
 637 static bool api_samr_QueryDomainInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 638 {
 639         const struct ndr_interface_call *call;
 640         struct ndr_pull *pull;
 641         struct ndr_push *push;
 642         enum ndr_err_code ndr_err;
 643         DATA_BLOB blob;
 644         struct samr_QueryDomainInfo *r;
 645 
 646         call = &ndr_table_samr.calls[NDR_SAMR_QUERYDOMAININFO];
 647 
 648         r = talloc(talloc_tos(), struct samr_QueryDomainInfo);
 649         if (r == NULL) {
 650                 return false;
 651         }
 652 
 653         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 654                 talloc_free(r);
 655                 return false;
 656         }
 657 
 658         pull = ndr_pull_init_blob(&blob, r, NULL);
 659         if (pull == NULL) {
 660                 talloc_free(r);
 661                 return false;
 662         }
 663 
 664         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 665         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 666         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 667                 talloc_free(r);
 668                 return false;
 669         }
 670 
 671         if (DEBUGLEVEL >= 10) {
 672                 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo, r);
 673         }
 674 
 675         ZERO_STRUCT(r->out);
 676         r->out.info = talloc_zero(r, union samr_DomainInfo *);
 677         if (r->out.info == NULL) {
 678                 talloc_free(r);
 679                 return false;
 680         }
 681 
 682         r->out.result = _samr_QueryDomainInfo(p, r);
 683 
 684         if (p->rng_fault_state) {
 685                 talloc_free(r);
 686                 /* Return true here, srv_pipe_hnd.c will take care */
 687                 return true;
 688         }
 689 
 690         if (DEBUGLEVEL >= 10) {
 691                 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo, r);
 692         }
 693 
 694         push = ndr_push_init_ctx(r, NULL);
 695         if (push == NULL) {
 696                 talloc_free(r);
 697                 return false;
 698         }
 699 
 700         ndr_err = call->ndr_push(push, NDR_OUT, r);
 701         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 702                 talloc_free(r);
 703                 return false;
 704         }
 705 
 706         blob = ndr_push_blob(push);
 707         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 708                 talloc_free(r);
 709                 return false;
 710         }
 711 
 712         talloc_free(r);
 713 
 714         return true;
 715 }
 716 
 717 static bool api_samr_SetDomainInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 718 {
 719         const struct ndr_interface_call *call;
 720         struct ndr_pull *pull;
 721         struct ndr_push *push;
 722         enum ndr_err_code ndr_err;
 723         DATA_BLOB blob;
 724         struct samr_SetDomainInfo *r;
 725 
 726         call = &ndr_table_samr.calls[NDR_SAMR_SETDOMAININFO];
 727 
 728         r = talloc(talloc_tos(), struct samr_SetDomainInfo);
 729         if (r == NULL) {
 730                 return false;
 731         }
 732 
 733         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 734                 talloc_free(r);
 735                 return false;
 736         }
 737 
 738         pull = ndr_pull_init_blob(&blob, r, NULL);
 739         if (pull == NULL) {
 740                 talloc_free(r);
 741                 return false;
 742         }
 743 
 744         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 745         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 746         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 747                 talloc_free(r);
 748                 return false;
 749         }
 750 
 751         if (DEBUGLEVEL >= 10) {
 752                 NDR_PRINT_IN_DEBUG(samr_SetDomainInfo, r);
 753         }
 754 
 755         r->out.result = _samr_SetDomainInfo(p, r);
 756 
 757         if (p->rng_fault_state) {
 758                 talloc_free(r);
 759                 /* Return true here, srv_pipe_hnd.c will take care */
 760                 return true;
 761         }
 762 
 763         if (DEBUGLEVEL >= 10) {
 764                 NDR_PRINT_OUT_DEBUG(samr_SetDomainInfo, r);
 765         }
 766 
 767         push = ndr_push_init_ctx(r, NULL);
 768         if (push == NULL) {
 769                 talloc_free(r);
 770                 return false;
 771         }
 772 
 773         ndr_err = call->ndr_push(push, NDR_OUT, r);
 774         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 775                 talloc_free(r);
 776                 return false;
 777         }
 778 
 779         blob = ndr_push_blob(push);
 780         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 781                 talloc_free(r);
 782                 return false;
 783         }
 784 
 785         talloc_free(r);
 786 
 787         return true;
 788 }
 789 
 790 static bool api_samr_CreateDomainGroup(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 791 {
 792         const struct ndr_interface_call *call;
 793         struct ndr_pull *pull;
 794         struct ndr_push *push;
 795         enum ndr_err_code ndr_err;
 796         DATA_BLOB blob;
 797         struct samr_CreateDomainGroup *r;
 798 
 799         call = &ndr_table_samr.calls[NDR_SAMR_CREATEDOMAINGROUP];
 800 
 801         r = talloc(talloc_tos(), struct samr_CreateDomainGroup);
 802         if (r == NULL) {
 803                 return false;
 804         }
 805 
 806         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 807                 talloc_free(r);
 808                 return false;
 809         }
 810 
 811         pull = ndr_pull_init_blob(&blob, r, NULL);
 812         if (pull == NULL) {
 813                 talloc_free(r);
 814                 return false;
 815         }
 816 
 817         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 818         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 819         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 820                 talloc_free(r);
 821                 return false;
 822         }
 823 
 824         if (DEBUGLEVEL >= 10) {
 825                 NDR_PRINT_IN_DEBUG(samr_CreateDomainGroup, r);
 826         }
 827 
 828         ZERO_STRUCT(r->out);
 829         r->out.group_handle = talloc_zero(r, struct policy_handle);
 830         if (r->out.group_handle == NULL) {
 831                 talloc_free(r);
 832                 return false;
 833         }
 834 
 835         r->out.rid = talloc_zero(r, uint32_t);
 836         if (r->out.rid == NULL) {
 837                 talloc_free(r);
 838                 return false;
 839         }
 840 
 841         r->out.result = _samr_CreateDomainGroup(p, r);
 842 
 843         if (p->rng_fault_state) {
 844                 talloc_free(r);
 845                 /* Return true here, srv_pipe_hnd.c will take care */
 846                 return true;
 847         }
 848 
 849         if (DEBUGLEVEL >= 10) {
 850                 NDR_PRINT_OUT_DEBUG(samr_CreateDomainGroup, r);
 851         }
 852 
 853         push = ndr_push_init_ctx(r, NULL);
 854         if (push == NULL) {
 855                 talloc_free(r);
 856                 return false;
 857         }
 858 
 859         ndr_err = call->ndr_push(push, NDR_OUT, r);
 860         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 861                 talloc_free(r);
 862                 return false;
 863         }
 864 
 865         blob = ndr_push_blob(push);
 866         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 867                 talloc_free(r);
 868                 return false;
 869         }
 870 
 871         talloc_free(r);
 872 
 873         return true;
 874 }
 875 
 876 static bool api_samr_EnumDomainGroups(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 877 {
 878         const struct ndr_interface_call *call;
 879         struct ndr_pull *pull;
 880         struct ndr_push *push;
 881         enum ndr_err_code ndr_err;
 882         DATA_BLOB blob;
 883         struct samr_EnumDomainGroups *r;
 884 
 885         call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINGROUPS];
 886 
 887         r = talloc(talloc_tos(), struct samr_EnumDomainGroups);
 888         if (r == NULL) {
 889                 return false;
 890         }
 891 
 892         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 893                 talloc_free(r);
 894                 return false;
 895         }
 896 
 897         pull = ndr_pull_init_blob(&blob, r, NULL);
 898         if (pull == NULL) {
 899                 talloc_free(r);
 900                 return false;
 901         }
 902 
 903         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 904         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 905         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 906                 talloc_free(r);
 907                 return false;
 908         }
 909 
 910         if (DEBUGLEVEL >= 10) {
 911                 NDR_PRINT_IN_DEBUG(samr_EnumDomainGroups, r);
 912         }
 913 
 914         ZERO_STRUCT(r->out);
 915         r->out.resume_handle = r->in.resume_handle;
 916         r->out.sam = talloc_zero(r, struct samr_SamArray *);
 917         if (r->out.sam == NULL) {
 918                 talloc_free(r);
 919                 return false;
 920         }
 921 
 922         r->out.num_entries = talloc_zero(r, uint32_t);
 923         if (r->out.num_entries == NULL) {
 924                 talloc_free(r);
 925                 return false;
 926         }
 927 
 928         r->out.result = _samr_EnumDomainGroups(p, r);
 929 
 930         if (p->rng_fault_state) {
 931                 talloc_free(r);
 932                 /* Return true here, srv_pipe_hnd.c will take care */
 933                 return true;
 934         }
 935 
 936         if (DEBUGLEVEL >= 10) {
 937                 NDR_PRINT_OUT_DEBUG(samr_EnumDomainGroups, r);
 938         }
 939 
 940         push = ndr_push_init_ctx(r, NULL);
 941         if (push == NULL) {
 942                 talloc_free(r);
 943                 return false;
 944         }
 945 
 946         ndr_err = call->ndr_push(push, NDR_OUT, r);
 947         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 948                 talloc_free(r);
 949                 return false;
 950         }
 951 
 952         blob = ndr_push_blob(push);
 953         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 954                 talloc_free(r);
 955                 return false;
 956         }
 957 
 958         talloc_free(r);
 959 
 960         return true;
 961 }
 962 
 963 static bool api_samr_CreateUser(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 964 {
 965         const struct ndr_interface_call *call;
 966         struct ndr_pull *pull;
 967         struct ndr_push *push;
 968         enum ndr_err_code ndr_err;
 969         DATA_BLOB blob;
 970         struct samr_CreateUser *r;
 971 
 972         call = &ndr_table_samr.calls[NDR_SAMR_CREATEUSER];
 973 
 974         r = talloc(talloc_tos(), struct samr_CreateUser);
 975         if (r == NULL) {
 976                 return false;
 977         }
 978 
 979         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 980                 talloc_free(r);
 981                 return false;
 982         }
 983 
 984         pull = ndr_pull_init_blob(&blob, r, NULL);
 985         if (pull == NULL) {
 986                 talloc_free(r);
 987                 return false;
 988         }
 989 
 990         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 991         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 992         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 993                 talloc_free(r);
 994                 return false;
 995         }
 996 
 997         if (DEBUGLEVEL >= 10) {
 998                 NDR_PRINT_IN_DEBUG(samr_CreateUser, r);
 999         }
1000 
1001         ZERO_STRUCT(r->out);
1002         r->out.user_handle = talloc_zero(r, struct policy_handle);
1003         if (r->out.user_handle == NULL) {
1004                 talloc_free(r);
1005                 return false;
1006         }
1007 
1008         r->out.rid = talloc_zero(r, uint32_t);
1009         if (r->out.rid == NULL) {
1010                 talloc_free(r);
1011                 return false;
1012         }
1013 
1014         r->out.result = _samr_CreateUser(p, r);
1015 
1016         if (p->rng_fault_state) {
1017                 talloc_free(r);
1018                 /* Return true here, srv_pipe_hnd.c will take care */
1019                 return true;
1020         }
1021 
1022         if (DEBUGLEVEL >= 10) {
1023                 NDR_PRINT_OUT_DEBUG(samr_CreateUser, r);
1024         }
1025 
1026         push = ndr_push_init_ctx(r, NULL);
1027         if (push == NULL) {
1028                 talloc_free(r);
1029                 return false;
1030         }
1031 
1032         ndr_err = call->ndr_push(push, NDR_OUT, r);
1033         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1034                 talloc_free(r);
1035                 return false;
1036         }
1037 
1038         blob = ndr_push_blob(push);
1039         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1040                 talloc_free(r);
1041                 return false;
1042         }
1043 
1044         talloc_free(r);
1045 
1046         return true;
1047 }
1048 
1049 static bool api_samr_EnumDomainUsers(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1050 {
1051         const struct ndr_interface_call *call;
1052         struct ndr_pull *pull;
1053         struct ndr_push *push;
1054         enum ndr_err_code ndr_err;
1055         DATA_BLOB blob;
1056         struct samr_EnumDomainUsers *r;
1057 
1058         call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINUSERS];
1059 
1060         r = talloc(talloc_tos(), struct samr_EnumDomainUsers);
1061         if (r == NULL) {
1062                 return false;
1063         }
1064 
1065         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1066                 talloc_free(r);
1067                 return false;
1068         }
1069 
1070         pull = ndr_pull_init_blob(&blob, r, NULL);
1071         if (pull == NULL) {
1072                 talloc_free(r);
1073                 return false;
1074         }
1075 
1076         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1077         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1078         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1079                 talloc_free(r);
1080                 return false;
1081         }
1082 
1083         if (DEBUGLEVEL >= 10) {
1084                 NDR_PRINT_IN_DEBUG(samr_EnumDomainUsers, r);
1085         }
1086 
1087         ZERO_STRUCT(r->out);
1088         r->out.resume_handle = r->in.resume_handle;
1089         r->out.sam = talloc_zero(r, struct samr_SamArray *);
1090         if (r->out.sam == NULL) {
1091                 talloc_free(r);
1092                 return false;
1093         }
1094 
1095         r->out.num_entries = talloc_zero(r, uint32_t);
1096         if (r->out.num_entries == NULL) {
1097                 talloc_free(r);
1098                 return false;
1099         }
1100 
1101         r->out.result = _samr_EnumDomainUsers(p, r);
1102 
1103         if (p->rng_fault_state) {
1104                 talloc_free(r);
1105                 /* Return true here, srv_pipe_hnd.c will take care */
1106                 return true;
1107         }
1108 
1109         if (DEBUGLEVEL >= 10) {
1110                 NDR_PRINT_OUT_DEBUG(samr_EnumDomainUsers, r);
1111         }
1112 
1113         push = ndr_push_init_ctx(r, NULL);
1114         if (push == NULL) {
1115                 talloc_free(r);
1116                 return false;
1117         }
1118 
1119         ndr_err = call->ndr_push(push, NDR_OUT, r);
1120         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1121                 talloc_free(r);
1122                 return false;
1123         }
1124 
1125         blob = ndr_push_blob(push);
1126         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1127                 talloc_free(r);
1128                 return false;
1129         }
1130 
1131         talloc_free(r);
1132 
1133         return true;
1134 }
1135 
1136 static bool api_samr_CreateDomAlias(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1137 {
1138         const struct ndr_interface_call *call;
1139         struct ndr_pull *pull;
1140         struct ndr_push *push;
1141         enum ndr_err_code ndr_err;
1142         DATA_BLOB blob;
1143         struct samr_CreateDomAlias *r;
1144 
1145         call = &ndr_table_samr.calls[NDR_SAMR_CREATEDOMALIAS];
1146 
1147         r = talloc(talloc_tos(), struct samr_CreateDomAlias);
1148         if (r == NULL) {
1149                 return false;
1150         }
1151 
1152         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1153                 talloc_free(r);
1154                 return false;
1155         }
1156 
1157         pull = ndr_pull_init_blob(&blob, r, NULL);
1158         if (pull == NULL) {
1159                 talloc_free(r);
1160                 return false;
1161         }
1162 
1163         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1164         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1165         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1166                 talloc_free(r);
1167                 return false;
1168         }
1169 
1170         if (DEBUGLEVEL >= 10) {
1171                 NDR_PRINT_IN_DEBUG(samr_CreateDomAlias, r);
1172         }
1173 
1174         ZERO_STRUCT(r->out);
1175         r->out.alias_handle = talloc_zero(r, struct policy_handle);
1176         if (r->out.alias_handle == NULL) {
1177                 talloc_free(r);
1178                 return false;
1179         }
1180 
1181         r->out.rid = talloc_zero(r, uint32_t);
1182         if (r->out.rid == NULL) {
1183                 talloc_free(r);
1184                 return false;
1185         }
1186 
1187         r->out.result = _samr_CreateDomAlias(p, r);
1188 
1189         if (p->rng_fault_state) {
1190                 talloc_free(r);
1191                 /* Return true here, srv_pipe_hnd.c will take care */
1192                 return true;
1193         }
1194 
1195         if (DEBUGLEVEL >= 10) {
1196                 NDR_PRINT_OUT_DEBUG(samr_CreateDomAlias, r);
1197         }
1198 
1199         push = ndr_push_init_ctx(r, NULL);
1200         if (push == NULL) {
1201                 talloc_free(r);
1202                 return false;
1203         }
1204 
1205         ndr_err = call->ndr_push(push, NDR_OUT, r);
1206         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1207                 talloc_free(r);
1208                 return false;
1209         }
1210 
1211         blob = ndr_push_blob(push);
1212         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1213                 talloc_free(r);
1214                 return false;
1215         }
1216 
1217         talloc_free(r);
1218 
1219         return true;
1220 }
1221 
1222 static bool api_samr_EnumDomainAliases(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1223 {
1224         const struct ndr_interface_call *call;
1225         struct ndr_pull *pull;
1226         struct ndr_push *push;
1227         enum ndr_err_code ndr_err;
1228         DATA_BLOB blob;
1229         struct samr_EnumDomainAliases *r;
1230 
1231         call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINALIASES];
1232 
1233         r = talloc(talloc_tos(), struct samr_EnumDomainAliases);
1234         if (r == NULL) {
1235                 return false;
1236         }
1237 
1238         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1239                 talloc_free(r);
1240                 return false;
1241         }
1242 
1243         pull = ndr_pull_init_blob(&blob, r, NULL);
1244         if (pull == NULL) {
1245                 talloc_free(r);
1246                 return false;
1247         }
1248 
1249         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1250         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1251         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1252                 talloc_free(r);
1253                 return false;
1254         }
1255 
1256         if (DEBUGLEVEL >= 10) {
1257                 NDR_PRINT_IN_DEBUG(samr_EnumDomainAliases, r);
1258         }
1259 
1260         ZERO_STRUCT(r->out);
1261         r->out.resume_handle = r->in.resume_handle;
1262         r->out.sam = talloc_zero(r, struct samr_SamArray *);
1263         if (r->out.sam == NULL) {
1264                 talloc_free(r);
1265                 return false;
1266         }
1267 
1268         r->out.num_entries = talloc_zero(r, uint32_t);
1269         if (r->out.num_entries == NULL) {
1270                 talloc_free(r);
1271                 return false;
1272         }
1273 
1274         r->out.result = _samr_EnumDomainAliases(p, r);
1275 
1276         if (p->rng_fault_state) {
1277                 talloc_free(r);
1278                 /* Return true here, srv_pipe_hnd.c will take care */
1279                 return true;
1280         }
1281 
1282         if (DEBUGLEVEL >= 10) {
1283                 NDR_PRINT_OUT_DEBUG(samr_EnumDomainAliases, r);
1284         }
1285 
1286         push = ndr_push_init_ctx(r, NULL);
1287         if (push == NULL) {
1288                 talloc_free(r);
1289                 return false;
1290         }
1291 
1292         ndr_err = call->ndr_push(push, NDR_OUT, r);
1293         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1294                 talloc_free(r);
1295                 return false;
1296         }
1297 
1298         blob = ndr_push_blob(push);
1299         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1300                 talloc_free(r);
1301                 return false;
1302         }
1303 
1304         talloc_free(r);
1305 
1306         return true;
1307 }
1308 
1309 static bool api_samr_GetAliasMembership(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1310 {
1311         const struct ndr_interface_call *call;
1312         struct ndr_pull *pull;
1313         struct ndr_push *push;
1314         enum ndr_err_code ndr_err;
1315         DATA_BLOB blob;
1316         struct samr_GetAliasMembership *r;
1317 
1318         call = &ndr_table_samr.calls[NDR_SAMR_GETALIASMEMBERSHIP];
1319 
1320         r = talloc(talloc_tos(), struct samr_GetAliasMembership);
1321         if (r == NULL) {
1322                 return false;
1323         }
1324 
1325         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1326                 talloc_free(r);
1327                 return false;
1328         }
1329 
1330         pull = ndr_pull_init_blob(&blob, r, NULL);
1331         if (pull == NULL) {
1332                 talloc_free(r);
1333                 return false;
1334         }
1335 
1336         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1337         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1338         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1339                 talloc_free(r);
1340                 return false;
1341         }
1342 
1343         if (DEBUGLEVEL >= 10) {
1344                 NDR_PRINT_IN_DEBUG(samr_GetAliasMembership, r);
1345         }
1346 
1347         ZERO_STRUCT(r->out);
1348         r->out.rids = talloc_zero(r, struct samr_Ids);
1349         if (r->out.rids == NULL) {
1350                 talloc_free(r);
1351                 return false;
1352         }
1353 
1354         r->out.result = _samr_GetAliasMembership(p, r);
1355 
1356         if (p->rng_fault_state) {
1357                 talloc_free(r);
1358                 /* Return true here, srv_pipe_hnd.c will take care */
1359                 return true;
1360         }
1361 
1362         if (DEBUGLEVEL >= 10) {
1363                 NDR_PRINT_OUT_DEBUG(samr_GetAliasMembership, r);
1364         }
1365 
1366         push = ndr_push_init_ctx(r, NULL);
1367         if (push == NULL) {
1368                 talloc_free(r);
1369                 return false;
1370         }
1371 
1372         ndr_err = call->ndr_push(push, NDR_OUT, r);
1373         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1374                 talloc_free(r);
1375                 return false;
1376         }
1377 
1378         blob = ndr_push_blob(push);
1379         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1380                 talloc_free(r);
1381                 return false;
1382         }
1383 
1384         talloc_free(r);
1385 
1386         return true;
1387 }
1388 
1389 static bool api_samr_LookupNames(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1390 {
1391         const struct ndr_interface_call *call;
1392         struct ndr_pull *pull;
1393         struct ndr_push *push;
1394         enum ndr_err_code ndr_err;
1395         DATA_BLOB blob;
1396         struct samr_LookupNames *r;
1397 
1398         call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPNAMES];
1399 
1400         r = talloc(talloc_tos(), struct samr_LookupNames);
1401         if (r == NULL) {
1402                 return false;
1403         }
1404 
1405         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1406                 talloc_free(r);
1407                 return false;
1408         }
1409 
1410         pull = ndr_pull_init_blob(&blob, r, NULL);
1411         if (pull == NULL) {
1412                 talloc_free(r);
1413                 return false;
1414         }
1415 
1416         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1417         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1418         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1419                 talloc_free(r);
1420                 return false;
1421         }
1422 
1423         if (DEBUGLEVEL >= 10) {
1424                 NDR_PRINT_IN_DEBUG(samr_LookupNames, r);
1425         }
1426 
1427         ZERO_STRUCT(r->out);
1428         r->out.rids = talloc_zero(r, struct samr_Ids);
1429         if (r->out.rids == NULL) {
1430                 talloc_free(r);
1431                 return false;
1432         }
1433 
1434         r->out.types = talloc_zero(r, struct samr_Ids);
1435         if (r->out.types == NULL) {
1436                 talloc_free(r);
1437                 return false;
1438         }
1439 
1440         r->out.result = _samr_LookupNames(p, r);
1441 
1442         if (p->rng_fault_state) {
1443                 talloc_free(r);
1444                 /* Return true here, srv_pipe_hnd.c will take care */
1445                 return true;
1446         }
1447 
1448         if (DEBUGLEVEL >= 10) {
1449                 NDR_PRINT_OUT_DEBUG(samr_LookupNames, r);
1450         }
1451 
1452         push = ndr_push_init_ctx(r, NULL);
1453         if (push == NULL) {
1454                 talloc_free(r);
1455                 return false;
1456         }
1457 
1458         ndr_err = call->ndr_push(push, NDR_OUT, r);
1459         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1460                 talloc_free(r);
1461                 return false;
1462         }
1463 
1464         blob = ndr_push_blob(push);
1465         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1466                 talloc_free(r);
1467                 return false;
1468         }
1469 
1470         talloc_free(r);
1471 
1472         return true;
1473 }
1474 
1475 static bool api_samr_LookupRids(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1476 {
1477         const struct ndr_interface_call *call;
1478         struct ndr_pull *pull;
1479         struct ndr_push *push;
1480         enum ndr_err_code ndr_err;
1481         DATA_BLOB blob;
1482         struct samr_LookupRids *r;
1483 
1484         call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPRIDS];
1485 
1486         r = talloc(talloc_tos(), struct samr_LookupRids);
1487         if (r == NULL) {
1488                 return false;
1489         }
1490 
1491         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1492                 talloc_free(r);
1493                 return false;
1494         }
1495 
1496         pull = ndr_pull_init_blob(&blob, r, NULL);
1497         if (pull == NULL) {
1498                 talloc_free(r);
1499                 return false;
1500         }
1501 
1502         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1503         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1504         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1505                 talloc_free(r);
1506                 return false;
1507         }
1508 
1509         if (DEBUGLEVEL >= 10) {
1510                 NDR_PRINT_IN_DEBUG(samr_LookupRids, r);
1511         }
1512 
1513         ZERO_STRUCT(r->out);
1514         r->out.names = talloc_zero(r, struct lsa_Strings);
1515         if (r->out.names == NULL) {
1516                 talloc_free(r);
1517                 return false;
1518         }
1519 
1520         r->out.types = talloc_zero(r, struct samr_Ids);
1521         if (r->out.types == NULL) {
1522                 talloc_free(r);
1523                 return false;
1524         }
1525 
1526         r->out.result = _samr_LookupRids(p, r);
1527 
1528         if (p->rng_fault_state) {
1529                 talloc_free(r);
1530                 /* Return true here, srv_pipe_hnd.c will take care */
1531                 return true;
1532         }
1533 
1534         if (DEBUGLEVEL >= 10) {
1535                 NDR_PRINT_OUT_DEBUG(samr_LookupRids, r);
1536         }
1537 
1538         push = ndr_push_init_ctx(r, NULL);
1539         if (push == NULL) {
1540                 talloc_free(r);
1541                 return false;
1542         }
1543 
1544         ndr_err = call->ndr_push(push, NDR_OUT, r);
1545         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1546                 talloc_free(r);
1547                 return false;
1548         }
1549 
1550         blob = ndr_push_blob(push);
1551         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1552                 talloc_free(r);
1553                 return false;
1554         }
1555 
1556         talloc_free(r);
1557 
1558         return true;
1559 }
1560 
1561 static bool api_samr_OpenGroup(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1562 {
1563         const struct ndr_interface_call *call;
1564         struct ndr_pull *pull;
1565         struct ndr_push *push;
1566         enum ndr_err_code ndr_err;
1567         DATA_BLOB blob;
1568         struct samr_OpenGroup *r;
1569 
1570         call = &ndr_table_samr.calls[NDR_SAMR_OPENGROUP];
1571 
1572         r = talloc(talloc_tos(), struct samr_OpenGroup);
1573         if (r == NULL) {
1574                 return false;
1575         }
1576 
1577         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1578                 talloc_free(r);
1579                 return false;
1580         }
1581 
1582         pull = ndr_pull_init_blob(&blob, r, NULL);
1583         if (pull == NULL) {
1584                 talloc_free(r);
1585                 return false;
1586         }
1587 
1588         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1589         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1590         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1591                 talloc_free(r);
1592                 return false;
1593         }
1594 
1595         if (DEBUGLEVEL >= 10) {
1596                 NDR_PRINT_IN_DEBUG(samr_OpenGroup, r);
1597         }
1598 
1599         ZERO_STRUCT(r->out);
1600         r->out.group_handle = talloc_zero(r, struct policy_handle);
1601         if (r->out.group_handle == NULL) {
1602                 talloc_free(r);
1603                 return false;
1604         }
1605 
1606         r->out.result = _samr_OpenGroup(p, r);
1607 
1608         if (p->rng_fault_state) {
1609                 talloc_free(r);
1610                 /* Return true here, srv_pipe_hnd.c will take care */
1611                 return true;
1612         }
1613 
1614         if (DEBUGLEVEL >= 10) {
1615                 NDR_PRINT_OUT_DEBUG(samr_OpenGroup, r);
1616         }
1617 
1618         push = ndr_push_init_ctx(r, NULL);
1619         if (push == NULL) {
1620                 talloc_free(r);
1621                 return false;
1622         }
1623 
1624         ndr_err = call->ndr_push(push, NDR_OUT, r);
1625         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1626                 talloc_free(r);
1627                 return false;
1628         }
1629 
1630         blob = ndr_push_blob(push);
1631         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1632                 talloc_free(r);
1633                 return false;
1634         }
1635 
1636         talloc_free(r);
1637 
1638         return true;
1639 }
1640 
1641 static bool api_samr_QueryGroupInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1642 {
1643         const struct ndr_interface_call *call;
1644         struct ndr_pull *pull;
1645         struct ndr_push *push;
1646         enum ndr_err_code ndr_err;
1647         DATA_BLOB blob;
1648         struct samr_QueryGroupInfo *r;
1649 
1650         call = &ndr_table_samr.calls[NDR_SAMR_QUERYGROUPINFO];
1651 
1652         r = talloc(talloc_tos(), struct samr_QueryGroupInfo);
1653         if (r == NULL) {
1654                 return false;
1655         }
1656 
1657         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1658                 talloc_free(r);
1659                 return false;
1660         }
1661 
1662         pull = ndr_pull_init_blob(&blob, r, NULL);
1663         if (pull == NULL) {
1664                 talloc_free(r);
1665                 return false;
1666         }
1667 
1668         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1669         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1670         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1671                 talloc_free(r);
1672                 return false;
1673         }
1674 
1675         if (DEBUGLEVEL >= 10) {
1676                 NDR_PRINT_IN_DEBUG(samr_QueryGroupInfo, r);
1677         }
1678 
1679         ZERO_STRUCT(r->out);
1680         r->out.info = talloc_zero(r, union samr_GroupInfo *);
1681         if (r->out.info == NULL) {
1682                 talloc_free(r);
1683                 return false;
1684         }
1685 
1686         r->out.result = _samr_QueryGroupInfo(p, r);
1687 
1688         if (p->rng_fault_state) {
1689                 talloc_free(r);
1690                 /* Return true here, srv_pipe_hnd.c will take care */
1691                 return true;
1692         }
1693 
1694         if (DEBUGLEVEL >= 10) {
1695                 NDR_PRINT_OUT_DEBUG(samr_QueryGroupInfo, r);
1696         }
1697 
1698         push = ndr_push_init_ctx(r, NULL);
1699         if (push == NULL) {
1700                 talloc_free(r);
1701                 return false;
1702         }
1703 
1704         ndr_err = call->ndr_push(push, NDR_OUT, r);
1705         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1706                 talloc_free(r);
1707                 return false;
1708         }
1709 
1710         blob = ndr_push_blob(push);
1711         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1712                 talloc_free(r);
1713                 return false;
1714         }
1715 
1716         talloc_free(r);
1717 
1718         return true;
1719 }
1720 
1721 static bool api_samr_SetGroupInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1722 {
1723         const struct ndr_interface_call *call;
1724         struct ndr_pull *pull;
1725         struct ndr_push *push;
1726         enum ndr_err_code ndr_err;
1727         DATA_BLOB blob;
1728         struct samr_SetGroupInfo *r;
1729 
1730         call = &ndr_table_samr.calls[NDR_SAMR_SETGROUPINFO];
1731 
1732         r = talloc(talloc_tos(), struct samr_SetGroupInfo);
1733         if (r == NULL) {
1734                 return false;
1735         }
1736 
1737         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1738                 talloc_free(r);
1739                 return false;
1740         }
1741 
1742         pull = ndr_pull_init_blob(&blob, r, NULL);
1743         if (pull == NULL) {
1744                 talloc_free(r);
1745                 return false;
1746         }
1747 
1748         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1749         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1750         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1751                 talloc_free(r);
1752                 return false;
1753         }
1754 
1755         if (DEBUGLEVEL >= 10) {
1756                 NDR_PRINT_IN_DEBUG(samr_SetGroupInfo, r);
1757         }
1758 
1759         r->out.result = _samr_SetGroupInfo(p, r);
1760 
1761         if (p->rng_fault_state) {
1762                 talloc_free(r);
1763                 /* Return true here, srv_pipe_hnd.c will take care */
1764                 return true;
1765         }
1766 
1767         if (DEBUGLEVEL >= 10) {
1768                 NDR_PRINT_OUT_DEBUG(samr_SetGroupInfo, r);
1769         }
1770 
1771         push = ndr_push_init_ctx(r, NULL);
1772         if (push == NULL) {
1773                 talloc_free(r);
1774                 return false;
1775         }
1776 
1777         ndr_err = call->ndr_push(push, NDR_OUT, r);
1778         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1779                 talloc_free(r);
1780                 return false;
1781         }
1782 
1783         blob = ndr_push_blob(push);
1784         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1785                 talloc_free(r);
1786                 return false;
1787         }
1788 
1789         talloc_free(r);
1790 
1791         return true;
1792 }
1793 
1794 static bool api_samr_AddGroupMember(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1795 {
1796         const struct ndr_interface_call *call;
1797         struct ndr_pull *pull;
1798         struct ndr_push *push;
1799         enum ndr_err_code ndr_err;
1800         DATA_BLOB blob;
1801         struct samr_AddGroupMember *r;
1802 
1803         call = &ndr_table_samr.calls[NDR_SAMR_ADDGROUPMEMBER];
1804 
1805         r = talloc(talloc_tos(), struct samr_AddGroupMember);
1806         if (r == NULL) {
1807                 return false;
1808         }
1809 
1810         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1811                 talloc_free(r);
1812                 return false;
1813         }
1814 
1815         pull = ndr_pull_init_blob(&blob, r, NULL);
1816         if (pull == NULL) {
1817                 talloc_free(r);
1818                 return false;
1819         }
1820 
1821         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1822         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1823         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1824                 talloc_free(r);
1825                 return false;
1826         }
1827 
1828         if (DEBUGLEVEL >= 10) {
1829                 NDR_PRINT_IN_DEBUG(samr_AddGroupMember, r);
1830         }
1831 
1832         r->out.result = _samr_AddGroupMember(p, r);
1833 
1834         if (p->rng_fault_state) {
1835                 talloc_free(r);
1836                 /* Return true here, srv_pipe_hnd.c will take care */
1837                 return true;
1838         }
1839 
1840         if (DEBUGLEVEL >= 10) {
1841                 NDR_PRINT_OUT_DEBUG(samr_AddGroupMember, r);
1842         }
1843 
1844         push = ndr_push_init_ctx(r, NULL);
1845         if (push == NULL) {
1846                 talloc_free(r);
1847                 return false;
1848         }
1849 
1850         ndr_err = call->ndr_push(push, NDR_OUT, r);
1851         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1852                 talloc_free(r);
1853                 return false;
1854         }
1855 
1856         blob = ndr_push_blob(push);
1857         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1858                 talloc_free(r);
1859                 return false;
1860         }
1861 
1862         talloc_free(r);
1863 
1864         return true;
1865 }
1866 
1867 static bool api_samr_DeleteDomainGroup(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1868 {
1869         const struct ndr_interface_call *call;
1870         struct ndr_pull *pull;
1871         struct ndr_push *push;
1872         enum ndr_err_code ndr_err;
1873         DATA_BLOB blob;
1874         struct samr_DeleteDomainGroup *r;
1875 
1876         call = &ndr_table_samr.calls[NDR_SAMR_DELETEDOMAINGROUP];
1877 
1878         r = talloc(talloc_tos(), struct samr_DeleteDomainGroup);
1879         if (r == NULL) {
1880                 return false;
1881         }
1882 
1883         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1884                 talloc_free(r);
1885                 return false;
1886         }
1887 
1888         pull = ndr_pull_init_blob(&blob, r, NULL);
1889         if (pull == NULL) {
1890                 talloc_free(r);
1891                 return false;
1892         }
1893 
1894         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1895         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1896         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1897                 talloc_free(r);
1898                 return false;
1899         }
1900 
1901         if (DEBUGLEVEL >= 10) {
1902                 NDR_PRINT_IN_DEBUG(samr_DeleteDomainGroup, r);
1903         }
1904 
1905         ZERO_STRUCT(r->out);
1906         r->out.group_handle = r->in.group_handle;
1907         r->out.result = _samr_DeleteDomainGroup(p, r);
1908 
1909         if (p->rng_fault_state) {
1910                 talloc_free(r);
1911                 /* Return true here, srv_pipe_hnd.c will take care */
1912                 return true;
1913         }
1914 
1915         if (DEBUGLEVEL >= 10) {
1916                 NDR_PRINT_OUT_DEBUG(samr_DeleteDomainGroup, r);
1917         }
1918 
1919         push = ndr_push_init_ctx(r, NULL);
1920         if (push == NULL) {
1921                 talloc_free(r);
1922                 return false;
1923         }
1924 
1925         ndr_err = call->ndr_push(push, NDR_OUT, r);
1926         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1927                 talloc_free(r);
1928                 return false;
1929         }
1930 
1931         blob = ndr_push_blob(push);
1932         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1933                 talloc_free(r);
1934                 return false;
1935         }
1936 
1937         talloc_free(r);
1938 
1939         return true;
1940 }
1941 
1942 static bool api_samr_DeleteGroupMember(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1943 {
1944         const struct ndr_interface_call *call;
1945         struct ndr_pull *pull;
1946         struct ndr_push *push;
1947         enum ndr_err_code ndr_err;
1948         DATA_BLOB blob;
1949         struct samr_DeleteGroupMember *r;
1950 
1951         call = &ndr_table_samr.calls[NDR_SAMR_DELETEGROUPMEMBER];
1952 
1953         r = talloc(talloc_tos(), struct samr_DeleteGroupMember);
1954         if (r == NULL) {
1955                 return false;
1956         }
1957 
1958         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1959                 talloc_free(r);
1960                 return false;
1961         }
1962 
1963         pull = ndr_pull_init_blob(&blob, r, NULL);
1964         if (pull == NULL) {
1965                 talloc_free(r);
1966                 return false;
1967         }
1968 
1969         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1970         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1971         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1972                 talloc_free(r);
1973                 return false;
1974         }
1975 
1976         if (DEBUGLEVEL >= 10) {
1977                 NDR_PRINT_IN_DEBUG(samr_DeleteGroupMember, r);
1978         }
1979 
1980         r->out.result = _samr_DeleteGroupMember(p, r);
1981 
1982         if (p->rng_fault_state) {
1983                 talloc_free(r);
1984                 /* Return true here, srv_pipe_hnd.c will take care */
1985                 return true;
1986         }
1987 
1988         if (DEBUGLEVEL >= 10) {
1989                 NDR_PRINT_OUT_DEBUG(samr_DeleteGroupMember, r);
1990         }
1991 
1992         push = ndr_push_init_ctx(r, NULL);
1993         if (push == NULL) {
1994                 talloc_free(r);
1995                 return false;
1996         }
1997 
1998         ndr_err = call->ndr_push(push, NDR_OUT, r);
1999         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2000                 talloc_free(r);
2001                 return false;
2002         }
2003 
2004         blob = ndr_push_blob(push);
2005         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2006                 talloc_free(r);
2007                 return false;
2008         }
2009 
2010         talloc_free(r);
2011 
2012         return true;
2013 }
2014 
2015 static bool api_samr_QueryGroupMember(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2016 {
2017         const struct ndr_interface_call *call;
2018         struct ndr_pull *pull;
2019         struct ndr_push *push;
2020         enum ndr_err_code ndr_err;
2021         DATA_BLOB blob;
2022         struct samr_QueryGroupMember *r;
2023 
2024         call = &ndr_table_samr.calls[NDR_SAMR_QUERYGROUPMEMBER];
2025 
2026         r = talloc(talloc_tos(), struct samr_QueryGroupMember);
2027         if (r == NULL) {
2028                 return false;
2029         }
2030 
2031         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2032                 talloc_free(r);
2033                 return false;
2034         }
2035 
2036         pull = ndr_pull_init_blob(&blob, r, NULL);
2037         if (pull == NULL) {
2038                 talloc_free(r);
2039                 return false;
2040         }
2041 
2042         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2043         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2044         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2045                 talloc_free(r);
2046                 return false;
2047         }
2048 
2049         if (DEBUGLEVEL >= 10) {
2050                 NDR_PRINT_IN_DEBUG(samr_QueryGroupMember, r);
2051         }
2052 
2053         ZERO_STRUCT(r->out);
2054         r->out.rids = talloc_zero(r, struct samr_RidTypeArray *);
2055         if (r->out.rids == NULL) {
2056                 talloc_free(r);
2057                 return false;
2058         }
2059 
2060         r->out.result = _samr_QueryGroupMember(p, r);
2061 
2062         if (p->rng_fault_state) {
2063                 talloc_free(r);
2064                 /* Return true here, srv_pipe_hnd.c will take care */
2065                 return true;
2066         }
2067 
2068         if (DEBUGLEVEL >= 10) {
2069                 NDR_PRINT_OUT_DEBUG(samr_QueryGroupMember, r);
2070         }
2071 
2072         push = ndr_push_init_ctx(r, NULL);
2073         if (push == NULL) {
2074                 talloc_free(r);
2075                 return false;
2076         }
2077 
2078         ndr_err = call->ndr_push(push, NDR_OUT, r);
2079         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2080                 talloc_free(r);
2081                 return false;
2082         }
2083 
2084         blob = ndr_push_blob(push);
2085         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2086                 talloc_free(r);
2087                 return false;
2088         }
2089 
2090         talloc_free(r);
2091 
2092         return true;
2093 }
2094 
2095 static bool api_samr_SetMemberAttributesOfGroup(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2096 {
2097         const struct ndr_interface_call *call;
2098         struct ndr_pull *pull;
2099         struct ndr_push *push;
2100         enum ndr_err_code ndr_err;
2101         DATA_BLOB blob;
2102         struct samr_SetMemberAttributesOfGroup *r;
2103 
2104         call = &ndr_table_samr.calls[NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP];
2105 
2106         r = talloc(talloc_tos(), struct samr_SetMemberAttributesOfGroup);
2107         if (r == NULL) {
2108                 return false;
2109         }
2110 
2111         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2112                 talloc_free(r);
2113                 return false;
2114         }
2115 
2116         pull = ndr_pull_init_blob(&blob, r, NULL);
2117         if (pull == NULL) {
2118                 talloc_free(r);
2119                 return false;
2120         }
2121 
2122         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2123         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2124         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2125                 talloc_free(r);
2126                 return false;
2127         }
2128 
2129         if (DEBUGLEVEL >= 10) {
2130                 NDR_PRINT_IN_DEBUG(samr_SetMemberAttributesOfGroup, r);
2131         }
2132 
2133         r->out.result = _samr_SetMemberAttributesOfGroup(p, r);
2134 
2135         if (p->rng_fault_state) {
2136                 talloc_free(r);
2137                 /* Return true here, srv_pipe_hnd.c will take care */
2138                 return true;
2139         }
2140 
2141         if (DEBUGLEVEL >= 10) {
2142                 NDR_PRINT_OUT_DEBUG(samr_SetMemberAttributesOfGroup, r);
2143         }
2144 
2145         push = ndr_push_init_ctx(r, NULL);
2146         if (push == NULL) {
2147                 talloc_free(r);
2148                 return false;
2149         }
2150 
2151         ndr_err = call->ndr_push(push, NDR_OUT, r);
2152         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2153                 talloc_free(r);
2154                 return false;
2155         }
2156 
2157         blob = ndr_push_blob(push);
2158         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2159                 talloc_free(r);
2160                 return false;
2161         }
2162 
2163         talloc_free(r);
2164 
2165         return true;
2166 }
2167 
2168 static bool api_samr_OpenAlias(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2169 {
2170         const struct ndr_interface_call *call;
2171         struct ndr_pull *pull;
2172         struct ndr_push *push;
2173         enum ndr_err_code ndr_err;
2174         DATA_BLOB blob;
2175         struct samr_OpenAlias *r;
2176 
2177         call = &ndr_table_samr.calls[NDR_SAMR_OPENALIAS];
2178 
2179         r = talloc(talloc_tos(), struct samr_OpenAlias);
2180         if (r == NULL) {
2181                 return false;
2182         }
2183 
2184         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2185                 talloc_free(r);
2186                 return false;
2187         }
2188 
2189         pull = ndr_pull_init_blob(&blob, r, NULL);
2190         if (pull == NULL) {
2191                 talloc_free(r);
2192                 return false;
2193         }
2194 
2195         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2196         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2197         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2198                 talloc_free(r);
2199                 return false;
2200         }
2201 
2202         if (DEBUGLEVEL >= 10) {
2203                 NDR_PRINT_IN_DEBUG(samr_OpenAlias, r);
2204         }
2205 
2206         ZERO_STRUCT(r->out);
2207         r->out.alias_handle = talloc_zero(r, struct policy_handle);
2208         if (r->out.alias_handle == NULL) {
2209                 talloc_free(r);
2210                 return false;
2211         }
2212 
2213         r->out.result = _samr_OpenAlias(p, r);
2214 
2215         if (p->rng_fault_state) {
2216                 talloc_free(r);
2217                 /* Return true here, srv_pipe_hnd.c will take care */
2218                 return true;
2219         }
2220 
2221         if (DEBUGLEVEL >= 10) {
2222                 NDR_PRINT_OUT_DEBUG(samr_OpenAlias, r);
2223         }
2224 
2225         push = ndr_push_init_ctx(r, NULL);
2226         if (push == NULL) {
2227                 talloc_free(r);
2228                 return false;
2229         }
2230 
2231         ndr_err = call->ndr_push(push, NDR_OUT, r);
2232         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2233                 talloc_free(r);
2234                 return false;
2235         }
2236 
2237         blob = ndr_push_blob(push);
2238         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2239                 talloc_free(r);
2240                 return false;
2241         }
2242 
2243         talloc_free(r);
2244 
2245         return true;
2246 }
2247 
2248 static bool api_samr_QueryAliasInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2249 {
2250         const struct ndr_interface_call *call;
2251         struct ndr_pull *pull;
2252         struct ndr_push *push;
2253         enum ndr_err_code ndr_err;
2254         DATA_BLOB blob;
2255         struct samr_QueryAliasInfo *r;
2256 
2257         call = &ndr_table_samr.calls[NDR_SAMR_QUERYALIASINFO];
2258 
2259         r = talloc(talloc_tos(), struct samr_QueryAliasInfo);
2260         if (r == NULL) {
2261                 return false;
2262         }
2263 
2264         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2265                 talloc_free(r);
2266                 return false;
2267         }
2268 
2269         pull = ndr_pull_init_blob(&blob, r, NULL);
2270         if (pull == NULL) {
2271                 talloc_free(r);
2272                 return false;
2273         }
2274 
2275         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2276         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2277         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2278                 talloc_free(r);
2279                 return false;
2280         }
2281 
2282         if (DEBUGLEVEL >= 10) {
2283                 NDR_PRINT_IN_DEBUG(samr_QueryAliasInfo, r);
2284         }
2285 
2286         ZERO_STRUCT(r->out);
2287         r->out.info = talloc_zero(r, union samr_AliasInfo *);
2288         if (r->out.info == NULL) {
2289                 talloc_free(r);
2290                 return false;
2291         }
2292 
2293         r->out.result = _samr_QueryAliasInfo(p, r);
2294 
2295         if (p->rng_fault_state) {
2296                 talloc_free(r);
2297                 /* Return true here, srv_pipe_hnd.c will take care */
2298                 return true;
2299         }
2300 
2301         if (DEBUGLEVEL >= 10) {
2302                 NDR_PRINT_OUT_DEBUG(samr_QueryAliasInfo, r);
2303         }
2304 
2305         push = ndr_push_init_ctx(r, NULL);
2306         if (push == NULL) {
2307                 talloc_free(r);
2308                 return false;
2309         }
2310 
2311         ndr_err = call->ndr_push(push, NDR_OUT, r);
2312         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2313                 talloc_free(r);
2314                 return false;
2315         }
2316 
2317         blob = ndr_push_blob(push);
2318         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2319                 talloc_free(r);
2320                 return false;
2321         }
2322 
2323         talloc_free(r);
2324 
2325         return true;
2326 }
2327 
2328 static bool api_samr_SetAliasInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2329 {
2330         const struct ndr_interface_call *call;
2331         struct ndr_pull *pull;
2332         struct ndr_push *push;
2333         enum ndr_err_code ndr_err;
2334         DATA_BLOB blob;
2335         struct samr_SetAliasInfo *r;
2336 
2337         call = &ndr_table_samr.calls[NDR_SAMR_SETALIASINFO];
2338 
2339         r = talloc(talloc_tos(), struct samr_SetAliasInfo);
2340         if (r == NULL) {
2341                 return false;
2342         }
2343 
2344         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2345                 talloc_free(r);
2346                 return false;
2347         }
2348 
2349         pull = ndr_pull_init_blob(&blob, r, NULL);
2350         if (pull == NULL) {
2351                 talloc_free(r);
2352                 return false;
2353         }
2354 
2355         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2356         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2357         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2358                 talloc_free(r);
2359                 return false;
2360         }
2361 
2362         if (DEBUGLEVEL >= 10) {
2363                 NDR_PRINT_IN_DEBUG(samr_SetAliasInfo, r);
2364         }
2365 
2366         r->out.result = _samr_SetAliasInfo(p, r);
2367 
2368         if (p->rng_fault_state) {
2369                 talloc_free(r);
2370                 /* Return true here, srv_pipe_hnd.c will take care */
2371                 return true;
2372         }
2373 
2374         if (DEBUGLEVEL >= 10) {
2375                 NDR_PRINT_OUT_DEBUG(samr_SetAliasInfo, r);
2376         }
2377 
2378         push = ndr_push_init_ctx(r, NULL);
2379         if (push == NULL) {
2380                 talloc_free(r);
2381                 return false;
2382         }
2383 
2384         ndr_err = call->ndr_push(push, NDR_OUT, r);
2385         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2386                 talloc_free(r);
2387                 return false;
2388         }
2389 
2390         blob = ndr_push_blob(push);
2391         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2392                 talloc_free(r);
2393                 return false;
2394         }
2395 
2396         talloc_free(r);
2397 
2398         return true;
2399 }
2400 
2401 static bool api_samr_DeleteDomAlias(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2402 {
2403         const struct ndr_interface_call *call;
2404         struct ndr_pull *pull;
2405         struct ndr_push *push;
2406         enum ndr_err_code ndr_err;
2407         DATA_BLOB blob;
2408         struct samr_DeleteDomAlias *r;
2409 
2410         call = &ndr_table_samr.calls[NDR_SAMR_DELETEDOMALIAS];
2411 
2412         r = talloc(talloc_tos(), struct samr_DeleteDomAlias);
2413         if (r == NULL) {
2414                 return false;
2415         }
2416 
2417         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2418                 talloc_free(r);
2419                 return false;
2420         }
2421 
2422         pull = ndr_pull_init_blob(&blob, r, NULL);
2423         if (pull == NULL) {
2424                 talloc_free(r);
2425                 return false;
2426         }
2427 
2428         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2429         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2430         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2431                 talloc_free(r);
2432                 return false;
2433         }
2434 
2435         if (DEBUGLEVEL >= 10) {
2436                 NDR_PRINT_IN_DEBUG(samr_DeleteDomAlias, r);
2437         }
2438 
2439         ZERO_STRUCT(r->out);
2440         r->out.alias_handle = r->in.alias_handle;
2441         r->out.result = _samr_DeleteDomAlias(p, r);
2442 
2443         if (p->rng_fault_state) {
2444                 talloc_free(r);
2445                 /* Return true here, srv_pipe_hnd.c will take care */
2446                 return true;
2447         }
2448 
2449         if (DEBUGLEVEL >= 10) {
2450                 NDR_PRINT_OUT_DEBUG(samr_DeleteDomAlias, r);
2451         }
2452 
2453         push = ndr_push_init_ctx(r, NULL);
2454         if (push == NULL) {
2455                 talloc_free(r);
2456                 return false;
2457         }
2458 
2459         ndr_err = call->ndr_push(push, NDR_OUT, r);
2460         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2461                 talloc_free(r);
2462                 return false;
2463         }
2464 
2465         blob = ndr_push_blob(push);
2466         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2467                 talloc_free(r);
2468                 return false;
2469         }
2470 
2471         talloc_free(r);
2472 
2473         return true;
2474 }
2475 
2476 static bool api_samr_AddAliasMember(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2477 {
2478         const struct ndr_interface_call *call;
2479         struct ndr_pull *pull;
2480         struct ndr_push *push;
2481         enum ndr_err_code ndr_err;
2482         DATA_BLOB blob;
2483         struct samr_AddAliasMember *r;
2484 
2485         call = &ndr_table_samr.calls[NDR_SAMR_ADDALIASMEMBER];
2486 
2487         r = talloc(talloc_tos(), struct samr_AddAliasMember);
2488         if (r == NULL) {
2489                 return false;
2490         }
2491 
2492         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2493                 talloc_free(r);
2494                 return false;
2495         }
2496 
2497         pull = ndr_pull_init_blob(&blob, r, NULL);
2498         if (pull == NULL) {
2499                 talloc_free(r);
2500                 return false;
2501         }
2502 
2503         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2504         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2505         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2506                 talloc_free(r);
2507                 return false;
2508         }
2509 
2510         if (DEBUGLEVEL >= 10) {
2511                 NDR_PRINT_IN_DEBUG(samr_AddAliasMember, r);
2512         }
2513 
2514         r->out.result = _samr_AddAliasMember(p, r);
2515 
2516         if (p->rng_fault_state) {
2517                 talloc_free(r);
2518                 /* Return true here, srv_pipe_hnd.c will take care */
2519                 return true;
2520         }
2521 
2522         if (DEBUGLEVEL >= 10) {
2523                 NDR_PRINT_OUT_DEBUG(samr_AddAliasMember, r);
2524         }
2525 
2526         push = ndr_push_init_ctx(r, NULL);
2527         if (push == NULL) {
2528                 talloc_free(r);
2529                 return false;
2530         }
2531 
2532         ndr_err = call->ndr_push(push, NDR_OUT, r);
2533         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2534                 talloc_free(r);
2535                 return false;
2536         }
2537 
2538         blob = ndr_push_blob(push);
2539         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2540                 talloc_free(r);
2541                 return false;
2542         }
2543 
2544         talloc_free(r);
2545 
2546         return true;
2547 }
2548 
2549 static bool api_samr_DeleteAliasMember(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2550 {
2551         const struct ndr_interface_call *call;
2552         struct ndr_pull *pull;
2553         struct ndr_push *push;
2554         enum ndr_err_code ndr_err;
2555         DATA_BLOB blob;
2556         struct samr_DeleteAliasMember *r;
2557 
2558         call = &ndr_table_samr.calls[NDR_SAMR_DELETEALIASMEMBER];
2559 
2560         r = talloc(talloc_tos(), struct samr_DeleteAliasMember);
2561         if (r == NULL) {
2562                 return false;
2563         }
2564 
2565         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2566                 talloc_free(r);
2567                 return false;
2568         }
2569 
2570         pull = ndr_pull_init_blob(&blob, r, NULL);
2571         if (pull == NULL) {
2572                 talloc_free(r);
2573                 return false;
2574         }
2575 
2576         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2577         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2578         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2579                 talloc_free(r);
2580                 return false;
2581         }
2582 
2583         if (DEBUGLEVEL >= 10) {
2584                 NDR_PRINT_IN_DEBUG(samr_DeleteAliasMember, r);
2585         }
2586 
2587         r->out.result = _samr_DeleteAliasMember(p, r);
2588 
2589         if (p->rng_fault_state) {
2590                 talloc_free(r);
2591                 /* Return true here, srv_pipe_hnd.c will take care */
2592                 return true;
2593         }
2594 
2595         if (DEBUGLEVEL >= 10) {
2596                 NDR_PRINT_OUT_DEBUG(samr_DeleteAliasMember, r);
2597         }
2598 
2599         push = ndr_push_init_ctx(r, NULL);
2600         if (push == NULL) {
2601                 talloc_free(r);
2602                 return false;
2603         }
2604 
2605         ndr_err = call->ndr_push(push, NDR_OUT, r);
2606         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2607                 talloc_free(r);
2608                 return false;
2609         }
2610 
2611         blob = ndr_push_blob(push);
2612         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2613                 talloc_free(r);
2614                 return false;
2615         }
2616 
2617         talloc_free(r);
2618 
2619         return true;
2620 }
2621 
2622 static bool api_samr_GetMembersInAlias(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2623 {
2624         const struct ndr_interface_call *call;
2625         struct ndr_pull *pull;
2626         struct ndr_push *push;
2627         enum ndr_err_code ndr_err;
2628         DATA_BLOB blob;
2629         struct samr_GetMembersInAlias *r;
2630 
2631         call = &ndr_table_samr.calls[NDR_SAMR_GETMEMBERSINALIAS];
2632 
2633         r = talloc(talloc_tos(), struct samr_GetMembersInAlias);
2634         if (r == NULL) {
2635                 return false;
2636         }
2637 
2638         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2639                 talloc_free(r);
2640                 return false;
2641         }
2642 
2643         pull = ndr_pull_init_blob(&blob, r, NULL);
2644         if (pull == NULL) {
2645                 talloc_free(r);
2646                 return false;
2647         }
2648 
2649         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2650         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2651         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2652                 talloc_free(r);
2653                 return false;
2654         }
2655 
2656         if (DEBUGLEVEL >= 10) {
2657                 NDR_PRINT_IN_DEBUG(samr_GetMembersInAlias, r);
2658         }
2659 
2660         ZERO_STRUCT(r->out);
2661         r->out.sids = talloc_zero(r, struct lsa_SidArray);
2662         if (r->out.sids == NULL) {
2663                 talloc_free(r);
2664                 return false;
2665         }
2666 
2667         r->out.result = _samr_GetMembersInAlias(p, r);
2668 
2669         if (p->rng_fault_state) {
2670                 talloc_free(r);
2671                 /* Return true here, srv_pipe_hnd.c will take care */
2672                 return true;
2673         }
2674 
2675         if (DEBUGLEVEL >= 10) {
2676                 NDR_PRINT_OUT_DEBUG(samr_GetMembersInAlias, r);
2677         }
2678 
2679         push = ndr_push_init_ctx(r, NULL);
2680         if (push == NULL) {
2681                 talloc_free(r);
2682                 return false;
2683         }
2684 
2685         ndr_err = call->ndr_push(push, NDR_OUT, r);
2686         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2687                 talloc_free(r);
2688                 return false;
2689         }
2690 
2691         blob = ndr_push_blob(push);
2692         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2693                 talloc_free(r);
2694                 return false;
2695         }
2696 
2697         talloc_free(r);
2698 
2699         return true;
2700 }
2701 
2702 static bool api_samr_OpenUser(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2703 {
2704         const struct ndr_interface_call *call;
2705         struct ndr_pull *pull;
2706         struct ndr_push *push;
2707         enum ndr_err_code ndr_err;
2708         DATA_BLOB blob;
2709         struct samr_OpenUser *r;
2710 
2711         call = &ndr_table_samr.calls[NDR_SAMR_OPENUSER];
2712 
2713         r = talloc(talloc_tos(), struct samr_OpenUser);
2714         if (r == NULL) {
2715                 return false;
2716         }
2717 
2718         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2719                 talloc_free(r);
2720                 return false;
2721         }
2722 
2723         pull = ndr_pull_init_blob(&blob, r, NULL);
2724         if (pull == NULL) {
2725                 talloc_free(r);
2726                 return false;
2727         }
2728 
2729         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2730         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2731         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2732                 talloc_free(r);
2733                 return false;
2734         }
2735 
2736         if (DEBUGLEVEL >= 10) {
2737                 NDR_PRINT_IN_DEBUG(samr_OpenUser, r);
2738         }
2739 
2740         ZERO_STRUCT(r->out);
2741         r->out.user_handle = talloc_zero(r, struct policy_handle);
2742         if (r->out.user_handle == NULL) {
2743                 talloc_free(r);
2744                 return false;
2745         }
2746 
2747         r->out.result = _samr_OpenUser(p, r);
2748 
2749         if (p->rng_fault_state) {
2750                 talloc_free(r);
2751                 /* Return true here, srv_pipe_hnd.c will take care */
2752                 return true;
2753         }
2754 
2755         if (DEBUGLEVEL >= 10) {
2756                 NDR_PRINT_OUT_DEBUG(samr_OpenUser, r);
2757         }
2758 
2759         push = ndr_push_init_ctx(r, NULL);
2760         if (push == NULL) {
2761                 talloc_free(r);
2762                 return false;
2763         }
2764 
2765         ndr_err = call->ndr_push(push, NDR_OUT, r);
2766         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2767                 talloc_free(r);
2768                 return false;
2769         }
2770 
2771         blob = ndr_push_blob(push);
2772         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2773                 talloc_free(r);
2774                 return false;
2775         }
2776 
2777         talloc_free(r);
2778 
2779         return true;
2780 }
2781 
2782 static bool api_samr_DeleteUser(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2783 {
2784         const struct ndr_interface_call *call;
2785         struct ndr_pull *pull;
2786         struct ndr_push *push;
2787         enum ndr_err_code ndr_err;
2788         DATA_BLOB blob;
2789         struct samr_DeleteUser *r;
2790 
2791         call = &ndr_table_samr.calls[NDR_SAMR_DELETEUSER];
2792 
2793         r = talloc(talloc_tos(), struct samr_DeleteUser);
2794         if (r == NULL) {
2795                 return false;
2796         }
2797 
2798         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2799                 talloc_free(r);
2800                 return false;
2801         }
2802 
2803         pull = ndr_pull_init_blob(&blob, r, NULL);
2804         if (pull == NULL) {
2805                 talloc_free(r);
2806                 return false;
2807         }
2808 
2809         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2810         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2811         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2812                 talloc_free(r);
2813                 return false;
2814         }
2815 
2816         if (DEBUGLEVEL >= 10) {
2817                 NDR_PRINT_IN_DEBUG(samr_DeleteUser, r);
2818         }
2819 
2820         ZERO_STRUCT(r->out);
2821         r->out.user_handle = r->in.user_handle;
2822         r->out.result = _samr_DeleteUser(p, r);
2823 
2824         if (p->rng_fault_state) {
2825                 talloc_free(r);
2826                 /* Return true here, srv_pipe_hnd.c will take care */
2827                 return true;
2828         }
2829 
2830         if (DEBUGLEVEL >= 10) {
2831                 NDR_PRINT_OUT_DEBUG(samr_DeleteUser, r);
2832         }
2833 
2834         push = ndr_push_init_ctx(r, NULL);
2835         if (push == NULL) {
2836                 talloc_free(r);
2837                 return false;
2838         }
2839 
2840         ndr_err = call->ndr_push(push, NDR_OUT, r);
2841         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2842                 talloc_free(r);
2843                 return false;
2844         }
2845 
2846         blob = ndr_push_blob(push);
2847         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2848                 talloc_free(r);
2849                 return false;
2850         }
2851 
2852         talloc_free(r);
2853 
2854         return true;
2855 }
2856 
2857 static bool api_samr_QueryUserInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2858 {
2859         const struct ndr_interface_call *call;
2860         struct ndr_pull *pull;
2861         struct ndr_push *push;
2862         enum ndr_err_code ndr_err;
2863         DATA_BLOB blob;
2864         struct samr_QueryUserInfo *r;
2865 
2866         call = &ndr_table_samr.calls[NDR_SAMR_QUERYUSERINFO];
2867 
2868         r = talloc(talloc_tos(), struct samr_QueryUserInfo);
2869         if (r == NULL) {
2870                 return false;
2871         }
2872 
2873         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2874                 talloc_free(r);
2875                 return false;
2876         }
2877 
2878         pull = ndr_pull_init_blob(&blob, r, NULL);
2879         if (pull == NULL) {
2880                 talloc_free(r);
2881                 return false;
2882         }
2883 
2884         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2885         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2886         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2887                 talloc_free(r);
2888                 return false;
2889         }
2890 
2891         if (DEBUGLEVEL >= 10) {
2892                 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo, r);
2893         }
2894 
2895         ZERO_STRUCT(r->out);
2896         r->out.info = talloc_zero(r, union samr_UserInfo *);
2897         if (r->out.info == NULL) {
2898                 talloc_free(r);
2899                 return false;
2900         }
2901 
2902         r->out.result = _samr_QueryUserInfo(p, r);
2903 
2904         if (p->rng_fault_state) {
2905                 talloc_free(r);
2906                 /* Return true here, srv_pipe_hnd.c will take care */
2907                 return true;
2908         }
2909 
2910         if (DEBUGLEVEL >= 10) {
2911                 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo, r);
2912         }
2913 
2914         push = ndr_push_init_ctx(r, NULL);
2915         if (push == NULL) {
2916                 talloc_free(r);
2917                 return false;
2918         }
2919 
2920         ndr_err = call->ndr_push(push, NDR_OUT, r);
2921         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2922                 talloc_free(r);
2923                 return false;
2924         }
2925 
2926         blob = ndr_push_blob(push);
2927         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2928                 talloc_free(r);
2929                 return false;
2930         }
2931 
2932         talloc_free(r);
2933 
2934         return true;
2935 }
2936 
2937 static bool api_samr_SetUserInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2938 {
2939         const struct ndr_interface_call *call;
2940         struct ndr_pull *pull;
2941         struct ndr_push *push;
2942         enum ndr_err_code ndr_err;
2943         DATA_BLOB blob;
2944         struct samr_SetUserInfo *r;
2945 
2946         call = &ndr_table_samr.calls[NDR_SAMR_SETUSERINFO];
2947 
2948         r = talloc(talloc_tos(), struct samr_SetUserInfo);
2949         if (r == NULL) {
2950                 return false;
2951         }
2952 
2953         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2954                 talloc_free(r);
2955                 return false;
2956         }
2957 
2958         pull = ndr_pull_init_blob(&blob, r, NULL);
2959         if (pull == NULL) {
2960                 talloc_free(r);
2961                 return false;
2962         }
2963 
2964         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2965         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2966         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2967                 talloc_free(r);
2968                 return false;
2969         }
2970 
2971         if (DEBUGLEVEL >= 10) {
2972                 NDR_PRINT_IN_DEBUG(samr_SetUserInfo, r);
2973         }
2974 
2975         r->out.result = _samr_SetUserInfo(p, r);
2976 
2977         if (p->rng_fault_state) {
2978                 talloc_free(r);
2979                 /* Return true here, srv_pipe_hnd.c will take care */
2980                 return true;
2981         }
2982 
2983         if (DEBUGLEVEL >= 10) {
2984                 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo, r);
2985         }
2986 
2987         push = ndr_push_init_ctx(r, NULL);
2988         if (push == NULL) {
2989                 talloc_free(r);
2990                 return false;
2991         }
2992 
2993         ndr_err = call->ndr_push(push, NDR_OUT, r);
2994         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2995                 talloc_free(r);
2996                 return false;
2997         }
2998 
2999         blob = ndr_push_blob(push);
3000         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3001                 talloc_free(r);
3002                 return false;
3003         }
3004 
3005         talloc_free(r);
3006 
3007         return true;
3008 }
3009 
3010 static bool api_samr_ChangePasswordUser(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3011 {
3012         const struct ndr_interface_call *call;
3013         struct ndr_pull *pull;
3014         struct ndr_push *push;
3015         enum ndr_err_code ndr_err;
3016         DATA_BLOB blob;
3017         struct samr_ChangePasswordUser *r;
3018 
3019         call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER];
3020 
3021         r = talloc(talloc_tos(), struct samr_ChangePasswordUser);
3022         if (r == NULL) {
3023                 return false;
3024         }
3025 
3026         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3027                 talloc_free(r);
3028                 return false;
3029         }
3030 
3031         pull = ndr_pull_init_blob(&blob, r, NULL);
3032         if (pull == NULL) {
3033                 talloc_free(r);
3034                 return false;
3035         }
3036 
3037         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3038         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3039         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3040                 talloc_free(r);
3041                 return false;
3042         }
3043 
3044         if (DEBUGLEVEL >= 10) {
3045                 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser, r);
3046         }
3047 
3048         r->out.result = _samr_ChangePasswordUser(p, r);
3049 
3050         if (p->rng_fault_state) {
3051                 talloc_free(r);
3052                 /* Return true here, srv_pipe_hnd.c will take care */
3053                 return true;
3054         }
3055 
3056         if (DEBUGLEVEL >= 10) {
3057                 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser, r);
3058         }
3059 
3060         push = ndr_push_init_ctx(r, NULL);
3061         if (push == NULL) {
3062                 talloc_free(r);
3063                 return false;
3064         }
3065 
3066         ndr_err = call->ndr_push(push, NDR_OUT, r);
3067         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3068                 talloc_free(r);
3069                 return false;
3070         }
3071 
3072         blob = ndr_push_blob(push);
3073         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3074                 talloc_free(r);
3075                 return false;
3076         }
3077 
3078         talloc_free(r);
3079 
3080         return true;
3081 }
3082 
3083 static bool api_samr_GetGroupsForUser(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3084 {
3085         const struct ndr_interface_call *call;
3086         struct ndr_pull *pull;
3087         struct ndr_push *push;
3088         enum ndr_err_code ndr_err;
3089         DATA_BLOB blob;
3090         struct samr_GetGroupsForUser *r;
3091 
3092         call = &ndr_table_samr.calls[NDR_SAMR_GETGROUPSFORUSER];
3093 
3094         r = talloc(talloc_tos(), struct samr_GetGroupsForUser);
3095         if (r == NULL) {
3096                 return false;
3097         }
3098 
3099         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3100                 talloc_free(r);
3101                 return false;
3102         }
3103 
3104         pull = ndr_pull_init_blob(&blob, r, NULL);
3105         if (pull == NULL) {
3106                 talloc_free(r);
3107                 return false;
3108         }
3109 
3110         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3111         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3112         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3113                 talloc_free(r);
3114                 return false;
3115         }
3116 
3117         if (DEBUGLEVEL >= 10) {
3118                 NDR_PRINT_IN_DEBUG(samr_GetGroupsForUser, r);
3119         }
3120 
3121         ZERO_STRUCT(r->out);
3122         r->out.rids = talloc_zero(r, struct samr_RidWithAttributeArray *);
3123         if (r->out.rids == NULL) {
3124                 talloc_free(r);
3125                 return false;
3126         }
3127 
3128         r->out.result = _samr_GetGroupsForUser(p, r);
3129 
3130         if (p->rng_fault_state) {
3131                 talloc_free(r);
3132                 /* Return true here, srv_pipe_hnd.c will take care */
3133                 return true;
3134         }
3135 
3136         if (DEBUGLEVEL >= 10) {
3137                 NDR_PRINT_OUT_DEBUG(samr_GetGroupsForUser, r);
3138         }
3139 
3140         push = ndr_push_init_ctx(r, NULL);
3141         if (push == NULL) {
3142                 talloc_free(r);
3143                 return false;
3144         }
3145 
3146         ndr_err = call->ndr_push(push, NDR_OUT, r);
3147         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3148                 talloc_free(r);
3149                 return false;
3150         }
3151 
3152         blob = ndr_push_blob(push);
3153         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3154                 talloc_free(r);
3155                 return false;
3156         }
3157 
3158         talloc_free(r);
3159 
3160         return true;
3161 }
3162 
3163 static bool api_samr_QueryDisplayInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3164 {
3165         const struct ndr_interface_call *call;
3166         struct ndr_pull *pull;
3167         struct ndr_push *push;
3168         enum ndr_err_code ndr_err;
3169         DATA_BLOB blob;
3170         struct samr_QueryDisplayInfo *r;
3171 
3172         call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO];
3173 
3174         r = talloc(talloc_tos(), struct samr_QueryDisplayInfo);
3175         if (r == NULL) {
3176                 return false;
3177         }
3178 
3179         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3180                 talloc_free(r);
3181                 return false;
3182         }
3183 
3184         pull = ndr_pull_init_blob(&blob, r, NULL);
3185         if (pull == NULL) {
3186                 talloc_free(r);
3187                 return false;
3188         }
3189 
3190         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3191         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3192         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3193                 talloc_free(r);
3194                 return false;
3195         }
3196 
3197         if (DEBUGLEVEL >= 10) {
3198                 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo, r);
3199         }
3200 
3201         ZERO_STRUCT(r->out);
3202         r->out.total_size = talloc_zero(r, uint32_t);
3203         if (r->out.total_size == NULL) {
3204                 talloc_free(r);
3205                 return false;
3206         }
3207 
3208         r->out.returned_size = talloc_zero(r, uint32_t);
3209         if (r->out.returned_size == NULL) {
3210                 talloc_free(r);
3211                 return false;
3212         }
3213 
3214         r->out.info = talloc_zero(r, union samr_DispInfo);
3215         if (r->out.info == NULL) {
3216                 talloc_free(r);
3217                 return false;
3218         }
3219 
3220         r->out.result = _samr_QueryDisplayInfo(p, r);
3221 
3222         if (p->rng_fault_state) {
3223                 talloc_free(r);
3224                 /* Return true here, srv_pipe_hnd.c will take care */
3225                 return true;
3226         }
3227 
3228         if (DEBUGLEVEL >= 10) {
3229                 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo, r);
3230         }
3231 
3232         push = ndr_push_init_ctx(r, NULL);
3233         if (push == NULL) {
3234                 talloc_free(r);
3235                 return false;
3236         }
3237 
3238         ndr_err = call->ndr_push(push, NDR_OUT, r);
3239         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3240                 talloc_free(r);
3241                 return false;
3242         }
3243 
3244         blob = ndr_push_blob(push);
3245         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3246                 talloc_free(r);
3247                 return false;
3248         }
3249 
3250         talloc_free(r);
3251 
3252         return true;
3253 }
3254 
3255 static bool api_samr_GetDisplayEnumerationIndex(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3256 {
3257         const struct ndr_interface_call *call;
3258         struct ndr_pull *pull;
3259         struct ndr_push *push;
3260         enum ndr_err_code ndr_err;
3261         DATA_BLOB blob;
3262         struct samr_GetDisplayEnumerationIndex *r;
3263 
3264         call = &ndr_table_samr.calls[NDR_SAMR_GETDISPLAYENUMERATIONINDEX];
3265 
3266         r = talloc(talloc_tos(), struct samr_GetDisplayEnumerationIndex);
3267         if (r == NULL) {
3268                 return false;
3269         }
3270 
3271         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3272                 talloc_free(r);
3273                 return false;
3274         }
3275 
3276         pull = ndr_pull_init_blob(&blob, r, NULL);
3277         if (pull == NULL) {
3278                 talloc_free(r);
3279                 return false;
3280         }
3281 
3282         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3283         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3284         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3285                 talloc_free(r);
3286                 return false;
3287         }
3288 
3289         if (DEBUGLEVEL >= 10) {
3290                 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex, r);
3291         }
3292 
3293         ZERO_STRUCT(r->out);
3294         r->out.idx = talloc_zero(r, uint32_t);
3295         if (r->out.idx == NULL) {
3296                 talloc_free(r);
3297                 return false;
3298         }
3299 
3300         r->out.result = _samr_GetDisplayEnumerationIndex(p, r);
3301 
3302         if (p->rng_fault_state) {
3303                 talloc_free(r);
3304                 /* Return true here, srv_pipe_hnd.c will take care */
3305                 return true;
3306         }
3307 
3308         if (DEBUGLEVEL >= 10) {
3309                 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex, r);
3310         }
3311 
3312         push = ndr_push_init_ctx(r, NULL);
3313         if (push == NULL) {
3314                 talloc_free(r);
3315                 return false;
3316         }
3317 
3318         ndr_err = call->ndr_push(push, NDR_OUT, r);
3319         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3320                 talloc_free(r);
3321                 return false;
3322         }
3323 
3324         blob = ndr_push_blob(push);
3325         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3326                 talloc_free(r);
3327                 return false;
3328         }
3329 
3330         talloc_free(r);
3331 
3332         return true;
3333 }
3334 
3335 static bool api_samr_TestPrivateFunctionsDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3336 {
3337         const struct ndr_interface_call *call;
3338         struct ndr_pull *pull;
3339         struct ndr_push *push;
3340         enum ndr_err_code ndr_err;
3341         DATA_BLOB blob;
3342         struct samr_TestPrivateFunctionsDomain *r;
3343 
3344         call = &ndr_table_samr.calls[NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN];
3345 
3346         r = talloc(talloc_tos(), struct samr_TestPrivateFunctionsDomain);
3347         if (r == NULL) {
3348                 return false;
3349         }
3350 
3351         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3352                 talloc_free(r);
3353                 return false;
3354         }
3355 
3356         pull = ndr_pull_init_blob(&blob, r, NULL);
3357         if (pull == NULL) {
3358                 talloc_free(r);
3359                 return false;
3360         }
3361 
3362         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3363         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3364         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3365                 talloc_free(r);
3366                 return false;
3367         }
3368 
3369         if (DEBUGLEVEL >= 10) {
3370                 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsDomain, r);
3371         }
3372 
3373         r->out.result = _samr_TestPrivateFunctionsDomain(p, r);
3374 
3375         if (p->rng_fault_state) {
3376                 talloc_free(r);
3377                 /* Return true here, srv_pipe_hnd.c will take care */
3378                 return true;
3379         }
3380 
3381         if (DEBUGLEVEL >= 10) {
3382                 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsDomain, r);
3383         }
3384 
3385         push = ndr_push_init_ctx(r, NULL);
3386         if (push == NULL) {
3387                 talloc_free(r);
3388                 return false;
3389         }
3390 
3391         ndr_err = call->ndr_push(push, NDR_OUT, r);
3392         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3393                 talloc_free(r);
3394                 return false;
3395         }
3396 
3397         blob = ndr_push_blob(push);
3398         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3399                 talloc_free(r);
3400                 return false;
3401         }
3402 
3403         talloc_free(r);
3404 
3405         return true;
3406 }
3407 
3408 static bool api_samr_TestPrivateFunctionsUser(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3409 {
3410         const struct ndr_interface_call *call;
3411         struct ndr_pull *pull;
3412         struct ndr_push *push;
3413         enum ndr_err_code ndr_err;
3414         DATA_BLOB blob;
3415         struct samr_TestPrivateFunctionsUser *r;
3416 
3417         call = &ndr_table_samr.calls[NDR_SAMR_TESTPRIVATEFUNCTIONSUSER];
3418 
3419         r = talloc(talloc_tos(), struct samr_TestPrivateFunctionsUser);
3420         if (r == NULL) {
3421                 return false;
3422         }
3423 
3424         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3425                 talloc_free(r);
3426                 return false;
3427         }
3428 
3429         pull = ndr_pull_init_blob(&blob, r, NULL);
3430         if (pull == NULL) {
3431                 talloc_free(r);
3432                 return false;
3433         }
3434 
3435         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3436         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3437         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3438                 talloc_free(r);
3439                 return false;
3440         }
3441 
3442         if (DEBUGLEVEL >= 10) {
3443                 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsUser, r);
3444         }
3445 
3446         r->out.result = _samr_TestPrivateFunctionsUser(p, r);
3447 
3448         if (p->rng_fault_state) {
3449                 talloc_free(r);
3450                 /* Return true here, srv_pipe_hnd.c will take care */
3451                 return true;
3452         }
3453 
3454         if (DEBUGLEVEL >= 10) {
3455                 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsUser, r);
3456         }
3457 
3458         push = ndr_push_init_ctx(r, NULL);
3459         if (push == NULL) {
3460                 talloc_free(r);
3461                 return false;
3462         }
3463 
3464         ndr_err = call->ndr_push(push, NDR_OUT, r);
3465         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3466                 talloc_free(r);
3467                 return false;
3468         }
3469 
3470         blob = ndr_push_blob(push);
3471         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3472                 talloc_free(r);
3473                 return false;
3474         }
3475 
3476         talloc_free(r);
3477 
3478         return true;
3479 }
3480 
3481 static bool api_samr_GetUserPwInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3482 {
3483         const struct ndr_interface_call *call;
3484         struct ndr_pull *pull;
3485         struct ndr_push *push;
3486         enum ndr_err_code ndr_err;
3487         DATA_BLOB blob;
3488         struct samr_GetUserPwInfo *r;
3489 
3490         call = &ndr_table_samr.calls[NDR_SAMR_GETUSERPWINFO];
3491 
3492         r = talloc(talloc_tos(), struct samr_GetUserPwInfo);
3493         if (r == NULL) {
3494                 return false;
3495         }
3496 
3497         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3498                 talloc_free(r);
3499                 return false;
3500         }
3501 
3502         pull = ndr_pull_init_blob(&blob, r, NULL);
3503         if (pull == NULL) {
3504                 talloc_free(r);
3505                 return false;
3506         }
3507 
3508         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3509         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3510         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3511                 talloc_free(r);
3512                 return false;
3513         }
3514 
3515         if (DEBUGLEVEL >= 10) {
3516                 NDR_PRINT_IN_DEBUG(samr_GetUserPwInfo, r);
3517         }
3518 
3519         ZERO_STRUCT(r->out);
3520         r->out.info = talloc_zero(r, struct samr_PwInfo);
3521         if (r->out.info == NULL) {
3522                 talloc_free(r);
3523                 return false;
3524         }
3525 
3526         r->out.result = _samr_GetUserPwInfo(p, r);
3527 
3528         if (p->rng_fault_state) {
3529                 talloc_free(r);
3530                 /* Return true here, srv_pipe_hnd.c will take care */
3531                 return true;
3532         }
3533 
3534         if (DEBUGLEVEL >= 10) {
3535                 NDR_PRINT_OUT_DEBUG(samr_GetUserPwInfo, r);
3536         }
3537 
3538         push = ndr_push_init_ctx(r, NULL);
3539         if (push == NULL) {
3540                 talloc_free(r);
3541                 return false;
3542         }
3543 
3544         ndr_err = call->ndr_push(push, NDR_OUT, r);
3545         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3546                 talloc_free(r);
3547                 return false;
3548         }
3549 
3550         blob = ndr_push_blob(push);
3551         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3552                 talloc_free(r);
3553                 return false;
3554         }
3555 
3556         talloc_free(r);
3557 
3558         return true;
3559 }
3560 
3561 static bool api_samr_RemoveMemberFromForeignDomain(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3562 {
3563         const struct ndr_interface_call *call;
3564         struct ndr_pull *pull;
3565         struct ndr_push *push;
3566         enum ndr_err_code ndr_err;
3567         DATA_BLOB blob;
3568         struct samr_RemoveMemberFromForeignDomain *r;
3569 
3570         call = &ndr_table_samr.calls[NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN];
3571 
3572         r = talloc(talloc_tos(), struct samr_RemoveMemberFromForeignDomain);
3573         if (r == NULL) {
3574                 return false;
3575         }
3576 
3577         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3578                 talloc_free(r);
3579                 return false;
3580         }
3581 
3582         pull = ndr_pull_init_blob(&blob, r, NULL);
3583         if (pull == NULL) {
3584                 talloc_free(r);
3585                 return false;
3586         }
3587 
3588         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3589         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3590         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3591                 talloc_free(r);
3592                 return false;
3593         }
3594 
3595         if (DEBUGLEVEL >= 10) {
3596                 NDR_PRINT_IN_DEBUG(samr_RemoveMemberFromForeignDomain, r);
3597         }
3598 
3599         r->out.result = _samr_RemoveMemberFromForeignDomain(p, r);
3600 
3601         if (p->rng_fault_state) {
3602                 talloc_free(r);
3603                 /* Return true here, srv_pipe_hnd.c will take care */
3604                 return true;
3605         }
3606 
3607         if (DEBUGLEVEL >= 10) {
3608                 NDR_PRINT_OUT_DEBUG(samr_RemoveMemberFromForeignDomain, r);
3609         }
3610 
3611         push = ndr_push_init_ctx(r, NULL);
3612         if (push == NULL) {
3613                 talloc_free(r);
3614                 return false;
3615         }
3616 
3617         ndr_err = call->ndr_push(push, NDR_OUT, r);
3618         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3619                 talloc_free(r);
3620                 return false;
3621         }
3622 
3623         blob = ndr_push_blob(push);
3624         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3625                 talloc_free(r);
3626                 return false;
3627         }
3628 
3629         talloc_free(r);
3630 
3631         return true;
3632 }
3633 
3634 static bool api_samr_QueryDomainInfo2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3635 {
3636         const struct ndr_interface_call *call;
3637         struct ndr_pull *pull;
3638         struct ndr_push *push;
3639         enum ndr_err_code ndr_err;
3640         DATA_BLOB blob;
3641         struct samr_QueryDomainInfo2 *r;
3642 
3643         call = &ndr_table_samr.calls[NDR_SAMR_QUERYDOMAININFO2];
3644 
3645         r = talloc(talloc_tos(), struct samr_QueryDomainInfo2);
3646         if (r == NULL) {
3647                 return false;
3648         }
3649 
3650         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3651                 talloc_free(r);
3652                 return false;
3653         }
3654 
3655         pull = ndr_pull_init_blob(&blob, r, NULL);
3656         if (pull == NULL) {
3657                 talloc_free(r);
3658                 return false;
3659         }
3660 
3661         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3662         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3663         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3664                 talloc_free(r);
3665                 return false;
3666         }
3667 
3668         if (DEBUGLEVEL >= 10) {
3669                 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo2, r);
3670         }
3671 
3672         ZERO_STRUCT(r->out);
3673         r->out.info = talloc_zero(r, union samr_DomainInfo *);
3674         if (r->out.info == NULL) {
3675                 talloc_free(r);
3676                 return false;
3677         }
3678 
3679         r->out.result = _samr_QueryDomainInfo2(p, r);
3680 
3681         if (p->rng_fault_state) {
3682                 talloc_free(r);
3683                 /* Return true here, srv_pipe_hnd.c will take care */
3684                 return true;
3685         }
3686 
3687         if (DEBUGLEVEL >= 10) {
3688                 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo2, r);
3689         }
3690 
3691         push = ndr_push_init_ctx(r, NULL);
3692         if (push == NULL) {
3693                 talloc_free(r);
3694                 return false;
3695         }
3696 
3697         ndr_err = call->ndr_push(push, NDR_OUT, r);
3698         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3699                 talloc_free(r);
3700                 return false;
3701         }
3702 
3703         blob = ndr_push_blob(push);
3704         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3705                 talloc_free(r);
3706                 return false;
3707         }
3708 
3709         talloc_free(r);
3710 
3711         return true;
3712 }
3713 
3714 static bool api_samr_QueryUserInfo2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3715 {
3716         const struct ndr_interface_call *call;
3717         struct ndr_pull *pull;
3718         struct ndr_push *push;
3719         enum ndr_err_code ndr_err;
3720         DATA_BLOB blob;
3721         struct samr_QueryUserInfo2 *r;
3722 
3723         call = &ndr_table_samr.calls[NDR_SAMR_QUERYUSERINFO2];
3724 
3725         r = talloc(talloc_tos(), struct samr_QueryUserInfo2);
3726         if (r == NULL) {
3727                 return false;
3728         }
3729 
3730         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3731                 talloc_free(r);
3732                 return false;
3733         }
3734 
3735         pull = ndr_pull_init_blob(&blob, r, NULL);
3736         if (pull == NULL) {
3737                 talloc_free(r);
3738                 return false;
3739         }
3740 
3741         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3742         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3743         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3744                 talloc_free(r);
3745                 return false;
3746         }
3747 
3748         if (DEBUGLEVEL >= 10) {
3749                 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo2, r);
3750         }
3751 
3752         ZERO_STRUCT(r->out);
3753         r->out.info = talloc_zero(r, union samr_UserInfo *);
3754         if (r->out.info == NULL) {
3755                 talloc_free(r);
3756                 return false;
3757         }
3758 
3759         r->out.result = _samr_QueryUserInfo2(p, r);
3760 
3761         if (p->rng_fault_state) {
3762                 talloc_free(r);
3763                 /* Return true here, srv_pipe_hnd.c will take care */
3764                 return true;
3765         }
3766 
3767         if (DEBUGLEVEL >= 10) {
3768                 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo2, r);
3769         }
3770 
3771         push = ndr_push_init_ctx(r, NULL);
3772         if (push == NULL) {
3773                 talloc_free(r);
3774                 return false;
3775         }
3776 
3777         ndr_err = call->ndr_push(push, NDR_OUT, r);
3778         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3779                 talloc_free(r);
3780                 return false;
3781         }
3782 
3783         blob = ndr_push_blob(push);
3784         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3785                 talloc_free(r);
3786                 return false;
3787         }
3788 
3789         talloc_free(r);
3790 
3791         return true;
3792 }
3793 
3794 static bool api_samr_QueryDisplayInfo2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3795 {
3796         const struct ndr_interface_call *call;
3797         struct ndr_pull *pull;
3798         struct ndr_push *push;
3799         enum ndr_err_code ndr_err;
3800         DATA_BLOB blob;
3801         struct samr_QueryDisplayInfo2 *r;
3802 
3803         call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO2];
3804 
3805         r = talloc(talloc_tos(), struct samr_QueryDisplayInfo2);
3806         if (r == NULL) {
3807                 return false;
3808         }
3809 
3810         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3811                 talloc_free(r);
3812                 return false;
3813         }
3814 
3815         pull = ndr_pull_init_blob(&blob, r, NULL);
3816         if (pull == NULL) {
3817                 talloc_free(r);
3818                 return false;
3819         }
3820 
3821         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3822         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3823         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3824                 talloc_free(r);
3825                 return false;
3826         }
3827 
3828         if (DEBUGLEVEL >= 10) {
3829                 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo2, r);
3830         }
3831 
3832         ZERO_STRUCT(r->out);
3833         r->out.total_size = talloc_zero(r, uint32_t);
3834         if (r->out.total_size == NULL) {
3835                 talloc_free(r);
3836                 return false;
3837         }
3838 
3839         r->out.returned_size = talloc_zero(r, uint32_t);
3840         if (r->out.returned_size == NULL) {
3841                 talloc_free(r);
3842                 return false;
3843         }
3844 
3845         r->out.info = talloc_zero(r, union samr_DispInfo);
3846         if (r->out.info == NULL) {
3847                 talloc_free(r);
3848                 return false;
3849         }
3850 
3851         r->out.result = _samr_QueryDisplayInfo2(p, r);
3852 
3853         if (p->rng_fault_state) {
3854                 talloc_free(r);
3855                 /* Return true here, srv_pipe_hnd.c will take care */
3856                 return true;
3857         }
3858 
3859         if (DEBUGLEVEL >= 10) {
3860                 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo2, r);
3861         }
3862 
3863         push = ndr_push_init_ctx(r, NULL);
3864         if (push == NULL) {
3865                 talloc_free(r);
3866                 return false;
3867         }
3868 
3869         ndr_err = call->ndr_push(push, NDR_OUT, r);
3870         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3871                 talloc_free(r);
3872                 return false;
3873         }
3874 
3875         blob = ndr_push_blob(push);
3876         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3877                 talloc_free(r);
3878                 return false;
3879         }
3880 
3881         talloc_free(r);
3882 
3883         return true;
3884 }
3885 
3886 static bool api_samr_GetDisplayEnumerationIndex2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3887 {
3888         const struct ndr_interface_call *call;
3889         struct ndr_pull *pull;
3890         struct ndr_push *push;
3891         enum ndr_err_code ndr_err;
3892         DATA_BLOB blob;
3893         struct samr_GetDisplayEnumerationIndex2 *r;
3894 
3895         call = &ndr_table_samr.calls[NDR_SAMR_GETDISPLAYENUMERATIONINDEX2];
3896 
3897         r = talloc(talloc_tos(), struct samr_GetDisplayEnumerationIndex2);
3898         if (r == NULL) {
3899                 return false;
3900         }
3901 
3902         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3903                 talloc_free(r);
3904                 return false;
3905         }
3906 
3907         pull = ndr_pull_init_blob(&blob, r, NULL);
3908         if (pull == NULL) {
3909                 talloc_free(r);
3910                 return false;
3911         }
3912 
3913         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3914         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3915         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3916                 talloc_free(r);
3917                 return false;
3918         }
3919 
3920         if (DEBUGLEVEL >= 10) {
3921                 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex2, r);
3922         }
3923 
3924         ZERO_STRUCT(r->out);
3925         r->out.idx = talloc_zero(r, uint32_t);
3926         if (r->out.idx == NULL) {
3927                 talloc_free(r);
3928                 return false;
3929         }
3930 
3931         r->out.result = _samr_GetDisplayEnumerationIndex2(p, r);
3932 
3933         if (p->rng_fault_state) {
3934                 talloc_free(r);
3935                 /* Return true here, srv_pipe_hnd.c will take care */
3936                 return true;
3937         }
3938 
3939         if (DEBUGLEVEL >= 10) {
3940                 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex2, r);
3941         }
3942 
3943         push = ndr_push_init_ctx(r, NULL);
3944         if (push == NULL) {
3945                 talloc_free(r);
3946                 return false;
3947         }
3948 
3949         ndr_err = call->ndr_push(push, NDR_OUT, r);
3950         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3951                 talloc_free(r);
3952                 return false;
3953         }
3954 
3955         blob = ndr_push_blob(push);
3956         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3957                 talloc_free(r);
3958                 return false;
3959         }
3960 
3961         talloc_free(r);
3962 
3963         return true;
3964 }
3965 
3966 static bool api_samr_CreateUser2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3967 {
3968         const struct ndr_interface_call *call;
3969         struct ndr_pull *pull;
3970         struct ndr_push *push;
3971         enum ndr_err_code ndr_err;
3972         DATA_BLOB blob;
3973         struct samr_CreateUser2 *r;
3974 
3975         call = &ndr_table_samr.calls[NDR_SAMR_CREATEUSER2];
3976 
3977         r = talloc(talloc_tos(), struct samr_CreateUser2);
3978         if (r == NULL) {
3979                 return false;
3980         }
3981 
3982         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3983                 talloc_free(r);
3984                 return false;
3985         }
3986 
3987         pull = ndr_pull_init_blob(&blob, r, NULL);
3988         if (pull == NULL) {
3989                 talloc_free(r);
3990                 return false;
3991         }
3992 
3993         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3994         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3995         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3996                 talloc_free(r);
3997                 return false;
3998         }
3999 
4000         if (DEBUGLEVEL >= 10) {
4001                 NDR_PRINT_IN_DEBUG(samr_CreateUser2, r);
4002         }
4003 
4004         ZERO_STRUCT(r->out);
4005         r->out.user_handle = talloc_zero(r, struct policy_handle);
4006         if (r->out.user_handle == NULL) {
4007                 talloc_free(r);
4008                 return false;
4009         }
4010 
4011         r->out.access_granted = talloc_zero(r, uint32_t);
4012         if (r->out.access_granted == NULL) {
4013                 talloc_free(r);
4014                 return false;
4015         }
4016 
4017         r->out.rid = talloc_zero(r, uint32_t);
4018         if (r->out.rid == NULL) {
4019                 talloc_free(r);
4020                 return false;
4021         }
4022 
4023         r->out.result = _samr_CreateUser2(p, r);
4024 
4025         if (p->rng_fault_state) {
4026                 talloc_free(r);
4027                 /* Return true here, srv_pipe_hnd.c will take care */
4028                 return true;
4029         }
4030 
4031         if (DEBUGLEVEL >= 10) {
4032                 NDR_PRINT_OUT_DEBUG(samr_CreateUser2, r);
4033         }
4034 
4035         push = ndr_push_init_ctx(r, NULL);
4036         if (push == NULL) {
4037                 talloc_free(r);
4038                 return false;
4039         }
4040 
4041         ndr_err = call->ndr_push(push, NDR_OUT, r);
4042         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4043                 talloc_free(r);
4044                 return false;
4045         }
4046 
4047         blob = ndr_push_blob(push);
4048         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4049                 talloc_free(r);
4050                 return false;
4051         }
4052 
4053         talloc_free(r);
4054 
4055         return true;
4056 }
4057 
4058 static bool api_samr_QueryDisplayInfo3(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4059 {
4060         const struct ndr_interface_call *call;
4061         struct ndr_pull *pull;
4062         struct ndr_push *push;
4063         enum ndr_err_code ndr_err;
4064         DATA_BLOB blob;
4065         struct samr_QueryDisplayInfo3 *r;
4066 
4067         call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO3];
4068 
4069         r = talloc(talloc_tos(), struct samr_QueryDisplayInfo3);
4070         if (r == NULL) {
4071                 return false;
4072         }
4073 
4074         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4075                 talloc_free(r);
4076                 return false;
4077         }
4078 
4079         pull = ndr_pull_init_blob(&blob, r, NULL);
4080         if (pull == NULL) {
4081                 talloc_free(r);
4082                 return false;
4083         }
4084 
4085         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4086         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4087         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4088                 talloc_free(r);
4089                 return false;
4090         }
4091 
4092         if (DEBUGLEVEL >= 10) {
4093                 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo3, r);
4094         }
4095 
4096         ZERO_STRUCT(r->out);
4097         r->out.total_size = talloc_zero(r, uint32_t);
4098         if (r->out.total_size == NULL) {
4099                 talloc_free(r);
4100                 return false;
4101         }
4102 
4103         r->out.returned_size = talloc_zero(r, uint32_t);
4104         if (r->out.returned_size == NULL) {
4105                 talloc_free(r);
4106                 return false;
4107         }
4108 
4109         r->out.info = talloc_zero(r, union samr_DispInfo);
4110         if (r->out.info == NULL) {
4111                 talloc_free(r);
4112                 return false;
4113         }
4114 
4115         r->out.result = _samr_QueryDisplayInfo3(p, r);
4116 
4117         if (p->rng_fault_state) {
4118                 talloc_free(r);
4119                 /* Return true here, srv_pipe_hnd.c will take care */
4120                 return true;
4121         }
4122 
4123         if (DEBUGLEVEL >= 10) {
4124                 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo3, r);
4125         }
4126 
4127         push = ndr_push_init_ctx(r, NULL);
4128         if (push == NULL) {
4129                 talloc_free(r);
4130                 return false;
4131         }
4132 
4133         ndr_err = call->ndr_push(push, NDR_OUT, r);
4134         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4135                 talloc_free(r);
4136                 return false;
4137         }
4138 
4139         blob = ndr_push_blob(push);
4140         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4141                 talloc_free(r);
4142                 return false;
4143         }
4144 
4145         talloc_free(r);
4146 
4147         return true;
4148 }
4149 
4150 static bool api_samr_AddMultipleMembersToAlias(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4151 {
4152         const struct ndr_interface_call *call;
4153         struct ndr_pull *pull;
4154         struct ndr_push *push;
4155         enum ndr_err_code ndr_err;
4156         DATA_BLOB blob;
4157         struct samr_AddMultipleMembersToAlias *r;
4158 
4159         call = &ndr_table_samr.calls[NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS];
4160 
4161         r = talloc(talloc_tos(), struct samr_AddMultipleMembersToAlias);
4162         if (r == NULL) {
4163                 return false;
4164         }
4165 
4166         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4167                 talloc_free(r);
4168                 return false;
4169         }
4170 
4171         pull = ndr_pull_init_blob(&blob, r, NULL);
4172         if (pull == NULL) {
4173                 talloc_free(r);
4174                 return false;
4175         }
4176 
4177         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4178         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4179         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4180                 talloc_free(r);
4181                 return false;
4182         }
4183 
4184         if (DEBUGLEVEL >= 10) {
4185                 NDR_PRINT_IN_DEBUG(samr_AddMultipleMembersToAlias, r);
4186         }
4187 
4188         r->out.result = _samr_AddMultipleMembersToAlias(p, r);
4189 
4190         if (p->rng_fault_state) {
4191                 talloc_free(r);
4192                 /* Return true here, srv_pipe_hnd.c will take care */
4193                 return true;
4194         }
4195 
4196         if (DEBUGLEVEL >= 10) {
4197                 NDR_PRINT_OUT_DEBUG(samr_AddMultipleMembersToAlias, r);
4198         }
4199 
4200         push = ndr_push_init_ctx(r, NULL);
4201         if (push == NULL) {
4202                 talloc_free(r);
4203                 return false;
4204         }
4205 
4206         ndr_err = call->ndr_push(push, NDR_OUT, r);
4207         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4208                 talloc_free(r);
4209                 return false;
4210         }
4211 
4212         blob = ndr_push_blob(push);
4213         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4214                 talloc_free(r);
4215                 return false;
4216         }
4217 
4218         talloc_free(r);
4219 
4220         return true;
4221 }
4222 
4223 static bool api_samr_RemoveMultipleMembersFromAlias(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4224 {
4225         const struct ndr_interface_call *call;
4226         struct ndr_pull *pull;
4227         struct ndr_push *push;
4228         enum ndr_err_code ndr_err;
4229         DATA_BLOB blob;
4230         struct samr_RemoveMultipleMembersFromAlias *r;
4231 
4232         call = &ndr_table_samr.calls[NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS];
4233 
4234         r = talloc(talloc_tos(), struct samr_RemoveMultipleMembersFromAlias);
4235         if (r == NULL) {
4236                 return false;
4237         }
4238 
4239         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4240                 talloc_free(r);
4241                 return false;
4242         }
4243 
4244         pull = ndr_pull_init_blob(&blob, r, NULL);
4245         if (pull == NULL) {
4246                 talloc_free(r);
4247                 return false;
4248         }
4249 
4250         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4251         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4252         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4253                 talloc_free(r);
4254                 return false;
4255         }
4256 
4257         if (DEBUGLEVEL >= 10) {
4258                 NDR_PRINT_IN_DEBUG(samr_RemoveMultipleMembersFromAlias, r);
4259         }
4260 
4261         r->out.result = _samr_RemoveMultipleMembersFromAlias(p, r);
4262 
4263         if (p->rng_fault_state) {
4264                 talloc_free(r);
4265                 /* Return true here, srv_pipe_hnd.c will take care */
4266                 return true;
4267         }
4268 
4269         if (DEBUGLEVEL >= 10) {
4270                 NDR_PRINT_OUT_DEBUG(samr_RemoveMultipleMembersFromAlias, r);
4271         }
4272 
4273         push = ndr_push_init_ctx(r, NULL);
4274         if (push == NULL) {
4275                 talloc_free(r);
4276                 return false;
4277         }
4278 
4279         ndr_err = call->ndr_push(push, NDR_OUT, r);
4280         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4281                 talloc_free(r);
4282                 return false;
4283         }
4284 
4285         blob = ndr_push_blob(push);
4286         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4287                 talloc_free(r);
4288                 return false;
4289         }
4290 
4291         talloc_free(r);
4292 
4293         return true;
4294 }
4295 
4296 static bool api_samr_OemChangePasswordUser2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4297 {
4298         const struct ndr_interface_call *call;
4299         struct ndr_pull *pull;
4300         struct ndr_push *push;
4301         enum ndr_err_code ndr_err;
4302         DATA_BLOB blob;
4303         struct samr_OemChangePasswordUser2 *r;
4304 
4305         call = &ndr_table_samr.calls[NDR_SAMR_OEMCHANGEPASSWORDUSER2];
4306 
4307         r = talloc(talloc_tos(), struct samr_OemChangePasswordUser2);
4308         if (r == NULL) {
4309                 return false;
4310         }
4311 
4312         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4313                 talloc_free(r);
4314                 return false;
4315         }
4316 
4317         pull = ndr_pull_init_blob(&blob, r, NULL);
4318         if (pull == NULL) {
4319                 talloc_free(r);
4320                 return false;
4321         }
4322 
4323         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4324         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4325         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4326                 talloc_free(r);
4327                 return false;
4328         }
4329 
4330         if (DEBUGLEVEL >= 10) {
4331                 NDR_PRINT_IN_DEBUG(samr_OemChangePasswordUser2, r);
4332         }
4333 
4334         r->out.result = _samr_OemChangePasswordUser2(p, r);
4335 
4336         if (p->rng_fault_state) {
4337                 talloc_free(r);
4338                 /* Return true here, srv_pipe_hnd.c will take care */
4339                 return true;
4340         }
4341 
4342         if (DEBUGLEVEL >= 10) {
4343                 NDR_PRINT_OUT_DEBUG(samr_OemChangePasswordUser2, r);
4344         }
4345 
4346         push = ndr_push_init_ctx(r, NULL);
4347         if (push == NULL) {
4348                 talloc_free(r);
4349                 return false;
4350         }
4351 
4352         ndr_err = call->ndr_push(push, NDR_OUT, r);
4353         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4354                 talloc_free(r);
4355                 return false;
4356         }
4357 
4358         blob = ndr_push_blob(push);
4359         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4360                 talloc_free(r);
4361                 return false;
4362         }
4363 
4364         talloc_free(r);
4365 
4366         return true;
4367 }
4368 
4369 static bool api_samr_ChangePasswordUser2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4370 {
4371         const struct ndr_interface_call *call;
4372         struct ndr_pull *pull;
4373         struct ndr_push *push;
4374         enum ndr_err_code ndr_err;
4375         DATA_BLOB blob;
4376         struct samr_ChangePasswordUser2 *r;
4377 
4378         call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER2];
4379 
4380         r = talloc(talloc_tos(), struct samr_ChangePasswordUser2);
4381         if (r == NULL) {
4382                 return false;
4383         }
4384 
4385         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4386                 talloc_free(r);
4387                 return false;
4388         }
4389 
4390         pull = ndr_pull_init_blob(&blob, r, NULL);
4391         if (pull == NULL) {
4392                 talloc_free(r);
4393                 return false;
4394         }
4395 
4396         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4397         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4398         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4399                 talloc_free(r);
4400                 return false;
4401         }
4402 
4403         if (DEBUGLEVEL >= 10) {
4404                 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser2, r);
4405         }
4406 
4407         r->out.result = _samr_ChangePasswordUser2(p, r);
4408 
4409         if (p->rng_fault_state) {
4410                 talloc_free(r);
4411                 /* Return true here, srv_pipe_hnd.c will take care */
4412                 return true;
4413         }
4414 
4415         if (DEBUGLEVEL >= 10) {
4416                 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser2, r);
4417         }
4418 
4419         push = ndr_push_init_ctx(r, NULL);
4420         if (push == NULL) {
4421                 talloc_free(r);
4422                 return false;
4423         }
4424 
4425         ndr_err = call->ndr_push(push, NDR_OUT, r);
4426         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4427                 talloc_free(r);
4428                 return false;
4429         }
4430 
4431         blob = ndr_push_blob(push);
4432         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4433                 talloc_free(r);
4434                 return false;
4435         }
4436 
4437         talloc_free(r);
4438 
4439         return true;
4440 }
4441 
4442 static bool api_samr_GetDomPwInfo(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4443 {
4444         const struct ndr_interface_call *call;
4445         struct ndr_pull *pull;
4446         struct ndr_push *push;
4447         enum ndr_err_code ndr_err;
4448         DATA_BLOB blob;
4449         struct samr_GetDomPwInfo *r;
4450 
4451         call = &ndr_table_samr.calls[NDR_SAMR_GETDOMPWINFO];
4452 
4453         r = talloc(talloc_tos(), struct samr_GetDomPwInfo);
4454         if (r == NULL) {
4455                 return false;
4456         }
4457 
4458         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4459                 talloc_free(r);
4460                 return false;
4461         }
4462 
4463         pull = ndr_pull_init_blob(&blob, r, NULL);
4464         if (pull == NULL) {
4465                 talloc_free(r);
4466                 return false;
4467         }
4468 
4469         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4470         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4471         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4472                 talloc_free(r);
4473                 return false;
4474         }
4475 
4476         if (DEBUGLEVEL >= 10) {
4477                 NDR_PRINT_IN_DEBUG(samr_GetDomPwInfo, r);
4478         }
4479 
4480         ZERO_STRUCT(r->out);
4481         r->out.info = talloc_zero(r, struct samr_PwInfo);
4482         if (r->out.info == NULL) {
4483                 talloc_free(r);
4484                 return false;
4485         }
4486 
4487         r->out.result = _samr_GetDomPwInfo(p, r);
4488 
4489         if (p->rng_fault_state) {
4490                 talloc_free(r);
4491                 /* Return true here, srv_pipe_hnd.c will take care */
4492                 return true;
4493         }
4494 
4495         if (DEBUGLEVEL >= 10) {
4496                 NDR_PRINT_OUT_DEBUG(samr_GetDomPwInfo, r);
4497         }
4498 
4499         push = ndr_push_init_ctx(r, NULL);
4500         if (push == NULL) {
4501                 talloc_free(r);
4502                 return false;
4503         }
4504 
4505         ndr_err = call->ndr_push(push, NDR_OUT, r);
4506         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4507                 talloc_free(r);
4508                 return false;
4509         }
4510 
4511         blob = ndr_push_blob(push);
4512         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4513                 talloc_free(r);
4514                 return false;
4515         }
4516 
4517         talloc_free(r);
4518 
4519         return true;
4520 }
4521 
4522 static bool api_samr_Connect2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4523 {
4524         const struct ndr_interface_call *call;
4525         struct ndr_pull *pull;
4526         struct ndr_push *push;
4527         enum ndr_err_code ndr_err;
4528         DATA_BLOB blob;
4529         struct samr_Connect2 *r;
4530 
4531         call = &ndr_table_samr.calls[NDR_SAMR_CONNECT2];
4532 
4533         r = talloc(talloc_tos(), struct samr_Connect2);
4534         if (r == NULL) {
4535                 return false;
4536         }
4537 
4538         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4539                 talloc_free(r);
4540                 return false;
4541         }
4542 
4543         pull = ndr_pull_init_blob(&blob, r, NULL);
4544         if (pull == NULL) {
4545                 talloc_free(r);
4546                 return false;
4547         }
4548 
4549         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4550         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4551         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4552                 talloc_free(r);
4553                 return false;
4554         }
4555 
4556         if (DEBUGLEVEL >= 10) {
4557                 NDR_PRINT_IN_DEBUG(samr_Connect2, r);
4558         }
4559 
4560         ZERO_STRUCT(r->out);
4561         r->out.connect_handle = talloc_zero(r, struct policy_handle);
4562         if (r->out.connect_handle == NULL) {
4563                 talloc_free(r);
4564                 return false;
4565         }
4566 
4567         r->out.result = _samr_Connect2(p, r);
4568 
4569         if (p->rng_fault_state) {
4570                 talloc_free(r);
4571                 /* Return true here, srv_pipe_hnd.c will take care */
4572                 return true;
4573         }
4574 
4575         if (DEBUGLEVEL >= 10) {
4576                 NDR_PRINT_OUT_DEBUG(samr_Connect2, r);
4577         }
4578 
4579         push = ndr_push_init_ctx(r, NULL);
4580         if (push == NULL) {
4581                 talloc_free(r);
4582                 return false;
4583         }
4584 
4585         ndr_err = call->ndr_push(push, NDR_OUT, r);
4586         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4587                 talloc_free(r);
4588                 return false;
4589         }
4590 
4591         blob = ndr_push_blob(push);
4592         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4593                 talloc_free(r);
4594                 return false;
4595         }
4596 
4597         talloc_free(r);
4598 
4599         return true;
4600 }
4601 
4602 static bool api_samr_SetUserInfo2(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4603 {
4604         const struct ndr_interface_call *call;
4605         struct ndr_pull *pull;
4606         struct ndr_push *push;
4607         enum ndr_err_code ndr_err;
4608         DATA_BLOB blob;
4609         struct samr_SetUserInfo2 *r;
4610 
4611         call = &ndr_table_samr.calls[NDR_SAMR_SETUSERINFO2];
4612 
4613         r = talloc(talloc_tos(), struct samr_SetUserInfo2);
4614         if (r == NULL) {
4615                 return false;
4616         }
4617 
4618         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4619                 talloc_free(r);
4620                 return false;
4621         }
4622 
4623         pull = ndr_pull_init_blob(&blob, r, NULL);
4624         if (pull == NULL) {
4625                 talloc_free(r);
4626                 return false;
4627         }
4628 
4629         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4630         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4631         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4632                 talloc_free(r);
4633                 return false;
4634         }
4635 
4636         if (DEBUGLEVEL >= 10) {
4637                 NDR_PRINT_IN_DEBUG(samr_SetUserInfo2, r);
4638         }
4639 
4640         r->out.result = _samr_SetUserInfo2(p, r);
4641 
4642         if (p->rng_fault_state) {
4643                 talloc_free(r);
4644                 /* Return true here, srv_pipe_hnd.c will take care */
4645                 return true;
4646         }
4647 
4648         if (DEBUGLEVEL >= 10) {
4649                 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo2, r);
4650         }
4651 
4652         push = ndr_push_init_ctx(r, NULL);
4653         if (push == NULL) {
4654                 talloc_free(r);
4655                 return false;
4656         }
4657 
4658         ndr_err = call->ndr_push(push, NDR_OUT, r);
4659         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4660                 talloc_free(r);
4661                 return false;
4662         }
4663 
4664         blob = ndr_push_blob(push);
4665         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4666                 talloc_free(r);
4667                 return false;
4668         }
4669 
4670         talloc_free(r);
4671 
4672         return true;
4673 }
4674 
4675 static bool api_samr_SetBootKeyInformation(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4676 {
4677         const struct ndr_interface_call *call;
4678         struct ndr_pull *pull;
4679         struct ndr_push *push;
4680         enum ndr_err_code ndr_err;
4681         DATA_BLOB blob;
4682         struct samr_SetBootKeyInformation *r;
4683 
4684         call = &ndr_table_samr.calls[NDR_SAMR_SETBOOTKEYINFORMATION];
4685 
4686         r = talloc(talloc_tos(), struct samr_SetBootKeyInformation);
4687         if (r == NULL) {
4688                 return false;
4689         }
4690 
4691         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4692                 talloc_free(r);
4693                 return false;
4694         }
4695 
4696         pull = ndr_pull_init_blob(&blob, r, NULL);
4697         if (pull == NULL) {
4698                 talloc_free(r);
4699                 return false;
4700         }
4701 
4702         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4703         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4704         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4705                 talloc_free(r);
4706                 return false;
4707         }
4708 
4709         if (DEBUGLEVEL >= 10) {
4710                 NDR_PRINT_IN_DEBUG(samr_SetBootKeyInformation, r);
4711         }
4712 
4713         r->out.result = _samr_SetBootKeyInformation(p, r);
4714 
4715         if (p->rng_fault_state) {
4716                 talloc_free(r);
4717                 /* Return true here, srv_pipe_hnd.c will take care */
4718                 return true;
4719         }
4720 
4721         if (DEBUGLEVEL >= 10) {
4722                 NDR_PRINT_OUT_DEBUG(samr_SetBootKeyInformation, r);
4723         }
4724 
4725         push = ndr_push_init_ctx(r, NULL);
4726         if (push == NULL) {
4727                 talloc_free(r);
4728                 return false;
4729         }
4730 
4731         ndr_err = call->ndr_push(push, NDR_OUT, r);
4732         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4733                 talloc_free(r);
4734                 return false;
4735         }
4736 
4737         blob = ndr_push_blob(push);
4738         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4739                 talloc_free(r);
4740                 return false;
4741         }
4742 
4743         talloc_free(r);
4744 
4745         return true;
4746 }
4747 
4748 static bool api_samr_GetBootKeyInformation(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4749 {
4750         const struct ndr_interface_call *call;
4751         struct ndr_pull *pull;
4752         struct ndr_push *push;
4753         enum ndr_err_code ndr_err;
4754         DATA_BLOB blob;
4755         struct samr_GetBootKeyInformation *r;
4756 
4757         call = &ndr_table_samr.calls[NDR_SAMR_GETBOOTKEYINFORMATION];
4758 
4759         r = talloc(talloc_tos(), struct samr_GetBootKeyInformation);
4760         if (r == NULL) {
4761                 return false;
4762         }
4763 
4764         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4765                 talloc_free(r);
4766                 return false;
4767         }
4768 
4769         pull = ndr_pull_init_blob(&blob, r, NULL);
4770         if (pull == NULL) {
4771                 talloc_free(r);
4772                 return false;
4773         }
4774 
4775         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4776         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4777         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4778                 talloc_free(r);
4779                 return false;
4780         }
4781 
4782         if (DEBUGLEVEL >= 10) {
4783                 NDR_PRINT_IN_DEBUG(samr_GetBootKeyInformation, r);
4784         }
4785 
4786         ZERO_STRUCT(r->out);
4787         r->out.unknown = talloc_zero(r, uint32_t);
4788         if (r->out.unknown == NULL) {
4789                 talloc_free(r);
4790                 return false;
4791         }
4792 
4793         r->out.result = _samr_GetBootKeyInformation(p, r);
4794 
4795         if (p->rng_fault_state) {
4796                 talloc_free(r);
4797                 /* Return true here, srv_pipe_hnd.c will take care */
4798                 return true;
4799         }
4800 
4801         if (DEBUGLEVEL >= 10) {
4802                 NDR_PRINT_OUT_DEBUG(samr_GetBootKeyInformation, r);
4803         }
4804 
4805         push = ndr_push_init_ctx(r, NULL);
4806         if (push == NULL) {
4807                 talloc_free(r);
4808                 return false;
4809         }
4810 
4811         ndr_err = call->ndr_push(push, NDR_OUT, r);
4812         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4813                 talloc_free(r);
4814                 return false;
4815         }
4816 
4817         blob = ndr_push_blob(push);
4818         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4819                 talloc_free(r);
4820                 return false;
4821         }
4822 
4823         talloc_free(r);
4824 
4825         return true;
4826 }
4827 
4828 static bool api_samr_Connect3(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4829 {
4830         const struct ndr_interface_call *call;
4831         struct ndr_pull *pull;
4832         struct ndr_push *push;
4833         enum ndr_err_code ndr_err;
4834         DATA_BLOB blob;
4835         struct samr_Connect3 *r;
4836 
4837         call = &ndr_table_samr.calls[NDR_SAMR_CONNECT3];
4838 
4839         r = talloc(talloc_tos(), struct samr_Connect3);
4840         if (r == NULL) {
4841                 return false;
4842         }
4843 
4844         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4845                 talloc_free(r);
4846                 return false;
4847         }
4848 
4849         pull = ndr_pull_init_blob(&blob, r, NULL);
4850         if (pull == NULL) {
4851                 talloc_free(r);
4852                 return false;
4853         }
4854 
4855         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4856         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4857         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4858                 talloc_free(r);
4859                 return false;
4860         }
4861 
4862         if (DEBUGLEVEL >= 10) {
4863                 NDR_PRINT_IN_DEBUG(samr_Connect3, r);
4864         }
4865 
4866         ZERO_STRUCT(r->out);
4867         r->out.connect_handle = talloc_zero(r, struct policy_handle);
4868         if (r->out.connect_handle == NULL) {
4869                 talloc_free(r);
4870                 return false;
4871         }
4872 
4873         r->out.result = _samr_Connect3(p, r);
4874 
4875         if (p->rng_fault_state) {
4876                 talloc_free(r);
4877                 /* Return true here, srv_pipe_hnd.c will take care */
4878                 return true;
4879         }
4880 
4881         if (DEBUGLEVEL >= 10) {
4882                 NDR_PRINT_OUT_DEBUG(samr_Connect3, r);
4883         }
4884 
4885         push = ndr_push_init_ctx(r, NULL);
4886         if (push == NULL) {
4887                 talloc_free(r);
4888                 return false;
4889         }
4890 
4891         ndr_err = call->ndr_push(push, NDR_OUT, r);
4892         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4893                 talloc_free(r);
4894                 return false;
4895         }
4896 
4897         blob = ndr_push_blob(push);
4898         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4899                 talloc_free(r);
4900                 return false;
4901         }
4902 
4903         talloc_free(r);
4904 
4905         return true;
4906 }
4907 
4908 static bool api_samr_Connect4(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4909 {
4910         const struct ndr_interface_call *call;
4911         struct ndr_pull *pull;
4912         struct ndr_push *push;
4913         enum ndr_err_code ndr_err;
4914         DATA_BLOB blob;
4915         struct samr_Connect4 *r;
4916 
4917         call = &ndr_table_samr.calls[NDR_SAMR_CONNECT4];
4918 
4919         r = talloc(talloc_tos(), struct samr_Connect4);
4920         if (r == NULL) {
4921                 return false;
4922         }
4923 
4924         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4925                 talloc_free(r);
4926                 return false;
4927         }
4928 
4929         pull = ndr_pull_init_blob(&blob, r, NULL);
4930         if (pull == NULL) {
4931                 talloc_free(r);
4932                 return false;
4933         }
4934 
4935         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4936         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4937         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4938                 talloc_free(r);
4939                 return false;
4940         }
4941 
4942         if (DEBUGLEVEL >= 10) {
4943                 NDR_PRINT_IN_DEBUG(samr_Connect4, r);
4944         }
4945 
4946         ZERO_STRUCT(r->out);
4947         r->out.connect_handle = talloc_zero(r, struct policy_handle);
4948         if (r->out.connect_handle == NULL) {
4949                 talloc_free(r);
4950                 return false;
4951         }
4952 
4953         r->out.result = _samr_Connect4(p, r);
4954 
4955         if (p->rng_fault_state) {
4956                 talloc_free(r);
4957                 /* Return true here, srv_pipe_hnd.c will take care */
4958                 return true;
4959         }
4960 
4961         if (DEBUGLEVEL >= 10) {
4962                 NDR_PRINT_OUT_DEBUG(samr_Connect4, r);
4963         }
4964 
4965         push = ndr_push_init_ctx(r, NULL);
4966         if (push == NULL) {
4967                 talloc_free(r);
4968                 return false;
4969         }
4970 
4971         ndr_err = call->ndr_push(push, NDR_OUT, r);
4972         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4973                 talloc_free(r);
4974                 return false;
4975         }
4976 
4977         blob = ndr_push_blob(push);
4978         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4979                 talloc_free(r);
4980                 return false;
4981         }
4982 
4983         talloc_free(r);
4984 
4985         return true;
4986 }
4987 
4988 static bool api_samr_ChangePasswordUser3(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
4989 {
4990         const struct ndr_interface_call *call;
4991         struct ndr_pull *pull;
4992         struct ndr_push *push;
4993         enum ndr_err_code ndr_err;
4994         DATA_BLOB blob;
4995         struct samr_ChangePasswordUser3 *r;
4996 
4997         call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER3];
4998 
4999         r = talloc(talloc_tos(), struct samr_ChangePasswordUser3);
5000         if (r == NULL) {
5001                 return false;
5002         }
5003 
5004         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5005                 talloc_free(r);
5006                 return false;
5007         }
5008 
5009         pull = ndr_pull_init_blob(&blob, r, NULL);
5010         if (pull == NULL) {
5011                 talloc_free(r);
5012                 return false;
5013         }
5014 
5015         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5016         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5017         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5018                 talloc_free(r);
5019                 return false;
5020         }
5021 
5022         if (DEBUGLEVEL >= 10) {
5023                 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser3, r);
5024         }
5025 
5026         ZERO_STRUCT(r->out);
5027         r->out.dominfo = talloc_zero(r, struct samr_DomInfo1 *);
5028         if (r->out.dominfo == NULL) {
5029                 talloc_free(r);
5030                 return false;
5031         }
5032 
5033         r->out.reject = talloc_zero(r, struct samr_ChangeReject *);
5034         if (r->out.reject == NULL) {
5035                 talloc_free(r);
5036                 return false;
5037         }
5038 
5039         r->out.result = _samr_ChangePasswordUser3(p, r);
5040 
5041         if (p->rng_fault_state) {
5042                 talloc_free(r);
5043                 /* Return true here, srv_pipe_hnd.c will take care */
5044                 return true;
5045         }
5046 
5047         if (DEBUGLEVEL >= 10) {
5048                 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser3, r);
5049         }
5050 
5051         push = ndr_push_init_ctx(r, NULL);
5052         if (push == NULL) {
5053                 talloc_free(r);
5054                 return false;
5055         }
5056 
5057         ndr_err = call->ndr_push(push, NDR_OUT, r);
5058         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5059                 talloc_free(r);
5060                 return false;
5061         }
5062 
5063         blob = ndr_push_blob(push);
5064         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5065                 talloc_free(r);
5066                 return false;
5067         }
5068 
5069         talloc_free(r);
5070 
5071         return true;
5072 }
5073 
5074 static bool api_samr_Connect5(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5075 {
5076         const struct ndr_interface_call *call;
5077         struct ndr_pull *pull;
5078         struct ndr_push *push;
5079         enum ndr_err_code ndr_err;
5080         DATA_BLOB blob;
5081         struct samr_Connect5 *r;
5082 
5083         call = &ndr_table_samr.calls[NDR_SAMR_CONNECT5];
5084 
5085         r = talloc(talloc_tos(), struct samr_Connect5);
5086         if (r == NULL) {
5087                 return false;
5088         }
5089 
5090         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5091                 talloc_free(r);
5092                 return false;
5093         }
5094 
5095         pull = ndr_pull_init_blob(&blob, r, NULL);
5096         if (pull == NULL) {
5097                 talloc_free(r);
5098                 return false;
5099         }
5100 
5101         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5102         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5103         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5104                 talloc_free(r);
5105                 return false;
5106         }
5107 
5108         if (DEBUGLEVEL >= 10) {
5109                 NDR_PRINT_IN_DEBUG(samr_Connect5, r);
5110         }
5111 
5112         ZERO_STRUCT(r->out);
5113         r->out.level_out = talloc_zero(r, uint32_t);
5114         if (r->out.level_out == NULL) {
5115                 talloc_free(r);
5116                 return false;
5117         }
5118 
5119         r->out.info_out = talloc_zero(r, union samr_ConnectInfo);
5120         if (r->out.info_out == NULL) {
5121                 talloc_free(r);
5122                 return false;
5123         }
5124 
5125         r->out.connect_handle = talloc_zero(r, struct policy_handle);
5126         if (r->out.connect_handle == NULL) {
5127                 talloc_free(r);
5128                 return false;
5129         }
5130 
5131         r->out.result = _samr_Connect5(p, r);
5132 
5133         if (p->rng_fault_state) {
5134                 talloc_free(r);
5135                 /* Return true here, srv_pipe_hnd.c will take care */
5136                 return true;
5137         }
5138 
5139         if (DEBUGLEVEL >= 10) {
5140                 NDR_PRINT_OUT_DEBUG(samr_Connect5, r);
5141         }
5142 
5143         push = ndr_push_init_ctx(r, NULL);
5144         if (push == NULL) {
5145                 talloc_free(r);
5146                 return false;
5147         }
5148 
5149         ndr_err = call->ndr_push(push, NDR_OUT, r);
5150         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5151                 talloc_free(r);
5152                 return false;
5153         }
5154 
5155         blob = ndr_push_blob(push);
5156         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5157                 talloc_free(r);
5158                 return false;
5159         }
5160 
5161         talloc_free(r);
5162 
5163         return true;
5164 }
5165 
5166 static bool api_samr_RidToSid(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5167 {
5168         const struct ndr_interface_call *call;
5169         struct ndr_pull *pull;
5170         struct ndr_push *push;
5171         enum ndr_err_code ndr_err;
5172         DATA_BLOB blob;
5173         struct samr_RidToSid *r;
5174 
5175         call = &ndr_table_samr.calls[NDR_SAMR_RIDTOSID];
5176 
5177         r = talloc(talloc_tos(), struct samr_RidToSid);
5178         if (r == NULL) {
5179                 return false;
5180         }
5181 
5182         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5183                 talloc_free(r);
5184                 return false;
5185         }
5186 
5187         pull = ndr_pull_init_blob(&blob, r, NULL);
5188         if (pull == NULL) {
5189                 talloc_free(r);
5190                 return false;
5191         }
5192 
5193         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5194         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5195         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5196                 talloc_free(r);
5197                 return false;
5198         }
5199 
5200         if (DEBUGLEVEL >= 10) {
5201                 NDR_PRINT_IN_DEBUG(samr_RidToSid, r);
5202         }
5203 
5204         ZERO_STRUCT(r->out);
5205         r->out.sid = talloc_zero(r, struct dom_sid2 *);
5206         if (r->out.sid == NULL) {
5207                 talloc_free(r);
5208                 return false;
5209         }
5210 
5211         r->out.result = _samr_RidToSid(p, r);
5212 
5213         if (p->rng_fault_state) {
5214                 talloc_free(r);
5215                 /* Return true here, srv_pipe_hnd.c will take care */
5216                 return true;
5217         }
5218 
5219         if (DEBUGLEVEL >= 10) {
5220                 NDR_PRINT_OUT_DEBUG(samr_RidToSid, r);
5221         }
5222 
5223         push = ndr_push_init_ctx(r, NULL);
5224         if (push == NULL) {
5225                 talloc_free(r);
5226                 return false;
5227         }
5228 
5229         ndr_err = call->ndr_push(push, NDR_OUT, r);
5230         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5231                 talloc_free(r);
5232                 return false;
5233         }
5234 
5235         blob = ndr_push_blob(push);
5236         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5237                 talloc_free(r);
5238                 return false;
5239         }
5240 
5241         talloc_free(r);
5242 
5243         return true;
5244 }
5245 
5246 static bool api_samr_SetDsrmPassword(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5247 {
5248         const struct ndr_interface_call *call;
5249         struct ndr_pull *pull;
5250         struct ndr_push *push;
5251         enum ndr_err_code ndr_err;
5252         DATA_BLOB blob;
5253         struct samr_SetDsrmPassword *r;
5254 
5255         call = &ndr_table_samr.calls[NDR_SAMR_SETDSRMPASSWORD];
5256 
5257         r = talloc(talloc_tos(), struct samr_SetDsrmPassword);
5258         if (r == NULL) {
5259                 return false;
5260         }
5261 
5262         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5263                 talloc_free(r);
5264                 return false;
5265         }
5266 
5267         pull = ndr_pull_init_blob(&blob, r, NULL);
5268         if (pull == NULL) {
5269                 talloc_free(r);
5270                 return false;
5271         }
5272 
5273         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5274         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5275         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5276                 talloc_free(r);
5277                 return false;
5278         }
5279 
5280         if (DEBUGLEVEL >= 10) {
5281                 NDR_PRINT_IN_DEBUG(samr_SetDsrmPassword, r);
5282         }
5283 
5284         r->out.result = _samr_SetDsrmPassword(p, r);
5285 
5286         if (p->rng_fault_state) {
5287                 talloc_free(r);
5288                 /* Return true here, srv_pipe_hnd.c will take care */
5289                 return true;
5290         }
5291 
5292         if (DEBUGLEVEL >= 10) {
5293                 NDR_PRINT_OUT_DEBUG(samr_SetDsrmPassword, r);
5294         }
5295 
5296         push = ndr_push_init_ctx(r, NULL);
5297         if (push == NULL) {
5298                 talloc_free(r);
5299                 return false;
5300         }
5301 
5302         ndr_err = call->ndr_push(push, NDR_OUT, r);
5303         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5304                 talloc_free(r);
5305                 return false;
5306         }
5307 
5308         blob = ndr_push_blob(push);
5309         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5310                 talloc_free(r);
5311                 return false;
5312         }
5313 
5314         talloc_free(r);
5315 
5316         return true;
5317 }
5318 
5319 static bool api_samr_ValidatePassword(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
5320 {
5321         const struct ndr_interface_call *call;
5322         struct ndr_pull *pull;
5323         struct ndr_push *push;
5324         enum ndr_err_code ndr_err;
5325         DATA_BLOB blob;
5326         struct samr_ValidatePassword *r;
5327 
5328         call = &ndr_table_samr.calls[NDR_SAMR_VALIDATEPASSWORD];
5329 
5330         r = talloc(talloc_tos(), struct samr_ValidatePassword);
5331         if (r == NULL) {
5332                 return false;
5333         }
5334 
5335         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5336                 talloc_free(r);
5337                 return false;
5338         }
5339 
5340         pull = ndr_pull_init_blob(&blob, r, NULL);
5341         if (pull == NULL) {
5342                 talloc_free(r);
5343                 return false;
5344         }
5345 
5346         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5347         ndr_err = call->ndr_pull(pull, NDR_IN, r);
5348         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5349                 talloc_free(r);
5350                 return false;
5351         }
5352 
5353         if (DEBUGLEVEL >= 10) {
5354                 NDR_PRINT_IN_DEBUG(samr_ValidatePassword, r);
5355         }
5356 
5357         ZERO_STRUCT(r->out);
5358         r->out.rep = talloc_zero(r, union samr_ValidatePasswordRep *);
5359         if (r->out.rep == NULL) {
5360                 talloc_free(r);
5361                 return false;
5362         }
5363 
5364         r->out.result = _samr_ValidatePassword(p, r);
5365 
5366         if (p->rng_fault_state) {
5367                 talloc_free(r);
5368                 /* Return true here, srv_pipe_hnd.c will take care */
5369                 return true;
5370         }
5371 
5372         if (DEBUGLEVEL >= 10) {
5373                 NDR_PRINT_OUT_DEBUG(samr_ValidatePassword, r);
5374         }
5375 
5376         push = ndr_push_init_ctx(r, NULL);
5377         if (push == NULL) {
5378                 talloc_free(r);
5379                 return false;
5380         }
5381 
5382         ndr_err = call->ndr_push(push, NDR_OUT, r);
5383         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5384                 talloc_free(r);
5385                 return false;
5386         }
5387 
5388         blob = ndr_push_blob(push);
5389         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5390                 talloc_free(r);
5391                 return false;
5392         }
5393 
5394         talloc_free(r);
5395 
5396         return true;
5397 }
5398 
5399 
5400 /* Tables */
5401 static struct api_struct api_samr_cmds[] = 
5402 {
5403         {"SAMR_CONNECT", NDR_SAMR_CONNECT, api_samr_Connect},
5404         {"SAMR_CLOSE", NDR_SAMR_CLOSE, api_samr_Close},
5405         {"SAMR_SETSECURITY", NDR_SAMR_SETSECURITY, api_samr_SetSecurity},
5406         {"SAMR_QUERYSECURITY", NDR_SAMR_QUERYSECURITY, api_samr_QuerySecurity},
5407         {"SAMR_SHUTDOWN", NDR_SAMR_SHUTDOWN, api_samr_Shutdown},
5408         {"SAMR_LOOKUPDOMAIN", NDR_SAMR_LOOKUPDOMAIN, api_samr_LookupDomain},
5409         {"SAMR_ENUMDOMAINS", NDR_SAMR_ENUMDOMAINS, api_samr_EnumDomains},
5410         {"SAMR_OPENDOMAIN", NDR_SAMR_OPENDOMAIN, api_samr_OpenDomain},
5411         {"SAMR_QUERYDOMAININFO", NDR_SAMR_QUERYDOMAININFO, api_samr_QueryDomainInfo},
5412         {"SAMR_SETDOMAININFO", NDR_SAMR_SETDOMAININFO, api_samr_SetDomainInfo},
5413         {"SAMR_CREATEDOMAINGROUP", NDR_SAMR_CREATEDOMAINGROUP, api_samr_CreateDomainGroup},
5414         {"SAMR_ENUMDOMAINGROUPS", NDR_SAMR_ENUMDOMAINGROUPS, api_samr_EnumDomainGroups},
5415         {"SAMR_CREATEUSER", NDR_SAMR_CREATEUSER, api_samr_CreateUser},
5416         {"SAMR_ENUMDOMAINUSERS", NDR_SAMR_ENUMDOMAINUSERS, api_samr_EnumDomainUsers},
5417         {"SAMR_CREATEDOMALIAS", NDR_SAMR_CREATEDOMALIAS, api_samr_CreateDomAlias},
5418         {"SAMR_ENUMDOMAINALIASES", NDR_SAMR_ENUMDOMAINALIASES, api_samr_EnumDomainAliases},
5419         {"SAMR_GETALIASMEMBERSHIP", NDR_SAMR_GETALIASMEMBERSHIP, api_samr_GetAliasMembership},
5420         {"SAMR_LOOKUPNAMES", NDR_SAMR_LOOKUPNAMES, api_samr_LookupNames},
5421         {"SAMR_LOOKUPRIDS", NDR_SAMR_LOOKUPRIDS, api_samr_LookupRids},
5422         {"SAMR_OPENGROUP", NDR_SAMR_OPENGROUP, api_samr_OpenGroup},
5423         {"SAMR_QUERYGROUPINFO", NDR_SAMR_QUERYGROUPINFO, api_samr_QueryGroupInfo},
5424         {"SAMR_SETGROUPINFO", NDR_SAMR_SETGROUPINFO, api_samr_SetGroupInfo},
5425         {"SAMR_ADDGROUPMEMBER", NDR_SAMR_ADDGROUPMEMBER, api_samr_AddGroupMember},
5426         {"SAMR_DELETEDOMAINGROUP", NDR_SAMR_DELETEDOMAINGROUP, api_samr_DeleteDomainGroup},
5427         {"SAMR_DELETEGROUPMEMBER", NDR_SAMR_DELETEGROUPMEMBER, api_samr_DeleteGroupMember},
5428         {"SAMR_QUERYGROUPMEMBER", NDR_SAMR_QUERYGROUPMEMBER, api_samr_QueryGroupMember},
5429         {"SAMR_SETMEMBERATTRIBUTESOFGROUP", NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP, api_samr_SetMemberAttributesOfGroup},
5430         {"SAMR_OPENALIAS", NDR_SAMR_OPENALIAS, api_samr_OpenAlias},
5431         {"SAMR_QUERYALIASINFO", NDR_SAMR_QUERYALIASINFO, api_samr_QueryAliasInfo},
5432         {"SAMR_SETALIASINFO", NDR_SAMR_SETALIASINFO, api_samr_SetAliasInfo},
5433         {"SAMR_DELETEDOMALIAS", NDR_SAMR_DELETEDOMALIAS, api_samr_DeleteDomAlias},
5434         {"SAMR_ADDALIASMEMBER", NDR_SAMR_ADDALIASMEMBER, api_samr_AddAliasMember},
5435         {"SAMR_DELETEALIASMEMBER", NDR_SAMR_DELETEALIASMEMBER, api_samr_DeleteAliasMember},
5436         {"SAMR_GETMEMBERSINALIAS", NDR_SAMR_GETMEMBERSINALIAS, api_samr_GetMembersInAlias},
5437         {"SAMR_OPENUSER", NDR_SAMR_OPENUSER, api_samr_OpenUser},
5438         {"SAMR_DELETEUSER", NDR_SAMR_DELETEUSER, api_samr_DeleteUser},
5439         {"SAMR_QUERYUSERINFO", NDR_SAMR_QUERYUSERINFO, api_samr_QueryUserInfo},
5440         {"SAMR_SETUSERINFO", NDR_SAMR_SETUSERINFO, api_samr_SetUserInfo},
5441         {"SAMR_CHANGEPASSWORDUSER", NDR_SAMR_CHANGEPASSWORDUSER, api_samr_ChangePasswordUser},
5442         {"SAMR_GETGROUPSFORUSER", NDR_SAMR_GETGROUPSFORUSER, api_samr_GetGroupsForUser},
5443         {"SAMR_QUERYDISPLAYINFO", NDR_SAMR_QUERYDISPLAYINFO, api_samr_QueryDisplayInfo},
5444         {"SAMR_GETDISPLAYENUMERATIONINDEX", NDR_SAMR_GETDISPLAYENUMERATIONINDEX, api_samr_GetDisplayEnumerationIndex},
5445         {"SAMR_TESTPRIVATEFUNCTIONSDOMAIN", NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN, api_samr_TestPrivateFunctionsDomain},
5446         {"SAMR_TESTPRIVATEFUNCTIONSUSER", NDR_SAMR_TESTPRIVATEFUNCTIONSUSER, api_samr_TestPrivateFunctionsUser},
5447         {"SAMR_GETUSERPWINFO", NDR_SAMR_GETUSERPWINFO, api_samr_GetUserPwInfo},
5448         {"SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN", NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN, api_samr_RemoveMemberFromForeignDomain},
5449         {"SAMR_QUERYDOMAININFO2", NDR_SAMR_QUERYDOMAININFO2, api_samr_QueryDomainInfo2},
5450         {"SAMR_QUERYUSERINFO2", NDR_SAMR_QUERYUSERINFO2, api_samr_QueryUserInfo2},
5451         {"SAMR_QUERYDISPLAYINFO2", NDR_SAMR_QUERYDISPLAYINFO2, api_samr_QueryDisplayInfo2},
5452         {"SAMR_GETDISPLAYENUMERATIONINDEX2", NDR_SAMR_GETDISPLAYENUMERATIONINDEX2, api_samr_GetDisplayEnumerationIndex2},
5453         {"SAMR_CREATEUSER2", NDR_SAMR_CREATEUSER2, api_samr_CreateUser2},
5454         {"SAMR_QUERYDISPLAYINFO3", NDR_SAMR_QUERYDISPLAYINFO3, api_samr_QueryDisplayInfo3},
5455         {"SAMR_ADDMULTIPLEMEMBERSTOALIAS", NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS, api_samr_AddMultipleMembersToAlias},
5456         {"SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS", NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS, api_samr_RemoveMultipleMembersFromAlias},
5457         {"SAMR_OEMCHANGEPASSWORDUSER2", NDR_SAMR_OEMCHANGEPASSWORDUSER2, api_samr_OemChangePasswordUser2},
5458         {"SAMR_CHANGEPASSWORDUSER2", NDR_SAMR_CHANGEPASSWORDUSER2, api_samr_ChangePasswordUser2},
5459         {"SAMR_GETDOMPWINFO", NDR_SAMR_GETDOMPWINFO, api_samr_GetDomPwInfo},
5460         {"SAMR_CONNECT2", NDR_SAMR_CONNECT2, api_samr_Connect2},
5461         {"SAMR_SETUSERINFO2", NDR_SAMR_SETUSERINFO2, api_samr_SetUserInfo2},
5462         {"SAMR_SETBOOTKEYINFORMATION", NDR_SAMR_SETBOOTKEYINFORMATION, api_samr_SetBootKeyInformation},
5463         {"SAMR_GETBOOTKEYINFORMATION", NDR_SAMR_GETBOOTKEYINFORMATION, api_samr_GetBootKeyInformation},
5464         {"SAMR_CONNECT3", NDR_SAMR_CONNECT3, api_samr_Connect3},
5465         {"SAMR_CONNECT4", NDR_SAMR_CONNECT4, api_samr_Connect4},
5466         {"SAMR_CHANGEPASSWORDUSER3", NDR_SAMR_CHANGEPASSWORDUSER3, api_samr_ChangePasswordUser3},
5467         {"SAMR_CONNECT5", NDR_SAMR_CONNECT5, api_samr_Connect5},
5468         {"SAMR_RIDTOSID", NDR_SAMR_RIDTOSID, api_samr_RidToSid},
5469         {"SAMR_SETDSRMPASSWORD", NDR_SAMR_SETDSRMPASSWORD, api_samr_SetDsrmPassword},
5470         {"SAMR_VALIDATEPASSWORD", NDR_SAMR_VALIDATEPASSWORD, api_samr_ValidatePassword},
5471 };
5472 
5473 void samr_get_pipe_fns(struct api_struct **fns, int *n_fns)
     /* [<][>][^][v][top][bottom][index][help] */
5474 {
5475         *fns = api_samr_cmds;
5476         *n_fns = sizeof(api_samr_cmds) / sizeof(struct api_struct);
5477 }
5478 
5479 NTSTATUS rpc_samr_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] */
5480 {
5481         if (cli->pipes_struct == NULL) {
5482                 return NT_STATUS_INVALID_PARAMETER;
5483         }
5484 
5485         switch (opnum)
5486         {
5487                 case NDR_SAMR_CONNECT: {
5488                         struct samr_Connect *r = (struct samr_Connect *)_r;
5489                         ZERO_STRUCT(r->out);
5490                         r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
5491                         if (r->out.connect_handle == NULL) {
5492                         return NT_STATUS_NO_MEMORY;
5493                         }
5494 
5495                         r->out.result = _samr_Connect(cli->pipes_struct, r);
5496                         return NT_STATUS_OK;
5497                 }
5498 
5499                 case NDR_SAMR_CLOSE: {
5500                         struct samr_Close *r = (struct samr_Close *)_r;
5501                         ZERO_STRUCT(r->out);
5502                         r->out.handle = r->in.handle;
5503                         r->out.result = _samr_Close(cli->pipes_struct, r);
5504                         return NT_STATUS_OK;
5505                 }
5506 
5507                 case NDR_SAMR_SETSECURITY: {
5508                         struct samr_SetSecurity *r = (struct samr_SetSecurity *)_r;
5509                         r->out.result = _samr_SetSecurity(cli->pipes_struct, r);
5510                         return NT_STATUS_OK;
5511                 }
5512 
5513                 case NDR_SAMR_QUERYSECURITY: {
5514                         struct samr_QuerySecurity *r = (struct samr_QuerySecurity *)_r;
5515                         ZERO_STRUCT(r->out);
5516                         r->out.sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf *);
5517                         if (r->out.sdbuf == NULL) {
5518                         return NT_STATUS_NO_MEMORY;
5519                         }
5520 
5521                         r->out.result = _samr_QuerySecurity(cli->pipes_struct, r);
5522                         return NT_STATUS_OK;
5523                 }
5524 
5525                 case NDR_SAMR_SHUTDOWN: {
5526                         struct samr_Shutdown *r = (struct samr_Shutdown *)_r;
5527                         r->out.result = _samr_Shutdown(cli->pipes_struct, r);
5528                         return NT_STATUS_OK;
5529                 }
5530 
5531                 case NDR_SAMR_LOOKUPDOMAIN: {
5532                         struct samr_LookupDomain *r = (struct samr_LookupDomain *)_r;
5533                         ZERO_STRUCT(r->out);
5534                         r->out.sid = talloc_zero(mem_ctx, struct dom_sid2 *);
5535                         if (r->out.sid == NULL) {
5536                         return NT_STATUS_NO_MEMORY;
5537                         }
5538 
5539                         r->out.result = _samr_LookupDomain(cli->pipes_struct, r);
5540                         return NT_STATUS_OK;
5541                 }
5542 
5543                 case NDR_SAMR_ENUMDOMAINS: {
5544                         struct samr_EnumDomains *r = (struct samr_EnumDomains *)_r;
5545                         ZERO_STRUCT(r->out);
5546                         r->out.resume_handle = r->in.resume_handle;
5547                         r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5548                         if (r->out.sam == NULL) {
5549                         return NT_STATUS_NO_MEMORY;
5550                         }
5551 
5552                         r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5553                         if (r->out.num_entries == NULL) {
5554                         return NT_STATUS_NO_MEMORY;
5555                         }
5556 
5557                         r->out.result = _samr_EnumDomains(cli->pipes_struct, r);
5558                         return NT_STATUS_OK;
5559                 }
5560 
5561                 case NDR_SAMR_OPENDOMAIN: {
5562                         struct samr_OpenDomain *r = (struct samr_OpenDomain *)_r;
5563                         ZERO_STRUCT(r->out);
5564                         r->out.domain_handle = talloc_zero(mem_ctx, struct policy_handle);
5565                         if (r->out.domain_handle == NULL) {
5566                         return NT_STATUS_NO_MEMORY;
5567                         }
5568 
5569                         r->out.result = _samr_OpenDomain(cli->pipes_struct, r);
5570                         return NT_STATUS_OK;
5571                 }
5572 
5573                 case NDR_SAMR_QUERYDOMAININFO: {
5574                         struct samr_QueryDomainInfo *r = (struct samr_QueryDomainInfo *)_r;
5575                         ZERO_STRUCT(r->out);
5576                         r->out.info = talloc_zero(mem_ctx, union samr_DomainInfo *);
5577                         if (r->out.info == NULL) {
5578                         return NT_STATUS_NO_MEMORY;
5579                         }
5580 
5581                         r->out.result = _samr_QueryDomainInfo(cli->pipes_struct, r);
5582                         return NT_STATUS_OK;
5583                 }
5584 
5585                 case NDR_SAMR_SETDOMAININFO: {
5586                         struct samr_SetDomainInfo *r = (struct samr_SetDomainInfo *)_r;
5587                         r->out.result = _samr_SetDomainInfo(cli->pipes_struct, r);
5588                         return NT_STATUS_OK;
5589                 }
5590 
5591                 case NDR_SAMR_CREATEDOMAINGROUP: {
5592                         struct samr_CreateDomainGroup *r = (struct samr_CreateDomainGroup *)_r;
5593                         ZERO_STRUCT(r->out);
5594                         r->out.group_handle = talloc_zero(mem_ctx, struct policy_handle);
5595                         if (r->out.group_handle == NULL) {
5596                         return NT_STATUS_NO_MEMORY;
5597                         }
5598 
5599                         r->out.rid = talloc_zero(mem_ctx, uint32_t);
5600                         if (r->out.rid == NULL) {
5601                         return NT_STATUS_NO_MEMORY;
5602                         }
5603 
5604                         r->out.result = _samr_CreateDomainGroup(cli->pipes_struct, r);
5605                         return NT_STATUS_OK;
5606                 }
5607 
5608                 case NDR_SAMR_ENUMDOMAINGROUPS: {
5609                         struct samr_EnumDomainGroups *r = (struct samr_EnumDomainGroups *)_r;
5610                         ZERO_STRUCT(r->out);
5611                         r->out.resume_handle = r->in.resume_handle;
5612                         r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5613                         if (r->out.sam == NULL) {
5614                         return NT_STATUS_NO_MEMORY;
5615                         }
5616 
5617                         r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5618                         if (r->out.num_entries == NULL) {
5619                         return NT_STATUS_NO_MEMORY;
5620                         }
5621 
5622                         r->out.result = _samr_EnumDomainGroups(cli->pipes_struct, r);
5623                         return NT_STATUS_OK;
5624                 }
5625 
5626                 case NDR_SAMR_CREATEUSER: {
5627                         struct samr_CreateUser *r = (struct samr_CreateUser *)_r;
5628                         ZERO_STRUCT(r->out);
5629                         r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle);
5630                         if (r->out.user_handle == NULL) {
5631                         return NT_STATUS_NO_MEMORY;
5632                         }
5633 
5634                         r->out.rid = talloc_zero(mem_ctx, uint32_t);
5635                         if (r->out.rid == NULL) {
5636                         return NT_STATUS_NO_MEMORY;
5637                         }
5638 
5639                         r->out.result = _samr_CreateUser(cli->pipes_struct, r);
5640                         return NT_STATUS_OK;
5641                 }
5642 
5643                 case NDR_SAMR_ENUMDOMAINUSERS: {
5644                         struct samr_EnumDomainUsers *r = (struct samr_EnumDomainUsers *)_r;
5645                         ZERO_STRUCT(r->out);
5646                         r->out.resume_handle = r->in.resume_handle;
5647                         r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5648                         if (r->out.sam == NULL) {
5649                         return NT_STATUS_NO_MEMORY;
5650                         }
5651 
5652                         r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5653                         if (r->out.num_entries == NULL) {
5654                         return NT_STATUS_NO_MEMORY;
5655                         }
5656 
5657                         r->out.result = _samr_EnumDomainUsers(cli->pipes_struct, r);
5658                         return NT_STATUS_OK;
5659                 }
5660 
5661                 case NDR_SAMR_CREATEDOMALIAS: {
5662                         struct samr_CreateDomAlias *r = (struct samr_CreateDomAlias *)_r;
5663                         ZERO_STRUCT(r->out);
5664                         r->out.alias_handle = talloc_zero(mem_ctx, struct policy_handle);
5665                         if (r->out.alias_handle == NULL) {
5666                         return NT_STATUS_NO_MEMORY;
5667                         }
5668 
5669                         r->out.rid = talloc_zero(mem_ctx, uint32_t);
5670                         if (r->out.rid == NULL) {
5671                         return NT_STATUS_NO_MEMORY;
5672                         }
5673 
5674                         r->out.result = _samr_CreateDomAlias(cli->pipes_struct, r);
5675                         return NT_STATUS_OK;
5676                 }
5677 
5678                 case NDR_SAMR_ENUMDOMAINALIASES: {
5679                         struct samr_EnumDomainAliases *r = (struct samr_EnumDomainAliases *)_r;
5680                         ZERO_STRUCT(r->out);
5681                         r->out.resume_handle = r->in.resume_handle;
5682                         r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5683                         if (r->out.sam == NULL) {
5684                         return NT_STATUS_NO_MEMORY;
5685                         }
5686 
5687                         r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5688                         if (r->out.num_entries == NULL) {
5689                         return NT_STATUS_NO_MEMORY;
5690                         }
5691 
5692                         r->out.result = _samr_EnumDomainAliases(cli->pipes_struct, r);
5693                         return NT_STATUS_OK;
5694                 }
5695 
5696                 case NDR_SAMR_GETALIASMEMBERSHIP: {
5697                         struct samr_GetAliasMembership *r = (struct samr_GetAliasMembership *)_r;
5698                         ZERO_STRUCT(r->out);
5699                         r->out.rids = talloc_zero(mem_ctx, struct samr_Ids);
5700                         if (r->out.rids == NULL) {
5701                         return NT_STATUS_NO_MEMORY;
5702                         }
5703 
5704                         r->out.result = _samr_GetAliasMembership(cli->pipes_struct, r);
5705                         return NT_STATUS_OK;
5706                 }
5707 
5708                 case NDR_SAMR_LOOKUPNAMES: {
5709                         struct samr_LookupNames *r = (struct samr_LookupNames *)_r;
5710                         ZERO_STRUCT(r->out);
5711                         r->out.rids = talloc_zero(mem_ctx, struct samr_Ids);
5712                         if (r->out.rids == NULL) {
5713                         return NT_STATUS_NO_MEMORY;
5714                         }
5715 
5716                         r->out.types = talloc_zero(mem_ctx, struct samr_Ids);
5717                         if (r->out.types == NULL) {
5718                         return NT_STATUS_NO_MEMORY;
5719                         }
5720 
5721                         r->out.result = _samr_LookupNames(cli->pipes_struct, r);
5722                         return NT_STATUS_OK;
5723                 }
5724 
5725                 case NDR_SAMR_LOOKUPRIDS: {
5726                         struct samr_LookupRids *r = (struct samr_LookupRids *)_r;
5727                         ZERO_STRUCT(r->out);
5728                         r->out.names = talloc_zero(mem_ctx, struct lsa_Strings);
5729                         if (r->out.names == NULL) {
5730                         return NT_STATUS_NO_MEMORY;
5731                         }
5732 
5733                         r->out.types = talloc_zero(mem_ctx, struct samr_Ids);
5734                         if (r->out.types == NULL) {
5735                         return NT_STATUS_NO_MEMORY;
5736                         }
5737 
5738                         r->out.result = _samr_LookupRids(cli->pipes_struct, r);
5739                         return NT_STATUS_OK;
5740                 }
5741 
5742                 case NDR_SAMR_OPENGROUP: {
5743                         struct samr_OpenGroup *r = (struct samr_OpenGroup *)_r;
5744                         ZERO_STRUCT(r->out);
5745                         r->out.group_handle = talloc_zero(mem_ctx, struct policy_handle);
5746                         if (r->out.group_handle == NULL) {
5747                         return NT_STATUS_NO_MEMORY;
5748                         }
5749 
5750                         r->out.result = _samr_OpenGroup(cli->pipes_struct, r);
5751                         return NT_STATUS_OK;
5752                 }
5753 
5754                 case NDR_SAMR_QUERYGROUPINFO: {
5755                         struct samr_QueryGroupInfo *r = (struct samr_QueryGroupInfo *)_r;
5756                         ZERO_STRUCT(r->out);
5757                         r->out.info = talloc_zero(mem_ctx, union samr_GroupInfo *);
5758                         if (r->out.info == NULL) {
5759                         return NT_STATUS_NO_MEMORY;
5760                         }
5761 
5762                         r->out.result = _samr_QueryGroupInfo(cli->pipes_struct, r);
5763                         return NT_STATUS_OK;
5764                 }
5765 
5766                 case NDR_SAMR_SETGROUPINFO: {
5767                         struct samr_SetGroupInfo *r = (struct samr_SetGroupInfo *)_r;
5768                         r->out.result = _samr_SetGroupInfo(cli->pipes_struct, r);
5769                         return NT_STATUS_OK;
5770                 }
5771 
5772                 case NDR_SAMR_ADDGROUPMEMBER: {
5773                         struct samr_AddGroupMember *r = (struct samr_AddGroupMember *)_r;
5774                         r->out.result = _samr_AddGroupMember(cli->pipes_struct, r);
5775                         return NT_STATUS_OK;
5776                 }
5777 
5778                 case NDR_SAMR_DELETEDOMAINGROUP: {
5779                         struct samr_DeleteDomainGroup *r = (struct samr_DeleteDomainGroup *)_r;
5780                         ZERO_STRUCT(r->out);
5781                         r->out.group_handle = r->in.group_handle;
5782                         r->out.result = _samr_DeleteDomainGroup(cli->pipes_struct, r);
5783                         return NT_STATUS_OK;
5784                 }
5785 
5786                 case NDR_SAMR_DELETEGROUPMEMBER: {
5787                         struct samr_DeleteGroupMember *r = (struct samr_DeleteGroupMember *)_r;
5788                         r->out.result = _samr_DeleteGroupMember(cli->pipes_struct, r);
5789                         return NT_STATUS_OK;
5790                 }
5791 
5792                 case NDR_SAMR_QUERYGROUPMEMBER: {
5793                         struct samr_QueryGroupMember *r = (struct samr_QueryGroupMember *)_r;
5794                         ZERO_STRUCT(r->out);
5795                         r->out.rids = talloc_zero(mem_ctx, struct samr_RidTypeArray *);
5796                         if (r->out.rids == NULL) {
5797                         return NT_STATUS_NO_MEMORY;
5798                         }
5799 
5800                         r->out.result = _samr_QueryGroupMember(cli->pipes_struct, r);
5801                         return NT_STATUS_OK;
5802                 }
5803 
5804                 case NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP: {
5805                         struct samr_SetMemberAttributesOfGroup *r = (struct samr_SetMemberAttributesOfGroup *)_r;
5806                         r->out.result = _samr_SetMemberAttributesOfGroup(cli->pipes_struct, r);
5807                         return NT_STATUS_OK;
5808                 }
5809 
5810                 case NDR_SAMR_OPENALIAS: {
5811                         struct samr_OpenAlias *r = (struct samr_OpenAlias *)_r;
5812                         ZERO_STRUCT(r->out);
5813                         r->out.alias_handle = talloc_zero(mem_ctx, struct policy_handle);
5814                         if (r->out.alias_handle == NULL) {
5815                         return NT_STATUS_NO_MEMORY;
5816                         }
5817 
5818                         r->out.result = _samr_OpenAlias(cli->pipes_struct, r);
5819                         return NT_STATUS_OK;
5820                 }
5821 
5822                 case NDR_SAMR_QUERYALIASINFO: {
5823                         struct samr_QueryAliasInfo *r = (struct samr_QueryAliasInfo *)_r;
5824                         ZERO_STRUCT(r->out);
5825                         r->out.info = talloc_zero(mem_ctx, union samr_AliasInfo *);
5826                         if (r->out.info == NULL) {
5827                         return NT_STATUS_NO_MEMORY;
5828                         }
5829 
5830                         r->out.result = _samr_QueryAliasInfo(cli->pipes_struct, r);
5831                         return NT_STATUS_OK;
5832                 }
5833 
5834                 case NDR_SAMR_SETALIASINFO: {
5835                         struct samr_SetAliasInfo *r = (struct samr_SetAliasInfo *)_r;
5836                         r->out.result = _samr_SetAliasInfo(cli->pipes_struct, r);
5837                         return NT_STATUS_OK;
5838                 }
5839 
5840                 case NDR_SAMR_DELETEDOMALIAS: {
5841                         struct samr_DeleteDomAlias *r = (struct samr_DeleteDomAlias *)_r;
5842                         ZERO_STRUCT(r->out);
5843                         r->out.alias_handle = r->in.alias_handle;
5844                         r->out.result = _samr_DeleteDomAlias(cli->pipes_struct, r);
5845                         return NT_STATUS_OK;
5846                 }
5847 
5848                 case NDR_SAMR_ADDALIASMEMBER: {
5849                         struct samr_AddAliasMember *r = (struct samr_AddAliasMember *)_r;
5850                         r->out.result = _samr_AddAliasMember(cli->pipes_struct, r);
5851                         return NT_STATUS_OK;
5852                 }
5853 
5854                 case NDR_SAMR_DELETEALIASMEMBER: {
5855                         struct samr_DeleteAliasMember *r = (struct samr_DeleteAliasMember *)_r;
5856                         r->out.result = _samr_DeleteAliasMember(cli->pipes_struct, r);
5857                         return NT_STATUS_OK;
5858                 }
5859 
5860                 case NDR_SAMR_GETMEMBERSINALIAS: {
5861                         struct samr_GetMembersInAlias *r = (struct samr_GetMembersInAlias *)_r;
5862                         ZERO_STRUCT(r->out);
5863                         r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
5864                         if (r->out.sids == NULL) {
5865                         return NT_STATUS_NO_MEMORY;
5866                         }
5867 
5868                         r->out.result = _samr_GetMembersInAlias(cli->pipes_struct, r);
5869                         return NT_STATUS_OK;
5870                 }
5871 
5872                 case NDR_SAMR_OPENUSER: {
5873                         struct samr_OpenUser *r = (struct samr_OpenUser *)_r;
5874                         ZERO_STRUCT(r->out);
5875                         r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle);
5876                         if (r->out.user_handle == NULL) {
5877                         return NT_STATUS_NO_MEMORY;
5878                         }
5879 
5880                         r->out.result = _samr_OpenUser(cli->pipes_struct, r);
5881                         return NT_STATUS_OK;
5882                 }
5883 
5884                 case NDR_SAMR_DELETEUSER: {
5885                         struct samr_DeleteUser *r = (struct samr_DeleteUser *)_r;
5886                         ZERO_STRUCT(r->out);
5887                         r->out.user_handle = r->in.user_handle;
5888                         r->out.result = _samr_DeleteUser(cli->pipes_struct, r);
5889                         return NT_STATUS_OK;
5890                 }
5891 
5892                 case NDR_SAMR_QUERYUSERINFO: {
5893                         struct samr_QueryUserInfo *r = (struct samr_QueryUserInfo *)_r;
5894                         ZERO_STRUCT(r->out);
5895                         r->out.info = talloc_zero(mem_ctx, union samr_UserInfo *);
5896                         if (r->out.info == NULL) {
5897                         return NT_STATUS_NO_MEMORY;
5898                         }
5899 
5900                         r->out.result = _samr_QueryUserInfo(cli->pipes_struct, r);
5901                         return NT_STATUS_OK;
5902                 }
5903 
5904                 case NDR_SAMR_SETUSERINFO: {
5905                         struct samr_SetUserInfo *r = (struct samr_SetUserInfo *)_r;
5906                         r->out.result = _samr_SetUserInfo(cli->pipes_struct, r);
5907                         return NT_STATUS_OK;
5908                 }
5909 
5910                 case NDR_SAMR_CHANGEPASSWORDUSER: {
5911                         struct samr_ChangePasswordUser *r = (struct samr_ChangePasswordUser *)_r;
5912                         r->out.result = _samr_ChangePasswordUser(cli->pipes_struct, r);
5913                         return NT_STATUS_OK;
5914                 }
5915 
5916                 case NDR_SAMR_GETGROUPSFORUSER: {
5917                         struct samr_GetGroupsForUser *r = (struct samr_GetGroupsForUser *)_r;
5918                         ZERO_STRUCT(r->out);
5919                         r->out.rids = talloc_zero(mem_ctx, struct samr_RidWithAttributeArray *);
5920                         if (r->out.rids == NULL) {
5921                         return NT_STATUS_NO_MEMORY;
5922                         }
5923 
5924                         r->out.result = _samr_GetGroupsForUser(cli->pipes_struct, r);
5925                         return NT_STATUS_OK;
5926                 }
5927 
5928                 case NDR_SAMR_QUERYDISPLAYINFO: {
5929                         struct samr_QueryDisplayInfo *r = (struct samr_QueryDisplayInfo *)_r;
5930                         ZERO_STRUCT(r->out);
5931                         r->out.total_size = talloc_zero(mem_ctx, uint32_t);
5932                         if (r->out.total_size == NULL) {
5933                         return NT_STATUS_NO_MEMORY;
5934                         }
5935 
5936                         r->out.returned_size = talloc_zero(mem_ctx, uint32_t);
5937                         if (r->out.returned_size == NULL) {
5938                         return NT_STATUS_NO_MEMORY;
5939                         }
5940 
5941                         r->out.info = talloc_zero(mem_ctx, union samr_DispInfo);
5942                         if (r->out.info == NULL) {
5943                         return NT_STATUS_NO_MEMORY;
5944                         }
5945 
5946                         r->out.result = _samr_QueryDisplayInfo(cli->pipes_struct, r);
5947                         return NT_STATUS_OK;
5948                 }
5949 
5950                 case NDR_SAMR_GETDISPLAYENUMERATIONINDEX: {
5951                         struct samr_GetDisplayEnumerationIndex *r = (struct samr_GetDisplayEnumerationIndex *)_r;
5952                         ZERO_STRUCT(r->out);
5953                         r->out.idx = talloc_zero(mem_ctx, uint32_t);
5954                         if (r->out.idx == NULL) {
5955                         return NT_STATUS_NO_MEMORY;
5956                         }
5957 
5958                         r->out.result = _samr_GetDisplayEnumerationIndex(cli->pipes_struct, r);
5959                         return NT_STATUS_OK;
5960                 }
5961 
5962                 case NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN: {
5963                         struct samr_TestPrivateFunctionsDomain *r = (struct samr_TestPrivateFunctionsDomain *)_r;
5964                         r->out.result = _samr_TestPrivateFunctionsDomain(cli->pipes_struct, r);
5965                         return NT_STATUS_OK;
5966                 }
5967 
5968                 case NDR_SAMR_TESTPRIVATEFUNCTIONSUSER: {
5969                         struct samr_TestPrivateFunctionsUser *r = (struct samr_TestPrivateFunctionsUser *)_r;
5970                         r->out.result = _samr_TestPrivateFunctionsUser(cli->pipes_struct, r);
5971                         return NT_STATUS_OK;
5972                 }
5973 
5974                 case NDR_SAMR_GETUSERPWINFO: {
5975                         struct samr_GetUserPwInfo *r = (struct samr_GetUserPwInfo *)_r;
5976                         ZERO_STRUCT(r->out);
5977                         r->out.info = talloc_zero(mem_ctx, struct samr_PwInfo);
5978                         if (r->out.info == NULL) {
5979                         return NT_STATUS_NO_MEMORY;
5980                         }
5981 
5982                         r->out.result = _samr_GetUserPwInfo(cli->pipes_struct, r);
5983                         return NT_STATUS_OK;
5984                 }
5985 
5986                 case NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN: {
5987                         struct samr_RemoveMemberFromForeignDomain *r = (struct samr_RemoveMemberFromForeignDomain *)_r;
5988                         r->out.result = _samr_RemoveMemberFromForeignDomain(cli->pipes_struct, r);
5989                         return NT_STATUS_OK;
5990                 }
5991 
5992                 case NDR_SAMR_QUERYDOMAININFO2: {
5993                         struct samr_QueryDomainInfo2 *r = (struct samr_QueryDomainInfo2 *)_r;
5994                         ZERO_STRUCT(r->out);
5995                         r->out.info = talloc_zero(mem_ctx, union samr_DomainInfo *);
5996                         if (r->out.info == NULL) {
5997                         return NT_STATUS_NO_MEMORY;
5998                         }
5999 
6000                         r->out.result = _samr_QueryDomainInfo2(cli->pipes_struct, r);
6001                         return NT_STATUS_OK;
6002                 }
6003 
6004                 case NDR_SAMR_QUERYUSERINFO2: {
6005                         struct samr_QueryUserInfo2 *r = (struct samr_QueryUserInfo2 *)_r;
6006                         ZERO_STRUCT(r->out);
6007                         r->out.info = talloc_zero(mem_ctx, union samr_UserInfo *);
6008                         if (r->out.info == NULL) {
6009                         return NT_STATUS_NO_MEMORY;
6010                         }
6011 
6012                         r->out.result = _samr_QueryUserInfo2(cli->pipes_struct, r);
6013                         return NT_STATUS_OK;
6014                 }
6015 
6016                 case NDR_SAMR_QUERYDISPLAYINFO2: {
6017                         struct samr_QueryDisplayInfo2 *r = (struct samr_QueryDisplayInfo2 *)_r;
6018                         ZERO_STRUCT(r->out);
6019                         r->out.total_size = talloc_zero(mem_ctx, uint32_t);
6020                         if (r->out.total_size == NULL) {
6021                         return NT_STATUS_NO_MEMORY;
6022                         }
6023 
6024                         r->out.returned_size = talloc_zero(mem_ctx, uint32_t);
6025                         if (r->out.returned_size == NULL) {
6026                         return NT_STATUS_NO_MEMORY;
6027                         }
6028 
6029                         r->out.info = talloc_zero(mem_ctx, union samr_DispInfo);
6030                         if (r->out.info == NULL) {
6031                         return NT_STATUS_NO_MEMORY;
6032                         }
6033 
6034                         r->out.result = _samr_QueryDisplayInfo2(cli->pipes_struct, r);
6035                         return NT_STATUS_OK;
6036                 }
6037 
6038                 case NDR_SAMR_GETDISPLAYENUMERATIONINDEX2: {
6039                         struct samr_GetDisplayEnumerationIndex2 *r = (struct samr_GetDisplayEnumerationIndex2 *)_r;
6040                         ZERO_STRUCT(r->out);
6041                         r->out.idx = talloc_zero(mem_ctx, uint32_t);
6042                         if (r->out.idx == NULL) {
6043                         return NT_STATUS_NO_MEMORY;
6044                         }
6045 
6046                         r->out.result = _samr_GetDisplayEnumerationIndex2(cli->pipes_struct, r);
6047                         return NT_STATUS_OK;
6048                 }
6049 
6050                 case NDR_SAMR_CREATEUSER2: {
6051                         struct samr_CreateUser2 *r = (struct samr_CreateUser2 *)_r;
6052                         ZERO_STRUCT(r->out);
6053                         r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle);
6054                         if (r->out.user_handle == NULL) {
6055                         return NT_STATUS_NO_MEMORY;
6056                         }
6057 
6058                         r->out.access_granted = talloc_zero(mem_ctx, uint32_t);
6059                         if (r->out.access_granted == NULL) {
6060                         return NT_STATUS_NO_MEMORY;
6061                         }
6062 
6063                         r->out.rid = talloc_zero(mem_ctx, uint32_t);
6064                         if (r->out.rid == NULL) {
6065                         return NT_STATUS_NO_MEMORY;
6066                         }
6067 
6068                         r->out.result = _samr_CreateUser2(cli->pipes_struct, r);
6069                         return NT_STATUS_OK;
6070                 }
6071 
6072                 case NDR_SAMR_QUERYDISPLAYINFO3: {
6073                         struct samr_QueryDisplayInfo3 *r = (struct samr_QueryDisplayInfo3 *)_r;
6074                         ZERO_STRUCT(r->out);
6075                         r->out.total_size = talloc_zero(mem_ctx, uint32_t);
6076                         if (r->out.total_size == NULL) {
6077                         return NT_STATUS_NO_MEMORY;
6078                         }
6079 
6080                         r->out.returned_size = talloc_zero(mem_ctx, uint32_t);
6081                         if (r->out.returned_size == NULL) {
6082                         return NT_STATUS_NO_MEMORY;
6083                         }
6084 
6085                         r->out.info = talloc_zero(mem_ctx, union samr_DispInfo);
6086                         if (r->out.info == NULL) {
6087                         return NT_STATUS_NO_MEMORY;
6088                         }
6089 
6090                         r->out.result = _samr_QueryDisplayInfo3(cli->pipes_struct, r);
6091                         return NT_STATUS_OK;
6092                 }
6093 
6094                 case NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS: {
6095                         struct samr_AddMultipleMembersToAlias *r = (struct samr_AddMultipleMembersToAlias *)_r;
6096                         r->out.result = _samr_AddMultipleMembersToAlias(cli->pipes_struct, r);
6097                         return NT_STATUS_OK;
6098                 }
6099 
6100                 case NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS: {
6101                         struct samr_RemoveMultipleMembersFromAlias *r = (struct samr_RemoveMultipleMembersFromAlias *)_r;
6102                         r->out.result = _samr_RemoveMultipleMembersFromAlias(cli->pipes_struct, r);
6103                         return NT_STATUS_OK;
6104                 }
6105 
6106                 case NDR_SAMR_OEMCHANGEPASSWORDUSER2: {
6107                         struct samr_OemChangePasswordUser2 *r = (struct samr_OemChangePasswordUser2 *)_r;
6108                         r->out.result = _samr_OemChangePasswordUser2(cli->pipes_struct, r);
6109                         return NT_STATUS_OK;
6110                 }
6111 
6112                 case NDR_SAMR_CHANGEPASSWORDUSER2: {
6113                         struct samr_ChangePasswordUser2 *r = (struct samr_ChangePasswordUser2 *)_r;
6114                         r->out.result = _samr_ChangePasswordUser2(cli->pipes_struct, r);
6115                         return NT_STATUS_OK;
6116                 }
6117 
6118                 case NDR_SAMR_GETDOMPWINFO: {
6119                         struct samr_GetDomPwInfo *r = (struct samr_GetDomPwInfo *)_r;
6120                         ZERO_STRUCT(r->out);
6121                         r->out.info = talloc_zero(mem_ctx, struct samr_PwInfo);
6122                         if (r->out.info == NULL) {
6123                         return NT_STATUS_NO_MEMORY;
6124                         }
6125 
6126                         r->out.result = _samr_GetDomPwInfo(cli->pipes_struct, r);
6127                         return NT_STATUS_OK;
6128                 }
6129 
6130                 case NDR_SAMR_CONNECT2: {
6131                         struct samr_Connect2 *r = (struct samr_Connect2 *)_r;
6132                         ZERO_STRUCT(r->out);
6133                         r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6134                         if (r->out.connect_handle == NULL) {
6135                         return NT_STATUS_NO_MEMORY;
6136                         }
6137 
6138                         r->out.result = _samr_Connect2(cli->pipes_struct, r);
6139                         return NT_STATUS_OK;
6140                 }
6141 
6142                 case NDR_SAMR_SETUSERINFO2: {
6143                         struct samr_SetUserInfo2 *r = (struct samr_SetUserInfo2 *)_r;
6144                         r->out.result = _samr_SetUserInfo2(cli->pipes_struct, r);
6145                         return NT_STATUS_OK;
6146                 }
6147 
6148                 case NDR_SAMR_SETBOOTKEYINFORMATION: {
6149                         struct samr_SetBootKeyInformation *r = (struct samr_SetBootKeyInformation *)_r;
6150                         r->out.result = _samr_SetBootKeyInformation(cli->pipes_struct, r);
6151                         return NT_STATUS_OK;
6152                 }
6153 
6154                 case NDR_SAMR_GETBOOTKEYINFORMATION: {
6155                         struct samr_GetBootKeyInformation *r = (struct samr_GetBootKeyInformation *)_r;
6156                         ZERO_STRUCT(r->out);
6157                         r->out.unknown = talloc_zero(mem_ctx, uint32_t);
6158                         if (r->out.unknown == NULL) {
6159                         return NT_STATUS_NO_MEMORY;
6160                         }
6161 
6162                         r->out.result = _samr_GetBootKeyInformation(cli->pipes_struct, r);
6163                         return NT_STATUS_OK;
6164                 }
6165 
6166                 case NDR_SAMR_CONNECT3: {
6167                         struct samr_Connect3 *r = (struct samr_Connect3 *)_r;
6168                         ZERO_STRUCT(r->out);
6169                         r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6170                         if (r->out.connect_handle == NULL) {
6171                         return NT_STATUS_NO_MEMORY;
6172                         }
6173 
6174                         r->out.result = _samr_Connect3(cli->pipes_struct, r);
6175                         return NT_STATUS_OK;
6176                 }
6177 
6178                 case NDR_SAMR_CONNECT4: {
6179                         struct samr_Connect4 *r = (struct samr_Connect4 *)_r;
6180                         ZERO_STRUCT(r->out);
6181                         r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6182                         if (r->out.connect_handle == NULL) {
6183                         return NT_STATUS_NO_MEMORY;
6184                         }
6185 
6186                         r->out.result = _samr_Connect4(cli->pipes_struct, r);
6187                         return NT_STATUS_OK;
6188                 }
6189 
6190                 case NDR_SAMR_CHANGEPASSWORDUSER3: {
6191                         struct samr_ChangePasswordUser3 *r = (struct samr_ChangePasswordUser3 *)_r;
6192                         ZERO_STRUCT(r->out);
6193                         r->out.dominfo = talloc_zero(mem_ctx, struct samr_DomInfo1 *);
6194                         if (r->out.dominfo == NULL) {
6195                         return NT_STATUS_NO_MEMORY;
6196                         }
6197 
6198                         r->out.reject = talloc_zero(mem_ctx, struct samr_ChangeReject *);
6199                         if (r->out.reject == NULL) {
6200                         return NT_STATUS_NO_MEMORY;
6201                         }
6202 
6203                         r->out.result = _samr_ChangePasswordUser3(cli->pipes_struct, r);
6204                         return NT_STATUS_OK;
6205                 }
6206 
6207                 case NDR_SAMR_CONNECT5: {
6208                         struct samr_Connect5 *r = (struct samr_Connect5 *)_r;
6209                         ZERO_STRUCT(r->out);
6210                         r->out.level_out = talloc_zero(mem_ctx, uint32_t);
6211                         if (r->out.level_out == NULL) {
6212                         return NT_STATUS_NO_MEMORY;
6213                         }
6214 
6215                         r->out.info_out = talloc_zero(mem_ctx, union samr_ConnectInfo);
6216                         if (r->out.info_out == NULL) {
6217                         return NT_STATUS_NO_MEMORY;
6218                         }
6219 
6220                         r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6221                         if (r->out.connect_handle == NULL) {
6222                         return NT_STATUS_NO_MEMORY;
6223                         }
6224 
6225                         r->out.result = _samr_Connect5(cli->pipes_struct, r);
6226                         return NT_STATUS_OK;
6227                 }
6228 
6229                 case NDR_SAMR_RIDTOSID: {
6230                         struct samr_RidToSid *r = (struct samr_RidToSid *)_r;
6231                         ZERO_STRUCT(r->out);
6232                         r->out.sid = talloc_zero(mem_ctx, struct dom_sid2 *);
6233                         if (r->out.sid == NULL) {
6234                         return NT_STATUS_NO_MEMORY;
6235                         }
6236 
6237                         r->out.result = _samr_RidToSid(cli->pipes_struct, r);
6238                         return NT_STATUS_OK;
6239                 }
6240 
6241                 case NDR_SAMR_SETDSRMPASSWORD: {
6242                         struct samr_SetDsrmPassword *r = (struct samr_SetDsrmPassword *)_r;
6243                         r->out.result = _samr_SetDsrmPassword(cli->pipes_struct, r);
6244                         return NT_STATUS_OK;
6245                 }
6246 
6247                 case NDR_SAMR_VALIDATEPASSWORD: {
6248                         struct samr_ValidatePassword *r = (struct samr_ValidatePassword *)_r;
6249                         ZERO_STRUCT(r->out);
6250                         r->out.rep = talloc_zero(mem_ctx, union samr_ValidatePasswordRep *);
6251                         if (r->out.rep == NULL) {
6252                         return NT_STATUS_NO_MEMORY;
6253                         }
6254 
6255                         r->out.result = _samr_ValidatePassword(cli->pipes_struct, r);
6256                         return NT_STATUS_OK;
6257                 }
6258 
6259                 default:
6260                         return NT_STATUS_NOT_IMPLEMENTED;
6261         }
6262 }
6263 
6264 NTSTATUS rpc_samr_init(void)
     /* [<][>][^][v][top][bottom][index][help] */
6265 {
6266         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "samr", "samr", &ndr_table_samr, api_samr_cmds, sizeof(api_samr_cmds) / sizeof(struct api_struct));
6267 }

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