root/librpc/gen_ndr/srv_svcctl.c

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

DEFINITIONS

This source file includes following definitions.
  1. api_svcctl_CloseServiceHandle
  2. api_svcctl_ControlService
  3. api_svcctl_DeleteService
  4. api_svcctl_LockServiceDatabase
  5. api_svcctl_QueryServiceObjectSecurity
  6. api_svcctl_SetServiceObjectSecurity
  7. api_svcctl_QueryServiceStatus
  8. api_svcctl_SetServiceStatus
  9. api_svcctl_UnlockServiceDatabase
  10. api_svcctl_NotifyBootConfigStatus
  11. api_svcctl_SCSetServiceBitsW
  12. api_svcctl_ChangeServiceConfigW
  13. api_svcctl_CreateServiceW
  14. api_svcctl_EnumDependentServicesW
  15. api_svcctl_EnumServicesStatusW
  16. api_svcctl_OpenSCManagerW
  17. api_svcctl_OpenServiceW
  18. api_svcctl_QueryServiceConfigW
  19. api_svcctl_QueryServiceLockStatusW
  20. api_svcctl_StartServiceW
  21. api_svcctl_GetServiceDisplayNameW
  22. api_svcctl_GetServiceKeyNameW
  23. api_svcctl_SCSetServiceBitsA
  24. api_svcctl_ChangeServiceConfigA
  25. api_svcctl_CreateServiceA
  26. api_svcctl_EnumDependentServicesA
  27. api_svcctl_EnumServicesStatusA
  28. api_svcctl_OpenSCManagerA
  29. api_svcctl_OpenServiceA
  30. api_svcctl_QueryServiceConfigA
  31. api_svcctl_QueryServiceLockStatusA
  32. api_svcctl_StartServiceA
  33. api_svcctl_GetServiceDisplayNameA
  34. api_svcctl_GetServiceKeyNameA
  35. api_svcctl_GetCurrentGroupeStateW
  36. api_svcctl_EnumServiceGroupW
  37. api_svcctl_ChangeServiceConfig2A
  38. api_svcctl_ChangeServiceConfig2W
  39. api_svcctl_QueryServiceConfig2A
  40. api_svcctl_QueryServiceConfig2W
  41. api_svcctl_QueryServiceStatusEx
  42. api_EnumServicesStatusExA
  43. api_EnumServicesStatusExW
  44. api_svcctl_SCSendTSMessage
  45. svcctl_get_pipe_fns
  46. rpc_svcctl_dispatch
  47. rpc_svcctl_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_svcctl.h"
   8 
   9 static bool api_svcctl_CloseServiceHandle(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 svcctl_CloseServiceHandle *r;
  17 
  18         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CLOSESERVICEHANDLE];
  19 
  20         r = talloc(talloc_tos(), struct svcctl_CloseServiceHandle);
  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(svcctl_CloseServiceHandle, r);
  45         }
  46 
  47         ZERO_STRUCT(r->out);
  48         r->out.handle = r->in.handle;
  49         r->out.result = _svcctl_CloseServiceHandle(p, r);
  50 
  51         if (p->rng_fault_state) {
  52                 talloc_free(r);
  53                 /* Return true here, srv_pipe_hnd.c will take care */
  54                 return true;
  55         }
  56 
  57         if (DEBUGLEVEL >= 10) {
  58                 NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, r);
  59         }
  60 
  61         push = ndr_push_init_ctx(r, NULL);
  62         if (push == NULL) {
  63                 talloc_free(r);
  64                 return false;
  65         }
  66 
  67         ndr_err = call->ndr_push(push, NDR_OUT, r);
  68         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  69                 talloc_free(r);
  70                 return false;
  71         }
  72 
  73         blob = ndr_push_blob(push);
  74         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  75                 talloc_free(r);
  76                 return false;
  77         }
  78 
  79         talloc_free(r);
  80 
  81         return true;
  82 }
  83 
  84 static bool api_svcctl_ControlService(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  85 {
  86         const struct ndr_interface_call *call;
  87         struct ndr_pull *pull;
  88         struct ndr_push *push;
  89         enum ndr_err_code ndr_err;
  90         DATA_BLOB blob;
  91         struct svcctl_ControlService *r;
  92 
  93         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CONTROLSERVICE];
  94 
  95         r = talloc(talloc_tos(), struct svcctl_ControlService);
  96         if (r == NULL) {
  97                 return false;
  98         }
  99 
 100         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 101                 talloc_free(r);
 102                 return false;
 103         }
 104 
 105         pull = ndr_pull_init_blob(&blob, r, NULL);
 106         if (pull == NULL) {
 107                 talloc_free(r);
 108                 return false;
 109         }
 110 
 111         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 112         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 113         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 114                 talloc_free(r);
 115                 return false;
 116         }
 117 
 118         if (DEBUGLEVEL >= 10) {
 119                 NDR_PRINT_IN_DEBUG(svcctl_ControlService, r);
 120         }
 121 
 122         ZERO_STRUCT(r->out);
 123         r->out.service_status = talloc_zero(r, struct SERVICE_STATUS);
 124         if (r->out.service_status == NULL) {
 125                 talloc_free(r);
 126                 return false;
 127         }
 128 
 129         r->out.result = _svcctl_ControlService(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(svcctl_ControlService, 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_svcctl_DeleteService(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 svcctl_DeleteService *r;
 172 
 173         call = &ndr_table_svcctl.calls[NDR_SVCCTL_DELETESERVICE];
 174 
 175         r = talloc(talloc_tos(), struct svcctl_DeleteService);
 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(svcctl_DeleteService, r);
 200         }
 201 
 202         r->out.result = _svcctl_DeleteService(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(svcctl_DeleteService, 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_svcctl_LockServiceDatabase(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 svcctl_LockServiceDatabase *r;
 245 
 246         call = &ndr_table_svcctl.calls[NDR_SVCCTL_LOCKSERVICEDATABASE];
 247 
 248         r = talloc(talloc_tos(), struct svcctl_LockServiceDatabase);
 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(svcctl_LockServiceDatabase, r);
 273         }
 274 
 275         ZERO_STRUCT(r->out);
 276         r->out.lock = talloc_zero(r, struct policy_handle);
 277         if (r->out.lock == NULL) {
 278                 talloc_free(r);
 279                 return false;
 280         }
 281 
 282         r->out.result = _svcctl_LockServiceDatabase(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(svcctl_LockServiceDatabase, 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_svcctl_QueryServiceObjectSecurity(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 svcctl_QueryServiceObjectSecurity *r;
 325 
 326         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY];
 327 
 328         r = talloc(talloc_tos(), struct svcctl_QueryServiceObjectSecurity);
 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(svcctl_QueryServiceObjectSecurity, r);
 353         }
 354 
 355         ZERO_STRUCT(r->out);
 356         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
 357         if (r->out.buffer == NULL) {
 358                 talloc_free(r);
 359                 return false;
 360         }
 361 
 362         r->out.needed = talloc_zero(r, uint32_t);
 363         if (r->out.needed == NULL) {
 364                 talloc_free(r);
 365                 return false;
 366         }
 367 
 368         r->out.result = _svcctl_QueryServiceObjectSecurity(p, r);
 369 
 370         if (p->rng_fault_state) {
 371                 talloc_free(r);
 372                 /* Return true here, srv_pipe_hnd.c will take care */
 373                 return true;
 374         }
 375 
 376         if (DEBUGLEVEL >= 10) {
 377                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, r);
 378         }
 379 
 380         push = ndr_push_init_ctx(r, NULL);
 381         if (push == NULL) {
 382                 talloc_free(r);
 383                 return false;
 384         }
 385 
 386         ndr_err = call->ndr_push(push, NDR_OUT, r);
 387         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 388                 talloc_free(r);
 389                 return false;
 390         }
 391 
 392         blob = ndr_push_blob(push);
 393         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 394                 talloc_free(r);
 395                 return false;
 396         }
 397 
 398         talloc_free(r);
 399 
 400         return true;
 401 }
 402 
 403 static bool api_svcctl_SetServiceObjectSecurity(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 404 {
 405         const struct ndr_interface_call *call;
 406         struct ndr_pull *pull;
 407         struct ndr_push *push;
 408         enum ndr_err_code ndr_err;
 409         DATA_BLOB blob;
 410         struct svcctl_SetServiceObjectSecurity *r;
 411 
 412         call = &ndr_table_svcctl.calls[NDR_SVCCTL_SETSERVICEOBJECTSECURITY];
 413 
 414         r = talloc(talloc_tos(), struct svcctl_SetServiceObjectSecurity);
 415         if (r == NULL) {
 416                 return false;
 417         }
 418 
 419         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 420                 talloc_free(r);
 421                 return false;
 422         }
 423 
 424         pull = ndr_pull_init_blob(&blob, r, NULL);
 425         if (pull == NULL) {
 426                 talloc_free(r);
 427                 return false;
 428         }
 429 
 430         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 431         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 432         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 433                 talloc_free(r);
 434                 return false;
 435         }
 436 
 437         if (DEBUGLEVEL >= 10) {
 438                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, r);
 439         }
 440 
 441         r->out.result = _svcctl_SetServiceObjectSecurity(p, r);
 442 
 443         if (p->rng_fault_state) {
 444                 talloc_free(r);
 445                 /* Return true here, srv_pipe_hnd.c will take care */
 446                 return true;
 447         }
 448 
 449         if (DEBUGLEVEL >= 10) {
 450                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, r);
 451         }
 452 
 453         push = ndr_push_init_ctx(r, NULL);
 454         if (push == NULL) {
 455                 talloc_free(r);
 456                 return false;
 457         }
 458 
 459         ndr_err = call->ndr_push(push, NDR_OUT, r);
 460         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 461                 talloc_free(r);
 462                 return false;
 463         }
 464 
 465         blob = ndr_push_blob(push);
 466         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 467                 talloc_free(r);
 468                 return false;
 469         }
 470 
 471         talloc_free(r);
 472 
 473         return true;
 474 }
 475 
 476 static bool api_svcctl_QueryServiceStatus(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 477 {
 478         const struct ndr_interface_call *call;
 479         struct ndr_pull *pull;
 480         struct ndr_push *push;
 481         enum ndr_err_code ndr_err;
 482         DATA_BLOB blob;
 483         struct svcctl_QueryServiceStatus *r;
 484 
 485         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICESTATUS];
 486 
 487         r = talloc(talloc_tos(), struct svcctl_QueryServiceStatus);
 488         if (r == NULL) {
 489                 return false;
 490         }
 491 
 492         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 493                 talloc_free(r);
 494                 return false;
 495         }
 496 
 497         pull = ndr_pull_init_blob(&blob, r, NULL);
 498         if (pull == NULL) {
 499                 talloc_free(r);
 500                 return false;
 501         }
 502 
 503         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 504         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 505         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 506                 talloc_free(r);
 507                 return false;
 508         }
 509 
 510         if (DEBUGLEVEL >= 10) {
 511                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatus, r);
 512         }
 513 
 514         ZERO_STRUCT(r->out);
 515         r->out.service_status = talloc_zero(r, struct SERVICE_STATUS);
 516         if (r->out.service_status == NULL) {
 517                 talloc_free(r);
 518                 return false;
 519         }
 520 
 521         r->out.result = _svcctl_QueryServiceStatus(p, r);
 522 
 523         if (p->rng_fault_state) {
 524                 talloc_free(r);
 525                 /* Return true here, srv_pipe_hnd.c will take care */
 526                 return true;
 527         }
 528 
 529         if (DEBUGLEVEL >= 10) {
 530                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, r);
 531         }
 532 
 533         push = ndr_push_init_ctx(r, NULL);
 534         if (push == NULL) {
 535                 talloc_free(r);
 536                 return false;
 537         }
 538 
 539         ndr_err = call->ndr_push(push, NDR_OUT, r);
 540         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 541                 talloc_free(r);
 542                 return false;
 543         }
 544 
 545         blob = ndr_push_blob(push);
 546         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 547                 talloc_free(r);
 548                 return false;
 549         }
 550 
 551         talloc_free(r);
 552 
 553         return true;
 554 }
 555 
 556 static bool api_svcctl_SetServiceStatus(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 557 {
 558         const struct ndr_interface_call *call;
 559         struct ndr_pull *pull;
 560         struct ndr_push *push;
 561         enum ndr_err_code ndr_err;
 562         DATA_BLOB blob;
 563         struct svcctl_SetServiceStatus *r;
 564 
 565         call = &ndr_table_svcctl.calls[NDR_SVCCTL_SETSERVICESTATUS];
 566 
 567         r = talloc(talloc_tos(), struct svcctl_SetServiceStatus);
 568         if (r == NULL) {
 569                 return false;
 570         }
 571 
 572         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 573                 talloc_free(r);
 574                 return false;
 575         }
 576 
 577         pull = ndr_pull_init_blob(&blob, r, NULL);
 578         if (pull == NULL) {
 579                 talloc_free(r);
 580                 return false;
 581         }
 582 
 583         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 584         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 585         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 586                 talloc_free(r);
 587                 return false;
 588         }
 589 
 590         if (DEBUGLEVEL >= 10) {
 591                 NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, r);
 592         }
 593 
 594         r->out.result = _svcctl_SetServiceStatus(p, r);
 595 
 596         if (p->rng_fault_state) {
 597                 talloc_free(r);
 598                 /* Return true here, srv_pipe_hnd.c will take care */
 599                 return true;
 600         }
 601 
 602         if (DEBUGLEVEL >= 10) {
 603                 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, r);
 604         }
 605 
 606         push = ndr_push_init_ctx(r, NULL);
 607         if (push == NULL) {
 608                 talloc_free(r);
 609                 return false;
 610         }
 611 
 612         ndr_err = call->ndr_push(push, NDR_OUT, r);
 613         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 614                 talloc_free(r);
 615                 return false;
 616         }
 617 
 618         blob = ndr_push_blob(push);
 619         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 620                 talloc_free(r);
 621                 return false;
 622         }
 623 
 624         talloc_free(r);
 625 
 626         return true;
 627 }
 628 
 629 static bool api_svcctl_UnlockServiceDatabase(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 630 {
 631         const struct ndr_interface_call *call;
 632         struct ndr_pull *pull;
 633         struct ndr_push *push;
 634         enum ndr_err_code ndr_err;
 635         DATA_BLOB blob;
 636         struct svcctl_UnlockServiceDatabase *r;
 637 
 638         call = &ndr_table_svcctl.calls[NDR_SVCCTL_UNLOCKSERVICEDATABASE];
 639 
 640         r = talloc(talloc_tos(), struct svcctl_UnlockServiceDatabase);
 641         if (r == NULL) {
 642                 return false;
 643         }
 644 
 645         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 646                 talloc_free(r);
 647                 return false;
 648         }
 649 
 650         pull = ndr_pull_init_blob(&blob, r, NULL);
 651         if (pull == NULL) {
 652                 talloc_free(r);
 653                 return false;
 654         }
 655 
 656         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 657         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 658         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 659                 talloc_free(r);
 660                 return false;
 661         }
 662 
 663         if (DEBUGLEVEL >= 10) {
 664                 NDR_PRINT_IN_DEBUG(svcctl_UnlockServiceDatabase, r);
 665         }
 666 
 667         ZERO_STRUCT(r->out);
 668         r->out.lock = r->in.lock;
 669         r->out.result = _svcctl_UnlockServiceDatabase(p, r);
 670 
 671         if (p->rng_fault_state) {
 672                 talloc_free(r);
 673                 /* Return true here, srv_pipe_hnd.c will take care */
 674                 return true;
 675         }
 676 
 677         if (DEBUGLEVEL >= 10) {
 678                 NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, r);
 679         }
 680 
 681         push = ndr_push_init_ctx(r, NULL);
 682         if (push == NULL) {
 683                 talloc_free(r);
 684                 return false;
 685         }
 686 
 687         ndr_err = call->ndr_push(push, NDR_OUT, r);
 688         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 689                 talloc_free(r);
 690                 return false;
 691         }
 692 
 693         blob = ndr_push_blob(push);
 694         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 695                 talloc_free(r);
 696                 return false;
 697         }
 698 
 699         talloc_free(r);
 700 
 701         return true;
 702 }
 703 
 704 static bool api_svcctl_NotifyBootConfigStatus(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 705 {
 706         const struct ndr_interface_call *call;
 707         struct ndr_pull *pull;
 708         struct ndr_push *push;
 709         enum ndr_err_code ndr_err;
 710         DATA_BLOB blob;
 711         struct svcctl_NotifyBootConfigStatus *r;
 712 
 713         call = &ndr_table_svcctl.calls[NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS];
 714 
 715         r = talloc(talloc_tos(), struct svcctl_NotifyBootConfigStatus);
 716         if (r == NULL) {
 717                 return false;
 718         }
 719 
 720         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 721                 talloc_free(r);
 722                 return false;
 723         }
 724 
 725         pull = ndr_pull_init_blob(&blob, r, NULL);
 726         if (pull == NULL) {
 727                 talloc_free(r);
 728                 return false;
 729         }
 730 
 731         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 732         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 733         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 734                 talloc_free(r);
 735                 return false;
 736         }
 737 
 738         if (DEBUGLEVEL >= 10) {
 739                 NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, r);
 740         }
 741 
 742         r->out.result = _svcctl_NotifyBootConfigStatus(p, r);
 743 
 744         if (p->rng_fault_state) {
 745                 talloc_free(r);
 746                 /* Return true here, srv_pipe_hnd.c will take care */
 747                 return true;
 748         }
 749 
 750         if (DEBUGLEVEL >= 10) {
 751                 NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, r);
 752         }
 753 
 754         push = ndr_push_init_ctx(r, NULL);
 755         if (push == NULL) {
 756                 talloc_free(r);
 757                 return false;
 758         }
 759 
 760         ndr_err = call->ndr_push(push, NDR_OUT, r);
 761         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 762                 talloc_free(r);
 763                 return false;
 764         }
 765 
 766         blob = ndr_push_blob(push);
 767         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 768                 talloc_free(r);
 769                 return false;
 770         }
 771 
 772         talloc_free(r);
 773 
 774         return true;
 775 }
 776 
 777 static bool api_svcctl_SCSetServiceBitsW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 778 {
 779         const struct ndr_interface_call *call;
 780         struct ndr_pull *pull;
 781         struct ndr_push *push;
 782         enum ndr_err_code ndr_err;
 783         DATA_BLOB blob;
 784         struct svcctl_SCSetServiceBitsW *r;
 785 
 786         call = &ndr_table_svcctl.calls[NDR_SVCCTL_SCSETSERVICEBITSW];
 787 
 788         r = talloc(talloc_tos(), struct svcctl_SCSetServiceBitsW);
 789         if (r == NULL) {
 790                 return false;
 791         }
 792 
 793         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 794                 talloc_free(r);
 795                 return false;
 796         }
 797 
 798         pull = ndr_pull_init_blob(&blob, r, NULL);
 799         if (pull == NULL) {
 800                 talloc_free(r);
 801                 return false;
 802         }
 803 
 804         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 805         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 806         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 807                 talloc_free(r);
 808                 return false;
 809         }
 810 
 811         if (DEBUGLEVEL >= 10) {
 812                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, r);
 813         }
 814 
 815         r->out.result = _svcctl_SCSetServiceBitsW(p, r);
 816 
 817         if (p->rng_fault_state) {
 818                 talloc_free(r);
 819                 /* Return true here, srv_pipe_hnd.c will take care */
 820                 return true;
 821         }
 822 
 823         if (DEBUGLEVEL >= 10) {
 824                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, r);
 825         }
 826 
 827         push = ndr_push_init_ctx(r, NULL);
 828         if (push == NULL) {
 829                 talloc_free(r);
 830                 return false;
 831         }
 832 
 833         ndr_err = call->ndr_push(push, NDR_OUT, r);
 834         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 835                 talloc_free(r);
 836                 return false;
 837         }
 838 
 839         blob = ndr_push_blob(push);
 840         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 841                 talloc_free(r);
 842                 return false;
 843         }
 844 
 845         talloc_free(r);
 846 
 847         return true;
 848 }
 849 
 850 static bool api_svcctl_ChangeServiceConfigW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 851 {
 852         const struct ndr_interface_call *call;
 853         struct ndr_pull *pull;
 854         struct ndr_push *push;
 855         enum ndr_err_code ndr_err;
 856         DATA_BLOB blob;
 857         struct svcctl_ChangeServiceConfigW *r;
 858 
 859         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CHANGESERVICECONFIGW];
 860 
 861         r = talloc(talloc_tos(), struct svcctl_ChangeServiceConfigW);
 862         if (r == NULL) {
 863                 return false;
 864         }
 865 
 866         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 867                 talloc_free(r);
 868                 return false;
 869         }
 870 
 871         pull = ndr_pull_init_blob(&blob, r, NULL);
 872         if (pull == NULL) {
 873                 talloc_free(r);
 874                 return false;
 875         }
 876 
 877         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 878         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 879         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 880                 talloc_free(r);
 881                 return false;
 882         }
 883 
 884         if (DEBUGLEVEL >= 10) {
 885                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigW, r);
 886         }
 887 
 888         ZERO_STRUCT(r->out);
 889         r->out.tag_id = talloc_zero(r, uint32_t);
 890         if (r->out.tag_id == NULL) {
 891                 talloc_free(r);
 892                 return false;
 893         }
 894 
 895         r->out.result = _svcctl_ChangeServiceConfigW(p, r);
 896 
 897         if (p->rng_fault_state) {
 898                 talloc_free(r);
 899                 /* Return true here, srv_pipe_hnd.c will take care */
 900                 return true;
 901         }
 902 
 903         if (DEBUGLEVEL >= 10) {
 904                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, r);
 905         }
 906 
 907         push = ndr_push_init_ctx(r, NULL);
 908         if (push == NULL) {
 909                 talloc_free(r);
 910                 return false;
 911         }
 912 
 913         ndr_err = call->ndr_push(push, NDR_OUT, r);
 914         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 915                 talloc_free(r);
 916                 return false;
 917         }
 918 
 919         blob = ndr_push_blob(push);
 920         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 921                 talloc_free(r);
 922                 return false;
 923         }
 924 
 925         talloc_free(r);
 926 
 927         return true;
 928 }
 929 
 930 static bool api_svcctl_CreateServiceW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 931 {
 932         const struct ndr_interface_call *call;
 933         struct ndr_pull *pull;
 934         struct ndr_push *push;
 935         enum ndr_err_code ndr_err;
 936         DATA_BLOB blob;
 937         struct svcctl_CreateServiceW *r;
 938 
 939         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CREATESERVICEW];
 940 
 941         r = talloc(talloc_tos(), struct svcctl_CreateServiceW);
 942         if (r == NULL) {
 943                 return false;
 944         }
 945 
 946         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 947                 talloc_free(r);
 948                 return false;
 949         }
 950 
 951         pull = ndr_pull_init_blob(&blob, r, NULL);
 952         if (pull == NULL) {
 953                 talloc_free(r);
 954                 return false;
 955         }
 956 
 957         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 958         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 959         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 960                 talloc_free(r);
 961                 return false;
 962         }
 963 
 964         if (DEBUGLEVEL >= 10) {
 965                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceW, r);
 966         }
 967 
 968         ZERO_STRUCT(r->out);
 969         r->out.TagId = r->in.TagId;
 970         r->out.handle = talloc_zero(r, struct policy_handle);
 971         if (r->out.handle == NULL) {
 972                 talloc_free(r);
 973                 return false;
 974         }
 975 
 976         r->out.result = _svcctl_CreateServiceW(p, r);
 977 
 978         if (p->rng_fault_state) {
 979                 talloc_free(r);
 980                 /* Return true here, srv_pipe_hnd.c will take care */
 981                 return true;
 982         }
 983 
 984         if (DEBUGLEVEL >= 10) {
 985                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, r);
 986         }
 987 
 988         push = ndr_push_init_ctx(r, NULL);
 989         if (push == NULL) {
 990                 talloc_free(r);
 991                 return false;
 992         }
 993 
 994         ndr_err = call->ndr_push(push, NDR_OUT, r);
 995         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 996                 talloc_free(r);
 997                 return false;
 998         }
 999 
