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