?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tevent: let tevent_loop_once() just run one fd event
[Samba/gbeck.git] / librpc / gen_ndr / cli_svcctl.c
blob4c013f52b3ea3b8ede35baeb497aabab0a280b5f
1 /*
2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "../librpc/gen_ndr/cli_svcctl.h"
8
9 NTSTATUS rpccli_svcctl_CloseServiceHandle(struct rpc_pipe_client *cli,
10 TALLOC_CTX *mem_ctx,
11 struct policy_handle *handle /* [in,out] [ref] */,
12 WERROR *werror)
13 {
14 struct svcctl_CloseServiceHandle r;
15 NTSTATUS status;
16
17 /* In parameters */
18 r.in.handle = handle;
19
20 if (DEBUGLEVEL >= 10) {
21 NDR_PRINT_IN_DEBUG(svcctl_CloseServiceHandle, &r);
22 }
23
24 status = cli->dispatch(cli,
25 mem_ctx,
26 &ndr_table_svcctl,
27 NDR_SVCCTL_CLOSESERVICEHANDLE,
28 &r);
29
30 if (!NT_STATUS_IS_OK(status)) {
31 return status;
32 }
33
34 if (DEBUGLEVEL >= 10) {
35 NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, &r);
36 }
37
38 if (NT_STATUS_IS_ERR(status)) {
39 return status;
40 }
41
42 /* Return variables */
43 *handle = *r.out.handle;
44
45 /* Return result */
46 if (werror) {
47 *werror = r.out.result;
48 }
49
50 return werror_to_ntstatus(r.out.result);
51 }
52
53 NTSTATUS rpccli_svcctl_ControlService(struct rpc_pipe_client *cli,
54 TALLOC_CTX *mem_ctx,
55 struct policy_handle *handle /* [in] [ref] */,
56 enum SERVICE_CONTROL control /* [in] */,
57 struct SERVICE_STATUS *service_status /* [out] [ref] */,
58 WERROR *werror)
59 {
60 struct svcctl_ControlService r;
61 NTSTATUS status;
62
63 /* In parameters */
64 r.in.handle = handle;
65 r.in.control = control;
66
67 if (DEBUGLEVEL >= 10) {
68 NDR_PRINT_IN_DEBUG(svcctl_ControlService, &r);
69 }
70
71 status = cli->dispatch(cli,
72 mem_ctx,
73 &ndr_table_svcctl,
74 NDR_SVCCTL_CONTROLSERVICE,
75 &r);
76
77 if (!NT_STATUS_IS_OK(status)) {
78 return status;
79 }
80
81 if (DEBUGLEVEL >= 10) {
82 NDR_PRINT_OUT_DEBUG(svcctl_ControlService, &r);
83 }
84
85 if (NT_STATUS_IS_ERR(status)) {
86 return status;
87 }
88
89 /* Return variables */
90 *service_status = *r.out.service_status;
91
92 /* Return result */
93 if (werror) {
94 *werror = r.out.result;
95 }
96
97 return werror_to_ntstatus(r.out.result);
98 }
99
100 NTSTATUS rpccli_svcctl_DeleteService(struct rpc_pipe_client *cli,
101 TALLOC_CTX *mem_ctx,
102 struct policy_handle *handle /* [in] [ref] */,
103 WERROR *werror)
104 {
105 struct svcctl_DeleteService r;
106 NTSTATUS status;
107
108 /* In parameters */
109 r.in.handle = handle;
110
111 if (DEBUGLEVEL >= 10) {
112 NDR_PRINT_IN_DEBUG(svcctl_DeleteService, &r);
113 }
114
115 status = cli->dispatch(cli,
116 mem_ctx,
117 &ndr_table_svcctl,
118 NDR_SVCCTL_DELETESERVICE,
119 &r);
120
121 if (!NT_STATUS_IS_OK(status)) {
122 return status;
123 }
124
125 if (DEBUGLEVEL >= 10) {
126 NDR_PRINT_OUT_DEBUG(svcctl_DeleteService, &r);
127 }
128
129 if (NT_STATUS_IS_ERR(status)) {
130 return status;
131 }
132
133 /* Return variables */
134
135 /* Return result */
136 if (werror) {
137 *werror = r.out.result;
138 }
139
140 return werror_to_ntstatus(r.out.result);
141 }
142
143 NTSTATUS rpccli_svcctl_LockServiceDatabase(struct rpc_pipe_client *cli,
144 TALLOC_CTX *mem_ctx,
145 struct policy_handle *handle /* [in] [ref] */,
146 struct policy_handle *lock /* [out] [ref] */,
147 WERROR *werror)
148 {
149 struct svcctl_LockServiceDatabase r;
150 NTSTATUS status;
151
152 /* In parameters */
153 r.in.handle = handle;
154
155 if (DEBUGLEVEL >= 10) {
156 NDR_PRINT_IN_DEBUG(svcctl_LockServiceDatabase, &r);
157 }
158
159 status = cli->dispatch(cli,
160 mem_ctx,
161 &ndr_table_svcctl,
162 NDR_SVCCTL_LOCKSERVICEDATABASE,
163 &r);
164
165 if (!NT_STATUS_IS_OK(status)) {
166 return status;
167 }
168
169 if (DEBUGLEVEL >= 10) {
170 NDR_PRINT_OUT_DEBUG(svcctl_LockServiceDatabase, &r);
171 }
172
173 if (NT_STATUS_IS_ERR(status)) {
174 return status;
175 }
176
177 /* Return variables */
178 *lock = *r.out.lock;
179
180 /* Return result */
181 if (werror) {
182 *werror = r.out.result;
183 }
184
185 return werror_to_ntstatus(r.out.result);
186 }
187
188 NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity(struct rpc_pipe_client *cli,
189 TALLOC_CTX *mem_ctx,
190 struct policy_handle *handle /* [in] [ref] */,
191 uint32_t security_flags /* [in] */,
192 uint8_t *buffer /* [out] [ref,size_is(buffer_size)] */,
193 uint32_t buffer_size /* [in] [range(0,0x40000)] */,
194 uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
195 WERROR *werror)
196 {
197 struct svcctl_QueryServiceObjectSecurity r;
198 NTSTATUS status;
199
200 /* In parameters */
201 r.in.handle = handle;
202 r.in.security_flags = security_flags;
203 r.in.buffer_size = buffer_size;
204
205 if (DEBUGLEVEL >= 10) {
206 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
207 }
208
209 status = cli->dispatch(cli,
210 mem_ctx,
211 &ndr_table_svcctl,
212 NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY,
213 &r);
214
215 if (!NT_STATUS_IS_OK(status)) {
216 return status;
217 }
218
219 if (DEBUGLEVEL >= 10) {
220 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
221 }
222
223 if (NT_STATUS_IS_ERR(status)) {
224 return status;
225 }
226
227 /* Return variables */
228 memcpy(buffer, r.out.buffer, r.in.buffer_size * sizeof(*buffer));
229 *needed = *r.out.needed;
230
231 /* Return result */
232 if (werror) {
233 *werror = r.out.result;
234 }
235
236 return werror_to_ntstatus(r.out.result);
237 }
238
239 NTSTATUS rpccli_svcctl_SetServiceObjectSecurity(struct rpc_pipe_client *cli,
240 TALLOC_CTX *mem_ctx,
241 struct policy_handle *handle /* [in] [ref] */,
242 uint32_t security_flags /* [in] */,
243 uint8_t *buffer /* [in] [ref,size_is(buffer_size)] */,
244 uint32_t buffer_size /* [in] */,
245 WERROR *werror)
246 {
247 struct svcctl_SetServiceObjectSecurity r;
248 NTSTATUS status;
249
250 /* In parameters */
251 r.in.handle = handle;
252 r.in.security_flags = security_flags;
253 r.in.buffer = buffer;
254 r.in.buffer_size = buffer_size;
255
256 if (DEBUGLEVEL >= 10) {
257 NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, &r);
258 }
259
260 status = cli->dispatch(cli,
261 mem_ctx,
262 &ndr_table_svcctl,
263 NDR_SVCCTL_SETSERVICEOBJECTSECURITY,
264 &r);
265
266 if (!NT_STATUS_IS_OK(status)) {
267 return status;
268 }
269
270 if (DEBUGLEVEL >= 10) {
271 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, &r);
272 }
273
274 if (NT_STATUS_IS_ERR(status)) {
275 return status;
276 }
277
278 /* Return variables */
279
280 /* Return result */
281 if (werror) {
282 *werror = r.out.result;
283 }
284
285 return werror_to_ntstatus(r.out.result);
286 }
287
288 NTSTATUS rpccli_svcctl_QueryServiceStatus(struct rpc_pipe_client *cli,
289 TALLOC_CTX *mem_ctx,
290 struct policy_handle *handle /* [in] [ref] */,
291 struct SERVICE_STATUS *service_status /* [out] [ref] */,
292 WERROR *werror)
293 {
294 struct svcctl_QueryServiceStatus r;
295 NTSTATUS status;
296
297 /* In parameters */
298 r.in.handle = handle;
299
300 if (DEBUGLEVEL >= 10) {
301 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatus, &r);
302 }
303
304 status = cli->dispatch(cli,
305 mem_ctx,
306 &ndr_table_svcctl,
307 NDR_SVCCTL_QUERYSERVICESTATUS,
308 &r);
309
310 if (!NT_STATUS_IS_OK(status)) {
311 return status;
312 }
313
314 if (DEBUGLEVEL >= 10) {
315 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, &r);
316 }
317
318 if (NT_STATUS_IS_ERR(status)) {
319 return status;
320 }
321
322 /* Return variables */
323 *service_status = *r.out.service_status;
324
325 /* Return result */
326 if (werror) {
327 *werror = r.out.result;
328 }
329
330 return werror_to_ntstatus(r.out.result);
331 }
332
333 NTSTATUS rpccli_svcctl_SetServiceStatus(struct rpc_pipe_client *cli,
334 TALLOC_CTX *mem_ctx,
335 WERROR *werror)
336 {
337 struct svcctl_SetServiceStatus r;
338 NTSTATUS status;
339
340 /* In parameters */
341
342 if (DEBUGLEVEL >= 10) {
343 NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, &r);
344 }
345
346 status = cli->dispatch(cli,
347 mem_ctx,
348 &ndr_table_svcctl,
349 NDR_SVCCTL_SETSERVICESTATUS,
350 &r);
351
352 if (!NT_STATUS_IS_OK(status)) {
353 return status;
354 }
355
356 if (DEBUGLEVEL >= 10) {
357 NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, &r);
358 }
359
360 if (NT_STATUS_IS_ERR(status)) {
361 return status;
362 }
363
364 /* Return variables */
365
366 /* Return result */
367 if (werror) {
368 *werror = r.out.result;
369 }
370
371 return werror_to_ntstatus(r.out.result);
372 }
373
374 NTSTATUS rpccli_svcctl_UnlockServiceDatabase(struct rpc_pipe_client *cli,
375 TALLOC_CTX *mem_ctx,
376 struct policy_handle *lock /* [in,out] [ref] */,
377 WERROR *werror)
378 {
379 struct svcctl_UnlockServiceDatabase r;
380 NTSTATUS status;
381
382 /* In parameters */
383 r.in.lock = lock;
384
385 if (DEBUGLEVEL >= 10) {
386 NDR_PRINT_IN_DEBUG(svcctl_UnlockServiceDatabase, &r);
387 }
388
389 status = cli->dispatch(cli,
390 mem_ctx,
391 &ndr_table_svcctl,
392 NDR_SVCCTL_UNLOCKSERVICEDATABASE,
393 &r);
394
395 if (!NT_STATUS_IS_OK(status)) {
396 return status;
397 }
398
399 if (DEBUGLEVEL >= 10) {
400 NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, &r);
401 }
402
403 if (NT_STATUS_IS_ERR(status)) {
404 return status;
405 }
406
407 /* Return variables */
408 *lock = *r.out.lock;
409
410 /* Return result */
411 if (werror) {
412 *werror = r.out.result;
413 }
414
415 return werror_to_ntstatus(r.out.result);
416 }
417
418 NTSTATUS rpccli_svcctl_NotifyBootConfigStatus(struct rpc_pipe_client *cli,
419 TALLOC_CTX *mem_ctx,
420 WERROR *werror)
421 {
422 struct svcctl_NotifyBootConfigStatus r;
423 NTSTATUS status;
424
425 /* In parameters */
426
427 if (DEBUGLEVEL >= 10) {
428 NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, &r);
429 }
430
431 status = cli->dispatch(cli,
432 mem_ctx,
433 &ndr_table_svcctl,
434 NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS,
435 &r);
436
437 if (!NT_STATUS_IS_OK(status)) {
438 return status;
439 }
440
441 if (DEBUGLEVEL >= 10) {
442 NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, &r);
443 }
444
445 if (NT_STATUS_IS_ERR(status)) {
446 return status;
447 }
448
449 /* Return variables */
450
451 /* Return result */
452 if (werror) {
453 *werror = r.out.result;
454 }
455
456 return werror_to_ntstatus(r.out.result);
457 }
458
459 NTSTATUS rpccli_svcctl_SCSetServiceBitsW(struct rpc_pipe_client *cli,
460 TALLOC_CTX *mem_ctx,
461 struct policy_handle *handle /* [in] [ref] */,
462 uint32_t bits /* [in] */,
463 uint32_t bitson /* [in] */,
464 uint32_t immediate /* [in] */,
465 WERROR *werror)
466 {
467 struct svcctl_SCSetServiceBitsW r;
468 NTSTATUS status;
469
470 /* In parameters */
471 r.in.handle = handle;
472 r.in.bits = bits;
473 r.in.bitson = bitson;
474 r.in.immediate = immediate;
475
476 if (DEBUGLEVEL >= 10) {
477 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &r);
478 }
479
480 status = cli->dispatch(cli,
481 mem_ctx,
482 &ndr_table_svcctl,
483 NDR_SVCCTL_SCSETSERVICEBITSW,
484 &r);
485
486 if (!NT_STATUS_IS_OK(status)) {
487 return status;
488 }
489
490 if (DEBUGLEVEL >= 10) {
491 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &r);
492 }
493
494 if (NT_STATUS_IS_ERR(status)) {
495 return status;
496 }
497
498 /* Return variables */
499
500 /* Return result */
501 if (werror) {
502 *werror = r.out.result;
503 }
504
505 return werror_to_ntstatus(r.out.result);
506 }
507
508 NTSTATUS rpccli_svcctl_ChangeServiceConfigW(struct rpc_pipe_client *cli,
509 TALLOC_CTX *mem_ctx,
510 struct policy_handle *handle /* [in] [ref] */,
511 uint32_t type /* [in] */,
512 enum svcctl_StartType start_type /* [in] */,
513 enum svcctl_ErrorControl error_control /* [in] */,
514 const char *binary_path /* [in] [unique,charset(UTF16)] */,
515 const char *load_order_group /* [in] [unique,charset(UTF16)] */,
516 uint32_t *tag_id /* [out] [ref] */,
517 const char *dependencies /* [in] [unique,charset(UTF16)] */,
518 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
519 const char *password /* [in] [unique,charset(UTF16)] */,
520 const char *display_name /* [in] [unique,charset(UTF16)] */,
521 WERROR *werror)
522 {
523 struct svcctl_ChangeServiceConfigW r;
524 NTSTATUS status;
525
526 /* In parameters */
527 r.in.handle = handle;
528 r.in.type = type;
529 r.in.start_type = start_type;
530 r.in.error_control = error_control;
531 r.in.binary_path = binary_path;
532 r.in.load_order_group = load_order_group;
533 r.in.dependencies = dependencies;
534 r.in.service_start_name = service_start_name;
535 r.in.password = password;
536 r.in.display_name = display_name;
537
538 if (DEBUGLEVEL >= 10) {
539 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigW, &r);
540 }
541
542 status = cli->dispatch(cli,
543 mem_ctx,
544 &ndr_table_svcctl,
545 NDR_SVCCTL_CHANGESERVICECONFIGW,
546 &r);
547
548 if (!NT_STATUS_IS_OK(status)) {
549 return status;
550 }
551
552 if (DEBUGLEVEL >= 10) {
553 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, &r);
554 }
555
556 if (NT_STATUS_IS_ERR(status)) {
557 return status;
558 }
559
560 /* Return variables */
561 *tag_id = *r.out.tag_id;
562
563 /* Return result */
564 if (werror) {
565 *werror = r.out.result;
566 }
567
568 return werror_to_ntstatus(r.out.result);
569 }
570
571 NTSTATUS rpccli_svcctl_CreateServiceW(struct rpc_pipe_client *cli,
572 TALLOC_CTX *mem_ctx,
573 struct policy_handle *scmanager_handle /* [in] [ref] */,
574 const char *ServiceName /* [in] [charset(UTF16)] */,
575 const char *DisplayName /* [in] [unique,charset(UTF16)] */,
576 uint32_t desired_access /* [in] */,
577 uint32_t type /* [in] */,
578 enum svcctl_StartType start_type /* [in] */,
579 enum svcctl_ErrorControl error_control /* [in] */,
580 const char *binary_path /* [in] [charset(UTF16)] */,
581 const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
582 uint32_t *TagId /* [in,out] [unique] */,
583 uint8_t *dependencies /* [in] [unique,size_is(dependencies_size)] */,
584 uint32_t dependencies_size /* [in] */,
585 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
586 uint8_t *password /* [in] [unique,size_is(password_size)] */,
587 uint32_t password_size /* [in] */,
588 struct policy_handle *handle /* [out] [ref] */,
589 WERROR *werror)
590 {
591 struct svcctl_CreateServiceW r;
592 NTSTATUS status;
593
594 /* In parameters */
595 r.in.scmanager_handle = scmanager_handle;
596 r.in.ServiceName = ServiceName;
597 r.in.DisplayName = DisplayName;
598 r.in.desired_access = desired_access;
599 r.in.type = type;
600 r.in.start_type = start_type;
601 r.in.error_control = error_control;
602 r.in.binary_path = binary_path;
603 r.in.LoadOrderGroupKey = LoadOrderGroupKey;
604 r.in.TagId = TagId;
605 r.in.dependencies = dependencies;
606 r.in.dependencies_size = dependencies_size;
607 r.in.service_start_name = service_start_name;
608 r.in.password = password;
609 r.in.password_size = password_size;
610
611 if (DEBUGLEVEL >= 10) {
612 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceW, &r);
613 }
614
615 status = cli->dispatch(cli,
616 mem_ctx,
617 &ndr_table_svcctl,
618 NDR_SVCCTL_CREATESERVICEW,
619 &r);
620
621 if (!NT_STATUS_IS_OK(status)) {
622 return status;
623 }
624
625 if (DEBUGLEVEL >= 10) {
626 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, &r);
627 }
628
629 if (NT_STATUS_IS_ERR(status)) {
630 return status;
631 }
632
633 /* Return variables */
634 if (TagId && r.out.TagId) {
635 *TagId = *r.out.TagId;
636 }
637 *handle = *r.out.handle;
638
639 /* Return result */
640 if (werror) {
641 *werror = r.out.result;
642 }
643
644 return werror_to_ntstatus(r.out.result);
645 }
646
647 NTSTATUS rpccli_svcctl_EnumDependentServicesW(struct rpc_pipe_client *cli,
648 TALLOC_CTX *mem_ctx,
649 struct policy_handle *service /* [in] [ref] */,
650 uint32_t state /* [in] */,
651 uint8_t *service_status /* [out] [ref,size_is(buf_size)] */,
652 uint32_t buf_size /* [in] [range(0,0x40000)] */,
653 uint32_t *bytes_needed /* [out] [ref,range(0,0x40000)] */,
654 uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
655 WERROR *werror)
656 {
657 struct svcctl_EnumDependentServicesW r;
658 NTSTATUS status;
659
660 /* In parameters */
661 r.in.service = service;
662 r.in.state = state;
663 r.in.buf_size = buf_size;
664
665 if (DEBUGLEVEL >= 10) {
666 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesW, &r);
667 }
668
669 status = cli->dispatch(cli,
670 mem_ctx,
671 &ndr_table_svcctl,
672 NDR_SVCCTL_ENUMDEPENDENTSERVICESW,
673 &r);
674
675 if (!NT_STATUS_IS_OK(status)) {
676 return status;
677 }
678
679 if (DEBUGLEVEL >= 10) {
680 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, &r);
681 }
682
683 if (NT_STATUS_IS_ERR(status)) {
684 return status;
685 }
686
687 /* Return variables */
688 memcpy(service_status, r.out.service_status, r.in.buf_size * sizeof(*service_status));
689 *bytes_needed = *r.out.bytes_needed;
690 *services_returned = *r.out.services_returned;
691
692 /* Return result */
693 if (werror) {
694 *werror = r.out.result;
695 }
696
697 return werror_to_ntstatus(r.out.result);
698 }
699
700 NTSTATUS rpccli_svcctl_EnumServicesStatusW(struct rpc_pipe_client *cli,
701 TALLOC_CTX *mem_ctx,
702 struct policy_handle *handle /* [in] [ref] */,
703 uint32_t type /* [in] */,
704 enum svcctl_ServiceState state /* [in] */,
705 uint8_t *service /* [out] [ref,size_is(buf_size)] */,
706 uint32_t buf_size /* [in] [range(0,0x40000)] */,
707 uint32_t *bytes_needed /* [out] [ref,range(0,0x40000)] */,
708 uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
709 uint32_t *resume_handle /* [in,out] [unique] */,
710 WERROR *werror)
711 {
712 struct svcctl_EnumServicesStatusW r;
713 NTSTATUS status;
714
715 /* In parameters */
716 r.in.handle = handle;
717 r.in.type = type;
718 r.in.state = state;
719 r.in.buf_size = buf_size;
720 r.in.resume_handle = resume_handle;
721
722 if (DEBUGLEVEL >= 10) {
723 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, &r);
724 }
725
726 status = cli->dispatch(cli,
727 mem_ctx,
728 &ndr_table_svcctl,
729 NDR_SVCCTL_ENUMSERVICESSTATUSW,
730 &r);
731
732 if (!NT_STATUS_IS_OK(status)) {
733 return status;
734 }
735
736 if (DEBUGLEVEL >= 10) {
737 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &r);
738 }
739
740 if (NT_STATUS_IS_ERR(status)) {
741 return status;
742 }
743
744 /* Return variables */
745 memcpy(service, r.out.service, r.in.buf_size * sizeof(*service));
746 *bytes_needed = *r.out.bytes_needed;
747 *services_returned = *r.out.services_returned;
748 if (resume_handle && r.out.resume_handle) {
749 *resume_handle = *r.out.resume_handle;
750 }
751
752 /* Return result */
753 if (werror) {
754 *werror = r.out.result;
755 }
756
757 return werror_to_ntstatus(r.out.result);
758 }
759
760 NTSTATUS rpccli_svcctl_OpenSCManagerW(struct rpc_pipe_client *cli,
761 TALLOC_CTX *mem_ctx,
762 const char *MachineName /* [in] [unique,charset(UTF16)] */,
763 const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
764 uint32_t access_mask /* [in] */,
765 struct policy_handle *handle /* [out] [ref] */,
766 WERROR *werror)
767 {
768 struct svcctl_OpenSCManagerW r;
769 NTSTATUS status;
770
771 /* In parameters */
772 r.in.MachineName = MachineName;
773 r.in.DatabaseName = DatabaseName;
774 r.in.access_mask = access_mask;
775
776 if (DEBUGLEVEL >= 10) {
777 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerW, &r);
778 }
779
780 status = cli->dispatch(cli,
781 mem_ctx,
782 &ndr_table_svcctl,
783 NDR_SVCCTL_OPENSCMANAGERW,
784 &r);
785
786 if (!NT_STATUS_IS_OK(status)) {
787 return status;
788 }
789
790 if (DEBUGLEVEL >= 10) {
791 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, &r);
792 }
793
794 if (NT_STATUS_IS_ERR(status)) {
795 return status;
796 }
797
798 /* Return variables */
799 *handle = *r.out.handle;
800
801 /* Return result */
802 if (werror) {
803 *werror = r.out.result;
804 }
805
806 return werror_to_ntstatus(r.out.result);
807 }
808
809 NTSTATUS rpccli_svcctl_OpenServiceW(struct rpc_pipe_client *cli,
810 TALLOC_CTX *mem_ctx,
811 struct policy_handle *scmanager_handle /* [in] [ref] */,
812 const char *ServiceName /* [in] [charset(UTF16)] */,
813 uint32_t access_mask /* [in] */,
814 struct policy_handle *handle /* [out] [ref] */,
815 WERROR *werror)
816 {
817 struct svcctl_OpenServiceW r;
818 NTSTATUS status;
819
820 /* In parameters */
821 r.in.scmanager_handle = scmanager_handle;
822 r.in.ServiceName = ServiceName;
823 r.in.access_mask = access_mask;
824
825 if (DEBUGLEVEL >= 10) {
826 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, &r);
827 }
828
829 status = cli->dispatch(cli,
830 mem_ctx,
831 &ndr_table_svcctl,
832 NDR_SVCCTL_OPENSERVICEW,
833 &r);
834
835 if (!NT_STATUS_IS_OK(status)) {
836 return status;
837 }
838
839 if (DEBUGLEVEL >= 10) {
840 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &r);
841 }
842
843 if (NT_STATUS_IS_ERR(status)) {
844 return status;
845 }
846
847 /* Return variables */
848 *handle = *r.out.handle;
849
850 /* Return result */
851 if (werror) {
852 *werror = r.out.result;
853 }
854
855 return werror_to_ntstatus(r.out.result);
856 }
857
858 NTSTATUS rpccli_svcctl_QueryServiceConfigW(struct rpc_pipe_client *cli,
859 TALLOC_CTX *mem_ctx,
860 struct policy_handle *handle /* [in] [ref] */,
861 struct QUERY_SERVICE_CONFIG *query /* [out] [ref] */,
862 uint32_t buf_size /* [in] [range(0,8192)] */,
863 uint32_t *bytes_needed /* [out] [ref,range(0,8192)] */,
864 WERROR *werror)
865 {
866 struct svcctl_QueryServiceConfigW r;
867 NTSTATUS status;
868
869 /* In parameters */
870 r.in.handle = handle;
871 r.in.buf_size = buf_size;
872
873 if (DEBUGLEVEL >= 10) {
874 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigW, &r);
875 }
876
877 status = cli->dispatch(cli,
878 mem_ctx,
879 &ndr_table_svcctl,
880 NDR_SVCCTL_QUERYSERVICECONFIGW,
881 &r);
882
883 if (!NT_STATUS_IS_OK(status)) {
884 return status;
885 }
886
887 if (DEBUGLEVEL >= 10) {
888 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, &r);
889 }
890
891 if (NT_STATUS_IS_ERR(status)) {
892 return status;
893 }
894
895 /* Return variables */
896 *query = *r.out.query;
897 *bytes_needed = *r.out.bytes_needed;
898
899 /* Return result */
900 if (werror) {
901 *werror = r.out.result;
902 }
903
904 return werror_to_ntstatus(r.out.result);
905 }
906
907 NTSTATUS rpccli_svcctl_QueryServiceLockStatusW(struct rpc_pipe_client *cli,
908 TALLOC_CTX *mem_ctx,
909 struct policy_handle *handle /* [in] [ref] */,
910 uint32_t buf_size /* [in] */,
911 struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
912 uint32_t *required_buf_size /* [out] [ref] */,
913 WERROR *werror)
914 {
915 struct svcctl_QueryServiceLockStatusW r;
916 NTSTATUS status;
917
918 /* In parameters */
919 r.in.handle = handle;
920 r.in.buf_size = buf_size;
921
922 if (DEBUGLEVEL >= 10) {
923 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, &r);
924 }
925
926 status = cli->dispatch(cli,
927 mem_ctx,
928 &ndr_table_svcctl,
929 NDR_SVCCTL_QUERYSERVICELOCKSTATUSW,
930 &r);
931
932 if (!NT_STATUS_IS_OK(status)) {
933 return status;
934 }
935
936 if (DEBUGLEVEL >= 10) {
937 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &r);
938 }
939
940 if (NT_STATUS_IS_ERR(status)) {
941 return status;
942 }
943
944 /* Return variables */
945 *lock_status = *r.out.lock_status;
946 *required_buf_size = *r.out.required_buf_size;
947
948 /* Return result */
949 if (werror) {
950 *werror = r.out.result;
951 }
952
953 return werror_to_ntstatus(r.out.result);
954 }
955
956 NTSTATUS rpccli_svcctl_StartServiceW(struct rpc_pipe_client *cli,
957 TALLOC_CTX *mem_ctx,
958 struct policy_handle *handle /* [in] [ref] */,
959 uint32_t NumArgs /* [in] */,
960 const char *Arguments /* [in] [unique,charset(UTF16)] */,
961 WERROR *werror)
962 {
963 struct svcctl_StartServiceW r;
964 NTSTATUS status;
965
966 /* In parameters */
967 r.in.handle = handle;
968 r.in.NumArgs = NumArgs;
969 r.in.Arguments = Arguments;
970
971 if (DEBUGLEVEL >= 10) {
972 NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, &r);
973 }
974
975 status = cli->dispatch(cli,
976 mem_ctx,
977 &ndr_table_svcctl,
978 NDR_SVCCTL_STARTSERVICEW,
979 &r);
980
981 if (!NT_STATUS_IS_OK(status)) {
982 return status;
983 }
984
985 if (DEBUGLEVEL >= 10) {
986 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, &r);
987 }
988
989 if (NT_STATUS_IS_ERR(status)) {
990 return status;
991 }
992
993 /* Return variables */
994
995 /* Return result */
996 if (werror) {
997 *werror = r.out.result;
998 }
999
1000 return werror_to_ntstatus(r.out.result);
1001 }
1002
1003 NTSTATUS rpccli_svcctl_GetServiceDisplayNameW(struct rpc_pipe_client *cli,
1004 TALLOC_CTX *mem_ctx,
1005 struct policy_handle *handle /* [in] [ref] */,
1006 const char *service_name /* [in] [unique,charset(UTF16)] */,
1007 const char **display_name /* [out] [ref,charset(UTF16)] */,
1008 uint32_t *display_name_length /* [in,out] [unique] */,
1009 WERROR *werror)
1010 {
1011 struct svcctl_GetServiceDisplayNameW r;
1012 NTSTATUS status;
1013
1014 /* In parameters */
1015 r.in.handle = handle;
1016 r.in.service_name = service_name;
1017 r.in.display_name_length = display_name_length;
1018
1019 if (DEBUGLEVEL >= 10) {
1020 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameW, &r);
1021 }
1022
1023 status = cli->dispatch(cli,
1024 mem_ctx,
1025 &ndr_table_svcctl,
1026 NDR_SVCCTL_GETSERVICEDISPLAYNAMEW,
1027 &r);
1028
1029 if (!NT_STATUS_IS_OK(status)) {
1030 return status;
1031 }
1032
1033 if (DEBUGLEVEL >= 10) {
1034 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, &r);
1035 }
1036
1037 if (NT_STATUS_IS_ERR(status)) {
1038 return status;
1039 }
1040
1041 /* Return variables */
1042 *display_name = *r.out.display_name;
1043 if (display_name_length && r.out.display_name_length) {
1044 *display_name_length = *r.out.display_name_length;
1045 }
1046
1047 /* Return result */
1048 if (werror) {
1049 *werror = r.out.result;
1050 }
1051
1052 return werror_to_ntstatus(r.out.result);
1053 }
1054
1055 NTSTATUS rpccli_svcctl_GetServiceKeyNameW(struct rpc_pipe_client *cli,
1056 TALLOC_CTX *mem_ctx,
1057 struct policy_handle *handle /* [in] [ref] */,
1058 const char *service_name /* [in] [unique,charset(UTF16)] */,
1059 const char **key_name /* [out] [ref,charset(UTF16)] */,
1060 uint32_t *display_name_length /* [in,out] [unique] */,
1061 WERROR *werror)
1062 {
1063 struct svcctl_GetServiceKeyNameW r;
1064 NTSTATUS status;
1065
1066 /* In parameters */
1067 r.in.handle = handle;
1068 r.in.service_name = service_name;
1069 r.in.display_name_length = display_name_length;
1070
1071 if (DEBUGLEVEL >= 10) {
1072 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameW, &r);
1073 }
1074
1075 status = cli->dispatch(cli,
1076 mem_ctx,
1077 &ndr_table_svcctl,
1078 NDR_SVCCTL_GETSERVICEKEYNAMEW,
1079 &r);
1080
1081 if (!NT_STATUS_IS_OK(status)) {
1082 return status;
1083 }
1084
1085 if (DEBUGLEVEL >= 10) {
1086 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, &r);
1087 }
1088
1089 if (NT_STATUS_IS_ERR(status)) {
1090 return status;
1091 }
1092
1093 /* Return variables */
1094 *key_name = *r.out.key_name;
1095 if (display_name_length && r.out.display_name_length) {
1096 *display_name_length = *r.out.display_name_length;
1097 }
1098
1099 /* Return result */
1100 if (werror) {
1101 *werror = r.out.result;
1102 }
1103
1104 return werror_to_ntstatus(r.out.result);
1105 }
1106
1107 NTSTATUS rpccli_svcctl_SCSetServiceBitsA(struct rpc_pipe_client *cli,
1108 TALLOC_CTX *mem_ctx,
1109 struct policy_handle *handle /* [in] [ref] */,
1110 uint32_t bits /* [in] */,
1111 uint32_t bitson /* [in] */,
1112 uint32_t immediate /* [in] */,
1113 WERROR *werror)
1114 {
1115 struct svcctl_SCSetServiceBitsA r;
1116 NTSTATUS status;
1117
1118 /* In parameters */
1119 r.in.handle = handle;
1120 r.in.bits = bits;
1121 r.in.bitson = bitson;
1122 r.in.immediate = immediate;
1123
1124 if (DEBUGLEVEL >= 10) {
1125 NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, &r);
1126 }
1127
1128 status = cli->dispatch(cli,
1129 mem_ctx,
1130 &ndr_table_svcctl,
1131 NDR_SVCCTL_SCSETSERVICEBITSA,
1132 &r);
1133
1134 if (!NT_STATUS_IS_OK(status)) {
1135 return status;
1136 }
1137
1138 if (DEBUGLEVEL >= 10) {
1139 NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, &r);
1140 }
1141
1142 if (NT_STATUS_IS_ERR(status)) {
1143 return status;
1144 }
1145
1146 /* Return variables */
1147
1148 /* Return result */
1149 if (werror) {
1150 *werror = r.out.result;
1151 }
1152
1153 return werror_to_ntstatus(r.out.result);
1154 }
1155
1156 NTSTATUS rpccli_svcctl_ChangeServiceConfigA(struct rpc_pipe_client *cli,
1157 TALLOC_CTX *mem_ctx,
1158 struct policy_handle *handle /* [in] [ref] */,
1159 uint32_t type /* [in] */,
1160 enum svcctl_StartType start_type /* [in] */,
1161 enum svcctl_ErrorControl error_control /* [in] */,
1162 const char *binary_path /* [in] [unique,charset(UTF16)] */,
1163 const char *load_order_group /* [in] [unique,charset(UTF16)] */,
1164 uint32_t *tag_id /* [out] [ref] */,
1165 const char *dependencies /* [in] [unique,charset(UTF16)] */,
1166 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
1167 const char *password /* [in] [unique,charset(UTF16)] */,
1168 const char *display_name /* [in] [unique,charset(UTF16)] */,
1169 WERROR *werror)
1170 {
1171 struct svcctl_ChangeServiceConfigA r;
1172 NTSTATUS status;
1173
1174 /* In parameters */
1175 r.in.handle = handle;
1176 r.in.type = type;
1177 r.in.start_type = start_type;
1178 r.in.error_control = error_control;
1179 r.in.binary_path = binary_path;
1180 r.in.load_order_group = load_order_group;
1181 r.in.dependencies = dependencies;
1182 r.in.service_start_name = service_start_name;
1183 r.in.password = password;
1184 r.in.display_name = display_name;
1185
1186 if (DEBUGLEVEL >= 10) {
1187 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfigA, &r);
1188 }
1189
1190 status = cli->dispatch(cli,
1191 mem_ctx,
1192 &ndr_table_svcctl,
1193 NDR_SVCCTL_CHANGESERVICECONFIGA,
1194 &r);
1195
1196 if (!NT_STATUS_IS_OK(status)) {
1197 return status;
1198 }
1199
1200 if (DEBUGLEVEL >= 10) {
1201 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, &r);
1202 }
1203
1204 if (NT_STATUS_IS_ERR(status)) {
1205 return status;
1206 }
1207
1208 /* Return variables */
1209 *tag_id = *r.out.tag_id;
1210
1211 /* Return result */
1212 if (werror) {
1213 *werror = r.out.result;
1214 }
1215
1216 return werror_to_ntstatus(r.out.result);
1217 }
1218
1219 NTSTATUS rpccli_svcctl_CreateServiceA(struct rpc_pipe_client *cli,
1220 TALLOC_CTX *mem_ctx,
1221 struct policy_handle *handle /* [in] [ref] */,
1222 const char *ServiceName /* [in] [unique,charset(UTF16)] */,
1223 const char *DisplayName /* [in] [unique,charset(UTF16)] */,
1224 uint32_t desired_access /* [in] */,
1225 uint32_t type /* [in] */,
1226 enum svcctl_StartType start_type /* [in] */,
1227 enum svcctl_ErrorControl error_control /* [in] */,
1228 const char *binary_path /* [in] [unique,charset(UTF16)] */,
1229 const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
1230 uint32_t *TagId /* [out] [unique] */,
1231 const char *dependencies /* [in] [unique,charset(UTF16)] */,
1232 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
1233 const char *password /* [in] [unique,charset(UTF16)] */,
1234 WERROR *werror)
1235 {
1236 struct svcctl_CreateServiceA r;
1237 NTSTATUS status;
1238
1239 /* In parameters */
1240 r.in.handle = handle;
1241 r.in.ServiceName = ServiceName;
1242 r.in.DisplayName = DisplayName;
1243 r.in.desired_access = desired_access;
1244 r.in.type = type;
1245 r.in.start_type = start_type;
1246 r.in.error_control = error_control;
1247 r.in.binary_path = binary_path;
1248 r.in.LoadOrderGroupKey = LoadOrderGroupKey;
1249 r.in.dependencies = dependencies;
1250 r.in.service_start_name = service_start_name;
1251 r.in.password = password;
1252
1253 if (DEBUGLEVEL >= 10) {
1254 NDR_PRINT_IN_DEBUG(svcctl_CreateServiceA, &r);
1255 }
1256
1257 status = cli->dispatch(cli,
1258 mem_ctx,
1259 &ndr_table_svcctl,
1260 NDR_SVCCTL_CREATESERVICEA,
1261 &r);
1262
1263 if (!NT_STATUS_IS_OK(status)) {
1264 return status;
1265 }
1266
1267 if (DEBUGLEVEL >= 10) {
1268 NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, &r);
1269 }
1270
1271 if (NT_STATUS_IS_ERR(status)) {
1272 return status;
1273 }
1274
1275 /* Return variables */
1276 if (TagId && r.out.TagId) {
1277 *TagId = *r.out.TagId;
1278 }
1279
1280 /* Return result */
1281 if (werror) {
1282 *werror = r.out.result;
1283 }
1284
1285 return werror_to_ntstatus(r.out.result);
1286 }
1287
1288 NTSTATUS rpccli_svcctl_EnumDependentServicesA(struct rpc_pipe_client *cli,
1289 TALLOC_CTX *mem_ctx,
1290 struct policy_handle *service /* [in] [ref] */,
1291 uint32_t state /* [in] */,
1292 struct ENUM_SERVICE_STATUSA *service_status /* [out] [unique] */,
1293 uint32_t buf_size /* [in] */,
1294 uint32_t *bytes_needed /* [out] [ref] */,
1295 uint32_t *services_returned /* [out] [ref] */,
1296 WERROR *werror)
1297 {
1298 struct svcctl_EnumDependentServicesA r;
1299 NTSTATUS status;
1300
1301 /* In parameters */
1302 r.in.service = service;
1303 r.in.state = state;
1304 r.in.buf_size = buf_size;
1305
1306 if (DEBUGLEVEL >= 10) {
1307 NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, &r);
1308 }
1309
1310 status = cli->dispatch(cli,
1311 mem_ctx,
1312 &ndr_table_svcctl,
1313 NDR_SVCCTL_ENUMDEPENDENTSERVICESA,
1314 &r);
1315
1316 if (!NT_STATUS_IS_OK(status)) {
1317 return status;
1318 }
1319
1320 if (DEBUGLEVEL >= 10) {
1321 NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &r);
1322 }
1323
1324 if (NT_STATUS_IS_ERR(status)) {
1325 return status;
1326 }
1327
1328 /* Return variables */
1329 if (service_status && r.out.service_status) {
1330 *service_status = *r.out.service_status;
1331 }
1332 *bytes_needed = *r.out.bytes_needed;
1333 *services_returned = *r.out.services_returned;
1334
1335 /* Return result */
1336 if (werror) {
1337 *werror = r.out.result;
1338 }
1339
1340 return werror_to_ntstatus(r.out.result);
1341 }
1342
1343 NTSTATUS rpccli_svcctl_EnumServicesStatusA(struct rpc_pipe_client *cli,
1344 TALLOC_CTX *mem_ctx,
1345 struct policy_handle *handle /* [in] [ref] */,
1346 uint32_t type /* [in] */,
1347 enum svcctl_ServiceState state /* [in] */,
1348 uint32_t buf_size /* [in] */,
1349 uint8_t *service /* [out] [size_is(buf_size)] */,
1350 uint32_t *bytes_needed /* [out] [ref] */,
1351 uint32_t *services_returned /* [out] [ref] */,
1352 uint32_t *resume_handle /* [in,out] [unique] */,
1353 WERROR *werror)
1354 {
1355 struct svcctl_EnumServicesStatusA r;
1356 NTSTATUS status;
1357
1358 /* In parameters */
1359 r.in.handle = handle;
1360 r.in.type = type;
1361 r.in.state = state;
1362 r.in.buf_size = buf_size;
1363 r.in.resume_handle = resume_handle;
1364
1365 if (DEBUGLEVEL >= 10) {
1366 NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusA, &r);
1367 }
1368
1369 status = cli->dispatch(cli,
1370 mem_ctx,
1371 &ndr_table_svcctl,
1372 NDR_SVCCTL_ENUMSERVICESSTATUSA,
1373 &r);
1374
1375 if (!NT_STATUS_IS_OK(status)) {
1376 return status;
1377 }
1378
1379 if (DEBUGLEVEL >= 10) {
1380 NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, &r);
1381 }
1382
1383 if (NT_STATUS_IS_ERR(status)) {
1384 return status;
1385 }
1386
1387 /* Return variables */
1388 memcpy(service, r.out.service, r.in.buf_size * sizeof(*service));
1389 *bytes_needed = *r.out.bytes_needed;
1390 *services_returned = *r.out.services_returned;
1391 if (resume_handle && r.out.resume_handle) {
1392 *resume_handle = *r.out.resume_handle;
1393 }
1394
1395 /* Return result */
1396 if (werror) {
1397 *werror = r.out.result;
1398 }
1399
1400 return werror_to_ntstatus(r.out.result);
1401 }
1402
1403 NTSTATUS rpccli_svcctl_OpenSCManagerA(struct rpc_pipe_client *cli,
1404 TALLOC_CTX *mem_ctx,
1405 const char *MachineName /* [in] [unique,charset(UTF16)] */,
1406 const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
1407 uint32_t access_mask /* [in] */,
1408 struct policy_handle *handle /* [out] [ref] */,
1409 WERROR *werror)
1410 {
1411 struct svcctl_OpenSCManagerA r;
1412 NTSTATUS status;
1413
1414 /* In parameters */
1415 r.in.MachineName = MachineName;
1416 r.in.DatabaseName = DatabaseName;
1417 r.in.access_mask = access_mask;
1418
1419 if (DEBUGLEVEL >= 10) {
1420 NDR_PRINT_IN_DEBUG(svcctl_OpenSCManagerA, &r);
1421 }
1422
1423 status = cli->dispatch(cli,
1424 mem_ctx,
1425 &ndr_table_svcctl,
1426 NDR_SVCCTL_OPENSCMANAGERA,
1427 &r);
1428
1429 if (!NT_STATUS_IS_OK(status)) {
1430 return status;
1431 }
1432
1433 if (DEBUGLEVEL >= 10) {
1434 NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, &r);
1435 }
1436
1437 if (NT_STATUS_IS_ERR(status)) {
1438 return status;
1439 }
1440
1441 /* Return variables */
1442 *handle = *r.out.handle;
1443
1444 /* Return result */
1445 if (werror) {
1446 *werror = r.out.result;
1447 }
1448
1449 return werror_to_ntstatus(r.out.result);
1450 }
1451
1452 NTSTATUS rpccli_svcctl_OpenServiceA(struct rpc_pipe_client *cli,
1453 TALLOC_CTX *mem_ctx,
1454 struct policy_handle *scmanager_handle /* [in] [ref] */,
1455 const char *ServiceName /* [in] [unique,charset(UTF16)] */,
1456 uint32_t access_mask /* [in] */,
1457 WERROR *werror)
1458 {
1459 struct svcctl_OpenServiceA r;
1460 NTSTATUS status;
1461
1462 /* In parameters */
1463 r.in.scmanager_handle = scmanager_handle;
1464 r.in.ServiceName = ServiceName;
1465 r.in.access_mask = access_mask;
1466
1467 if (DEBUGLEVEL >= 10) {
1468 NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, &r);
1469 }
1470
1471 status = cli->dispatch(cli,
1472 mem_ctx,
1473 &ndr_table_svcctl,
1474 NDR_SVCCTL_OPENSERVICEA,
1475 &r);
1476
1477 if (!NT_STATUS_IS_OK(status)) {
1478 return status;
1479 }
1480
1481 if (DEBUGLEVEL >= 10) {
1482 NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, &r);
1483 }
1484
1485 if (NT_STATUS_IS_ERR(status)) {
1486 return status;
1487 }
1488
1489 /* Return variables */
1490
1491 /* Return result */
1492 if (werror) {
1493 *werror = r.out.result;
1494 }
1495
1496 return werror_to_ntstatus(r.out.result);
1497 }
1498
1499 NTSTATUS rpccli_svcctl_QueryServiceConfigA(struct rpc_pipe_client *cli,
1500 TALLOC_CTX *mem_ctx,
1501 struct policy_handle *handle /* [in] [ref] */,
1502 uint8_t *query /* [out] */,
1503 uint32_t buf_size /* [in] */,
1504 uint32_t *bytes_needed /* [out] [ref] */,
1505 WERROR *werror)
1506 {
1507 struct svcctl_QueryServiceConfigA r;
1508 NTSTATUS status;
1509
1510 /* In parameters */
1511 r.in.handle = handle;
1512 r.in.buf_size = buf_size;
1513
1514 if (DEBUGLEVEL >= 10) {
1515 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, &r);
1516 }
1517
1518 status = cli->dispatch(cli,
1519 mem_ctx,
1520 &ndr_table_svcctl,
1521 NDR_SVCCTL_QUERYSERVICECONFIGA,
1522 &r);
1523
1524 if (!NT_STATUS_IS_OK(status)) {
1525 return status;
1526 }
1527
1528 if (DEBUGLEVEL >= 10) {
1529 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &r);
1530 }
1531
1532 if (NT_STATUS_IS_ERR(status)) {
1533 return status;
1534 }
1535
1536 /* Return variables */
1537 memcpy(query, r.out.query, r.in.buf_size * sizeof(*query));
1538 *bytes_needed = *r.out.bytes_needed;
1539
1540 /* Return result */
1541 if (werror) {
1542 *werror = r.out.result;
1543 }
1544
1545 return werror_to_ntstatus(r.out.result);
1546 }
1547
1548 NTSTATUS rpccli_svcctl_QueryServiceLockStatusA(struct rpc_pipe_client *cli,
1549 TALLOC_CTX *mem_ctx,
1550 struct policy_handle *handle /* [in] [ref] */,
1551 uint32_t buf_size /* [in] */,
1552 struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
1553 uint32_t *required_buf_size /* [out] [ref] */,
1554 WERROR *werror)
1555 {
1556 struct svcctl_QueryServiceLockStatusA r;
1557 NTSTATUS status;
1558
1559 /* In parameters */
1560 r.in.handle = handle;
1561 r.in.buf_size = buf_size;
1562
1563 if (DEBUGLEVEL >= 10) {
1564 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusA, &r);
1565 }
1566
1567 status = cli->dispatch(cli,
1568 mem_ctx,
1569 &ndr_table_svcctl,
1570 NDR_SVCCTL_QUERYSERVICELOCKSTATUSA,
1571 &r);
1572
1573 if (!NT_STATUS_IS_OK(status)) {
1574 return status;
1575 }
1576
1577 if (DEBUGLEVEL >= 10) {
1578 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, &r);
1579 }
1580
1581 if (NT_STATUS_IS_ERR(status)) {
1582 return status;
1583 }
1584
1585 /* Return variables */
1586 *lock_status = *r.out.lock_status;
1587 *required_buf_size = *r.out.required_buf_size;
1588
1589 /* Return result */
1590 if (werror) {
1591 *werror = r.out.result;
1592 }
1593
1594 return werror_to_ntstatus(r.out.result);
1595 }
1596
1597 NTSTATUS rpccli_svcctl_StartServiceA(struct rpc_pipe_client *cli,
1598 TALLOC_CTX *mem_ctx,
1599 struct policy_handle *handle /* [in] [ref] */,
1600 uint32_t NumArgs /* [in] */,
1601 const char *Arguments /* [in] [unique,charset(UTF16)] */,
1602 WERROR *werror)
1603 {
1604 struct svcctl_StartServiceA r;
1605 NTSTATUS status;
1606
1607 /* In parameters */
1608 r.in.handle = handle;
1609 r.in.NumArgs = NumArgs;
1610 r.in.Arguments = Arguments;
1611
1612 if (DEBUGLEVEL >= 10) {
1613 NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, &r);
1614 }
1615
1616 status = cli->dispatch(cli,
1617 mem_ctx,
1618 &ndr_table_svcctl,
1619 NDR_SVCCTL_STARTSERVICEA,
1620 &r);
1621
1622 if (!NT_STATUS_IS_OK(status)) {
1623 return status;
1624 }
1625
1626 if (DEBUGLEVEL >= 10) {
1627 NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, &r);
1628 }
1629
1630 if (NT_STATUS_IS_ERR(status)) {
1631 return status;
1632 }
1633
1634 /* Return variables */
1635
1636 /* Return result */
1637 if (werror) {
1638 *werror = r.out.result;
1639 }
1640
1641 return werror_to_ntstatus(r.out.result);
1642 }
1643
1644 NTSTATUS rpccli_svcctl_GetServiceDisplayNameA(struct rpc_pipe_client *cli,
1645 TALLOC_CTX *mem_ctx,
1646 struct policy_handle *handle /* [in] [ref] */,
1647 const char *service_name /* [in] [unique,charset(UTF16)] */,
1648 const char **display_name /* [out] [ref,charset(UTF16)] */,
1649 uint32_t *display_name_length /* [in,out] [unique] */,
1650 WERROR *werror)
1651 {
1652 struct svcctl_GetServiceDisplayNameA r;
1653 NTSTATUS status;
1654
1655 /* In parameters */
1656 r.in.handle = handle;
1657 r.in.service_name = service_name;
1658 r.in.display_name_length = display_name_length;
1659
1660 if (DEBUGLEVEL >= 10) {
1661 NDR_PRINT_IN_DEBUG(svcctl_GetServiceDisplayNameA, &r);
1662 }
1663
1664 status = cli->dispatch(cli,
1665 mem_ctx,
1666 &ndr_table_svcctl,
1667 NDR_SVCCTL_GETSERVICEDISPLAYNAMEA,
1668 &r);
1669
1670 if (!NT_STATUS_IS_OK(status)) {
1671 return status;
1672 }
1673
1674 if (DEBUGLEVEL >= 10) {
1675 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, &r);
1676 }
1677
1678 if (NT_STATUS_IS_ERR(status)) {
1679 return status;
1680 }
1681
1682 /* Return variables */
1683 *display_name = *r.out.display_name;
1684 if (display_name_length && r.out.display_name_length) {
1685 *display_name_length = *r.out.display_name_length;
1686 }
1687
1688 /* Return result */
1689 if (werror) {
1690 *werror = r.out.result;
1691 }
1692
1693 return werror_to_ntstatus(r.out.result);
1694 }
1695
1696 NTSTATUS rpccli_svcctl_GetServiceKeyNameA(struct rpc_pipe_client *cli,
1697 TALLOC_CTX *mem_ctx,
1698 struct policy_handle *handle /* [in] [ref] */,
1699 const char *service_name /* [in] [unique,charset(UTF16)] */,
1700 const char **key_name /* [out] [ref,charset(UTF16)] */,
1701 uint32_t *display_name_length /* [in,out] [unique] */,
1702 WERROR *werror)
1703 {
1704 struct svcctl_GetServiceKeyNameA r;
1705 NTSTATUS status;
1706
1707 /* In parameters */
1708 r.in.handle = handle;
1709 r.in.service_name = service_name;
1710 r.in.display_name_length = display_name_length;
1711
1712 if (DEBUGLEVEL >= 10) {
1713 NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, &r);
1714 }
1715
1716 status = cli->dispatch(cli,
1717 mem_ctx,
1718 &ndr_table_svcctl,
1719 NDR_SVCCTL_GETSERVICEKEYNAMEA,
1720 &r);
1721
1722 if (!NT_STATUS_IS_OK(status)) {
1723 return status;
1724 }
1725
1726 if (DEBUGLEVEL >= 10) {
1727 NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &r);
1728 }
1729
1730 if (NT_STATUS_IS_ERR(status)) {
1731 return status;
1732 }
1733
1734 /* Return variables */
1735 *key_name = *r.out.key_name;
1736 if (display_name_length && r.out.display_name_length) {
1737 *display_name_length = *r.out.display_name_length;
1738 }
1739
1740 /* Return result */
1741 if (werror) {
1742 *werror = r.out.result;
1743 }
1744
1745 return werror_to_ntstatus(r.out.result);
1746 }
1747
1748 NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW(struct rpc_pipe_client *cli,
1749 TALLOC_CTX *mem_ctx,
1750 WERROR *werror)
1751 {
1752 struct svcctl_GetCurrentGroupeStateW r;
1753 NTSTATUS status;
1754
1755 /* In parameters */
1756
1757 if (DEBUGLEVEL >= 10) {
1758 NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1759 }
1760
1761 status = cli->dispatch(cli,
1762 mem_ctx,
1763 &ndr_table_svcctl,
1764 NDR_SVCCTL_GETCURRENTGROUPESTATEW,
1765 &r);
1766
1767 if (!NT_STATUS_IS_OK(status)) {
1768 return status;
1769 }
1770
1771 if (DEBUGLEVEL >= 10) {
1772 NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
1773 }
1774
1775 if (NT_STATUS_IS_ERR(status)) {
1776 return status;
1777 }
1778
1779 /* Return variables */
1780
1781 /* Return result */
1782 if (werror) {
1783 *werror = r.out.result;
1784 }
1785
1786 return werror_to_ntstatus(r.out.result);
1787 }
1788
1789 NTSTATUS rpccli_svcctl_EnumServiceGroupW(struct rpc_pipe_client *cli,
1790 TALLOC_CTX *mem_ctx,
1791 WERROR *werror)
1792 {
1793 struct svcctl_EnumServiceGroupW r;
1794 NTSTATUS status;
1795
1796 /* In parameters */
1797
1798 if (DEBUGLEVEL >= 10) {
1799 NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, &r);
1800 }
1801
1802 status = cli->dispatch(cli,
1803 mem_ctx,
1804 &ndr_table_svcctl,
1805 NDR_SVCCTL_ENUMSERVICEGROUPW,
1806 &r);
1807
1808 if (!NT_STATUS_IS_OK(status)) {
1809 return status;
1810 }
1811
1812 if (DEBUGLEVEL >= 10) {
1813 NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, &r);
1814 }
1815
1816 if (NT_STATUS_IS_ERR(status)) {
1817 return status;
1818 }
1819
1820 /* Return variables */
1821
1822 /* Return result */
1823 if (werror) {
1824 *werror = r.out.result;
1825 }
1826
1827 return werror_to_ntstatus(r.out.result);
1828 }
1829
1830 NTSTATUS rpccli_svcctl_ChangeServiceConfig2A(struct rpc_pipe_client *cli,
1831 TALLOC_CTX *mem_ctx,
1832 struct policy_handle *handle /* [in] [ref] */,
1833 uint32_t info_level /* [in] */,
1834 uint8_t *info /* [in] [unique] */,
1835 WERROR *werror)
1836 {
1837 struct svcctl_ChangeServiceConfig2A r;
1838 NTSTATUS status;
1839
1840 /* In parameters */
1841 r.in.handle = handle;
1842 r.in.info_level = info_level;
1843 r.in.info = info;
1844
1845 if (DEBUGLEVEL >= 10) {
1846 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1847 }
1848
1849 status = cli->dispatch(cli,
1850 mem_ctx,
1851 &ndr_table_svcctl,
1852 NDR_SVCCTL_CHANGESERVICECONFIG2A,
1853 &r);
1854
1855 if (!NT_STATUS_IS_OK(status)) {
1856 return status;
1857 }
1858
1859 if (DEBUGLEVEL >= 10) {
1860 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, &r);
1861 }
1862
1863 if (NT_STATUS_IS_ERR(status)) {
1864 return status;
1865 }
1866
1867 /* Return variables */
1868
1869 /* Return result */
1870 if (werror) {
1871 *werror = r.out.result;
1872 }
1873
1874 return werror_to_ntstatus(r.out.result);
1875 }
1876
1877 NTSTATUS rpccli_svcctl_ChangeServiceConfig2W(struct rpc_pipe_client *cli,
1878 TALLOC_CTX *mem_ctx,
1879 struct policy_handle *handle /* [in] [ref] */,
1880 uint32_t info_level /* [in] */,
1881 uint8_t *info /* [in] [unique] */,
1882 WERROR *werror)
1883 {
1884 struct svcctl_ChangeServiceConfig2W r;
1885 NTSTATUS status;
1886
1887 /* In parameters */
1888 r.in.handle = handle;
1889 r.in.info_level = info_level;
1890 r.in.info = info;
1891
1892 if (DEBUGLEVEL >= 10) {
1893 NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1894 }
1895
1896 status = cli->dispatch(cli,
1897 mem_ctx,
1898 &ndr_table_svcctl,
1899 NDR_SVCCTL_CHANGESERVICECONFIG2W,
1900 &r);
1901
1902 if (!NT_STATUS_IS_OK(status)) {
1903 return status;
1904 }
1905
1906 if (DEBUGLEVEL >= 10) {
1907 NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, &r);
1908 }
1909
1910 if (NT_STATUS_IS_ERR(status)) {
1911 return status;
1912 }
1913
1914 /* Return variables */
1915
1916 /* Return result */
1917 if (werror) {
1918 *werror = r.out.result;
1919 }
1920
1921 return werror_to_ntstatus(r.out.result);
1922 }
1923
1924 NTSTATUS rpccli_svcctl_QueryServiceConfig2A(struct rpc_pipe_client *cli,
1925 TALLOC_CTX *mem_ctx,
1926 struct policy_handle *handle /* [in] [ref] */,
1927 enum svcctl_ConfigLevel info_level /* [in] */,
1928 uint8_t *buffer /* [out] */,
1929 uint32_t buf_size /* [in] */,
1930 uint32_t *bytes_needed /* [out] [ref] */,
1931 WERROR *werror)
1932 {
1933 struct svcctl_QueryServiceConfig2A r;
1934 NTSTATUS status;
1935
1936 /* In parameters */
1937 r.in.handle = handle;
1938 r.in.info_level = info_level;
1939 r.in.buf_size = buf_size;
1940
1941 if (DEBUGLEVEL >= 10) {
1942 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2A, &r);
1943 }
1944
1945 status = cli->dispatch(cli,
1946 mem_ctx,
1947 &ndr_table_svcctl,
1948 NDR_SVCCTL_QUERYSERVICECONFIG2A,
1949 &r);
1950
1951 if (!NT_STATUS_IS_OK(status)) {
1952 return status;
1953 }
1954
1955 if (DEBUGLEVEL >= 10) {
1956 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, &r);
1957 }
1958
1959 if (NT_STATUS_IS_ERR(status)) {
1960 return status;
1961 }
1962
1963 /* Return variables */
1964 memcpy(buffer, r.out.buffer, r.in.buf_size * sizeof(*buffer));
1965 *bytes_needed = *r.out.bytes_needed;
1966
1967 /* Return result */
1968 if (werror) {
1969 *werror = r.out.result;
1970 }
1971
1972 return werror_to_ntstatus(r.out.result);
1973 }
1974
1975 NTSTATUS rpccli_svcctl_QueryServiceConfig2W(struct rpc_pipe_client *cli,
1976 TALLOC_CTX *mem_ctx,
1977 struct policy_handle *handle /* [in] [ref] */,
1978 enum svcctl_ConfigLevel info_level /* [in] */,
1979 uint8_t *buffer /* [out] [ref,size_is(buf_size)] */,
1980 uint32_t buf_size /* [in] [range(0,8192)] */,
1981 uint32_t *bytes_needed /* [out] [ref,range(0,8192)] */,
1982 WERROR *werror)
1983 {
1984 struct svcctl_QueryServiceConfig2W r;
1985 NTSTATUS status;
1986
1987 /* In parameters */
1988 r.in.handle = handle;
1989 r.in.info_level = info_level;
1990 r.in.buf_size = buf_size;
1991
1992 if (DEBUGLEVEL >= 10) {
1993 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfig2W, &r);
1994 }
1995
1996 status = cli->dispatch(cli,
1997 mem_ctx,
1998 &ndr_table_svcctl,
1999 NDR_SVCCTL_QUERYSERVICECONFIG2W,
2000 &r);
2001
2002 if (!NT_STATUS_IS_OK(status)) {
2003 return status;
2004 }
2005
2006 if (DEBUGLEVEL >= 10) {
2007 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, &r);
2008 }
2009
2010 if (NT_STATUS_IS_ERR(status)) {
2011 return status;
2012 }
2013
2014 /* Return variables */
2015 memcpy(buffer, r.out.buffer, r.in.buf_size * sizeof(*buffer));
2016 *bytes_needed = *r.out.bytes_needed;
2017
2018 /* Return result */
2019 if (werror) {
2020 *werror = r.out.result;
2021 }
2022
2023 return werror_to_ntstatus(r.out.result);
2024 }
2025
2026 NTSTATUS rpccli_svcctl_QueryServiceStatusEx(struct rpc_pipe_client *cli,
2027 TALLOC_CTX *mem_ctx,
2028 struct policy_handle *handle /* [in] [ref] */,
2029 enum svcctl_StatusLevel info_level /* [in] */,
2030 uint8_t *buffer /* [out] [ref,size_is(buf_size)] */,
2031 uint32_t buf_size /* [in] [range(0,8192)] */,
2032 uint32_t *bytes_needed /* [out] [ref,range(0,8192)] */,
2033 WERROR *werror)
2034 {
2035 struct svcctl_QueryServiceStatusEx r;
2036 NTSTATUS status;
2037
2038 /* In parameters */
2039 r.in.handle = handle;
2040 r.in.info_level = info_level;
2041 r.in.buf_size = buf_size;
2042
2043 if (DEBUGLEVEL >= 10) {
2044 NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, &r);
2045 }
2046
2047 status = cli->dispatch(cli,
2048 mem_ctx,
2049 &ndr_table_svcctl,
2050 NDR_SVCCTL_QUERYSERVICESTATUSEX,
2051 &r);
2052
2053 if (!NT_STATUS_IS_OK(status)) {
2054 return status;
2055 }
2056
2057 if (DEBUGLEVEL >= 10) {
2058 NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &r);
2059 }
2060
2061 if (NT_STATUS_IS_ERR(status)) {
2062 return status;
2063 }
2064
2065 /* Return variables */
2066 memcpy(buffer, r.out.buffer, r.in.buf_size * sizeof(*buffer));
2067 *bytes_needed = *r.out.bytes_needed;
2068
2069 /* Return result */
2070 if (werror) {
2071 *werror = r.out.result;
2072 }
2073
2074 return werror_to_ntstatus(r.out.result);
2075 }
2076
2077 NTSTATUS rpccli_EnumServicesStatusExA(struct rpc_pipe_client *cli,
2078 TALLOC_CTX *mem_ctx,
2079 struct policy_handle *scmanager /* [in] [ref] */,
2080 uint32_t info_level /* [in] */,
2081 uint32_t type /* [in] */,
2082 enum svcctl_ServiceState state /* [in] */,
2083 uint8_t *services /* [out] */,
2084 uint32_t buf_size /* [in] */,
2085 uint32_t *bytes_needed /* [out] [ref] */,
2086 uint32_t *service_returned /* [out] [ref] */,
2087 uint32_t *resume_handle /* [in,out] [unique] */,
2088 const char **group_name /* [out] [ref,charset(UTF16)] */,
2089 WERROR *werror)
2090 {
2091 struct EnumServicesStatusExA r;
2092 NTSTATUS status;
2093
2094 /* In parameters */
2095 r.in.scmanager = scmanager;
2096 r.in.info_level = info_level;
2097 r.in.type = type;
2098 r.in.state = state;
2099 r.in.buf_size = buf_size;
2100 r.in.resume_handle = resume_handle;
2101
2102 if (DEBUGLEVEL >= 10) {
2103 NDR_PRINT_IN_DEBUG(EnumServicesStatusExA, &r);
2104 }
2105
2106 status = cli->dispatch(cli,
2107 mem_ctx,
2108 &ndr_table_svcctl,
2109 NDR_ENUMSERVICESSTATUSEXA,
2110 &r);
2111
2112 if (!NT_STATUS_IS_OK(status)) {
2113 return status;
2114 }
2115
2116 if (DEBUGLEVEL >= 10) {
2117 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, &r);
2118 }
2119
2120 if (NT_STATUS_IS_ERR(status)) {
2121 return status;
2122 }
2123
2124 /* Return variables */
2125 memcpy(services, r.out.services, r.in.buf_size * sizeof(*services));
2126 *bytes_needed = *r.out.bytes_needed;
2127 *service_returned = *r.out.service_returned;
2128 if (resume_handle && r.out.resume_handle) {
2129 *resume_handle = *r.out.resume_handle;
2130 }
2131 *group_name = *r.out.group_name;
2132
2133 /* Return result */
2134 if (werror) {
2135 *werror = r.out.result;
2136 }
2137
2138 return werror_to_ntstatus(r.out.result);
2139 }
2140
2141 NTSTATUS rpccli_EnumServicesStatusExW(struct rpc_pipe_client *cli,
2142 TALLOC_CTX *mem_ctx,
2143 struct policy_handle *scmanager /* [in] [ref] */,
2144 uint32_t info_level /* [in] */,
2145 uint32_t type /* [in] */,
2146 enum svcctl_ServiceState state /* [in] */,
2147 uint8_t *services /* [out] [ref,size_is(buf_size)] */,
2148 uint32_t buf_size /* [in] [range(0,0x40000)] */,
2149 uint32_t *bytes_needed /* [out] [ref,range(0,0x40000)] */,
2150 uint32_t *service_returned /* [out] [ref,range(0,0x40000)] */,
2151 uint32_t *resume_handle /* [in,out] [unique,range(0,0x40000)] */,
2152 const char *group_name /* [in] [unique,charset(UTF16)] */,
2153 WERROR *werror)
2154 {
2155 struct EnumServicesStatusExW r;
2156 NTSTATUS status;
2157
2158 /* In parameters */
2159 r.in.scmanager = scmanager;
2160 r.in.info_level = info_level;
2161 r.in.type = type;
2162 r.in.state = state;
2163 r.in.buf_size = buf_size;
2164 r.in.resume_handle = resume_handle;
2165 r.in.group_name = group_name;
2166
2167 if (DEBUGLEVEL >= 10) {
2168 NDR_PRINT_IN_DEBUG(EnumServicesStatusExW, &r);
2169 }
2170
2171 status = cli->dispatch(cli,
2172 mem_ctx,
2173 &ndr_table_svcctl,
2174 NDR_ENUMSERVICESSTATUSEXW,
2175 &r);
2176
2177 if (!NT_STATUS_IS_OK(status)) {
2178 return status;
2179 }
2180
2181 if (DEBUGLEVEL >= 10) {
2182 NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, &r);
2183 }
2184
2185 if (NT_STATUS_IS_ERR(status)) {
2186 return status;
2187 }
2188
2189 /* Return variables */
2190 memcpy(services, r.out.services, r.in.buf_size * sizeof(*services));
2191 *bytes_needed = *r.out.bytes_needed;
2192 *service_returned = *r.out.service_returned;
2193 if (resume_handle && r.out.resume_handle) {
2194 *resume_handle = *r.out.resume_handle;
2195 }
2196
2197 /* Return result */
2198 if (werror) {
2199 *werror = r.out.result;
2200 }
2201
2202 return werror_to_ntstatus(r.out.result);
2203 }
2204
2205 NTSTATUS rpccli_svcctl_SCSendTSMessage(struct rpc_pipe_client *cli,
2206 TALLOC_CTX *mem_ctx,
2207 WERROR *werror)
2208 {
2209 struct svcctl_SCSendTSMessage r;
2210 NTSTATUS status;
2211
2212 /* In parameters */
2213
2214 if (DEBUGLEVEL >= 10) {
2215 NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, &r);
2216 }
2217
2218 status = cli->dispatch(cli,
2219 mem_ctx,
2220 &ndr_table_svcctl,
2221 NDR_SVCCTL_SCSENDTSMESSAGE,
2222 &r);
2223
2224 if (!NT_STATUS_IS_OK(status)) {
2225 return status;
2226 }
2227
2228 if (DEBUGLEVEL >= 10) {
2229 NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, &r);
2230 }
2231
2232 if (NT_STATUS_IS_ERR(status)) {
2233 return status;
2234 }
2235
2236 /* Return variables */
2237
2238 /* Return result */
2239 if (werror) {
2240 *werror = r.out.result;
2241 }
2242
2243 return werror_to_ntstatus(r.out.result);
2244 }
2245
WIP