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

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

Samba 3.5.0: Initial import
File size: 185.6 KB
Line 
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
9struct rpccli_svcctl_CloseServiceHandle_state {
10 struct svcctl_CloseServiceHandle orig;
11 struct svcctl_CloseServiceHandle tmp;
12 TALLOC_CTX *out_mem_ctx;
13 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14};
15
16static void rpccli_svcctl_CloseServiceHandle_done(struct tevent_req *subreq);
17
18struct tevent_req *rpccli_svcctl_CloseServiceHandle_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli,
21 struct policy_handle *_handle /* [in,out] [ref] */)
22{
23 struct tevent_req *req;
24 struct rpccli_svcctl_CloseServiceHandle_state *state;
25 struct tevent_req *subreq;
26
27 req = tevent_req_create(mem_ctx, &state,
28 struct rpccli_svcctl_CloseServiceHandle_state);
29 if (req == NULL) {
30 return NULL;
31 }
32 state->out_mem_ctx = NULL;
33 state->dispatch_recv = cli->dispatch_recv;
34
35 /* In parameters */
36 state->orig.in.handle = _handle;
37
38 /* Out parameters */
39 state->orig.out.handle = _handle;
40
41 /* Result */
42 ZERO_STRUCT(state->orig.out.result);
43
44 state->out_mem_ctx = talloc_named_const(state, 0,
45 "rpccli_svcctl_CloseServiceHandle_out_memory");
46 if (tevent_req_nomem(state->out_mem_ctx, req)) {
47 return tevent_req_post(req, ev);
48 }
49
50 /* make a temporary copy, that we pass to the dispatch function */
51 state->tmp = state->orig;
52
53 subreq = cli->dispatch_send(state, ev, cli,
54 &ndr_table_svcctl,
55 NDR_SVCCTL_CLOSESERVICEHANDLE,
56 &state->tmp);
57 if (tevent_req_nomem(subreq, req)) {
58 return tevent_req_post(req, ev);
59 }
60 tevent_req_set_callback(subreq, rpccli_svcctl_CloseServiceHandle_done, req);
61 return req;
62}
63
64static void rpccli_svcctl_CloseServiceHandle_done(struct tevent_req *subreq)
65{
66 struct tevent_req *req = tevent_req_callback_data(
67 subreq, struct tevent_req);
68 struct rpccli_svcctl_CloseServiceHandle_state *state = tevent_req_data(
69 req, struct rpccli_svcctl_CloseServiceHandle_state);
70 NTSTATUS status;
71 TALLOC_CTX *mem_ctx;
72
73 if (state->out_mem_ctx) {
74 mem_ctx = state->out_mem_ctx;
75 } else {
76 mem_ctx = state;
77 }
78
79 status = state->dispatch_recv(subreq, mem_ctx);
80 TALLOC_FREE(subreq);
81 if (!NT_STATUS_IS_OK(status)) {
82 tevent_req_nterror(req, status);
83 return;
84 }
85
86 /* Copy out parameters */
87 *state->orig.out.handle = *state->tmp.out.handle;
88
89 /* Copy result */
90 state->orig.out.result = state->tmp.out.result;
91
92 /* Reset temporary structure */
93 ZERO_STRUCT(state->tmp);
94
95 tevent_req_done(req);
96}
97
98NTSTATUS rpccli_svcctl_CloseServiceHandle_recv(struct tevent_req *req,
99 TALLOC_CTX *mem_ctx,
100 WERROR *result)
101{
102 struct rpccli_svcctl_CloseServiceHandle_state *state = tevent_req_data(
103 req, struct rpccli_svcctl_CloseServiceHandle_state);
104 NTSTATUS status;
105
106 if (tevent_req_is_nterror(req, &status)) {
107 tevent_req_received(req);
108 return status;
109 }
110
111 /* Steal possbile out parameters to the callers context */
112 talloc_steal(mem_ctx, state->out_mem_ctx);
113
114 /* Return result */
115 *result = state->orig.out.result;
116
117 tevent_req_received(req);
118 return NT_STATUS_OK;
119}
120
121NTSTATUS rpccli_svcctl_CloseServiceHandle(struct rpc_pipe_client *cli,
122 TALLOC_CTX *mem_ctx,
123 struct policy_handle *handle /* [in,out] [ref] */,
124 WERROR *werror)
125{
126 struct svcctl_CloseServiceHandle r;
127 NTSTATUS status;
128
129 /* In parameters */
130 r.in.handle = handle;
131
132 status = cli->dispatch(cli,
133 mem_ctx,
134 &ndr_table_svcctl,
135 NDR_SVCCTL_CLOSESERVICEHANDLE,
136 &r);
137
138 if (!NT_STATUS_IS_OK(status)) {
139 return status;
140 }
141
142 if (NT_STATUS_IS_ERR(status)) {
143 return status;
144 }
145
146 /* Return variables */
147 *handle = *r.out.handle;
148
149 /* Return result */
150 if (werror) {
151 *werror = r.out.result;
152 }
153
154 return werror_to_ntstatus(r.out.result);
155}
156
157struct rpccli_svcctl_ControlService_state {
158 struct svcctl_ControlService orig;
159 struct svcctl_ControlService tmp;
160 TALLOC_CTX *out_mem_ctx;
161 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
162};
163
164static void rpccli_svcctl_ControlService_done(struct tevent_req *subreq);
165
166struct tevent_req *rpccli_svcctl_ControlService_send(TALLOC_CTX *mem_ctx,
167 struct tevent_context *ev,
168 struct rpc_pipe_client *cli,
169 struct policy_handle *_handle /* [in] [ref] */,
170 enum SERVICE_CONTROL _control /* [in] */,
171 struct SERVICE_STATUS *_service_status /* [out] [ref] */)
172{
173 struct tevent_req *req;
174 struct rpccli_svcctl_ControlService_state *state;
175 struct tevent_req *subreq;
176
177 req = tevent_req_create(mem_ctx, &state,
178 struct rpccli_svcctl_ControlService_state);
179 if (req == NULL) {
180 return NULL;
181 }
182 state->out_mem_ctx = NULL;
183 state->dispatch_recv = cli->dispatch_recv;
184
185 /* In parameters */
186 state->orig.in.handle = _handle;
187 state->orig.in.control = _control;
188
189 /* Out parameters */
190 state->orig.out.service_status = _service_status;
191
192 /* Result */
193 ZERO_STRUCT(state->orig.out.result);
194
195 state->out_mem_ctx = talloc_named_const(state, 0,
196 "rpccli_svcctl_ControlService_out_memory");
197 if (tevent_req_nomem(state->out_mem_ctx, req)) {
198 return tevent_req_post(req, ev);
199 }
200
201 /* make a temporary copy, that we pass to the dispatch function */
202 state->tmp = state->orig;
203
204 subreq = cli->dispatch_send(state, ev, cli,
205 &ndr_table_svcctl,
206 NDR_SVCCTL_CONTROLSERVICE,
207 &state->tmp);
208 if (tevent_req_nomem(subreq, req)) {
209 return tevent_req_post(req, ev);
210 }
211 tevent_req_set_callback(subreq, rpccli_svcctl_ControlService_done, req);
212 return req;
213}
214
215static void rpccli_svcctl_ControlService_done(struct tevent_req *subreq)
216{
217 struct tevent_req *req = tevent_req_callback_data(
218 subreq, struct tevent_req);
219 struct rpccli_svcctl_ControlService_state *state = tevent_req_data(
220 req, struct rpccli_svcctl_ControlService_state);
221 NTSTATUS status;
222 TALLOC_CTX *mem_ctx;
223
224 if (state->out_mem_ctx) {
225 mem_ctx = state->out_mem_ctx;
226 } else {
227 mem_ctx = state;
228 }
229
230 status = state->dispatch_recv(subreq, mem_ctx);
231 TALLOC_FREE(subreq);
232 if (!NT_STATUS_IS_OK(status)) {
233 tevent_req_nterror(req, status);
234 return;
235 }
236
237 /* Copy out parameters */
238 *state->orig.out.service_status = *state->tmp.out.service_status;
239
240 /* Copy result */
241 state->orig.out.result = state->tmp.out.result;
242
243 /* Reset temporary structure */
244 ZERO_STRUCT(state->tmp);
245
246 tevent_req_done(req);
247}
248
249NTSTATUS rpccli_svcctl_ControlService_recv(struct tevent_req *req,
250 TALLOC_CTX *mem_ctx,
251 WERROR *result)
252{
253 struct rpccli_svcctl_ControlService_state *state = tevent_req_data(
254 req, struct rpccli_svcctl_ControlService_state);
255 NTSTATUS status;
256
257 if (tevent_req_is_nterror(req, &status)) {
258 tevent_req_received(req);
259 return status;
260 }
261
262 /* Steal possbile out parameters to the callers context */
263 talloc_steal(mem_ctx, state->out_mem_ctx);
264
265 /* Return result */
266 *result = state->orig.out.result;
267
268 tevent_req_received(req);
269 return NT_STATUS_OK;
270}
271
272NTSTATUS rpccli_svcctl_ControlService(struct rpc_pipe_client *cli,
273 TALLOC_CTX *mem_ctx,
274 struct policy_handle *handle /* [in] [ref] */,
275 enum SERVICE_CONTROL control /* [in] */,
276 struct SERVICE_STATUS *service_status /* [out] [ref] */,
277 WERROR *werror)
278{
279 struct svcctl_ControlService r;
280 NTSTATUS status;
281
282 /* In parameters */
283 r.in.handle = handle;
284 r.in.control = control;
285
286 status = cli->dispatch(cli,
287 mem_ctx,
288 &ndr_table_svcctl,
289 NDR_SVCCTL_CONTROLSERVICE,
290 &r);
291
292 if (!NT_STATUS_IS_OK(status)) {
293 return status;
294 }
295
296 if (NT_STATUS_IS_ERR(status)) {
297 return status;
298 }
299
300 /* Return variables */
301 *service_status = *r.out.service_status;
302
303 /* Return result */
304 if (werror) {
305 *werror = r.out.result;
306 }
307
308 return werror_to_ntstatus(r.out.result);
309}
310
311struct rpccli_svcctl_DeleteService_state {
312 struct svcctl_DeleteService orig;
313 struct svcctl_DeleteService tmp;
314 TALLOC_CTX *out_mem_ctx;
315 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
316};
317
318static void rpccli_svcctl_DeleteService_done(struct tevent_req *subreq);
319
320struct tevent_req *rpccli_svcctl_DeleteService_send(TALLOC_CTX *mem_ctx,
321 struct tevent_context *ev,
322 struct rpc_pipe_client *cli,
323 struct policy_handle *_handle /* [in] [ref] */)
324{
325 struct tevent_req *req;
326 struct rpccli_svcctl_DeleteService_state *state;
327 struct tevent_req *subreq;
328
329 req = tevent_req_create(mem_ctx, &state,
330 struct rpccli_svcctl_DeleteService_state);
331 if (req == NULL) {
332 return NULL;
333 }
334 state->out_mem_ctx = NULL;
335 state->dispatch_recv = cli->dispatch_recv;
336
337 /* In parameters */
338 state->orig.in.handle = _handle;
339
340 /* Out parameters */
341
342 /* Result */
343 ZERO_STRUCT(state->orig.out.result);
344
345 /* make a temporary copy, that we pass to the dispatch function */
346 state->tmp = state->orig;
347
348 subreq = cli->dispatch_send(state, ev, cli,
349 &ndr_table_svcctl,
350 NDR_SVCCTL_DELETESERVICE,
351 &state->tmp);
352 if (tevent_req_nomem(subreq, req)) {
353 return tevent_req_post(req, ev);
354 }
355 tevent_req_set_callback(subreq, rpccli_svcctl_DeleteService_done, req);
356 return req;
357}
358
359static void rpccli_svcctl_DeleteService_done(struct tevent_req *subreq)
360{
361 struct tevent_req *req = tevent_req_callback_data(
362 subreq, struct tevent_req);
363 struct rpccli_svcctl_DeleteService_state *state = tevent_req_data(
364 req, struct rpccli_svcctl_DeleteService_state);
365 NTSTATUS status;
366 TALLOC_CTX *mem_ctx;
367
368 if (state->out_mem_ctx) {
369 mem_ctx = state->out_mem_ctx;
370 } else {
371 mem_ctx = state;
372 }
373
374 status = state->dispatch_recv(subreq, mem_ctx);
375 TALLOC_FREE(subreq);
376 if (!NT_STATUS_IS_OK(status)) {
377 tevent_req_nterror(req, status);
378 return;
379 }
380
381 /* Copy out parameters */
382
383 /* Copy result */
384 state->orig.out.result = state->tmp.out.result;
385
386 /* Reset temporary structure */
387 ZERO_STRUCT(state->tmp);
388
389 tevent_req_done(req);
390}
391
392NTSTATUS rpccli_svcctl_DeleteService_recv(struct tevent_req *req,
393 TALLOC_CTX *mem_ctx,
394 WERROR *result)
395{
396 struct rpccli_svcctl_DeleteService_state *state = tevent_req_data(
397 req, struct rpccli_svcctl_DeleteService_state);
398 NTSTATUS status;
399
400 if (tevent_req_is_nterror(req, &status)) {
401 tevent_req_received(req);
402 return status;
403 }
404
405 /* Steal possbile out parameters to the callers context */
406 talloc_steal(mem_ctx, state->out_mem_ctx);
407
408 /* Return result */
409 *result = state->orig.out.result;
410
411 tevent_req_received(req);
412 return NT_STATUS_OK;
413}
414
415NTSTATUS rpccli_svcctl_DeleteService(struct rpc_pipe_client *cli,
416 TALLOC_CTX *mem_ctx,
417 struct policy_handle *handle /* [in] [ref] */,
418 WERROR *werror)
419{
420 struct svcctl_DeleteService r;
421 NTSTATUS status;
422
423 /* In parameters */
424 r.in.handle = handle;
425
426 status = cli->dispatch(cli,
427 mem_ctx,
428 &ndr_table_svcctl,
429 NDR_SVCCTL_DELETESERVICE,
430 &r);
431
432 if (!NT_STATUS_IS_OK(status)) {
433 return status;
434 }
435
436 if (NT_STATUS_IS_ERR(status)) {
437 return status;
438 }
439
440 /* Return variables */
441
442 /* Return result */
443 if (werror) {
444 *werror = r.out.result;
445 }
446
447 return werror_to_ntstatus(r.out.result);
448}
449
450struct rpccli_svcctl_LockServiceDatabase_state {
451 struct svcctl_LockServiceDatabase orig;
452 struct svcctl_LockServiceDatabase tmp;
453 TALLOC_CTX *out_mem_ctx;
454 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
455};
456
457static void rpccli_svcctl_LockServiceDatabase_done(struct tevent_req *subreq);
458
459struct tevent_req *rpccli_svcctl_LockServiceDatabase_send(TALLOC_CTX *mem_ctx,
460 struct tevent_context *ev,
461 struct rpc_pipe_client *cli,
462 struct policy_handle *_handle /* [in] [ref] */,
463 struct policy_handle *_lock /* [out] [ref] */)
464{
465 struct tevent_req *req;
466 struct rpccli_svcctl_LockServiceDatabase_state *state;
467 struct tevent_req *subreq;
468
469 req = tevent_req_create(mem_ctx, &state,
470 struct rpccli_svcctl_LockServiceDatabase_state);
471 if (req == NULL) {
472 return NULL;
473 }
474 state->out_mem_ctx = NULL;
475 state->dispatch_recv = cli->dispatch_recv;
476
477 /* In parameters */
478 state->orig.in.handle = _handle;
479
480 /* Out parameters */
481 state->orig.out.lock = _lock;
482
483 /* Result */
484 ZERO_STRUCT(state->orig.out.result);
485
486 state->out_mem_ctx = talloc_named_const(state, 0,
487 "rpccli_svcctl_LockServiceDatabase_out_memory");
488 if (tevent_req_nomem(state->out_mem_ctx, req)) {
489 return tevent_req_post(req, ev);
490 }
491
492 /* make a temporary copy, that we pass to the dispatch function */
493 state->tmp = state->orig;
494
495 subreq = cli->dispatch_send(state, ev, cli,
496 &ndr_table_svcctl,
497 NDR_SVCCTL_LOCKSERVICEDATABASE,
498 &state->tmp);
499 if (tevent_req_nomem(subreq, req)) {
500 return tevent_req_post(req, ev);
501 }
502 tevent_req_set_callback(subreq, rpccli_svcctl_LockServiceDatabase_done, req);
503 return req;
504}
505
506static void rpccli_svcctl_LockServiceDatabase_done(struct tevent_req *subreq)
507{
508 struct tevent_req *req = tevent_req_callback_data(
509 subreq, struct tevent_req);
510 struct rpccli_svcctl_LockServiceDatabase_state *state = tevent_req_data(
511 req, struct rpccli_svcctl_LockServiceDatabase_state);
512 NTSTATUS status;
513 TALLOC_CTX *mem_ctx;
514
515 if (state->out_mem_ctx) {
516 mem_ctx = state->out_mem_ctx;
517 } else {
518 mem_ctx = state;
519 }
520
521 status = state->dispatch_recv(subreq, mem_ctx);
522 TALLOC_FREE(subreq);
523 if (!NT_STATUS_IS_OK(status)) {
524 tevent_req_nterror(req, status);
525 return;
526 }
527
528 /* Copy out parameters */
529 *state->orig.out.lock = *state->tmp.out.lock;
530
531 /* Copy result */
532 state->orig.out.result = state->tmp.out.result;
533
534 /* Reset temporary structure */
535 ZERO_STRUCT(state->tmp);
536
537 tevent_req_done(req);
538}
539
540NTSTATUS rpccli_svcctl_LockServiceDatabase_recv(struct tevent_req *req,
541 TALLOC_CTX *mem_ctx,
542 WERROR *result)
543{
544 struct rpccli_svcctl_LockServiceDatabase_state *state = tevent_req_data(
545 req, struct rpccli_svcctl_LockServiceDatabase_state);
546 NTSTATUS status;
547
548 if (tevent_req_is_nterror(req, &status)) {
549 tevent_req_received(req);
550 return status;
551 }
552
553 /* Steal possbile out parameters to the callers context */
554 talloc_steal(mem_ctx, state->out_mem_ctx);
555
556 /* Return result */
557 *result = state->orig.out.result;
558
559 tevent_req_received(req);
560 return NT_STATUS_OK;
561}
562
563NTSTATUS rpccli_svcctl_LockServiceDatabase(struct rpc_pipe_client *cli,
564 TALLOC_CTX *mem_ctx,
565 struct policy_handle *handle /* [in] [ref] */,
566 struct policy_handle *lock /* [out] [ref] */,
567 WERROR *werror)
568{
569 struct svcctl_LockServiceDatabase r;
570 NTSTATUS status;
571
572 /* In parameters */
573 r.in.handle = handle;
574
575 status = cli->dispatch(cli,
576 mem_ctx,
577 &ndr_table_svcctl,
578 NDR_SVCCTL_LOCKSERVICEDATABASE,
579 &r);
580
581 if (!NT_STATUS_IS_OK(status)) {
582 return status;
583 }
584
585 if (NT_STATUS_IS_ERR(status)) {
586 return status;
587 }
588
589 /* Return variables */
590 *lock = *r.out.lock;
591
592 /* Return result */
593 if (werror) {
594 *werror = r.out.result;
595 }
596
597 return werror_to_ntstatus(r.out.result);
598}
599
600struct rpccli_svcctl_QueryServiceObjectSecurity_state {
601 struct svcctl_QueryServiceObjectSecurity orig;
602 struct svcctl_QueryServiceObjectSecurity tmp;
603 TALLOC_CTX *out_mem_ctx;
604 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
605};
606
607static void rpccli_svcctl_QueryServiceObjectSecurity_done(struct tevent_req *subreq);
608
609struct tevent_req *rpccli_svcctl_QueryServiceObjectSecurity_send(TALLOC_CTX *mem_ctx,
610 struct tevent_context *ev,
611 struct rpc_pipe_client *cli,
612 struct policy_handle *_handle /* [in] [ref] */,
613 uint32_t _security_flags /* [in] */,
614 uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
615 uint32_t _offered /* [in] [range(0,0x40000)] */,
616 uint32_t *_needed /* [out] [ref,range(0,0x40000)] */)
617{
618 struct tevent_req *req;
619 struct rpccli_svcctl_QueryServiceObjectSecurity_state *state;
620 struct tevent_req *subreq;
621
622 req = tevent_req_create(mem_ctx, &state,
623 struct rpccli_svcctl_QueryServiceObjectSecurity_state);
624 if (req == NULL) {
625 return NULL;
626 }
627 state->out_mem_ctx = NULL;
628 state->dispatch_recv = cli->dispatch_recv;
629
630 /* In parameters */
631 state->orig.in.handle = _handle;
632 state->orig.in.security_flags = _security_flags;
633 state->orig.in.offered = _offered;
634
635 /* Out parameters */
636 state->orig.out.buffer = _buffer;
637 state->orig.out.needed = _needed;
638
639 /* Result */
640 ZERO_STRUCT(state->orig.out.result);
641
642 state->out_mem_ctx = talloc_named_const(state, 0,
643 "rpccli_svcctl_QueryServiceObjectSecurity_out_memory");
644 if (tevent_req_nomem(state->out_mem_ctx, req)) {
645 return tevent_req_post(req, ev);
646 }
647
648 /* make a temporary copy, that we pass to the dispatch function */
649 state->tmp = state->orig;
650
651 subreq = cli->dispatch_send(state, ev, cli,
652 &ndr_table_svcctl,
653 NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY,
654 &state->tmp);
655 if (tevent_req_nomem(subreq, req)) {
656 return tevent_req_post(req, ev);
657 }
658 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceObjectSecurity_done, req);
659 return req;
660}
661
662static void rpccli_svcctl_QueryServiceObjectSecurity_done(struct tevent_req *subreq)
663{
664 struct tevent_req *req = tevent_req_callback_data(
665 subreq, struct tevent_req);
666 struct rpccli_svcctl_QueryServiceObjectSecurity_state *state = tevent_req_data(
667 req, struct rpccli_svcctl_QueryServiceObjectSecurity_state);
668 NTSTATUS status;
669 TALLOC_CTX *mem_ctx;
670
671 if (state->out_mem_ctx) {
672 mem_ctx = state->out_mem_ctx;
673 } else {
674 mem_ctx = state;
675 }
676
677 status = state->dispatch_recv(subreq, mem_ctx);
678 TALLOC_FREE(subreq);
679 if (!NT_STATUS_IS_OK(status)) {
680 tevent_req_nterror(req, status);
681 return;
682 }
683
684 /* Copy out parameters */
685 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
686 *state->orig.out.needed = *state->tmp.out.needed;
687
688 /* Copy result */
689 state->orig.out.result = state->tmp.out.result;
690
691 /* Reset temporary structure */
692 ZERO_STRUCT(state->tmp);
693
694 tevent_req_done(req);
695}
696
697NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity_recv(struct tevent_req *req,
698 TALLOC_CTX *mem_ctx,
699 WERROR *result)
700{
701 struct rpccli_svcctl_QueryServiceObjectSecurity_state *state = tevent_req_data(
702 req, struct rpccli_svcctl_QueryServiceObjectSecurity_state);
703 NTSTATUS status;
704
705 if (tevent_req_is_nterror(req, &status)) {
706 tevent_req_received(req);
707 return status;
708 }
709
710 /* Steal possbile out parameters to the callers context */
711 talloc_steal(mem_ctx, state->out_mem_ctx);
712
713 /* Return result */
714 *result = state->orig.out.result;
715
716 tevent_req_received(req);
717 return NT_STATUS_OK;
718}
719
720NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity(struct rpc_pipe_client *cli,
721 TALLOC_CTX *mem_ctx,
722 struct policy_handle *handle /* [in] [ref] */,
723 uint32_t security_flags /* [in] */,
724 uint8_t *buffer /* [out] [ref,size_is(offered)] */,
725 uint32_t offered /* [in] [range(0,0x40000)] */,
726 uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
727 WERROR *werror)
728{
729 struct svcctl_QueryServiceObjectSecurity r;
730 NTSTATUS status;
731
732 /* In parameters */
733 r.in.handle = handle;
734 r.in.security_flags = security_flags;
735 r.in.offered = offered;
736
737 status = cli->dispatch(cli,
738 mem_ctx,
739 &ndr_table_svcctl,
740 NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY,
741 &r);
742
743 if (!NT_STATUS_IS_OK(status)) {
744 return status;
745 }
746
747 if (NT_STATUS_IS_ERR(status)) {
748 return status;
749 }
750
751 /* Return variables */
752 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
753 *needed = *r.out.needed;
754
755 /* Return result */
756 if (werror) {
757 *werror = r.out.result;
758 }
759
760 return werror_to_ntstatus(r.out.result);
761}
762
763struct rpccli_svcctl_SetServiceObjectSecurity_state {
764 struct svcctl_SetServiceObjectSecurity orig;
765 struct svcctl_SetServiceObjectSecurity tmp;
766 TALLOC_CTX *out_mem_ctx;
767 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
768};
769
770static void rpccli_svcctl_SetServiceObjectSecurity_done(struct tevent_req *subreq);
771
772struct tevent_req *rpccli_svcctl_SetServiceObjectSecurity_send(TALLOC_CTX *mem_ctx,
773 struct tevent_context *ev,
774 struct rpc_pipe_client *cli,
775 struct policy_handle *_handle /* [in] [ref] */,
776 uint32_t _security_flags /* [in] */,
777 uint8_t *_buffer /* [in] [ref,size_is(offered)] */,
778 uint32_t _offered /* [in] */)
779{
780 struct tevent_req *req;
781 struct rpccli_svcctl_SetServiceObjectSecurity_state *state;
782 struct tevent_req *subreq;
783
784 req = tevent_req_create(mem_ctx, &state,
785 struct rpccli_svcctl_SetServiceObjectSecurity_state);
786 if (req == NULL) {
787 return NULL;
788 }
789 state->out_mem_ctx = NULL;
790 state->dispatch_recv = cli->dispatch_recv;
791
792 /* In parameters */
793 state->orig.in.handle = _handle;
794 state->orig.in.security_flags = _security_flags;
795 state->orig.in.buffer = _buffer;
796 state->orig.in.offered = _offered;
797
798 /* Out parameters */
799
800 /* Result */
801 ZERO_STRUCT(state->orig.out.result);
802
803 /* make a temporary copy, that we pass to the dispatch function */
804 state->tmp = state->orig;
805
806 subreq = cli->dispatch_send(state, ev, cli,
807 &ndr_table_svcctl,
808 NDR_SVCCTL_SETSERVICEOBJECTSECURITY,
809 &state->tmp);
810 if (tevent_req_nomem(subreq, req)) {
811 return tevent_req_post(req, ev);
812 }
813 tevent_req_set_callback(subreq, rpccli_svcctl_SetServiceObjectSecurity_done, req);
814 return req;
815}
816
817static void rpccli_svcctl_SetServiceObjectSecurity_done(struct tevent_req *subreq)
818{
819 struct tevent_req *req = tevent_req_callback_data(
820 subreq, struct tevent_req);
821 struct rpccli_svcctl_SetServiceObjectSecurity_state *state = tevent_req_data(
822 req, struct rpccli_svcctl_SetServiceObjectSecurity_state);
823 NTSTATUS status;
824 TALLOC_CTX *mem_ctx;
825
826 if (state->out_mem_ctx) {
827 mem_ctx = state->out_mem_ctx;
828 } else {
829 mem_ctx = state;
830 }
831
832 status = state->dispatch_recv(subreq, mem_ctx);
833 TALLOC_FREE(subreq);
834 if (!NT_STATUS_IS_OK(status)) {
835 tevent_req_nterror(req, status);
836 return;
837 }
838
839 /* Copy out parameters */
840
841 /* Copy result */
842 state->orig.out.result = state->tmp.out.result;
843
844 /* Reset temporary structure */
845 ZERO_STRUCT(state->tmp);
846
847 tevent_req_done(req);
848}
849
850NTSTATUS rpccli_svcctl_SetServiceObjectSecurity_recv(struct tevent_req *req,
851 TALLOC_CTX *mem_ctx,
852 WERROR *result)
853{
854 struct rpccli_svcctl_SetServiceObjectSecurity_state *state = tevent_req_data(
855 req, struct rpccli_svcctl_SetServiceObjectSecurity_state);
856 NTSTATUS status;
857
858 if (tevent_req_is_nterror(req, &status)) {
859 tevent_req_received(req);
860 return status;
861 }
862
863 /* Steal possbile out parameters to the callers context */
864 talloc_steal(mem_ctx, state->out_mem_ctx);
865
866 /* Return result */
867 *result = state->orig.out.result;
868
869 tevent_req_received(req);
870 return NT_STATUS_OK;
871}
872
873NTSTATUS rpccli_svcctl_SetServiceObjectSecurity(struct rpc_pipe_client *cli,
874 TALLOC_CTX *mem_ctx,
875 struct policy_handle *handle /* [in] [ref] */,
876 uint32_t security_flags /* [in] */,
877 uint8_t *buffer /* [in] [ref,size_is(offered)] */,
878 uint32_t offered /* [in] */,
879 WERROR *werror)
880{
881 struct svcctl_SetServiceObjectSecurity r;
882 NTSTATUS status;
883
884 /* In parameters */
885 r.in.handle = handle;
886 r.in.security_flags = security_flags;
887 r.in.buffer = buffer;
888 r.in.offered = offered;
889
890 status = cli->dispatch(cli,
891 mem_ctx,
892 &ndr_table_svcctl,
893 NDR_SVCCTL_SETSERVICEOBJECTSECURITY,
894 &r);
895
896 if (!NT_STATUS_IS_OK(status)) {
897 return status;
898 }
899
900 if (NT_STATUS_IS_ERR(status)) {
901 return status;
902 }
903
904 /* Return variables */
905
906 /* Return result */
907 if (werror) {
908 *werror = r.out.result;
909 }
910
911 return werror_to_ntstatus(r.out.result);
912}
913
914struct rpccli_svcctl_QueryServiceStatus_state {
915 struct svcctl_QueryServiceStatus orig;
916 struct svcctl_QueryServiceStatus tmp;
917 TALLOC_CTX *out_mem_ctx;
918 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
919};
920
921static void rpccli_svcctl_QueryServiceStatus_done(struct tevent_req *subreq);
922
923struct tevent_req *rpccli_svcctl_QueryServiceStatus_send(TALLOC_CTX *mem_ctx,
924 struct tevent_context *ev,
925 struct rpc_pipe_client *cli,
926 struct policy_handle *_handle /* [in] [ref] */,
927 struct SERVICE_STATUS *_service_status /* [out] [ref] */)
928{
929 struct tevent_req *req;
930 struct rpccli_svcctl_QueryServiceStatus_state *state;
931 struct tevent_req *subreq;
932
933 req = tevent_req_create(mem_ctx, &state,
934 struct rpccli_svcctl_QueryServiceStatus_state);
935 if (req == NULL) {
936 return NULL;
937 }
938 state->out_mem_ctx = NULL;
939 state->dispatch_recv = cli->dispatch_recv;
940
941 /* In parameters */
942 state->orig.in.handle = _handle;
943
944 /* Out parameters */
945 state->orig.out.service_status = _service_status;
946
947 /* Result */
948 ZERO_STRUCT(state->orig.out.result);
949
950 state->out_mem_ctx = talloc_named_const(state, 0,
951 "rpccli_svcctl_QueryServiceStatus_out_memory");
952 if (tevent_req_nomem(state->out_mem_ctx, req)) {
953 return tevent_req_post(req, ev);
954 }
955
956 /* make a temporary copy, that we pass to the dispatch function */
957 state->tmp = state->orig;
958
959 subreq = cli->dispatch_send(state, ev, cli,
960 &ndr_table_svcctl,
961 NDR_SVCCTL_QUERYSERVICESTATUS,
962 &state->tmp);
963 if (tevent_req_nomem(subreq, req)) {
964 return tevent_req_post(req, ev);
965 }
966 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceStatus_done, req);
967 return req;
968}
969
970static void rpccli_svcctl_QueryServiceStatus_done(struct tevent_req *subreq)
971{
972 struct tevent_req *req = tevent_req_callback_data(
973 subreq, struct tevent_req);
974 struct rpccli_svcctl_QueryServiceStatus_state *state = tevent_req_data(
975 req, struct rpccli_svcctl_QueryServiceStatus_state);
976 NTSTATUS status;
977 TALLOC_CTX *mem_ctx;
978
979 if (state->out_mem_ctx) {
980 mem_ctx = state->out_mem_ctx;
981 } else {
982 mem_ctx = state;
983 }
984
985 status = state->dispatch_recv(subreq, mem_ctx);
986 TALLOC_FREE(subreq);
987 if (!NT_STATUS_IS_OK(status)) {
988 tevent_req_nterror(req, status);
989 return;
990 }
991
992 /* Copy out parameters */
993 *state->orig.out.service_status = *state->tmp.out.service_status;
994
995 /* Copy result */
996 state->orig.out.result = state->tmp.out.result;
997
998 /* Reset temporary structure */
999 ZERO_STRUCT(state->tmp);
1000
1001 tevent_req_done(req);
1002}
1003
1004NTSTATUS rpccli_svcctl_QueryServiceStatus_recv(struct tevent_req *req,
1005 TALLOC_CTX *mem_ctx,
1006 WERROR *result)
1007{
1008 struct rpccli_svcctl_QueryServiceStatus_state *state = tevent_req_data(
1009 req, struct rpccli_svcctl_QueryServiceStatus_state);
1010 NTSTATUS status;
1011
1012 if (tevent_req_is_nterror(req, &status)) {
1013 tevent_req_received(req);
1014 return status;
1015 }
1016
1017 /* Steal possbile out parameters to the callers context */
1018 talloc_steal(mem_ctx, state->out_mem_ctx);
1019
1020 /* Return result */
1021 *result = state->orig.out.result;
1022
1023 tevent_req_received(req);
1024 return NT_STATUS_OK;
1025}
1026
1027NTSTATUS rpccli_svcctl_QueryServiceStatus(struct rpc_pipe_client *cli,
1028 TALLOC_CTX *mem_ctx,
1029 struct policy_handle *handle /* [in] [ref] */,
1030 struct SERVICE_STATUS *service_status /* [out] [ref] */,
1031 WERROR *werror)
1032{
1033 struct svcctl_QueryServiceStatus r;
1034 NTSTATUS status;
1035
1036 /* In parameters */
1037 r.in.handle = handle;
1038
1039 status = cli->dispatch(cli,
1040 mem_ctx,
1041 &ndr_table_svcctl,
1042 NDR_SVCCTL_QUERYSERVICESTATUS,
1043 &r);
1044
1045 if (!NT_STATUS_IS_OK(status)) {
1046 return status;
1047 }
1048
1049 if (NT_STATUS_IS_ERR(status)) {
1050 return status;
1051 }
1052
1053 /* Return variables */
1054 *service_status = *r.out.service_status;
1055
1056 /* Return result */
1057 if (werror) {
1058 *werror = r.out.result;
1059 }
1060
1061 return werror_to_ntstatus(r.out.result);
1062}
1063
1064struct rpccli_svcctl_SetServiceStatus_state {
1065 struct svcctl_SetServiceStatus orig;
1066 struct svcctl_SetServiceStatus tmp;
1067 TALLOC_CTX *out_mem_ctx;
1068 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1069};
1070
1071static void rpccli_svcctl_SetServiceStatus_done(struct tevent_req *subreq);
1072
1073struct tevent_req *rpccli_svcctl_SetServiceStatus_send(TALLOC_CTX *mem_ctx,
1074 struct tevent_context *ev,
1075 struct rpc_pipe_client *cli)
1076{
1077 struct tevent_req *req;
1078 struct rpccli_svcctl_SetServiceStatus_state *state;
1079 struct tevent_req *subreq;
1080
1081 req = tevent_req_create(mem_ctx, &state,
1082 struct rpccli_svcctl_SetServiceStatus_state);
1083 if (req == NULL) {
1084 return NULL;
1085 }
1086 state->out_mem_ctx = NULL;
1087 state->dispatch_recv = cli->dispatch_recv;
1088
1089 /* In parameters */
1090
1091 /* Out parameters */
1092
1093 /* Result */
1094 ZERO_STRUCT(state->orig.out.result);
1095
1096 /* make a temporary copy, that we pass to the dispatch function */
1097 state->tmp = state->orig;
1098
1099 subreq = cli->dispatch_send(state, ev, cli,
1100 &ndr_table_svcctl,
1101 NDR_SVCCTL_SETSERVICESTATUS,
1102 &state->tmp);
1103 if (tevent_req_nomem(subreq, req)) {
1104 return tevent_req_post(req, ev);
1105 }
1106 tevent_req_set_callback(subreq, rpccli_svcctl_SetServiceStatus_done, req);
1107 return req;
1108}
1109
1110static void rpccli_svcctl_SetServiceStatus_done(struct tevent_req *subreq)
1111{
1112 struct tevent_req *req = tevent_req_callback_data(
1113 subreq, struct tevent_req);
1114 struct rpccli_svcctl_SetServiceStatus_state *state = tevent_req_data(
1115 req, struct rpccli_svcctl_SetServiceStatus_state);
1116 NTSTATUS status;
1117 TALLOC_CTX *mem_ctx;
1118
1119 if (state->out_mem_ctx) {
1120 mem_ctx = state->out_mem_ctx;
1121 } else {
1122 mem_ctx = state;
1123 }
1124
1125 status = state->dispatch_recv(subreq, mem_ctx);
1126 TALLOC_FREE(subreq);
1127 if (!NT_STATUS_IS_OK(status)) {
1128 tevent_req_nterror(req, status);
1129 return;
1130 }
1131
1132 /* Copy out parameters */
1133
1134 /* Copy result */
1135 state->orig.out.result = state->tmp.out.result;
1136
1137 /* Reset temporary structure */
1138 ZERO_STRUCT(state->tmp);
1139
1140 tevent_req_done(req);
1141}
1142
1143NTSTATUS rpccli_svcctl_SetServiceStatus_recv(struct tevent_req *req,
1144 TALLOC_CTX *mem_ctx,
1145 WERROR *result)
1146{
1147 struct rpccli_svcctl_SetServiceStatus_state *state = tevent_req_data(
1148 req, struct rpccli_svcctl_SetServiceStatus_state);
1149 NTSTATUS status;
1150
1151 if (tevent_req_is_nterror(req, &status)) {
1152 tevent_req_received(req);
1153 return status;
1154 }
1155
1156 /* Steal possbile out parameters to the callers context */
1157 talloc_steal(mem_ctx, state->out_mem_ctx);
1158
1159 /* Return result */
1160 *result = state->orig.out.result;
1161
1162 tevent_req_received(req);
1163 return NT_STATUS_OK;
1164}
1165
1166NTSTATUS rpccli_svcctl_SetServiceStatus(struct rpc_pipe_client *cli,
1167 TALLOC_CTX *mem_ctx,
1168 WERROR *werror)
1169{
1170 struct svcctl_SetServiceStatus r;
1171 NTSTATUS status;
1172
1173 /* In parameters */
1174
1175 status = cli->dispatch(cli,
1176 mem_ctx,
1177 &ndr_table_svcctl,
1178 NDR_SVCCTL_SETSERVICESTATUS,
1179 &r);
1180
1181 if (!NT_STATUS_IS_OK(status)) {
1182 return status;
1183 }
1184
1185 if (NT_STATUS_IS_ERR(status)) {
1186 return status;
1187 }
1188
1189 /* Return variables */
1190
1191 /* Return result */
1192 if (werror) {
1193 *werror = r.out.result;
1194 }
1195
1196 return werror_to_ntstatus(r.out.result);
1197}
1198
1199struct rpccli_svcctl_UnlockServiceDatabase_state {
1200 struct svcctl_UnlockServiceDatabase orig;
1201 struct svcctl_UnlockServiceDatabase tmp;
1202 TALLOC_CTX *out_mem_ctx;
1203 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1204};
1205
1206static void rpccli_svcctl_UnlockServiceDatabase_done(struct tevent_req *subreq);
1207
1208struct tevent_req *rpccli_svcctl_UnlockServiceDatabase_send(TALLOC_CTX *mem_ctx,
1209 struct tevent_context *ev,
1210 struct rpc_pipe_client *cli,
1211 struct policy_handle *_lock /* [in,out] [ref] */)
1212{
1213 struct tevent_req *req;
1214 struct rpccli_svcctl_UnlockServiceDatabase_state *state;
1215 struct tevent_req *subreq;
1216
1217 req = tevent_req_create(mem_ctx, &state,
1218 struct rpccli_svcctl_UnlockServiceDatabase_state);
1219 if (req == NULL) {
1220 return NULL;
1221 }
1222 state->out_mem_ctx = NULL;
1223 state->dispatch_recv = cli->dispatch_recv;
1224
1225 /* In parameters */
1226 state->orig.in.lock = _lock;
1227
1228 /* Out parameters */
1229 state->orig.out.lock = _lock;
1230
1231 /* Result */
1232 ZERO_STRUCT(state->orig.out.result);
1233
1234 state->out_mem_ctx = talloc_named_const(state, 0,
1235 "rpccli_svcctl_UnlockServiceDatabase_out_memory");
1236 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1237 return tevent_req_post(req, ev);
1238 }
1239
1240 /* make a temporary copy, that we pass to the dispatch function */
1241 state->tmp = state->orig;
1242
1243 subreq = cli->dispatch_send(state, ev, cli,
1244 &ndr_table_svcctl,
1245 NDR_SVCCTL_UNLOCKSERVICEDATABASE,
1246 &state->tmp);
1247 if (tevent_req_nomem(subreq, req)) {
1248 return tevent_req_post(req, ev);
1249 }
1250 tevent_req_set_callback(subreq, rpccli_svcctl_UnlockServiceDatabase_done, req);
1251 return req;
1252}
1253
1254static void rpccli_svcctl_UnlockServiceDatabase_done(struct tevent_req *subreq)
1255{
1256 struct tevent_req *req = tevent_req_callback_data(
1257 subreq, struct tevent_req);
1258 struct rpccli_svcctl_UnlockServiceDatabase_state *state = tevent_req_data(
1259 req, struct rpccli_svcctl_UnlockServiceDatabase_state);
1260 NTSTATUS status;
1261 TALLOC_CTX *mem_ctx;
1262
1263 if (state->out_mem_ctx) {
1264 mem_ctx = state->out_mem_ctx;
1265 } else {
1266 mem_ctx = state;
1267 }
1268
1269 status = state->dispatch_recv(subreq, mem_ctx);
1270 TALLOC_FREE(subreq);
1271 if (!NT_STATUS_IS_OK(status)) {
1272 tevent_req_nterror(req, status);
1273 return;
1274 }
1275
1276 /* Copy out parameters */
1277 *state->orig.out.lock = *state->tmp.out.lock;
1278
1279 /* Copy result */
1280 state->orig.out.result = state->tmp.out.result;
1281
1282 /* Reset temporary structure */
1283 ZERO_STRUCT(state->tmp);
1284
1285 tevent_req_done(req);
1286}
1287
1288NTSTATUS rpccli_svcctl_UnlockServiceDatabase_recv(struct tevent_req *req,
1289 TALLOC_CTX *mem_ctx,
1290 WERROR *result)
1291{
1292 struct rpccli_svcctl_UnlockServiceDatabase_state *state = tevent_req_data(
1293 req, struct rpccli_svcctl_UnlockServiceDatabase_state);
1294 NTSTATUS status;
1295
1296 if (tevent_req_is_nterror(req, &status)) {
1297 tevent_req_received(req);
1298 return status;
1299 }
1300
1301 /* Steal possbile out parameters to the callers context */
1302 talloc_steal(mem_ctx, state->out_mem_ctx);
1303
1304 /* Return result */
1305 *result = state->orig.out.result;
1306
1307 tevent_req_received(req);
1308 return NT_STATUS_OK;
1309}
1310
1311NTSTATUS rpccli_svcctl_UnlockServiceDatabase(struct rpc_pipe_client *cli,
1312 TALLOC_CTX *mem_ctx,
1313 struct policy_handle *lock /* [in,out] [ref] */,
1314 WERROR *werror)
1315{
1316 struct svcctl_UnlockServiceDatabase r;
1317 NTSTATUS status;
1318
1319 /* In parameters */
1320 r.in.lock = lock;
1321
1322 status = cli->dispatch(cli,
1323 mem_ctx,
1324 &ndr_table_svcctl,
1325 NDR_SVCCTL_UNLOCKSERVICEDATABASE,
1326 &r);
1327
1328 if (!NT_STATUS_IS_OK(status)) {
1329 return status;
1330 }
1331
1332 if (NT_STATUS_IS_ERR(status)) {
1333 return status;
1334 }
1335
1336 /* Return variables */
1337 *lock = *r.out.lock;
1338
1339 /* Return result */
1340 if (werror) {
1341 *werror = r.out.result;
1342 }
1343
1344 return werror_to_ntstatus(r.out.result);
1345}
1346
1347struct rpccli_svcctl_NotifyBootConfigStatus_state {
1348 struct svcctl_NotifyBootConfigStatus orig;
1349 struct svcctl_NotifyBootConfigStatus tmp;
1350 TALLOC_CTX *out_mem_ctx;
1351 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1352};
1353
1354static void rpccli_svcctl_NotifyBootConfigStatus_done(struct tevent_req *subreq);
1355
1356struct tevent_req *rpccli_svcctl_NotifyBootConfigStatus_send(TALLOC_CTX *mem_ctx,
1357 struct tevent_context *ev,
1358 struct rpc_pipe_client *cli)
1359{
1360 struct tevent_req *req;
1361 struct rpccli_svcctl_NotifyBootConfigStatus_state *state;
1362 struct tevent_req *subreq;
1363
1364 req = tevent_req_create(mem_ctx, &state,
1365 struct rpccli_svcctl_NotifyBootConfigStatus_state);
1366 if (req == NULL) {
1367 return NULL;
1368 }
1369 state->out_mem_ctx = NULL;
1370 state->dispatch_recv = cli->dispatch_recv;
1371
1372 /* In parameters */
1373
1374 /* Out parameters */
1375
1376 /* Result */
1377 ZERO_STRUCT(state->orig.out.result);
1378
1379 /* make a temporary copy, that we pass to the dispatch function */
1380 state->tmp = state->orig;
1381
1382 subreq = cli->dispatch_send(state, ev, cli,
1383 &ndr_table_svcctl,
1384 NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS,
1385 &state->tmp);
1386 if (tevent_req_nomem(subreq, req)) {
1387 return tevent_req_post(req, ev);
1388 }
1389 tevent_req_set_callback(subreq, rpccli_svcctl_NotifyBootConfigStatus_done, req);
1390 return req;
1391}
1392
1393static void rpccli_svcctl_NotifyBootConfigStatus_done(struct tevent_req *subreq)
1394{
1395 struct tevent_req *req = tevent_req_callback_data(
1396 subreq, struct tevent_req);
1397 struct rpccli_svcctl_NotifyBootConfigStatus_state *state = tevent_req_data(
1398 req, struct rpccli_svcctl_NotifyBootConfigStatus_state);
1399 NTSTATUS status;
1400 TALLOC_CTX *mem_ctx;
1401
1402 if (state->out_mem_ctx) {
1403 mem_ctx = state->out_mem_ctx;
1404 } else {
1405 mem_ctx = state;
1406 }
1407
1408 status = state->dispatch_recv(subreq, mem_ctx);
1409 TALLOC_FREE(subreq);
1410 if (!NT_STATUS_IS_OK(status)) {
1411 tevent_req_nterror(req, status);
1412 return;
1413 }
1414
1415 /* Copy out parameters */
1416
1417 /* Copy result */
1418 state->orig.out.result = state->tmp.out.result;
1419
1420 /* Reset temporary structure */
1421 ZERO_STRUCT(state->tmp);
1422
1423 tevent_req_done(req);
1424}
1425
1426NTSTATUS rpccli_svcctl_NotifyBootConfigStatus_recv(struct tevent_req *req,
1427 TALLOC_CTX *mem_ctx,
1428 WERROR *result)
1429{
1430 struct rpccli_svcctl_NotifyBootConfigStatus_state *state = tevent_req_data(
1431 req, struct rpccli_svcctl_NotifyBootConfigStatus_state);
1432 NTSTATUS status;
1433
1434 if (tevent_req_is_nterror(req, &status)) {
1435 tevent_req_received(req);
1436 return status;
1437 }
1438
1439 /* Steal possbile out parameters to the callers context */
1440 talloc_steal(mem_ctx, state->out_mem_ctx);
1441
1442 /* Return result */
1443 *result = state->orig.out.result;
1444
1445 tevent_req_received(req);
1446 return NT_STATUS_OK;
1447}
1448
1449NTSTATUS rpccli_svcctl_NotifyBootConfigStatus(struct rpc_pipe_client *cli,
1450 TALLOC_CTX *mem_ctx,
1451 WERROR *werror)
1452{
1453 struct svcctl_NotifyBootConfigStatus r;
1454 NTSTATUS status;
1455
1456 /* In parameters */
1457
1458 status = cli->dispatch(cli,
1459 mem_ctx,
1460 &ndr_table_svcctl,
1461 NDR_SVCCTL_NOTIFYBOOTCONFIGSTATUS,
1462 &r);
1463
1464 if (!NT_STATUS_IS_OK(status)) {
1465 return status;
1466 }
1467
1468 if (NT_STATUS_IS_ERR(status)) {
1469 return status;
1470 }
1471
1472 /* Return variables */
1473
1474 /* Return result */
1475 if (werror) {
1476 *werror = r.out.result;
1477 }
1478
1479 return werror_to_ntstatus(r.out.result);
1480}
1481
1482struct rpccli_svcctl_SCSetServiceBitsW_state {
1483 struct svcctl_SCSetServiceBitsW orig;
1484 struct svcctl_SCSetServiceBitsW tmp;
1485 TALLOC_CTX *out_mem_ctx;
1486 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1487};
1488
1489static void rpccli_svcctl_SCSetServiceBitsW_done(struct tevent_req *subreq);
1490
1491struct tevent_req *rpccli_svcctl_SCSetServiceBitsW_send(TALLOC_CTX *mem_ctx,
1492 struct tevent_context *ev,
1493 struct rpc_pipe_client *cli,
1494 struct policy_handle *_handle /* [in] [ref] */,
1495 uint32_t _bits /* [in] */,
1496 uint32_t _bitson /* [in] */,
1497 uint32_t _immediate /* [in] */)
1498{
1499 struct tevent_req *req;
1500 struct rpccli_svcctl_SCSetServiceBitsW_state *state;
1501 struct tevent_req *subreq;
1502
1503 req = tevent_req_create(mem_ctx, &state,
1504 struct rpccli_svcctl_SCSetServiceBitsW_state);
1505 if (req == NULL) {
1506 return NULL;
1507 }
1508 state->out_mem_ctx = NULL;
1509 state->dispatch_recv = cli->dispatch_recv;
1510
1511 /* In parameters */
1512 state->orig.in.handle = _handle;
1513 state->orig.in.bits = _bits;
1514 state->orig.in.bitson = _bitson;
1515 state->orig.in.immediate = _immediate;
1516
1517 /* Out parameters */
1518
1519 /* Result */
1520 ZERO_STRUCT(state->orig.out.result);
1521
1522 /* make a temporary copy, that we pass to the dispatch function */
1523 state->tmp = state->orig;
1524
1525 subreq = cli->dispatch_send(state, ev, cli,
1526 &ndr_table_svcctl,
1527 NDR_SVCCTL_SCSETSERVICEBITSW,
1528 &state->tmp);
1529 if (tevent_req_nomem(subreq, req)) {
1530 return tevent_req_post(req, ev);
1531 }
1532 tevent_req_set_callback(subreq, rpccli_svcctl_SCSetServiceBitsW_done, req);
1533 return req;
1534}
1535
1536static void rpccli_svcctl_SCSetServiceBitsW_done(struct tevent_req *subreq)
1537{
1538 struct tevent_req *req = tevent_req_callback_data(
1539 subreq, struct tevent_req);
1540 struct rpccli_svcctl_SCSetServiceBitsW_state *state = tevent_req_data(
1541 req, struct rpccli_svcctl_SCSetServiceBitsW_state);
1542 NTSTATUS status;
1543 TALLOC_CTX *mem_ctx;
1544
1545 if (state->out_mem_ctx) {
1546 mem_ctx = state->out_mem_ctx;
1547 } else {
1548 mem_ctx = state;
1549 }
1550
1551 status = state->dispatch_recv(subreq, mem_ctx);
1552 TALLOC_FREE(subreq);
1553 if (!NT_STATUS_IS_OK(status)) {
1554 tevent_req_nterror(req, status);
1555 return;
1556 }
1557
1558 /* Copy out parameters */
1559
1560 /* Copy result */
1561 state->orig.out.result = state->tmp.out.result;
1562
1563 /* Reset temporary structure */
1564 ZERO_STRUCT(state->tmp);
1565
1566 tevent_req_done(req);
1567}
1568
1569NTSTATUS rpccli_svcctl_SCSetServiceBitsW_recv(struct tevent_req *req,
1570 TALLOC_CTX *mem_ctx,
1571 WERROR *result)
1572{
1573 struct rpccli_svcctl_SCSetServiceBitsW_state *state = tevent_req_data(
1574 req, struct rpccli_svcctl_SCSetServiceBitsW_state);
1575 NTSTATUS status;
1576
1577 if (tevent_req_is_nterror(req, &status)) {
1578 tevent_req_received(req);
1579 return status;
1580 }
1581
1582 /* Steal possbile out parameters to the callers context */
1583 talloc_steal(mem_ctx, state->out_mem_ctx);
1584
1585 /* Return result */
1586 *result = state->orig.out.result;
1587
1588 tevent_req_received(req);
1589 return NT_STATUS_OK;
1590}
1591
1592NTSTATUS rpccli_svcctl_SCSetServiceBitsW(struct rpc_pipe_client *cli,
1593 TALLOC_CTX *mem_ctx,
1594 struct policy_handle *handle /* [in] [ref] */,
1595 uint32_t bits /* [in] */,
1596 uint32_t bitson /* [in] */,
1597 uint32_t immediate /* [in] */,
1598 WERROR *werror)
1599{
1600 struct svcctl_SCSetServiceBitsW r;
1601 NTSTATUS status;
1602
1603 /* In parameters */
1604 r.in.handle = handle;
1605 r.in.bits = bits;
1606 r.in.bitson = bitson;
1607 r.in.immediate = immediate;
1608
1609 status = cli->dispatch(cli,
1610 mem_ctx,
1611 &ndr_table_svcctl,
1612 NDR_SVCCTL_SCSETSERVICEBITSW,
1613 &r);
1614
1615 if (!NT_STATUS_IS_OK(status)) {
1616 return status;
1617 }
1618
1619 if (NT_STATUS_IS_ERR(status)) {
1620 return status;
1621 }
1622
1623 /* Return variables */
1624
1625 /* Return result */
1626 if (werror) {
1627 *werror = r.out.result;
1628 }
1629
1630 return werror_to_ntstatus(r.out.result);
1631}
1632
1633struct rpccli_svcctl_ChangeServiceConfigW_state {
1634 struct svcctl_ChangeServiceConfigW orig;
1635 struct svcctl_ChangeServiceConfigW tmp;
1636 TALLOC_CTX *out_mem_ctx;
1637 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1638};
1639
1640static void rpccli_svcctl_ChangeServiceConfigW_done(struct tevent_req *subreq);
1641
1642struct tevent_req *rpccli_svcctl_ChangeServiceConfigW_send(TALLOC_CTX *mem_ctx,
1643 struct tevent_context *ev,
1644 struct rpc_pipe_client *cli,
1645 struct policy_handle *_handle /* [in] [ref] */,
1646 uint32_t _type /* [in] */,
1647 enum svcctl_StartType _start_type /* [in] */,
1648 enum svcctl_ErrorControl _error_control /* [in] */,
1649 const char *_binary_path /* [in] [unique,charset(UTF16)] */,
1650 const char *_load_order_group /* [in] [unique,charset(UTF16)] */,
1651 uint32_t *_tag_id /* [out] [ref] */,
1652 const char *_dependencies /* [in] [unique,charset(UTF16)] */,
1653 const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
1654 const char *_password /* [in] [unique,charset(UTF16)] */,
1655 const char *_display_name /* [in] [unique,charset(UTF16)] */)
1656{
1657 struct tevent_req *req;
1658 struct rpccli_svcctl_ChangeServiceConfigW_state *state;
1659 struct tevent_req *subreq;
1660
1661 req = tevent_req_create(mem_ctx, &state,
1662 struct rpccli_svcctl_ChangeServiceConfigW_state);
1663 if (req == NULL) {
1664 return NULL;
1665 }
1666 state->out_mem_ctx = NULL;
1667 state->dispatch_recv = cli->dispatch_recv;
1668
1669 /* In parameters */
1670 state->orig.in.handle = _handle;
1671 state->orig.in.type = _type;
1672 state->orig.in.start_type = _start_type;
1673 state->orig.in.error_control = _error_control;
1674 state->orig.in.binary_path = _binary_path;
1675 state->orig.in.load_order_group = _load_order_group;
1676 state->orig.in.dependencies = _dependencies;
1677 state->orig.in.service_start_name = _service_start_name;
1678 state->orig.in.password = _password;
1679 state->orig.in.display_name = _display_name;
1680
1681 /* Out parameters */
1682 state->orig.out.tag_id = _tag_id;
1683
1684 /* Result */
1685 ZERO_STRUCT(state->orig.out.result);
1686
1687 state->out_mem_ctx = talloc_named_const(state, 0,
1688 "rpccli_svcctl_ChangeServiceConfigW_out_memory");
1689 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1690 return tevent_req_post(req, ev);
1691 }
1692
1693 /* make a temporary copy, that we pass to the dispatch function */
1694 state->tmp = state->orig;
1695
1696 subreq = cli->dispatch_send(state, ev, cli,
1697 &ndr_table_svcctl,
1698 NDR_SVCCTL_CHANGESERVICECONFIGW,
1699 &state->tmp);
1700 if (tevent_req_nomem(subreq, req)) {
1701 return tevent_req_post(req, ev);
1702 }
1703 tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfigW_done, req);
1704 return req;
1705}
1706
1707static void rpccli_svcctl_ChangeServiceConfigW_done(struct tevent_req *subreq)
1708{
1709 struct tevent_req *req = tevent_req_callback_data(
1710 subreq, struct tevent_req);
1711 struct rpccli_svcctl_ChangeServiceConfigW_state *state = tevent_req_data(
1712 req, struct rpccli_svcctl_ChangeServiceConfigW_state);
1713 NTSTATUS status;
1714 TALLOC_CTX *mem_ctx;
1715
1716 if (state->out_mem_ctx) {
1717 mem_ctx = state->out_mem_ctx;
1718 } else {
1719 mem_ctx = state;
1720 }
1721
1722 status = state->dispatch_recv(subreq, mem_ctx);
1723 TALLOC_FREE(subreq);
1724 if (!NT_STATUS_IS_OK(status)) {
1725 tevent_req_nterror(req, status);
1726 return;
1727 }
1728
1729 /* Copy out parameters */
1730 *state->orig.out.tag_id = *state->tmp.out.tag_id;
1731
1732 /* Copy result */
1733 state->orig.out.result = state->tmp.out.result;
1734
1735 /* Reset temporary structure */
1736 ZERO_STRUCT(state->tmp);
1737
1738 tevent_req_done(req);
1739}
1740
1741NTSTATUS rpccli_svcctl_ChangeServiceConfigW_recv(struct tevent_req *req,
1742 TALLOC_CTX *mem_ctx,
1743 WERROR *result)
1744{
1745 struct rpccli_svcctl_ChangeServiceConfigW_state *state = tevent_req_data(
1746 req, struct rpccli_svcctl_ChangeServiceConfigW_state);
1747 NTSTATUS status;
1748
1749 if (tevent_req_is_nterror(req, &status)) {
1750 tevent_req_received(req);
1751 return status;
1752 }
1753
1754 /* Steal possbile out parameters to the callers context */
1755 talloc_steal(mem_ctx, state->out_mem_ctx);
1756
1757 /* Return result */
1758 *result = state->orig.out.result;
1759
1760 tevent_req_received(req);
1761 return NT_STATUS_OK;
1762}
1763
1764NTSTATUS rpccli_svcctl_ChangeServiceConfigW(struct rpc_pipe_client *cli,
1765 TALLOC_CTX *mem_ctx,
1766 struct policy_handle *handle /* [in] [ref] */,
1767 uint32_t type /* [in] */,
1768 enum svcctl_StartType start_type /* [in] */,
1769 enum svcctl_ErrorControl error_control /* [in] */,
1770 const char *binary_path /* [in] [unique,charset(UTF16)] */,
1771 const char *load_order_group /* [in] [unique,charset(UTF16)] */,
1772 uint32_t *tag_id /* [out] [ref] */,
1773 const char *dependencies /* [in] [unique,charset(UTF16)] */,
1774 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
1775 const char *password /* [in] [unique,charset(UTF16)] */,
1776 const char *display_name /* [in] [unique,charset(UTF16)] */,
1777 WERROR *werror)
1778{
1779 struct svcctl_ChangeServiceConfigW r;
1780 NTSTATUS status;
1781
1782 /* In parameters */
1783 r.in.handle = handle;
1784 r.in.type = type;
1785 r.in.start_type = start_type;
1786 r.in.error_control = error_control;
1787 r.in.binary_path = binary_path;
1788 r.in.load_order_group = load_order_group;
1789 r.in.dependencies = dependencies;
1790 r.in.service_start_name = service_start_name;
1791 r.in.password = password;
1792 r.in.display_name = display_name;
1793
1794 status = cli->dispatch(cli,
1795 mem_ctx,
1796 &ndr_table_svcctl,
1797 NDR_SVCCTL_CHANGESERVICECONFIGW,
1798 &r);
1799
1800 if (!NT_STATUS_IS_OK(status)) {
1801 return status;
1802 }
1803
1804 if (NT_STATUS_IS_ERR(status)) {
1805 return status;
1806 }
1807
1808 /* Return variables */
1809 *tag_id = *r.out.tag_id;
1810
1811 /* Return result */
1812 if (werror) {
1813 *werror = r.out.result;
1814 }
1815
1816 return werror_to_ntstatus(r.out.result);
1817}
1818
1819struct rpccli_svcctl_CreateServiceW_state {
1820 struct svcctl_CreateServiceW orig;
1821 struct svcctl_CreateServiceW tmp;
1822 TALLOC_CTX *out_mem_ctx;
1823 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1824};
1825
1826static void rpccli_svcctl_CreateServiceW_done(struct tevent_req *subreq);
1827
1828struct tevent_req *rpccli_svcctl_CreateServiceW_send(TALLOC_CTX *mem_ctx,
1829 struct tevent_context *ev,
1830 struct rpc_pipe_client *cli,
1831 struct policy_handle *_scmanager_handle /* [in] [ref] */,
1832 const char *_ServiceName /* [in] [charset(UTF16)] */,
1833 const char *_DisplayName /* [in] [unique,charset(UTF16)] */,
1834 uint32_t _desired_access /* [in] */,
1835 uint32_t _type /* [in] */,
1836 enum svcctl_StartType _start_type /* [in] */,
1837 enum svcctl_ErrorControl _error_control /* [in] */,
1838 const char *_binary_path /* [in] [charset(UTF16)] */,
1839 const char *_LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
1840 uint32_t *_TagId /* [in,out] [unique] */,
1841 uint8_t *_dependencies /* [in] [unique,size_is(dependencies_size)] */,
1842 uint32_t _dependencies_size /* [in] */,
1843 const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
1844 uint8_t *_password /* [in] [unique,size_is(password_size)] */,
1845 uint32_t _password_size /* [in] */,
1846 struct policy_handle *_handle /* [out] [ref] */)
1847{
1848 struct tevent_req *req;
1849 struct rpccli_svcctl_CreateServiceW_state *state;
1850 struct tevent_req *subreq;
1851
1852 req = tevent_req_create(mem_ctx, &state,
1853 struct rpccli_svcctl_CreateServiceW_state);
1854 if (req == NULL) {
1855 return NULL;
1856 }
1857 state->out_mem_ctx = NULL;
1858 state->dispatch_recv = cli->dispatch_recv;
1859
1860 /* In parameters */
1861 state->orig.in.scmanager_handle = _scmanager_handle;
1862 state->orig.in.ServiceName = _ServiceName;
1863 state->orig.in.DisplayName = _DisplayName;
1864 state->orig.in.desired_access = _desired_access;
1865 state->orig.in.type = _type;
1866 state->orig.in.start_type = _start_type;
1867 state->orig.in.error_control = _error_control;
1868 state->orig.in.binary_path = _binary_path;
1869 state->orig.in.LoadOrderGroupKey = _LoadOrderGroupKey;
1870 state->orig.in.TagId = _TagId;
1871 state->orig.in.dependencies = _dependencies;
1872 state->orig.in.dependencies_size = _dependencies_size;
1873 state->orig.in.service_start_name = _service_start_name;
1874 state->orig.in.password = _password;
1875 state->orig.in.password_size = _password_size;
1876
1877 /* Out parameters */
1878 state->orig.out.TagId = _TagId;
1879 state->orig.out.handle = _handle;
1880
1881 /* Result */
1882 ZERO_STRUCT(state->orig.out.result);
1883
1884 state->out_mem_ctx = talloc_named_const(state, 0,
1885 "rpccli_svcctl_CreateServiceW_out_memory");
1886 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1887 return tevent_req_post(req, ev);
1888 }
1889
1890 /* make a temporary copy, that we pass to the dispatch function */
1891 state->tmp = state->orig;
1892
1893 subreq = cli->dispatch_send(state, ev, cli,
1894 &ndr_table_svcctl,
1895 NDR_SVCCTL_CREATESERVICEW,
1896 &state->tmp);
1897 if (tevent_req_nomem(subreq, req)) {
1898 return tevent_req_post(req, ev);
1899 }
1900 tevent_req_set_callback(subreq, rpccli_svcctl_CreateServiceW_done, req);
1901 return req;
1902}
1903
1904static void rpccli_svcctl_CreateServiceW_done(struct tevent_req *subreq)
1905{
1906 struct tevent_req *req = tevent_req_callback_data(
1907 subreq, struct tevent_req);
1908 struct rpccli_svcctl_CreateServiceW_state *state = tevent_req_data(
1909 req, struct rpccli_svcctl_CreateServiceW_state);
1910 NTSTATUS status;
1911 TALLOC_CTX *mem_ctx;
1912
1913 if (state->out_mem_ctx) {
1914 mem_ctx = state->out_mem_ctx;
1915 } else {
1916 mem_ctx = state;
1917 }
1918
1919 status = state->dispatch_recv(subreq, mem_ctx);
1920 TALLOC_FREE(subreq);
1921 if (!NT_STATUS_IS_OK(status)) {
1922 tevent_req_nterror(req, status);
1923 return;
1924 }
1925
1926 /* Copy out parameters */
1927 if (state->orig.out.TagId && state->tmp.out.TagId) {
1928 *state->orig.out.TagId = *state->tmp.out.TagId;
1929 }
1930 *state->orig.out.handle = *state->tmp.out.handle;
1931
1932 /* Copy result */
1933 state->orig.out.result = state->tmp.out.result;
1934
1935 /* Reset temporary structure */
1936 ZERO_STRUCT(state->tmp);
1937
1938 tevent_req_done(req);
1939}
1940
1941NTSTATUS rpccli_svcctl_CreateServiceW_recv(struct tevent_req *req,
1942 TALLOC_CTX *mem_ctx,
1943 WERROR *result)
1944{
1945 struct rpccli_svcctl_CreateServiceW_state *state = tevent_req_data(
1946 req, struct rpccli_svcctl_CreateServiceW_state);
1947 NTSTATUS status;
1948
1949 if (tevent_req_is_nterror(req, &status)) {
1950 tevent_req_received(req);
1951 return status;
1952 }
1953
1954 /* Steal possbile out parameters to the callers context */
1955 talloc_steal(mem_ctx, state->out_mem_ctx);
1956
1957 /* Return result */
1958 *result = state->orig.out.result;
1959
1960 tevent_req_received(req);
1961 return NT_STATUS_OK;
1962}
1963
1964NTSTATUS rpccli_svcctl_CreateServiceW(struct rpc_pipe_client *cli,
1965 TALLOC_CTX *mem_ctx,
1966 struct policy_handle *scmanager_handle /* [in] [ref] */,
1967 const char *ServiceName /* [in] [charset(UTF16)] */,
1968 const char *DisplayName /* [in] [unique,charset(UTF16)] */,
1969 uint32_t desired_access /* [in] */,
1970 uint32_t type /* [in] */,
1971 enum svcctl_StartType start_type /* [in] */,
1972 enum svcctl_ErrorControl error_control /* [in] */,
1973 const char *binary_path /* [in] [charset(UTF16)] */,
1974 const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
1975 uint32_t *TagId /* [in,out] [unique] */,
1976 uint8_t *dependencies /* [in] [unique,size_is(dependencies_size)] */,
1977 uint32_t dependencies_size /* [in] */,
1978 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
1979 uint8_t *password /* [in] [unique,size_is(password_size)] */,
1980 uint32_t password_size /* [in] */,
1981 struct policy_handle *handle /* [out] [ref] */,
1982 WERROR *werror)
1983{
1984 struct svcctl_CreateServiceW r;
1985 NTSTATUS status;
1986
1987 /* In parameters */
1988 r.in.scmanager_handle = scmanager_handle;
1989 r.in.ServiceName = ServiceName;
1990 r.in.DisplayName = DisplayName;
1991 r.in.desired_access = desired_access;
1992 r.in.type = type;
1993 r.in.start_type = start_type;
1994 r.in.error_control = error_control;
1995 r.in.binary_path = binary_path;
1996 r.in.LoadOrderGroupKey = LoadOrderGroupKey;
1997 r.in.TagId = TagId;
1998 r.in.dependencies = dependencies;
1999 r.in.dependencies_size = dependencies_size;
2000 r.in.service_start_name = service_start_name;
2001 r.in.password = password;
2002 r.in.password_size = password_size;
2003
2004 status = cli->dispatch(cli,
2005 mem_ctx,
2006 &ndr_table_svcctl,
2007 NDR_SVCCTL_CREATESERVICEW,
2008 &r);
2009
2010 if (!NT_STATUS_IS_OK(status)) {
2011 return status;
2012 }
2013
2014 if (NT_STATUS_IS_ERR(status)) {
2015 return status;
2016 }
2017
2018 /* Return variables */
2019 if (TagId && r.out.TagId) {
2020 *TagId = *r.out.TagId;
2021 }
2022 *handle = *r.out.handle;
2023
2024 /* Return result */
2025 if (werror) {
2026 *werror = r.out.result;
2027 }
2028
2029 return werror_to_ntstatus(r.out.result);
2030}
2031
2032struct rpccli_svcctl_EnumDependentServicesW_state {
2033 struct svcctl_EnumDependentServicesW orig;
2034 struct svcctl_EnumDependentServicesW tmp;
2035 TALLOC_CTX *out_mem_ctx;
2036 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2037};
2038
2039static void rpccli_svcctl_EnumDependentServicesW_done(struct tevent_req *subreq);
2040
2041struct tevent_req *rpccli_svcctl_EnumDependentServicesW_send(TALLOC_CTX *mem_ctx,
2042 struct tevent_context *ev,
2043 struct rpc_pipe_client *cli,
2044 struct policy_handle *_service /* [in] [ref] */,
2045 enum svcctl_ServiceState _state /* [in] */,
2046 uint8_t *_service_status /* [out] [ref,size_is(offered)] */,
2047 uint32_t _offered /* [in] [range(0,0x40000)] */,
2048 uint32_t *_needed /* [out] [ref,range(0,0x40000)] */,
2049 uint32_t *_services_returned /* [out] [ref,range(0,0x40000)] */)
2050{
2051 struct tevent_req *req;
2052 struct rpccli_svcctl_EnumDependentServicesW_state *state;
2053 struct tevent_req *subreq;
2054
2055 req = tevent_req_create(mem_ctx, &state,
2056 struct rpccli_svcctl_EnumDependentServicesW_state);
2057 if (req == NULL) {
2058 return NULL;
2059 }
2060 state->out_mem_ctx = NULL;
2061 state->dispatch_recv = cli->dispatch_recv;
2062
2063 /* In parameters */
2064 state->orig.in.service = _service;
2065 state->orig.in.state = _state;
2066 state->orig.in.offered = _offered;
2067
2068 /* Out parameters */
2069 state->orig.out.service_status = _service_status;
2070 state->orig.out.needed = _needed;
2071 state->orig.out.services_returned = _services_returned;
2072
2073 /* Result */
2074 ZERO_STRUCT(state->orig.out.result);
2075
2076 state->out_mem_ctx = talloc_named_const(state, 0,
2077 "rpccli_svcctl_EnumDependentServicesW_out_memory");
2078 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2079 return tevent_req_post(req, ev);
2080 }
2081
2082 /* make a temporary copy, that we pass to the dispatch function */
2083 state->tmp = state->orig;
2084
2085 subreq = cli->dispatch_send(state, ev, cli,
2086 &ndr_table_svcctl,
2087 NDR_SVCCTL_ENUMDEPENDENTSERVICESW,
2088 &state->tmp);
2089 if (tevent_req_nomem(subreq, req)) {
2090 return tevent_req_post(req, ev);
2091 }
2092 tevent_req_set_callback(subreq, rpccli_svcctl_EnumDependentServicesW_done, req);
2093 return req;
2094}
2095
2096static void rpccli_svcctl_EnumDependentServicesW_done(struct tevent_req *subreq)
2097{
2098 struct tevent_req *req = tevent_req_callback_data(
2099 subreq, struct tevent_req);
2100 struct rpccli_svcctl_EnumDependentServicesW_state *state = tevent_req_data(
2101 req, struct rpccli_svcctl_EnumDependentServicesW_state);
2102 NTSTATUS status;
2103 TALLOC_CTX *mem_ctx;
2104
2105 if (state->out_mem_ctx) {
2106 mem_ctx = state->out_mem_ctx;
2107 } else {
2108 mem_ctx = state;
2109 }
2110
2111 status = state->dispatch_recv(subreq, mem_ctx);
2112 TALLOC_FREE(subreq);
2113 if (!NT_STATUS_IS_OK(status)) {
2114 tevent_req_nterror(req, status);
2115 return;
2116 }
2117
2118 /* Copy out parameters */
2119 memcpy(state->orig.out.service_status, state->tmp.out.service_status, (state->tmp.in.offered) * sizeof(*state->orig.out.service_status));
2120 *state->orig.out.needed = *state->tmp.out.needed;
2121 *state->orig.out.services_returned = *state->tmp.out.services_returned;
2122
2123 /* Copy result */
2124 state->orig.out.result = state->tmp.out.result;
2125
2126 /* Reset temporary structure */
2127 ZERO_STRUCT(state->tmp);
2128
2129 tevent_req_done(req);
2130}
2131
2132NTSTATUS rpccli_svcctl_EnumDependentServicesW_recv(struct tevent_req *req,
2133 TALLOC_CTX *mem_ctx,
2134 WERROR *result)
2135{
2136 struct rpccli_svcctl_EnumDependentServicesW_state *state = tevent_req_data(
2137 req, struct rpccli_svcctl_EnumDependentServicesW_state);
2138 NTSTATUS status;
2139
2140 if (tevent_req_is_nterror(req, &status)) {
2141 tevent_req_received(req);
2142 return status;
2143 }
2144
2145 /* Steal possbile out parameters to the callers context */
2146 talloc_steal(mem_ctx, state->out_mem_ctx);
2147
2148 /* Return result */
2149 *result = state->orig.out.result;
2150
2151 tevent_req_received(req);
2152 return NT_STATUS_OK;
2153}
2154
2155NTSTATUS rpccli_svcctl_EnumDependentServicesW(struct rpc_pipe_client *cli,
2156 TALLOC_CTX *mem_ctx,
2157 struct policy_handle *service /* [in] [ref] */,
2158 enum svcctl_ServiceState state /* [in] */,
2159 uint8_t *service_status /* [out] [ref,size_is(offered)] */,
2160 uint32_t offered /* [in] [range(0,0x40000)] */,
2161 uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
2162 uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
2163 WERROR *werror)
2164{
2165 struct svcctl_EnumDependentServicesW r;
2166 NTSTATUS status;
2167
2168 /* In parameters */
2169 r.in.service = service;
2170 r.in.state = state;
2171 r.in.offered = offered;
2172
2173 status = cli->dispatch(cli,
2174 mem_ctx,
2175 &ndr_table_svcctl,
2176 NDR_SVCCTL_ENUMDEPENDENTSERVICESW,
2177 &r);
2178
2179 if (!NT_STATUS_IS_OK(status)) {
2180 return status;
2181 }
2182
2183 if (NT_STATUS_IS_ERR(status)) {
2184 return status;
2185 }
2186
2187 /* Return variables */
2188 memcpy(service_status, r.out.service_status, (r.in.offered) * sizeof(*service_status));
2189 *needed = *r.out.needed;
2190 *services_returned = *r.out.services_returned;
2191
2192 /* Return result */
2193 if (werror) {
2194 *werror = r.out.result;
2195 }
2196
2197 return werror_to_ntstatus(r.out.result);
2198}
2199
2200struct rpccli_svcctl_EnumServicesStatusW_state {
2201 struct svcctl_EnumServicesStatusW orig;
2202 struct svcctl_EnumServicesStatusW tmp;
2203 TALLOC_CTX *out_mem_ctx;
2204 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2205};
2206
2207static void rpccli_svcctl_EnumServicesStatusW_done(struct tevent_req *subreq);
2208
2209struct tevent_req *rpccli_svcctl_EnumServicesStatusW_send(TALLOC_CTX *mem_ctx,
2210 struct tevent_context *ev,
2211 struct rpc_pipe_client *cli,
2212 struct policy_handle *_handle /* [in] [ref] */,
2213 uint32_t _type /* [in] */,
2214 enum svcctl_ServiceState _state /* [in] */,
2215 uint8_t *_service /* [out] [ref,size_is(offered)] */,
2216 uint32_t _offered /* [in] [range(0,0x40000)] */,
2217 uint32_t *_needed /* [out] [ref,range(0,0x40000)] */,
2218 uint32_t *_services_returned /* [out] [ref,range(0,0x40000)] */,
2219 uint32_t *_resume_handle /* [in,out] [unique] */)
2220{
2221 struct tevent_req *req;
2222 struct rpccli_svcctl_EnumServicesStatusW_state *state;
2223 struct tevent_req *subreq;
2224
2225 req = tevent_req_create(mem_ctx, &state,
2226 struct rpccli_svcctl_EnumServicesStatusW_state);
2227 if (req == NULL) {
2228 return NULL;
2229 }
2230 state->out_mem_ctx = NULL;
2231 state->dispatch_recv = cli->dispatch_recv;
2232
2233 /* In parameters */
2234 state->orig.in.handle = _handle;
2235 state->orig.in.type = _type;
2236 state->orig.in.state = _state;
2237 state->orig.in.offered = _offered;
2238 state->orig.in.resume_handle = _resume_handle;
2239
2240 /* Out parameters */
2241 state->orig.out.service = _service;
2242 state->orig.out.needed = _needed;
2243 state->orig.out.services_returned = _services_returned;
2244 state->orig.out.resume_handle = _resume_handle;
2245
2246 /* Result */
2247 ZERO_STRUCT(state->orig.out.result);
2248
2249 state->out_mem_ctx = talloc_named_const(state, 0,
2250 "rpccli_svcctl_EnumServicesStatusW_out_memory");
2251 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2252 return tevent_req_post(req, ev);
2253 }
2254
2255 /* make a temporary copy, that we pass to the dispatch function */
2256 state->tmp = state->orig;
2257
2258 subreq = cli->dispatch_send(state, ev, cli,
2259 &ndr_table_svcctl,
2260 NDR_SVCCTL_ENUMSERVICESSTATUSW,
2261 &state->tmp);
2262 if (tevent_req_nomem(subreq, req)) {
2263 return tevent_req_post(req, ev);
2264 }
2265 tevent_req_set_callback(subreq, rpccli_svcctl_EnumServicesStatusW_done, req);
2266 return req;
2267}
2268
2269static void rpccli_svcctl_EnumServicesStatusW_done(struct tevent_req *subreq)
2270{
2271 struct tevent_req *req = tevent_req_callback_data(
2272 subreq, struct tevent_req);
2273 struct rpccli_svcctl_EnumServicesStatusW_state *state = tevent_req_data(
2274 req, struct rpccli_svcctl_EnumServicesStatusW_state);
2275 NTSTATUS status;
2276 TALLOC_CTX *mem_ctx;
2277
2278 if (state->out_mem_ctx) {
2279 mem_ctx = state->out_mem_ctx;
2280 } else {
2281 mem_ctx = state;
2282 }
2283
2284 status = state->dispatch_recv(subreq, mem_ctx);
2285 TALLOC_FREE(subreq);
2286 if (!NT_STATUS_IS_OK(status)) {
2287 tevent_req_nterror(req, status);
2288 return;
2289 }
2290
2291 /* Copy out parameters */
2292 memcpy(state->orig.out.service, state->tmp.out.service, (state->tmp.in.offered) * sizeof(*state->orig.out.service));
2293 *state->orig.out.needed = *state->tmp.out.needed;
2294 *state->orig.out.services_returned = *state->tmp.out.services_returned;
2295 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
2296 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2297 }
2298
2299 /* Copy result */
2300 state->orig.out.result = state->tmp.out.result;
2301
2302 /* Reset temporary structure */
2303 ZERO_STRUCT(state->tmp);
2304
2305 tevent_req_done(req);
2306}
2307
2308NTSTATUS rpccli_svcctl_EnumServicesStatusW_recv(struct tevent_req *req,
2309 TALLOC_CTX *mem_ctx,
2310 WERROR *result)
2311{
2312 struct rpccli_svcctl_EnumServicesStatusW_state *state = tevent_req_data(
2313 req, struct rpccli_svcctl_EnumServicesStatusW_state);
2314 NTSTATUS status;
2315
2316 if (tevent_req_is_nterror(req, &status)) {
2317 tevent_req_received(req);
2318 return status;
2319 }
2320
2321 /* Steal possbile out parameters to the callers context */
2322 talloc_steal(mem_ctx, state->out_mem_ctx);
2323
2324 /* Return result */
2325 *result = state->orig.out.result;
2326
2327 tevent_req_received(req);
2328 return NT_STATUS_OK;
2329}
2330
2331NTSTATUS rpccli_svcctl_EnumServicesStatusW(struct rpc_pipe_client *cli,
2332 TALLOC_CTX *mem_ctx,
2333 struct policy_handle *handle /* [in] [ref] */,
2334 uint32_t type /* [in] */,
2335 enum svcctl_ServiceState state /* [in] */,
2336 uint8_t *service /* [out] [ref,size_is(offered)] */,
2337 uint32_t offered /* [in] [range(0,0x40000)] */,
2338 uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
2339 uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,
2340 uint32_t *resume_handle /* [in,out] [unique] */,
2341 WERROR *werror)
2342{
2343 struct svcctl_EnumServicesStatusW r;
2344 NTSTATUS status;
2345
2346 /* In parameters */
2347 r.in.handle = handle;
2348 r.in.type = type;
2349 r.in.state = state;
2350 r.in.offered = offered;
2351 r.in.resume_handle = resume_handle;
2352
2353 status = cli->dispatch(cli,
2354 mem_ctx,
2355 &ndr_table_svcctl,
2356 NDR_SVCCTL_ENUMSERVICESSTATUSW,
2357 &r);
2358
2359 if (!NT_STATUS_IS_OK(status)) {
2360 return status;
2361 }
2362
2363 if (NT_STATUS_IS_ERR(status)) {
2364 return status;
2365 }
2366
2367 /* Return variables */
2368 memcpy(service, r.out.service, (r.in.offered) * sizeof(*service));
2369 *needed = *r.out.needed;
2370 *services_returned = *r.out.services_returned;
2371 if (resume_handle && r.out.resume_handle) {
2372 *resume_handle = *r.out.resume_handle;
2373 }
2374
2375 /* Return result */
2376 if (werror) {
2377 *werror = r.out.result;
2378 }
2379
2380 return werror_to_ntstatus(r.out.result);
2381}
2382
2383struct rpccli_svcctl_OpenSCManagerW_state {
2384 struct svcctl_OpenSCManagerW orig;
2385 struct svcctl_OpenSCManagerW tmp;
2386 TALLOC_CTX *out_mem_ctx;
2387 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2388};
2389
2390static void rpccli_svcctl_OpenSCManagerW_done(struct tevent_req *subreq);
2391
2392struct tevent_req *rpccli_svcctl_OpenSCManagerW_send(TALLOC_CTX *mem_ctx,
2393 struct tevent_context *ev,
2394 struct rpc_pipe_client *cli,
2395 const char *_MachineName /* [in] [unique,charset(UTF16)] */,
2396 const char *_DatabaseName /* [in] [unique,charset(UTF16)] */,
2397 uint32_t _access_mask /* [in] */,
2398 struct policy_handle *_handle /* [out] [ref] */)
2399{
2400 struct tevent_req *req;
2401 struct rpccli_svcctl_OpenSCManagerW_state *state;
2402 struct tevent_req *subreq;
2403
2404 req = tevent_req_create(mem_ctx, &state,
2405 struct rpccli_svcctl_OpenSCManagerW_state);
2406 if (req == NULL) {
2407 return NULL;
2408 }
2409 state->out_mem_ctx = NULL;
2410 state->dispatch_recv = cli->dispatch_recv;
2411
2412 /* In parameters */
2413 state->orig.in.MachineName = _MachineName;
2414 state->orig.in.DatabaseName = _DatabaseName;
2415 state->orig.in.access_mask = _access_mask;
2416
2417 /* Out parameters */
2418 state->orig.out.handle = _handle;
2419
2420 /* Result */
2421 ZERO_STRUCT(state->orig.out.result);
2422
2423 state->out_mem_ctx = talloc_named_const(state, 0,
2424 "rpccli_svcctl_OpenSCManagerW_out_memory");
2425 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2426 return tevent_req_post(req, ev);
2427 }
2428
2429 /* make a temporary copy, that we pass to the dispatch function */
2430 state->tmp = state->orig;
2431
2432 subreq = cli->dispatch_send(state, ev, cli,
2433 &ndr_table_svcctl,
2434 NDR_SVCCTL_OPENSCMANAGERW,
2435 &state->tmp);
2436 if (tevent_req_nomem(subreq, req)) {
2437 return tevent_req_post(req, ev);
2438 }
2439 tevent_req_set_callback(subreq, rpccli_svcctl_OpenSCManagerW_done, req);
2440 return req;
2441}
2442
2443static void rpccli_svcctl_OpenSCManagerW_done(struct tevent_req *subreq)
2444{
2445 struct tevent_req *req = tevent_req_callback_data(
2446 subreq, struct tevent_req);
2447 struct rpccli_svcctl_OpenSCManagerW_state *state = tevent_req_data(
2448 req, struct rpccli_svcctl_OpenSCManagerW_state);
2449 NTSTATUS status;
2450 TALLOC_CTX *mem_ctx;
2451
2452 if (state->out_mem_ctx) {
2453 mem_ctx = state->out_mem_ctx;
2454 } else {
2455 mem_ctx = state;
2456 }
2457
2458 status = state->dispatch_recv(subreq, mem_ctx);
2459 TALLOC_FREE(subreq);
2460 if (!NT_STATUS_IS_OK(status)) {
2461 tevent_req_nterror(req, status);
2462 return;
2463 }
2464
2465 /* Copy out parameters */
2466 *state->orig.out.handle = *state->tmp.out.handle;
2467
2468 /* Copy result */
2469 state->orig.out.result = state->tmp.out.result;
2470
2471 /* Reset temporary structure */
2472 ZERO_STRUCT(state->tmp);
2473
2474 tevent_req_done(req);
2475}
2476
2477NTSTATUS rpccli_svcctl_OpenSCManagerW_recv(struct tevent_req *req,
2478 TALLOC_CTX *mem_ctx,
2479 WERROR *result)
2480{
2481 struct rpccli_svcctl_OpenSCManagerW_state *state = tevent_req_data(
2482 req, struct rpccli_svcctl_OpenSCManagerW_state);
2483 NTSTATUS status;
2484
2485 if (tevent_req_is_nterror(req, &status)) {
2486 tevent_req_received(req);
2487 return status;
2488 }
2489
2490 /* Steal possbile out parameters to the callers context */
2491 talloc_steal(mem_ctx, state->out_mem_ctx);
2492
2493 /* Return result */
2494 *result = state->orig.out.result;
2495
2496 tevent_req_received(req);
2497 return NT_STATUS_OK;
2498}
2499
2500NTSTATUS rpccli_svcctl_OpenSCManagerW(struct rpc_pipe_client *cli,
2501 TALLOC_CTX *mem_ctx,
2502 const char *MachineName /* [in] [unique,charset(UTF16)] */,
2503 const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
2504 uint32_t access_mask /* [in] */,
2505 struct policy_handle *handle /* [out] [ref] */,
2506 WERROR *werror)
2507{
2508 struct svcctl_OpenSCManagerW r;
2509 NTSTATUS status;
2510
2511 /* In parameters */
2512 r.in.MachineName = MachineName;
2513 r.in.DatabaseName = DatabaseName;
2514 r.in.access_mask = access_mask;
2515
2516 status = cli->dispatch(cli,
2517 mem_ctx,
2518 &ndr_table_svcctl,
2519 NDR_SVCCTL_OPENSCMANAGERW,
2520 &r);
2521
2522 if (!NT_STATUS_IS_OK(status)) {
2523 return status;
2524 }
2525
2526 if (NT_STATUS_IS_ERR(status)) {
2527 return status;
2528 }
2529
2530 /* Return variables */
2531 *handle = *r.out.handle;
2532
2533 /* Return result */
2534 if (werror) {
2535 *werror = r.out.result;
2536 }
2537
2538 return werror_to_ntstatus(r.out.result);
2539}
2540
2541struct rpccli_svcctl_OpenServiceW_state {
2542 struct svcctl_OpenServiceW orig;
2543 struct svcctl_OpenServiceW tmp;
2544 TALLOC_CTX *out_mem_ctx;
2545 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2546};
2547
2548static void rpccli_svcctl_OpenServiceW_done(struct tevent_req *subreq);
2549
2550struct tevent_req *rpccli_svcctl_OpenServiceW_send(TALLOC_CTX *mem_ctx,
2551 struct tevent_context *ev,
2552 struct rpc_pipe_client *cli,
2553 struct policy_handle *_scmanager_handle /* [in] [ref] */,
2554 const char *_ServiceName /* [in] [charset(UTF16)] */,
2555 uint32_t _access_mask /* [in] */,
2556 struct policy_handle *_handle /* [out] [ref] */)
2557{
2558 struct tevent_req *req;
2559 struct rpccli_svcctl_OpenServiceW_state *state;
2560 struct tevent_req *subreq;
2561
2562 req = tevent_req_create(mem_ctx, &state,
2563 struct rpccli_svcctl_OpenServiceW_state);
2564 if (req == NULL) {
2565 return NULL;
2566 }
2567 state->out_mem_ctx = NULL;
2568 state->dispatch_recv = cli->dispatch_recv;
2569
2570 /* In parameters */
2571 state->orig.in.scmanager_handle = _scmanager_handle;
2572 state->orig.in.ServiceName = _ServiceName;
2573 state->orig.in.access_mask = _access_mask;
2574
2575 /* Out parameters */
2576 state->orig.out.handle = _handle;
2577
2578 /* Result */
2579 ZERO_STRUCT(state->orig.out.result);
2580
2581 state->out_mem_ctx = talloc_named_const(state, 0,
2582 "rpccli_svcctl_OpenServiceW_out_memory");
2583 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2584 return tevent_req_post(req, ev);
2585 }
2586
2587 /* make a temporary copy, that we pass to the dispatch function */
2588 state->tmp = state->orig;
2589
2590 subreq = cli->dispatch_send(state, ev, cli,
2591 &ndr_table_svcctl,
2592 NDR_SVCCTL_OPENSERVICEW,
2593 &state->tmp);
2594 if (tevent_req_nomem(subreq, req)) {
2595 return tevent_req_post(req, ev);
2596 }
2597 tevent_req_set_callback(subreq, rpccli_svcctl_OpenServiceW_done, req);
2598 return req;
2599}
2600
2601static void rpccli_svcctl_OpenServiceW_done(struct tevent_req *subreq)
2602{
2603 struct tevent_req *req = tevent_req_callback_data(
2604 subreq, struct tevent_req);
2605 struct rpccli_svcctl_OpenServiceW_state *state = tevent_req_data(
2606 req, struct rpccli_svcctl_OpenServiceW_state);
2607 NTSTATUS status;
2608 TALLOC_CTX *mem_ctx;
2609
2610 if (state->out_mem_ctx) {
2611 mem_ctx = state->out_mem_ctx;
2612 } else {
2613 mem_ctx = state;
2614 }
2615
2616 status = state->dispatch_recv(subreq, mem_ctx);
2617 TALLOC_FREE(subreq);
2618 if (!NT_STATUS_IS_OK(status)) {
2619 tevent_req_nterror(req, status);
2620 return;
2621 }
2622
2623 /* Copy out parameters */
2624 *state->orig.out.handle = *state->tmp.out.handle;
2625
2626 /* Copy result */
2627 state->orig.out.result = state->tmp.out.result;
2628
2629 /* Reset temporary structure */
2630 ZERO_STRUCT(state->tmp);
2631
2632 tevent_req_done(req);
2633}
2634
2635NTSTATUS rpccli_svcctl_OpenServiceW_recv(struct tevent_req *req,
2636 TALLOC_CTX *mem_ctx,
2637 WERROR *result)
2638{
2639 struct rpccli_svcctl_OpenServiceW_state *state = tevent_req_data(
2640 req, struct rpccli_svcctl_OpenServiceW_state);
2641 NTSTATUS status;
2642
2643 if (tevent_req_is_nterror(req, &status)) {
2644 tevent_req_received(req);
2645 return status;
2646 }
2647
2648 /* Steal possbile out parameters to the callers context */
2649 talloc_steal(mem_ctx, state->out_mem_ctx);
2650
2651 /* Return result */
2652 *result = state->orig.out.result;
2653
2654 tevent_req_received(req);
2655 return NT_STATUS_OK;
2656}
2657
2658NTSTATUS rpccli_svcctl_OpenServiceW(struct rpc_pipe_client *cli,
2659 TALLOC_CTX *mem_ctx,
2660 struct policy_handle *scmanager_handle /* [in] [ref] */,
2661 const char *ServiceName /* [in] [charset(UTF16)] */,
2662 uint32_t access_mask /* [in] */,
2663 struct policy_handle *handle /* [out] [ref] */,
2664 WERROR *werror)
2665{
2666 struct svcctl_OpenServiceW r;
2667 NTSTATUS status;
2668
2669 /* In parameters */
2670 r.in.scmanager_handle = scmanager_handle;
2671 r.in.ServiceName = ServiceName;
2672 r.in.access_mask = access_mask;
2673
2674 status = cli->dispatch(cli,
2675 mem_ctx,
2676 &ndr_table_svcctl,
2677 NDR_SVCCTL_OPENSERVICEW,
2678 &r);
2679
2680 if (!NT_STATUS_IS_OK(status)) {
2681 return status;
2682 }
2683
2684 if (NT_STATUS_IS_ERR(status)) {
2685 return status;
2686 }
2687
2688 /* Return variables */
2689 *handle = *r.out.handle;
2690
2691 /* Return result */
2692 if (werror) {
2693 *werror = r.out.result;
2694 }
2695
2696 return werror_to_ntstatus(r.out.result);
2697}
2698
2699struct rpccli_svcctl_QueryServiceConfigW_state {
2700 struct svcctl_QueryServiceConfigW orig;
2701 struct svcctl_QueryServiceConfigW tmp;
2702 TALLOC_CTX *out_mem_ctx;
2703 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2704};
2705
2706static void rpccli_svcctl_QueryServiceConfigW_done(struct tevent_req *subreq);
2707
2708struct tevent_req *rpccli_svcctl_QueryServiceConfigW_send(TALLOC_CTX *mem_ctx,
2709 struct tevent_context *ev,
2710 struct rpc_pipe_client *cli,
2711 struct policy_handle *_handle /* [in] [ref] */,
2712 struct QUERY_SERVICE_CONFIG *_query /* [out] [ref] */,
2713 uint32_t _offered /* [in] [range(0,8192)] */,
2714 uint32_t *_needed /* [out] [ref,range(0,8192)] */)
2715{
2716 struct tevent_req *req;
2717 struct rpccli_svcctl_QueryServiceConfigW_state *state;
2718 struct tevent_req *subreq;
2719
2720 req = tevent_req_create(mem_ctx, &state,
2721 struct rpccli_svcctl_QueryServiceConfigW_state);
2722 if (req == NULL) {
2723 return NULL;
2724 }
2725 state->out_mem_ctx = NULL;
2726 state->dispatch_recv = cli->dispatch_recv;
2727
2728 /* In parameters */
2729 state->orig.in.handle = _handle;
2730 state->orig.in.offered = _offered;
2731
2732 /* Out parameters */
2733 state->orig.out.query = _query;
2734 state->orig.out.needed = _needed;
2735
2736 /* Result */
2737 ZERO_STRUCT(state->orig.out.result);
2738
2739 state->out_mem_ctx = talloc_named_const(state, 0,
2740 "rpccli_svcctl_QueryServiceConfigW_out_memory");
2741 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2742 return tevent_req_post(req, ev);
2743 }
2744
2745 /* make a temporary copy, that we pass to the dispatch function */
2746 state->tmp = state->orig;
2747
2748 subreq = cli->dispatch_send(state, ev, cli,
2749 &ndr_table_svcctl,
2750 NDR_SVCCTL_QUERYSERVICECONFIGW,
2751 &state->tmp);
2752 if (tevent_req_nomem(subreq, req)) {
2753 return tevent_req_post(req, ev);
2754 }
2755 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceConfigW_done, req);
2756 return req;
2757}
2758
2759static void rpccli_svcctl_QueryServiceConfigW_done(struct tevent_req *subreq)
2760{
2761 struct tevent_req *req = tevent_req_callback_data(
2762 subreq, struct tevent_req);
2763 struct rpccli_svcctl_QueryServiceConfigW_state *state = tevent_req_data(
2764 req, struct rpccli_svcctl_QueryServiceConfigW_state);
2765 NTSTATUS status;
2766 TALLOC_CTX *mem_ctx;
2767
2768 if (state->out_mem_ctx) {
2769 mem_ctx = state->out_mem_ctx;
2770 } else {
2771 mem_ctx = state;
2772 }
2773
2774 status = state->dispatch_recv(subreq, mem_ctx);
2775 TALLOC_FREE(subreq);
2776 if (!NT_STATUS_IS_OK(status)) {
2777 tevent_req_nterror(req, status);
2778 return;
2779 }
2780
2781 /* Copy out parameters */
2782 *state->orig.out.query = *state->tmp.out.query;
2783 *state->orig.out.needed = *state->tmp.out.needed;
2784
2785 /* Copy result */
2786 state->orig.out.result = state->tmp.out.result;
2787
2788 /* Reset temporary structure */
2789 ZERO_STRUCT(state->tmp);
2790
2791 tevent_req_done(req);
2792}
2793
2794NTSTATUS rpccli_svcctl_QueryServiceConfigW_recv(struct tevent_req *req,
2795 TALLOC_CTX *mem_ctx,
2796 WERROR *result)
2797{
2798 struct rpccli_svcctl_QueryServiceConfigW_state *state = tevent_req_data(
2799 req, struct rpccli_svcctl_QueryServiceConfigW_state);
2800 NTSTATUS status;
2801
2802 if (tevent_req_is_nterror(req, &status)) {
2803 tevent_req_received(req);
2804 return status;
2805 }
2806
2807 /* Steal possbile out parameters to the callers context */
2808 talloc_steal(mem_ctx, state->out_mem_ctx);
2809
2810 /* Return result */
2811 *result = state->orig.out.result;
2812
2813 tevent_req_received(req);
2814 return NT_STATUS_OK;
2815}
2816
2817NTSTATUS rpccli_svcctl_QueryServiceConfigW(struct rpc_pipe_client *cli,
2818 TALLOC_CTX *mem_ctx,
2819 struct policy_handle *handle /* [in] [ref] */,
2820 struct QUERY_SERVICE_CONFIG *query /* [out] [ref] */,
2821 uint32_t offered /* [in] [range(0,8192)] */,
2822 uint32_t *needed /* [out] [ref,range(0,8192)] */,
2823 WERROR *werror)
2824{
2825 struct svcctl_QueryServiceConfigW r;
2826 NTSTATUS status;
2827
2828 /* In parameters */
2829 r.in.handle = handle;
2830 r.in.offered = offered;
2831
2832 status = cli->dispatch(cli,
2833 mem_ctx,
2834 &ndr_table_svcctl,
2835 NDR_SVCCTL_QUERYSERVICECONFIGW,
2836 &r);
2837
2838 if (!NT_STATUS_IS_OK(status)) {
2839 return status;
2840 }
2841
2842 if (NT_STATUS_IS_ERR(status)) {
2843 return status;
2844 }
2845
2846 /* Return variables */
2847 *query = *r.out.query;
2848 *needed = *r.out.needed;
2849
2850 /* Return result */
2851 if (werror) {
2852 *werror = r.out.result;
2853 }
2854
2855 return werror_to_ntstatus(r.out.result);
2856}
2857
2858struct rpccli_svcctl_QueryServiceLockStatusW_state {
2859 struct svcctl_QueryServiceLockStatusW orig;
2860 struct svcctl_QueryServiceLockStatusW tmp;
2861 TALLOC_CTX *out_mem_ctx;
2862 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2863};
2864
2865static void rpccli_svcctl_QueryServiceLockStatusW_done(struct tevent_req *subreq);
2866
2867struct tevent_req *rpccli_svcctl_QueryServiceLockStatusW_send(TALLOC_CTX *mem_ctx,
2868 struct tevent_context *ev,
2869 struct rpc_pipe_client *cli,
2870 struct policy_handle *_handle /* [in] [ref] */,
2871 uint32_t _offered /* [in] */,
2872 struct SERVICE_LOCK_STATUS *_lock_status /* [out] [ref] */,
2873 uint32_t *_needed /* [out] [ref] */)
2874{
2875 struct tevent_req *req;
2876 struct rpccli_svcctl_QueryServiceLockStatusW_state *state;
2877 struct tevent_req *subreq;
2878
2879 req = tevent_req_create(mem_ctx, &state,
2880 struct rpccli_svcctl_QueryServiceLockStatusW_state);
2881 if (req == NULL) {
2882 return NULL;
2883 }
2884 state->out_mem_ctx = NULL;
2885 state->dispatch_recv = cli->dispatch_recv;
2886
2887 /* In parameters */
2888 state->orig.in.handle = _handle;
2889 state->orig.in.offered = _offered;
2890
2891 /* Out parameters */
2892 state->orig.out.lock_status = _lock_status;
2893 state->orig.out.needed = _needed;
2894
2895 /* Result */
2896 ZERO_STRUCT(state->orig.out.result);
2897
2898 state->out_mem_ctx = talloc_named_const(state, 0,
2899 "rpccli_svcctl_QueryServiceLockStatusW_out_memory");
2900 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2901 return tevent_req_post(req, ev);
2902 }
2903
2904 /* make a temporary copy, that we pass to the dispatch function */
2905 state->tmp = state->orig;
2906
2907 subreq = cli->dispatch_send(state, ev, cli,
2908 &ndr_table_svcctl,
2909 NDR_SVCCTL_QUERYSERVICELOCKSTATUSW,
2910 &state->tmp);
2911 if (tevent_req_nomem(subreq, req)) {
2912 return tevent_req_post(req, ev);
2913 }
2914 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceLockStatusW_done, req);
2915 return req;
2916}
2917
2918static void rpccli_svcctl_QueryServiceLockStatusW_done(struct tevent_req *subreq)
2919{
2920 struct tevent_req *req = tevent_req_callback_data(
2921 subreq, struct tevent_req);
2922 struct rpccli_svcctl_QueryServiceLockStatusW_state *state = tevent_req_data(
2923 req, struct rpccli_svcctl_QueryServiceLockStatusW_state);
2924 NTSTATUS status;
2925 TALLOC_CTX *mem_ctx;
2926
2927 if (state->out_mem_ctx) {
2928 mem_ctx = state->out_mem_ctx;
2929 } else {
2930 mem_ctx = state;
2931 }
2932
2933 status = state->dispatch_recv(subreq, mem_ctx);
2934 TALLOC_FREE(subreq);
2935 if (!NT_STATUS_IS_OK(status)) {
2936 tevent_req_nterror(req, status);
2937 return;
2938 }
2939
2940 /* Copy out parameters */
2941 *state->orig.out.lock_status = *state->tmp.out.lock_status;
2942 *state->orig.out.needed = *state->tmp.out.needed;
2943
2944 /* Copy result */
2945 state->orig.out.result = state->tmp.out.result;
2946
2947 /* Reset temporary structure */
2948 ZERO_STRUCT(state->tmp);
2949
2950 tevent_req_done(req);
2951}
2952
2953NTSTATUS rpccli_svcctl_QueryServiceLockStatusW_recv(struct tevent_req *req,
2954 TALLOC_CTX *mem_ctx,
2955 WERROR *result)
2956{
2957 struct rpccli_svcctl_QueryServiceLockStatusW_state *state = tevent_req_data(
2958 req, struct rpccli_svcctl_QueryServiceLockStatusW_state);
2959 NTSTATUS status;
2960
2961 if (tevent_req_is_nterror(req, &status)) {
2962 tevent_req_received(req);
2963 return status;
2964 }
2965
2966 /* Steal possbile out parameters to the callers context */
2967 talloc_steal(mem_ctx, state->out_mem_ctx);
2968
2969 /* Return result */
2970 *result = state->orig.out.result;
2971
2972 tevent_req_received(req);
2973 return NT_STATUS_OK;
2974}
2975
2976NTSTATUS rpccli_svcctl_QueryServiceLockStatusW(struct rpc_pipe_client *cli,
2977 TALLOC_CTX *mem_ctx,
2978 struct policy_handle *handle /* [in] [ref] */,
2979 uint32_t offered /* [in] */,
2980 struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
2981 uint32_t *needed /* [out] [ref] */,
2982 WERROR *werror)
2983{
2984 struct svcctl_QueryServiceLockStatusW r;
2985 NTSTATUS status;
2986
2987 /* In parameters */
2988 r.in.handle = handle;
2989 r.in.offered = offered;
2990
2991 status = cli->dispatch(cli,
2992 mem_ctx,
2993 &ndr_table_svcctl,
2994 NDR_SVCCTL_QUERYSERVICELOCKSTATUSW,
2995 &r);
2996
2997 if (!NT_STATUS_IS_OK(status)) {
2998 return status;
2999 }
3000
3001 if (NT_STATUS_IS_ERR(status)) {
3002 return status;
3003 }
3004
3005 /* Return variables */
3006 *lock_status = *r.out.lock_status;
3007 *needed = *r.out.needed;
3008
3009 /* Return result */
3010 if (werror) {
3011 *werror = r.out.result;
3012 }
3013
3014 return werror_to_ntstatus(r.out.result);
3015}
3016
3017struct rpccli_svcctl_StartServiceW_state {
3018 struct svcctl_StartServiceW orig;
3019 struct svcctl_StartServiceW tmp;
3020 TALLOC_CTX *out_mem_ctx;
3021 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3022};
3023
3024static void rpccli_svcctl_StartServiceW_done(struct tevent_req *subreq);
3025
3026struct tevent_req *rpccli_svcctl_StartServiceW_send(TALLOC_CTX *mem_ctx,
3027 struct tevent_context *ev,
3028 struct rpc_pipe_client *cli,
3029 struct policy_handle *_handle /* [in] [ref] */,
3030 uint32_t _NumArgs /* [in] [range(0,SC_MAX_ARGUMENTS)] */,
3031 struct svcctl_ArgumentString *_Arguments /* [in] [unique,size_is(NumArgs)] */)
3032{
3033 struct tevent_req *req;
3034 struct rpccli_svcctl_StartServiceW_state *state;
3035 struct tevent_req *subreq;
3036
3037 req = tevent_req_create(mem_ctx, &state,
3038 struct rpccli_svcctl_StartServiceW_state);
3039 if (req == NULL) {
3040 return NULL;
3041 }
3042 state->out_mem_ctx = NULL;
3043 state->dispatch_recv = cli->dispatch_recv;
3044
3045 /* In parameters */
3046 state->orig.in.handle = _handle;
3047 state->orig.in.NumArgs = _NumArgs;
3048 state->orig.in.Arguments = _Arguments;
3049
3050 /* Out parameters */
3051
3052 /* Result */
3053 ZERO_STRUCT(state->orig.out.result);
3054
3055 /* make a temporary copy, that we pass to the dispatch function */
3056 state->tmp = state->orig;
3057
3058 subreq = cli->dispatch_send(state, ev, cli,
3059 &ndr_table_svcctl,
3060 NDR_SVCCTL_STARTSERVICEW,
3061 &state->tmp);
3062 if (tevent_req_nomem(subreq, req)) {
3063 return tevent_req_post(req, ev);
3064 }
3065 tevent_req_set_callback(subreq, rpccli_svcctl_StartServiceW_done, req);
3066 return req;
3067}
3068
3069static void rpccli_svcctl_StartServiceW_done(struct tevent_req *subreq)
3070{
3071 struct tevent_req *req = tevent_req_callback_data(
3072 subreq, struct tevent_req);
3073 struct rpccli_svcctl_StartServiceW_state *state = tevent_req_data(
3074 req, struct rpccli_svcctl_StartServiceW_state);
3075 NTSTATUS status;
3076 TALLOC_CTX *mem_ctx;
3077
3078 if (state->out_mem_ctx) {
3079 mem_ctx = state->out_mem_ctx;
3080 } else {
3081 mem_ctx = state;
3082 }
3083
3084 status = state->dispatch_recv(subreq, mem_ctx);
3085 TALLOC_FREE(subreq);
3086 if (!NT_STATUS_IS_OK(status)) {
3087 tevent_req_nterror(req, status);
3088 return;
3089 }
3090
3091 /* Copy out parameters */
3092
3093 /* Copy result */
3094 state->orig.out.result = state->tmp.out.result;
3095
3096 /* Reset temporary structure */
3097 ZERO_STRUCT(state->tmp);
3098
3099 tevent_req_done(req);
3100}
3101
3102NTSTATUS rpccli_svcctl_StartServiceW_recv(struct tevent_req *req,
3103 TALLOC_CTX *mem_ctx,
3104 WERROR *result)
3105{
3106 struct rpccli_svcctl_StartServiceW_state *state = tevent_req_data(
3107 req, struct rpccli_svcctl_StartServiceW_state);
3108 NTSTATUS status;
3109
3110 if (tevent_req_is_nterror(req, &status)) {
3111 tevent_req_received(req);
3112 return status;
3113 }
3114
3115 /* Steal possbile out parameters to the callers context */
3116 talloc_steal(mem_ctx, state->out_mem_ctx);
3117
3118 /* Return result */
3119 *result = state->orig.out.result;
3120
3121 tevent_req_received(req);
3122 return NT_STATUS_OK;
3123}
3124
3125NTSTATUS rpccli_svcctl_StartServiceW(struct rpc_pipe_client *cli,
3126 TALLOC_CTX *mem_ctx,
3127 struct policy_handle *handle /* [in] [ref] */,
3128 uint32_t NumArgs /* [in] [range(0,SC_MAX_ARGUMENTS)] */,
3129 struct svcctl_ArgumentString *Arguments /* [in] [unique,size_is(NumArgs)] */,
3130 WERROR *werror)
3131{
3132 struct svcctl_StartServiceW r;
3133 NTSTATUS status;
3134
3135 /* In parameters */
3136 r.in.handle = handle;
3137 r.in.NumArgs = NumArgs;
3138 r.in.Arguments = Arguments;
3139
3140 status = cli->dispatch(cli,
3141 mem_ctx,
3142 &ndr_table_svcctl,
3143 NDR_SVCCTL_STARTSERVICEW,
3144 &r);
3145
3146 if (!NT_STATUS_IS_OK(status)) {
3147 return status;
3148 }
3149
3150 if (NT_STATUS_IS_ERR(status)) {
3151 return status;
3152 }
3153
3154 /* Return variables */
3155
3156 /* Return result */
3157 if (werror) {
3158 *werror = r.out.result;
3159 }
3160
3161 return werror_to_ntstatus(r.out.result);
3162}
3163
3164struct rpccli_svcctl_GetServiceDisplayNameW_state {
3165 struct svcctl_GetServiceDisplayNameW orig;
3166 struct svcctl_GetServiceDisplayNameW tmp;
3167 TALLOC_CTX *out_mem_ctx;
3168 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3169};
3170
3171static void rpccli_svcctl_GetServiceDisplayNameW_done(struct tevent_req *subreq);
3172
3173struct tevent_req *rpccli_svcctl_GetServiceDisplayNameW_send(TALLOC_CTX *mem_ctx,
3174 struct tevent_context *ev,
3175 struct rpc_pipe_client *cli,
3176 struct policy_handle *_handle /* [in] [ref] */,
3177 const char *_service_name /* [in] [unique,charset(UTF16)] */,
3178 const char **_display_name /* [out] [ref,charset(UTF16)] */,
3179 uint32_t *_display_name_length /* [in,out] [unique] */)
3180{
3181 struct tevent_req *req;
3182 struct rpccli_svcctl_GetServiceDisplayNameW_state *state;
3183 struct tevent_req *subreq;
3184
3185 req = tevent_req_create(mem_ctx, &state,
3186 struct rpccli_svcctl_GetServiceDisplayNameW_state);
3187 if (req == NULL) {
3188 return NULL;
3189 }
3190 state->out_mem_ctx = NULL;
3191 state->dispatch_recv = cli->dispatch_recv;
3192
3193 /* In parameters */
3194 state->orig.in.handle = _handle;
3195 state->orig.in.service_name = _service_name;
3196 state->orig.in.display_name_length = _display_name_length;
3197
3198 /* Out parameters */
3199 state->orig.out.display_name = _display_name;
3200 state->orig.out.display_name_length = _display_name_length;
3201
3202 /* Result */
3203 ZERO_STRUCT(state->orig.out.result);
3204
3205 state->out_mem_ctx = talloc_named_const(state, 0,
3206 "rpccli_svcctl_GetServiceDisplayNameW_out_memory");
3207 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3208 return tevent_req_post(req, ev);
3209 }
3210
3211 /* make a temporary copy, that we pass to the dispatch function */
3212 state->tmp = state->orig;
3213
3214 subreq = cli->dispatch_send(state, ev, cli,
3215 &ndr_table_svcctl,
3216 NDR_SVCCTL_GETSERVICEDISPLAYNAMEW,
3217 &state->tmp);
3218 if (tevent_req_nomem(subreq, req)) {
3219 return tevent_req_post(req, ev);
3220 }
3221 tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceDisplayNameW_done, req);
3222 return req;
3223}
3224
3225static void rpccli_svcctl_GetServiceDisplayNameW_done(struct tevent_req *subreq)
3226{
3227 struct tevent_req *req = tevent_req_callback_data(
3228 subreq, struct tevent_req);
3229 struct rpccli_svcctl_GetServiceDisplayNameW_state *state = tevent_req_data(
3230 req, struct rpccli_svcctl_GetServiceDisplayNameW_state);
3231 NTSTATUS status;
3232 TALLOC_CTX *mem_ctx;
3233
3234 if (state->out_mem_ctx) {
3235 mem_ctx = state->out_mem_ctx;
3236 } else {
3237 mem_ctx = state;
3238 }
3239
3240 status = state->dispatch_recv(subreq, mem_ctx);
3241 TALLOC_FREE(subreq);
3242 if (!NT_STATUS_IS_OK(status)) {
3243 tevent_req_nterror(req, status);
3244 return;
3245 }
3246
3247 /* Copy out parameters */
3248 *state->orig.out.display_name = *state->tmp.out.display_name;
3249 if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
3250 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
3251 }
3252
3253 /* Copy result */
3254 state->orig.out.result = state->tmp.out.result;
3255
3256 /* Reset temporary structure */
3257 ZERO_STRUCT(state->tmp);
3258
3259 tevent_req_done(req);
3260}
3261
3262NTSTATUS rpccli_svcctl_GetServiceDisplayNameW_recv(struct tevent_req *req,
3263 TALLOC_CTX *mem_ctx,
3264 WERROR *result)
3265{
3266 struct rpccli_svcctl_GetServiceDisplayNameW_state *state = tevent_req_data(
3267 req, struct rpccli_svcctl_GetServiceDisplayNameW_state);
3268 NTSTATUS status;
3269
3270 if (tevent_req_is_nterror(req, &status)) {
3271 tevent_req_received(req);
3272 return status;
3273 }
3274
3275 /* Steal possbile out parameters to the callers context */
3276 talloc_steal(mem_ctx, state->out_mem_ctx);
3277
3278 /* Return result */
3279 *result = state->orig.out.result;
3280
3281 tevent_req_received(req);
3282 return NT_STATUS_OK;
3283}
3284
3285NTSTATUS rpccli_svcctl_GetServiceDisplayNameW(struct rpc_pipe_client *cli,
3286 TALLOC_CTX *mem_ctx,
3287 struct policy_handle *handle /* [in] [ref] */,
3288 const char *service_name /* [in] [unique,charset(UTF16)] */,
3289 const char **display_name /* [out] [ref,charset(UTF16)] */,
3290 uint32_t *display_name_length /* [in,out] [unique] */,
3291 WERROR *werror)
3292{
3293 struct svcctl_GetServiceDisplayNameW r;
3294 NTSTATUS status;
3295
3296 /* In parameters */
3297 r.in.handle = handle;
3298 r.in.service_name = service_name;
3299 r.in.display_name_length = display_name_length;
3300
3301 status = cli->dispatch(cli,
3302 mem_ctx,
3303 &ndr_table_svcctl,
3304 NDR_SVCCTL_GETSERVICEDISPLAYNAMEW,
3305 &r);
3306
3307 if (!NT_STATUS_IS_OK(status)) {
3308 return status;
3309 }
3310
3311 if (NT_STATUS_IS_ERR(status)) {
3312 return status;
3313 }
3314
3315 /* Return variables */
3316 *display_name = *r.out.display_name;
3317 if (display_name_length && r.out.display_name_length) {
3318 *display_name_length = *r.out.display_name_length;
3319 }
3320
3321 /* Return result */
3322 if (werror) {
3323 *werror = r.out.result;
3324 }
3325
3326 return werror_to_ntstatus(r.out.result);
3327}
3328
3329struct rpccli_svcctl_GetServiceKeyNameW_state {
3330 struct svcctl_GetServiceKeyNameW orig;
3331 struct svcctl_GetServiceKeyNameW tmp;
3332 TALLOC_CTX *out_mem_ctx;
3333 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3334};
3335
3336static void rpccli_svcctl_GetServiceKeyNameW_done(struct tevent_req *subreq);
3337
3338struct tevent_req *rpccli_svcctl_GetServiceKeyNameW_send(TALLOC_CTX *mem_ctx,
3339 struct tevent_context *ev,
3340 struct rpc_pipe_client *cli,
3341 struct policy_handle *_handle /* [in] [ref] */,
3342 const char *_service_name /* [in] [unique,charset(UTF16)] */,
3343 const char **_key_name /* [out] [ref,charset(UTF16)] */,
3344 uint32_t *_display_name_length /* [in,out] [unique] */)
3345{
3346 struct tevent_req *req;
3347 struct rpccli_svcctl_GetServiceKeyNameW_state *state;
3348 struct tevent_req *subreq;
3349
3350 req = tevent_req_create(mem_ctx, &state,
3351 struct rpccli_svcctl_GetServiceKeyNameW_state);
3352 if (req == NULL) {
3353 return NULL;
3354 }
3355 state->out_mem_ctx = NULL;
3356 state->dispatch_recv = cli->dispatch_recv;
3357
3358 /* In parameters */
3359 state->orig.in.handle = _handle;
3360 state->orig.in.service_name = _service_name;
3361 state->orig.in.display_name_length = _display_name_length;
3362
3363 /* Out parameters */
3364 state->orig.out.key_name = _key_name;
3365 state->orig.out.display_name_length = _display_name_length;
3366
3367 /* Result */
3368 ZERO_STRUCT(state->orig.out.result);
3369
3370 state->out_mem_ctx = talloc_named_const(state, 0,
3371 "rpccli_svcctl_GetServiceKeyNameW_out_memory");
3372 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3373 return tevent_req_post(req, ev);
3374 }
3375
3376 /* make a temporary copy, that we pass to the dispatch function */
3377 state->tmp = state->orig;
3378
3379 subreq = cli->dispatch_send(state, ev, cli,
3380 &ndr_table_svcctl,
3381 NDR_SVCCTL_GETSERVICEKEYNAMEW,
3382 &state->tmp);
3383 if (tevent_req_nomem(subreq, req)) {
3384 return tevent_req_post(req, ev);
3385 }
3386 tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceKeyNameW_done, req);
3387 return req;
3388}
3389
3390static void rpccli_svcctl_GetServiceKeyNameW_done(struct tevent_req *subreq)
3391{
3392 struct tevent_req *req = tevent_req_callback_data(
3393 subreq, struct tevent_req);
3394 struct rpccli_svcctl_GetServiceKeyNameW_state *state = tevent_req_data(
3395 req, struct rpccli_svcctl_GetServiceKeyNameW_state);
3396 NTSTATUS status;
3397 TALLOC_CTX *mem_ctx;
3398
3399 if (state->out_mem_ctx) {
3400 mem_ctx = state->out_mem_ctx;
3401 } else {
3402 mem_ctx = state;
3403 }
3404
3405 status = state->dispatch_recv(subreq, mem_ctx);
3406 TALLOC_FREE(subreq);
3407 if (!NT_STATUS_IS_OK(status)) {
3408 tevent_req_nterror(req, status);
3409 return;
3410 }
3411
3412 /* Copy out parameters */
3413 *state->orig.out.key_name = *state->tmp.out.key_name;
3414 if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
3415 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
3416 }
3417
3418 /* Copy result */
3419 state->orig.out.result = state->tmp.out.result;
3420
3421 /* Reset temporary structure */
3422 ZERO_STRUCT(state->tmp);
3423
3424 tevent_req_done(req);
3425}
3426
3427NTSTATUS rpccli_svcctl_GetServiceKeyNameW_recv(struct tevent_req *req,
3428 TALLOC_CTX *mem_ctx,
3429 WERROR *result)
3430{
3431 struct rpccli_svcctl_GetServiceKeyNameW_state *state = tevent_req_data(
3432 req, struct rpccli_svcctl_GetServiceKeyNameW_state);
3433 NTSTATUS status;
3434
3435 if (tevent_req_is_nterror(req, &status)) {
3436 tevent_req_received(req);
3437 return status;
3438 }
3439
3440 /* Steal possbile out parameters to the callers context */
3441 talloc_steal(mem_ctx, state->out_mem_ctx);
3442
3443 /* Return result */
3444 *result = state->orig.out.result;
3445
3446 tevent_req_received(req);
3447 return NT_STATUS_OK;
3448}
3449
3450NTSTATUS rpccli_svcctl_GetServiceKeyNameW(struct rpc_pipe_client *cli,
3451 TALLOC_CTX *mem_ctx,
3452 struct policy_handle *handle /* [in] [ref] */,
3453 const char *service_name /* [in] [unique,charset(UTF16)] */,
3454 const char **key_name /* [out] [ref,charset(UTF16)] */,
3455 uint32_t *display_name_length /* [in,out] [unique] */,
3456 WERROR *werror)
3457{
3458 struct svcctl_GetServiceKeyNameW r;
3459 NTSTATUS status;
3460
3461 /* In parameters */
3462 r.in.handle = handle;
3463 r.in.service_name = service_name;
3464 r.in.display_name_length = display_name_length;
3465
3466 status = cli->dispatch(cli,
3467 mem_ctx,
3468 &ndr_table_svcctl,
3469 NDR_SVCCTL_GETSERVICEKEYNAMEW,
3470 &r);
3471
3472 if (!NT_STATUS_IS_OK(status)) {
3473 return status;
3474 }
3475
3476 if (NT_STATUS_IS_ERR(status)) {
3477 return status;
3478 }
3479
3480 /* Return variables */
3481 *key_name = *r.out.key_name;
3482 if (display_name_length && r.out.display_name_length) {
3483 *display_name_length = *r.out.display_name_length;
3484 }
3485
3486 /* Return result */
3487 if (werror) {
3488 *werror = r.out.result;
3489 }
3490
3491 return werror_to_ntstatus(r.out.result);
3492}
3493
3494struct rpccli_svcctl_SCSetServiceBitsA_state {
3495 struct svcctl_SCSetServiceBitsA orig;
3496 struct svcctl_SCSetServiceBitsA tmp;
3497 TALLOC_CTX *out_mem_ctx;
3498 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3499};
3500
3501static void rpccli_svcctl_SCSetServiceBitsA_done(struct tevent_req *subreq);
3502
3503struct tevent_req *rpccli_svcctl_SCSetServiceBitsA_send(TALLOC_CTX *mem_ctx,
3504 struct tevent_context *ev,
3505 struct rpc_pipe_client *cli,
3506 struct policy_handle *_handle /* [in] [ref] */,
3507 uint32_t _bits /* [in] */,
3508 uint32_t _bitson /* [in] */,
3509 uint32_t _immediate /* [in] */)
3510{
3511 struct tevent_req *req;
3512 struct rpccli_svcctl_SCSetServiceBitsA_state *state;
3513 struct tevent_req *subreq;
3514
3515 req = tevent_req_create(mem_ctx, &state,
3516 struct rpccli_svcctl_SCSetServiceBitsA_state);
3517 if (req == NULL) {
3518 return NULL;
3519 }
3520 state->out_mem_ctx = NULL;
3521 state->dispatch_recv = cli->dispatch_recv;
3522
3523 /* In parameters */
3524 state->orig.in.handle = _handle;
3525 state->orig.in.bits = _bits;
3526 state->orig.in.bitson = _bitson;
3527 state->orig.in.immediate = _immediate;
3528
3529 /* Out parameters */
3530
3531 /* Result */
3532 ZERO_STRUCT(state->orig.out.result);
3533
3534 /* make a temporary copy, that we pass to the dispatch function */
3535 state->tmp = state->orig;
3536
3537 subreq = cli->dispatch_send(state, ev, cli,
3538 &ndr_table_svcctl,
3539 NDR_SVCCTL_SCSETSERVICEBITSA,
3540 &state->tmp);
3541 if (tevent_req_nomem(subreq, req)) {
3542 return tevent_req_post(req, ev);
3543 }
3544 tevent_req_set_callback(subreq, rpccli_svcctl_SCSetServiceBitsA_done, req);
3545 return req;
3546}
3547
3548static void rpccli_svcctl_SCSetServiceBitsA_done(struct tevent_req *subreq)
3549{
3550 struct tevent_req *req = tevent_req_callback_data(
3551 subreq, struct tevent_req);
3552 struct rpccli_svcctl_SCSetServiceBitsA_state *state = tevent_req_data(
3553 req, struct rpccli_svcctl_SCSetServiceBitsA_state);
3554 NTSTATUS status;
3555 TALLOC_CTX *mem_ctx;
3556
3557 if (state->out_mem_ctx) {
3558 mem_ctx = state->out_mem_ctx;
3559 } else {
3560 mem_ctx = state;
3561 }
3562
3563 status = state->dispatch_recv(subreq, mem_ctx);
3564 TALLOC_FREE(subreq);
3565 if (!NT_STATUS_IS_OK(status)) {
3566 tevent_req_nterror(req, status);
3567 return;
3568 }
3569
3570 /* Copy out parameters */
3571
3572 /* Copy result */
3573 state->orig.out.result = state->tmp.out.result;
3574
3575 /* Reset temporary structure */
3576 ZERO_STRUCT(state->tmp);
3577
3578 tevent_req_done(req);
3579}
3580
3581NTSTATUS rpccli_svcctl_SCSetServiceBitsA_recv(struct tevent_req *req,
3582 TALLOC_CTX *mem_ctx,
3583 WERROR *result)
3584{
3585 struct rpccli_svcctl_SCSetServiceBitsA_state *state = tevent_req_data(
3586 req, struct rpccli_svcctl_SCSetServiceBitsA_state);
3587 NTSTATUS status;
3588
3589 if (tevent_req_is_nterror(req, &status)) {
3590 tevent_req_received(req);
3591 return status;
3592 }
3593
3594 /* Steal possbile out parameters to the callers context */
3595 talloc_steal(mem_ctx, state->out_mem_ctx);
3596
3597 /* Return result */
3598 *result = state->orig.out.result;
3599
3600 tevent_req_received(req);
3601 return NT_STATUS_OK;
3602}
3603
3604NTSTATUS rpccli_svcctl_SCSetServiceBitsA(struct rpc_pipe_client *cli,
3605 TALLOC_CTX *mem_ctx,
3606 struct policy_handle *handle /* [in] [ref] */,
3607 uint32_t bits /* [in] */,
3608 uint32_t bitson /* [in] */,
3609 uint32_t immediate /* [in] */,
3610 WERROR *werror)
3611{
3612 struct svcctl_SCSetServiceBitsA r;
3613 NTSTATUS status;
3614
3615 /* In parameters */
3616 r.in.handle = handle;
3617 r.in.bits = bits;
3618 r.in.bitson = bitson;
3619 r.in.immediate = immediate;
3620
3621 status = cli->dispatch(cli,
3622 mem_ctx,
3623 &ndr_table_svcctl,
3624 NDR_SVCCTL_SCSETSERVICEBITSA,
3625 &r);
3626
3627 if (!NT_STATUS_IS_OK(status)) {
3628 return status;
3629 }
3630
3631 if (NT_STATUS_IS_ERR(status)) {
3632 return status;
3633 }
3634
3635 /* Return variables */
3636
3637 /* Return result */
3638 if (werror) {
3639 *werror = r.out.result;
3640 }
3641
3642 return werror_to_ntstatus(r.out.result);
3643}
3644
3645struct rpccli_svcctl_ChangeServiceConfigA_state {
3646 struct svcctl_ChangeServiceConfigA orig;
3647 struct svcctl_ChangeServiceConfigA tmp;
3648 TALLOC_CTX *out_mem_ctx;
3649 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3650};
3651
3652static void rpccli_svcctl_ChangeServiceConfigA_done(struct tevent_req *subreq);
3653
3654struct tevent_req *rpccli_svcctl_ChangeServiceConfigA_send(TALLOC_CTX *mem_ctx,
3655 struct tevent_context *ev,
3656 struct rpc_pipe_client *cli,
3657 struct policy_handle *_handle /* [in] [ref] */,
3658 uint32_t _type /* [in] */,
3659 enum svcctl_StartType _start_type /* [in] */,
3660 enum svcctl_ErrorControl _error_control /* [in] */,
3661 const char *_binary_path /* [in] [unique,charset(UTF16)] */,
3662 const char *_load_order_group /* [in] [unique,charset(UTF16)] */,
3663 uint32_t *_tag_id /* [out] [ref] */,
3664 const char *_dependencies /* [in] [unique,charset(UTF16)] */,
3665 const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
3666 const char *_password /* [in] [unique,charset(UTF16)] */,
3667 const char *_display_name /* [in] [unique,charset(UTF16)] */)
3668{
3669 struct tevent_req *req;
3670 struct rpccli_svcctl_ChangeServiceConfigA_state *state;
3671 struct tevent_req *subreq;
3672
3673 req = tevent_req_create(mem_ctx, &state,
3674 struct rpccli_svcctl_ChangeServiceConfigA_state);
3675 if (req == NULL) {
3676 return NULL;
3677 }
3678 state->out_mem_ctx = NULL;
3679 state->dispatch_recv = cli->dispatch_recv;
3680
3681 /* In parameters */
3682 state->orig.in.handle = _handle;
3683 state->orig.in.type = _type;
3684 state->orig.in.start_type = _start_type;
3685 state->orig.in.error_control = _error_control;
3686 state->orig.in.binary_path = _binary_path;
3687 state->orig.in.load_order_group = _load_order_group;
3688 state->orig.in.dependencies = _dependencies;
3689 state->orig.in.service_start_name = _service_start_name;
3690 state->orig.in.password = _password;
3691 state->orig.in.display_name = _display_name;
3692
3693 /* Out parameters */
3694 state->orig.out.tag_id = _tag_id;
3695
3696 /* Result */
3697 ZERO_STRUCT(state->orig.out.result);
3698
3699 state->out_mem_ctx = talloc_named_const(state, 0,
3700 "rpccli_svcctl_ChangeServiceConfigA_out_memory");
3701 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3702 return tevent_req_post(req, ev);
3703 }
3704
3705 /* make a temporary copy, that we pass to the dispatch function */
3706 state->tmp = state->orig;
3707
3708 subreq = cli->dispatch_send(state, ev, cli,
3709 &ndr_table_svcctl,
3710 NDR_SVCCTL_CHANGESERVICECONFIGA,
3711 &state->tmp);
3712 if (tevent_req_nomem(subreq, req)) {
3713 return tevent_req_post(req, ev);
3714 }
3715 tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfigA_done, req);
3716 return req;
3717}
3718
3719static void rpccli_svcctl_ChangeServiceConfigA_done(struct tevent_req *subreq)
3720{
3721 struct tevent_req *req = tevent_req_callback_data(
3722 subreq, struct tevent_req);
3723 struct rpccli_svcctl_ChangeServiceConfigA_state *state = tevent_req_data(
3724 req, struct rpccli_svcctl_ChangeServiceConfigA_state);
3725 NTSTATUS status;
3726 TALLOC_CTX *mem_ctx;
3727
3728 if (state->out_mem_ctx) {
3729 mem_ctx = state->out_mem_ctx;
3730 } else {
3731 mem_ctx = state;
3732 }
3733
3734 status = state->dispatch_recv(subreq, mem_ctx);
3735 TALLOC_FREE(subreq);
3736 if (!NT_STATUS_IS_OK(status)) {
3737 tevent_req_nterror(req, status);
3738 return;
3739 }
3740
3741 /* Copy out parameters */
3742 *state->orig.out.tag_id = *state->tmp.out.tag_id;
3743
3744 /* Copy result */
3745 state->orig.out.result = state->tmp.out.result;
3746
3747 /* Reset temporary structure */
3748 ZERO_STRUCT(state->tmp);
3749
3750 tevent_req_done(req);
3751}
3752
3753NTSTATUS rpccli_svcctl_ChangeServiceConfigA_recv(struct tevent_req *req,
3754 TALLOC_CTX *mem_ctx,
3755 WERROR *result)
3756{
3757 struct rpccli_svcctl_ChangeServiceConfigA_state *state = tevent_req_data(
3758 req, struct rpccli_svcctl_ChangeServiceConfigA_state);
3759 NTSTATUS status;
3760
3761 if (tevent_req_is_nterror(req, &status)) {
3762 tevent_req_received(req);
3763 return status;
3764 }
3765
3766 /* Steal possbile out parameters to the callers context */
3767 talloc_steal(mem_ctx, state->out_mem_ctx);
3768
3769 /* Return result */
3770 *result = state->orig.out.result;
3771
3772 tevent_req_received(req);
3773 return NT_STATUS_OK;
3774}
3775
3776NTSTATUS rpccli_svcctl_ChangeServiceConfigA(struct rpc_pipe_client *cli,
3777 TALLOC_CTX *mem_ctx,
3778 struct policy_handle *handle /* [in] [ref] */,
3779 uint32_t type /* [in] */,
3780 enum svcctl_StartType start_type /* [in] */,
3781 enum svcctl_ErrorControl error_control /* [in] */,
3782 const char *binary_path /* [in] [unique,charset(UTF16)] */,
3783 const char *load_order_group /* [in] [unique,charset(UTF16)] */,
3784 uint32_t *tag_id /* [out] [ref] */,
3785 const char *dependencies /* [in] [unique,charset(UTF16)] */,
3786 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
3787 const char *password /* [in] [unique,charset(UTF16)] */,
3788 const char *display_name /* [in] [unique,charset(UTF16)] */,
3789 WERROR *werror)
3790{
3791 struct svcctl_ChangeServiceConfigA r;
3792 NTSTATUS status;
3793
3794 /* In parameters */
3795 r.in.handle = handle;
3796 r.in.type = type;
3797 r.in.start_type = start_type;
3798 r.in.error_control = error_control;
3799 r.in.binary_path = binary_path;
3800 r.in.load_order_group = load_order_group;
3801 r.in.dependencies = dependencies;
3802 r.in.service_start_name = service_start_name;
3803 r.in.password = password;
3804 r.in.display_name = display_name;
3805
3806 status = cli->dispatch(cli,
3807 mem_ctx,
3808 &ndr_table_svcctl,
3809 NDR_SVCCTL_CHANGESERVICECONFIGA,
3810 &r);
3811
3812 if (!NT_STATUS_IS_OK(status)) {
3813 return status;
3814 }
3815
3816 if (NT_STATUS_IS_ERR(status)) {
3817 return status;
3818 }
3819
3820 /* Return variables */
3821 *tag_id = *r.out.tag_id;
3822
3823 /* Return result */
3824 if (werror) {
3825 *werror = r.out.result;
3826 }
3827
3828 return werror_to_ntstatus(r.out.result);
3829}
3830
3831struct rpccli_svcctl_CreateServiceA_state {
3832 struct svcctl_CreateServiceA orig;
3833 struct svcctl_CreateServiceA tmp;
3834 TALLOC_CTX *out_mem_ctx;
3835 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3836};
3837
3838static void rpccli_svcctl_CreateServiceA_done(struct tevent_req *subreq);
3839
3840struct tevent_req *rpccli_svcctl_CreateServiceA_send(TALLOC_CTX *mem_ctx,
3841 struct tevent_context *ev,
3842 struct rpc_pipe_client *cli,
3843 struct policy_handle *_handle /* [in] [ref] */,
3844 const char *_ServiceName /* [in] [unique,charset(UTF16)] */,
3845 const char *_DisplayName /* [in] [unique,charset(UTF16)] */,
3846 uint32_t _desired_access /* [in] */,
3847 uint32_t _type /* [in] */,
3848 enum svcctl_StartType _start_type /* [in] */,
3849 enum svcctl_ErrorControl _error_control /* [in] */,
3850 const char *_binary_path /* [in] [unique,charset(UTF16)] */,
3851 const char *_LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
3852 uint32_t *_TagId /* [out] [unique] */,
3853 const char *_dependencies /* [in] [unique,charset(UTF16)] */,
3854 const char *_service_start_name /* [in] [unique,charset(UTF16)] */,
3855 const char *_password /* [in] [unique,charset(UTF16)] */)
3856{
3857 struct tevent_req *req;
3858 struct rpccli_svcctl_CreateServiceA_state *state;
3859 struct tevent_req *subreq;
3860
3861 req = tevent_req_create(mem_ctx, &state,
3862 struct rpccli_svcctl_CreateServiceA_state);
3863 if (req == NULL) {
3864 return NULL;
3865 }
3866 state->out_mem_ctx = NULL;
3867 state->dispatch_recv = cli->dispatch_recv;
3868
3869 /* In parameters */
3870 state->orig.in.handle = _handle;
3871 state->orig.in.ServiceName = _ServiceName;
3872 state->orig.in.DisplayName = _DisplayName;
3873 state->orig.in.desired_access = _desired_access;
3874 state->orig.in.type = _type;
3875 state->orig.in.start_type = _start_type;
3876 state->orig.in.error_control = _error_control;
3877 state->orig.in.binary_path = _binary_path;
3878 state->orig.in.LoadOrderGroupKey = _LoadOrderGroupKey;
3879 state->orig.in.dependencies = _dependencies;
3880 state->orig.in.service_start_name = _service_start_name;
3881 state->orig.in.password = _password;
3882
3883 /* Out parameters */
3884 state->orig.out.TagId = _TagId;
3885
3886 /* Result */
3887 ZERO_STRUCT(state->orig.out.result);
3888
3889 state->out_mem_ctx = talloc_named_const(state, 0,
3890 "rpccli_svcctl_CreateServiceA_out_memory");
3891 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3892 return tevent_req_post(req, ev);
3893 }
3894
3895 /* make a temporary copy, that we pass to the dispatch function */
3896 state->tmp = state->orig;
3897
3898 subreq = cli->dispatch_send(state, ev, cli,
3899 &ndr_table_svcctl,
3900 NDR_SVCCTL_CREATESERVICEA,
3901 &state->tmp);
3902 if (tevent_req_nomem(subreq, req)) {
3903 return tevent_req_post(req, ev);
3904 }
3905 tevent_req_set_callback(subreq, rpccli_svcctl_CreateServiceA_done, req);
3906 return req;
3907}
3908
3909static void rpccli_svcctl_CreateServiceA_done(struct tevent_req *subreq)
3910{
3911 struct tevent_req *req = tevent_req_callback_data(
3912 subreq, struct tevent_req);
3913 struct rpccli_svcctl_CreateServiceA_state *state = tevent_req_data(
3914 req, struct rpccli_svcctl_CreateServiceA_state);
3915 NTSTATUS status;
3916 TALLOC_CTX *mem_ctx;
3917
3918 if (state->out_mem_ctx) {
3919 mem_ctx = state->out_mem_ctx;
3920 } else {
3921 mem_ctx = state;
3922 }
3923
3924 status = state->dispatch_recv(subreq, mem_ctx);
3925 TALLOC_FREE(subreq);
3926 if (!NT_STATUS_IS_OK(status)) {
3927 tevent_req_nterror(req, status);
3928 return;
3929 }
3930
3931 /* Copy out parameters */
3932 if (state->orig.out.TagId && state->tmp.out.TagId) {
3933 *state->orig.out.TagId = *state->tmp.out.TagId;
3934 }
3935
3936 /* Copy result */
3937 state->orig.out.result = state->tmp.out.result;
3938
3939 /* Reset temporary structure */
3940 ZERO_STRUCT(state->tmp);
3941
3942 tevent_req_done(req);
3943}
3944
3945NTSTATUS rpccli_svcctl_CreateServiceA_recv(struct tevent_req *req,
3946 TALLOC_CTX *mem_ctx,
3947 WERROR *result)
3948{
3949 struct rpccli_svcctl_CreateServiceA_state *state = tevent_req_data(
3950 req, struct rpccli_svcctl_CreateServiceA_state);
3951 NTSTATUS status;
3952
3953 if (tevent_req_is_nterror(req, &status)) {
3954 tevent_req_received(req);
3955 return status;
3956 }
3957
3958 /* Steal possbile out parameters to the callers context */
3959 talloc_steal(mem_ctx, state->out_mem_ctx);
3960
3961 /* Return result */
3962 *result = state->orig.out.result;
3963
3964 tevent_req_received(req);
3965 return NT_STATUS_OK;
3966}
3967
3968NTSTATUS rpccli_svcctl_CreateServiceA(struct rpc_pipe_client *cli,
3969 TALLOC_CTX *mem_ctx,
3970 struct policy_handle *handle /* [in] [ref] */,
3971 const char *ServiceName /* [in] [unique,charset(UTF16)] */,
3972 const char *DisplayName /* [in] [unique,charset(UTF16)] */,
3973 uint32_t desired_access /* [in] */,
3974 uint32_t type /* [in] */,
3975 enum svcctl_StartType start_type /* [in] */,
3976 enum svcctl_ErrorControl error_control /* [in] */,
3977 const char *binary_path /* [in] [unique,charset(UTF16)] */,
3978 const char *LoadOrderGroupKey /* [in] [unique,charset(UTF16)] */,
3979 uint32_t *TagId /* [out] [unique] */,
3980 const char *dependencies /* [in] [unique,charset(UTF16)] */,
3981 const char *service_start_name /* [in] [unique,charset(UTF16)] */,
3982 const char *password /* [in] [unique,charset(UTF16)] */,
3983 WERROR *werror)
3984{
3985 struct svcctl_CreateServiceA r;
3986 NTSTATUS status;
3987
3988 /* In parameters */
3989 r.in.handle = handle;
3990 r.in.ServiceName = ServiceName;
3991 r.in.DisplayName = DisplayName;
3992 r.in.desired_access = desired_access;
3993 r.in.type = type;
3994 r.in.start_type = start_type;
3995 r.in.error_control = error_control;
3996 r.in.binary_path = binary_path;
3997 r.in.LoadOrderGroupKey = LoadOrderGroupKey;
3998 r.in.dependencies = dependencies;
3999 r.in.service_start_name = service_start_name;
4000 r.in.password = password;
4001
4002 status = cli->dispatch(cli,
4003 mem_ctx,
4004 &ndr_table_svcctl,
4005 NDR_SVCCTL_CREATESERVICEA,
4006 &r);
4007
4008 if (!NT_STATUS_IS_OK(status)) {
4009 return status;
4010 }
4011
4012 if (NT_STATUS_IS_ERR(status)) {
4013 return status;
4014 }
4015
4016 /* Return variables */
4017 if (TagId && r.out.TagId) {
4018 *TagId = *r.out.TagId;
4019 }
4020
4021 /* Return result */
4022 if (werror) {
4023 *werror = r.out.result;
4024 }
4025
4026 return werror_to_ntstatus(r.out.result);
4027}
4028
4029struct rpccli_svcctl_EnumDependentServicesA_state {
4030 struct svcctl_EnumDependentServicesA orig;
4031 struct svcctl_EnumDependentServicesA tmp;
4032 TALLOC_CTX *out_mem_ctx;
4033 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4034};
4035
4036static void rpccli_svcctl_EnumDependentServicesA_done(struct tevent_req *subreq);
4037
4038struct tevent_req *rpccli_svcctl_EnumDependentServicesA_send(TALLOC_CTX *mem_ctx,
4039 struct tevent_context *ev,
4040 struct rpc_pipe_client *cli,
4041 struct policy_handle *_service /* [in] [ref] */,
4042 enum svcctl_ServiceState _state /* [in] */,
4043 struct ENUM_SERVICE_STATUSA *_service_status /* [out] [unique] */,
4044 uint32_t _offered /* [in] */,
4045 uint32_t *_needed /* [out] [ref] */,
4046 uint32_t *_services_returned /* [out] [ref] */)
4047{
4048 struct tevent_req *req;
4049 struct rpccli_svcctl_EnumDependentServicesA_state *state;
4050 struct tevent_req *subreq;
4051
4052 req = tevent_req_create(mem_ctx, &state,
4053 struct rpccli_svcctl_EnumDependentServicesA_state);
4054 if (req == NULL) {
4055 return NULL;
4056 }
4057 state->out_mem_ctx = NULL;
4058 state->dispatch_recv = cli->dispatch_recv;
4059
4060 /* In parameters */
4061 state->orig.in.service = _service;
4062 state->orig.in.state = _state;
4063 state->orig.in.offered = _offered;
4064
4065 /* Out parameters */
4066 state->orig.out.service_status = _service_status;
4067 state->orig.out.needed = _needed;
4068 state->orig.out.services_returned = _services_returned;
4069
4070 /* Result */
4071 ZERO_STRUCT(state->orig.out.result);
4072
4073 state->out_mem_ctx = talloc_named_const(state, 0,
4074 "rpccli_svcctl_EnumDependentServicesA_out_memory");
4075 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4076 return tevent_req_post(req, ev);
4077 }
4078
4079 /* make a temporary copy, that we pass to the dispatch function */
4080 state->tmp = state->orig;
4081
4082 subreq = cli->dispatch_send(state, ev, cli,
4083 &ndr_table_svcctl,
4084 NDR_SVCCTL_ENUMDEPENDENTSERVICESA,
4085 &state->tmp);
4086 if (tevent_req_nomem(subreq, req)) {
4087 return tevent_req_post(req, ev);
4088 }
4089 tevent_req_set_callback(subreq, rpccli_svcctl_EnumDependentServicesA_done, req);
4090 return req;
4091}
4092
4093static void rpccli_svcctl_EnumDependentServicesA_done(struct tevent_req *subreq)
4094{
4095 struct tevent_req *req = tevent_req_callback_data(
4096 subreq, struct tevent_req);
4097 struct rpccli_svcctl_EnumDependentServicesA_state *state = tevent_req_data(
4098 req, struct rpccli_svcctl_EnumDependentServicesA_state);
4099 NTSTATUS status;
4100 TALLOC_CTX *mem_ctx;
4101
4102 if (state->out_mem_ctx) {
4103 mem_ctx = state->out_mem_ctx;
4104 } else {
4105 mem_ctx = state;
4106 }
4107
4108 status = state->dispatch_recv(subreq, mem_ctx);
4109 TALLOC_FREE(subreq);
4110 if (!NT_STATUS_IS_OK(status)) {
4111 tevent_req_nterror(req, status);
4112 return;
4113 }
4114
4115 /* Copy out parameters */
4116 if (state->orig.out.service_status && state->tmp.out.service_status) {
4117 *state->orig.out.service_status = *state->tmp.out.service_status;
4118 }
4119 *state->orig.out.needed = *state->tmp.out.needed;
4120 *state->orig.out.services_returned = *state->tmp.out.services_returned;
4121
4122 /* Copy result */
4123 state->orig.out.result = state->tmp.out.result;
4124
4125 /* Reset temporary structure */
4126 ZERO_STRUCT(state->tmp);
4127
4128 tevent_req_done(req);
4129}
4130
4131NTSTATUS rpccli_svcctl_EnumDependentServicesA_recv(struct tevent_req *req,
4132 TALLOC_CTX *mem_ctx,
4133 WERROR *result)
4134{
4135 struct rpccli_svcctl_EnumDependentServicesA_state *state = tevent_req_data(
4136 req, struct rpccli_svcctl_EnumDependentServicesA_state);
4137 NTSTATUS status;
4138
4139 if (tevent_req_is_nterror(req, &status)) {
4140 tevent_req_received(req);
4141 return status;
4142 }
4143
4144 /* Steal possbile out parameters to the callers context */
4145 talloc_steal(mem_ctx, state->out_mem_ctx);
4146
4147 /* Return result */
4148 *result = state->orig.out.result;
4149
4150 tevent_req_received(req);
4151 return NT_STATUS_OK;
4152}
4153
4154NTSTATUS rpccli_svcctl_EnumDependentServicesA(struct rpc_pipe_client *cli,
4155 TALLOC_CTX *mem_ctx,
4156 struct policy_handle *service /* [in] [ref] */,
4157 enum svcctl_ServiceState state /* [in] */,
4158 struct ENUM_SERVICE_STATUSA *service_status /* [out] [unique] */,
4159 uint32_t offered /* [in] */,
4160 uint32_t *needed /* [out] [ref] */,
4161 uint32_t *services_returned /* [out] [ref] */,
4162 WERROR *werror)
4163{
4164 struct svcctl_EnumDependentServicesA r;
4165 NTSTATUS status;
4166
4167 /* In parameters */
4168 r.in.service = service;
4169 r.in.state = state;
4170 r.in.offered = offered;
4171
4172 status = cli->dispatch(cli,
4173 mem_ctx,
4174 &ndr_table_svcctl,
4175 NDR_SVCCTL_ENUMDEPENDENTSERVICESA,
4176 &r);
4177
4178 if (!NT_STATUS_IS_OK(status)) {
4179 return status;
4180 }
4181
4182 if (NT_STATUS_IS_ERR(status)) {
4183 return status;
4184 }
4185
4186 /* Return variables */
4187 if (service_status && r.out.service_status) {
4188 *service_status = *r.out.service_status;
4189 }
4190 *needed = *r.out.needed;
4191 *services_returned = *r.out.services_returned;
4192
4193 /* Return result */
4194 if (werror) {
4195 *werror = r.out.result;
4196 }
4197
4198 return werror_to_ntstatus(r.out.result);
4199}
4200
4201struct rpccli_svcctl_EnumServicesStatusA_state {
4202 struct svcctl_EnumServicesStatusA orig;
4203 struct svcctl_EnumServicesStatusA tmp;
4204 TALLOC_CTX *out_mem_ctx;
4205 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4206};
4207
4208static void rpccli_svcctl_EnumServicesStatusA_done(struct tevent_req *subreq);
4209
4210struct tevent_req *rpccli_svcctl_EnumServicesStatusA_send(TALLOC_CTX *mem_ctx,
4211 struct tevent_context *ev,
4212 struct rpc_pipe_client *cli,
4213 struct policy_handle *_handle /* [in] [ref] */,
4214 uint32_t _type /* [in] */,
4215 enum svcctl_ServiceState _state /* [in] */,
4216 uint32_t _offered /* [in] */,
4217 uint8_t *_service /* [out] [size_is(offered)] */,
4218 uint32_t *_needed /* [out] [ref] */,
4219 uint32_t *_services_returned /* [out] [ref] */,
4220 uint32_t *_resume_handle /* [in,out] [unique] */)
4221{
4222 struct tevent_req *req;
4223 struct rpccli_svcctl_EnumServicesStatusA_state *state;
4224 struct tevent_req *subreq;
4225
4226 req = tevent_req_create(mem_ctx, &state,
4227 struct rpccli_svcctl_EnumServicesStatusA_state);
4228 if (req == NULL) {
4229 return NULL;
4230 }
4231 state->out_mem_ctx = NULL;
4232 state->dispatch_recv = cli->dispatch_recv;
4233
4234 /* In parameters */
4235 state->orig.in.handle = _handle;
4236 state->orig.in.type = _type;
4237 state->orig.in.state = _state;
4238 state->orig.in.offered = _offered;
4239 state->orig.in.resume_handle = _resume_handle;
4240
4241 /* Out parameters */
4242 state->orig.out.service = _service;
4243 state->orig.out.needed = _needed;
4244 state->orig.out.services_returned = _services_returned;
4245 state->orig.out.resume_handle = _resume_handle;
4246
4247 /* Result */
4248 ZERO_STRUCT(state->orig.out.result);
4249
4250 state->out_mem_ctx = talloc_named_const(state, 0,
4251 "rpccli_svcctl_EnumServicesStatusA_out_memory");
4252 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4253 return tevent_req_post(req, ev);
4254 }
4255
4256 /* make a temporary copy, that we pass to the dispatch function */
4257 state->tmp = state->orig;
4258
4259 subreq = cli->dispatch_send(state, ev, cli,
4260 &ndr_table_svcctl,
4261 NDR_SVCCTL_ENUMSERVICESSTATUSA,
4262 &state->tmp);
4263 if (tevent_req_nomem(subreq, req)) {
4264 return tevent_req_post(req, ev);
4265 }
4266 tevent_req_set_callback(subreq, rpccli_svcctl_EnumServicesStatusA_done, req);
4267 return req;
4268}
4269
4270static void rpccli_svcctl_EnumServicesStatusA_done(struct tevent_req *subreq)
4271{
4272 struct tevent_req *req = tevent_req_callback_data(
4273 subreq, struct tevent_req);
4274 struct rpccli_svcctl_EnumServicesStatusA_state *state = tevent_req_data(
4275 req, struct rpccli_svcctl_EnumServicesStatusA_state);
4276 NTSTATUS status;
4277 TALLOC_CTX *mem_ctx;
4278
4279 if (state->out_mem_ctx) {
4280 mem_ctx = state->out_mem_ctx;
4281 } else {
4282 mem_ctx = state;
4283 }
4284
4285 status = state->dispatch_recv(subreq, mem_ctx);
4286 TALLOC_FREE(subreq);
4287 if (!NT_STATUS_IS_OK(status)) {
4288 tevent_req_nterror(req, status);
4289 return;
4290 }
4291
4292 /* Copy out parameters */
4293 memcpy(state->orig.out.service, state->tmp.out.service, (state->tmp.in.offered) * sizeof(*state->orig.out.service));
4294 *state->orig.out.needed = *state->tmp.out.needed;
4295 *state->orig.out.services_returned = *state->tmp.out.services_returned;
4296 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
4297 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
4298 }
4299
4300 /* Copy result */
4301 state->orig.out.result = state->tmp.out.result;
4302
4303 /* Reset temporary structure */
4304 ZERO_STRUCT(state->tmp);
4305
4306 tevent_req_done(req);
4307}
4308
4309NTSTATUS rpccli_svcctl_EnumServicesStatusA_recv(struct tevent_req *req,
4310 TALLOC_CTX *mem_ctx,
4311 WERROR *result)
4312{
4313 struct rpccli_svcctl_EnumServicesStatusA_state *state = tevent_req_data(
4314 req, struct rpccli_svcctl_EnumServicesStatusA_state);
4315 NTSTATUS status;
4316
4317 if (tevent_req_is_nterror(req, &status)) {
4318 tevent_req_received(req);
4319 return status;
4320 }
4321
4322 /* Steal possbile out parameters to the callers context */
4323 talloc_steal(mem_ctx, state->out_mem_ctx);
4324
4325 /* Return result */
4326 *result = state->orig.out.result;
4327
4328 tevent_req_received(req);
4329 return NT_STATUS_OK;
4330}
4331
4332NTSTATUS rpccli_svcctl_EnumServicesStatusA(struct rpc_pipe_client *cli,
4333 TALLOC_CTX *mem_ctx,
4334 struct policy_handle *handle /* [in] [ref] */,
4335 uint32_t type /* [in] */,
4336 enum svcctl_ServiceState state /* [in] */,
4337 uint32_t offered /* [in] */,
4338 uint8_t *service /* [out] [size_is(offered)] */,
4339 uint32_t *needed /* [out] [ref] */,
4340 uint32_t *services_returned /* [out] [ref] */,
4341 uint32_t *resume_handle /* [in,out] [unique] */,
4342 WERROR *werror)
4343{
4344 struct svcctl_EnumServicesStatusA r;
4345 NTSTATUS status;
4346
4347 /* In parameters */
4348 r.in.handle = handle;
4349 r.in.type = type;
4350 r.in.state = state;
4351 r.in.offered = offered;
4352 r.in.resume_handle = resume_handle;
4353
4354 status = cli->dispatch(cli,
4355 mem_ctx,
4356 &ndr_table_svcctl,
4357 NDR_SVCCTL_ENUMSERVICESSTATUSA,
4358 &r);
4359
4360 if (!NT_STATUS_IS_OK(status)) {
4361 return status;
4362 }
4363
4364 if (NT_STATUS_IS_ERR(status)) {
4365 return status;
4366 }
4367
4368 /* Return variables */
4369 memcpy(service, r.out.service, (r.in.offered) * sizeof(*service));
4370 *needed = *r.out.needed;
4371 *services_returned = *r.out.services_returned;
4372 if (resume_handle && r.out.resume_handle) {
4373 *resume_handle = *r.out.resume_handle;
4374 }
4375
4376 /* Return result */
4377 if (werror) {
4378 *werror = r.out.result;
4379 }
4380
4381 return werror_to_ntstatus(r.out.result);
4382}
4383
4384struct rpccli_svcctl_OpenSCManagerA_state {
4385 struct svcctl_OpenSCManagerA orig;
4386 struct svcctl_OpenSCManagerA tmp;
4387 TALLOC_CTX *out_mem_ctx;
4388 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4389};
4390
4391static void rpccli_svcctl_OpenSCManagerA_done(struct tevent_req *subreq);
4392
4393struct tevent_req *rpccli_svcctl_OpenSCManagerA_send(TALLOC_CTX *mem_ctx,
4394 struct tevent_context *ev,
4395 struct rpc_pipe_client *cli,
4396 const char *_MachineName /* [in] [unique,charset(UTF16)] */,
4397 const char *_DatabaseName /* [in] [unique,charset(UTF16)] */,
4398 uint32_t _access_mask /* [in] */,
4399 struct policy_handle *_handle /* [out] [ref] */)
4400{
4401 struct tevent_req *req;
4402 struct rpccli_svcctl_OpenSCManagerA_state *state;
4403 struct tevent_req *subreq;
4404
4405 req = tevent_req_create(mem_ctx, &state,
4406 struct rpccli_svcctl_OpenSCManagerA_state);
4407 if (req == NULL) {
4408 return NULL;
4409 }
4410 state->out_mem_ctx = NULL;
4411 state->dispatch_recv = cli->dispatch_recv;
4412
4413 /* In parameters */
4414 state->orig.in.MachineName = _MachineName;
4415 state->orig.in.DatabaseName = _DatabaseName;
4416 state->orig.in.access_mask = _access_mask;
4417
4418 /* Out parameters */
4419 state->orig.out.handle = _handle;
4420
4421 /* Result */
4422 ZERO_STRUCT(state->orig.out.result);
4423
4424 state->out_mem_ctx = talloc_named_const(state, 0,
4425 "rpccli_svcctl_OpenSCManagerA_out_memory");
4426 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4427 return tevent_req_post(req, ev);
4428 }
4429
4430 /* make a temporary copy, that we pass to the dispatch function */
4431 state->tmp = state->orig;
4432
4433 subreq = cli->dispatch_send(state, ev, cli,
4434 &ndr_table_svcctl,
4435 NDR_SVCCTL_OPENSCMANAGERA,
4436 &state->tmp);
4437 if (tevent_req_nomem(subreq, req)) {
4438 return tevent_req_post(req, ev);
4439 }
4440 tevent_req_set_callback(subreq, rpccli_svcctl_OpenSCManagerA_done, req);
4441 return req;
4442}
4443
4444static void rpccli_svcctl_OpenSCManagerA_done(struct tevent_req *subreq)
4445{
4446 struct tevent_req *req = tevent_req_callback_data(
4447 subreq, struct tevent_req);
4448 struct rpccli_svcctl_OpenSCManagerA_state *state = tevent_req_data(
4449 req, struct rpccli_svcctl_OpenSCManagerA_state);
4450 NTSTATUS status;
4451 TALLOC_CTX *mem_ctx;
4452
4453 if (state->out_mem_ctx) {
4454 mem_ctx = state->out_mem_ctx;
4455 } else {
4456 mem_ctx = state;
4457 }
4458
4459 status = state->dispatch_recv(subreq, mem_ctx);
4460 TALLOC_FREE(subreq);
4461 if (!NT_STATUS_IS_OK(status)) {
4462 tevent_req_nterror(req, status);
4463 return;
4464 }
4465
4466 /* Copy out parameters */
4467 *state->orig.out.handle = *state->tmp.out.handle;
4468
4469 /* Copy result */
4470 state->orig.out.result = state->tmp.out.result;
4471
4472 /* Reset temporary structure */
4473 ZERO_STRUCT(state->tmp);
4474
4475 tevent_req_done(req);
4476}
4477
4478NTSTATUS rpccli_svcctl_OpenSCManagerA_recv(struct tevent_req *req,
4479 TALLOC_CTX *mem_ctx,
4480 WERROR *result)
4481{
4482 struct rpccli_svcctl_OpenSCManagerA_state *state = tevent_req_data(
4483 req, struct rpccli_svcctl_OpenSCManagerA_state);
4484 NTSTATUS status;
4485
4486 if (tevent_req_is_nterror(req, &status)) {
4487 tevent_req_received(req);
4488 return status;
4489 }
4490
4491 /* Steal possbile out parameters to the callers context */
4492 talloc_steal(mem_ctx, state->out_mem_ctx);
4493
4494 /* Return result */
4495 *result = state->orig.out.result;
4496
4497 tevent_req_received(req);
4498 return NT_STATUS_OK;
4499}
4500
4501NTSTATUS rpccli_svcctl_OpenSCManagerA(struct rpc_pipe_client *cli,
4502 TALLOC_CTX *mem_ctx,
4503 const char *MachineName /* [in] [unique,charset(UTF16)] */,
4504 const char *DatabaseName /* [in] [unique,charset(UTF16)] */,
4505 uint32_t access_mask /* [in] */,
4506 struct policy_handle *handle /* [out] [ref] */,
4507 WERROR *werror)
4508{
4509 struct svcctl_OpenSCManagerA r;
4510 NTSTATUS status;
4511
4512 /* In parameters */
4513 r.in.MachineName = MachineName;
4514 r.in.DatabaseName = DatabaseName;
4515 r.in.access_mask = access_mask;
4516
4517 status = cli->dispatch(cli,
4518 mem_ctx,
4519 &ndr_table_svcctl,
4520 NDR_SVCCTL_OPENSCMANAGERA,
4521 &r);
4522
4523 if (!NT_STATUS_IS_OK(status)) {
4524 return status;
4525 }
4526
4527 if (NT_STATUS_IS_ERR(status)) {
4528 return status;
4529 }
4530
4531 /* Return variables */
4532 *handle = *r.out.handle;
4533
4534 /* Return result */
4535 if (werror) {
4536 *werror = r.out.result;
4537 }
4538
4539 return werror_to_ntstatus(r.out.result);
4540}
4541
4542struct rpccli_svcctl_OpenServiceA_state {
4543 struct svcctl_OpenServiceA orig;
4544 struct svcctl_OpenServiceA tmp;
4545 TALLOC_CTX *out_mem_ctx;
4546 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4547};
4548
4549static void rpccli_svcctl_OpenServiceA_done(struct tevent_req *subreq);
4550
4551struct tevent_req *rpccli_svcctl_OpenServiceA_send(TALLOC_CTX *mem_ctx,
4552 struct tevent_context *ev,
4553 struct rpc_pipe_client *cli,
4554 struct policy_handle *_scmanager_handle /* [in] [ref] */,
4555 const char *_ServiceName /* [in] [unique,charset(UTF16)] */,
4556 uint32_t _access_mask /* [in] */)
4557{
4558 struct tevent_req *req;
4559 struct rpccli_svcctl_OpenServiceA_state *state;
4560 struct tevent_req *subreq;
4561
4562 req = tevent_req_create(mem_ctx, &state,
4563 struct rpccli_svcctl_OpenServiceA_state);
4564 if (req == NULL) {
4565 return NULL;
4566 }
4567 state->out_mem_ctx = NULL;
4568 state->dispatch_recv = cli->dispatch_recv;
4569
4570 /* In parameters */
4571 state->orig.in.scmanager_handle = _scmanager_handle;
4572 state->orig.in.ServiceName = _ServiceName;
4573 state->orig.in.access_mask = _access_mask;
4574
4575 /* Out parameters */
4576
4577 /* Result */
4578 ZERO_STRUCT(state->orig.out.result);
4579
4580 /* make a temporary copy, that we pass to the dispatch function */
4581 state->tmp = state->orig;
4582
4583 subreq = cli->dispatch_send(state, ev, cli,
4584 &ndr_table_svcctl,
4585 NDR_SVCCTL_OPENSERVICEA,
4586 &state->tmp);
4587 if (tevent_req_nomem(subreq, req)) {
4588 return tevent_req_post(req, ev);
4589 }
4590 tevent_req_set_callback(subreq, rpccli_svcctl_OpenServiceA_done, req);
4591 return req;
4592}
4593
4594static void rpccli_svcctl_OpenServiceA_done(struct tevent_req *subreq)
4595{
4596 struct tevent_req *req = tevent_req_callback_data(
4597 subreq, struct tevent_req);
4598 struct rpccli_svcctl_OpenServiceA_state *state = tevent_req_data(
4599 req, struct rpccli_svcctl_OpenServiceA_state);
4600 NTSTATUS status;
4601 TALLOC_CTX *mem_ctx;
4602
4603 if (state->out_mem_ctx) {
4604 mem_ctx = state->out_mem_ctx;
4605 } else {
4606 mem_ctx = state;
4607 }
4608
4609 status = state->dispatch_recv(subreq, mem_ctx);
4610 TALLOC_FREE(subreq);
4611 if (!NT_STATUS_IS_OK(status)) {
4612 tevent_req_nterror(req, status);
4613 return;
4614 }
4615
4616 /* Copy out parameters */
4617
4618 /* Copy result */
4619 state->orig.out.result = state->tmp.out.result;
4620
4621 /* Reset temporary structure */
4622 ZERO_STRUCT(state->tmp);
4623
4624 tevent_req_done(req);
4625}
4626
4627NTSTATUS rpccli_svcctl_OpenServiceA_recv(struct tevent_req *req,
4628 TALLOC_CTX *mem_ctx,
4629 WERROR *result)
4630{
4631 struct rpccli_svcctl_OpenServiceA_state *state = tevent_req_data(
4632 req, struct rpccli_svcctl_OpenServiceA_state);
4633 NTSTATUS status;
4634
4635 if (tevent_req_is_nterror(req, &status)) {
4636 tevent_req_received(req);
4637 return status;
4638 }
4639
4640 /* Steal possbile out parameters to the callers context */
4641 talloc_steal(mem_ctx, state->out_mem_ctx);
4642
4643 /* Return result */
4644 *result = state->orig.out.result;
4645
4646 tevent_req_received(req);
4647 return NT_STATUS_OK;
4648}
4649
4650NTSTATUS rpccli_svcctl_OpenServiceA(struct rpc_pipe_client *cli,
4651 TALLOC_CTX *mem_ctx,
4652 struct policy_handle *scmanager_handle /* [in] [ref] */,
4653 const char *ServiceName /* [in] [unique,charset(UTF16)] */,
4654 uint32_t access_mask /* [in] */,
4655 WERROR *werror)
4656{
4657 struct svcctl_OpenServiceA r;
4658 NTSTATUS status;
4659
4660 /* In parameters */
4661 r.in.scmanager_handle = scmanager_handle;
4662 r.in.ServiceName = ServiceName;
4663 r.in.access_mask = access_mask;
4664
4665 status = cli->dispatch(cli,
4666 mem_ctx,
4667 &ndr_table_svcctl,
4668 NDR_SVCCTL_OPENSERVICEA,
4669 &r);
4670
4671 if (!NT_STATUS_IS_OK(status)) {
4672 return status;
4673 }
4674
4675 if (NT_STATUS_IS_ERR(status)) {
4676 return status;
4677 }
4678
4679 /* Return variables */
4680
4681 /* Return result */
4682 if (werror) {
4683 *werror = r.out.result;
4684 }
4685
4686 return werror_to_ntstatus(r.out.result);
4687}
4688
4689struct rpccli_svcctl_QueryServiceConfigA_state {
4690 struct svcctl_QueryServiceConfigA orig;
4691 struct svcctl_QueryServiceConfigA tmp;
4692 TALLOC_CTX *out_mem_ctx;
4693 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4694};
4695
4696static void rpccli_svcctl_QueryServiceConfigA_done(struct tevent_req *subreq);
4697
4698struct tevent_req *rpccli_svcctl_QueryServiceConfigA_send(TALLOC_CTX *mem_ctx,
4699 struct tevent_context *ev,
4700 struct rpc_pipe_client *cli,
4701 struct policy_handle *_handle /* [in] [ref] */,
4702 uint8_t *_query /* [out] */,
4703 uint32_t _offered /* [in] */,
4704 uint32_t *_needed /* [out] [ref] */)
4705{
4706 struct tevent_req *req;
4707 struct rpccli_svcctl_QueryServiceConfigA_state *state;
4708 struct tevent_req *subreq;
4709
4710 req = tevent_req_create(mem_ctx, &state,
4711 struct rpccli_svcctl_QueryServiceConfigA_state);
4712 if (req == NULL) {
4713 return NULL;
4714 }
4715 state->out_mem_ctx = NULL;
4716 state->dispatch_recv = cli->dispatch_recv;
4717
4718 /* In parameters */
4719 state->orig.in.handle = _handle;
4720 state->orig.in.offered = _offered;
4721
4722 /* Out parameters */
4723 state->orig.out.query = _query;
4724 state->orig.out.needed = _needed;
4725
4726 /* Result */
4727 ZERO_STRUCT(state->orig.out.result);
4728
4729 state->out_mem_ctx = talloc_named_const(state, 0,
4730 "rpccli_svcctl_QueryServiceConfigA_out_memory");
4731 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4732 return tevent_req_post(req, ev);
4733 }
4734
4735 /* make a temporary copy, that we pass to the dispatch function */
4736 state->tmp = state->orig;
4737
4738 subreq = cli->dispatch_send(state, ev, cli,
4739 &ndr_table_svcctl,
4740 NDR_SVCCTL_QUERYSERVICECONFIGA,
4741 &state->tmp);
4742 if (tevent_req_nomem(subreq, req)) {
4743 return tevent_req_post(req, ev);
4744 }
4745 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceConfigA_done, req);
4746 return req;
4747}
4748
4749static void rpccli_svcctl_QueryServiceConfigA_done(struct tevent_req *subreq)
4750{
4751 struct tevent_req *req = tevent_req_callback_data(
4752 subreq, struct tevent_req);
4753 struct rpccli_svcctl_QueryServiceConfigA_state *state = tevent_req_data(
4754 req, struct rpccli_svcctl_QueryServiceConfigA_state);
4755 NTSTATUS status;
4756 TALLOC_CTX *mem_ctx;
4757
4758 if (state->out_mem_ctx) {
4759 mem_ctx = state->out_mem_ctx;
4760 } else {
4761 mem_ctx = state;
4762 }
4763
4764 status = state->dispatch_recv(subreq, mem_ctx);
4765 TALLOC_FREE(subreq);
4766 if (!NT_STATUS_IS_OK(status)) {
4767 tevent_req_nterror(req, status);
4768 return;
4769 }
4770
4771 /* Copy out parameters */
4772 memcpy(state->orig.out.query, state->tmp.out.query, (state->tmp.in.offered) * sizeof(*state->orig.out.query));
4773 *state->orig.out.needed = *state->tmp.out.needed;
4774
4775 /* Copy result */
4776 state->orig.out.result = state->tmp.out.result;
4777
4778 /* Reset temporary structure */
4779 ZERO_STRUCT(state->tmp);
4780
4781 tevent_req_done(req);
4782}
4783
4784NTSTATUS rpccli_svcctl_QueryServiceConfigA_recv(struct tevent_req *req,
4785 TALLOC_CTX *mem_ctx,
4786 WERROR *result)
4787{
4788 struct rpccli_svcctl_QueryServiceConfigA_state *state = tevent_req_data(
4789 req, struct rpccli_svcctl_QueryServiceConfigA_state);
4790 NTSTATUS status;
4791
4792 if (tevent_req_is_nterror(req, &status)) {
4793 tevent_req_received(req);
4794 return status;
4795 }
4796
4797 /* Steal possbile out parameters to the callers context */
4798 talloc_steal(mem_ctx, state->out_mem_ctx);
4799
4800 /* Return result */
4801 *result = state->orig.out.result;
4802
4803 tevent_req_received(req);
4804 return NT_STATUS_OK;
4805}
4806
4807NTSTATUS rpccli_svcctl_QueryServiceConfigA(struct rpc_pipe_client *cli,
4808 TALLOC_CTX *mem_ctx,
4809 struct policy_handle *handle /* [in] [ref] */,
4810 uint8_t *query /* [out] */,
4811 uint32_t offered /* [in] */,
4812 uint32_t *needed /* [out] [ref] */,
4813 WERROR *werror)
4814{
4815 struct svcctl_QueryServiceConfigA r;
4816 NTSTATUS status;
4817
4818 /* In parameters */
4819 r.in.handle = handle;
4820 r.in.offered = offered;
4821
4822 status = cli->dispatch(cli,
4823 mem_ctx,
4824 &ndr_table_svcctl,
4825 NDR_SVCCTL_QUERYSERVICECONFIGA,
4826 &r);
4827
4828 if (!NT_STATUS_IS_OK(status)) {
4829 return status;
4830 }
4831
4832 if (NT_STATUS_IS_ERR(status)) {
4833 return status;
4834 }
4835
4836 /* Return variables */
4837 memcpy(query, r.out.query, (r.in.offered) * sizeof(*query));
4838 *needed = *r.out.needed;
4839
4840 /* Return result */
4841 if (werror) {
4842 *werror = r.out.result;
4843 }
4844
4845 return werror_to_ntstatus(r.out.result);
4846}
4847
4848struct rpccli_svcctl_QueryServiceLockStatusA_state {
4849 struct svcctl_QueryServiceLockStatusA orig;
4850 struct svcctl_QueryServiceLockStatusA tmp;
4851 TALLOC_CTX *out_mem_ctx;
4852 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4853};
4854
4855static void rpccli_svcctl_QueryServiceLockStatusA_done(struct tevent_req *subreq);
4856
4857struct tevent_req *rpccli_svcctl_QueryServiceLockStatusA_send(TALLOC_CTX *mem_ctx,
4858 struct tevent_context *ev,
4859 struct rpc_pipe_client *cli,
4860 struct policy_handle *_handle /* [in] [ref] */,
4861 uint32_t _offered /* [in] */,
4862 struct SERVICE_LOCK_STATUS *_lock_status /* [out] [ref] */,
4863 uint32_t *_needed /* [out] [ref] */)
4864{
4865 struct tevent_req *req;
4866 struct rpccli_svcctl_QueryServiceLockStatusA_state *state;
4867 struct tevent_req *subreq;
4868
4869 req = tevent_req_create(mem_ctx, &state,
4870 struct rpccli_svcctl_QueryServiceLockStatusA_state);
4871 if (req == NULL) {
4872 return NULL;
4873 }
4874 state->out_mem_ctx = NULL;
4875 state->dispatch_recv = cli->dispatch_recv;
4876
4877 /* In parameters */
4878 state->orig.in.handle = _handle;
4879 state->orig.in.offered = _offered;
4880
4881 /* Out parameters */
4882 state->orig.out.lock_status = _lock_status;
4883 state->orig.out.needed = _needed;
4884
4885 /* Result */
4886 ZERO_STRUCT(state->orig.out.result);
4887
4888 state->out_mem_ctx = talloc_named_const(state, 0,
4889 "rpccli_svcctl_QueryServiceLockStatusA_out_memory");
4890 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4891 return tevent_req_post(req, ev);
4892 }
4893
4894 /* make a temporary copy, that we pass to the dispatch function */
4895 state->tmp = state->orig;
4896
4897 subreq = cli->dispatch_send(state, ev, cli,
4898 &ndr_table_svcctl,
4899 NDR_SVCCTL_QUERYSERVICELOCKSTATUSA,
4900 &state->tmp);
4901 if (tevent_req_nomem(subreq, req)) {
4902 return tevent_req_post(req, ev);
4903 }
4904 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceLockStatusA_done, req);
4905 return req;
4906}
4907
4908static void rpccli_svcctl_QueryServiceLockStatusA_done(struct tevent_req *subreq)
4909{
4910 struct tevent_req *req = tevent_req_callback_data(
4911 subreq, struct tevent_req);
4912 struct rpccli_svcctl_QueryServiceLockStatusA_state *state = tevent_req_data(
4913 req, struct rpccli_svcctl_QueryServiceLockStatusA_state);
4914 NTSTATUS status;
4915 TALLOC_CTX *mem_ctx;
4916
4917 if (state->out_mem_ctx) {
4918 mem_ctx = state->out_mem_ctx;
4919 } else {
4920 mem_ctx = state;
4921 }
4922
4923 status = state->dispatch_recv(subreq, mem_ctx);
4924 TALLOC_FREE(subreq);
4925 if (!NT_STATUS_IS_OK(status)) {
4926 tevent_req_nterror(req, status);
4927 return;
4928 }
4929
4930 /* Copy out parameters */
4931 *state->orig.out.lock_status = *state->tmp.out.lock_status;
4932 *state->orig.out.needed = *state->tmp.out.needed;
4933
4934 /* Copy result */
4935 state->orig.out.result = state->tmp.out.result;
4936
4937 /* Reset temporary structure */
4938 ZERO_STRUCT(state->tmp);
4939
4940 tevent_req_done(req);
4941}
4942
4943NTSTATUS rpccli_svcctl_QueryServiceLockStatusA_recv(struct tevent_req *req,
4944 TALLOC_CTX *mem_ctx,
4945 WERROR *result)
4946{
4947 struct rpccli_svcctl_QueryServiceLockStatusA_state *state = tevent_req_data(
4948 req, struct rpccli_svcctl_QueryServiceLockStatusA_state);
4949 NTSTATUS status;
4950
4951 if (tevent_req_is_nterror(req, &status)) {
4952 tevent_req_received(req);
4953 return status;
4954 }
4955
4956 /* Steal possbile out parameters to the callers context */
4957 talloc_steal(mem_ctx, state->out_mem_ctx);
4958
4959 /* Return result */
4960 *result = state->orig.out.result;
4961
4962 tevent_req_received(req);
4963 return NT_STATUS_OK;
4964}
4965
4966NTSTATUS rpccli_svcctl_QueryServiceLockStatusA(struct rpc_pipe_client *cli,
4967 TALLOC_CTX *mem_ctx,
4968 struct policy_handle *handle /* [in] [ref] */,
4969 uint32_t offered /* [in] */,
4970 struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,
4971 uint32_t *needed /* [out] [ref] */,
4972 WERROR *werror)
4973{
4974 struct svcctl_QueryServiceLockStatusA r;
4975 NTSTATUS status;
4976
4977 /* In parameters */
4978 r.in.handle = handle;
4979 r.in.offered = offered;
4980
4981 status = cli->dispatch(cli,
4982 mem_ctx,
4983 &ndr_table_svcctl,
4984 NDR_SVCCTL_QUERYSERVICELOCKSTATUSA,
4985 &r);
4986
4987 if (!NT_STATUS_IS_OK(status)) {
4988 return status;
4989 }
4990
4991 if (NT_STATUS_IS_ERR(status)) {
4992 return status;
4993 }
4994
4995 /* Return variables */
4996 *lock_status = *r.out.lock_status;
4997 *needed = *r.out.needed;
4998
4999 /* Return result */
5000 if (werror) {
5001 *werror = r.out.result;
5002 }
5003
5004 return werror_to_ntstatus(r.out.result);
5005}
5006
5007struct rpccli_svcctl_StartServiceA_state {
5008 struct svcctl_StartServiceA orig;
5009 struct svcctl_StartServiceA tmp;
5010 TALLOC_CTX *out_mem_ctx;
5011 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5012};
5013
5014static void rpccli_svcctl_StartServiceA_done(struct tevent_req *subreq);
5015
5016struct tevent_req *rpccli_svcctl_StartServiceA_send(TALLOC_CTX *mem_ctx,
5017 struct tevent_context *ev,
5018 struct rpc_pipe_client *cli,
5019 struct policy_handle *_handle /* [in] [ref] */,
5020 uint32_t _NumArgs /* [in] */,
5021 const char *_Arguments /* [in] [unique,charset(UTF16)] */)
5022{
5023 struct tevent_req *req;
5024 struct rpccli_svcctl_StartServiceA_state *state;
5025 struct tevent_req *subreq;
5026
5027 req = tevent_req_create(mem_ctx, &state,
5028 struct rpccli_svcctl_StartServiceA_state);
5029 if (req == NULL) {
5030 return NULL;
5031 }
5032 state->out_mem_ctx = NULL;
5033 state->dispatch_recv = cli->dispatch_recv;
5034
5035 /* In parameters */
5036 state->orig.in.handle = _handle;
5037 state->orig.in.NumArgs = _NumArgs;
5038 state->orig.in.Arguments = _Arguments;
5039
5040 /* Out parameters */
5041
5042 /* Result */
5043 ZERO_STRUCT(state->orig.out.result);
5044
5045 /* make a temporary copy, that we pass to the dispatch function */
5046 state->tmp = state->orig;
5047
5048 subreq = cli->dispatch_send(state, ev, cli,
5049 &ndr_table_svcctl,
5050 NDR_SVCCTL_STARTSERVICEA,
5051 &state->tmp);
5052 if (tevent_req_nomem(subreq, req)) {
5053 return tevent_req_post(req, ev);
5054 }
5055 tevent_req_set_callback(subreq, rpccli_svcctl_StartServiceA_done, req);
5056 return req;
5057}
5058
5059static void rpccli_svcctl_StartServiceA_done(struct tevent_req *subreq)
5060{
5061 struct tevent_req *req = tevent_req_callback_data(
5062 subreq, struct tevent_req);
5063 struct rpccli_svcctl_StartServiceA_state *state = tevent_req_data(
5064 req, struct rpccli_svcctl_StartServiceA_state);
5065 NTSTATUS status;
5066 TALLOC_CTX *mem_ctx;
5067
5068 if (state->out_mem_ctx) {
5069 mem_ctx = state->out_mem_ctx;
5070 } else {
5071 mem_ctx = state;
5072 }
5073
5074 status = state->dispatch_recv(subreq, mem_ctx);
5075 TALLOC_FREE(subreq);
5076 if (!NT_STATUS_IS_OK(status)) {
5077 tevent_req_nterror(req, status);
5078 return;
5079 }
5080
5081 /* Copy out parameters */
5082
5083 /* Copy result */
5084 state->orig.out.result = state->tmp.out.result;
5085
5086 /* Reset temporary structure */
5087 ZERO_STRUCT(state->tmp);
5088
5089 tevent_req_done(req);
5090}
5091
5092NTSTATUS rpccli_svcctl_StartServiceA_recv(struct tevent_req *req,
5093 TALLOC_CTX *mem_ctx,
5094 WERROR *result)
5095{
5096 struct rpccli_svcctl_StartServiceA_state *state = tevent_req_data(
5097 req, struct rpccli_svcctl_StartServiceA_state);
5098 NTSTATUS status;
5099
5100 if (tevent_req_is_nterror(req, &status)) {
5101 tevent_req_received(req);
5102 return status;
5103 }
5104
5105 /* Steal possbile out parameters to the callers context */
5106 talloc_steal(mem_ctx, state->out_mem_ctx);
5107
5108 /* Return result */
5109 *result = state->orig.out.result;
5110
5111 tevent_req_received(req);
5112 return NT_STATUS_OK;
5113}
5114
5115NTSTATUS rpccli_svcctl_StartServiceA(struct rpc_pipe_client *cli,
5116 TALLOC_CTX *mem_ctx,
5117 struct policy_handle *handle /* [in] [ref] */,
5118 uint32_t NumArgs /* [in] */,
5119 const char *Arguments /* [in] [unique,charset(UTF16)] */,
5120 WERROR *werror)
5121{
5122 struct svcctl_StartServiceA r;
5123 NTSTATUS status;
5124
5125 /* In parameters */
5126 r.in.handle = handle;
5127 r.in.NumArgs = NumArgs;
5128 r.in.Arguments = Arguments;
5129
5130 status = cli->dispatch(cli,
5131 mem_ctx,
5132 &ndr_table_svcctl,
5133 NDR_SVCCTL_STARTSERVICEA,
5134 &r);
5135
5136 if (!NT_STATUS_IS_OK(status)) {
5137 return status;
5138 }
5139
5140 if (NT_STATUS_IS_ERR(status)) {
5141 return status;
5142 }
5143
5144 /* Return variables */
5145
5146 /* Return result */
5147 if (werror) {
5148 *werror = r.out.result;
5149 }
5150
5151 return werror_to_ntstatus(r.out.result);
5152}
5153
5154struct rpccli_svcctl_GetServiceDisplayNameA_state {
5155 struct svcctl_GetServiceDisplayNameA orig;
5156 struct svcctl_GetServiceDisplayNameA tmp;
5157 TALLOC_CTX *out_mem_ctx;
5158 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5159};
5160
5161static void rpccli_svcctl_GetServiceDisplayNameA_done(struct tevent_req *subreq);
5162
5163struct tevent_req *rpccli_svcctl_GetServiceDisplayNameA_send(TALLOC_CTX *mem_ctx,
5164 struct tevent_context *ev,
5165 struct rpc_pipe_client *cli,
5166 struct policy_handle *_handle /* [in] [ref] */,
5167 const char *_service_name /* [in] [unique,charset(UTF16)] */,
5168 const char **_display_name /* [out] [ref,charset(UTF16)] */,
5169 uint32_t *_display_name_length /* [in,out] [unique] */)
5170{
5171 struct tevent_req *req;
5172 struct rpccli_svcctl_GetServiceDisplayNameA_state *state;
5173 struct tevent_req *subreq;
5174
5175 req = tevent_req_create(mem_ctx, &state,
5176 struct rpccli_svcctl_GetServiceDisplayNameA_state);
5177 if (req == NULL) {
5178 return NULL;
5179 }
5180 state->out_mem_ctx = NULL;
5181 state->dispatch_recv = cli->dispatch_recv;
5182
5183 /* In parameters */
5184 state->orig.in.handle = _handle;
5185 state->orig.in.service_name = _service_name;
5186 state->orig.in.display_name_length = _display_name_length;
5187
5188 /* Out parameters */
5189 state->orig.out.display_name = _display_name;
5190 state->orig.out.display_name_length = _display_name_length;
5191
5192 /* Result */
5193 ZERO_STRUCT(state->orig.out.result);
5194
5195 state->out_mem_ctx = talloc_named_const(state, 0,
5196 "rpccli_svcctl_GetServiceDisplayNameA_out_memory");
5197 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5198 return tevent_req_post(req, ev);
5199 }
5200
5201 /* make a temporary copy, that we pass to the dispatch function */
5202 state->tmp = state->orig;
5203
5204 subreq = cli->dispatch_send(state, ev, cli,
5205 &ndr_table_svcctl,
5206 NDR_SVCCTL_GETSERVICEDISPLAYNAMEA,
5207 &state->tmp);
5208 if (tevent_req_nomem(subreq, req)) {
5209 return tevent_req_post(req, ev);
5210 }
5211 tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceDisplayNameA_done, req);
5212 return req;
5213}
5214
5215static void rpccli_svcctl_GetServiceDisplayNameA_done(struct tevent_req *subreq)
5216{
5217 struct tevent_req *req = tevent_req_callback_data(
5218 subreq, struct tevent_req);
5219 struct rpccli_svcctl_GetServiceDisplayNameA_state *state = tevent_req_data(
5220 req, struct rpccli_svcctl_GetServiceDisplayNameA_state);
5221 NTSTATUS status;
5222 TALLOC_CTX *mem_ctx;
5223
5224 if (state->out_mem_ctx) {
5225 mem_ctx = state->out_mem_ctx;
5226 } else {
5227 mem_ctx = state;
5228 }
5229
5230 status = state->dispatch_recv(subreq, mem_ctx);
5231 TALLOC_FREE(subreq);
5232 if (!NT_STATUS_IS_OK(status)) {
5233 tevent_req_nterror(req, status);
5234 return;
5235 }
5236
5237 /* Copy out parameters */
5238 *state->orig.out.display_name = *state->tmp.out.display_name;
5239 if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
5240 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
5241 }
5242
5243 /* Copy result */
5244 state->orig.out.result = state->tmp.out.result;
5245
5246 /* Reset temporary structure */
5247 ZERO_STRUCT(state->tmp);
5248
5249 tevent_req_done(req);
5250}
5251
5252NTSTATUS rpccli_svcctl_GetServiceDisplayNameA_recv(struct tevent_req *req,
5253 TALLOC_CTX *mem_ctx,
5254 WERROR *result)
5255{
5256 struct rpccli_svcctl_GetServiceDisplayNameA_state *state = tevent_req_data(
5257 req, struct rpccli_svcctl_GetServiceDisplayNameA_state);
5258 NTSTATUS status;
5259
5260 if (tevent_req_is_nterror(req, &status)) {
5261 tevent_req_received(req);
5262 return status;
5263 }
5264
5265 /* Steal possbile out parameters to the callers context */
5266 talloc_steal(mem_ctx, state->out_mem_ctx);
5267
5268 /* Return result */
5269 *result = state->orig.out.result;
5270
5271 tevent_req_received(req);
5272 return NT_STATUS_OK;
5273}
5274
5275NTSTATUS rpccli_svcctl_GetServiceDisplayNameA(struct rpc_pipe_client *cli,
5276 TALLOC_CTX *mem_ctx,
5277 struct policy_handle *handle /* [in] [ref] */,
5278 const char *service_name /* [in] [unique,charset(UTF16)] */,
5279 const char **display_name /* [out] [ref,charset(UTF16)] */,
5280 uint32_t *display_name_length /* [in,out] [unique] */,
5281 WERROR *werror)
5282{
5283 struct svcctl_GetServiceDisplayNameA r;
5284 NTSTATUS status;
5285
5286 /* In parameters */
5287 r.in.handle = handle;
5288 r.in.service_name = service_name;
5289 r.in.display_name_length = display_name_length;
5290
5291 status = cli->dispatch(cli,
5292 mem_ctx,
5293 &ndr_table_svcctl,
5294 NDR_SVCCTL_GETSERVICEDISPLAYNAMEA,
5295 &r);
5296
5297 if (!NT_STATUS_IS_OK(status)) {
5298 return status;
5299 }
5300
5301 if (NT_STATUS_IS_ERR(status)) {
5302 return status;
5303 }
5304
5305 /* Return variables */
5306 *display_name = *r.out.display_name;
5307 if (display_name_length && r.out.display_name_length) {
5308 *display_name_length = *r.out.display_name_length;
5309 }
5310
5311 /* Return result */
5312 if (werror) {
5313 *werror = r.out.result;
5314 }
5315
5316 return werror_to_ntstatus(r.out.result);
5317}
5318
5319struct rpccli_svcctl_GetServiceKeyNameA_state {
5320 struct svcctl_GetServiceKeyNameA orig;
5321 struct svcctl_GetServiceKeyNameA tmp;
5322 TALLOC_CTX *out_mem_ctx;
5323 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5324};
5325
5326static void rpccli_svcctl_GetServiceKeyNameA_done(struct tevent_req *subreq);
5327
5328struct tevent_req *rpccli_svcctl_GetServiceKeyNameA_send(TALLOC_CTX *mem_ctx,
5329 struct tevent_context *ev,
5330 struct rpc_pipe_client *cli,
5331 struct policy_handle *_handle /* [in] [ref] */,
5332 const char *_service_name /* [in] [unique,charset(UTF16)] */,
5333 const char **_key_name /* [out] [ref,charset(UTF16)] */,
5334 uint32_t *_display_name_length /* [in,out] [unique] */)
5335{
5336 struct tevent_req *req;
5337 struct rpccli_svcctl_GetServiceKeyNameA_state *state;
5338 struct tevent_req *subreq;
5339
5340 req = tevent_req_create(mem_ctx, &state,
5341 struct rpccli_svcctl_GetServiceKeyNameA_state);
5342 if (req == NULL) {
5343 return NULL;
5344 }
5345 state->out_mem_ctx = NULL;
5346 state->dispatch_recv = cli->dispatch_recv;
5347
5348 /* In parameters */
5349 state->orig.in.handle = _handle;
5350 state->orig.in.service_name = _service_name;
5351 state->orig.in.display_name_length = _display_name_length;
5352
5353 /* Out parameters */
5354 state->orig.out.key_name = _key_name;
5355 state->orig.out.display_name_length = _display_name_length;
5356
5357 /* Result */
5358 ZERO_STRUCT(state->orig.out.result);
5359
5360 state->out_mem_ctx = talloc_named_const(state, 0,
5361 "rpccli_svcctl_GetServiceKeyNameA_out_memory");
5362 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5363 return tevent_req_post(req, ev);
5364 }
5365
5366 /* make a temporary copy, that we pass to the dispatch function */
5367 state->tmp = state->orig;
5368
5369 subreq = cli->dispatch_send(state, ev, cli,
5370 &ndr_table_svcctl,
5371 NDR_SVCCTL_GETSERVICEKEYNAMEA,
5372 &state->tmp);
5373 if (tevent_req_nomem(subreq, req)) {
5374 return tevent_req_post(req, ev);
5375 }
5376 tevent_req_set_callback(subreq, rpccli_svcctl_GetServiceKeyNameA_done, req);
5377 return req;
5378}
5379
5380static void rpccli_svcctl_GetServiceKeyNameA_done(struct tevent_req *subreq)
5381{
5382 struct tevent_req *req = tevent_req_callback_data(
5383 subreq, struct tevent_req);
5384 struct rpccli_svcctl_GetServiceKeyNameA_state *state = tevent_req_data(
5385 req, struct rpccli_svcctl_GetServiceKeyNameA_state);
5386 NTSTATUS status;
5387 TALLOC_CTX *mem_ctx;
5388
5389 if (state->out_mem_ctx) {
5390 mem_ctx = state->out_mem_ctx;
5391 } else {
5392 mem_ctx = state;
5393 }
5394
5395 status = state->dispatch_recv(subreq, mem_ctx);
5396 TALLOC_FREE(subreq);
5397 if (!NT_STATUS_IS_OK(status)) {
5398 tevent_req_nterror(req, status);
5399 return;
5400 }
5401
5402 /* Copy out parameters */
5403 *state->orig.out.key_name = *state->tmp.out.key_name;
5404 if (state->orig.out.display_name_length && state->tmp.out.display_name_length) {
5405 *state->orig.out.display_name_length = *state->tmp.out.display_name_length;
5406 }
5407
5408 /* Copy result */
5409 state->orig.out.result = state->tmp.out.result;
5410
5411 /* Reset temporary structure */
5412 ZERO_STRUCT(state->tmp);
5413
5414 tevent_req_done(req);
5415}
5416
5417NTSTATUS rpccli_svcctl_GetServiceKeyNameA_recv(struct tevent_req *req,
5418 TALLOC_CTX *mem_ctx,
5419 WERROR *result)
5420{
5421 struct rpccli_svcctl_GetServiceKeyNameA_state *state = tevent_req_data(
5422 req, struct rpccli_svcctl_GetServiceKeyNameA_state);
5423 NTSTATUS status;
5424
5425 if (tevent_req_is_nterror(req, &status)) {
5426 tevent_req_received(req);
5427 return status;
5428 }
5429
5430 /* Steal possbile out parameters to the callers context */
5431 talloc_steal(mem_ctx, state->out_mem_ctx);
5432
5433 /* Return result */
5434 *result = state->orig.out.result;
5435
5436 tevent_req_received(req);
5437 return NT_STATUS_OK;
5438}
5439
5440NTSTATUS rpccli_svcctl_GetServiceKeyNameA(struct rpc_pipe_client *cli,
5441 TALLOC_CTX *mem_ctx,
5442 struct policy_handle *handle /* [in] [ref] */,
5443 const char *service_name /* [in] [unique,charset(UTF16)] */,
5444 const char **key_name /* [out] [ref,charset(UTF16)] */,
5445 uint32_t *display_name_length /* [in,out] [unique] */,
5446 WERROR *werror)
5447{
5448 struct svcctl_GetServiceKeyNameA r;
5449 NTSTATUS status;
5450
5451 /* In parameters */
5452 r.in.handle = handle;
5453 r.in.service_name = service_name;
5454 r.in.display_name_length = display_name_length;
5455
5456 status = cli->dispatch(cli,
5457 mem_ctx,
5458 &ndr_table_svcctl,
5459 NDR_SVCCTL_GETSERVICEKEYNAMEA,
5460 &r);
5461
5462 if (!NT_STATUS_IS_OK(status)) {
5463 return status;
5464 }
5465
5466 if (NT_STATUS_IS_ERR(status)) {
5467 return status;
5468 }
5469
5470 /* Return variables */
5471 *key_name = *r.out.key_name;
5472 if (display_name_length && r.out.display_name_length) {
5473 *display_name_length = *r.out.display_name_length;
5474 }
5475
5476 /* Return result */
5477 if (werror) {
5478 *werror = r.out.result;
5479 }
5480
5481 return werror_to_ntstatus(r.out.result);
5482}
5483
5484struct rpccli_svcctl_GetCurrentGroupeStateW_state {
5485 struct svcctl_GetCurrentGroupeStateW orig;
5486 struct svcctl_GetCurrentGroupeStateW tmp;
5487 TALLOC_CTX *out_mem_ctx;
5488 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5489};
5490
5491static void rpccli_svcctl_GetCurrentGroupeStateW_done(struct tevent_req *subreq);
5492
5493struct tevent_req *rpccli_svcctl_GetCurrentGroupeStateW_send(TALLOC_CTX *mem_ctx,
5494 struct tevent_context *ev,
5495 struct rpc_pipe_client *cli)
5496{
5497 struct tevent_req *req;
5498 struct rpccli_svcctl_GetCurrentGroupeStateW_state *state;
5499 struct tevent_req *subreq;
5500
5501 req = tevent_req_create(mem_ctx, &state,
5502 struct rpccli_svcctl_GetCurrentGroupeStateW_state);
5503 if (req == NULL) {
5504 return NULL;
5505 }
5506 state->out_mem_ctx = NULL;
5507 state->dispatch_recv = cli->dispatch_recv;
5508
5509 /* In parameters */
5510
5511 /* Out parameters */
5512
5513 /* Result */
5514 ZERO_STRUCT(state->orig.out.result);
5515
5516 /* make a temporary copy, that we pass to the dispatch function */
5517 state->tmp = state->orig;
5518
5519 subreq = cli->dispatch_send(state, ev, cli,
5520 &ndr_table_svcctl,
5521 NDR_SVCCTL_GETCURRENTGROUPESTATEW,
5522 &state->tmp);
5523 if (tevent_req_nomem(subreq, req)) {
5524 return tevent_req_post(req, ev);
5525 }
5526 tevent_req_set_callback(subreq, rpccli_svcctl_GetCurrentGroupeStateW_done, req);
5527 return req;
5528}
5529
5530static void rpccli_svcctl_GetCurrentGroupeStateW_done(struct tevent_req *subreq)
5531{
5532 struct tevent_req *req = tevent_req_callback_data(
5533 subreq, struct tevent_req);
5534 struct rpccli_svcctl_GetCurrentGroupeStateW_state *state = tevent_req_data(
5535 req, struct rpccli_svcctl_GetCurrentGroupeStateW_state);
5536 NTSTATUS status;
5537 TALLOC_CTX *mem_ctx;
5538
5539 if (state->out_mem_ctx) {
5540 mem_ctx = state->out_mem_ctx;
5541 } else {
5542 mem_ctx = state;
5543 }
5544
5545 status = state->dispatch_recv(subreq, mem_ctx);
5546 TALLOC_FREE(subreq);
5547 if (!NT_STATUS_IS_OK(status)) {
5548 tevent_req_nterror(req, status);
5549 return;
5550 }
5551
5552 /* Copy out parameters */
5553
5554 /* Copy result */
5555 state->orig.out.result = state->tmp.out.result;
5556
5557 /* Reset temporary structure */
5558 ZERO_STRUCT(state->tmp);
5559
5560 tevent_req_done(req);
5561}
5562
5563NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW_recv(struct tevent_req *req,
5564 TALLOC_CTX *mem_ctx,
5565 WERROR *result)
5566{
5567 struct rpccli_svcctl_GetCurrentGroupeStateW_state *state = tevent_req_data(
5568 req, struct rpccli_svcctl_GetCurrentGroupeStateW_state);
5569 NTSTATUS status;
5570
5571 if (tevent_req_is_nterror(req, &status)) {
5572 tevent_req_received(req);
5573 return status;
5574 }
5575
5576 /* Steal possbile out parameters to the callers context */
5577 talloc_steal(mem_ctx, state->out_mem_ctx);
5578
5579 /* Return result */
5580 *result = state->orig.out.result;
5581
5582 tevent_req_received(req);
5583 return NT_STATUS_OK;
5584}
5585
5586NTSTATUS rpccli_svcctl_GetCurrentGroupeStateW(struct rpc_pipe_client *cli,
5587 TALLOC_CTX *mem_ctx,
5588 WERROR *werror)
5589{
5590 struct svcctl_GetCurrentGroupeStateW r;
5591 NTSTATUS status;
5592
5593 /* In parameters */
5594
5595 status = cli->dispatch(cli,
5596 mem_ctx,
5597 &ndr_table_svcctl,
5598 NDR_SVCCTL_GETCURRENTGROUPESTATEW,
5599 &r);
5600
5601 if (!NT_STATUS_IS_OK(status)) {
5602 return status;
5603 }
5604
5605 if (NT_STATUS_IS_ERR(status)) {
5606 return status;
5607 }
5608
5609 /* Return variables */
5610
5611 /* Return result */
5612 if (werror) {
5613 *werror = r.out.result;
5614 }
5615
5616 return werror_to_ntstatus(r.out.result);
5617}
5618
5619struct rpccli_svcctl_EnumServiceGroupW_state {
5620 struct svcctl_EnumServiceGroupW orig;
5621 struct svcctl_EnumServiceGroupW tmp;
5622 TALLOC_CTX *out_mem_ctx;
5623 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5624};
5625
5626static void rpccli_svcctl_EnumServiceGroupW_done(struct tevent_req *subreq);
5627
5628struct tevent_req *rpccli_svcctl_EnumServiceGroupW_send(TALLOC_CTX *mem_ctx,
5629 struct tevent_context *ev,
5630 struct rpc_pipe_client *cli)
5631{
5632 struct tevent_req *req;
5633 struct rpccli_svcctl_EnumServiceGroupW_state *state;
5634 struct tevent_req *subreq;
5635
5636 req = tevent_req_create(mem_ctx, &state,
5637 struct rpccli_svcctl_EnumServiceGroupW_state);
5638 if (req == NULL) {
5639 return NULL;
5640 }
5641 state->out_mem_ctx = NULL;
5642 state->dispatch_recv = cli->dispatch_recv;
5643
5644 /* In parameters */
5645
5646 /* Out parameters */
5647
5648 /* Result */
5649 ZERO_STRUCT(state->orig.out.result);
5650
5651 /* make a temporary copy, that we pass to the dispatch function */
5652 state->tmp = state->orig;
5653
5654 subreq = cli->dispatch_send(state, ev, cli,
5655 &ndr_table_svcctl,
5656 NDR_SVCCTL_ENUMSERVICEGROUPW,
5657 &state->tmp);
5658 if (tevent_req_nomem(subreq, req)) {
5659 return tevent_req_post(req, ev);
5660 }
5661 tevent_req_set_callback(subreq, rpccli_svcctl_EnumServiceGroupW_done, req);
5662 return req;
5663}
5664
5665static void rpccli_svcctl_EnumServiceGroupW_done(struct tevent_req *subreq)
5666{
5667 struct tevent_req *req = tevent_req_callback_data(
5668 subreq, struct tevent_req);
5669 struct rpccli_svcctl_EnumServiceGroupW_state *state = tevent_req_data(
5670 req, struct rpccli_svcctl_EnumServiceGroupW_state);
5671 NTSTATUS status;
5672 TALLOC_CTX *mem_ctx;
5673
5674 if (state->out_mem_ctx) {
5675 mem_ctx = state->out_mem_ctx;
5676 } else {
5677 mem_ctx = state;
5678 }
5679
5680 status = state->dispatch_recv(subreq, mem_ctx);
5681 TALLOC_FREE(subreq);
5682 if (!NT_STATUS_IS_OK(status)) {
5683 tevent_req_nterror(req, status);
5684 return;
5685 }
5686
5687 /* Copy out parameters */
5688
5689 /* Copy result */
5690 state->orig.out.result = state->tmp.out.result;
5691
5692 /* Reset temporary structure */
5693 ZERO_STRUCT(state->tmp);
5694
5695 tevent_req_done(req);
5696}
5697
5698NTSTATUS rpccli_svcctl_EnumServiceGroupW_recv(struct tevent_req *req,
5699 TALLOC_CTX *mem_ctx,
5700 WERROR *result)
5701{
5702 struct rpccli_svcctl_EnumServiceGroupW_state *state = tevent_req_data(
5703 req, struct rpccli_svcctl_EnumServiceGroupW_state);
5704 NTSTATUS status;
5705
5706 if (tevent_req_is_nterror(req, &status)) {
5707 tevent_req_received(req);
5708 return status;
5709 }
5710
5711 /* Steal possbile out parameters to the callers context */
5712 talloc_steal(mem_ctx, state->out_mem_ctx);
5713
5714 /* Return result */
5715 *result = state->orig.out.result;
5716
5717 tevent_req_received(req);
5718 return NT_STATUS_OK;
5719}
5720
5721NTSTATUS rpccli_svcctl_EnumServiceGroupW(struct rpc_pipe_client *cli,
5722 TALLOC_CTX *mem_ctx,
5723 WERROR *werror)
5724{
5725 struct svcctl_EnumServiceGroupW r;
5726 NTSTATUS status;
5727
5728 /* In parameters */
5729
5730 status = cli->dispatch(cli,
5731 mem_ctx,
5732 &ndr_table_svcctl,
5733 NDR_SVCCTL_ENUMSERVICEGROUPW,
5734 &r);
5735
5736 if (!NT_STATUS_IS_OK(status)) {
5737 return status;
5738 }
5739
5740 if (NT_STATUS_IS_ERR(status)) {
5741 return status;
5742 }
5743
5744 /* Return variables */
5745
5746 /* Return result */
5747 if (werror) {
5748 *werror = r.out.result;
5749 }
5750
5751 return werror_to_ntstatus(r.out.result);
5752}
5753
5754struct rpccli_svcctl_ChangeServiceConfig2A_state {
5755 struct svcctl_ChangeServiceConfig2A orig;
5756 struct svcctl_ChangeServiceConfig2A tmp;
5757 TALLOC_CTX *out_mem_ctx;
5758 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5759};
5760
5761static void rpccli_svcctl_ChangeServiceConfig2A_done(struct tevent_req *subreq);
5762
5763struct tevent_req *rpccli_svcctl_ChangeServiceConfig2A_send(TALLOC_CTX *mem_ctx,
5764 struct tevent_context *ev,
5765 struct rpc_pipe_client *cli,
5766 struct policy_handle *_handle /* [in] [ref] */,
5767 uint32_t _info_level /* [in] */,
5768 uint8_t *_info /* [in] [unique] */)
5769{
5770 struct tevent_req *req;
5771 struct rpccli_svcctl_ChangeServiceConfig2A_state *state;
5772 struct tevent_req *subreq;
5773
5774 req = tevent_req_create(mem_ctx, &state,
5775 struct rpccli_svcctl_ChangeServiceConfig2A_state);
5776 if (req == NULL) {
5777 return NULL;
5778 }
5779 state->out_mem_ctx = NULL;
5780 state->dispatch_recv = cli->dispatch_recv;
5781
5782 /* In parameters */
5783 state->orig.in.handle = _handle;
5784 state->orig.in.info_level = _info_level;
5785 state->orig.in.info = _info;
5786
5787 /* Out parameters */
5788
5789 /* Result */
5790 ZERO_STRUCT(state->orig.out.result);
5791
5792 /* make a temporary copy, that we pass to the dispatch function */
5793 state->tmp = state->orig;
5794
5795 subreq = cli->dispatch_send(state, ev, cli,
5796 &ndr_table_svcctl,
5797 NDR_SVCCTL_CHANGESERVICECONFIG2A,
5798 &state->tmp);
5799 if (tevent_req_nomem(subreq, req)) {
5800 return tevent_req_post(req, ev);
5801 }
5802 tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfig2A_done, req);
5803 return req;
5804}
5805
5806static void rpccli_svcctl_ChangeServiceConfig2A_done(struct tevent_req *subreq)
5807{
5808 struct tevent_req *req = tevent_req_callback_data(
5809 subreq, struct tevent_req);
5810 struct rpccli_svcctl_ChangeServiceConfig2A_state *state = tevent_req_data(
5811 req, struct rpccli_svcctl_ChangeServiceConfig2A_state);
5812 NTSTATUS status;
5813 TALLOC_CTX *mem_ctx;
5814
5815 if (state->out_mem_ctx) {
5816 mem_ctx = state->out_mem_ctx;
5817 } else {
5818 mem_ctx = state;
5819 }
5820
5821 status = state->dispatch_recv(subreq, mem_ctx);
5822 TALLOC_FREE(subreq);
5823 if (!NT_STATUS_IS_OK(status)) {
5824 tevent_req_nterror(req, status);
5825 return;
5826 }
5827
5828 /* Copy out parameters */
5829
5830 /* Copy result */
5831 state->orig.out.result = state->tmp.out.result;
5832
5833 /* Reset temporary structure */
5834 ZERO_STRUCT(state->tmp);
5835
5836 tevent_req_done(req);
5837}
5838
5839NTSTATUS rpccli_svcctl_ChangeServiceConfig2A_recv(struct tevent_req *req,
5840 TALLOC_CTX *mem_ctx,
5841 WERROR *result)
5842{
5843 struct rpccli_svcctl_ChangeServiceConfig2A_state *state = tevent_req_data(
5844 req, struct rpccli_svcctl_ChangeServiceConfig2A_state);
5845 NTSTATUS status;
5846
5847 if (tevent_req_is_nterror(req, &status)) {
5848 tevent_req_received(req);
5849 return status;
5850 }
5851
5852 /* Steal possbile out parameters to the callers context */
5853 talloc_steal(mem_ctx, state->out_mem_ctx);
5854
5855 /* Return result */
5856 *result = state->orig.out.result;
5857
5858 tevent_req_received(req);
5859 return NT_STATUS_OK;
5860}
5861
5862NTSTATUS rpccli_svcctl_ChangeServiceConfig2A(struct rpc_pipe_client *cli,
5863 TALLOC_CTX *mem_ctx,
5864 struct policy_handle *handle /* [in] [ref] */,
5865 uint32_t info_level /* [in] */,
5866 uint8_t *info /* [in] [unique] */,
5867 WERROR *werror)
5868{
5869 struct svcctl_ChangeServiceConfig2A r;
5870 NTSTATUS status;
5871
5872 /* In parameters */
5873 r.in.handle = handle;
5874 r.in.info_level = info_level;
5875 r.in.info = info;
5876
5877 status = cli->dispatch(cli,
5878 mem_ctx,
5879 &ndr_table_svcctl,
5880 NDR_SVCCTL_CHANGESERVICECONFIG2A,
5881 &r);
5882
5883 if (!NT_STATUS_IS_OK(status)) {
5884 return status;
5885 }
5886
5887 if (NT_STATUS_IS_ERR(status)) {
5888 return status;
5889 }
5890
5891 /* Return variables */
5892
5893 /* Return result */
5894 if (werror) {
5895 *werror = r.out.result;
5896 }
5897
5898 return werror_to_ntstatus(r.out.result);
5899}
5900
5901struct rpccli_svcctl_ChangeServiceConfig2W_state {
5902 struct svcctl_ChangeServiceConfig2W orig;
5903 struct svcctl_ChangeServiceConfig2W tmp;
5904 TALLOC_CTX *out_mem_ctx;
5905 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5906};
5907
5908static void rpccli_svcctl_ChangeServiceConfig2W_done(struct tevent_req *subreq);
5909
5910struct tevent_req *rpccli_svcctl_ChangeServiceConfig2W_send(TALLOC_CTX *mem_ctx,
5911 struct tevent_context *ev,
5912 struct rpc_pipe_client *cli,
5913 struct policy_handle *_handle /* [in] [ref] */,
5914 uint32_t _info_level /* [in] */,
5915 uint8_t *_info /* [in] [unique] */)
5916{
5917 struct tevent_req *req;
5918 struct rpccli_svcctl_ChangeServiceConfig2W_state *state;
5919 struct tevent_req *subreq;
5920
5921 req = tevent_req_create(mem_ctx, &state,
5922 struct rpccli_svcctl_ChangeServiceConfig2W_state);
5923 if (req == NULL) {
5924 return NULL;
5925 }
5926 state->out_mem_ctx = NULL;
5927 state->dispatch_recv = cli->dispatch_recv;
5928
5929 /* In parameters */
5930 state->orig.in.handle = _handle;
5931 state->orig.in.info_level = _info_level;
5932 state->orig.in.info = _info;
5933
5934 /* Out parameters */
5935
5936 /* Result */
5937 ZERO_STRUCT(state->orig.out.result);
5938
5939 /* make a temporary copy, that we pass to the dispatch function */
5940 state->tmp = state->orig;
5941
5942 subreq = cli->dispatch_send(state, ev, cli,
5943 &ndr_table_svcctl,
5944 NDR_SVCCTL_CHANGESERVICECONFIG2W,
5945 &state->tmp);
5946 if (tevent_req_nomem(subreq, req)) {
5947 return tevent_req_post(req, ev);
5948 }
5949 tevent_req_set_callback(subreq, rpccli_svcctl_ChangeServiceConfig2W_done, req);
5950 return req;
5951}
5952
5953static void rpccli_svcctl_ChangeServiceConfig2W_done(struct tevent_req *subreq)
5954{
5955 struct tevent_req *req = tevent_req_callback_data(
5956 subreq, struct tevent_req);
5957 struct rpccli_svcctl_ChangeServiceConfig2W_state *state = tevent_req_data(
5958 req, struct rpccli_svcctl_ChangeServiceConfig2W_state);
5959 NTSTATUS status;
5960 TALLOC_CTX *mem_ctx;
5961
5962 if (state->out_mem_ctx) {
5963 mem_ctx = state->out_mem_ctx;
5964 } else {
5965 mem_ctx = state;
5966 }
5967
5968 status = state->dispatch_recv(subreq, mem_ctx);
5969 TALLOC_FREE(subreq);
5970 if (!NT_STATUS_IS_OK(status)) {
5971 tevent_req_nterror(req, status);
5972 return;
5973 }
5974
5975 /* Copy out parameters */
5976
5977 /* Copy result */
5978 state->orig.out.result = state->tmp.out.result;
5979
5980 /* Reset temporary structure */
5981 ZERO_STRUCT(state->tmp);
5982
5983 tevent_req_done(req);
5984}
5985
5986NTSTATUS rpccli_svcctl_ChangeServiceConfig2W_recv(struct tevent_req *req,
5987 TALLOC_CTX *mem_ctx,
5988 WERROR *result)
5989{
5990 struct rpccli_svcctl_ChangeServiceConfig2W_state *state = tevent_req_data(
5991 req, struct rpccli_svcctl_ChangeServiceConfig2W_state);
5992 NTSTATUS status;
5993
5994 if (tevent_req_is_nterror(req, &status)) {
5995 tevent_req_received(req);
5996 return status;
5997 }
5998
5999 /* Steal possbile out parameters to the callers context */
6000 talloc_steal(mem_ctx, state->out_mem_ctx);
6001
6002 /* Return result */
6003 *result = state->orig.out.result;
6004
6005 tevent_req_received(req);
6006 return NT_STATUS_OK;
6007}
6008
6009NTSTATUS rpccli_svcctl_ChangeServiceConfig2W(struct rpc_pipe_client *cli,
6010 TALLOC_CTX *mem_ctx,
6011 struct policy_handle *handle /* [in] [ref] */,
6012 uint32_t info_level /* [in] */,
6013 uint8_t *info /* [in] [unique] */,
6014 WERROR *werror)
6015{
6016 struct svcctl_ChangeServiceConfig2W r;
6017 NTSTATUS status;
6018
6019 /* In parameters */
6020 r.in.handle = handle;
6021 r.in.info_level = info_level;
6022 r.in.info = info;
6023
6024 status = cli->dispatch(cli,
6025 mem_ctx,
6026 &ndr_table_svcctl,
6027 NDR_SVCCTL_CHANGESERVICECONFIG2W,
6028 &r);
6029
6030 if (!NT_STATUS_IS_OK(status)) {
6031 return status;
6032 }
6033
6034 if (NT_STATUS_IS_ERR(status)) {
6035 return status;
6036 }
6037
6038 /* Return variables */
6039
6040 /* Return result */
6041 if (werror) {
6042 *werror = r.out.result;
6043 }
6044
6045 return werror_to_ntstatus(r.out.result);
6046}
6047
6048struct rpccli_svcctl_QueryServiceConfig2A_state {
6049 struct svcctl_QueryServiceConfig2A orig;
6050 struct svcctl_QueryServiceConfig2A tmp;
6051 TALLOC_CTX *out_mem_ctx;
6052 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6053};
6054
6055static void rpccli_svcctl_QueryServiceConfig2A_done(struct tevent_req *subreq);
6056
6057struct tevent_req *rpccli_svcctl_QueryServiceConfig2A_send(TALLOC_CTX *mem_ctx,
6058 struct tevent_context *ev,
6059 struct rpc_pipe_client *cli,
6060 struct policy_handle *_handle /* [in] [ref] */,
6061 enum svcctl_ConfigLevel _info_level /* [in] */,
6062 uint8_t *_buffer /* [out] */,
6063 uint32_t _offered /* [in] */,
6064 uint32_t *_needed /* [out] [ref] */)
6065{
6066 struct tevent_req *req;
6067 struct rpccli_svcctl_QueryServiceConfig2A_state *state;
6068 struct tevent_req *subreq;
6069
6070 req = tevent_req_create(mem_ctx, &state,
6071 struct rpccli_svcctl_QueryServiceConfig2A_state);
6072 if (req == NULL) {
6073 return NULL;
6074 }
6075 state->out_mem_ctx = NULL;
6076 state->dispatch_recv = cli->dispatch_recv;
6077
6078 /* In parameters */
6079 state->orig.in.handle = _handle;
6080 state->orig.in.info_level = _info_level;
6081 state->orig.in.offered = _offered;
6082
6083 /* Out parameters */
6084 state->orig.out.buffer = _buffer;
6085 state->orig.out.needed = _needed;
6086
6087 /* Result */
6088 ZERO_STRUCT(state->orig.out.result);
6089
6090 state->out_mem_ctx = talloc_named_const(state, 0,
6091 "rpccli_svcctl_QueryServiceConfig2A_out_memory");
6092 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6093 return tevent_req_post(req, ev);
6094 }
6095
6096 /* make a temporary copy, that we pass to the dispatch function */
6097 state->tmp = state->orig;
6098
6099 subreq = cli->dispatch_send(state, ev, cli,
6100 &ndr_table_svcctl,
6101 NDR_SVCCTL_QUERYSERVICECONFIG2A,
6102 &state->tmp);
6103 if (tevent_req_nomem(subreq, req)) {
6104 return tevent_req_post(req, ev);
6105 }
6106 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceConfig2A_done, req);
6107 return req;
6108}
6109
6110static void rpccli_svcctl_QueryServiceConfig2A_done(struct tevent_req *subreq)
6111{
6112 struct tevent_req *req = tevent_req_callback_data(
6113 subreq, struct tevent_req);
6114 struct rpccli_svcctl_QueryServiceConfig2A_state *state = tevent_req_data(
6115 req, struct rpccli_svcctl_QueryServiceConfig2A_state);
6116 NTSTATUS status;
6117 TALLOC_CTX *mem_ctx;
6118
6119 if (state->out_mem_ctx) {
6120 mem_ctx = state->out_mem_ctx;
6121 } else {
6122 mem_ctx = state;
6123 }
6124
6125 status = state->dispatch_recv(subreq, mem_ctx);
6126 TALLOC_FREE(subreq);
6127 if (!NT_STATUS_IS_OK(status)) {
6128 tevent_req_nterror(req, status);
6129 return;
6130 }
6131
6132 /* Copy out parameters */
6133 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
6134 *state->orig.out.needed = *state->tmp.out.needed;
6135
6136 /* Copy result */
6137 state->orig.out.result = state->tmp.out.result;
6138
6139 /* Reset temporary structure */
6140 ZERO_STRUCT(state->tmp);
6141
6142 tevent_req_done(req);
6143}
6144
6145NTSTATUS rpccli_svcctl_QueryServiceConfig2A_recv(struct tevent_req *req,
6146 TALLOC_CTX *mem_ctx,
6147 WERROR *result)
6148{
6149 struct rpccli_svcctl_QueryServiceConfig2A_state *state = tevent_req_data(
6150 req, struct rpccli_svcctl_QueryServiceConfig2A_state);
6151 NTSTATUS status;
6152
6153 if (tevent_req_is_nterror(req, &status)) {
6154 tevent_req_received(req);
6155 return status;
6156 }
6157
6158 /* Steal possbile out parameters to the callers context */
6159 talloc_steal(mem_ctx, state->out_mem_ctx);
6160
6161 /* Return result */
6162 *result = state->orig.out.result;
6163
6164 tevent_req_received(req);
6165 return NT_STATUS_OK;
6166}
6167
6168NTSTATUS rpccli_svcctl_QueryServiceConfig2A(struct rpc_pipe_client *cli,
6169 TALLOC_CTX *mem_ctx,
6170 struct policy_handle *handle /* [in] [ref] */,
6171 enum svcctl_ConfigLevel info_level /* [in] */,
6172 uint8_t *buffer /* [out] */,
6173 uint32_t offered /* [in] */,
6174 uint32_t *needed /* [out] [ref] */,
6175 WERROR *werror)
6176{
6177 struct svcctl_QueryServiceConfig2A r;
6178 NTSTATUS status;
6179
6180 /* In parameters */
6181 r.in.handle = handle;
6182 r.in.info_level = info_level;
6183 r.in.offered = offered;
6184
6185 status = cli->dispatch(cli,
6186 mem_ctx,
6187 &ndr_table_svcctl,
6188 NDR_SVCCTL_QUERYSERVICECONFIG2A,
6189 &r);
6190
6191 if (!NT_STATUS_IS_OK(status)) {
6192 return status;
6193 }
6194
6195 if (NT_STATUS_IS_ERR(status)) {
6196 return status;
6197 }
6198
6199 /* Return variables */
6200 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
6201 *needed = *r.out.needed;
6202
6203 /* Return result */
6204 if (werror) {
6205 *werror = r.out.result;
6206 }
6207
6208 return werror_to_ntstatus(r.out.result);
6209}
6210
6211struct rpccli_svcctl_QueryServiceConfig2W_state {
6212 struct svcctl_QueryServiceConfig2W orig;
6213 struct svcctl_QueryServiceConfig2W tmp;
6214 TALLOC_CTX *out_mem_ctx;
6215 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6216};
6217
6218static void rpccli_svcctl_QueryServiceConfig2W_done(struct tevent_req *subreq);
6219
6220struct tevent_req *rpccli_svcctl_QueryServiceConfig2W_send(TALLOC_CTX *mem_ctx,
6221 struct tevent_context *ev,
6222 struct rpc_pipe_client *cli,
6223 struct policy_handle *_handle /* [in] [ref] */,
6224 enum svcctl_ConfigLevel _info_level /* [in] */,
6225 uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
6226 uint32_t _offered /* [in] [range(0,8192)] */,
6227 uint32_t *_needed /* [out] [ref,range(0,8192)] */)
6228{
6229 struct tevent_req *req;
6230 struct rpccli_svcctl_QueryServiceConfig2W_state *state;
6231 struct tevent_req *subreq;
6232
6233 req = tevent_req_create(mem_ctx, &state,
6234 struct rpccli_svcctl_QueryServiceConfig2W_state);
6235 if (req == NULL) {
6236 return NULL;
6237 }
6238 state->out_mem_ctx = NULL;
6239 state->dispatch_recv = cli->dispatch_recv;
6240
6241 /* In parameters */
6242 state->orig.in.handle = _handle;
6243 state->orig.in.info_level = _info_level;
6244 state->orig.in.offered = _offered;
6245
6246 /* Out parameters */
6247 state->orig.out.buffer = _buffer;
6248 state->orig.out.needed = _needed;
6249
6250 /* Result */
6251 ZERO_STRUCT(state->orig.out.result);
6252
6253 state->out_mem_ctx = talloc_named_const(state, 0,
6254 "rpccli_svcctl_QueryServiceConfig2W_out_memory");
6255 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6256 return tevent_req_post(req, ev);
6257 }
6258
6259 /* make a temporary copy, that we pass to the dispatch function */
6260 state->tmp = state->orig;
6261
6262 subreq = cli->dispatch_send(state, ev, cli,
6263 &ndr_table_svcctl,
6264 NDR_SVCCTL_QUERYSERVICECONFIG2W,
6265 &state->tmp);
6266 if (tevent_req_nomem(subreq, req)) {
6267 return tevent_req_post(req, ev);
6268 }
6269 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceConfig2W_done, req);
6270 return req;
6271}
6272
6273static void rpccli_svcctl_QueryServiceConfig2W_done(struct tevent_req *subreq)
6274{
6275 struct tevent_req *req = tevent_req_callback_data(
6276 subreq, struct tevent_req);
6277 struct rpccli_svcctl_QueryServiceConfig2W_state *state = tevent_req_data(
6278 req, struct rpccli_svcctl_QueryServiceConfig2W_state);
6279 NTSTATUS status;
6280 TALLOC_CTX *mem_ctx;
6281
6282 if (state->out_mem_ctx) {
6283 mem_ctx = state->out_mem_ctx;
6284 } else {
6285 mem_ctx = state;
6286 }
6287
6288 status = state->dispatch_recv(subreq, mem_ctx);
6289 TALLOC_FREE(subreq);
6290 if (!NT_STATUS_IS_OK(status)) {
6291 tevent_req_nterror(req, status);
6292 return;
6293 }
6294
6295 /* Copy out parameters */
6296 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
6297 *state->orig.out.needed = *state->tmp.out.needed;
6298
6299 /* Copy result */
6300 state->orig.out.result = state->tmp.out.result;
6301
6302 /* Reset temporary structure */
6303 ZERO_STRUCT(state->tmp);
6304
6305 tevent_req_done(req);
6306}
6307
6308NTSTATUS rpccli_svcctl_QueryServiceConfig2W_recv(struct tevent_req *req,
6309 TALLOC_CTX *mem_ctx,
6310 WERROR *result)
6311{
6312 struct rpccli_svcctl_QueryServiceConfig2W_state *state = tevent_req_data(
6313 req, struct rpccli_svcctl_QueryServiceConfig2W_state);
6314 NTSTATUS status;
6315
6316 if (tevent_req_is_nterror(req, &status)) {
6317 tevent_req_received(req);
6318 return status;
6319 }
6320
6321 /* Steal possbile out parameters to the callers context */
6322 talloc_steal(mem_ctx, state->out_mem_ctx);
6323
6324 /* Return result */
6325 *result = state->orig.out.result;
6326
6327 tevent_req_received(req);
6328 return NT_STATUS_OK;
6329}
6330
6331NTSTATUS rpccli_svcctl_QueryServiceConfig2W(struct rpc_pipe_client *cli,
6332 TALLOC_CTX *mem_ctx,
6333 struct policy_handle *handle /* [in] [ref] */,
6334 enum svcctl_ConfigLevel info_level /* [in] */,
6335 uint8_t *buffer /* [out] [ref,size_is(offered)] */,
6336 uint32_t offered /* [in] [range(0,8192)] */,
6337 uint32_t *needed /* [out] [ref,range(0,8192)] */,
6338 WERROR *werror)
6339{
6340 struct svcctl_QueryServiceConfig2W r;
6341 NTSTATUS status;
6342
6343 /* In parameters */
6344 r.in.handle = handle;
6345 r.in.info_level = info_level;
6346 r.in.offered = offered;
6347
6348 status = cli->dispatch(cli,
6349 mem_ctx,
6350 &ndr_table_svcctl,
6351 NDR_SVCCTL_QUERYSERVICECONFIG2W,
6352 &r);
6353
6354 if (!NT_STATUS_IS_OK(status)) {
6355 return status;
6356 }
6357
6358 if (NT_STATUS_IS_ERR(status)) {
6359 return status;
6360 }
6361
6362 /* Return variables */
6363 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
6364 *needed = *r.out.needed;
6365
6366 /* Return result */
6367 if (werror) {
6368 *werror = r.out.result;
6369 }
6370
6371 return werror_to_ntstatus(r.out.result);
6372}
6373
6374struct rpccli_svcctl_QueryServiceStatusEx_state {
6375 struct svcctl_QueryServiceStatusEx orig;
6376 struct svcctl_QueryServiceStatusEx tmp;
6377 TALLOC_CTX *out_mem_ctx;
6378 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6379};
6380
6381static void rpccli_svcctl_QueryServiceStatusEx_done(struct tevent_req *subreq);
6382
6383struct tevent_req *rpccli_svcctl_QueryServiceStatusEx_send(TALLOC_CTX *mem_ctx,
6384 struct tevent_context *ev,
6385 struct rpc_pipe_client *cli,
6386 struct policy_handle *_handle /* [in] [ref] */,
6387 enum svcctl_StatusLevel _info_level /* [in] */,
6388 uint8_t *_buffer /* [out] [ref,size_is(offered)] */,
6389 uint32_t _offered /* [in] [range(0,8192)] */,
6390 uint32_t *_needed /* [out] [ref,range(0,8192)] */)
6391{
6392 struct tevent_req *req;
6393 struct rpccli_svcctl_QueryServiceStatusEx_state *state;
6394 struct tevent_req *subreq;
6395
6396 req = tevent_req_create(mem_ctx, &state,
6397 struct rpccli_svcctl_QueryServiceStatusEx_state);
6398 if (req == NULL) {
6399 return NULL;
6400 }
6401 state->out_mem_ctx = NULL;
6402 state->dispatch_recv = cli->dispatch_recv;
6403
6404 /* In parameters */
6405 state->orig.in.handle = _handle;
6406 state->orig.in.info_level = _info_level;
6407 state->orig.in.offered = _offered;
6408
6409 /* Out parameters */
6410 state->orig.out.buffer = _buffer;
6411 state->orig.out.needed = _needed;
6412
6413 /* Result */
6414 ZERO_STRUCT(state->orig.out.result);
6415
6416 state->out_mem_ctx = talloc_named_const(state, 0,
6417 "rpccli_svcctl_QueryServiceStatusEx_out_memory");
6418 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6419 return tevent_req_post(req, ev);
6420 }
6421
6422 /* make a temporary copy, that we pass to the dispatch function */
6423 state->tmp = state->orig;
6424
6425 subreq = cli->dispatch_send(state, ev, cli,
6426 &ndr_table_svcctl,
6427 NDR_SVCCTL_QUERYSERVICESTATUSEX,
6428 &state->tmp);
6429 if (tevent_req_nomem(subreq, req)) {
6430 return tevent_req_post(req, ev);
6431 }
6432 tevent_req_set_callback(subreq, rpccli_svcctl_QueryServiceStatusEx_done, req);
6433 return req;
6434}
6435
6436static void rpccli_svcctl_QueryServiceStatusEx_done(struct tevent_req *subreq)
6437{
6438 struct tevent_req *req = tevent_req_callback_data(
6439 subreq, struct tevent_req);
6440 struct rpccli_svcctl_QueryServiceStatusEx_state *state = tevent_req_data(
6441 req, struct rpccli_svcctl_QueryServiceStatusEx_state);
6442 NTSTATUS status;
6443 TALLOC_CTX *mem_ctx;
6444
6445 if (state->out_mem_ctx) {
6446 mem_ctx = state->out_mem_ctx;
6447 } else {
6448 mem_ctx = state;
6449 }
6450
6451 status = state->dispatch_recv(subreq, mem_ctx);
6452 TALLOC_FREE(subreq);
6453 if (!NT_STATUS_IS_OK(status)) {
6454 tevent_req_nterror(req, status);
6455 return;
6456 }
6457
6458 /* Copy out parameters */
6459 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
6460 *state->orig.out.needed = *state->tmp.out.needed;
6461
6462 /* Copy result */
6463 state->orig.out.result = state->tmp.out.result;
6464
6465 /* Reset temporary structure */
6466 ZERO_STRUCT(state->tmp);
6467
6468 tevent_req_done(req);
6469}
6470
6471NTSTATUS rpccli_svcctl_QueryServiceStatusEx_recv(struct tevent_req *req,
6472 TALLOC_CTX *mem_ctx,
6473 WERROR *result)
6474{
6475 struct rpccli_svcctl_QueryServiceStatusEx_state *state = tevent_req_data(
6476 req, struct rpccli_svcctl_QueryServiceStatusEx_state);
6477 NTSTATUS status;
6478
6479 if (tevent_req_is_nterror(req, &status)) {
6480 tevent_req_received(req);
6481 return status;
6482 }
6483
6484 /* Steal possbile out parameters to the callers context */
6485 talloc_steal(mem_ctx, state->out_mem_ctx);
6486
6487 /* Return result */
6488 *result = state->orig.out.result;
6489
6490 tevent_req_received(req);
6491 return NT_STATUS_OK;
6492}
6493
6494NTSTATUS rpccli_svcctl_QueryServiceStatusEx(struct rpc_pipe_client *cli,
6495 TALLOC_CTX *mem_ctx,
6496 struct policy_handle *handle /* [in] [ref] */,
6497 enum svcctl_StatusLevel info_level /* [in] */,
6498 uint8_t *buffer /* [out] [ref,size_is(offered)] */,
6499 uint32_t offered /* [in] [range(0,8192)] */,
6500 uint32_t *needed /* [out] [ref,range(0,8192)] */,
6501 WERROR *werror)
6502{
6503 struct svcctl_QueryServiceStatusEx r;
6504 NTSTATUS status;
6505
6506 /* In parameters */
6507 r.in.handle = handle;
6508 r.in.info_level = info_level;
6509 r.in.offered = offered;
6510
6511 status = cli->dispatch(cli,
6512 mem_ctx,
6513 &ndr_table_svcctl,
6514 NDR_SVCCTL_QUERYSERVICESTATUSEX,
6515 &r);
6516
6517 if (!NT_STATUS_IS_OK(status)) {
6518 return status;
6519 }
6520
6521 if (NT_STATUS_IS_ERR(status)) {
6522 return status;
6523 }
6524
6525 /* Return variables */
6526 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
6527 *needed = *r.out.needed;
6528
6529 /* Return result */
6530 if (werror) {
6531 *werror = r.out.result;
6532 }
6533
6534 return werror_to_ntstatus(r.out.result);
6535}
6536
6537struct rpccli_EnumServicesStatusExA_state {
6538 struct EnumServicesStatusExA orig;
6539 struct EnumServicesStatusExA tmp;
6540 TALLOC_CTX *out_mem_ctx;
6541 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6542};
6543
6544static void rpccli_EnumServicesStatusExA_done(struct tevent_req *subreq);
6545
6546struct tevent_req *rpccli_EnumServicesStatusExA_send(TALLOC_CTX *mem_ctx,
6547 struct tevent_context *ev,
6548 struct rpc_pipe_client *cli,
6549 struct policy_handle *_scmanager /* [in] [ref] */,
6550 uint32_t _info_level /* [in] */,
6551 uint32_t _type /* [in] */,
6552 enum svcctl_ServiceState _state /* [in] */,
6553 uint8_t *_services /* [out] */,
6554 uint32_t _offered /* [in] */,
6555 uint32_t *_needed /* [out] [ref] */,
6556 uint32_t *_service_returned /* [out] [ref] */,
6557 uint32_t *_resume_handle /* [in,out] [unique] */,
6558 const char **_group_name /* [out] [ref,charset(UTF16)] */)
6559{
6560 struct tevent_req *req;
6561 struct rpccli_EnumServicesStatusExA_state *state;
6562 struct tevent_req *subreq;
6563
6564 req = tevent_req_create(mem_ctx, &state,
6565 struct rpccli_EnumServicesStatusExA_state);
6566 if (req == NULL) {
6567 return NULL;
6568 }
6569 state->out_mem_ctx = NULL;
6570 state->dispatch_recv = cli->dispatch_recv;
6571
6572 /* In parameters */
6573 state->orig.in.scmanager = _scmanager;
6574 state->orig.in.info_level = _info_level;
6575 state->orig.in.type = _type;
6576 state->orig.in.state = _state;
6577 state->orig.in.offered = _offered;
6578 state->orig.in.resume_handle = _resume_handle;
6579
6580 /* Out parameters */
6581 state->orig.out.services = _services;
6582 state->orig.out.needed = _needed;
6583 state->orig.out.service_returned = _service_returned;
6584 state->orig.out.resume_handle = _resume_handle;
6585 state->orig.out.group_name = _group_name;
6586
6587 /* Result */
6588 ZERO_STRUCT(state->orig.out.result);
6589
6590 state->out_mem_ctx = talloc_named_const(state, 0,
6591 "rpccli_EnumServicesStatusExA_out_memory");
6592 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6593 return tevent_req_post(req, ev);
6594 }
6595
6596 /* make a temporary copy, that we pass to the dispatch function */
6597 state->tmp = state->orig;
6598
6599 subreq = cli->dispatch_send(state, ev, cli,
6600 &ndr_table_svcctl,
6601 NDR_ENUMSERVICESSTATUSEXA,
6602 &state->tmp);
6603 if (tevent_req_nomem(subreq, req)) {
6604 return tevent_req_post(req, ev);
6605 }
6606 tevent_req_set_callback(subreq, rpccli_EnumServicesStatusExA_done, req);
6607 return req;
6608}
6609
6610static void rpccli_EnumServicesStatusExA_done(struct tevent_req *subreq)
6611{
6612 struct tevent_req *req = tevent_req_callback_data(
6613 subreq, struct tevent_req);
6614 struct rpccli_EnumServicesStatusExA_state *state = tevent_req_data(
6615 req, struct rpccli_EnumServicesStatusExA_state);
6616 NTSTATUS status;
6617 TALLOC_CTX *mem_ctx;
6618
6619 if (state->out_mem_ctx) {
6620 mem_ctx = state->out_mem_ctx;
6621 } else {
6622 mem_ctx = state;
6623 }
6624
6625 status = state->dispatch_recv(subreq, mem_ctx);
6626 TALLOC_FREE(subreq);
6627 if (!NT_STATUS_IS_OK(status)) {
6628 tevent_req_nterror(req, status);
6629 return;
6630 }
6631
6632 /* Copy out parameters */
6633 memcpy(state->orig.out.services, state->tmp.out.services, (state->tmp.in.offered) * sizeof(*state->orig.out.services));
6634 *state->orig.out.needed = *state->tmp.out.needed;
6635 *state->orig.out.service_returned = *state->tmp.out.service_returned;
6636 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
6637 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
6638 }
6639 *state->orig.out.group_name = *state->tmp.out.group_name;
6640
6641 /* Copy result */
6642 state->orig.out.result = state->tmp.out.result;
6643
6644 /* Reset temporary structure */
6645 ZERO_STRUCT(state->tmp);
6646
6647 tevent_req_done(req);
6648}
6649
6650NTSTATUS rpccli_EnumServicesStatusExA_recv(struct tevent_req *req,
6651 TALLOC_CTX *mem_ctx,
6652 WERROR *result)
6653{
6654 struct rpccli_EnumServicesStatusExA_state *state = tevent_req_data(
6655 req, struct rpccli_EnumServicesStatusExA_state);
6656 NTSTATUS status;
6657
6658 if (tevent_req_is_nterror(req, &status)) {
6659 tevent_req_received(req);
6660 return status;
6661 }
6662
6663 /* Steal possbile out parameters to the callers context */
6664 talloc_steal(mem_ctx, state->out_mem_ctx);
6665
6666 /* Return result */
6667 *result = state->orig.out.result;
6668
6669 tevent_req_received(req);
6670 return NT_STATUS_OK;
6671}
6672
6673NTSTATUS rpccli_EnumServicesStatusExA(struct rpc_pipe_client *cli,
6674 TALLOC_CTX *mem_ctx,
6675 struct policy_handle *scmanager /* [in] [ref] */,
6676 uint32_t info_level /* [in] */,
6677 uint32_t type /* [in] */,
6678 enum svcctl_ServiceState state /* [in] */,
6679 uint8_t *services /* [out] */,
6680 uint32_t offered /* [in] */,
6681 uint32_t *needed /* [out] [ref] */,
6682 uint32_t *service_returned /* [out] [ref] */,
6683 uint32_t *resume_handle /* [in,out] [unique] */,
6684 const char **group_name /* [out] [ref,charset(UTF16)] */,
6685 WERROR *werror)
6686{
6687 struct EnumServicesStatusExA r;
6688 NTSTATUS status;
6689
6690 /* In parameters */
6691 r.in.scmanager = scmanager;
6692 r.in.info_level = info_level;
6693 r.in.type = type;
6694 r.in.state = state;
6695 r.in.offered = offered;
6696 r.in.resume_handle = resume_handle;
6697
6698 status = cli->dispatch(cli,
6699 mem_ctx,
6700 &ndr_table_svcctl,
6701 NDR_ENUMSERVICESSTATUSEXA,
6702 &r);
6703
6704 if (!NT_STATUS_IS_OK(status)) {
6705 return status;
6706 }
6707
6708 if (NT_STATUS_IS_ERR(status)) {
6709 return status;
6710 }
6711
6712 /* Return variables */
6713 memcpy(services, r.out.services, (r.in.offered) * sizeof(*services));
6714 *needed = *r.out.needed;
6715 *service_returned = *r.out.service_returned;
6716 if (resume_handle && r.out.resume_handle) {
6717 *resume_handle = *r.out.resume_handle;
6718 }
6719 *group_name = *r.out.group_name;
6720
6721 /* Return result */
6722 if (werror) {
6723 *werror = r.out.result;
6724 }
6725
6726 return werror_to_ntstatus(r.out.result);
6727}
6728
6729struct rpccli_EnumServicesStatusExW_state {
6730 struct EnumServicesStatusExW orig;
6731 struct EnumServicesStatusExW tmp;
6732 TALLOC_CTX *out_mem_ctx;
6733 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6734};
6735
6736static void rpccli_EnumServicesStatusExW_done(struct tevent_req *subreq);
6737
6738struct tevent_req *rpccli_EnumServicesStatusExW_send(TALLOC_CTX *mem_ctx,
6739 struct tevent_context *ev,
6740 struct rpc_pipe_client *cli,
6741 struct policy_handle *_scmanager /* [in] [ref] */,
6742 uint32_t _info_level /* [in] */,
6743 uint32_t _type /* [in] */,
6744 enum svcctl_ServiceState _state /* [in] */,
6745 uint8_t *_services /* [out] [ref,size_is(offered)] */,
6746 uint32_t _offered /* [in] [range(0,0x40000)] */,
6747 uint32_t *_needed /* [out] [ref,range(0,0x40000)] */,
6748 uint32_t *_service_returned /* [out] [ref,range(0,0x40000)] */,
6749 uint32_t *_resume_handle /* [in,out] [unique,range(0,0x40000)] */,
6750 const char *_group_name /* [in] [unique,charset(UTF16)] */)
6751{
6752 struct tevent_req *req;
6753 struct rpccli_EnumServicesStatusExW_state *state;
6754 struct tevent_req *subreq;
6755
6756 req = tevent_req_create(mem_ctx, &state,
6757 struct rpccli_EnumServicesStatusExW_state);
6758 if (req == NULL) {
6759 return NULL;
6760 }
6761 state->out_mem_ctx = NULL;
6762 state->dispatch_recv = cli->dispatch_recv;
6763
6764 /* In parameters */
6765 state->orig.in.scmanager = _scmanager;
6766 state->orig.in.info_level = _info_level;
6767 state->orig.in.type = _type;
6768 state->orig.in.state = _state;
6769 state->orig.in.offered = _offered;
6770 state->orig.in.resume_handle = _resume_handle;
6771 state->orig.in.group_name = _group_name;
6772
6773 /* Out parameters */
6774 state->orig.out.services = _services;
6775 state->orig.out.needed = _needed;
6776 state->orig.out.service_returned = _service_returned;
6777 state->orig.out.resume_handle = _resume_handle;
6778
6779 /* Result */
6780 ZERO_STRUCT(state->orig.out.result);
6781
6782 state->out_mem_ctx = talloc_named_const(state, 0,
6783 "rpccli_EnumServicesStatusExW_out_memory");
6784 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6785 return tevent_req_post(req, ev);
6786 }
6787
6788 /* make a temporary copy, that we pass to the dispatch function */
6789 state->tmp = state->orig;
6790
6791 subreq = cli->dispatch_send(state, ev, cli,
6792 &ndr_table_svcctl,
6793 NDR_ENUMSERVICESSTATUSEXW,
6794 &state->tmp);
6795 if (tevent_req_nomem(subreq, req)) {
6796 return tevent_req_post(req, ev);
6797 }
6798 tevent_req_set_callback(subreq, rpccli_EnumServicesStatusExW_done, req);
6799 return req;
6800}
6801
6802static void rpccli_EnumServicesStatusExW_done(struct tevent_req *subreq)
6803{
6804 struct tevent_req *req = tevent_req_callback_data(
6805 subreq, struct tevent_req);
6806 struct rpccli_EnumServicesStatusExW_state *state = tevent_req_data(
6807 req, struct rpccli_EnumServicesStatusExW_state);
6808 NTSTATUS status;
6809 TALLOC_CTX *mem_ctx;
6810
6811 if (state->out_mem_ctx) {
6812 mem_ctx = state->out_mem_ctx;
6813 } else {
6814 mem_ctx = state;
6815 }
6816
6817 status = state->dispatch_recv(subreq, mem_ctx);
6818 TALLOC_FREE(subreq);
6819 if (!NT_STATUS_IS_OK(status)) {
6820 tevent_req_nterror(req, status);
6821 return;
6822 }
6823
6824 /* Copy out parameters */
6825 memcpy(state->orig.out.services, state->tmp.out.services, (state->tmp.in.offered) * sizeof(*state->orig.out.services));
6826 *state->orig.out.needed = *state->tmp.out.needed;
6827 *state->orig.out.service_returned = *state->tmp.out.service_returned;
6828 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
6829 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
6830 }
6831
6832 /* Copy result */
6833 state->orig.out.result = state->tmp.out.result;
6834
6835 /* Reset temporary structure */
6836 ZERO_STRUCT(state->tmp);
6837
6838 tevent_req_done(req);
6839}
6840
6841NTSTATUS rpccli_EnumServicesStatusExW_recv(struct tevent_req *req,
6842 TALLOC_CTX *mem_ctx,
6843 WERROR *result)
6844{
6845 struct rpccli_EnumServicesStatusExW_state *state = tevent_req_data(
6846 req, struct rpccli_EnumServicesStatusExW_state);
6847 NTSTATUS status;
6848
6849 if (tevent_req_is_nterror(req, &status)) {
6850 tevent_req_received(req);
6851 return status;
6852 }
6853
6854 /* Steal possbile out parameters to the callers context */
6855 talloc_steal(mem_ctx, state->out_mem_ctx);
6856
6857 /* Return result */
6858 *result = state->orig.out.result;
6859
6860 tevent_req_received(req);
6861 return NT_STATUS_OK;
6862}
6863
6864NTSTATUS rpccli_EnumServicesStatusExW(struct rpc_pipe_client *cli,
6865 TALLOC_CTX *mem_ctx,
6866 struct policy_handle *scmanager /* [in] [ref] */,
6867 uint32_t info_level /* [in] */,
6868 uint32_t type /* [in] */,
6869 enum svcctl_ServiceState state /* [in] */,
6870 uint8_t *services /* [out] [ref,size_is(offered)] */,
6871 uint32_t offered /* [in] [range(0,0x40000)] */,
6872 uint32_t *needed /* [out] [ref,range(0,0x40000)] */,
6873 uint32_t *service_returned /* [out] [ref,range(0,0x40000)] */,
6874 uint32_t *resume_handle /* [in,out] [unique,range(0,0x40000)] */,
6875 const char *group_name /* [in] [unique,charset(UTF16)] */,
6876 WERROR *werror)
6877{
6878 struct EnumServicesStatusExW r;
6879 NTSTATUS status;
6880
6881 /* In parameters */
6882 r.in.scmanager = scmanager;
6883 r.in.info_level = info_level;
6884 r.in.type = type;
6885 r.in.state = state;
6886 r.in.offered = offered;
6887 r.in.resume_handle = resume_handle;
6888 r.in.group_name = group_name;
6889
6890 status = cli->dispatch(cli,
6891 mem_ctx,
6892 &ndr_table_svcctl,
6893 NDR_ENUMSERVICESSTATUSEXW,
6894 &r);
6895
6896 if (!NT_STATUS_IS_OK(status)) {
6897 return status;
6898 }
6899
6900 if (NT_STATUS_IS_ERR(status)) {
6901 return status;
6902 }
6903
6904 /* Return variables */
6905 memcpy(services, r.out.services, (r.in.offered) * sizeof(*services));
6906 *needed = *r.out.needed;
6907 *service_returned = *r.out.service_returned;
6908 if (resume_handle && r.out.resume_handle) {
6909 *resume_handle = *r.out.resume_handle;
6910 }
6911
6912 /* Return result */
6913 if (werror) {
6914 *werror = r.out.result;
6915 }
6916
6917 return werror_to_ntstatus(r.out.result);
6918}
6919
6920struct rpccli_svcctl_SCSendTSMessage_state {
6921 struct svcctl_SCSendTSMessage orig;
6922 struct svcctl_SCSendTSMessage tmp;
6923 TALLOC_CTX *out_mem_ctx;
6924 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6925};
6926
6927static void rpccli_svcctl_SCSendTSMessage_done(struct tevent_req *subreq);
6928
6929struct tevent_req *rpccli_svcctl_SCSendTSMessage_send(TALLOC_CTX *mem_ctx,
6930 struct tevent_context *ev,
6931 struct rpc_pipe_client *cli)
6932{
6933 struct tevent_req *req;
6934 struct rpccli_svcctl_SCSendTSMessage_state *state;
6935 struct tevent_req *subreq;
6936
6937 req = tevent_req_create(mem_ctx, &state,
6938 struct rpccli_svcctl_SCSendTSMessage_state);
6939 if (req == NULL) {
6940 return NULL;
6941 }
6942 state->out_mem_ctx = NULL;
6943 state->dispatch_recv = cli->dispatch_recv;
6944
6945 /* In parameters */
6946
6947 /* Out parameters */
6948
6949 /* Result */
6950 ZERO_STRUCT(state->orig.out.result);
6951
6952 /* make a temporary copy, that we pass to the dispatch function */
6953 state->tmp = state->orig;
6954
6955 subreq = cli->dispatch_send(state, ev, cli,
6956 &ndr_table_svcctl,
6957 NDR_SVCCTL_SCSENDTSMESSAGE,
6958 &state->tmp);
6959 if (tevent_req_nomem(subreq, req)) {
6960 return tevent_req_post(req, ev);
6961 }
6962 tevent_req_set_callback(subreq, rpccli_svcctl_SCSendTSMessage_done, req);
6963 return req;
6964}
6965
6966static void rpccli_svcctl_SCSendTSMessage_done(struct tevent_req *subreq)
6967{
6968 struct tevent_req *req = tevent_req_callback_data(
6969 subreq, struct tevent_req);
6970 struct rpccli_svcctl_SCSendTSMessage_state *state = tevent_req_data(
6971 req, struct rpccli_svcctl_SCSendTSMessage_state);
6972 NTSTATUS status;
6973 TALLOC_CTX *mem_ctx;
6974
6975 if (state->out_mem_ctx) {
6976 mem_ctx = state->out_mem_ctx;
6977 } else {
6978 mem_ctx = state;
6979 }
6980
6981 status = state->dispatch_recv(subreq, mem_ctx);
6982 TALLOC_FREE(subreq);
6983 if (!NT_STATUS_IS_OK(status)) {
6984 tevent_req_nterror(req, status);
6985 return;
6986 }
6987
6988 /* Copy out parameters */
6989
6990 /* Copy result */
6991 state->orig.out.result = state->tmp.out.result;
6992
6993 /* Reset temporary structure */
6994 ZERO_STRUCT(state->tmp);
6995
6996 tevent_req_done(req);
6997}
6998
6999NTSTATUS rpccli_svcctl_SCSendTSMessage_recv(struct tevent_req *req,
7000 TALLOC_CTX *mem_ctx,
7001 WERROR *result)
7002{
7003 struct rpccli_svcctl_SCSendTSMessage_state *state = tevent_req_data(
7004 req, struct rpccli_svcctl_SCSendTSMessage_state);
7005 NTSTATUS status;
7006
7007 if (tevent_req_is_nterror(req, &status)) {
7008 tevent_req_received(req);
7009 return status;
7010 }
7011
7012 /* Steal possbile out parameters to the callers context */
7013 talloc_steal(mem_ctx, state->out_mem_ctx);
7014
7015 /* Return result */
7016 *result = state->orig.out.result;
7017
7018 tevent_req_received(req);
7019 return NT_STATUS_OK;
7020}
7021
7022NTSTATUS rpccli_svcctl_SCSendTSMessage(struct rpc_pipe_client *cli,
7023 TALLOC_CTX *mem_ctx,
7024 WERROR *werror)
7025{
7026 struct svcctl_SCSendTSMessage r;
7027 NTSTATUS status;
7028
7029 /* In parameters */
7030
7031 status = cli->dispatch(cli,
7032 mem_ctx,
7033 &ndr_table_svcctl,
7034 NDR_SVCCTL_SCSENDTSMESSAGE,
7035 &r);
7036
7037 if (!NT_STATUS_IS_OK(status)) {
7038 return status;
7039 }
7040
7041 if (NT_STATUS_IS_ERR(status)) {
7042 return status;
7043 }
7044
7045 /* Return variables */
7046
7047 /* Return result */
7048 if (werror) {
7049 *werror = r.out.result;
7050 }
7051
7052 return werror_to_ntstatus(r.out.result);
7053}
7054
Note: See TracBrowser for help on using the repository browser.