source: branches/samba-3.5.x/librpc/gen_ndr/srv_svcctl.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 93.6 KB
Line 
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
9static bool api_svcctl_CloseServiceHandle(pipes_struct *p)
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
84static bool api_svcctl_ControlService(pipes_struct *p)
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
164static bool api_svcctl_DeleteService(pipes_struct *p)
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
237static bool api_svcctl_LockServiceDatabase(pipes_struct *p)
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
317static bool api_svcctl_QueryServiceObjectSecurity(pipes_struct *p)
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
403static bool api_svcctl_SetServiceObjectSecurity(pipes_struct *p)
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
476static bool api_svcctl_QueryServiceStatus(pipes_struct *p)
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
556static bool api_svcctl_SetServiceStatus(pipes_struct *p)
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
629static bool api_svcctl_UnlockServiceDatabase(pipes_struct *p)
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
704static bool api_svcctl_NotifyBootConfigStatus(pipes_struct *p)
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
777static bool api_svcctl_SCSetServiceBitsW(pipes_struct *p)
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
850static bool api_svcctl_ChangeServiceConfigW(pipes_struct *p)
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
930static bool api_svcctl_CreateServiceW(pipes_struct *p)
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
1011static bool api_svcctl_EnumDependentServicesW(pipes_struct *p)
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
1103static bool api_svcctl_EnumServicesStatusW(pipes_struct *p)
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
1196static bool api_svcctl_OpenSCManagerW(pipes_struct *p)
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
1276static bool api_svcctl_OpenServiceW(pipes_struct *p)
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
1356static bool api_svcctl_QueryServiceConfigW(pipes_struct *p)
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
1442static bool api_svcctl_QueryServiceLockStatusW(pipes_struct *p)
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
1528static bool api_svcctl_StartServiceW(pipes_struct *p)
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
1601static bool api_svcctl_GetServiceDisplayNameW(pipes_struct *p)
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
1682static bool api_svcctl_GetServiceKeyNameW(pipes_struct *p)
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
1763static bool api_svcctl_SCSetServiceBitsA(pipes_struct *p)
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
1836static bool api_svcctl_ChangeServiceConfigA(pipes_struct *p)
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
1916static bool api_svcctl_CreateServiceA(pipes_struct *p)
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
1996static bool api_svcctl_EnumDependentServicesA(pipes_struct *p)
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
2088static bool api_svcctl_EnumServicesStatusA(pipes_struct *p)
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
2181static bool api_svcctl_OpenSCManagerA(pipes_struct *p)
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
2261static bool api_svcctl_OpenServiceA(pipes_struct *p)
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
2334static bool api_svcctl_QueryServiceConfigA(pipes_struct *p)
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
2420static bool api_svcctl_QueryServiceLockStatusA(pipes_struct *p)
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
2506static bool api_svcctl_StartServiceA(pipes_struct *p)
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
2579static bool api_svcctl_GetServiceDisplayNameA(pipes_struct *p)
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
2660static bool api_svcctl_GetServiceKeyNameA(pipes_struct *p)
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
2741static bool api_svcctl_GetCurrentGroupeStateW(pipes_struct *p)
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
2814static bool api_svcctl_EnumServiceGroupW(pipes_struct *p)
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
2887static bool api_svcctl_ChangeServiceConfig2A(pipes_struct *p)
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
2960static bool api_svcctl_ChangeServiceConfig2W(pipes_struct *p)
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
3033static bool api_svcctl_QueryServiceConfig2A(pipes_struct *p)
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
3119static bool api_svcctl_QueryServiceConfig2W(pipes_struct *p)
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
3205static bool api_svcctl_QueryServiceStatusEx(pipes_struct *p)
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
3291static bool api_EnumServicesStatusExA(pipes_struct *p)
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
3390static bool api_EnumServicesStatusExW(pipes_struct *p)
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
3483static bool api_svcctl_SCSendTSMessage(pipes_struct *p)
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 */
3558static 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
3606void svcctl_get_pipe_fns(struct api_struct **fns, int *n_fns)
3607{
3608 *fns = api_svcctl_cmds;
3609 *n_fns = sizeof(api_svcctl_cmds) / sizeof(struct api_struct);
3610}
3611
3612NTSTATUS rpc_svcctl_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
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
4175NTSTATUS rpc_svcctl_init(void)
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}
Note: See TracBrowser for help on using the repository browser.