1000         blob = ndr_push_blob(push);
1001         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1002                 talloc_free(r);
1003                 return false;
1004         }
1005 
1006         talloc_free(r);
1007 
1008         return true;
1009 }
1010 
1011 static bool api_svcctl_EnumDependentServicesW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1012 {
1013         const struct ndr_interface_call *call;
1014         struct ndr_pull *pull;
1015         struct ndr_push *push;
1016         enum ndr_err_code ndr_err;
1017         DATA_BLOB blob;
1018         struct svcctl_EnumDependentServicesW *r;
1019 
1020         call = &ndr_table_svcctl.calls[NDR_SVCCTL_ENUMDEPENDENTSERVICESW];
1021 
1022         r = talloc(talloc_tos(), struct svcctl_EnumDependentServicesW);
1023         if (r == NULL) {
1024                 return false;
1025         }
1026 
1027         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1028                 talloc_free(r);
1029                 return false;
1030         }
1031 
1032         pull = ndr_pull_init_blob(&blob, r, NULL);
1033         if (pull == NULL) {
1034                 talloc_free(r);
1035                 return false;
1036         }
1037 
1038         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1039         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1040         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1041                 talloc_free(r);
1042                 return false;
1043         }
1044 
1045         if (DEBUGLEVEL >= 10) {
1046                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesW, r);
1047         }
1048 
1049         ZERO_STRUCT(r->out);
1050         r->out.service_status = talloc_zero_array(r, uint8_t, r->in.offered);
1051         if (r->out.service_status == NULL) {
1052                 talloc_free(r);
1053                 return false;
1054         }
1055 
1056         r->out.needed = talloc_zero(r, uint32_t);
1057         if (r->out.needed == NULL) {
1058                 talloc_free(r);
1059                 return false;
1060         }
1061 
1062         r->out.services_returned = talloc_zero(r, uint32_t);
1063         if (r->out.services_returned == NULL) {
1064                 talloc_free(r);
1065                 return false;
1066         }
1067 
1068         r->out.result = _svcctl_EnumDependentServicesW(p, r);
1069 
1070         if (p->rng_fault_state) {
1071                 talloc_free(r);
1072                 /* Return true here, srv_pipe_hnd.c will take care */
1073                 return true;
1074         }
1075 
1076         if (DEBUGLEVEL >= 10) {
1077                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, r);
1078         }
1079 
1080         push = ndr_push_init_ctx(r, NULL);
1081         if (push == NULL) {
1082                 talloc_free(r);
1083                 return false;
1084         }
1085 
1086         ndr_err = call->ndr_push(push, NDR_OUT, r);
1087         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1088                 talloc_free(r);
1089                 return false;
1090         }
1091 
1092         blob = ndr_push_blob(push);
1093         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1094                 talloc_free(r);
1095                 return false;
1096         }
1097 
1098         talloc_free(r);
1099 
1100         return true;
1101 }
1102 
1103 static bool api_svcctl_EnumServicesStatusW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1104 {
1105         const struct ndr_interface_call *call;
1106         struct ndr_pull *pull;
1107         struct ndr_push *push;
1108         enum ndr_err_code ndr_err;
1109         DATA_BLOB blob;
1110         struct svcctl_EnumServicesStatusW *r;
1111 
1112         call = &ndr_table_svcctl.calls[NDR_SVCCTL_ENUMSERVICESSTATUSW];
1113 
1114         r = talloc(talloc_tos(), struct svcctl_EnumServicesStatusW);
1115         if (r == NULL) {
1116                 return false;
1117         }
1118 
1119         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1120                 talloc_free(r);
1121                 return false;
1122         }
1123 
1124         pull = ndr_pull_init_blob(&blob, r, NULL);
1125         if (pull == NULL) {
1126                 talloc_free(r);
1127                 return false;
1128         }
1129 
1130         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1131         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1132         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1133                 talloc_free(r);
1134                 return false;
1135         }
1136 
1137         if (DEBUGLEVEL >= 10) {
1138                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, r);
1139         }
1140 
1141         ZERO_STRUCT(r->out);
1142         r->out.resume_handle = r->in.resume_handle;
1143         r->out.service = talloc_zero_array(r, uint8_t, r->in.offered);
1144         if (r->out.service == NULL) {
1145                 talloc_free(r);
1146                 return false;
1147         }
1148 
1149         r->out.needed = talloc_zero(r, uint32_t);
1150         if (r->out.needed == NULL) {
1151                 talloc_free(r);
1152                 return false;
1153         }
1154 
1155         r->out.services_returned = talloc_zero(r, uint32_t);
1156         if (r->out.services_returned == NULL) {
1157                 talloc_free(r);
1158                 return false;
1159         }
1160 
1161         r->out.result = _svcctl_EnumServicesStatusW(p, r);
1162 
1163         if (p->rng_fault_state) {
1164                 talloc_free(r);
1165                 /* Return true here, srv_pipe_hnd.c will take care */
1166                 return true;
1167         }
1168 
1169         if (DEBUGLEVEL >= 10) {
1170                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, r);
1171         }
1172 
1173         push = ndr_push_init_ctx(r, NULL);
1174         if (push == NULL) {
1175                 talloc_free(r);
1176                 return false;
1177         }
1178 
1179         ndr_err = call->ndr_push(push, NDR_OUT, r);
1180         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1181                 talloc_free(r);
1182                 return false;
1183         }
1184 
1185         blob = ndr_push_blob(push);
1186         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1187                 talloc_free(r);
1188                 return false;
1189         }
1190 
1191         talloc_free(r);
1192 
1193         return true;
1194 }
1195 
1196 static bool api_svcctl_OpenSCManagerW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1197 {
1198         const struct ndr_interface_call *call;
1199         struct ndr_pull *pull;
1200         struct ndr_push *push;
1201         enum ndr_err_code ndr_err;
1202         DATA_BLOB blob;
1203         struct svcctl_OpenSCManagerW *r;
1204 
1205         call = &ndr_table_svcctl.calls[NDR_SVCCTL_OPENSCMANAGERW];
1206 
1207         r = talloc(talloc_tos(), struct svcctl_OpenSCManagerW);
1208         if (r == NULL) {
1209                 return false;
1210         }
1211 
1212         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1213                 talloc_free(r);
1214                 return false;
1215         }
1216 
1217         pull = ndr_pull_init_blob(&blob, r, NULL);
1218         if (pull == NULL) {
1219                 talloc_free(r);
1220                 return false;
1221         }
1222 
1223         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1224         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1225         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1226                 talloc_free(r);
1227                 return false;
1228         }
1229 
1230         if (DEBUGLEVEL >= 10) {
1231                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerW, r);
1232         }
1233 
1234         ZERO_STRUCT(r->out);
1235         r->out.handle = talloc_zero(r, struct policy_handle);
1236         if (r->out.handle == NULL) {
1237                 talloc_free(r);
1238                 return false;
1239         }
1240 
1241         r->out.result = _svcctl_OpenSCManagerW(p, r);
1242 
1243         if (p->rng_fault_state) {
1244                 talloc_free(r);
1245                 /* Return true here, srv_pipe_hnd.c will take care */
1246                 return true;
1247         }
1248 
1249         if (DEBUGLEVEL >= 10) {
1250                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, r);
1251         }
1252 
1253         push = ndr_push_init_ctx(r, NULL);
1254         if (push == NULL) {
1255                 talloc_free(r);
1256                 return false;
1257         }
1258 
1259         ndr_err = call->ndr_push(push, NDR_OUT, r);
1260         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1261                 talloc_free(r);
1262                 return false;
1263         }
1264 
1265         blob = ndr_push_blob(push);
1266         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1267                 talloc_free(r);
1268                 return false;
1269         }
1270 
1271         talloc_free(r);
1272 
1273         return true;
1274 }
1275 
1276 static bool api_svcctl_OpenServiceW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1277 {
1278         const struct ndr_interface_call *call;
1279         struct ndr_pull *pull;
1280         struct ndr_push *push;
1281         enum ndr_err_code ndr_err;
1282         DATA_BLOB blob;
1283         struct svcctl_OpenServiceW *r;
1284 
1285         call = &ndr_table_svcctl.calls[NDR_SVCCTL_OPENSERVICEW];
1286 
1287         r = talloc(talloc_tos(), struct svcctl_OpenServiceW);
1288         if (r == NULL) {
1289                 return false;
1290         }
1291 
1292         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1293                 talloc_free(r);
1294                 return false;
1295         }
1296 
1297         pull = ndr_pull_init_blob(&blob, r, NULL);
1298         if (pull == NULL) {
1299                 talloc_free(r);
1300                 return false;
1301         }
1302 
1303         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1304         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1305         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1306                 talloc_free(r);
1307                 return false;
1308         }
1309 
1310         if (DEBUGLEVEL >= 10) {
1311                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, r);
1312         }
1313 
1314         ZERO_STRUCT(r->out);
1315         r->out.handle = talloc_zero(r, struct policy_handle);
1316         if (r->out.handle == NULL) {
1317                 talloc_free(r);
1318                 return false;
1319         }
1320 
1321         r->out.result = _svcctl_OpenServiceW(p, r);
1322 
1323         if (p->rng_fault_state) {
1324                 talloc_free(r);
1325                 /* Return true here, srv_pipe_hnd.c will take care */
1326                 return true;
1327         }
1328 
1329         if (DEBUGLEVEL >= 10) {
1330                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, r);
1331         }
1332 
1333         push = ndr_push_init_ctx(r, NULL);
1334         if (push == NULL) {
1335                 talloc_free(r);
1336                 return false;
1337         }
1338 
1339         ndr_err = call->ndr_push(push, NDR_OUT, r);
1340         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1341                 talloc_free(r);
1342                 return false;
1343         }
1344 
1345         blob = ndr_push_blob(push);
1346         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1347                 talloc_free(r);
1348                 return false;
1349         }
1350 
1351         talloc_free(r);
1352 
1353         return true;
1354 }
1355 
1356 static bool api_svcctl_QueryServiceConfigW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1357 {
1358         const struct ndr_interface_call *call;
1359         struct ndr_pull *pull;
1360         struct ndr_push *push;
1361         enum ndr_err_code ndr_err;
1362         DATA_BLOB blob;
1363         struct svcctl_QueryServiceConfigW *r;
1364 
1365         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICECONFIGW];
1366 
1367         r = talloc(talloc_tos(), struct svcctl_QueryServiceConfigW);
1368         if (r == NULL) {
1369                 return false;
1370         }
1371 
1372         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1373                 talloc_free(r);
1374                 return false;
1375         }
1376 
1377         pull = ndr_pull_init_blob(&blob, r, NULL);
1378         if (pull == NULL) {
1379                 talloc_free(r);
1380                 return false;
1381         }
1382 
1383         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1384         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1385         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1386                 talloc_free(r);
1387                 return false;
1388         }
1389 
1390         if (DEBUGLEVEL >= 10) {
1391                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigW, r);
1392         }
1393 
1394         ZERO_STRUCT(r->out);
1395         r->out.query = talloc_zero(r, struct QUERY_SERVICE_CONFIG);
1396         if (r->out.query == NULL) {
1397                 talloc_free(r);
1398                 return false;
1399         }
1400 
1401         r->out.needed = talloc_zero(r, uint32_t);
1402         if (r->out.needed == NULL) {
1403                 talloc_free(r);
1404                 return false;
1405         }
1406 
1407         r->out.result = _svcctl_QueryServiceConfigW(p, r);
1408 
1409         if (p->rng_fault_state) {
1410                 talloc_free(r);
1411                 /* Return true here, srv_pipe_hnd.c will take care */
1412                 return true;
1413         }
1414 
1415         if (DEBUGLEVEL >= 10) {
1416                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, r);
1417         }
1418 
1419         push = ndr_push_init_ctx(r, NULL);
1420         if (push == NULL) {
1421                 talloc_free(r);
1422                 return false;
1423         }
1424 
1425         ndr_err = call->ndr_push(push, NDR_OUT, r);
1426         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1427                 talloc_free(r);
1428                 return false;
1429         }
1430 
1431         blob = ndr_push_blob(push);
1432         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1433                 talloc_free(r);
1434                 return false;
1435         }
1436 
1437         talloc_free(r);
1438 
1439         return true;
1440 }
1441 
1442 static bool api_svcctl_QueryServiceLockStatusW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1443 {
1444         const struct ndr_interface_call *call;
1445         struct ndr_pull *pull;
1446         struct ndr_push *push;
1447         enum ndr_err_code ndr_err;
1448         DATA_BLOB blob;
1449         struct svcctl_QueryServiceLockStatusW *r;
1450 
1451         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICELOCKSTATUSW];
1452 
1453         r = talloc(talloc_tos(), struct svcctl_QueryServiceLockStatusW);
1454         if (r == NULL) {
1455                 return false;
1456         }
1457 
1458         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1459                 talloc_free(r);
1460                 return false;
1461         }
1462 
1463         pull = ndr_pull_init_blob(&blob, r, NULL);
1464         if (pull == NULL) {
1465                 talloc_free(r);
1466                 return false;
1467         }
1468 
1469         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1470         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1471         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1472                 talloc_free(r);
1473                 return false;
1474         }
1475 
1476         if (DEBUGLEVEL >= 10) {
1477                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, r);
1478         }
1479 
1480         ZERO_STRUCT(r->out);
1481         r->out.lock_status = talloc_zero(r, struct SERVICE_LOCK_STATUS);
1482         if (r->out.lock_status == NULL) {
1483                 talloc_free(r);
1484                 return false;
1485         }
1486 
1487         r->out.needed = talloc_zero(r, uint32_t);
1488         if (r->out.needed == NULL) {
1489                 talloc_free(r);
1490                 return false;
1491         }
1492 
1493         r->out.result = _svcctl_QueryServiceLockStatusW(p, r);
1494 
1495         if (p->rng_fault_state) {
1496                 talloc_free(r);
1497                 /* Return true here, srv_pipe_hnd.c will take care */
1498                 return true;
1499         }
1500 
1501         if (DEBUGLEVEL >= 10) {
1502                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, r);
1503         }
1504 
1505         push = ndr_push_init_ctx(r, NULL);
1506         if (push == NULL) {
1507                 talloc_free(r);
1508                 return false;
1509         }
1510 
1511         ndr_err = call->ndr_push(push, NDR_OUT, r);
1512         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1513                 talloc_free(r);
1514                 return false;
1515         }
1516 
1517         blob = ndr_push_blob(push);
1518         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1519                 talloc_free(r);
1520                 return false;
1521         }
1522 
1523         talloc_free(r);
1524 
1525         return true;
1526 }
1527 
1528 static bool api_svcctl_StartServiceW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1529 {
1530         const struct ndr_interface_call *call;
1531         struct ndr_pull *pull;
1532         struct ndr_push *push;
1533         enum ndr_err_code ndr_err;
1534         DATA_BLOB blob;
1535         struct svcctl_StartServiceW *r;
1536 
1537         call = &ndr_table_svcctl.calls[NDR_SVCCTL_STARTSERVICEW];
1538 
1539         r = talloc(talloc_tos(), struct svcctl_StartServiceW);
1540         if (r == NULL) {
1541                 return false;
1542         }
1543 
1544         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1545                 talloc_free(r);
1546                 return false;
1547         }
1548 
1549         pull = ndr_pull_init_blob(&blob, r, NULL);
1550         if (pull == NULL) {
1551                 talloc_free(r);
1552                 return false;
1553         }
1554 
1555         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1556         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1557         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1558                 talloc_free(r);
1559                 return false;
1560         }
1561 
1562         if (DEBUGLEVEL >= 10) {
1563                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, r);
1564         }
1565 
1566         r->out.result = _svcctl_StartServiceW(p, r);
1567 
1568         if (p->rng_fault_state) {
1569                 talloc_free(r);
1570                 /* Return true here, srv_pipe_hnd.c will take care */
1571                 return true;
1572         }
1573 
1574         if (DEBUGLEVEL >= 10) {
1575                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, r);
1576         }
1577 
1578         push = ndr_push_init_ctx(r, NULL);
1579         if (push == NULL) {
1580                 talloc_free(r);
1581                 return false;
1582         }
1583 
1584         ndr_err = call->ndr_push(push, NDR_OUT, r);
1585         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1586                 talloc_free(r);
1587                 return false;
1588         }
1589 
1590         blob = ndr_push_blob(push);
1591         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1592                 talloc_free(r);
1593                 return false;
1594         }
1595 
1596         talloc_free(r);
1597 
1598         return true;
1599 }
1600 
1601 static bool api_svcctl_GetServiceDisplayNameW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1602 {
1603         const struct ndr_interface_call *call;
1604         struct ndr_pull *pull;
1605         struct ndr_push *push;
1606         enum ndr_err_code ndr_err;
1607         DATA_BLOB blob;
1608         struct svcctl_GetServiceDisplayNameW *r;
1609 
1610         call = &ndr_table_svcctl.calls[NDR_SVCCTL_GETSERVICEDISPLAYNAMEW];
1611 
1612         r = talloc(talloc_tos(), struct svcctl_GetServiceDisplayNameW);
1613         if (r == NULL) {
1614                 return false;
1615         }
1616 
1617         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1618                 talloc_free(r);
1619                 return false;
1620         }
1621 
1622         pull = ndr_pull_init_blob(&blob, r, NULL);
1623         if (pull == NULL) {
1624                 talloc_free(r);
1625                 return false;
1626         }
1627 
1628         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1629         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1630         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1631                 talloc_free(r);
1632                 return false;
1633         }
1634 
1635         if (DEBUGLEVEL >= 10) {
1636                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameW, r);
1637         }
1638 
1639         ZERO_STRUCT(r->out);
1640         r->out.display_name_length = r->in.display_name_length;
1641         r->out.display_name = talloc_zero(r, const char *);
1642         if (r->out.display_name == NULL) {
1643                 talloc_free(r);
1644                 return false;
1645         }
1646 
1647         r->out.result = _svcctl_GetServiceDisplayNameW(p, r);
1648 
1649         if (p->rng_fault_state) {
1650                 talloc_free(r);
1651                 /* Return true here, srv_pipe_hnd.c will take care */
1652                 return true;
1653         }
1654 
1655         if (DEBUGLEVEL >= 10) {
1656                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, r);
1657         }
1658 
1659         push = ndr_push_init_ctx(r, NULL);
1660         if (push == NULL) {
1661                 talloc_free(r);
1662                 return false;
1663         }
1664 
1665         ndr_err = call->ndr_push(push, NDR_OUT, r);
1666         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1667                 talloc_free(r);
1668                 return false;
1669         }
1670 
1671         blob = ndr_push_blob(push);
1672         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1673                 talloc_free(r);
1674                 return false;
1675         }
1676 
1677         talloc_free(r);
1678 
1679         return true;
1680 }
1681 
1682 static bool api_svcctl_GetServiceKeyNameW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1683 {
1684         const struct ndr_interface_call *call;
1685         struct ndr_pull *pull;
1686         struct ndr_push *push;
1687         enum ndr_err_code ndr_err;
1688         DATA_BLOB blob;
1689         struct svcctl_GetServiceKeyNameW *r;
1690 
1691         call = &ndr_table_svcctl.calls[NDR_SVCCTL_GETSERVICEKEYNAMEW];
1692 
1693         r = talloc(talloc_tos(), struct svcctl_GetServiceKeyNameW);
1694         if (r == NULL) {
1695                 return false;
1696         }
1697 
1698         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1699                 talloc_free(r);
1700                 return false;
1701         }
1702 
1703         pull = ndr_pull_init_blob(&blob, r, NULL);
1704         if (pull == NULL) {
1705                 talloc_free(r);
1706                 return false;
1707         }
1708 
1709         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1710         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1711         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1712                 talloc_free(r);
1713                 return false;
1714         }
1715 
1716         if (DEBUGLEVEL >= 10) {
1717                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameW, r);
1718         }
1719 
1720         ZERO_STRUCT(r->out);
1721         r->out.display_name_length = r->in.display_name_length;
1722         r->out.key_name = talloc_zero(r, const char *);
1723         if (r->out.key_name == NULL) {
1724                 talloc_free(r);
1725                 return false;
1726         }
1727 
1728         r->out.result = _svcctl_GetServiceKeyNameW(p, r);
1729 
1730         if (p->rng_fault_state) {
1731                 talloc_free(r);
1732                 /* Return true here, srv_pipe_hnd.c will take care */
1733                 return true;
1734         }
1735 
1736         if (DEBUGLEVEL >= 10) {
1737                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, r);
1738         }
1739 
1740         push = ndr_push_init_ctx(r, NULL);
1741         if (push == NULL) {
1742                 talloc_free(r);
1743                 return false;
1744         }
1745 
1746         ndr_err = call->ndr_push(push, NDR_OUT, r);
1747         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1748                 talloc_free(r);
1749                 return false;
1750         }
1751 
1752         blob = ndr_push_blob(push);
1753         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1754                 talloc_free(r);
1755                 return false;
1756         }
1757 
1758         talloc_free(r);
1759 
1760         return true;
1761 }
1762 
1763 static bool api_svcctl_SCSetServiceBitsA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1764 {
1765         const struct ndr_interface_call *call;
1766         struct ndr_pull *pull;
1767         struct ndr_push *push;
1768         enum ndr_err_code ndr_err;
1769         DATA_BLOB blob;
1770         struct svcctl_SCSetServiceBitsA *r;
1771 
1772         call = &ndr_table_svcctl.calls[NDR_SVCCTL_SCSETSERVICEBITSA];
1773 
1774         r = talloc(talloc_tos(), struct svcctl_SCSetServiceBitsA);
1775         if (r == NULL) {
1776                 return false;
1777         }
1778 
1779         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1780                 talloc_free(r);
1781                 return false;
1782         }
1783 
1784         pull = ndr_pull_init_blob(&blob, r, NULL);
1785         if (pull == NULL) {
1786                 talloc_free(r);
1787                 return false;
1788         }
1789 
1790         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1791         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1792         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1793                 talloc_free(r);
1794                 return false;
1795         }
1796 
1797         if (DEBUGLEVEL >= 10) {
1798                 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, r);
1799         }
1800 
1801         r->out.result = _svcctl_SCSetServiceBitsA(p, r);
1802 
1803         if (p->rng_fault_state) {
1804                 talloc_free(r);
1805                 /* Return true here, srv_pipe_hnd.c will take care */
1806                 return true;
1807         }
1808 
1809         if (DEBUGLEVEL >= 10) {
1810                 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, r);
1811         }
1812 
1813         push = ndr_push_init_ctx(r, NULL);
1814         if (push == NULL) {
1815                 talloc_free(r);
1816                 return false;
1817         }
1818 
1819         ndr_err = call->ndr_push(push, NDR_OUT, r);
1820         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1821                 talloc_free(r);
1822                 return false;
1823         }
1824 
1825         blob = ndr_push_blob(push);
1826         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1827                 talloc_free(r);
1828                 return false;
1829         }
1830 
1831         talloc_free(r);
1832 
1833         return true;
1834 }
1835 
1836 static bool api_svcctl_ChangeServiceConfigA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1837 {
1838         const struct ndr_interface_call *call;
1839         struct ndr_pull *pull;
1840         struct ndr_push *push;
1841         enum ndr_err_code ndr_err;
1842         DATA_BLOB blob;
1843         struct svcctl_ChangeServiceConfigA *r;
1844 
1845         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CHANGESERVICECONFIGA];
1846 
1847         r = talloc(talloc_tos(), struct svcctl_ChangeServiceConfigA);
1848         if (r == NULL) {
1849                 return false;
1850         }
1851 
1852         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1853                 talloc_free(r);
1854                 return false;
1855         }
1856 
1857         pull = ndr_pull_init_blob(&blob, r, NULL);
1858         if (pull == NULL) {
1859                 talloc_free(r);
1860                 return false;
1861         }
1862 
1863         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1864         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1865         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1866                 talloc_free(r);
1867                 return false;
1868         }
1869 
1870         if (DEBUGLEVEL >= 10) {
1871                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigA, r);
1872         }
1873 
1874         ZERO_STRUCT(r->out);
1875         r->out.tag_id = talloc_zero(r, uint32_t);
1876         if (r->out.tag_id == NULL) {
1877                 talloc_free(r);
1878                 return false;
1879         }
1880 
1881         r->out.result = _svcctl_ChangeServiceConfigA(p, r);
1882 
1883         if (p->rng_fault_state) {
1884                 talloc_free(r);
1885                 /* Return true here, srv_pipe_hnd.c will take care */
1886                 return true;
1887         }
1888 
1889         if (DEBUGLEVEL >= 10) {
1890                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, r);
1891         }
1892 
1893         push = ndr_push_init_ctx(r, NULL);
1894         if (push == NULL) {
1895                 talloc_free(r);
1896                 return false;
1897         }
1898 
1899         ndr_err = call->ndr_push(push, NDR_OUT, r);
1900         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1901                 talloc_free(r);
1902                 return false;
1903         }
1904 
1905         blob = ndr_push_blob(push);
1906         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1907                 talloc_free(r);
1908                 return false;
1909         }
1910 
1911         talloc_free(r);
1912 
1913         return true;
1914 }
1915 
1916 static bool api_svcctl_CreateServiceA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1917 {
1918         const struct ndr_interface_call *call;
1919         struct ndr_pull *pull;
1920         struct ndr_push *push;
1921         enum ndr_err_code ndr_err;
1922         DATA_BLOB blob;
1923         struct svcctl_CreateServiceA *r;
1924 
1925         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CREATESERVICEA];
1926 
1927         r = talloc(talloc_tos(), struct svcctl_CreateServiceA);
1928         if (r == NULL) {
1929                 return false;
1930         }
1931 
1932         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1933                 talloc_free(r);
1934                 return false;
1935         }
1936 
1937         pull = ndr_pull_init_blob(&blob, r, NULL);
1938         if (pull == NULL) {
1939                 talloc_free(r);
1940                 return false;
1941         }
1942 
1943         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1944         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1945         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1946                 talloc_free(r);
1947                 return false;
1948         }
1949 
1950         if (DEBUGLEVEL >= 10) {
1951                 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceA, r);
1952         }
1953 
1954         ZERO_STRUCT(r->out);
1955         r->out.TagId = talloc_zero(r, uint32_t);
1956         if (r->out.TagId == NULL) {
1957                 talloc_free(r);
1958                 return false;
1959         }
1960 
1961         r->out.result = _svcctl_CreateServiceA(p, r);
1962 
1963         if (p->rng_fault_state) {
1964                 talloc_free(r);
1965                 /* Return true here, srv_pipe_hnd.c will take care */
1966                 return true;
1967         }
1968 
1969         if (DEBUGLEVEL >= 10) {
1970                 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, r);
1971         }
1972 
1973         push = ndr_push_init_ctx(r, NULL);
1974         if (push == NULL) {
1975                 talloc_free(r);
1976                 return false;
1977         }
1978 
1979         ndr_err = call->ndr_push(push, NDR_OUT, r);
1980         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1981                 talloc_free(r);
1982                 return false;
1983         }
1984 
1985         blob = ndr_push_blob(push);
1986         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1987                 talloc_free(r);
1988                 return false;
1989         }
1990 
1991         talloc_free(r);
1992 
1993         return true;
1994 }
1995 
1996 static bool api_svcctl_EnumDependentServicesA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1997 {
1998         const struct ndr_interface_call *call;
1999         struct ndr_pull *pull;
2000         struct ndr_push *push;
2001         enum ndr_err_code ndr_err;
2002         DATA_BLOB blob;
2003         struct svcctl_EnumDependentServicesA *r;
2004 
2005         call = &ndr_table_svcctl.calls[NDR_SVCCTL_ENUMDEPENDENTSERVICESA];
2006 
2007         r = talloc(talloc_tos(), struct svcctl_EnumDependentServicesA);
2008         if (r == NULL) {
2009                 return false;
2010         }
2011 
2012         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2013                 talloc_free(r);
2014                 return false;
2015         }
2016 
2017         pull = ndr_pull_init_blob(&blob, r, NULL);
2018         if (pull == NULL) {
2019                 talloc_free(r);
2020                 return false;
2021         }
2022 
2023         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2024         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2025         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2026                 talloc_free(r);
2027                 return false;
2028         }
2029 
2030         if (DEBUGLEVEL >= 10) {
2031                 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, r);
2032         }
2033 
2034         ZERO_STRUCT(r->out);
2035         r->out.service_status = talloc_zero(r, struct ENUM_SERVICE_STATUSA);
2036         if (r->out.service_status == NULL) {
2037                 talloc_free(r);
2038                 return false;
2039         }
2040 
2041         r->out.needed = talloc_zero(r, uint32_t);
2042         if (r->out.needed == NULL) {
2043                 talloc_free(r);
2044                 return false;
2045         }
2046 
2047         r->out.services_returned = talloc_zero(r, uint32_t);
2048         if (r->out.services_returned == NULL) {
2049                 talloc_free(r);
2050                 return false;
2051         }
2052 
2053         r->out.result = _svcctl_EnumDependentServicesA(p, r);
2054 
2055         if (p->rng_fault_state) {
2056                 talloc_free(r);
2057                 /* Return true here, srv_pipe_hnd.c will take care */
2058                 return true;
2059         }
2060 
2061         if (DEBUGLEVEL >= 10) {
2062                 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, r);
2063         }
2064 
2065         push = ndr_push_init_ctx(r, NULL);
2066         if (push == NULL) {
2067                 talloc_free(r);
2068                 return false;
2069         }
2070 
2071         ndr_err = call->ndr_push(push, NDR_OUT, r);
2072         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2073                 talloc_free(r);
2074                 return false;
2075         }
2076 
2077         blob = ndr_push_blob(push);
2078         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2079                 talloc_free(r);
2080                 return false;
2081         }
2082 
2083         talloc_free(r);
2084 
2085         return true;
2086 }
2087 
2088 static bool api_svcctl_EnumServicesStatusA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2089 {
2090         const struct ndr_interface_call *call;
2091         struct ndr_pull *pull;
2092         struct ndr_push *push;
2093         enum ndr_err_code ndr_err;
2094         DATA_BLOB blob;
2095         struct svcctl_EnumServicesStatusA *r;
2096 
2097         call = &ndr_table_svcctl.calls[NDR_SVCCTL_ENUMSERVICESSTATUSA];
2098 
2099         r = talloc(talloc_tos(), struct svcctl_EnumServicesStatusA);
2100         if (r == NULL) {
2101                 return false;
2102         }
2103 
2104         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2105                 talloc_free(r);
2106                 return false;
2107         }
2108 
2109         pull = ndr_pull_init_blob(&blob, r, NULL);
2110         if (pull == NULL) {
2111                 talloc_free(r);
2112                 return false;
2113         }
2114 
2115         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2116         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2117         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2118                 talloc_free(r);
2119                 return false;
2120         }
2121 
2122         if (DEBUGLEVEL >= 10) {
2123                 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusA, r);
2124         }
2125 
2126         ZERO_STRUCT(r->out);
2127         r->out.resume_handle = r->in.resume_handle;
2128         r->out.service = talloc_zero_array(r, uint8_t, r->in.offered);
2129         if (r->out.service == NULL) {
2130                 talloc_free(r);
2131                 return false;
2132         }
2133 
2134         r->out.needed = talloc_zero(r, uint32_t);
2135         if (r->out.needed == NULL) {
2136                 talloc_free(r);
2137                 return false;
2138         }
2139 
2140         r->out.services_returned = talloc_zero(r, uint32_t);
2141         if (r->out.services_returned == NULL) {
2142                 talloc_free(r);
2143                 return false;
2144         }
2145 
2146         r->out.result = _svcctl_EnumServicesStatusA(p, r);
2147 
2148         if (p->rng_fault_state) {
2149                 talloc_free(r);
2150                 /* Return true here, srv_pipe_hnd.c will take care */
2151                 return true;
2152         }
2153 
2154         if (DEBUGLEVEL >= 10) {
2155                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, r);
2156         }
2157 
2158         push = ndr_push_init_ctx(r, NULL);
2159         if (push == NULL) {
2160                 talloc_free(r);
2161                 return false;
2162         }
2163 
2164         ndr_err = call->ndr_push(push, NDR_OUT, r);
2165         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2166                 talloc_free(r);
2167                 return false;
2168         }
2169 
2170         blob = ndr_push_blob(push);
2171         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2172                 talloc_free(r);
2173                 return false;
2174         }
2175 
2176         talloc_free(r);
2177 
2178         return true;
2179 }
2180 
2181 static bool api_svcctl_OpenSCManagerA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2182 {
2183         const struct ndr_interface_call *call;
2184         struct ndr_pull *pull;
2185         struct ndr_push *push;
2186         enum ndr_err_code ndr_err;
2187         DATA_BLOB blob;
2188         struct svcctl_OpenSCManagerA *r;
2189 
2190         call = &ndr_table_svcctl.calls[NDR_SVCCTL_OPENSCMANAGERA];
2191 
2192         r = talloc(talloc_tos(), struct svcctl_OpenSCManagerA);
2193         if (r == NULL) {
2194                 return false;
2195         }
2196 
2197         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2198                 talloc_free(r);
2199                 return false;
2200         }
2201 
2202         pull = ndr_pull_init_blob(&blob, r, NULL);
2203         if (pull == NULL) {
2204                 talloc_free(r);
2205                 return false;
2206         }
2207 
2208         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2209         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2210         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2211                 talloc_free(r);
2212                 return false;
2213         }
2214 
2215         if (DEBUGLEVEL >= 10) {
2216                 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerA, r);
2217         }
2218 
2219         ZERO_STRUCT(r->out);
2220         r->out.handle = talloc_zero(r, struct policy_handle);
2221         if (r->out.handle == NULL) {
2222                 talloc_free(r);
2223                 return false;
2224         }
2225 
2226         r->out.result = _svcctl_OpenSCManagerA(p, r);
2227 
2228         if (p->rng_fault_state) {
2229                 talloc_free(r);
2230                 /* Return true here, srv_pipe_hnd.c will take care */
2231                 return true;
2232         }
2233 
2234         if (DEBUGLEVEL >= 10) {
2235                 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, r);
2236         }
2237 
2238         push = ndr_push_init_ctx(r, NULL);
2239         if (push == NULL) {
2240                 talloc_free(r);
2241                 return false;
2242         }
2243 
2244         ndr_err = call->ndr_push(push, NDR_OUT, r);
2245         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2246                 talloc_free(r);
2247                 return false;
2248         }
2249 
2250         blob = ndr_push_blob(push);
2251         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2252                 talloc_free(r);
2253                 return false;
2254         }
2255 
2256         talloc_free(r);
2257 
2258         return true;
2259 }
2260 
2261 static bool api_svcctl_OpenServiceA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2262 {
2263         const struct ndr_interface_call *call;
2264         struct ndr_pull *pull;
2265         struct ndr_push *push;
2266         enum ndr_err_code ndr_err;
2267         DATA_BLOB blob;
2268         struct svcctl_OpenServiceA *r;
2269 
2270         call = &ndr_table_svcctl.calls[NDR_SVCCTL_OPENSERVICEA];
2271 
2272         r = talloc(talloc_tos(), struct svcctl_OpenServiceA);
2273         if (r == NULL) {
2274                 return false;
2275         }
2276 
2277         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2278                 talloc_free(r);
2279                 return false;
2280         }
2281 
2282         pull = ndr_pull_init_blob(&blob, r, NULL);
2283         if (pull == NULL) {
2284                 talloc_free(r);
2285                 return false;
2286         }
2287 
2288         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2289         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2290         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2291                 talloc_free(r);
2292                 return false;
2293         }
2294 
2295         if (DEBUGLEVEL >= 10) {
2296                 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, r);
2297         }
2298 
2299         r->out.result = _svcctl_OpenServiceA(p, r);
2300 
2301         if (p->rng_fault_state) {
2302                 talloc_free(r);
2303                 /* Return true here, srv_pipe_hnd.c will take care */
2304                 return true;
2305         }
2306 
2307         if (DEBUGLEVEL >= 10) {
2308                 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, r);
2309         }
2310 
2311         push = ndr_push_init_ctx(r, NULL);
2312         if (push == NULL) {
2313                 talloc_free(r);
2314                 return false;
2315         }
2316 
2317         ndr_err = call->ndr_push(push, NDR_OUT, r);
2318         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2319                 talloc_free(r);
2320                 return false;
2321         }
2322 
2323         blob = ndr_push_blob(push);
2324         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2325                 talloc_free(r);
2326                 return false;
2327         }
2328 
2329         talloc_free(r);
2330 
2331         return true;
2332 }
2333 
2334 static bool api_svcctl_QueryServiceConfigA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2335 {
2336         const struct ndr_interface_call *call;
2337         struct ndr_pull *pull;
2338         struct ndr_push *push;
2339         enum ndr_err_code ndr_err;
2340         DATA_BLOB blob;
2341         struct svcctl_QueryServiceConfigA *r;
2342 
2343         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICECONFIGA];
2344 
2345         r = talloc(talloc_tos(), struct svcctl_QueryServiceConfigA);
2346         if (r == NULL) {
2347                 return false;
2348         }
2349 
2350         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2351                 talloc_free(r);
2352                 return false;
2353         }
2354 
2355         pull = ndr_pull_init_blob(&blob, r, NULL);
2356         if (pull == NULL) {
2357                 talloc_free(r);
2358                 return false;
2359         }
2360 
2361         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2362         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2363         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2364                 talloc_free(r);
2365                 return false;
2366         }
2367 
2368         if (DEBUGLEVEL >= 10) {
2369                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, r);
2370         }
2371 
2372         ZERO_STRUCT(r->out);
2373         r->out.query = talloc_zero_array(r, uint8_t, r->in.offered);
2374         if (r->out.query == NULL) {
2375                 talloc_free(r);
2376                 return false;
2377         }
2378 
2379         r->out.needed = talloc_zero(r, uint32_t);
2380         if (r->out.needed == NULL) {
2381                 talloc_free(r);
2382                 return false;
2383         }
2384 
2385         r->out.result = _svcctl_QueryServiceConfigA(p, r);
2386 
2387         if (p->rng_fault_state) {
2388                 talloc_free(r);
2389                 /* Return true here, srv_pipe_hnd.c will take care */
2390                 return true;
2391         }
2392 
2393         if (DEBUGLEVEL >= 10) {
2394                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, r);
2395         }
2396 
2397         push = ndr_push_init_ctx(r, NULL);
2398         if (push == NULL) {
2399                 talloc_free(r);
2400                 return false;
2401         }
2402 
2403         ndr_err = call->ndr_push(push, NDR_OUT, r);
2404         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2405                 talloc_free(r);
2406                 return false;
2407         }
2408 
2409         blob = ndr_push_blob(push);
2410         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2411                 talloc_free(r);
2412                 return false;
2413         }
2414 
2415         talloc_free(r);
2416 
2417         return true;
2418 }
2419 
2420 static bool api_svcctl_QueryServiceLockStatusA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2421 {
2422         const struct ndr_interface_call *call;
2423         struct ndr_pull *pull;
2424         struct ndr_push *push;
2425         enum ndr_err_code ndr_err;
2426         DATA_BLOB blob;
2427         struct svcctl_QueryServiceLockStatusA *r;
2428 
2429         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICELOCKSTATUSA];
2430 
2431         r = talloc(talloc_tos(), struct svcctl_QueryServiceLockStatusA);
2432         if (r == NULL) {
2433                 return false;
2434         }
2435 
2436         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2437                 talloc_free(r);
2438                 return false;
2439         }
2440 
2441         pull = ndr_pull_init_blob(&blob, r, NULL);
2442         if (pull == NULL) {
2443                 talloc_free(r);
2444                 return false;
2445         }
2446 
2447         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2448         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2449         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2450                 talloc_free(r);
2451                 return false;
2452         }
2453 
2454         if (DEBUGLEVEL >= 10) {
2455                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusA, r);
2456         }
2457 
2458         ZERO_STRUCT(r->out);
2459         r->out.lock_status = talloc_zero(r, struct SERVICE_LOCK_STATUS);
2460         if (r->out.lock_status == NULL) {
2461                 talloc_free(r);
2462                 return false;
2463         }
2464 
2465         r->out.needed = talloc_zero(r, uint32_t);
2466         if (r->out.needed == NULL) {
2467                 talloc_free(r);
2468                 return false;
2469         }
2470 
2471         r->out.result = _svcctl_QueryServiceLockStatusA(p, r);
2472 
2473         if (p->rng_fault_state) {
2474                 talloc_free(r);
2475                 /* Return true here, srv_pipe_hnd.c will take care */
2476                 return true;
2477         }
2478 
2479         if (DEBUGLEVEL >= 10) {
2480                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, r);
2481         }
2482 
2483         push = ndr_push_init_ctx(r, NULL);
2484         if (push == NULL) {
2485                 talloc_free(r);
2486                 return false;
2487         }
2488 
2489         ndr_err = call->ndr_push(push, NDR_OUT, r);
2490         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2491                 talloc_free(r);
2492                 return false;
2493         }
2494 
2495         blob = ndr_push_blob(push);
2496         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2497                 talloc_free(r);
2498                 return false;
2499         }
2500 
2501         talloc_free(r);
2502 
2503         return true;
2504 }
2505 
2506 static bool api_svcctl_StartServiceA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2507 {
2508         const struct ndr_interface_call *call;
2509         struct ndr_pull *pull;
2510         struct ndr_push *push;
2511         enum ndr_err_code ndr_err;
2512         DATA_BLOB blob;
2513         struct svcctl_StartServiceA *r;
2514 
2515         call = &ndr_table_svcctl.calls[NDR_SVCCTL_STARTSERVICEA];
2516 
2517         r = talloc(talloc_tos(), struct svcctl_StartServiceA);
2518         if (r == NULL) {
2519                 return false;
2520         }
2521 
2522         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2523                 talloc_free(r);
2524                 return false;
2525         }
2526 
2527         pull = ndr_pull_init_blob(&blob, r, NULL);
2528         if (pull == NULL) {
2529                 talloc_free(r);
2530                 return false;
2531         }
2532 
2533         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2534         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2535         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2536                 talloc_free(r);
2537                 return false;
2538         }
2539 
2540         if (DEBUGLEVEL >= 10) {
2541                 NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, r);
2542         }
2543 
2544         r->out.result = _svcctl_StartServiceA(p, r);
2545 
2546         if (p->rng_fault_state) {
2547                 talloc_free(r);
2548                 /* Return true here, srv_pipe_hnd.c will take care */
2549                 return true;
2550         }
2551 
2552         if (DEBUGLEVEL >= 10) {
2553                 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, r);
2554         }
2555 
2556         push = ndr_push_init_ctx(r, NULL);
2557         if (push == NULL) {
2558                 talloc_free(r);
2559                 return false;
2560         }
2561 
2562         ndr_err = call->ndr_push(push, NDR_OUT, r);
2563         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2564                 talloc_free(r);
2565                 return false;
2566         }
2567 
2568         blob = ndr_push_blob(push);
2569         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2570                 talloc_free(r);
2571                 return false;
2572         }
2573 
2574         talloc_free(r);
2575 
2576         return true;
2577 }
2578 
2579 static bool api_svcctl_GetServiceDisplayNameA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2580 {
2581         const struct ndr_interface_call *call;
2582         struct ndr_pull *pull;
2583         struct ndr_push *push;
2584         enum ndr_err_code ndr_err;
2585         DATA_BLOB blob;
2586         struct svcctl_GetServiceDisplayNameA *r;
2587 
2588         call = &ndr_table_svcctl.calls[NDR_SVCCTL_GETSERVICEDISPLAYNAMEA];
2589 
2590         r = talloc(talloc_tos(), struct svcctl_GetServiceDisplayNameA);
2591         if (r == NULL) {
2592                 return false;
2593         }
2594 
2595         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2596                 talloc_free(r);
2597                 return false;
2598         }
2599 
2600         pull = ndr_pull_init_blob(&blob, r, NULL);
2601         if (pull == NULL) {
2602                 talloc_free(r);
2603                 return false;
2604         }
2605 
2606         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2607         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2608         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2609                 talloc_free(r);
2610                 return false;
2611         }
2612 
2613         if (DEBUGLEVEL >= 10) {
2614                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameA, r);
2615         }
2616 
2617         ZERO_STRUCT(r->out);
2618         r->out.display_name_length = r->in.display_name_length;
2619         r->out.display_name = talloc_zero(r, const char *);
2620         if (r->out.display_name == NULL) {
2621                 talloc_free(r);
2622                 return false;
2623         }
2624 
2625         r->out.result = _svcctl_GetServiceDisplayNameA(p, r);
2626 
2627         if (p->rng_fault_state) {
2628                 talloc_free(r);
2629                 /* Return true here, srv_pipe_hnd.c will take care */
2630                 return true;
2631         }
2632 
2633         if (DEBUGLEVEL >= 10) {
2634                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, r);
2635         }
2636 
2637         push = ndr_push_init_ctx(r, NULL);
2638         if (push == NULL) {
2639                 talloc_free(r);
2640                 return false;
2641         }
2642 
2643         ndr_err = call->ndr_push(push, NDR_OUT, r);
2644         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2645                 talloc_free(r);
2646                 return false;
2647         }
2648 
2649         blob = ndr_push_blob(push);
2650         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2651                 talloc_free(r);
2652                 return false;
2653         }
2654 
2655         talloc_free(r);
2656 
2657         return true;
2658 }
2659 
2660 static bool api_svcctl_GetServiceKeyNameA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2661 {
2662         const struct ndr_interface_call *call;
2663         struct ndr_pull *pull;
2664         struct ndr_push *push;
2665         enum ndr_err_code ndr_err;
2666         DATA_BLOB blob;
2667         struct svcctl_GetServiceKeyNameA *r;
2668 
2669         call = &ndr_table_svcctl.calls[NDR_SVCCTL_GETSERVICEKEYNAMEA];
2670 
2671         r = talloc(talloc_tos(), struct svcctl_GetServiceKeyNameA);
2672         if (r == NULL) {
2673                 return false;
2674         }
2675 
2676         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2677                 talloc_free(r);
2678                 return false;
2679         }
2680 
2681         pull = ndr_pull_init_blob(&blob, r, NULL);
2682         if (pull == NULL) {
2683                 talloc_free(r);
2684                 return false;
2685         }
2686 
2687         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2688         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2689         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2690                 talloc_free(r);
2691                 return false;
2692         }
2693 
2694         if (DEBUGLEVEL >= 10) {
2695                 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, r);
2696         }
2697 
2698         ZERO_STRUCT(r->out);
2699         r->out.display_name_length = r->in.display_name_length;
2700         r->out.key_name = talloc_zero(r, const char *);
2701         if (r->out.key_name == NULL) {
2702                 talloc_free(r);
2703                 return false;
2704         }
2705 
2706         r->out.result = _svcctl_GetServiceKeyNameA(p, r);
2707 
2708         if (p->rng_fault_state) {
2709                 talloc_free(r);
2710                 /* Return true here, srv_pipe_hnd.c will take care */
2711                 return true;
2712         }
2713 
2714         if (DEBUGLEVEL >= 10) {
2715                 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, r);
2716         }
2717 
2718         push = ndr_push_init_ctx(r, NULL);
2719         if (push == NULL) {
2720                 talloc_free(r);
2721                 return false;
2722         }
2723 
2724         ndr_err = call->ndr_push(push, NDR_OUT, r);
2725         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2726                 talloc_free(r);
2727                 return false;
2728         }
2729 
2730         blob = ndr_push_blob(push);
2731         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2732                 talloc_free(r);
2733                 return false;
2734         }
2735 
2736         talloc_free(r);
2737 
2738         return true;
2739 }
2740 
2741 static bool api_svcctl_GetCurrentGroupeStateW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2742 {
2743         const struct ndr_interface_call *call;
2744         struct ndr_pull *pull;
2745         struct ndr_push *push;
2746         enum ndr_err_code ndr_err;
2747         DATA_BLOB blob;
2748         struct svcctl_GetCurrentGroupeStateW *r;
2749 
2750         call = &ndr_table_svcctl.calls[NDR_SVCCTL_GETCURRENTGROUPESTATEW];
2751 
2752         r = talloc(talloc_tos(), struct svcctl_GetCurrentGroupeStateW);
2753         if (r == NULL) {
2754                 return false;
2755         }
2756 
2757         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2758                 talloc_free(r);
2759                 return false;
2760         }
2761 
2762         pull = ndr_pull_init_blob(&blob, r, NULL);
2763         if (pull == NULL) {
2764                 talloc_free(r);
2765                 return false;
2766         }
2767 
2768         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2769         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2770         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2771                 talloc_free(r);
2772                 return false;
2773         }
2774 
2775         if (DEBUGLEVEL >= 10) {
2776                 NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, r);
2777         }
2778 
2779         r->out.result = _svcctl_GetCurrentGroupeStateW(p, r);
2780 
2781         if (p->rng_fault_state) {
2782                 talloc_free(r);
2783                 /* Return true here, srv_pipe_hnd.c will take care */
2784                 return true;
2785         }
2786 
2787         if (DEBUGLEVEL >= 10) {
2788                 NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, r);
2789         }
2790 
2791         push = ndr_push_init_ctx(r, NULL);
2792         if (push == NULL) {
2793                 talloc_free(r);
2794                 return false;
2795         }
2796 
2797         ndr_err = call->ndr_push(push, NDR_OUT, r);
2798         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2799                 talloc_free(r);
2800                 return false;
2801         }
2802 
2803         blob = ndr_push_blob(push);
2804         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2805                 talloc_free(r);
2806                 return false;
2807         }
2808 
2809         talloc_free(r);
2810 
2811         return true;
2812 }
2813 
2814 static bool api_svcctl_EnumServiceGroupW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2815 {
2816         const struct ndr_interface_call *call;
2817         struct ndr_pull *pull;
2818         struct ndr_push *push;
2819         enum ndr_err_code ndr_err;
2820         DATA_BLOB blob;
2821         struct svcctl_EnumServiceGroupW *r;
2822 
2823         call = &ndr_table_svcctl.calls[NDR_SVCCTL_ENUMSERVICEGROUPW];
2824 
2825         r = talloc(talloc_tos(), struct svcctl_EnumServiceGroupW);
2826         if (r == NULL) {
2827                 return false;
2828         }
2829 
2830         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2831                 talloc_free(r);
2832                 return false;
2833         }
2834 
2835         pull = ndr_pull_init_blob(&blob, r, NULL);
2836         if (pull == NULL) {
2837                 talloc_free(r);
2838                 return false;
2839         }
2840 
2841         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2842         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2843         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2844                 talloc_free(r);
2845                 return false;
2846         }
2847 
2848         if (DEBUGLEVEL >= 10) {
2849                 NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, r);
2850         }
2851 
2852         r->out.result = _svcctl_EnumServiceGroupW(p, r);
2853 
2854         if (p->rng_fault_state) {
2855                 talloc_free(r);
2856                 /* Return true here, srv_pipe_hnd.c will take care */
2857                 return true;
2858         }
2859 
2860         if (DEBUGLEVEL >= 10) {
2861                 NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, r);
2862         }
2863 
2864         push = ndr_push_init_ctx(r, NULL);
2865         if (push == NULL) {
2866                 talloc_free(r);
2867                 return false;
2868         }
2869 
2870         ndr_err = call->ndr_push(push, NDR_OUT, r);
2871         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2872                 talloc_free(r);
2873                 return false;
2874         }
2875 
2876         blob = ndr_push_blob(push);
2877         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2878                 talloc_free(r);
2879                 return false;
2880         }
2881 
2882         talloc_free(r);
2883 
2884         return true;
2885 }
2886 
2887 static bool api_svcctl_ChangeServiceConfig2A(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2888 {
2889         const struct ndr_interface_call *call;
2890         struct ndr_pull *pull;
2891         struct ndr_push *push;
2892         enum ndr_err_code ndr_err;
2893         DATA_BLOB blob;
2894         struct svcctl_ChangeServiceConfig2A *r;
2895 
2896         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CHANGESERVICECONFIG2A];
2897 
2898         r = talloc(talloc_tos(), struct svcctl_ChangeServiceConfig2A);
2899         if (r == NULL) {
2900                 return false;
2901         }
2902 
2903         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2904                 talloc_free(r);
2905                 return false;
2906         }
2907 
2908         pull = ndr_pull_init_blob(&blob, r, NULL);
2909         if (pull == NULL) {
2910                 talloc_free(r);
2911                 return false;
2912         }
2913 
2914         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2915         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2916         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2917                 talloc_free(r);
2918                 return false;
2919         }
2920 
2921         if (DEBUGLEVEL >= 10) {
2922                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, r);
2923         }
2924 
2925         r->out.result = _svcctl_ChangeServiceConfig2A(p, r);
2926 
2927         if (p->rng_fault_state) {
2928                 talloc_free(r);
2929                 /* Return true here, srv_pipe_hnd.c will take care */
2930                 return true;
2931         }
2932 
2933         if (DEBUGLEVEL >= 10) {
2934                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, r);
2935         }
2936 
2937         push = ndr_push_init_ctx(r, NULL);
2938         if (push == NULL) {
2939                 talloc_free(r);
2940                 return false;
2941         }
2942 
2943         ndr_err = call->ndr_push(push, NDR_OUT, r);
2944         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2945                 talloc_free(r);
2946                 return false;
2947         }
2948 
2949         blob = ndr_push_blob(push);
2950         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2951                 talloc_free(r);
2952                 return false;
2953         }
2954 
2955         talloc_free(r);
2956 
2957         return true;
2958 }
2959 
2960 static bool api_svcctl_ChangeServiceConfig2W(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
2961 {
2962         const struct ndr_interface_call *call;
2963         struct ndr_pull *pull;
2964         struct ndr_push *push;
2965         enum ndr_err_code ndr_err;
2966         DATA_BLOB blob;
2967         struct svcctl_ChangeServiceConfig2W *r;
2968 
2969         call = &ndr_table_svcctl.calls[NDR_SVCCTL_CHANGESERVICECONFIG2W];
2970 
2971         r = talloc(talloc_tos(), struct svcctl_ChangeServiceConfig2W);
2972         if (r == NULL) {
2973                 return false;
2974         }
2975 
2976         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2977                 talloc_free(r);
2978                 return false;
2979         }
2980 
2981         pull = ndr_pull_init_blob(&blob, r, NULL);
2982         if (pull == NULL) {
2983                 talloc_free(r);
2984                 return false;
2985         }
2986 
2987         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2988         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2989         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2990                 talloc_free(r);
2991                 return false;
2992         }
2993 
2994         if (DEBUGLEVEL >= 10) {
2995                 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, r);
2996         }
2997 
2998         r->out.result = _svcctl_ChangeServiceConfig2W(p, r);
2999 
3000         if (p->rng_fault_state) {
3001                 talloc_free(r);
3002                 /* Return true here, srv_pipe_hnd.c will take care */
3003                 return true;
3004         }
3005 
3006         if (DEBUGLEVEL >= 10) {
3007                 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, r);
3008         }
3009 
3010         push = ndr_push_init_ctx(r, NULL);
3011         if (push == NULL) {
3012                 talloc_free(r);
3013                 return false;
3014         }
3015 
3016         ndr_err = call->ndr_push(push, NDR_OUT, r);
3017         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3018                 talloc_free(r);
3019                 return false;
3020         }
3021 
3022         blob = ndr_push_blob(push);
3023         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3024                 talloc_free(r);
3025                 return false;
3026         }
3027 
3028         talloc_free(r);
3029 
3030         return true;
3031 }
3032 
3033 static bool api_svcctl_QueryServiceConfig2A(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3034 {
3035         const struct ndr_interface_call *call;
3036         struct ndr_pull *pull;
3037         struct ndr_push *push;
3038         enum ndr_err_code ndr_err;
3039         DATA_BLOB blob;
3040         struct svcctl_QueryServiceConfig2A *r;
3041 
3042         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICECONFIG2A];
3043 
3044         r = talloc(talloc_tos(), struct svcctl_QueryServiceConfig2A);
3045         if (r == NULL) {
3046                 return false;
3047         }
3048 
3049         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3050                 talloc_free(r);
3051                 return false;
3052         }
3053 
3054         pull = ndr_pull_init_blob(&blob, r, NULL);
3055         if (pull == NULL) {
3056                 talloc_free(r);
3057                 return false;
3058         }
3059 
3060         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3061         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3062         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3063                 talloc_free(r);
3064                 return false;
3065         }
3066 
3067         if (DEBUGLEVEL >= 10) {
3068                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2A, r);
3069         }
3070 
3071         ZERO_STRUCT(r->out);
3072         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
3073         if (r->out.buffer == NULL) {
3074                 talloc_free(r);
3075                 return false;
3076         }
3077 
3078         r->out.needed = talloc_zero(r, uint32_t);
3079         if (r->out.needed == NULL) {
3080                 talloc_free(r);
3081                 return false;
3082         }
3083 
3084         r->out.result = _svcctl_QueryServiceConfig2A(p, r);
3085 
3086         if (p->rng_fault_state) {
3087                 talloc_free(r);
3088                 /* Return true here, srv_pipe_hnd.c will take care */
3089                 return true;
3090         }
3091 
3092         if (DEBUGLEVEL >= 10) {
3093                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, r);
3094         }
3095 
3096         push = ndr_push_init_ctx(r, NULL);
3097         if (push == NULL) {
3098                 talloc_free(r);
3099                 return false;
3100         }
3101 
3102         ndr_err = call->ndr_push(push, NDR_OUT, r);
3103         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3104                 talloc_free(r);
3105                 return false;
3106         }
3107 
3108         blob = ndr_push_blob(push);
3109         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3110                 talloc_free(r);
3111                 return false;
3112         }
3113 
3114         talloc_free(r);
3115 
3116         return true;
3117 }
3118 
3119 static bool api_svcctl_QueryServiceConfig2W(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3120 {
3121         const struct ndr_interface_call *call;
3122         struct ndr_pull *pull;
3123         struct ndr_push *push;
3124         enum ndr_err_code ndr_err;
3125         DATA_BLOB blob;
3126         struct svcctl_QueryServiceConfig2W *r;
3127 
3128         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICECONFIG2W];
3129 
3130         r = talloc(talloc_tos(), struct svcctl_QueryServiceConfig2W);
3131         if (r == NULL) {
3132                 return false;
3133         }
3134 
3135         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3136                 talloc_free(r);
3137                 return false;
3138         }
3139 
3140         pull = ndr_pull_init_blob(&blob, r, NULL);
3141         if (pull == NULL) {
3142                 talloc_free(r);
3143                 return false;
3144         }
3145 
3146         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3147         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3148         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3149                 talloc_free(r);
3150                 return false;
3151         }
3152 
3153         if (DEBUGLEVEL >= 10) {
3154                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2W, r);
3155         }
3156 
3157         ZERO_STRUCT(r->out);
3158         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
3159         if (r->out.buffer == NULL) {
3160                 talloc_free(r);
3161                 return false;
3162         }
3163 
3164         r->out.needed = talloc_zero(r, uint32_t);
3165         if (r->out.needed == NULL) {
3166                 talloc_free(r);
3167                 return false;
3168         }
3169 
3170         r->out.result = _svcctl_QueryServiceConfig2W(p, r);
3171 
3172         if (p->rng_fault_state) {
3173                 talloc_free(r);
3174                 /* Return true here, srv_pipe_hnd.c will take care */
3175                 return true;
3176         }
3177 
3178         if (DEBUGLEVEL >= 10) {
3179                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, r);
3180         }
3181 
3182         push = ndr_push_init_ctx(r, NULL);
3183         if (push == NULL) {
3184                 talloc_free(r);
3185                 return false;
3186         }
3187 
3188         ndr_err = call->ndr_push(push, NDR_OUT, r);
3189         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3190                 talloc_free(r);
3191                 return false;
3192         }
3193 
3194         blob = ndr_push_blob(push);
3195         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3196                 talloc_free(r);
3197                 return false;
3198         }
3199 
3200         talloc_free(r);
3201 
3202         return true;
3203 }
3204 
3205 static bool api_svcctl_QueryServiceStatusEx(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3206 {
3207         const struct ndr_interface_call *call;
3208         struct ndr_pull *pull;
3209         struct ndr_push *push;
3210         enum ndr_err_code ndr_err;
3211         DATA_BLOB blob;
3212         struct svcctl_QueryServiceStatusEx *r;
3213 
3214         call = &ndr_table_svcctl.calls[NDR_SVCCTL_QUERYSERVICESTATUSEX];
3215 
3216         r = talloc(talloc_tos(), struct svcctl_QueryServiceStatusEx);
3217         if (r == NULL) {
3218                 return false;
3219         }
3220 
3221         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3222                 talloc_free(r);
3223                 return false;
3224         }
3225 
3226         pull = ndr_pull_init_blob(&blob, r, NULL);
3227         if (pull == NULL) {
3228                 talloc_free(r);
3229                 return false;
3230         }
3231 
3232         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3233         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3234         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3235                 talloc_free(r);
3236                 return false;
3237         }
3238 
3239         if (DEBUGLEVEL >= 10) {
3240                 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, r);
3241         }
3242 
3243         ZERO_STRUCT(r->out);
3244         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.offered);
3245         if (r->out.buffer == NULL) {
3246                 talloc_free(r);
3247                 return false;
3248         }
3249 
3250         r->out.needed = talloc_zero(r, uint32_t);
3251         if (r->out.needed == NULL) {
3252                 talloc_free(r);
3253                 return false;
3254         }
3255 
3256         r->out.result = _svcctl_QueryServiceStatusEx(p, r);
3257 
3258         if (p->rng_fault_state) {
3259                 talloc_free(r);
3260                 /* Return true here, srv_pipe_hnd.c will take care */
3261                 return true;
3262         }
3263 
3264         if (DEBUGLEVEL >= 10) {
3265                 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, r);
3266         }
3267 
3268         push = ndr_push_init_ctx(r, NULL);
3269         if (push == NULL) {
3270                 talloc_free(r);
3271                 return false;
3272         }
3273 
3274         ndr_err = call->ndr_push(push, NDR_OUT, r);
3275         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3276                 talloc_free(r);
3277                 return false;
3278         }
3279 
3280         blob = ndr_push_blob(push);
3281         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3282                 talloc_free(r);
3283                 return false;
3284         }
3285 
3286         talloc_free(r);
3287 
3288         return true;
3289 }
3290 
3291 static bool api_EnumServicesStatusExA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3292 {
3293         const struct ndr_interface_call *call;
3294         struct ndr_pull *pull;
3295         struct ndr_push *push;
3296         enum ndr_err_code ndr_err;
3297         DATA_BLOB blob;
3298         struct EnumServicesStatusExA *r;
3299 
3300         call = &ndr_table_svcctl.calls[NDR_ENUMSERVICESSTATUSEXA];
3301 
3302         r = talloc(talloc_tos(), struct EnumServicesStatusExA);
3303         if (r == NULL) {
3304                 return false;
3305         }
3306 
3307         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3308                 talloc_free(r);
3309                 return false;
3310         }
3311 
3312         pull = ndr_pull_init_blob(&blob, r, NULL);
3313         if (pull == NULL) {
3314                 talloc_free(r);
3315                 return false;
3316         }
3317 
3318         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3319         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3320         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3321                 talloc_free(r);
3322                 return false;
3323         }
3324 
3325         if (DEBUGLEVEL >= 10) {
3326                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExA, r);
3327         }
3328 
3329         ZERO_STRUCT(r->out);
3330         r->out.resume_handle = r->in.resume_handle;
3331         r->out.services = talloc_zero_array(r, uint8_t, r->in.offered);
3332         if (r->out.services == NULL) {
3333                 talloc_free(r);
3334                 return false;
3335         }
3336 
3337         r->out.needed = talloc_zero(r, uint32_t);
3338         if (r->out.needed == NULL) {
3339                 talloc_free(r);
3340                 return false;
3341         }
3342 
3343         r->out.service_returned = talloc_zero(r, uint32_t);
3344         if (r->out.service_returned == NULL) {
3345                 talloc_free(r);
3346                 return false;
3347         }
3348 
3349         r->out.group_name = talloc_zero(r, const char *);
3350         if (r->out.group_name == NULL) {
3351                 talloc_free(r);
3352                 return false;
3353         }
3354 
3355         r->out.result = _EnumServicesStatusExA(p, r);
3356 
3357         if (p->rng_fault_state) {
3358                 talloc_free(r);
3359                 /* Return true here, srv_pipe_hnd.c will take care */
3360                 return true;
3361         }
3362 
3363         if (DEBUGLEVEL >= 10) {
3364                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, r);
3365         }
3366 
3367         push = ndr_push_init_ctx(r, NULL);
3368         if (push == NULL) {
3369                 talloc_free(r);
3370                 return false;
3371         }
3372 
3373         ndr_err = call->ndr_push(push, NDR_OUT, r);
3374         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3375                 talloc_free(r);
3376                 return false;
3377         }
3378 
3379         blob = ndr_push_blob(push);
3380         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3381                 talloc_free(r);
3382                 return false;
3383         }
3384 
3385         talloc_free(r);
3386 
3387         return true;
3388 }
3389 
3390 static bool api_EnumServicesStatusExW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3391 {
3392         const struct ndr_interface_call *call;
3393         struct ndr_pull *pull;
3394         struct ndr_push *push;
3395         enum ndr_err_code ndr_err;
3396         DATA_BLOB blob;
3397         struct EnumServicesStatusExW *r;
3398 
3399         call = &ndr_table_svcctl.calls[NDR_ENUMSERVICESSTATUSEXW];
3400 
3401         r = talloc(talloc_tos(), struct EnumServicesStatusExW);
3402         if (r == NULL) {
3403                 return false;
3404         }
3405 
3406         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3407                 talloc_free(r);
3408                 return false;
3409         }
3410 
3411         pull = ndr_pull_init_blob(&blob, r, NULL);
3412         if (pull == NULL) {
3413                 talloc_free(r);
3414                 return false;
3415         }
3416 
3417         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3418         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3419         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3420                 talloc_free(r);
3421                 return false;
3422         }
3423 
3424         if (DEBUGLEVEL >= 10) {
3425                 NDR_PRINT_IN_DEBUG(EnumServicesStatusExW, r);
3426         }
3427 
3428         ZERO_STRUCT(r->out);
3429         r->out.resume_handle = r->in.resume_handle;
3430         r->out.services = talloc_zero_array(r, uint8_t, r->in.offered);
3431         if (r->out.services == NULL) {
3432                 talloc_free(r);
3433                 return false;
3434         }
3435 
3436         r->out.needed = talloc_zero(r, uint32_t);
3437         if (r->out.needed == NULL) {
3438                 talloc_free(r);
3439                 return false;
3440         }
3441 
3442         r->out.service_returned = talloc_zero(r, uint32_t);
3443         if (r->out.service_returned == NULL) {
3444                 talloc_free(r);
3445                 return false;
3446         }
3447 
3448         r->out.result = _EnumServicesStatusExW(p, r);
3449 
3450         if (p->rng_fault_state) {
3451                 talloc_free(r);
3452                 /* Return true here, srv_pipe_hnd.c will take care */
3453                 return true;
3454         }
3455 
3456         if (DEBUGLEVEL >= 10) {
3457                 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, r);
3458         }
3459 
3460         push = ndr_push_init_ctx(r, NULL);
3461         if (push == NULL) {
3462                 talloc_free(r);
3463                 return false;
3464         }
3465 
3466         ndr_err = call->ndr_push(push, NDR_OUT, r);
3467         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3468                 talloc_free(r);
3469                 return false;
3470         }
3471 
3472         blob = ndr_push_blob(push);
3473         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3474                 talloc_free(r);
3475                 return false;
3476         }
3477 
3478         talloc_free(r);
3479 
3480         return true;
3481 }
3482 
3483 static bool api_svcctl_SCSendTSMessage(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
3484 {
3485         const struct ndr_interface_call *call;
3486         struct ndr_pull *pull;
3487         struct ndr_push *push;
3488         enum ndr_err_code ndr_err;
3489         DATA_BLOB blob;
3490         struct svcctl_SCSendTSMessage *r;
3491 
3492         call = &ndr_table_svcctl.calls[NDR_SVCCTL_SCSENDTSMESSAGE];
3493 
3494         r = talloc(talloc_tos(), struct svcctl_SCSendTSMessage);
3495         if (r == NULL) {
3496                 return false;
3497         }
3498 
3499         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3500                 talloc_free(r);
3501                 return false;
3502         }
3503 
3504         pull = ndr_pull_init_blob(&blob, r, NULL);
3505         if (pull == NULL) {
3506                 talloc_free(r);
3507                 return false;
3508         }
3509 
3510         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3511         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3512         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3513                 talloc_free(r);
3514                 return false;
3515         }
3516 
3517         if (DEBUGLEVEL >= 10) {
3518                 NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, r);
3519         }
3520 
3521         r->out.result = _svcctl_SCSendTSMessage(p, r);
3522 
3523         if (p->rng_fault_state) {
3524                 talloc_free(r);
3525                 /* Return true here, srv_pipe_hnd.c will take care */
3526                 return true;
3527         }
3528 
3529         if (DEBUGLEVEL >= 10) {
3530                 NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, r);
3531         }
3532 
3533         push = ndr_push_init_ctx(r, NULL);
3534         if (push == NULL) {
3535                 talloc_free(r);
3536                 return false;
3537         }
3538 
3539         ndr_err = call->ndr_push(push, NDR_OUT, r);
3540         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3541                 talloc_free(r);
3542                 return false;
3543         }
3544 
3545         blob = ndr_push_blob(push);
3546         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3547                 talloc_free(r);
3548                 return false;
3549         }
3550 
3551         talloc_free(r);
3552 
3553         return true;
3554 }
3555 
3556 
3557 /* Tables */
3558 static struct api_struct api_svcctl_cmds[] = 
3559 {
3560         {"SVCCTL_CLOSESERVICEHANDLE", NDR_SVCCTL_CLOSESERVICEHANDLE, api_svcctl_CloseServiceHandle},
3561         {"SVCCTL_CONTROLSERVICE", NDR_SVCCTL_CONTROLSERVICE, api_svcctl_ControlService},
3562         {"SVCCTL_DELETESERVICE", NDR_SVCCTL_DELETESERVICE, api_svcctl_DeleteService},
3563         {"SVCCTL_LOCKSERVICEDATABASE", NDR_SVCCTL_LOCKSERVICEDATABASE, api_svcctl_LockServiceDatabase},
3564         {"SVCCTL_QUERYSERVICEOBJECTSECURITY", NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY, api_svcctl_QueryServiceObjectSecurity},
3565         {"SVCCTL_SETSERVICEOBJECTSECURITY", NDR_SVCCTL_SETSERVICEOBJECTSECURITY, api_svcctl_SetServiceObjectSecurity},
3566         {"SVCCTL_QUERYSERVICESTATUS", NDR_SVCCTL_QUERYSERVICESTATUS, api_svcctl_QueryServiceStatus},
3567         {"SVCCTL_SETSERVICESTATUS", NDR_SVCCTL_SETSERVICESTATUS, api_svcctl_SetServiceStatus},
3568         {"SVCCTL_UNLOCKSERVICEDATABASE", NDR_SVCCTL_UNLOCKSERVICEDATABASE, api_svcctl_UnlockServiceDatabase},
3569         {"SVCCTL_NOTIFYBOOTCONFIGSTATUS", NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS, api_svcctl_NotifyBootConfigStatus},
3570         {"SVCCTL_SCSETSERVICEBITSW", NDR_SVCCTL_SCSETSERVICEBITSW, api_svcctl_SCSetServiceBitsW},
3571         {"SVCCTL_CHANGESERVICECONFIGW", NDR_SVCCTL_CHANGESERVICECONFIGW, api_svcctl_ChangeServiceConfigW},
3572         {"SVCCTL_CREATESERVICEW", NDR_SVCCTL_CREATESERVICEW, api_svcctl_CreateServiceW},
3573         {"SVCCTL_ENUMDEPENDENTSERVICESW", NDR_SVCCTL_ENUMDEPENDENTSERVICESW, api_svcctl_EnumDependentServicesW},
3574         {"SVCCTL_ENUMSERVICESSTATUSW", NDR_SVCCTL_ENUMSERVICESSTATUSW, api_svcctl_EnumServicesStatusW},
3575         {"SVCCTL_OPENSCMANAGERW", NDR_SVCCTL_OPENSCMANAGERW, api_svcctl_OpenSCManagerW},
3576         {"SVCCTL_OPENSERVICEW", NDR_SVCCTL_OPENSERVICEW, api_svcctl_OpenServiceW},
3577         {"SVCCTL_QUERYSERVICECONFIGW", NDR_SVCCTL_QUERYSERVICECONFIGW, api_svcctl_QueryServiceConfigW},
3578         {"SVCCTL_QUERYSERVICELOCKSTATUSW", NDR_SVCCTL_QUERYSERVICELOCKSTATUSW, api_svcctl_QueryServiceLockStatusW},
3579         {"SVCCTL_STARTSERVICEW", NDR_SVCCTL_STARTSERVICEW, api_svcctl_StartServiceW},
3580         {"SVCCTL_GETSERVICEDISPLAYNAMEW", NDR_SVCCTL_GETSERVICEDISPLAYNAMEW, api_svcctl_GetServiceDisplayNameW},
3581         {"SVCCTL_GETSERVICEKEYNAMEW", NDR_SVCCTL_GETSERVICEKEYNAMEW, api_svcctl_GetServiceKeyNameW},
3582         {"SVCCTL_SCSETSERVICEBITSA", NDR_SVCCTL_SCSETSERVICEBITSA, api_svcctl_SCSetServiceBitsA},
3583         {"SVCCTL_CHANGESERVICECONFIGA", NDR_SVCCTL_CHANGESERVICECONFIGA, api_svcctl_ChangeServiceConfigA},
3584         {"SVCCTL_CREATESERVICEA", NDR_SVCCTL_CREATESERVICEA, api_svcctl_CreateServiceA},
3585         {"SVCCTL_ENUMDEPENDENTSERVICESA", NDR_SVCCTL_ENUMDEPENDENTSERVICESA, api_svcctl_EnumDependentServicesA},
3586         {"SVCCTL_ENUMSERVICESSTATUSA", NDR_SVCCTL_ENUMSERVICESSTATUSA, api_svcctl_EnumServicesStatusA},
3587         {"SVCCTL_OPENSCMANAGERA", NDR_SVCCTL_OPENSCMANAGERA, api_svcctl_OpenSCManagerA},
3588         {"SVCCTL_OPENSERVICEA", NDR_SVCCTL_OPENSERVICEA, api_svcctl_OpenServiceA},
3589         {"SVCCTL_QUERYSERVICECONFIGA", NDR_SVCCTL_QUERYSERVICECONFIGA, api_svcctl_QueryServiceConfigA},
3590         {"SVCCTL_QUERYSERVICELOCKSTATUSA", NDR_SVCCTL_QUERYSERVICELOCKSTATUSA, api_svcctl_QueryServiceLockStatusA},
3591         {"SVCCTL_STARTSERVICEA", NDR_SVCCTL_STARTSERVICEA, api_svcctl_StartServiceA},
3592         {"SVCCTL_GETSERVICEDISPLAYNAMEA", NDR_SVCCTL_GETSERVICEDISPLAYNAMEA, api_svcctl_GetServiceDisplayNameA},
3593         {"SVCCTL_GETSERVICEKEYNAMEA", NDR_SVCCTL_GETSERVICEKEYNAMEA, api_svcctl_GetServiceKeyNameA},
3594         {"SVCCTL_GETCURRENTGROUPESTATEW", NDR_SVCCTL_GETCURRENTGROUPESTATEW, api_svcctl_GetCurrentGroupeStateW},
3595         {"SVCCTL_ENUMSERVICEGROUPW", NDR_SVCCTL_ENUMSERVICEGROUPW, api_svcctl_EnumServiceGroupW},
3596         {"SVCCTL_CHANGESERVICECONFIG2A", NDR_SVCCTL_CHANGESERVICECONFIG2A, api_svcctl_ChangeServiceConfig2A},
3597         {"SVCCTL_CHANGESERVICECONFIG2W", NDR_SVCCTL_CHANGESERVICECONFIG2W, api_svcctl_ChangeServiceConfig2W},
3598         {"SVCCTL_QUERYSERVICECONFIG2A", NDR_SVCCTL_QUERYSERVICECONFIG2A, api_svcctl_QueryServiceConfig2A},
3599         {"SVCCTL_QUERYSERVICECONFIG2W", NDR_SVCCTL_QUERYSERVICECONFIG2W, api_svcctl_QueryServiceConfig2W},
3600         {"SVCCTL_QUERYSERVICESTATUSEX", NDR_SVCCTL_QUERYSERVICESTATUSEX, api_svcctl_QueryServiceStatusEx},
3601         {"ENUMSERVICESSTATUSEXA", NDR_ENUMSERVICESSTATUSEXA, api_EnumServicesStatusExA},
3602         {"ENUMSERVICESSTATUSEXW", NDR_ENUMSERVICESSTATUSEXW, api_EnumServicesStatusExW},
3603         {"SVCCTL_SCSENDTSMESSAGE", NDR_SVCCTL_SCSENDTSMESSAGE, api_svcctl_SCSendTSMessage},
3604 };
3605 
3606 void svcctl_get_pipe_fns(struct api_struct **fns, int *n_fns)
     /* [<][>][^][v][top][bottom][index][help] */
3607 {
3608         *fns = api_svcctl_cmds;
3609         *n_fns = sizeof(api_svcctl_cmds) / sizeof(struct api_struct);
3610 }
3611 
3612 NTSTATUS rpc_svcctl_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] */
3613 {
3614         if (cli->pipes_struct == NULL) {
3615                 return NT_STATUS_INVALID_PARAMETER;
3616         }
3617 
3618         switch (opnum)
3619         {
3620                 case NDR_SVCCTL_CLOSESERVICEHANDLE: {
3621                         struct svcctl_CloseServiceHandle *r = (struct svcctl_CloseServiceHandle *)_r;
3622                         ZERO_STRUCT(r->out);
3623                         r->out.handle = r->in.handle;
3624                         r->out.result = _svcctl_CloseServiceHandle(cli->pipes_struct, r);
3625                         return NT_STATUS_OK;
3626                 }
3627 
3628                 case NDR_SVCCTL_CONTROLSERVICE: {
3629                         struct svcctl_ControlService *r = (struct svcctl_ControlService *)_r;
3630                         ZERO_STRUCT(r->out);
3631                         r->out.service_status = talloc_zero(mem_ctx, struct SERVICE_STATUS);
3632                         if (r->out.service_status == NULL) {
3633                         return NT_STATUS_NO_MEMORY;
3634                         }
3635 
3636                         r->out.result = _svcctl_ControlService(cli->pipes_struct, r);
3637                         return NT_STATUS_OK;
3638                 }
3639 
3640                 case NDR_SVCCTL_DELETESERVICE: {
3641                         struct svcctl_DeleteService *r = (struct svcctl_DeleteService *)_r;
3642                         r->out.result = _svcctl_DeleteService(cli->pipes_struct, r);
3643                         return NT_STATUS_OK;
3644                 }
3645 
3646                 case NDR_SVCCTL_LOCKSERVICEDATABASE: {
3647                         struct svcctl_LockServiceDatabase *r = (struct svcctl_LockServiceDatabase *)_r;
3648                         ZERO_STRUCT(r->out);
3649                         r->out.lock = talloc_zero(mem_ctx, struct policy_handle);
3650                         if (r->out.lock == NULL) {
3651                         return NT_STATUS_NO_MEMORY;
3652                         }
3653 
3654                         r->out.result = _svcctl_LockServiceDatabase(cli->pipes_struct, r);
3655                         return NT_STATUS_OK;
3656                 }
3657 
3658                 case NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY: {
3659                         struct svcctl_QueryServiceObjectSecurity *r = (struct svcctl_QueryServiceObjectSecurity *)_r;
3660                         ZERO_STRUCT(r->out);
3661                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
3662                         if (r->out.buffer == NULL) {
3663                         return NT_STATUS_NO_MEMORY;
3664                         }
3665 
3666                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3667                         if (r->out.needed == NULL) {
3668                         return NT_STATUS_NO_MEMORY;
3669                         }
3670 
3671                         r->out.result = _svcctl_QueryServiceObjectSecurity(cli->pipes_struct, r);
3672                         return NT_STATUS_OK;
3673                 }
3674 
3675                 case NDR_SVCCTL_SETSERVICEOBJECTSECURITY: {
3676                         struct svcctl_SetServiceObjectSecurity *r = (struct svcctl_SetServiceObjectSecurity *)_r;
3677                         r->out.result = _svcctl_SetServiceObjectSecurity(cli->pipes_struct, r);
3678                         return NT_STATUS_OK;
3679                 }
3680 
3681                 case NDR_SVCCTL_QUERYSERVICESTATUS: {
3682                         struct svcctl_QueryServiceStatus *r = (struct svcctl_QueryServiceStatus *)_r;
3683                         ZERO_STRUCT(r->out);
3684                         r->out.service_status = talloc_zero(mem_ctx, struct SERVICE_STATUS);
3685                         if (r->out.service_status == NULL) {
3686                         return NT_STATUS_NO_MEMORY;
3687                         }
3688 
3689                         r->out.result = _svcctl_QueryServiceStatus(cli->pipes_struct, r);
3690                         return NT_STATUS_OK;
3691                 }
3692 
3693                 case NDR_SVCCTL_SETSERVICESTATUS: {
3694                         struct svcctl_SetServiceStatus *r = (struct svcctl_SetServiceStatus *)_r;
3695                         r->out.result = _svcctl_SetServiceStatus(cli->pipes_struct, r);
3696                         return NT_STATUS_OK;
3697                 }
3698 
3699                 case NDR_SVCCTL_UNLOCKSERVICEDATABASE: {
3700                         struct svcctl_UnlockServiceDatabase *r = (struct svcctl_UnlockServiceDatabase *)_r;
3701                         ZERO_STRUCT(r->out);
3702                         r->out.lock = r->in.lock;
3703                         r->out.result = _svcctl_UnlockServiceDatabase(cli->pipes_struct, r);
3704                         return NT_STATUS_OK;
3705                 }
3706 
3707                 case NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS: {
3708                         struct svcctl_NotifyBootConfigStatus *r = (struct svcctl_NotifyBootConfigStatus *)_r;
3709                         r->out.result = _svcctl_NotifyBootConfigStatus(cli->pipes_struct, r);
3710                         return NT_STATUS_OK;
3711                 }
3712 
3713                 case NDR_SVCCTL_SCSETSERVICEBITSW: {
3714                         struct svcctl_SCSetServiceBitsW *r = (struct svcctl_SCSetServiceBitsW *)_r;
3715                         r->out.result = _svcctl_SCSetServiceBitsW(cli->pipes_struct, r);
3716                         return NT_STATUS_OK;
3717                 }
3718 
3719                 case NDR_SVCCTL_CHANGESERVICECONFIGW: {
3720                         struct svcctl_ChangeServiceConfigW *r = (struct svcctl_ChangeServiceConfigW *)_r;
3721                         ZERO_STRUCT(r->out);
3722                         r->out.tag_id = talloc_zero(mem_ctx, uint32_t);
3723                         if (r->out.tag_id == NULL) {
3724                         return NT_STATUS_NO_MEMORY;
3725                         }
3726 
3727                         r->out.result = _svcctl_ChangeServiceConfigW(cli->pipes_struct, r);
3728                         return NT_STATUS_OK;
3729                 }
3730 
3731                 case NDR_SVCCTL_CREATESERVICEW: {
3732                         struct svcctl_CreateServiceW *r = (struct svcctl_CreateServiceW *)_r;
3733                         ZERO_STRUCT(r->out);
3734                         r->out.TagId = r->in.TagId;
3735                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3736                         if (r->out.handle == NULL) {
3737                         return NT_STATUS_NO_MEMORY;
3738                         }
3739 
3740                         r->out.result = _svcctl_CreateServiceW(cli->pipes_struct, r);
3741                         return NT_STATUS_OK;
3742                 }
3743 
3744                 case NDR_SVCCTL_ENUMDEPENDENTSERVICESW: {
3745                         struct svcctl_EnumDependentServicesW *r = (struct svcctl_EnumDependentServicesW *)_r;
3746                         ZERO_STRUCT(r->out);
3747                         r->out.service_status = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
3748                         if (r->out.service_status == NULL) {
3749                         return NT_STATUS_NO_MEMORY;
3750                         }
3751 
3752                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3753                         if (r->out.needed == NULL) {
3754                         return NT_STATUS_NO_MEMORY;
3755                         }
3756 
3757                         r->out.services_returned = talloc_zero(mem_ctx, uint32_t);
3758                         if (r->out.services_returned == NULL) {
3759                         return NT_STATUS_NO_MEMORY;
3760                         }
3761 
3762                         r->out.result = _svcctl_EnumDependentServicesW(cli->pipes_struct, r);
3763                         return NT_STATUS_OK;
3764                 }
3765 
3766                 case NDR_SVCCTL_ENUMSERVICESSTATUSW: {
3767                         struct svcctl_EnumServicesStatusW *r = (struct svcctl_EnumServicesStatusW *)_r;
3768                         ZERO_STRUCT(r->out);
3769                         r->out.resume_handle = r->in.resume_handle;
3770                         r->out.service = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
3771                         if (r->out.service == NULL) {
3772                         return NT_STATUS_NO_MEMORY;
3773                         }
3774 
3775                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3776                         if (r->out.needed == NULL) {
3777                         return NT_STATUS_NO_MEMORY;
3778                         }
3779 
3780                         r->out.services_returned = talloc_zero(mem_ctx, uint32_t);
3781                         if (r->out.services_returned == NULL) {
3782                         return NT_STATUS_NO_MEMORY;
3783                         }
3784 
3785                         r->out.result = _svcctl_EnumServicesStatusW(cli->pipes_struct, r);
3786                         return NT_STATUS_OK;
3787                 }
3788 
3789                 case NDR_SVCCTL_OPENSCMANAGERW: {
3790                         struct svcctl_OpenSCManagerW *r = (struct svcctl_OpenSCManagerW *)_r;
3791                         ZERO_STRUCT(r->out);
3792                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3793                         if (r->out.handle == NULL) {
3794                         return NT_STATUS_NO_MEMORY;
3795                         }
3796 
3797                         r->out.result = _svcctl_OpenSCManagerW(cli->pipes_struct, r);
3798                         return NT_STATUS_OK;
3799                 }
3800 
3801                 case NDR_SVCCTL_OPENSERVICEW: {
3802                         struct svcctl_OpenServiceW *r = (struct svcctl_OpenServiceW *)_r;
3803                         ZERO_STRUCT(r->out);
3804                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3805                         if (r->out.handle == NULL) {
3806                         return NT_STATUS_NO_MEMORY;
3807                         }
3808 
3809                         r->out.result = _svcctl_OpenServiceW(cli->pipes_struct, r);
3810                         return NT_STATUS_OK;
3811                 }
3812 
3813                 case NDR_SVCCTL_QUERYSERVICECONFIGW: {
3814                         struct svcctl_QueryServiceConfigW *r = (struct svcctl_QueryServiceConfigW *)_r;
3815                         ZERO_STRUCT(r->out);
3816                         r->out.query = talloc_zero(mem_ctx, struct QUERY_SERVICE_CONFIG);
3817                         if (r->out.query == NULL) {
3818                         return NT_STATUS_NO_MEMORY;
3819                         }
3820 
3821                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3822                         if (r->out.needed == NULL) {
3823                         return NT_STATUS_NO_MEMORY;
3824                         }
3825 
3826                         r->out.result = _svcctl_QueryServiceConfigW(cli->pipes_struct, r);
3827                         return NT_STATUS_OK;
3828                 }
3829 
3830                 case NDR_SVCCTL_QUERYSERVICELOCKSTATUSW: {
3831                         struct svcctl_QueryServiceLockStatusW *r = (struct svcctl_QueryServiceLockStatusW *)_r;
3832                         ZERO_STRUCT(r->out);
3833                         r->out.lock_status = talloc_zero(mem_ctx, struct SERVICE_LOCK_STATUS);
3834                         if (r->out.lock_status == NULL) {
3835                         return NT_STATUS_NO_MEMORY;
3836                         }
3837 
3838                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3839                         if (r->out.needed == NULL) {
3840                         return NT_STATUS_NO_MEMORY;
3841                         }
3842 
3843                         r->out.result = _svcctl_QueryServiceLockStatusW(cli->pipes_struct, r);
3844                         return NT_STATUS_OK;
3845                 }
3846 
3847                 case NDR_SVCCTL_STARTSERVICEW: {
3848                         struct svcctl_StartServiceW *r = (struct svcctl_StartServiceW *)_r;
3849                         r->out.result = _svcctl_StartServiceW(cli->pipes_struct, r);
3850                         return NT_STATUS_OK;
3851                 }
3852 
3853                 case NDR_SVCCTL_GETSERVICEDISPLAYNAMEW: {
3854                         struct svcctl_GetServiceDisplayNameW *r = (struct svcctl_GetServiceDisplayNameW *)_r;
3855                         ZERO_STRUCT(r->out);
3856                         r->out.display_name_length = r->in.display_name_length;
3857                         r->out.display_name = talloc_zero(mem_ctx, const char *);
3858                         if (r->out.display_name == NULL) {
3859                         return NT_STATUS_NO_MEMORY;
3860                         }
3861 
3862                         r->out.result = _svcctl_GetServiceDisplayNameW(cli->pipes_struct, r);
3863                         return NT_STATUS_OK;
3864                 }
3865 
3866                 case NDR_SVCCTL_GETSERVICEKEYNAMEW: {
3867                         struct svcctl_GetServiceKeyNameW *r = (struct svcctl_GetServiceKeyNameW *)_r;
3868                         ZERO_STRUCT(r->out);
3869                         r->out.display_name_length = r->in.display_name_length;
3870                         r->out.key_name = talloc_zero(mem_ctx, const char *);
3871                         if (r->out.key_name == NULL) {
3872                         return NT_STATUS_NO_MEMORY;
3873                         }
3874 
3875                         r->out.result = _svcctl_GetServiceKeyNameW(cli->pipes_struct, r);
3876                         return NT_STATUS_OK;
3877                 }
3878 
3879                 case NDR_SVCCTL_SCSETSERVICEBITSA: {
3880                         struct svcctl_SCSetServiceBitsA *r = (struct svcctl_SCSetServiceBitsA *)_r;
3881                         r->out.result = _svcctl_SCSetServiceBitsA(cli->pipes_struct, r);
3882                         return NT_STATUS_OK;
3883                 }
3884 
3885                 case NDR_SVCCTL_CHANGESERVICECONFIGA: {
3886                         struct svcctl_ChangeServiceConfigA *r = (struct svcctl_ChangeServiceConfigA *)_r;
3887                         ZERO_STRUCT(r->out);
3888                         r->out.tag_id = talloc_zero(mem_ctx, uint32_t);
3889                         if (r->out.tag_id == NULL) {
3890                         return NT_STATUS_NO_MEMORY;
3891                         }
3892 
3893                         r->out.result = _svcctl_ChangeServiceConfigA(cli->pipes_struct, r);
3894                         return NT_STATUS_OK;
3895                 }
3896 
3897                 case NDR_SVCCTL_CREATESERVICEA: {
3898                         struct svcctl_CreateServiceA *r = (struct svcctl_CreateServiceA *)_r;
3899                         ZERO_STRUCT(r->out);
3900                         r->out.TagId = talloc_zero(mem_ctx, uint32_t);
3901                         if (r->out.TagId == NULL) {
3902                         return NT_STATUS_NO_MEMORY;
3903                         }
3904 
3905                         r->out.result = _svcctl_CreateServiceA(cli->pipes_struct, r);
3906                         return NT_STATUS_OK;
3907                 }
3908 
3909                 case NDR_SVCCTL_ENUMDEPENDENTSERVICESA: {
3910                         struct svcctl_EnumDependentServicesA *r = (struct svcctl_EnumDependentServicesA *)_r;
3911                         ZERO_STRUCT(r->out);
3912                         r->out.service_status = talloc_zero(mem_ctx, struct ENUM_SERVICE_STATUSA);
3913                         if (r->out.service_status == NULL) {
3914                         return NT_STATUS_NO_MEMORY;
3915                         }
3916 
3917                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3918                         if (r->out.needed == NULL) {
3919                         return NT_STATUS_NO_MEMORY;
3920                         }
3921 
3922                         r->out.services_returned = talloc_zero(mem_ctx, uint32_t);
3923                         if (r->out.services_returned == NULL) {
3924                         return NT_STATUS_NO_MEMORY;
3925                         }
3926 
3927                         r->out.result = _svcctl_EnumDependentServicesA(cli->pipes_struct, r);
3928                         return NT_STATUS_OK;
3929                 }
3930 
3931                 case NDR_SVCCTL_ENUMSERVICESSTATUSA: {
3932                         struct svcctl_EnumServicesStatusA *r = (struct svcctl_EnumServicesStatusA *)_r;
3933                         ZERO_STRUCT(r->out);
3934                         r->out.resume_handle = r->in.resume_handle;
3935                         r->out.service = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
3936                         if (r->out.service == NULL) {
3937                         return NT_STATUS_NO_MEMORY;
3938                         }
3939 
3940                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3941                         if (r->out.needed == NULL) {
3942                         return NT_STATUS_NO_MEMORY;
3943                         }
3944 
3945                         r->out.services_returned = talloc_zero(mem_ctx, uint32_t);
3946                         if (r->out.services_returned == NULL) {
3947                         return NT_STATUS_NO_MEMORY;
3948                         }
3949 
3950                         r->out.result = _svcctl_EnumServicesStatusA(cli->pipes_struct, r);
3951                         return NT_STATUS_OK;
3952                 }
3953 
3954                 case NDR_SVCCTL_OPENSCMANAGERA: {
3955                         struct svcctl_OpenSCManagerA *r = (struct svcctl_OpenSCManagerA *)_r;
3956                         ZERO_STRUCT(r->out);
3957                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3958                         if (r->out.handle == NULL) {
3959                         return NT_STATUS_NO_MEMORY;
3960                         }
3961 
3962                         r->out.result = _svcctl_OpenSCManagerA(cli->pipes_struct, r);
3963                         return NT_STATUS_OK;
3964                 }
3965 
3966                 case NDR_SVCCTL_OPENSERVICEA: {
3967                         struct svcctl_OpenServiceA *r = (struct svcctl_OpenServiceA *)_r;
3968                         r->out.result = _svcctl_OpenServiceA(cli->pipes_struct, r);
3969                         return NT_STATUS_OK;
3970                 }
3971 
3972                 case NDR_SVCCTL_QUERYSERVICECONFIGA: {
3973                         struct svcctl_QueryServiceConfigA *r = (struct svcctl_QueryServiceConfigA *)_r;
3974                         ZERO_STRUCT(r->out);
3975                         r->out.query = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
3976                         if (r->out.query == NULL) {
3977                         return NT_STATUS_NO_MEMORY;
3978                         }
3979 
3980                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3981                         if (r->out.needed == NULL) {
3982                         return NT_STATUS_NO_MEMORY;
3983                         }
3984 
3985                         r->out.result = _svcctl_QueryServiceConfigA(cli->pipes_struct, r);
3986                         return NT_STATUS_OK;
3987                 }
3988 
3989                 case NDR_SVCCTL_QUERYSERVICELOCKSTATUSA: {
3990                         struct svcctl_QueryServiceLockStatusA *r = (struct svcctl_QueryServiceLockStatusA *)_r;
3991                         ZERO_STRUCT(r->out);
3992                         r->out.lock_status = talloc_zero(mem_ctx, struct SERVICE_LOCK_STATUS);
3993                         if (r->out.lock_status == NULL) {
3994                         return NT_STATUS_NO_MEMORY;
3995                         }
3996 
3997                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
3998                         if (r->out.needed == NULL) {
3999                         return NT_STATUS_NO_MEMORY;
4000                         }
4001 
4002                         r->out.result = _svcctl_QueryServiceLockStatusA(cli->pipes_struct, r);
4003                         return NT_STATUS_OK;
4004                 }
4005 
4006                 case NDR_SVCCTL_STARTSERVICEA: {
4007                         struct svcctl_StartServiceA *r = (struct svcctl_StartServiceA *)_r;
4008                         r->out.result = _svcctl_StartServiceA(cli->pipes_struct, r);
4009                         return NT_STATUS_OK;
4010                 }
4011 
4012                 case NDR_SVCCTL_GETSERVICEDISPLAYNAMEA: {
4013                         struct svcctl_GetServiceDisplayNameA *r = (struct svcctl_GetServiceDisplayNameA *)_r;
4014                         ZERO_STRUCT(r->out);
4015                         r->out.display_name_length = r->in.display_name_length;
4016                         r->out.display_name = talloc_zero(mem_ctx, const char *);
4017                         if (r->out.display_name == NULL) {
4018                         return NT_STATUS_NO_MEMORY;
4019                         }
4020 
4021                         r->out.result = _svcctl_GetServiceDisplayNameA(cli->pipes_struct, r);
4022                         return NT_STATUS_OK;
4023                 }
4024 
4025                 case NDR_SVCCTL_GETSERVICEKEYNAMEA: {
4026                         struct svcctl_GetServiceKeyNameA *r = (struct svcctl_GetServiceKeyNameA *)_r;
4027                         ZERO_STRUCT(r->out);
4028                         r->out.display_name_length = r->in.display_name_length;
4029                         r->out.key_name = talloc_zero(mem_ctx, const char *);
4030                         if (r->out.key_name == NULL) {
4031                         return NT_STATUS_NO_MEMORY;
4032                         }
4033 
4034                         r->out.result = _svcctl_GetServiceKeyNameA(cli->pipes_struct, r);
4035                         return NT_STATUS_OK;
4036                 }
4037 
4038                 case NDR_SVCCTL_GETCURRENTGROUPESTATEW: {
4039                         struct svcctl_GetCurrentGroupeStateW *r = (struct svcctl_GetCurrentGroupeStateW *)_r;
4040                         r->out.result = _svcctl_GetCurrentGroupeStateW(cli->pipes_struct, r);
4041                         return NT_STATUS_OK;
4042                 }
4043 
4044                 case NDR_SVCCTL_ENUMSERVICEGROUPW: {
4045                         struct svcctl_EnumServiceGroupW *r = (struct svcctl_EnumServiceGroupW *)_r;
4046                         r->out.result = _svcctl_EnumServiceGroupW(cli->pipes_struct, r);
4047                         return NT_STATUS_OK;
4048                 }
4049 
4050                 case NDR_SVCCTL_CHANGESERVICECONFIG2A: {
4051                         struct svcctl_ChangeServiceConfig2A *r = (struct svcctl_ChangeServiceConfig2A *)_r;
4052                         r->out.result = _svcctl_ChangeServiceConfig2A(cli->pipes_struct, r);
4053                         return NT_STATUS_OK;
4054                 }
4055 
4056                 case NDR_SVCCTL_CHANGESERVICECONFIG2W: {
4057                         struct svcctl_ChangeServiceConfig2W *r = (struct svcctl_ChangeServiceConfig2W *)_r;
4058                         r->out.result = _svcctl_ChangeServiceConfig2W(cli->pipes_struct, r);
4059                         return NT_STATUS_OK;
4060                 }
4061 
4062                 case NDR_SVCCTL_QUERYSERVICECONFIG2A: {
4063                         struct svcctl_QueryServiceConfig2A *r = (struct svcctl_QueryServiceConfig2A *)_r;
4064                         ZERO_STRUCT(r->out);
4065                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
4066                         if (r->out.buffer == NULL) {
4067                         return NT_STATUS_NO_MEMORY;
4068                         }
4069 
4070                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
4071                         if (r->out.needed == NULL) {
4072                         return NT_STATUS_NO_MEMORY;
4073                         }
4074 
4075                         r->out.result = _svcctl_QueryServiceConfig2A(cli->pipes_struct, r);
4076                         return NT_STATUS_OK;
4077                 }
4078 
4079                 case NDR_SVCCTL_QUERYSERVICECONFIG2W: {
4080                         struct svcctl_QueryServiceConfig2W *r = (struct svcctl_QueryServiceConfig2W *)_r;
4081                         ZERO_STRUCT(r->out);
4082                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
4083                         if (r->out.buffer == NULL) {
4084                         return NT_STATUS_NO_MEMORY;
4085                         }
4086 
4087                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
4088                         if (r->out.needed == NULL) {
4089                         return NT_STATUS_NO_MEMORY;
4090                         }
4091 
4092                         r->out.result = _svcctl_QueryServiceConfig2W(cli->pipes_struct, r);
4093                         return NT_STATUS_OK;
4094                 }
4095 
4096                 case NDR_SVCCTL_QUERYSERVICESTATUSEX: {
4097                         struct svcctl_QueryServiceStatusEx *r = (struct svcctl_QueryServiceStatusEx *)_r;
4098                         ZERO_STRUCT(r->out);
4099                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
4100                         if (r->out.buffer == NULL) {
4101                         return NT_STATUS_NO_MEMORY;
4102                         }
4103 
4104                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
4105                         if (r->out.needed == NULL) {
4106                         return NT_STATUS_NO_MEMORY;
4107                         }
4108 
4109                         r->out.result = _svcctl_QueryServiceStatusEx(cli->pipes_struct, r);
4110                         return NT_STATUS_OK;
4111                 }
4112 
4113                 case NDR_ENUMSERVICESSTATUSEXA: {
4114                         struct EnumServicesStatusExA *r = (struct EnumServicesStatusExA *)_r;
4115                         ZERO_STRUCT(r->out);
4116                         r->out.resume_handle = r->in.resume_handle;
4117                         r->out.services = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
4118                         if (r->out.services == NULL) {
4119                         return NT_STATUS_NO_MEMORY;
4120                         }
4121 
4122                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
4123                         if (r->out.needed == NULL) {
4124                         return NT_STATUS_NO_MEMORY;
4125                         }
4126 
4127                         r->out.service_returned = talloc_zero(mem_ctx, uint32_t);
4128                         if (r->out.service_returned == NULL) {
4129                         return NT_STATUS_NO_MEMORY;
4130                         }
4131 
4132                         r->out.group_name = talloc_zero(mem_ctx, const char *);
4133                         if (r->out.group_name == NULL) {
4134                         return NT_STATUS_NO_MEMORY;
4135                         }
4136 
4137                         r->out.result = _EnumServicesStatusExA(cli->pipes_struct, r);
4138                         return NT_STATUS_OK;
4139                 }
4140 
4141                 case NDR_ENUMSERVICESSTATUSEXW: {
4142                         struct EnumServicesStatusExW *r = (struct EnumServicesStatusExW *)_r;
4143                         ZERO_STRUCT(r->out);
4144                         r->out.resume_handle = r->in.resume_handle;
4145                         r->out.services = talloc_zero_array(mem_ctx, uint8_t, r->in.offered);
4146                         if (r->out.services == NULL) {
4147                         return NT_STATUS_NO_MEMORY;
4148                         }
4149 
4150                         r->out.needed = talloc_zero(mem_ctx, uint32_t);
4151                         if (r->out.needed == NULL) {
4152                         return NT_STATUS_NO_MEMORY;
4153                         }
4154 
4155                         r->out.service_returned = talloc_zero(mem_ctx, uint32_t);
4156                         if (r->out.service_returned == NULL) {
4157                         return NT_STATUS_NO_MEMORY;
4158                         }
4159 
4160                         r->out.result = _EnumServicesStatusExW(cli->pipes_struct, r);
4161                         return NT_STATUS_OK;
4162                 }
4163 
4164                 case NDR_SVCCTL_SCSENDTSMESSAGE: {
4165                         struct svcctl_SCSendTSMessage *r = (struct svcctl_SCSendTSMessage *)_r;
4166                         r->out.result = _svcctl_SCSendTSMessage(cli->pipes_struct, r);
4167                         return NT_STATUS_OK;
4168                 }
4169 
4170                 default:
4171                         return NT_STATUS_NOT_IMPLEMENTED;
4172         }
4173 }
4174 
4175 NTSTATUS rpc_svcctl_init(void)
     /* [<][>][^][v][top][bottom][index][help] */
4176 {
4177         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "svcctl", "svcctl", &ndr_table_svcctl, api_svcctl_cmds, sizeof(api_svcctl_cmds) / sizeof(struct api_struct));
4178 }

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