?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-winreg: make QueryValue pass RPC-WINREG test again.
[Samba/bb.git] / librpc / gen_ndr / cli_srvsvc.c
blob045dd3c5a87175d00b07a44a818557dc07979542
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_srvsvc.h"
8
9 struct rpccli_srvsvc_NetCharDevEnum_state {
10 struct srvsvc_NetCharDevEnum orig;
11 struct srvsvc_NetCharDevEnum tmp;
12 TALLOC_CTX *out_mem_ctx;
13 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14 };
15
16 static void rpccli_srvsvc_NetCharDevEnum_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_srvsvc_NetCharDevEnum_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli,
21 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
22 struct srvsvc_NetCharDevInfoCtr *_info_ctr /* [in,out] [ref] */,
23 uint32_t _max_buffer /* [in] */,
24 uint32_t *_totalentries /* [out] [ref] */,
25 uint32_t *_resume_handle /* [in,out] [unique] */)
26 {
27 struct tevent_req *req;
28 struct rpccli_srvsvc_NetCharDevEnum_state *state;
29 struct tevent_req *subreq;
30
31 req = tevent_req_create(mem_ctx, &state,
32 struct rpccli_srvsvc_NetCharDevEnum_state);
33 if (req == NULL) {
34 return NULL;
35 }
36 state->out_mem_ctx = NULL;
37 state->dispatch_recv = cli->dispatch_recv;
38
39 /* In parameters */
40 state->orig.in.server_unc = _server_unc;
41 state->orig.in.info_ctr = _info_ctr;
42 state->orig.in.max_buffer = _max_buffer;
43 state->orig.in.resume_handle = _resume_handle;
44
45 /* Out parameters */
46 state->orig.out.info_ctr = _info_ctr;
47 state->orig.out.totalentries = _totalentries;
48 state->orig.out.resume_handle = _resume_handle;
49
50 /* Result */
51 ZERO_STRUCT(state->orig.out.result);
52
53 state->out_mem_ctx = talloc_named_const(state, 0,
54 "rpccli_srvsvc_NetCharDevEnum_out_memory");
55 if (tevent_req_nomem(state->out_mem_ctx, req)) {
56 return tevent_req_post(req, ev);
57 }
58
59 /* make a temporary copy, that we pass to the dispatch function */
60 state->tmp = state->orig;
61
62 subreq = cli->dispatch_send(state, ev, cli,
63 &ndr_table_srvsvc,
64 NDR_SRVSVC_NETCHARDEVENUM,
65 &state->tmp);
66 if (tevent_req_nomem(subreq, req)) {
67 return tevent_req_post(req, ev);
68 }
69 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevEnum_done, req);
70 return req;
71 }
72
73 static void rpccli_srvsvc_NetCharDevEnum_done(struct tevent_req *subreq)
74 {
75 struct tevent_req *req = tevent_req_callback_data(
76 subreq, struct tevent_req);
77 struct rpccli_srvsvc_NetCharDevEnum_state *state = tevent_req_data(
78 req, struct rpccli_srvsvc_NetCharDevEnum_state);
79 NTSTATUS status;
80 TALLOC_CTX *mem_ctx;
81
82 if (state->out_mem_ctx) {
83 mem_ctx = state->out_mem_ctx;
84 } else {
85 mem_ctx = state;
86 }
87
88 status = state->dispatch_recv(subreq, mem_ctx);
89 TALLOC_FREE(subreq);
90 if (!NT_STATUS_IS_OK(status)) {
91 tevent_req_nterror(req, status);
92 return;
93 }
94
95 /* Copy out parameters */
96 *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
97 *state->orig.out.totalentries = *state->tmp.out.totalentries;
98 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
99 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
100 }
101
102 /* Copy result */
103 state->orig.out.result = state->tmp.out.result;
104
105 /* Reset temporary structure */
106 ZERO_STRUCT(state->tmp);
107
108 tevent_req_done(req);
109 }
110
111 NTSTATUS rpccli_srvsvc_NetCharDevEnum_recv(struct tevent_req *req,
112 TALLOC_CTX *mem_ctx,
113 WERROR *result)
114 {
115 struct rpccli_srvsvc_NetCharDevEnum_state *state = tevent_req_data(
116 req, struct rpccli_srvsvc_NetCharDevEnum_state);
117 NTSTATUS status;
118
119 if (tevent_req_is_nterror(req, &status)) {
120 tevent_req_received(req);
121 return status;
122 }
123
124 /* Steal possbile out parameters to the callers context */
125 talloc_steal(mem_ctx, state->out_mem_ctx);
126
127 /* Return result */
128 *result = state->orig.out.result;
129
130 tevent_req_received(req);
131 return NT_STATUS_OK;
132 }
133
134 NTSTATUS rpccli_srvsvc_NetCharDevEnum(struct rpc_pipe_client *cli,
135 TALLOC_CTX *mem_ctx,
136 const char *server_unc /* [in] [unique,charset(UTF16)] */,
137 struct srvsvc_NetCharDevInfoCtr *info_ctr /* [in,out] [ref] */,
138 uint32_t max_buffer /* [in] */,
139 uint32_t *totalentries /* [out] [ref] */,
140 uint32_t *resume_handle /* [in,out] [unique] */,
141 WERROR *werror)
142 {
143 struct srvsvc_NetCharDevEnum r;
144 NTSTATUS status;
145
146 /* In parameters */
147 r.in.server_unc = server_unc;
148 r.in.info_ctr = info_ctr;
149 r.in.max_buffer = max_buffer;
150 r.in.resume_handle = resume_handle;
151
152 status = cli->dispatch(cli,
153 mem_ctx,
154 &ndr_table_srvsvc,
155 NDR_SRVSVC_NETCHARDEVENUM,
156 &r);
157
158 if (!NT_STATUS_IS_OK(status)) {
159 return status;
160 }
161
162 if (NT_STATUS_IS_ERR(status)) {
163 return status;
164 }
165
166 /* Return variables */
167 *info_ctr = *r.out.info_ctr;
168 *totalentries = *r.out.totalentries;
169 if (resume_handle && r.out.resume_handle) {
170 *resume_handle = *r.out.resume_handle;
171 }
172
173 /* Return result */
174 if (werror) {
175 *werror = r.out.result;
176 }
177
178 return werror_to_ntstatus(r.out.result);
179 }
180
181 struct rpccli_srvsvc_NetCharDevGetInfo_state {
182 struct srvsvc_NetCharDevGetInfo orig;
183 struct srvsvc_NetCharDevGetInfo tmp;
184 TALLOC_CTX *out_mem_ctx;
185 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
186 };
187
188 static void rpccli_srvsvc_NetCharDevGetInfo_done(struct tevent_req *subreq);
189
190 struct tevent_req *rpccli_srvsvc_NetCharDevGetInfo_send(TALLOC_CTX *mem_ctx,
191 struct tevent_context *ev,
192 struct rpc_pipe_client *cli,
193 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
194 const char *_device_name /* [in] [charset(UTF16)] */,
195 uint32_t _level /* [in] */,
196 union srvsvc_NetCharDevInfo *_info /* [out] [ref,switch_is(level)] */)
197 {
198 struct tevent_req *req;
199 struct rpccli_srvsvc_NetCharDevGetInfo_state *state;
200 struct tevent_req *subreq;
201
202 req = tevent_req_create(mem_ctx, &state,
203 struct rpccli_srvsvc_NetCharDevGetInfo_state);
204 if (req == NULL) {
205 return NULL;
206 }
207 state->out_mem_ctx = NULL;
208 state->dispatch_recv = cli->dispatch_recv;
209
210 /* In parameters */
211 state->orig.in.server_unc = _server_unc;
212 state->orig.in.device_name = _device_name;
213 state->orig.in.level = _level;
214
215 /* Out parameters */
216 state->orig.out.info = _info;
217
218 /* Result */
219 ZERO_STRUCT(state->orig.out.result);
220
221 state->out_mem_ctx = talloc_named_const(state, 0,
222 "rpccli_srvsvc_NetCharDevGetInfo_out_memory");
223 if (tevent_req_nomem(state->out_mem_ctx, req)) {
224 return tevent_req_post(req, ev);
225 }
226
227 /* make a temporary copy, that we pass to the dispatch function */
228 state->tmp = state->orig;
229
230 subreq = cli->dispatch_send(state, ev, cli,
231 &ndr_table_srvsvc,
232 NDR_SRVSVC_NETCHARDEVGETINFO,
233 &state->tmp);
234 if (tevent_req_nomem(subreq, req)) {
235 return tevent_req_post(req, ev);
236 }
237 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevGetInfo_done, req);
238 return req;
239 }
240
241 static void rpccli_srvsvc_NetCharDevGetInfo_done(struct tevent_req *subreq)
242 {
243 struct tevent_req *req = tevent_req_callback_data(
244 subreq, struct tevent_req);
245 struct rpccli_srvsvc_NetCharDevGetInfo_state *state = tevent_req_data(
246 req, struct rpccli_srvsvc_NetCharDevGetInfo_state);
247 NTSTATUS status;
248 TALLOC_CTX *mem_ctx;
249
250 if (state->out_mem_ctx) {
251 mem_ctx = state->out_mem_ctx;
252 } else {
253 mem_ctx = state;
254 }
255
256 status = state->dispatch_recv(subreq, mem_ctx);
257 TALLOC_FREE(subreq);
258 if (!NT_STATUS_IS_OK(status)) {
259 tevent_req_nterror(req, status);
260 return;
261 }
262
263 /* Copy out parameters */
264 *state->orig.out.info = *state->tmp.out.info;
265
266 /* Copy result */
267 state->orig.out.result = state->tmp.out.result;
268
269 /* Reset temporary structure */
270 ZERO_STRUCT(state->tmp);
271
272 tevent_req_done(req);
273 }
274
275 NTSTATUS rpccli_srvsvc_NetCharDevGetInfo_recv(struct tevent_req *req,
276 TALLOC_CTX *mem_ctx,
277 WERROR *result)
278 {
279 struct rpccli_srvsvc_NetCharDevGetInfo_state *state = tevent_req_data(
280 req, struct rpccli_srvsvc_NetCharDevGetInfo_state);
281 NTSTATUS status;
282
283 if (tevent_req_is_nterror(req, &status)) {
284 tevent_req_received(req);
285 return status;
286 }
287
288 /* Steal possbile out parameters to the callers context */
289 talloc_steal(mem_ctx, state->out_mem_ctx);
290
291 /* Return result */
292 *result = state->orig.out.result;
293
294 tevent_req_received(req);
295 return NT_STATUS_OK;
296 }
297
298 NTSTATUS rpccli_srvsvc_NetCharDevGetInfo(struct rpc_pipe_client *cli,
299 TALLOC_CTX *mem_ctx,
300 const char *server_unc /* [in] [unique,charset(UTF16)] */,
301 const char *device_name /* [in] [charset(UTF16)] */,
302 uint32_t level /* [in] */,
303 union srvsvc_NetCharDevInfo *info /* [out] [ref,switch_is(level)] */,
304 WERROR *werror)
305 {
306 struct srvsvc_NetCharDevGetInfo r;
307 NTSTATUS status;
308
309 /* In parameters */
310 r.in.server_unc = server_unc;
311 r.in.device_name = device_name;
312 r.in.level = level;
313
314 status = cli->dispatch(cli,
315 mem_ctx,
316 &ndr_table_srvsvc,
317 NDR_SRVSVC_NETCHARDEVGETINFO,
318 &r);
319
320 if (!NT_STATUS_IS_OK(status)) {
321 return status;
322 }
323
324 if (NT_STATUS_IS_ERR(status)) {
325 return status;
326 }
327
328 /* Return variables */
329 *info = *r.out.info;
330
331 /* Return result */
332 if (werror) {
333 *werror = r.out.result;
334 }
335
336 return werror_to_ntstatus(r.out.result);
337 }
338
339 struct rpccli_srvsvc_NetCharDevControl_state {
340 struct srvsvc_NetCharDevControl orig;
341 struct srvsvc_NetCharDevControl tmp;
342 TALLOC_CTX *out_mem_ctx;
343 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
344 };
345
346 static void rpccli_srvsvc_NetCharDevControl_done(struct tevent_req *subreq);
347
348 struct tevent_req *rpccli_srvsvc_NetCharDevControl_send(TALLOC_CTX *mem_ctx,
349 struct tevent_context *ev,
350 struct rpc_pipe_client *cli,
351 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
352 const char *_device_name /* [in] [charset(UTF16)] */,
353 uint32_t _opcode /* [in] */)
354 {
355 struct tevent_req *req;
356 struct rpccli_srvsvc_NetCharDevControl_state *state;
357 struct tevent_req *subreq;
358
359 req = tevent_req_create(mem_ctx, &state,
360 struct rpccli_srvsvc_NetCharDevControl_state);
361 if (req == NULL) {
362 return NULL;
363 }
364 state->out_mem_ctx = NULL;
365 state->dispatch_recv = cli->dispatch_recv;
366
367 /* In parameters */
368 state->orig.in.server_unc = _server_unc;
369 state->orig.in.device_name = _device_name;
370 state->orig.in.opcode = _opcode;
371
372 /* Out parameters */
373
374 /* Result */
375 ZERO_STRUCT(state->orig.out.result);
376
377 /* make a temporary copy, that we pass to the dispatch function */
378 state->tmp = state->orig;
379
380 subreq = cli->dispatch_send(state, ev, cli,
381 &ndr_table_srvsvc,
382 NDR_SRVSVC_NETCHARDEVCONTROL,
383 &state->tmp);
384 if (tevent_req_nomem(subreq, req)) {
385 return tevent_req_post(req, ev);
386 }
387 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevControl_done, req);
388 return req;
389 }
390
391 static void rpccli_srvsvc_NetCharDevControl_done(struct tevent_req *subreq)
392 {
393 struct tevent_req *req = tevent_req_callback_data(
394 subreq, struct tevent_req);
395 struct rpccli_srvsvc_NetCharDevControl_state *state = tevent_req_data(
396 req, struct rpccli_srvsvc_NetCharDevControl_state);
397 NTSTATUS status;
398 TALLOC_CTX *mem_ctx;
399
400 if (state->out_mem_ctx) {
401 mem_ctx = state->out_mem_ctx;
402 } else {
403 mem_ctx = state;
404 }
405
406 status = state->dispatch_recv(subreq, mem_ctx);
407 TALLOC_FREE(subreq);
408 if (!NT_STATUS_IS_OK(status)) {
409 tevent_req_nterror(req, status);
410 return;
411 }
412
413 /* Copy out parameters */
414
415 /* Copy result */
416 state->orig.out.result = state->tmp.out.result;
417
418 /* Reset temporary structure */
419 ZERO_STRUCT(state->tmp);
420
421 tevent_req_done(req);
422 }
423
424 NTSTATUS rpccli_srvsvc_NetCharDevControl_recv(struct tevent_req *req,
425 TALLOC_CTX *mem_ctx,
426 WERROR *result)
427 {
428 struct rpccli_srvsvc_NetCharDevControl_state *state = tevent_req_data(
429 req, struct rpccli_srvsvc_NetCharDevControl_state);
430 NTSTATUS status;
431
432 if (tevent_req_is_nterror(req, &status)) {
433 tevent_req_received(req);
434 return status;
435 }
436
437 /* Steal possbile out parameters to the callers context */
438 talloc_steal(mem_ctx, state->out_mem_ctx);
439
440 /* Return result */
441 *result = state->orig.out.result;
442
443 tevent_req_received(req);
444 return NT_STATUS_OK;
445 }
446
447 NTSTATUS rpccli_srvsvc_NetCharDevControl(struct rpc_pipe_client *cli,
448 TALLOC_CTX *mem_ctx,
449 const char *server_unc /* [in] [unique,charset(UTF16)] */,
450 const char *device_name /* [in] [charset(UTF16)] */,
451 uint32_t opcode /* [in] */,
452 WERROR *werror)
453 {
454 struct srvsvc_NetCharDevControl r;
455 NTSTATUS status;
456
457 /* In parameters */
458 r.in.server_unc = server_unc;
459 r.in.device_name = device_name;
460 r.in.opcode = opcode;
461
462 status = cli->dispatch(cli,
463 mem_ctx,
464 &ndr_table_srvsvc,
465 NDR_SRVSVC_NETCHARDEVCONTROL,
466 &r);
467
468 if (!NT_STATUS_IS_OK(status)) {
469 return status;
470 }
471
472 if (NT_STATUS_IS_ERR(status)) {
473 return status;
474 }
475
476 /* Return variables */
477
478 /* Return result */
479 if (werror) {
480 *werror = r.out.result;
481 }
482
483 return werror_to_ntstatus(r.out.result);
484 }
485
486 struct rpccli_srvsvc_NetCharDevQEnum_state {
487 struct srvsvc_NetCharDevQEnum orig;
488 struct srvsvc_NetCharDevQEnum tmp;
489 TALLOC_CTX *out_mem_ctx;
490 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
491 };
492
493 static void rpccli_srvsvc_NetCharDevQEnum_done(struct tevent_req *subreq);
494
495 struct tevent_req *rpccli_srvsvc_NetCharDevQEnum_send(TALLOC_CTX *mem_ctx,
496 struct tevent_context *ev,
497 struct rpc_pipe_client *cli,
498 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
499 const char *_user /* [in] [unique,charset(UTF16)] */,
500 struct srvsvc_NetCharDevQInfoCtr *_info_ctr /* [in,out] [ref] */,
501 uint32_t _max_buffer /* [in] */,
502 uint32_t *_totalentries /* [out] [ref] */,
503 uint32_t *_resume_handle /* [in,out] [unique] */)
504 {
505 struct tevent_req *req;
506 struct rpccli_srvsvc_NetCharDevQEnum_state *state;
507 struct tevent_req *subreq;
508
509 req = tevent_req_create(mem_ctx, &state,
510 struct rpccli_srvsvc_NetCharDevQEnum_state);
511 if (req == NULL) {
512 return NULL;
513 }
514 state->out_mem_ctx = NULL;
515 state->dispatch_recv = cli->dispatch_recv;
516
517 /* In parameters */
518 state->orig.in.server_unc = _server_unc;
519 state->orig.in.user = _user;
520 state->orig.in.info_ctr = _info_ctr;
521 state->orig.in.max_buffer = _max_buffer;
522 state->orig.in.resume_handle = _resume_handle;
523
524 /* Out parameters */
525 state->orig.out.info_ctr = _info_ctr;
526 state->orig.out.totalentries = _totalentries;
527 state->orig.out.resume_handle = _resume_handle;
528
529 /* Result */
530 ZERO_STRUCT(state->orig.out.result);
531
532 state->out_mem_ctx = talloc_named_const(state, 0,
533 "rpccli_srvsvc_NetCharDevQEnum_out_memory");
534 if (tevent_req_nomem(state->out_mem_ctx, req)) {
535 return tevent_req_post(req, ev);
536 }
537
538 /* make a temporary copy, that we pass to the dispatch function */
539 state->tmp = state->orig;
540
541 subreq = cli->dispatch_send(state, ev, cli,
542 &ndr_table_srvsvc,
543 NDR_SRVSVC_NETCHARDEVQENUM,
544 &state->tmp);
545 if (tevent_req_nomem(subreq, req)) {
546 return tevent_req_post(req, ev);
547 }
548 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevQEnum_done, req);
549 return req;
550 }
551
552 static void rpccli_srvsvc_NetCharDevQEnum_done(struct tevent_req *subreq)
553 {
554 struct tevent_req *req = tevent_req_callback_data(
555 subreq, struct tevent_req);
556 struct rpccli_srvsvc_NetCharDevQEnum_state *state = tevent_req_data(
557 req, struct rpccli_srvsvc_NetCharDevQEnum_state);
558 NTSTATUS status;
559 TALLOC_CTX *mem_ctx;
560
561 if (state->out_mem_ctx) {
562 mem_ctx = state->out_mem_ctx;
563 } else {
564 mem_ctx = state;
565 }
566
567 status = state->dispatch_recv(subreq, mem_ctx);
568 TALLOC_FREE(subreq);
569 if (!NT_STATUS_IS_OK(status)) {
570 tevent_req_nterror(req, status);
571 return;
572 }
573
574 /* Copy out parameters */
575 *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
576 *state->orig.out.totalentries = *state->tmp.out.totalentries;
577 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
578 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
579 }
580
581 /* Copy result */
582 state->orig.out.result = state->tmp.out.result;
583
584 /* Reset temporary structure */
585 ZERO_STRUCT(state->tmp);
586
587 tevent_req_done(req);
588 }
589
590 NTSTATUS rpccli_srvsvc_NetCharDevQEnum_recv(struct tevent_req *req,
591 TALLOC_CTX *mem_ctx,
592 WERROR *result)
593 {
594 struct rpccli_srvsvc_NetCharDevQEnum_state *state = tevent_req_data(
595 req, struct rpccli_srvsvc_NetCharDevQEnum_state);
596 NTSTATUS status;
597
598 if (tevent_req_is_nterror(req, &status)) {
599 tevent_req_received(req);
600 return status;
601 }
602
603 /* Steal possbile out parameters to the callers context */
604 talloc_steal(mem_ctx, state->out_mem_ctx);
605
606 /* Return result */
607 *result = state->orig.out.result;
608
609 tevent_req_received(req);
610 return NT_STATUS_OK;
611 }
612
613 NTSTATUS rpccli_srvsvc_NetCharDevQEnum(struct rpc_pipe_client *cli,
614 TALLOC_CTX *mem_ctx,
615 const char *server_unc /* [in] [unique,charset(UTF16)] */,
616 const char *user /* [in] [unique,charset(UTF16)] */,
617 struct srvsvc_NetCharDevQInfoCtr *info_ctr /* [in,out] [ref] */,
618 uint32_t max_buffer /* [in] */,
619 uint32_t *totalentries /* [out] [ref] */,
620 uint32_t *resume_handle /* [in,out] [unique] */,
621 WERROR *werror)
622 {
623 struct srvsvc_NetCharDevQEnum r;
624 NTSTATUS status;
625
626 /* In parameters */
627 r.in.server_unc = server_unc;
628 r.in.user = user;
629 r.in.info_ctr = info_ctr;
630 r.in.max_buffer = max_buffer;
631 r.in.resume_handle = resume_handle;
632
633 status = cli->dispatch(cli,
634 mem_ctx,
635 &ndr_table_srvsvc,
636 NDR_SRVSVC_NETCHARDEVQENUM,
637 &r);
638
639 if (!NT_STATUS_IS_OK(status)) {
640 return status;
641 }
642
643 if (NT_STATUS_IS_ERR(status)) {
644 return status;
645 }
646
647 /* Return variables */
648 *info_ctr = *r.out.info_ctr;
649 *totalentries = *r.out.totalentries;
650 if (resume_handle && r.out.resume_handle) {
651 *resume_handle = *r.out.resume_handle;
652 }
653
654 /* Return result */
655 if (werror) {
656 *werror = r.out.result;
657 }
658
659 return werror_to_ntstatus(r.out.result);
660 }
661
662 struct rpccli_srvsvc_NetCharDevQGetInfo_state {
663 struct srvsvc_NetCharDevQGetInfo orig;
664 struct srvsvc_NetCharDevQGetInfo tmp;
665 TALLOC_CTX *out_mem_ctx;
666 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
667 };
668
669 static void rpccli_srvsvc_NetCharDevQGetInfo_done(struct tevent_req *subreq);
670
671 struct tevent_req *rpccli_srvsvc_NetCharDevQGetInfo_send(TALLOC_CTX *mem_ctx,
672 struct tevent_context *ev,
673 struct rpc_pipe_client *cli,
674 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
675 const char *_queue_name /* [in] [charset(UTF16)] */,
676 const char *_user /* [in] [charset(UTF16)] */,
677 uint32_t _level /* [in] */,
678 union srvsvc_NetCharDevQInfo *_info /* [out] [ref,switch_is(level)] */)
679 {
680 struct tevent_req *req;
681 struct rpccli_srvsvc_NetCharDevQGetInfo_state *state;
682 struct tevent_req *subreq;
683
684 req = tevent_req_create(mem_ctx, &state,
685 struct rpccli_srvsvc_NetCharDevQGetInfo_state);
686 if (req == NULL) {
687 return NULL;
688 }
689 state->out_mem_ctx = NULL;
690 state->dispatch_recv = cli->dispatch_recv;
691
692 /* In parameters */
693 state->orig.in.server_unc = _server_unc;
694 state->orig.in.queue_name = _queue_name;
695 state->orig.in.user = _user;
696 state->orig.in.level = _level;
697
698 /* Out parameters */
699 state->orig.out.info = _info;
700
701 /* Result */
702 ZERO_STRUCT(state->orig.out.result);
703
704 state->out_mem_ctx = talloc_named_const(state, 0,
705 "rpccli_srvsvc_NetCharDevQGetInfo_out_memory");
706 if (tevent_req_nomem(state->out_mem_ctx, req)) {
707 return tevent_req_post(req, ev);
708 }
709
710 /* make a temporary copy, that we pass to the dispatch function */
711 state->tmp = state->orig;
712
713 subreq = cli->dispatch_send(state, ev, cli,
714 &ndr_table_srvsvc,
715 NDR_SRVSVC_NETCHARDEVQGETINFO,
716 &state->tmp);
717 if (tevent_req_nomem(subreq, req)) {
718 return tevent_req_post(req, ev);
719 }
720 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevQGetInfo_done, req);
721 return req;
722 }
723
724 static void rpccli_srvsvc_NetCharDevQGetInfo_done(struct tevent_req *subreq)
725 {
726 struct tevent_req *req = tevent_req_callback_data(
727 subreq, struct tevent_req);
728 struct rpccli_srvsvc_NetCharDevQGetInfo_state *state = tevent_req_data(
729 req, struct rpccli_srvsvc_NetCharDevQGetInfo_state);
730 NTSTATUS status;
731 TALLOC_CTX *mem_ctx;
732
733 if (state->out_mem_ctx) {
734 mem_ctx = state->out_mem_ctx;
735 } else {
736 mem_ctx = state;
737 }
738
739 status = state->dispatch_recv(subreq, mem_ctx);
740 TALLOC_FREE(subreq);
741 if (!NT_STATUS_IS_OK(status)) {
742 tevent_req_nterror(req, status);
743 return;
744 }
745
746 /* Copy out parameters */
747 *state->orig.out.info = *state->tmp.out.info;
748
749 /* Copy result */
750 state->orig.out.result = state->tmp.out.result;
751
752 /* Reset temporary structure */
753 ZERO_STRUCT(state->tmp);
754
755 tevent_req_done(req);
756 }
757
758 NTSTATUS rpccli_srvsvc_NetCharDevQGetInfo_recv(struct tevent_req *req,
759 TALLOC_CTX *mem_ctx,
760 WERROR *result)
761 {
762 struct rpccli_srvsvc_NetCharDevQGetInfo_state *state = tevent_req_data(
763 req, struct rpccli_srvsvc_NetCharDevQGetInfo_state);
764 NTSTATUS status;
765
766 if (tevent_req_is_nterror(req, &status)) {
767 tevent_req_received(req);
768 return status;
769 }
770
771 /* Steal possbile out parameters to the callers context */
772 talloc_steal(mem_ctx, state->out_mem_ctx);
773
774 /* Return result */
775 *result = state->orig.out.result;
776
777 tevent_req_received(req);
778 return NT_STATUS_OK;
779 }
780
781 NTSTATUS rpccli_srvsvc_NetCharDevQGetInfo(struct rpc_pipe_client *cli,
782 TALLOC_CTX *mem_ctx,
783 const char *server_unc /* [in] [unique,charset(UTF16)] */,
784 const char *queue_name /* [in] [charset(UTF16)] */,
785 const char *user /* [in] [charset(UTF16)] */,
786 uint32_t level /* [in] */,
787 union srvsvc_NetCharDevQInfo *info /* [out] [ref,switch_is(level)] */,
788 WERROR *werror)
789 {
790 struct srvsvc_NetCharDevQGetInfo r;
791 NTSTATUS status;
792
793 /* In parameters */
794 r.in.server_unc = server_unc;
795 r.in.queue_name = queue_name;
796 r.in.user = user;
797 r.in.level = level;
798
799 status = cli->dispatch(cli,
800 mem_ctx,
801 &ndr_table_srvsvc,
802 NDR_SRVSVC_NETCHARDEVQGETINFO,
803 &r);
804
805 if (!NT_STATUS_IS_OK(status)) {
806 return status;
807 }
808
809 if (NT_STATUS_IS_ERR(status)) {
810 return status;
811 }
812
813 /* Return variables */
814 *info = *r.out.info;
815
816 /* Return result */
817 if (werror) {
818 *werror = r.out.result;
819 }
820
821 return werror_to_ntstatus(r.out.result);
822 }
823
824 struct rpccli_srvsvc_NetCharDevQSetInfo_state {
825 struct srvsvc_NetCharDevQSetInfo orig;
826 struct srvsvc_NetCharDevQSetInfo tmp;
827 TALLOC_CTX *out_mem_ctx;
828 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
829 };
830
831 static void rpccli_srvsvc_NetCharDevQSetInfo_done(struct tevent_req *subreq);
832
833 struct tevent_req *rpccli_srvsvc_NetCharDevQSetInfo_send(TALLOC_CTX *mem_ctx,
834 struct tevent_context *ev,
835 struct rpc_pipe_client *cli,
836 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
837 const char *_queue_name /* [in] [charset(UTF16)] */,
838 uint32_t _level /* [in] */,
839 union srvsvc_NetCharDevQInfo _info /* [in] [switch_is(level)] */,
840 uint32_t *_parm_error /* [in,out] [unique] */)
841 {
842 struct tevent_req *req;
843 struct rpccli_srvsvc_NetCharDevQSetInfo_state *state;
844 struct tevent_req *subreq;
845
846 req = tevent_req_create(mem_ctx, &state,
847 struct rpccli_srvsvc_NetCharDevQSetInfo_state);
848 if (req == NULL) {
849 return NULL;
850 }
851 state->out_mem_ctx = NULL;
852 state->dispatch_recv = cli->dispatch_recv;
853
854 /* In parameters */
855 state->orig.in.server_unc = _server_unc;
856 state->orig.in.queue_name = _queue_name;
857 state->orig.in.level = _level;
858 state->orig.in.info = _info;
859 state->orig.in.parm_error = _parm_error;
860
861 /* Out parameters */
862 state->orig.out.parm_error = _parm_error;
863
864 /* Result */
865 ZERO_STRUCT(state->orig.out.result);
866
867 state->out_mem_ctx = talloc_named_const(state, 0,
868 "rpccli_srvsvc_NetCharDevQSetInfo_out_memory");
869 if (tevent_req_nomem(state->out_mem_ctx, req)) {
870 return tevent_req_post(req, ev);
871 }
872
873 /* make a temporary copy, that we pass to the dispatch function */
874 state->tmp = state->orig;
875
876 subreq = cli->dispatch_send(state, ev, cli,
877 &ndr_table_srvsvc,
878 NDR_SRVSVC_NETCHARDEVQSETINFO,
879 &state->tmp);
880 if (tevent_req_nomem(subreq, req)) {
881 return tevent_req_post(req, ev);
882 }
883 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevQSetInfo_done, req);
884 return req;
885 }
886
887 static void rpccli_srvsvc_NetCharDevQSetInfo_done(struct tevent_req *subreq)
888 {
889 struct tevent_req *req = tevent_req_callback_data(
890 subreq, struct tevent_req);
891 struct rpccli_srvsvc_NetCharDevQSetInfo_state *state = tevent_req_data(
892 req, struct rpccli_srvsvc_NetCharDevQSetInfo_state);
893 NTSTATUS status;
894 TALLOC_CTX *mem_ctx;
895
896 if (state->out_mem_ctx) {
897 mem_ctx = state->out_mem_ctx;
898 } else {
899 mem_ctx = state;
900 }
901
902 status = state->dispatch_recv(subreq, mem_ctx);
903 TALLOC_FREE(subreq);
904 if (!NT_STATUS_IS_OK(status)) {
905 tevent_req_nterror(req, status);
906 return;
907 }
908
909 /* Copy out parameters */
910 if (state->orig.out.parm_error && state->tmp.out.parm_error) {
911 *state->orig.out.parm_error = *state->tmp.out.parm_error;
912 }
913
914 /* Copy result */
915 state->orig.out.result = state->tmp.out.result;
916
917 /* Reset temporary structure */
918 ZERO_STRUCT(state->tmp);
919
920 tevent_req_done(req);
921 }
922
923 NTSTATUS rpccli_srvsvc_NetCharDevQSetInfo_recv(struct tevent_req *req,
924 TALLOC_CTX *mem_ctx,
925 WERROR *result)
926 {
927 struct rpccli_srvsvc_NetCharDevQSetInfo_state *state = tevent_req_data(
928 req, struct rpccli_srvsvc_NetCharDevQSetInfo_state);
929 NTSTATUS status;
930
931 if (tevent_req_is_nterror(req, &status)) {
932 tevent_req_received(req);
933 return status;
934 }
935
936 /* Steal possbile out parameters to the callers context */
937 talloc_steal(mem_ctx, state->out_mem_ctx);
938
939 /* Return result */
940 *result = state->orig.out.result;
941
942 tevent_req_received(req);
943 return NT_STATUS_OK;
944 }
945
946 NTSTATUS rpccli_srvsvc_NetCharDevQSetInfo(struct rpc_pipe_client *cli,
947 TALLOC_CTX *mem_ctx,
948 const char *server_unc /* [in] [unique,charset(UTF16)] */,
949 const char *queue_name /* [in] [charset(UTF16)] */,
950 uint32_t level /* [in] */,
951 union srvsvc_NetCharDevQInfo info /* [in] [switch_is(level)] */,
952 uint32_t *parm_error /* [in,out] [unique] */,
953 WERROR *werror)
954 {
955 struct srvsvc_NetCharDevQSetInfo r;
956 NTSTATUS status;
957
958 /* In parameters */
959 r.in.server_unc = server_unc;
960 r.in.queue_name = queue_name;
961 r.in.level = level;
962 r.in.info = info;
963 r.in.parm_error = parm_error;
964
965 status = cli->dispatch(cli,
966 mem_ctx,
967 &ndr_table_srvsvc,
968 NDR_SRVSVC_NETCHARDEVQSETINFO,
969 &r);
970
971 if (!NT_STATUS_IS_OK(status)) {
972 return status;
973 }
974
975 if (NT_STATUS_IS_ERR(status)) {
976 return status;
977 }
978
979 /* Return variables */
980 if (parm_error && r.out.parm_error) {
981 *parm_error = *r.out.parm_error;
982 }
983
984 /* Return result */
985 if (werror) {
986 *werror = r.out.result;
987 }
988
989 return werror_to_ntstatus(r.out.result);
990 }
991
992 struct rpccli_srvsvc_NetCharDevQPurge_state {
993 struct srvsvc_NetCharDevQPurge orig;
994 struct srvsvc_NetCharDevQPurge tmp;
995 TALLOC_CTX *out_mem_ctx;
996 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
997 };
998
999 static void rpccli_srvsvc_NetCharDevQPurge_done(struct tevent_req *subreq);
1000
1001 struct tevent_req *rpccli_srvsvc_NetCharDevQPurge_send(TALLOC_CTX *mem_ctx,
1002 struct tevent_context *ev,
1003 struct rpc_pipe_client *cli,
1004 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1005 const char *_queue_name /* [in] [charset(UTF16)] */)
1006 {
1007 struct tevent_req *req;
1008 struct rpccli_srvsvc_NetCharDevQPurge_state *state;
1009 struct tevent_req *subreq;
1010
1011 req = tevent_req_create(mem_ctx, &state,
1012 struct rpccli_srvsvc_NetCharDevQPurge_state);
1013 if (req == NULL) {
1014 return NULL;
1015 }
1016 state->out_mem_ctx = NULL;
1017 state->dispatch_recv = cli->dispatch_recv;
1018
1019 /* In parameters */
1020 state->orig.in.server_unc = _server_unc;
1021 state->orig.in.queue_name = _queue_name;
1022
1023 /* Out parameters */
1024
1025 /* Result */
1026 ZERO_STRUCT(state->orig.out.result);
1027
1028 /* make a temporary copy, that we pass to the dispatch function */
1029 state->tmp = state->orig;
1030
1031 subreq = cli->dispatch_send(state, ev, cli,
1032 &ndr_table_srvsvc,
1033 NDR_SRVSVC_NETCHARDEVQPURGE,
1034 &state->tmp);
1035 if (tevent_req_nomem(subreq, req)) {
1036 return tevent_req_post(req, ev);
1037 }
1038 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevQPurge_done, req);
1039 return req;
1040 }
1041
1042 static void rpccli_srvsvc_NetCharDevQPurge_done(struct tevent_req *subreq)
1043 {
1044 struct tevent_req *req = tevent_req_callback_data(
1045 subreq, struct tevent_req);
1046 struct rpccli_srvsvc_NetCharDevQPurge_state *state = tevent_req_data(
1047 req, struct rpccli_srvsvc_NetCharDevQPurge_state);
1048 NTSTATUS status;
1049 TALLOC_CTX *mem_ctx;
1050
1051 if (state->out_mem_ctx) {
1052 mem_ctx = state->out_mem_ctx;
1053 } else {
1054 mem_ctx = state;
1055 }
1056
1057 status = state->dispatch_recv(subreq, mem_ctx);
1058 TALLOC_FREE(subreq);
1059 if (!NT_STATUS_IS_OK(status)) {
1060 tevent_req_nterror(req, status);
1061 return;
1062 }
1063
1064 /* Copy out parameters */
1065
1066 /* Copy result */
1067 state->orig.out.result = state->tmp.out.result;
1068
1069 /* Reset temporary structure */
1070 ZERO_STRUCT(state->tmp);
1071
1072 tevent_req_done(req);
1073 }
1074
1075 NTSTATUS rpccli_srvsvc_NetCharDevQPurge_recv(struct tevent_req *req,
1076 TALLOC_CTX *mem_ctx,
1077 WERROR *result)
1078 {
1079 struct rpccli_srvsvc_NetCharDevQPurge_state *state = tevent_req_data(
1080 req, struct rpccli_srvsvc_NetCharDevQPurge_state);
1081 NTSTATUS status;
1082
1083 if (tevent_req_is_nterror(req, &status)) {
1084 tevent_req_received(req);
1085 return status;
1086 }
1087
1088 /* Steal possbile out parameters to the callers context */
1089 talloc_steal(mem_ctx, state->out_mem_ctx);
1090
1091 /* Return result */
1092 *result = state->orig.out.result;
1093
1094 tevent_req_received(req);
1095 return NT_STATUS_OK;
1096 }
1097
1098 NTSTATUS rpccli_srvsvc_NetCharDevQPurge(struct rpc_pipe_client *cli,
1099 TALLOC_CTX *mem_ctx,
1100 const char *server_unc /* [in] [unique,charset(UTF16)] */,
1101 const char *queue_name /* [in] [charset(UTF16)] */,
1102 WERROR *werror)
1103 {
1104 struct srvsvc_NetCharDevQPurge r;
1105 NTSTATUS status;
1106
1107 /* In parameters */
1108 r.in.server_unc = server_unc;
1109 r.in.queue_name = queue_name;
1110
1111 status = cli->dispatch(cli,
1112 mem_ctx,
1113 &ndr_table_srvsvc,
1114 NDR_SRVSVC_NETCHARDEVQPURGE,
1115 &r);
1116
1117 if (!NT_STATUS_IS_OK(status)) {
1118 return status;
1119 }
1120
1121 if (NT_STATUS_IS_ERR(status)) {
1122 return status;
1123 }
1124
1125 /* Return variables */
1126
1127 /* Return result */
1128 if (werror) {
1129 *werror = r.out.result;
1130 }
1131
1132 return werror_to_ntstatus(r.out.result);
1133 }
1134
1135 struct rpccli_srvsvc_NetCharDevQPurgeSelf_state {
1136 struct srvsvc_NetCharDevQPurgeSelf orig;
1137 struct srvsvc_NetCharDevQPurgeSelf tmp;
1138 TALLOC_CTX *out_mem_ctx;
1139 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1140 };
1141
1142 static void rpccli_srvsvc_NetCharDevQPurgeSelf_done(struct tevent_req *subreq);
1143
1144 struct tevent_req *rpccli_srvsvc_NetCharDevQPurgeSelf_send(TALLOC_CTX *mem_ctx,
1145 struct tevent_context *ev,
1146 struct rpc_pipe_client *cli,
1147 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1148 const char *_queue_name /* [in] [charset(UTF16)] */,
1149 const char *_computer_name /* [in] [charset(UTF16)] */)
1150 {
1151 struct tevent_req *req;
1152 struct rpccli_srvsvc_NetCharDevQPurgeSelf_state *state;
1153 struct tevent_req *subreq;
1154
1155 req = tevent_req_create(mem_ctx, &state,
1156 struct rpccli_srvsvc_NetCharDevQPurgeSelf_state);
1157 if (req == NULL) {
1158 return NULL;
1159 }
1160 state->out_mem_ctx = NULL;
1161 state->dispatch_recv = cli->dispatch_recv;
1162
1163 /* In parameters */
1164 state->orig.in.server_unc = _server_unc;
1165 state->orig.in.queue_name = _queue_name;
1166 state->orig.in.computer_name = _computer_name;
1167
1168 /* Out parameters */
1169
1170 /* Result */
1171 ZERO_STRUCT(state->orig.out.result);
1172
1173 /* make a temporary copy, that we pass to the dispatch function */
1174 state->tmp = state->orig;
1175
1176 subreq = cli->dispatch_send(state, ev, cli,
1177 &ndr_table_srvsvc,
1178 NDR_SRVSVC_NETCHARDEVQPURGESELF,
1179 &state->tmp);
1180 if (tevent_req_nomem(subreq, req)) {
1181 return tevent_req_post(req, ev);
1182 }
1183 tevent_req_set_callback(subreq, rpccli_srvsvc_NetCharDevQPurgeSelf_done, req);
1184 return req;
1185 }
1186
1187 static void rpccli_srvsvc_NetCharDevQPurgeSelf_done(struct tevent_req *subreq)
1188 {
1189 struct tevent_req *req = tevent_req_callback_data(
1190 subreq, struct tevent_req);
1191 struct rpccli_srvsvc_NetCharDevQPurgeSelf_state *state = tevent_req_data(
1192 req, struct rpccli_srvsvc_NetCharDevQPurgeSelf_state);
1193 NTSTATUS status;
1194 TALLOC_CTX *mem_ctx;
1195
1196 if (state->out_mem_ctx) {
1197 mem_ctx = state->out_mem_ctx;
1198 } else {
1199 mem_ctx = state;
1200 }
1201
1202 status = state->dispatch_recv(subreq, mem_ctx);
1203 TALLOC_FREE(subreq);
1204 if (!NT_STATUS_IS_OK(status)) {
1205 tevent_req_nterror(req, status);
1206 return;
1207 }
1208
1209 /* Copy out parameters */
1210
1211 /* Copy result */
1212 state->orig.out.result = state->tmp.out.result;
1213
1214 /* Reset temporary structure */
1215 ZERO_STRUCT(state->tmp);
1216
1217 tevent_req_done(req);
1218 }
1219
1220 NTSTATUS rpccli_srvsvc_NetCharDevQPurgeSelf_recv(struct tevent_req *req,
1221 TALLOC_CTX *mem_ctx,
1222 WERROR *result)
1223 {
1224 struct rpccli_srvsvc_NetCharDevQPurgeSelf_state *state = tevent_req_data(
1225 req, struct rpccli_srvsvc_NetCharDevQPurgeSelf_state);
1226 NTSTATUS status;
1227
1228 if (tevent_req_is_nterror(req, &status)) {
1229 tevent_req_received(req);
1230 return status;
1231 }
1232
1233 /* Steal possbile out parameters to the callers context */
1234 talloc_steal(mem_ctx, state->out_mem_ctx);
1235
1236 /* Return result */
1237 *result = state->orig.out.result;
1238
1239 tevent_req_received(req);
1240 return NT_STATUS_OK;
1241 }
1242
1243 NTSTATUS rpccli_srvsvc_NetCharDevQPurgeSelf(struct rpc_pipe_client *cli,
1244 TALLOC_CTX *mem_ctx,
1245 const char *server_unc /* [in] [unique,charset(UTF16)] */,
1246 const char *queue_name /* [in] [charset(UTF16)] */,
1247 const char *computer_name /* [in] [charset(UTF16)] */,
1248 WERROR *werror)
1249 {
1250 struct srvsvc_NetCharDevQPurgeSelf r;
1251 NTSTATUS status;
1252
1253 /* In parameters */
1254 r.in.server_unc = server_unc;
1255 r.in.queue_name = queue_name;
1256 r.in.computer_name = computer_name;
1257
1258 status = cli->dispatch(cli,
1259 mem_ctx,
1260 &ndr_table_srvsvc,
1261 NDR_SRVSVC_NETCHARDEVQPURGESELF,
1262 &r);
1263
1264 if (!NT_STATUS_IS_OK(status)) {
1265 return status;
1266 }
1267
1268 if (NT_STATUS_IS_ERR(status)) {
1269 return status;
1270 }
1271
1272 /* Return variables */
1273
1274 /* Return result */
1275 if (werror) {
1276 *werror = r.out.result;
1277 }
1278
1279 return werror_to_ntstatus(r.out.result);
1280 }
1281
1282 struct rpccli_srvsvc_NetConnEnum_state {
1283 struct srvsvc_NetConnEnum orig;
1284 struct srvsvc_NetConnEnum tmp;
1285 TALLOC_CTX *out_mem_ctx;
1286 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1287 };
1288
1289 static void rpccli_srvsvc_NetConnEnum_done(struct tevent_req *subreq);
1290
1291 struct tevent_req *rpccli_srvsvc_NetConnEnum_send(TALLOC_CTX *mem_ctx,
1292 struct tevent_context *ev,
1293 struct rpc_pipe_client *cli,
1294 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1295 const char *_path /* [in] [unique,charset(UTF16)] */,
1296 struct srvsvc_NetConnInfoCtr *_info_ctr /* [in,out] [ref] */,
1297 uint32_t _max_buffer /* [in] */,
1298 uint32_t *_totalentries /* [out] [ref] */,
1299 uint32_t *_resume_handle /* [in,out] [unique] */)
1300 {
1301 struct tevent_req *req;
1302 struct rpccli_srvsvc_NetConnEnum_state *state;
1303 struct tevent_req *subreq;
1304
1305 req = tevent_req_create(mem_ctx, &state,
1306 struct rpccli_srvsvc_NetConnEnum_state);
1307 if (req == NULL) {
1308 return NULL;
1309 }
1310 state->out_mem_ctx = NULL;
1311 state->dispatch_recv = cli->dispatch_recv;
1312
1313 /* In parameters */
1314 state->orig.in.server_unc = _server_unc;
1315 state->orig.in.path = _path;
1316 state->orig.in.info_ctr = _info_ctr;
1317 state->orig.in.max_buffer = _max_buffer;
1318 state->orig.in.resume_handle = _resume_handle;
1319
1320 /* Out parameters */
1321 state->orig.out.info_ctr = _info_ctr;
1322 state->orig.out.totalentries = _totalentries;
1323 state->orig.out.resume_handle = _resume_handle;
1324
1325 /* Result */
1326 ZERO_STRUCT(state->orig.out.result);
1327
1328 state->out_mem_ctx = talloc_named_const(state, 0,
1329 "rpccli_srvsvc_NetConnEnum_out_memory");
1330 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1331 return tevent_req_post(req, ev);
1332 }
1333
1334 /* make a temporary copy, that we pass to the dispatch function */
1335 state->tmp = state->orig;
1336
1337 subreq = cli->dispatch_send(state, ev, cli,
1338 &ndr_table_srvsvc,
1339 NDR_SRVSVC_NETCONNENUM,
1340 &state->tmp);
1341 if (tevent_req_nomem(subreq, req)) {
1342 return tevent_req_post(req, ev);
1343 }
1344 tevent_req_set_callback(subreq, rpccli_srvsvc_NetConnEnum_done, req);
1345 return req;
1346 }
1347
1348 static void rpccli_srvsvc_NetConnEnum_done(struct tevent_req *subreq)
1349 {
1350 struct tevent_req *req = tevent_req_callback_data(
1351 subreq, struct tevent_req);
1352 struct rpccli_srvsvc_NetConnEnum_state *state = tevent_req_data(
1353 req, struct rpccli_srvsvc_NetConnEnum_state);
1354 NTSTATUS status;
1355 TALLOC_CTX *mem_ctx;
1356
1357 if (state->out_mem_ctx) {
1358 mem_ctx = state->out_mem_ctx;
1359 } else {
1360 mem_ctx = state;
1361 }
1362
1363 status = state->dispatch_recv(subreq, mem_ctx);
1364 TALLOC_FREE(subreq);
1365 if (!NT_STATUS_IS_OK(status)) {
1366 tevent_req_nterror(req, status);
1367 return;
1368 }
1369
1370 /* Copy out parameters */
1371 *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
1372 *state->orig.out.totalentries = *state->tmp.out.totalentries;
1373 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
1374 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
1375 }
1376
1377 /* Copy result */
1378 state->orig.out.result = state->tmp.out.result;
1379
1380 /* Reset temporary structure */
1381 ZERO_STRUCT(state->tmp);
1382
1383 tevent_req_done(req);
1384 }
1385
1386 NTSTATUS rpccli_srvsvc_NetConnEnum_recv(struct tevent_req *req,
1387 TALLOC_CTX *mem_ctx,
1388 WERROR *result)
1389 {
1390 struct rpccli_srvsvc_NetConnEnum_state *state = tevent_req_data(
1391 req, struct rpccli_srvsvc_NetConnEnum_state);
1392 NTSTATUS status;
1393
1394 if (tevent_req_is_nterror(req, &status)) {
1395 tevent_req_received(req);
1396 return status;
1397 }
1398
1399 /* Steal possbile out parameters to the callers context */
1400 talloc_steal(mem_ctx, state->out_mem_ctx);
1401
1402 /* Return result */
1403 *result = state->orig.out.result;
1404
1405 tevent_req_received(req);
1406 return NT_STATUS_OK;
1407 }
1408
1409 NTSTATUS rpccli_srvsvc_NetConnEnum(struct rpc_pipe_client *cli,
1410 TALLOC_CTX *mem_ctx,
1411 const char *server_unc /* [in] [unique,charset(UTF16)] */,
1412 const char *path /* [in] [unique,charset(UTF16)] */,
1413 struct srvsvc_NetConnInfoCtr *info_ctr /* [in,out] [ref] */,
1414 uint32_t max_buffer /* [in] */,
1415 uint32_t *totalentries /* [out] [ref] */,
1416 uint32_t *resume_handle /* [in,out] [unique] */,
1417 WERROR *werror)
1418 {
1419 struct srvsvc_NetConnEnum r;
1420 NTSTATUS status;
1421
1422 /* In parameters */
1423 r.in.server_unc = server_unc;
1424 r.in.path = path;
1425 r.in.info_ctr = info_ctr;
1426 r.in.max_buffer = max_buffer;
1427 r.in.resume_handle = resume_handle;
1428
1429 status = cli->dispatch(cli,
1430 mem_ctx,
1431 &ndr_table_srvsvc,
1432 NDR_SRVSVC_NETCONNENUM,
1433 &r);
1434
1435 if (!NT_STATUS_IS_OK(status)) {
1436 return status;
1437 }
1438
1439 if (NT_STATUS_IS_ERR(status)) {
1440 return status;
1441 }
1442
1443 /* Return variables */
1444 *info_ctr = *r.out.info_ctr;
1445 *totalentries = *r.out.totalentries;
1446 if (resume_handle && r.out.resume_handle) {
1447 *resume_handle = *r.out.resume_handle;
1448 }
1449
1450 /* Return result */
1451 if (werror) {
1452 *werror = r.out.result;
1453 }
1454
1455 return werror_to_ntstatus(r.out.result);
1456 }
1457
1458 struct rpccli_srvsvc_NetFileEnum_state {
1459 struct srvsvc_NetFileEnum orig;
1460 struct srvsvc_NetFileEnum tmp;
1461 TALLOC_CTX *out_mem_ctx;
1462 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1463 };
1464
1465 static void rpccli_srvsvc_NetFileEnum_done(struct tevent_req *subreq);
1466
1467 struct tevent_req *rpccli_srvsvc_NetFileEnum_send(TALLOC_CTX *mem_ctx,
1468 struct tevent_context *ev,
1469 struct rpc_pipe_client *cli,
1470 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1471 const char *_path /* [in] [unique,charset(UTF16)] */,
1472 const char *_user /* [in] [unique,charset(UTF16)] */,
1473 struct srvsvc_NetFileInfoCtr *_info_ctr /* [in,out] [ref] */,
1474 uint32_t _max_buffer /* [in] */,
1475 uint32_t *_totalentries /* [out] [ref] */,
1476 uint32_t *_resume_handle /* [in,out] [unique] */)
1477 {
1478 struct tevent_req *req;
1479 struct rpccli_srvsvc_NetFileEnum_state *state;
1480 struct tevent_req *subreq;
1481
1482 req = tevent_req_create(mem_ctx, &state,
1483 struct rpccli_srvsvc_NetFileEnum_state);
1484 if (req == NULL) {
1485 return NULL;
1486 }
1487 state->out_mem_ctx = NULL;
1488 state->dispatch_recv = cli->dispatch_recv;
1489
1490 /* In parameters */
1491 state->orig.in.server_unc = _server_unc;
1492 state->orig.in.path = _path;
1493 state->orig.in.user = _user;
1494 state->orig.in.info_ctr = _info_ctr;
1495 state->orig.in.max_buffer = _max_buffer;
1496 state->orig.in.resume_handle = _resume_handle;
1497
1498 /* Out parameters */
1499 state->orig.out.info_ctr = _info_ctr;
1500 state->orig.out.totalentries = _totalentries;
1501 state->orig.out.resume_handle = _resume_handle;
1502
1503 /* Result */
1504 ZERO_STRUCT(state->orig.out.result);
1505
1506 state->out_mem_ctx = talloc_named_const(state, 0,
1507 "rpccli_srvsvc_NetFileEnum_out_memory");
1508 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1509 return tevent_req_post(req, ev);
1510 }
1511
1512 /* make a temporary copy, that we pass to the dispatch function */
1513 state->tmp = state->orig;
1514
1515 subreq = cli->dispatch_send(state, ev, cli,
1516 &ndr_table_srvsvc,
1517 NDR_SRVSVC_NETFILEENUM,
1518 &state->tmp);
1519 if (tevent_req_nomem(subreq, req)) {
1520 return tevent_req_post(req, ev);
1521 }
1522 tevent_req_set_callback(subreq, rpccli_srvsvc_NetFileEnum_done, req);
1523 return req;
1524 }
1525
1526 static void rpccli_srvsvc_NetFileEnum_done(struct tevent_req *subreq)
1527 {
1528 struct tevent_req *req = tevent_req_callback_data(
1529 subreq, struct tevent_req);
1530 struct rpccli_srvsvc_NetFileEnum_state *state = tevent_req_data(
1531 req, struct rpccli_srvsvc_NetFileEnum_state);
1532 NTSTATUS status;
1533 TALLOC_CTX *mem_ctx;
1534
1535 if (state->out_mem_ctx) {
1536 mem_ctx = state->out_mem_ctx;
1537 } else {
1538 mem_ctx = state;
1539 }
1540
1541 status = state->dispatch_recv(subreq, mem_ctx);
1542 TALLOC_FREE(subreq);
1543 if (!NT_STATUS_IS_OK(status)) {
1544 tevent_req_nterror(req, status);
1545 return;
1546 }
1547
1548 /* Copy out parameters */
1549 *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
1550 *state->orig.out.totalentries = *state->tmp.out.totalentries;
1551 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
1552 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
1553 }
1554
1555 /* Copy result */
1556 state->orig.out.result = state->tmp.out.result;
1557
1558 /* Reset temporary structure */
1559 ZERO_STRUCT(state->tmp);
1560
1561 tevent_req_done(req);
1562 }
1563
1564 NTSTATUS rpccli_srvsvc_NetFileEnum_recv(struct tevent_req *req,
1565 TALLOC_CTX *mem_ctx,
1566 WERROR *result)
1567 {
1568 struct rpccli_srvsvc_NetFileEnum_state *state = tevent_req_data(
1569 req, struct rpccli_srvsvc_NetFileEnum_state);
1570 NTSTATUS status;
1571
1572 if (tevent_req_is_nterror(req, &status)) {
1573 tevent_req_received(req);
1574 return status;
1575 }
1576
1577 /* Steal possbile out parameters to the callers context */
1578 talloc_steal(mem_ctx, state->out_mem_ctx);
1579
1580 /* Return result */
1581 *result = state->orig.out.result;
1582
1583 tevent_req_received(req);
1584 return NT_STATUS_OK;
1585 }
1586
1587 NTSTATUS rpccli_srvsvc_NetFileEnum(struct rpc_pipe_client *cli,
1588 TALLOC_CTX *mem_ctx,
1589 const char *server_unc /* [in] [unique,charset(UTF16)] */,
1590 const char *path /* [in] [unique,charset(UTF16)] */,
1591 const char *user /* [in] [unique,charset(UTF16)] */,
1592 struct srvsvc_NetFileInfoCtr *info_ctr /* [in,out] [ref] */,
1593 uint32_t max_buffer /* [in] */,
1594 uint32_t *totalentries /* [out] [ref] */,
1595 uint32_t *resume_handle /* [in,out] [unique] */,
1596 WERROR *werror)
1597 {
1598 struct srvsvc_NetFileEnum r;
1599 NTSTATUS status;
1600
1601 /* In parameters */
1602 r.in.server_unc = server_unc;
1603 r.in.path = path;
1604 r.in.user = user;
1605 r.in.info_ctr = info_ctr;
1606 r.in.max_buffer = max_buffer;
1607 r.in.resume_handle = resume_handle;
1608
1609 status = cli->dispatch(cli,
1610 mem_ctx,
1611 &ndr_table_srvsvc,
1612 NDR_SRVSVC_NETFILEENUM,
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 *info_ctr = *r.out.info_ctr;
1625 *totalentries = *r.out.totalentries;
1626 if (resume_handle && r.out.resume_handle) {
1627 *resume_handle = *r.out.resume_handle;
1628 }
1629
1630 /* Return result */
1631 if (werror) {
1632 *werror = r.out.result;
1633 }
1634
1635 return werror_to_ntstatus(r.out.result);
1636 }
1637
1638 struct rpccli_srvsvc_NetFileGetInfo_state {
1639 struct srvsvc_NetFileGetInfo orig;
1640 struct srvsvc_NetFileGetInfo tmp;
1641 TALLOC_CTX *out_mem_ctx;
1642 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1643 };
1644
1645 static void rpccli_srvsvc_NetFileGetInfo_done(struct tevent_req *subreq);
1646
1647 struct tevent_req *rpccli_srvsvc_NetFileGetInfo_send(TALLOC_CTX *mem_ctx,
1648 struct tevent_context *ev,
1649 struct rpc_pipe_client *cli,
1650 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1651 uint32_t _fid /* [in] */,
1652 uint32_t _level /* [in] */,
1653 union srvsvc_NetFileInfo *_info /* [out] [ref,switch_is(level)] */)
1654 {
1655 struct tevent_req *req;
1656 struct rpccli_srvsvc_NetFileGetInfo_state *state;
1657 struct tevent_req *subreq;
1658
1659 req = tevent_req_create(mem_ctx, &state,
1660 struct rpccli_srvsvc_NetFileGetInfo_state);
1661 if (req == NULL) {
1662 return NULL;
1663 }
1664 state->out_mem_ctx = NULL;
1665 state->dispatch_recv = cli->dispatch_recv;
1666
1667 /* In parameters */
1668 state->orig.in.server_unc = _server_unc;
1669 state->orig.in.fid = _fid;
1670 state->orig.in.level = _level;
1671
1672 /* Out parameters */
1673 state->orig.out.info = _info;
1674
1675 /* Result */
1676 ZERO_STRUCT(state->orig.out.result);
1677
1678 state->out_mem_ctx = talloc_named_const(state, 0,
1679 "rpccli_srvsvc_NetFileGetInfo_out_memory");
1680 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1681 return tevent_req_post(req, ev);
1682 }
1683
1684 /* make a temporary copy, that we pass to the dispatch function */
1685 state->tmp = state->orig;
1686
1687 subreq = cli->dispatch_send(state, ev, cli,
1688 &ndr_table_srvsvc,
1689 NDR_SRVSVC_NETFILEGETINFO,
1690 &state->tmp);
1691 if (tevent_req_nomem(subreq, req)) {
1692 return tevent_req_post(req, ev);
1693 }
1694 tevent_req_set_callback(subreq, rpccli_srvsvc_NetFileGetInfo_done, req);
1695 return req;
1696 }
1697
1698 static void rpccli_srvsvc_NetFileGetInfo_done(struct tevent_req *subreq)
1699 {
1700 struct tevent_req *req = tevent_req_callback_data(
1701 subreq, struct tevent_req);
1702 struct rpccli_srvsvc_NetFileGetInfo_state *state = tevent_req_data(
1703 req, struct rpccli_srvsvc_NetFileGetInfo_state);
1704 NTSTATUS status;
1705 TALLOC_CTX *mem_ctx;
1706
1707 if (state->out_mem_ctx) {
1708 mem_ctx = state->out_mem_ctx;
1709 } else {
1710 mem_ctx = state;
1711 }
1712
1713 status = state->dispatch_recv(subreq, mem_ctx);
1714 TALLOC_FREE(subreq);
1715 if (!NT_STATUS_IS_OK(status)) {
1716 tevent_req_nterror(req, status);
1717 return;
1718 }
1719
1720 /* Copy out parameters */
1721 *state->orig.out.info = *state->tmp.out.info;
1722
1723 /* Copy result */
1724 state->orig.out.result = state->tmp.out.result;
1725
1726 /* Reset temporary structure */
1727 ZERO_STRUCT(state->tmp);
1728
1729 tevent_req_done(req);
1730 }
1731
1732 NTSTATUS rpccli_srvsvc_NetFileGetInfo_recv(struct tevent_req *req,
1733 TALLOC_CTX *mem_ctx,
1734 WERROR *result)
1735 {
1736 struct rpccli_srvsvc_NetFileGetInfo_state *state = tevent_req_data(
1737 req, struct rpccli_srvsvc_NetFileGetInfo_state);
1738 NTSTATUS status;
1739
1740 if (tevent_req_is_nterror(req, &status)) {
1741 tevent_req_received(req);
1742 return status;
1743 }
1744
1745 /* Steal possbile out parameters to the callers context */
1746 talloc_steal(mem_ctx, state->out_mem_ctx);
1747
1748 /* Return result */
1749 *result = state->orig.out.result;
1750
1751 tevent_req_received(req);
1752 return NT_STATUS_OK;
1753 }
1754
1755 NTSTATUS rpccli_srvsvc_NetFileGetInfo(struct rpc_pipe_client *cli,
1756 TALLOC_CTX *mem_ctx,
1757 const char *server_unc /* [in] [unique,charset(UTF16)] */,
1758 uint32_t fid /* [in] */,
1759 uint32_t level /* [in] */,
1760 union srvsvc_NetFileInfo *info /* [out] [ref,switch_is(level)] */,
1761 WERROR *werror)
1762 {
1763 struct srvsvc_NetFileGetInfo r;
1764 NTSTATUS status;
1765
1766 /* In parameters */
1767 r.in.server_unc = server_unc;
1768 r.in.fid = fid;
1769 r.in.level = level;
1770
1771 status = cli->dispatch(cli,
1772 mem_ctx,
1773 &ndr_table_srvsvc,
1774 NDR_SRVSVC_NETFILEGETINFO,
1775 &r);
1776
1777 if (!NT_STATUS_IS_OK(status)) {
1778 return status;
1779 }
1780
1781 if (NT_STATUS_IS_ERR(status)) {
1782 return status;
1783 }
1784
1785 /* Return variables */
1786 *info = *r.out.info;
1787
1788 /* Return result */
1789 if (werror) {
1790 *werror = r.out.result;
1791 }
1792
1793 return werror_to_ntstatus(r.out.result);
1794 }
1795
1796 struct rpccli_srvsvc_NetFileClose_state {
1797 struct srvsvc_NetFileClose orig;
1798 struct srvsvc_NetFileClose tmp;
1799 TALLOC_CTX *out_mem_ctx;
1800 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1801 };
1802
1803 static void rpccli_srvsvc_NetFileClose_done(struct tevent_req *subreq);
1804
1805 struct tevent_req *rpccli_srvsvc_NetFileClose_send(TALLOC_CTX *mem_ctx,
1806 struct tevent_context *ev,
1807 struct rpc_pipe_client *cli,
1808 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1809 uint32_t _fid /* [in] */)
1810 {
1811 struct tevent_req *req;
1812 struct rpccli_srvsvc_NetFileClose_state *state;
1813 struct tevent_req *subreq;
1814
1815 req = tevent_req_create(mem_ctx, &state,
1816 struct rpccli_srvsvc_NetFileClose_state);
1817 if (req == NULL) {
1818 return NULL;
1819 }
1820 state->out_mem_ctx = NULL;
1821 state->dispatch_recv = cli->dispatch_recv;
1822
1823 /* In parameters */
1824 state->orig.in.server_unc = _server_unc;
1825 state->orig.in.fid = _fid;
1826
1827 /* Out parameters */
1828
1829 /* Result */
1830 ZERO_STRUCT(state->orig.out.result);
1831
1832 /* make a temporary copy, that we pass to the dispatch function */
1833 state->tmp = state->orig;
1834
1835 subreq = cli->dispatch_send(state, ev, cli,
1836 &ndr_table_srvsvc,
1837 NDR_SRVSVC_NETFILECLOSE,
1838 &state->tmp);
1839 if (tevent_req_nomem(subreq, req)) {
1840 return tevent_req_post(req, ev);
1841 }
1842 tevent_req_set_callback(subreq, rpccli_srvsvc_NetFileClose_done, req);
1843 return req;
1844 }
1845
1846 static void rpccli_srvsvc_NetFileClose_done(struct tevent_req *subreq)
1847 {
1848 struct tevent_req *req = tevent_req_callback_data(
1849 subreq, struct tevent_req);
1850 struct rpccli_srvsvc_NetFileClose_state *state = tevent_req_data(
1851 req, struct rpccli_srvsvc_NetFileClose_state);
1852 NTSTATUS status;
1853 TALLOC_CTX *mem_ctx;
1854
1855 if (state->out_mem_ctx) {
1856 mem_ctx = state->out_mem_ctx;
1857 } else {
1858 mem_ctx = state;
1859 }
1860
1861 status = state->dispatch_recv(subreq, mem_ctx);
1862 TALLOC_FREE(subreq);
1863 if (!NT_STATUS_IS_OK(status)) {
1864 tevent_req_nterror(req, status);
1865 return;
1866 }
1867
1868 /* Copy out parameters */
1869
1870 /* Copy result */
1871 state->orig.out.result = state->tmp.out.result;
1872
1873 /* Reset temporary structure */
1874 ZERO_STRUCT(state->tmp);
1875
1876 tevent_req_done(req);
1877 }
1878
1879 NTSTATUS rpccli_srvsvc_NetFileClose_recv(struct tevent_req *req,
1880 TALLOC_CTX *mem_ctx,
1881 WERROR *result)
1882 {
1883 struct rpccli_srvsvc_NetFileClose_state *state = tevent_req_data(
1884 req, struct rpccli_srvsvc_NetFileClose_state);
1885 NTSTATUS status;
1886
1887 if (tevent_req_is_nterror(req, &status)) {
1888 tevent_req_received(req);
1889 return status;
1890 }
1891
1892 /* Steal possbile out parameters to the callers context */
1893 talloc_steal(mem_ctx, state->out_mem_ctx);
1894
1895 /* Return result */
1896 *result = state->orig.out.result;
1897
1898 tevent_req_received(req);
1899 return NT_STATUS_OK;
1900 }
1901
1902 NTSTATUS rpccli_srvsvc_NetFileClose(struct rpc_pipe_client *cli,
1903 TALLOC_CTX *mem_ctx,
1904 const char *server_unc /* [in] [unique,charset(UTF16)] */,
1905 uint32_t fid /* [in] */,
1906 WERROR *werror)
1907 {
1908 struct srvsvc_NetFileClose r;
1909 NTSTATUS status;
1910
1911 /* In parameters */
1912 r.in.server_unc = server_unc;
1913 r.in.fid = fid;
1914
1915 status = cli->dispatch(cli,
1916 mem_ctx,
1917 &ndr_table_srvsvc,
1918 NDR_SRVSVC_NETFILECLOSE,
1919 &r);
1920
1921 if (!NT_STATUS_IS_OK(status)) {
1922 return status;
1923 }
1924
1925 if (NT_STATUS_IS_ERR(status)) {
1926 return status;
1927 }
1928
1929 /* Return variables */
1930
1931 /* Return result */
1932 if (werror) {
1933 *werror = r.out.result;
1934 }
1935
1936 return werror_to_ntstatus(r.out.result);
1937 }
1938
1939 struct rpccli_srvsvc_NetSessEnum_state {
1940 struct srvsvc_NetSessEnum orig;
1941 struct srvsvc_NetSessEnum tmp;
1942 TALLOC_CTX *out_mem_ctx;
1943 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1944 };
1945
1946 static void rpccli_srvsvc_NetSessEnum_done(struct tevent_req *subreq);
1947
1948 struct tevent_req *rpccli_srvsvc_NetSessEnum_send(TALLOC_CTX *mem_ctx,
1949 struct tevent_context *ev,
1950 struct rpc_pipe_client *cli,
1951 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1952 const char *_client /* [in] [unique,charset(UTF16)] */,
1953 const char *_user /* [in] [unique,charset(UTF16)] */,
1954 struct srvsvc_NetSessInfoCtr *_info_ctr /* [in,out] [ref] */,
1955 uint32_t _max_buffer /* [in] */,
1956 uint32_t *_totalentries /* [out] [ref] */,
1957 uint32_t *_resume_handle /* [in,out] [unique] */)
1958 {
1959 struct tevent_req *req;
1960 struct rpccli_srvsvc_NetSessEnum_state *state;
1961 struct tevent_req *subreq;
1962
1963 req = tevent_req_create(mem_ctx, &state,
1964 struct rpccli_srvsvc_NetSessEnum_state);
1965 if (req == NULL) {
1966 return NULL;
1967 }
1968 state->out_mem_ctx = NULL;
1969 state->dispatch_recv = cli->dispatch_recv;
1970
1971 /* In parameters */
1972 state->orig.in.server_unc = _server_unc;
1973 state->orig.in.client = _client;
1974 state->orig.in.user = _user;
1975 state->orig.in.info_ctr = _info_ctr;
1976 state->orig.in.max_buffer = _max_buffer;
1977 state->orig.in.resume_handle = _resume_handle;
1978
1979 /* Out parameters */
1980 state->orig.out.info_ctr = _info_ctr;
1981 state->orig.out.totalentries = _totalentries;
1982 state->orig.out.resume_handle = _resume_handle;
1983
1984 /* Result */
1985 ZERO_STRUCT(state->orig.out.result);
1986
1987 state->out_mem_ctx = talloc_named_const(state, 0,
1988 "rpccli_srvsvc_NetSessEnum_out_memory");
1989 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1990 return tevent_req_post(req, ev);
1991 }
1992
1993 /* make a temporary copy, that we pass to the dispatch function */
1994 state->tmp = state->orig;
1995
1996 subreq = cli->dispatch_send(state, ev, cli,
1997 &ndr_table_srvsvc,
1998 NDR_SRVSVC_NETSESSENUM,
1999 &state->tmp);
2000 if (tevent_req_nomem(subreq, req)) {
2001 return tevent_req_post(req, ev);
2002 }
2003 tevent_req_set_callback(subreq, rpccli_srvsvc_NetSessEnum_done, req);
2004 return req;
2005 }
2006
2007 static void rpccli_srvsvc_NetSessEnum_done(struct tevent_req *subreq)
2008 {
2009 struct tevent_req *req = tevent_req_callback_data(
2010 subreq, struct tevent_req);
2011 struct rpccli_srvsvc_NetSessEnum_state *state = tevent_req_data(
2012 req, struct rpccli_srvsvc_NetSessEnum_state);
2013 NTSTATUS status;
2014 TALLOC_CTX *mem_ctx;
2015
2016 if (state->out_mem_ctx) {
2017 mem_ctx = state->out_mem_ctx;
2018 } else {
2019 mem_ctx = state;
2020 }
2021
2022 status = state->dispatch_recv(subreq, mem_ctx);
2023 TALLOC_FREE(subreq);
2024 if (!NT_STATUS_IS_OK(status)) {
2025 tevent_req_nterror(req, status);
2026 return;
2027 }
2028
2029 /* Copy out parameters */
2030 *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
2031 *state->orig.out.totalentries = *state->tmp.out.totalentries;
2032 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
2033 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2034 }
2035
2036 /* Copy result */
2037 state->orig.out.result = state->tmp.out.result;
2038
2039 /* Reset temporary structure */
2040 ZERO_STRUCT(state->tmp);
2041
2042 tevent_req_done(req);
2043 }
2044
2045 NTSTATUS rpccli_srvsvc_NetSessEnum_recv(struct tevent_req *req,
2046 TALLOC_CTX *mem_ctx,
2047 WERROR *result)
2048 {
2049 struct rpccli_srvsvc_NetSessEnum_state *state = tevent_req_data(
2050 req, struct rpccli_srvsvc_NetSessEnum_state);
2051 NTSTATUS status;
2052
2053 if (tevent_req_is_nterror(req, &status)) {
2054 tevent_req_received(req);
2055 return status;
2056 }
2057
2058 /* Steal possbile out parameters to the callers context */
2059 talloc_steal(mem_ctx, state->out_mem_ctx);
2060
2061 /* Return result */
2062 *result = state->orig.out.result;
2063
2064 tevent_req_received(req);
2065 return NT_STATUS_OK;
2066 }
2067
2068 NTSTATUS rpccli_srvsvc_NetSessEnum(struct rpc_pipe_client *cli,
2069 TALLOC_CTX *mem_ctx,
2070 const char *server_unc /* [in] [unique,charset(UTF16)] */,
2071 const char *client /* [in] [unique,charset(UTF16)] */,
2072 const char *user /* [in] [unique,charset(UTF16)] */,
2073 struct srvsvc_NetSessInfoCtr *info_ctr /* [in,out] [ref] */,
2074 uint32_t max_buffer /* [in] */,
2075 uint32_t *totalentries /* [out] [ref] */,
2076 uint32_t *resume_handle /* [in,out] [unique] */,
2077 WERROR *werror)
2078 {
2079 struct srvsvc_NetSessEnum r;
2080 NTSTATUS status;
2081
2082 /* In parameters */
2083 r.in.server_unc = server_unc;
2084 r.in.client = client;
2085 r.in.user = user;
2086 r.in.info_ctr = info_ctr;
2087 r.in.max_buffer = max_buffer;
2088 r.in.resume_handle = resume_handle;
2089
2090 status = cli->dispatch(cli,
2091 mem_ctx,
2092 &ndr_table_srvsvc,
2093 NDR_SRVSVC_NETSESSENUM,
2094 &r);
2095
2096 if (!NT_STATUS_IS_OK(status)) {
2097 return status;
2098 }
2099
2100 if (NT_STATUS_IS_ERR(status)) {
2101 return status;
2102 }
2103
2104 /* Return variables */
2105 *info_ctr = *r.out.info_ctr;
2106 *totalentries = *r.out.totalentries;
2107 if (resume_handle && r.out.resume_handle) {
2108 *resume_handle = *r.out.resume_handle;
2109 }
2110
2111 /* Return result */
2112 if (werror) {
2113 *werror = r.out.result;
2114 }
2115
2116 return werror_to_ntstatus(r.out.result);
2117 }
2118
2119 struct rpccli_srvsvc_NetSessDel_state {
2120 struct srvsvc_NetSessDel orig;
2121 struct srvsvc_NetSessDel tmp;
2122 TALLOC_CTX *out_mem_ctx;
2123 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2124 };
2125
2126 static void rpccli_srvsvc_NetSessDel_done(struct tevent_req *subreq);
2127
2128 struct tevent_req *rpccli_srvsvc_NetSessDel_send(TALLOC_CTX *mem_ctx,
2129 struct tevent_context *ev,
2130 struct rpc_pipe_client *cli,
2131 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2132 const char *_client /* [in] [unique,charset(UTF16)] */,
2133 const char *_user /* [in] [unique,charset(UTF16)] */)
2134 {
2135 struct tevent_req *req;
2136 struct rpccli_srvsvc_NetSessDel_state *state;
2137 struct tevent_req *subreq;
2138
2139 req = tevent_req_create(mem_ctx, &state,
2140 struct rpccli_srvsvc_NetSessDel_state);
2141 if (req == NULL) {
2142 return NULL;
2143 }
2144 state->out_mem_ctx = NULL;
2145 state->dispatch_recv = cli->dispatch_recv;
2146
2147 /* In parameters */
2148 state->orig.in.server_unc = _server_unc;
2149 state->orig.in.client = _client;
2150 state->orig.in.user = _user;
2151
2152 /* Out parameters */
2153
2154 /* Result */
2155 ZERO_STRUCT(state->orig.out.result);
2156
2157 /* make a temporary copy, that we pass to the dispatch function */
2158 state->tmp = state->orig;
2159
2160 subreq = cli->dispatch_send(state, ev, cli,
2161 &ndr_table_srvsvc,
2162 NDR_SRVSVC_NETSESSDEL,
2163 &state->tmp);
2164 if (tevent_req_nomem(subreq, req)) {
2165 return tevent_req_post(req, ev);
2166 }
2167 tevent_req_set_callback(subreq, rpccli_srvsvc_NetSessDel_done, req);
2168 return req;
2169 }
2170
2171 static void rpccli_srvsvc_NetSessDel_done(struct tevent_req *subreq)
2172 {
2173 struct tevent_req *req = tevent_req_callback_data(
2174 subreq, struct tevent_req);
2175 struct rpccli_srvsvc_NetSessDel_state *state = tevent_req_data(
2176 req, struct rpccli_srvsvc_NetSessDel_state);
2177 NTSTATUS status;
2178 TALLOC_CTX *mem_ctx;
2179
2180 if (state->out_mem_ctx) {
2181 mem_ctx = state->out_mem_ctx;
2182 } else {
2183 mem_ctx = state;
2184 }
2185
2186 status = state->dispatch_recv(subreq, mem_ctx);
2187 TALLOC_FREE(subreq);
2188 if (!NT_STATUS_IS_OK(status)) {
2189 tevent_req_nterror(req, status);
2190 return;
2191 }
2192
2193 /* Copy out parameters */
2194
2195 /* Copy result */
2196 state->orig.out.result = state->tmp.out.result;
2197
2198 /* Reset temporary structure */
2199 ZERO_STRUCT(state->tmp);
2200
2201 tevent_req_done(req);
2202 }
2203
2204 NTSTATUS rpccli_srvsvc_NetSessDel_recv(struct tevent_req *req,
2205 TALLOC_CTX *mem_ctx,
2206 WERROR *result)
2207 {
2208 struct rpccli_srvsvc_NetSessDel_state *state = tevent_req_data(
2209 req, struct rpccli_srvsvc_NetSessDel_state);
2210 NTSTATUS status;
2211
2212 if (tevent_req_is_nterror(req, &status)) {
2213 tevent_req_received(req);
2214 return status;
2215 }
2216
2217 /* Steal possbile out parameters to the callers context */
2218 talloc_steal(mem_ctx, state->out_mem_ctx);
2219
2220 /* Return result */
2221 *result = state->orig.out.result;
2222
2223 tevent_req_received(req);
2224 return NT_STATUS_OK;
2225 }
2226
2227 NTSTATUS rpccli_srvsvc_NetSessDel(struct rpc_pipe_client *cli,
2228 TALLOC_CTX *mem_ctx,
2229 const char *server_unc /* [in] [unique,charset(UTF16)] */,
2230 const char *client /* [in] [unique,charset(UTF16)] */,
2231 const char *user /* [in] [unique,charset(UTF16)] */,
2232 WERROR *werror)
2233 {
2234 struct srvsvc_NetSessDel r;
2235 NTSTATUS status;
2236
2237 /* In parameters */
2238 r.in.server_unc = server_unc;
2239 r.in.client = client;
2240 r.in.user = user;
2241
2242 status = cli->dispatch(cli,
2243 mem_ctx,
2244 &ndr_table_srvsvc,
2245 NDR_SRVSVC_NETSESSDEL,
2246 &r);
2247
2248 if (!NT_STATUS_IS_OK(status)) {
2249 return status;
2250 }
2251
2252 if (NT_STATUS_IS_ERR(status)) {
2253 return status;
2254 }
2255
2256 /* Return variables */
2257
2258 /* Return result */
2259 if (werror) {
2260 *werror = r.out.result;
2261 }
2262
2263 return werror_to_ntstatus(r.out.result);
2264 }
2265
2266 struct rpccli_srvsvc_NetShareAdd_state {
2267 struct srvsvc_NetShareAdd orig;
2268 struct srvsvc_NetShareAdd tmp;
2269 TALLOC_CTX *out_mem_ctx;
2270 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2271 };
2272
2273 static void rpccli_srvsvc_NetShareAdd_done(struct tevent_req *subreq);
2274
2275 struct tevent_req *rpccli_srvsvc_NetShareAdd_send(TALLOC_CTX *mem_ctx,
2276 struct tevent_context *ev,
2277 struct rpc_pipe_client *cli,
2278 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2279 uint32_t _level /* [in] */,
2280 union srvsvc_NetShareInfo *_info /* [in] [ref,switch_is(level)] */,
2281 uint32_t *_parm_error /* [in,out] [unique] */)
2282 {
2283 struct tevent_req *req;
2284 struct rpccli_srvsvc_NetShareAdd_state *state;
2285 struct tevent_req *subreq;
2286
2287 req = tevent_req_create(mem_ctx, &state,
2288 struct rpccli_srvsvc_NetShareAdd_state);
2289 if (req == NULL) {
2290 return NULL;
2291 }
2292 state->out_mem_ctx = NULL;
2293 state->dispatch_recv = cli->dispatch_recv;
2294
2295 /* In parameters */
2296 state->orig.in.server_unc = _server_unc;
2297 state->orig.in.level = _level;
2298 state->orig.in.info = _info;
2299 state->orig.in.parm_error = _parm_error;
2300
2301 /* Out parameters */
2302 state->orig.out.parm_error = _parm_error;
2303
2304 /* Result */
2305 ZERO_STRUCT(state->orig.out.result);
2306
2307 state->out_mem_ctx = talloc_named_const(state, 0,
2308 "rpccli_srvsvc_NetShareAdd_out_memory");
2309 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2310 return tevent_req_post(req, ev);
2311 }
2312
2313 /* make a temporary copy, that we pass to the dispatch function */
2314 state->tmp = state->orig;
2315
2316 subreq = cli->dispatch_send(state, ev, cli,
2317 &ndr_table_srvsvc,
2318 NDR_SRVSVC_NETSHAREADD,
2319 &state->tmp);
2320 if (tevent_req_nomem(subreq, req)) {
2321 return tevent_req_post(req, ev);
2322 }
2323 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareAdd_done, req);
2324 return req;
2325 }
2326
2327 static void rpccli_srvsvc_NetShareAdd_done(struct tevent_req *subreq)
2328 {
2329 struct tevent_req *req = tevent_req_callback_data(
2330 subreq, struct tevent_req);
2331 struct rpccli_srvsvc_NetShareAdd_state *state = tevent_req_data(
2332 req, struct rpccli_srvsvc_NetShareAdd_state);
2333 NTSTATUS status;
2334 TALLOC_CTX *mem_ctx;
2335
2336 if (state->out_mem_ctx) {
2337 mem_ctx = state->out_mem_ctx;
2338 } else {
2339 mem_ctx = state;
2340 }
2341
2342 status = state->dispatch_recv(subreq, mem_ctx);
2343 TALLOC_FREE(subreq);
2344 if (!NT_STATUS_IS_OK(status)) {
2345 tevent_req_nterror(req, status);
2346 return;
2347 }
2348
2349 /* Copy out parameters */
2350 if (state->orig.out.parm_error && state->tmp.out.parm_error) {
2351 *state->orig.out.parm_error = *state->tmp.out.parm_error;
2352 }
2353
2354 /* Copy result */
2355 state->orig.out.result = state->tmp.out.result;
2356
2357 /* Reset temporary structure */
2358 ZERO_STRUCT(state->tmp);
2359
2360 tevent_req_done(req);
2361 }
2362
2363 NTSTATUS rpccli_srvsvc_NetShareAdd_recv(struct tevent_req *req,
2364 TALLOC_CTX *mem_ctx,
2365 WERROR *result)
2366 {
2367 struct rpccli_srvsvc_NetShareAdd_state *state = tevent_req_data(
2368 req, struct rpccli_srvsvc_NetShareAdd_state);
2369 NTSTATUS status;
2370
2371 if (tevent_req_is_nterror(req, &status)) {
2372 tevent_req_received(req);
2373 return status;
2374 }
2375
2376 /* Steal possbile out parameters to the callers context */
2377 talloc_steal(mem_ctx, state->out_mem_ctx);
2378
2379 /* Return result */
2380 *result = state->orig.out.result;
2381
2382 tevent_req_received(req);
2383 return NT_STATUS_OK;
2384 }
2385
2386 NTSTATUS rpccli_srvsvc_NetShareAdd(struct rpc_pipe_client *cli,
2387 TALLOC_CTX *mem_ctx,
2388 const char *server_unc /* [in] [unique,charset(UTF16)] */,
2389 uint32_t level /* [in] */,
2390 union srvsvc_NetShareInfo *info /* [in] [ref,switch_is(level)] */,
2391 uint32_t *parm_error /* [in,out] [unique] */,
2392 WERROR *werror)
2393 {
2394 struct srvsvc_NetShareAdd r;
2395 NTSTATUS status;
2396
2397 /* In parameters */
2398 r.in.server_unc = server_unc;
2399 r.in.level = level;
2400 r.in.info = info;
2401 r.in.parm_error = parm_error;
2402
2403 status = cli->dispatch(cli,
2404 mem_ctx,
2405 &ndr_table_srvsvc,
2406 NDR_SRVSVC_NETSHAREADD,
2407 &r);
2408
2409 if (!NT_STATUS_IS_OK(status)) {
2410 return status;
2411 }
2412
2413 if (NT_STATUS_IS_ERR(status)) {
2414 return status;
2415 }
2416
2417 /* Return variables */
2418 if (parm_error && r.out.parm_error) {
2419 *parm_error = *r.out.parm_error;
2420 }
2421
2422 /* Return result */
2423 if (werror) {
2424 *werror = r.out.result;
2425 }
2426
2427 return werror_to_ntstatus(r.out.result);
2428 }
2429
2430 struct rpccli_srvsvc_NetShareEnumAll_state {
2431 struct srvsvc_NetShareEnumAll orig;
2432 struct srvsvc_NetShareEnumAll tmp;
2433 TALLOC_CTX *out_mem_ctx;
2434 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2435 };
2436
2437 static void rpccli_srvsvc_NetShareEnumAll_done(struct tevent_req *subreq);
2438
2439 struct tevent_req *rpccli_srvsvc_NetShareEnumAll_send(TALLOC_CTX *mem_ctx,
2440 struct tevent_context *ev,
2441 struct rpc_pipe_client *cli,
2442 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2443 struct srvsvc_NetShareInfoCtr *_info_ctr /* [in,out] [ref] */,
2444 uint32_t _max_buffer /* [in] */,
2445 uint32_t *_totalentries /* [out] [ref] */,
2446 uint32_t *_resume_handle /* [in,out] [unique] */)
2447 {
2448 struct tevent_req *req;
2449 struct rpccli_srvsvc_NetShareEnumAll_state *state;
2450 struct tevent_req *subreq;
2451
2452 req = tevent_req_create(mem_ctx, &state,
2453 struct rpccli_srvsvc_NetShareEnumAll_state);
2454 if (req == NULL) {
2455 return NULL;
2456 }
2457 state->out_mem_ctx = NULL;
2458 state->dispatch_recv = cli->dispatch_recv;
2459
2460 /* In parameters */
2461 state->orig.in.server_unc = _server_unc;
2462 state->orig.in.info_ctr = _info_ctr;
2463 state->orig.in.max_buffer = _max_buffer;
2464 state->orig.in.resume_handle = _resume_handle;
2465
2466 /* Out parameters */
2467 state->orig.out.info_ctr = _info_ctr;
2468 state->orig.out.totalentries = _totalentries;
2469 state->orig.out.resume_handle = _resume_handle;
2470
2471 /* Result */
2472 ZERO_STRUCT(state->orig.out.result);
2473
2474 state->out_mem_ctx = talloc_named_const(state, 0,
2475 "rpccli_srvsvc_NetShareEnumAll_out_memory");
2476 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2477 return tevent_req_post(req, ev);
2478 }
2479
2480 /* make a temporary copy, that we pass to the dispatch function */
2481 state->tmp = state->orig;
2482
2483 subreq = cli->dispatch_send(state, ev, cli,
2484 &ndr_table_srvsvc,
2485 NDR_SRVSVC_NETSHAREENUMALL,
2486 &state->tmp);
2487 if (tevent_req_nomem(subreq, req)) {
2488 return tevent_req_post(req, ev);
2489 }
2490 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareEnumAll_done, req);
2491 return req;
2492 }
2493
2494 static void rpccli_srvsvc_NetShareEnumAll_done(struct tevent_req *subreq)
2495 {
2496 struct tevent_req *req = tevent_req_callback_data(
2497 subreq, struct tevent_req);
2498 struct rpccli_srvsvc_NetShareEnumAll_state *state = tevent_req_data(
2499 req, struct rpccli_srvsvc_NetShareEnumAll_state);
2500 NTSTATUS status;
2501 TALLOC_CTX *mem_ctx;
2502
2503 if (state->out_mem_ctx) {
2504 mem_ctx = state->out_mem_ctx;
2505 } else {
2506 mem_ctx = state;
2507 }
2508
2509 status = state->dispatch_recv(subreq, mem_ctx);
2510 TALLOC_FREE(subreq);
2511 if (!NT_STATUS_IS_OK(status)) {
2512 tevent_req_nterror(req, status);
2513 return;
2514 }
2515
2516 /* Copy out parameters */
2517 *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
2518 *state->orig.out.totalentries = *state->tmp.out.totalentries;
2519 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
2520 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2521 }
2522
2523 /* Copy result */
2524 state->orig.out.result = state->tmp.out.result;
2525
2526 /* Reset temporary structure */
2527 ZERO_STRUCT(state->tmp);
2528
2529 tevent_req_done(req);
2530 }
2531
2532 NTSTATUS rpccli_srvsvc_NetShareEnumAll_recv(struct tevent_req *req,
2533 TALLOC_CTX *mem_ctx,
2534 WERROR *result)
2535 {
2536 struct rpccli_srvsvc_NetShareEnumAll_state *state = tevent_req_data(
2537 req, struct rpccli_srvsvc_NetShareEnumAll_state);
2538 NTSTATUS status;
2539
2540 if (tevent_req_is_nterror(req, &status)) {
2541 tevent_req_received(req);
2542 return status;
2543 }
2544
2545 /* Steal possbile out parameters to the callers context */
2546 talloc_steal(mem_ctx, state->out_mem_ctx);
2547
2548 /* Return result */
2549 *result = state->orig.out.result;
2550
2551 tevent_req_received(req);
2552 return NT_STATUS_OK;
2553 }
2554
2555 NTSTATUS rpccli_srvsvc_NetShareEnumAll(struct rpc_pipe_client *cli,
2556 TALLOC_CTX *mem_ctx,
2557 const char *server_unc /* [in] [unique,charset(UTF16)] */,
2558 struct srvsvc_NetShareInfoCtr *info_ctr /* [in,out] [ref] */,
2559 uint32_t max_buffer /* [in] */,
2560 uint32_t *totalentries /* [out] [ref] */,
2561 uint32_t *resume_handle /* [in,out] [unique] */,
2562 WERROR *werror)
2563 {
2564 struct srvsvc_NetShareEnumAll r;
2565 NTSTATUS status;
2566
2567 /* In parameters */
2568 r.in.server_unc = server_unc;
2569 r.in.info_ctr = info_ctr;
2570 r.in.max_buffer = max_buffer;
2571 r.in.resume_handle = resume_handle;
2572
2573 status = cli->dispatch(cli,
2574 mem_ctx,
2575 &ndr_table_srvsvc,
2576 NDR_SRVSVC_NETSHAREENUMALL,
2577 &r);
2578
2579 if (!NT_STATUS_IS_OK(status)) {
2580 return status;
2581 }
2582
2583 if (NT_STATUS_IS_ERR(status)) {
2584 return status;
2585 }
2586
2587 /* Return variables */
2588 *info_ctr = *r.out.info_ctr;
2589 *totalentries = *r.out.totalentries;
2590 if (resume_handle && r.out.resume_handle) {
2591 *resume_handle = *r.out.resume_handle;
2592 }
2593
2594 /* Return result */
2595 if (werror) {
2596 *werror = r.out.result;
2597 }
2598
2599 return werror_to_ntstatus(r.out.result);
2600 }
2601
2602 struct rpccli_srvsvc_NetShareGetInfo_state {
2603 struct srvsvc_NetShareGetInfo orig;
2604 struct srvsvc_NetShareGetInfo tmp;
2605 TALLOC_CTX *out_mem_ctx;
2606 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2607 };
2608
2609 static void rpccli_srvsvc_NetShareGetInfo_done(struct tevent_req *subreq);
2610
2611 struct tevent_req *rpccli_srvsvc_NetShareGetInfo_send(TALLOC_CTX *mem_ctx,
2612 struct tevent_context *ev,
2613 struct rpc_pipe_client *cli,
2614 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2615 const char *_share_name /* [in] [charset(UTF16)] */,
2616 uint32_t _level /* [in] */,
2617 union srvsvc_NetShareInfo *_info /* [out] [ref,switch_is(level)] */)
2618 {
2619 struct tevent_req *req;
2620 struct rpccli_srvsvc_NetShareGetInfo_state *state;
2621 struct tevent_req *subreq;
2622
2623 req = tevent_req_create(mem_ctx, &state,
2624 struct rpccli_srvsvc_NetShareGetInfo_state);
2625 if (req == NULL) {
2626 return NULL;
2627 }
2628 state->out_mem_ctx = NULL;
2629 state->dispatch_recv = cli->dispatch_recv;
2630
2631 /* In parameters */
2632 state->orig.in.server_unc = _server_unc;
2633 state->orig.in.share_name = _share_name;
2634 state->orig.in.level = _level;
2635
2636 /* Out parameters */
2637 state->orig.out.info = _info;
2638
2639 /* Result */
2640 ZERO_STRUCT(state->orig.out.result);
2641
2642 state->out_mem_ctx = talloc_named_const(state, 0,
2643 "rpccli_srvsvc_NetShareGetInfo_out_memory");
2644 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2645 return tevent_req_post(req, ev);
2646 }
2647
2648 /* make a temporary copy, that we pass to the dispatch function */
2649 state->tmp = state->orig;
2650
2651 subreq = cli->dispatch_send(state, ev, cli,
2652 &ndr_table_srvsvc,
2653 NDR_SRVSVC_NETSHAREGETINFO,
2654 &state->tmp);
2655 if (tevent_req_nomem(subreq, req)) {
2656 return tevent_req_post(req, ev);
2657 }
2658 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareGetInfo_done, req);
2659 return req;
2660 }
2661
2662 static void rpccli_srvsvc_NetShareGetInfo_done(struct tevent_req *subreq)
2663 {
2664 struct tevent_req *req = tevent_req_callback_data(
2665 subreq, struct tevent_req);
2666 struct rpccli_srvsvc_NetShareGetInfo_state *state = tevent_req_data(
2667 req, struct rpccli_srvsvc_NetShareGetInfo_state);
2668 NTSTATUS status;
2669 TALLOC_CTX *mem_ctx;
2670
2671 if (state->out_mem_ctx) {
2672 mem_ctx = state->out_mem_ctx;
2673 } else {
2674 mem_ctx = state;
2675 }
2676
2677 status = state->dispatch_recv(subreq, mem_ctx);
2678 TALLOC_FREE(subreq);
2679 if (!NT_STATUS_IS_OK(status)) {
2680 tevent_req_nterror(req, status);
2681 return;
2682 }
2683
2684 /* Copy out parameters */
2685 *state->orig.out.info = *state->tmp.out.info;
2686
2687 /* Copy result */
2688 state->orig.out.result = state->tmp.out.result;
2689
2690 /* Reset temporary structure */
2691 ZERO_STRUCT(state->tmp);
2692
2693 tevent_req_done(req);
2694 }
2695
2696 NTSTATUS rpccli_srvsvc_NetShareGetInfo_recv(struct tevent_req *req,
2697 TALLOC_CTX *mem_ctx,
2698 WERROR *result)
2699 {
2700 struct rpccli_srvsvc_NetShareGetInfo_state *state = tevent_req_data(
2701 req, struct rpccli_srvsvc_NetShareGetInfo_state);
2702 NTSTATUS status;
2703
2704 if (tevent_req_is_nterror(req, &status)) {
2705 tevent_req_received(req);
2706 return status;
2707 }
2708
2709 /* Steal possbile out parameters to the callers context */
2710 talloc_steal(mem_ctx, state->out_mem_ctx);
2711
2712 /* Return result */
2713 *result = state->orig.out.result;
2714
2715 tevent_req_received(req);
2716 return NT_STATUS_OK;
2717 }
2718
2719 NTSTATUS rpccli_srvsvc_NetShareGetInfo(struct rpc_pipe_client *cli,
2720 TALLOC_CTX *mem_ctx,
2721 const char *server_unc /* [in] [unique,charset(UTF16)] */,
2722 const char *share_name /* [in] [charset(UTF16)] */,
2723 uint32_t level /* [in] */,
2724 union srvsvc_NetShareInfo *info /* [out] [ref,switch_is(level)] */,
2725 WERROR *werror)
2726 {
2727 struct srvsvc_NetShareGetInfo r;
2728 NTSTATUS status;
2729
2730 /* In parameters */
2731 r.in.server_unc = server_unc;
2732 r.in.share_name = share_name;
2733 r.in.level = level;
2734
2735 status = cli->dispatch(cli,
2736 mem_ctx,
2737 &ndr_table_srvsvc,
2738 NDR_SRVSVC_NETSHAREGETINFO,
2739 &r);
2740
2741 if (!NT_STATUS_IS_OK(status)) {
2742 return status;
2743 }
2744
2745 if (NT_STATUS_IS_ERR(status)) {
2746 return status;
2747 }
2748
2749 /* Return variables */
2750 *info = *r.out.info;
2751
2752 /* Return result */
2753 if (werror) {
2754 *werror = r.out.result;
2755 }
2756
2757 return werror_to_ntstatus(r.out.result);
2758 }
2759
2760 struct rpccli_srvsvc_NetShareSetInfo_state {
2761 struct srvsvc_NetShareSetInfo orig;
2762 struct srvsvc_NetShareSetInfo tmp;
2763 TALLOC_CTX *out_mem_ctx;
2764 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2765 };
2766
2767 static void rpccli_srvsvc_NetShareSetInfo_done(struct tevent_req *subreq);
2768
2769 struct tevent_req *rpccli_srvsvc_NetShareSetInfo_send(TALLOC_CTX *mem_ctx,
2770 struct tevent_context *ev,
2771 struct rpc_pipe_client *cli,
2772 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2773 const char *_share_name /* [in] [charset(UTF16)] */,
2774 uint32_t _level /* [in] */,
2775 union srvsvc_NetShareInfo *_info /* [in] [ref,switch_is(level)] */,
2776 uint32_t *_parm_error /* [in,out] [unique] */)
2777 {
2778 struct tevent_req *req;
2779 struct rpccli_srvsvc_NetShareSetInfo_state *state;
2780 struct tevent_req *subreq;
2781
2782 req = tevent_req_create(mem_ctx, &state,
2783 struct rpccli_srvsvc_NetShareSetInfo_state);
2784 if (req == NULL) {
2785 return NULL;
2786 }
2787 state->out_mem_ctx = NULL;
2788 state->dispatch_recv = cli->dispatch_recv;
2789
2790 /* In parameters */
2791 state->orig.in.server_unc = _server_unc;
2792 state->orig.in.share_name = _share_name;
2793 state->orig.in.level = _level;
2794 state->orig.in.info = _info;
2795 state->orig.in.parm_error = _parm_error;
2796
2797 /* Out parameters */
2798 state->orig.out.parm_error = _parm_error;
2799
2800 /* Result */
2801 ZERO_STRUCT(state->orig.out.result);
2802
2803 state->out_mem_ctx = talloc_named_const(state, 0,
2804 "rpccli_srvsvc_NetShareSetInfo_out_memory");
2805 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2806 return tevent_req_post(req, ev);
2807 }
2808
2809 /* make a temporary copy, that we pass to the dispatch function */
2810 state->tmp = state->orig;
2811
2812 subreq = cli->dispatch_send(state, ev, cli,
2813 &ndr_table_srvsvc,
2814 NDR_SRVSVC_NETSHARESETINFO,
2815 &state->tmp);
2816 if (tevent_req_nomem(subreq, req)) {
2817 return tevent_req_post(req, ev);
2818 }
2819 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareSetInfo_done, req);
2820 return req;
2821 }
2822
2823 static void rpccli_srvsvc_NetShareSetInfo_done(struct tevent_req *subreq)
2824 {
2825 struct tevent_req *req = tevent_req_callback_data(
2826 subreq, struct tevent_req);
2827 struct rpccli_srvsvc_NetShareSetInfo_state *state = tevent_req_data(
2828 req, struct rpccli_srvsvc_NetShareSetInfo_state);
2829 NTSTATUS status;
2830 TALLOC_CTX *mem_ctx;
2831
2832 if (state->out_mem_ctx) {
2833 mem_ctx = state->out_mem_ctx;
2834 } else {
2835 mem_ctx = state;
2836 }
2837
2838 status = state->dispatch_recv(subreq, mem_ctx);
2839 TALLOC_FREE(subreq);
2840 if (!NT_STATUS_IS_OK(status)) {
2841 tevent_req_nterror(req, status);
2842 return;
2843 }
2844
2845 /* Copy out parameters */
2846 if (state->orig.out.parm_error && state->tmp.out.parm_error) {
2847 *state->orig.out.parm_error = *state->tmp.out.parm_error;
2848 }
2849
2850 /* Copy result */
2851 state->orig.out.result = state->tmp.out.result;
2852
2853 /* Reset temporary structure */
2854 ZERO_STRUCT(state->tmp);
2855
2856 tevent_req_done(req);
2857 }
2858
2859 NTSTATUS rpccli_srvsvc_NetShareSetInfo_recv(struct tevent_req *req,
2860 TALLOC_CTX *mem_ctx,
2861 WERROR *result)
2862 {
2863 struct rpccli_srvsvc_NetShareSetInfo_state *state = tevent_req_data(
2864 req, struct rpccli_srvsvc_NetShareSetInfo_state);
2865 NTSTATUS status;
2866
2867 if (tevent_req_is_nterror(req, &status)) {
2868 tevent_req_received(req);
2869 return status;
2870 }
2871
2872 /* Steal possbile out parameters to the callers context */
2873 talloc_steal(mem_ctx, state->out_mem_ctx);
2874
2875 /* Return result */
2876 *result = state->orig.out.result;
2877
2878 tevent_req_received(req);
2879 return NT_STATUS_OK;
2880 }
2881
2882 NTSTATUS rpccli_srvsvc_NetShareSetInfo(struct rpc_pipe_client *cli,
2883 TALLOC_CTX *mem_ctx,
2884 const char *server_unc /* [in] [unique,charset(UTF16)] */,
2885 const char *share_name /* [in] [charset(UTF16)] */,
2886 uint32_t level /* [in] */,
2887 union srvsvc_NetShareInfo *info /* [in] [ref,switch_is(level)] */,
2888 uint32_t *parm_error /* [in,out] [unique] */,
2889 WERROR *werror)
2890 {
2891 struct srvsvc_NetShareSetInfo r;
2892 NTSTATUS status;
2893
2894 /* In parameters */
2895 r.in.server_unc = server_unc;
2896 r.in.share_name = share_name;
2897 r.in.level = level;
2898 r.in.info = info;
2899 r.in.parm_error = parm_error;
2900
2901 status = cli->dispatch(cli,
2902 mem_ctx,
2903 &ndr_table_srvsvc,
2904 NDR_SRVSVC_NETSHARESETINFO,
2905 &r);
2906
2907 if (!NT_STATUS_IS_OK(status)) {
2908 return status;
2909 }
2910
2911 if (NT_STATUS_IS_ERR(status)) {
2912 return status;
2913 }
2914
2915 /* Return variables */
2916 if (parm_error && r.out.parm_error) {
2917 *parm_error = *r.out.parm_error;
2918 }
2919
2920 /* Return result */
2921 if (werror) {
2922 *werror = r.out.result;
2923 }
2924
2925 return werror_to_ntstatus(r.out.result);
2926 }
2927
2928 struct rpccli_srvsvc_NetShareDel_state {
2929 struct srvsvc_NetShareDel orig;
2930 struct srvsvc_NetShareDel tmp;
2931 TALLOC_CTX *out_mem_ctx;
2932 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2933 };
2934
2935 static void rpccli_srvsvc_NetShareDel_done(struct tevent_req *subreq);
2936
2937 struct tevent_req *rpccli_srvsvc_NetShareDel_send(TALLOC_CTX *mem_ctx,
2938 struct tevent_context *ev,
2939 struct rpc_pipe_client *cli,
2940 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2941 const char *_share_name /* [in] [charset(UTF16)] */,
2942 uint32_t _reserved /* [in] */)
2943 {
2944 struct tevent_req *req;
2945 struct rpccli_srvsvc_NetShareDel_state *state;
2946 struct tevent_req *subreq;
2947
2948 req = tevent_req_create(mem_ctx, &state,
2949 struct rpccli_srvsvc_NetShareDel_state);
2950 if (req == NULL) {
2951 return NULL;
2952 }
2953 state->out_mem_ctx = NULL;
2954 state->dispatch_recv = cli->dispatch_recv;
2955
2956 /* In parameters */
2957 state->orig.in.server_unc = _server_unc;
2958 state->orig.in.share_name = _share_name;
2959 state->orig.in.reserved = _reserved;
2960
2961 /* Out parameters */
2962
2963 /* Result */
2964 ZERO_STRUCT(state->orig.out.result);
2965
2966 /* make a temporary copy, that we pass to the dispatch function */
2967 state->tmp = state->orig;
2968
2969 subreq = cli->dispatch_send(state, ev, cli,
2970 &ndr_table_srvsvc,
2971 NDR_SRVSVC_NETSHAREDEL,
2972 &state->tmp);
2973 if (tevent_req_nomem(subreq, req)) {
2974 return tevent_req_post(req, ev);
2975 }
2976 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareDel_done, req);
2977 return req;
2978 }
2979
2980 static void rpccli_srvsvc_NetShareDel_done(struct tevent_req *subreq)
2981 {
2982 struct tevent_req *req = tevent_req_callback_data(
2983 subreq, struct tevent_req);
2984 struct rpccli_srvsvc_NetShareDel_state *state = tevent_req_data(
2985 req, struct rpccli_srvsvc_NetShareDel_state);
2986 NTSTATUS status;
2987 TALLOC_CTX *mem_ctx;
2988
2989 if (state->out_mem_ctx) {
2990 mem_ctx = state->out_mem_ctx;
2991 } else {
2992 mem_ctx = state;
2993 }
2994
2995 status = state->dispatch_recv(subreq, mem_ctx);
2996 TALLOC_FREE(subreq);
2997 if (!NT_STATUS_IS_OK(status)) {
2998 tevent_req_nterror(req, status);
2999 return;
3000 }
3001
3002 /* Copy out parameters */
3003
3004 /* Copy result */
3005 state->orig.out.result = state->tmp.out.result;
3006
3007 /* Reset temporary structure */
3008 ZERO_STRUCT(state->tmp);
3009
3010 tevent_req_done(req);
3011 }
3012
3013 NTSTATUS rpccli_srvsvc_NetShareDel_recv(struct tevent_req *req,
3014 TALLOC_CTX *mem_ctx,
3015 WERROR *result)
3016 {
3017 struct rpccli_srvsvc_NetShareDel_state *state = tevent_req_data(
3018 req, struct rpccli_srvsvc_NetShareDel_state);
3019 NTSTATUS status;
3020
3021 if (tevent_req_is_nterror(req, &status)) {
3022 tevent_req_received(req);
3023 return status;
3024 }
3025
3026 /* Steal possbile out parameters to the callers context */
3027 talloc_steal(mem_ctx, state->out_mem_ctx);
3028
3029 /* Return result */
3030 *result = state->orig.out.result;
3031
3032 tevent_req_received(req);
3033 return NT_STATUS_OK;
3034 }
3035
3036 NTSTATUS rpccli_srvsvc_NetShareDel(struct rpc_pipe_client *cli,
3037 TALLOC_CTX *mem_ctx,
3038 const char *server_unc /* [in] [unique,charset(UTF16)] */,
3039 const char *share_name /* [in] [charset(UTF16)] */,
3040 uint32_t reserved /* [in] */,
3041 WERROR *werror)
3042 {
3043 struct srvsvc_NetShareDel r;
3044 NTSTATUS status;
3045
3046 /* In parameters */
3047 r.in.server_unc = server_unc;
3048 r.in.share_name = share_name;
3049 r.in.reserved = reserved;
3050
3051 status = cli->dispatch(cli,
3052 mem_ctx,
3053 &ndr_table_srvsvc,
3054 NDR_SRVSVC_NETSHAREDEL,
3055 &r);
3056
3057 if (!NT_STATUS_IS_OK(status)) {
3058 return status;
3059 }
3060
3061 if (NT_STATUS_IS_ERR(status)) {
3062 return status;
3063 }
3064
3065 /* Return variables */
3066
3067 /* Return result */
3068 if (werror) {
3069 *werror = r.out.result;
3070 }
3071
3072 return werror_to_ntstatus(r.out.result);
3073 }
3074
3075 struct rpccli_srvsvc_NetShareDelSticky_state {
3076 struct srvsvc_NetShareDelSticky orig;
3077 struct srvsvc_NetShareDelSticky tmp;
3078 TALLOC_CTX *out_mem_ctx;
3079 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3080 };
3081
3082 static void rpccli_srvsvc_NetShareDelSticky_done(struct tevent_req *subreq);
3083
3084 struct tevent_req *rpccli_srvsvc_NetShareDelSticky_send(TALLOC_CTX *mem_ctx,
3085 struct tevent_context *ev,
3086 struct rpc_pipe_client *cli,
3087 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3088 const char *_share_name /* [in] [charset(UTF16)] */,
3089 uint32_t _reserved /* [in] */)
3090 {
3091 struct tevent_req *req;
3092 struct rpccli_srvsvc_NetShareDelSticky_state *state;
3093 struct tevent_req *subreq;
3094
3095 req = tevent_req_create(mem_ctx, &state,
3096 struct rpccli_srvsvc_NetShareDelSticky_state);
3097 if (req == NULL) {
3098 return NULL;
3099 }
3100 state->out_mem_ctx = NULL;
3101 state->dispatch_recv = cli->dispatch_recv;
3102
3103 /* In parameters */
3104 state->orig.in.server_unc = _server_unc;
3105 state->orig.in.share_name = _share_name;
3106 state->orig.in.reserved = _reserved;
3107
3108 /* Out parameters */
3109
3110 /* Result */
3111 ZERO_STRUCT(state->orig.out.result);
3112
3113 /* make a temporary copy, that we pass to the dispatch function */
3114 state->tmp = state->orig;
3115
3116 subreq = cli->dispatch_send(state, ev, cli,
3117 &ndr_table_srvsvc,
3118 NDR_SRVSVC_NETSHAREDELSTICKY,
3119 &state->tmp);
3120 if (tevent_req_nomem(subreq, req)) {
3121 return tevent_req_post(req, ev);
3122 }
3123 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareDelSticky_done, req);
3124 return req;
3125 }
3126
3127 static void rpccli_srvsvc_NetShareDelSticky_done(struct tevent_req *subreq)
3128 {
3129 struct tevent_req *req = tevent_req_callback_data(
3130 subreq, struct tevent_req);
3131 struct rpccli_srvsvc_NetShareDelSticky_state *state = tevent_req_data(
3132 req, struct rpccli_srvsvc_NetShareDelSticky_state);
3133 NTSTATUS status;
3134 TALLOC_CTX *mem_ctx;
3135
3136 if (state->out_mem_ctx) {
3137 mem_ctx = state->out_mem_ctx;
3138 } else {
3139 mem_ctx = state;
3140 }
3141
3142 status = state->dispatch_recv(subreq, mem_ctx);
3143 TALLOC_FREE(subreq);
3144 if (!NT_STATUS_IS_OK(status)) {
3145 tevent_req_nterror(req, status);
3146 return;
3147 }
3148
3149 /* Copy out parameters */
3150
3151 /* Copy result */
3152 state->orig.out.result = state->tmp.out.result;
3153
3154 /* Reset temporary structure */
3155 ZERO_STRUCT(state->tmp);
3156
3157 tevent_req_done(req);
3158 }
3159
3160 NTSTATUS rpccli_srvsvc_NetShareDelSticky_recv(struct tevent_req *req,
3161 TALLOC_CTX *mem_ctx,
3162 WERROR *result)
3163 {
3164 struct rpccli_srvsvc_NetShareDelSticky_state *state = tevent_req_data(
3165 req, struct rpccli_srvsvc_NetShareDelSticky_state);
3166 NTSTATUS status;
3167
3168 if (tevent_req_is_nterror(req, &status)) {
3169 tevent_req_received(req);
3170 return status;
3171 }
3172
3173 /* Steal possbile out parameters to the callers context */
3174 talloc_steal(mem_ctx, state->out_mem_ctx);
3175
3176 /* Return result */
3177 *result = state->orig.out.result;
3178
3179 tevent_req_received(req);
3180 return NT_STATUS_OK;
3181 }
3182
3183 NTSTATUS rpccli_srvsvc_NetShareDelSticky(struct rpc_pipe_client *cli,
3184 TALLOC_CTX *mem_ctx,
3185 const char *server_unc /* [in] [unique,charset(UTF16)] */,
3186 const char *share_name /* [in] [charset(UTF16)] */,
3187 uint32_t reserved /* [in] */,
3188 WERROR *werror)
3189 {
3190 struct srvsvc_NetShareDelSticky r;
3191 NTSTATUS status;
3192
3193 /* In parameters */
3194 r.in.server_unc = server_unc;
3195 r.in.share_name = share_name;
3196 r.in.reserved = reserved;
3197
3198 status = cli->dispatch(cli,
3199 mem_ctx,
3200 &ndr_table_srvsvc,
3201 NDR_SRVSVC_NETSHAREDELSTICKY,
3202 &r);
3203
3204 if (!NT_STATUS_IS_OK(status)) {
3205 return status;
3206 }
3207
3208 if (NT_STATUS_IS_ERR(status)) {
3209 return status;
3210 }
3211
3212 /* Return variables */
3213
3214 /* Return result */
3215 if (werror) {
3216 *werror = r.out.result;
3217 }
3218
3219 return werror_to_ntstatus(r.out.result);
3220 }
3221
3222 struct rpccli_srvsvc_NetShareCheck_state {
3223 struct srvsvc_NetShareCheck orig;
3224 struct srvsvc_NetShareCheck tmp;
3225 TALLOC_CTX *out_mem_ctx;
3226 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3227 };
3228
3229 static void rpccli_srvsvc_NetShareCheck_done(struct tevent_req *subreq);
3230
3231 struct tevent_req *rpccli_srvsvc_NetShareCheck_send(TALLOC_CTX *mem_ctx,
3232 struct tevent_context *ev,
3233 struct rpc_pipe_client *cli,
3234 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3235 const char *_device_name /* [in] [charset(UTF16)] */,
3236 enum srvsvc_ShareType *_type /* [out] [ref] */)
3237 {
3238 struct tevent_req *req;
3239 struct rpccli_srvsvc_NetShareCheck_state *state;
3240 struct tevent_req *subreq;
3241
3242 req = tevent_req_create(mem_ctx, &state,
3243 struct rpccli_srvsvc_NetShareCheck_state);
3244 if (req == NULL) {
3245 return NULL;
3246 }
3247 state->out_mem_ctx = NULL;
3248 state->dispatch_recv = cli->dispatch_recv;
3249
3250 /* In parameters */
3251 state->orig.in.server_unc = _server_unc;
3252 state->orig.in.device_name = _device_name;
3253
3254 /* Out parameters */
3255 state->orig.out.type = _type;
3256
3257 /* Result */
3258 ZERO_STRUCT(state->orig.out.result);
3259
3260 state->out_mem_ctx = talloc_named_const(state, 0,
3261 "rpccli_srvsvc_NetShareCheck_out_memory");
3262 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3263 return tevent_req_post(req, ev);
3264 }
3265
3266 /* make a temporary copy, that we pass to the dispatch function */
3267 state->tmp = state->orig;
3268
3269 subreq = cli->dispatch_send(state, ev, cli,
3270 &ndr_table_srvsvc,
3271 NDR_SRVSVC_NETSHARECHECK,
3272 &state->tmp);
3273 if (tevent_req_nomem(subreq, req)) {
3274 return tevent_req_post(req, ev);
3275 }
3276 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareCheck_done, req);
3277 return req;
3278 }
3279
3280 static void rpccli_srvsvc_NetShareCheck_done(struct tevent_req *subreq)
3281 {
3282 struct tevent_req *req = tevent_req_callback_data(
3283 subreq, struct tevent_req);
3284 struct rpccli_srvsvc_NetShareCheck_state *state = tevent_req_data(
3285 req, struct rpccli_srvsvc_NetShareCheck_state);
3286 NTSTATUS status;
3287 TALLOC_CTX *mem_ctx;
3288
3289 if (state->out_mem_ctx) {
3290 mem_ctx = state->out_mem_ctx;
3291 } else {
3292 mem_ctx = state;
3293 }
3294
3295 status = state->dispatch_recv(subreq, mem_ctx);
3296 TALLOC_FREE(subreq);
3297 if (!NT_STATUS_IS_OK(status)) {
3298 tevent_req_nterror(req, status);
3299 return;
3300 }
3301
3302 /* Copy out parameters */
3303 *state->orig.out.type = *state->tmp.out.type;
3304
3305 /* Copy result */
3306 state->orig.out.result = state->tmp.out.result;
3307
3308 /* Reset temporary structure */
3309 ZERO_STRUCT(state->tmp);
3310
3311 tevent_req_done(req);
3312 }
3313
3314 NTSTATUS rpccli_srvsvc_NetShareCheck_recv(struct tevent_req *req,
3315 TALLOC_CTX *mem_ctx,
3316 WERROR *result)
3317 {
3318 struct rpccli_srvsvc_NetShareCheck_state *state = tevent_req_data(
3319 req, struct rpccli_srvsvc_NetShareCheck_state);
3320 NTSTATUS status;
3321
3322 if (tevent_req_is_nterror(req, &status)) {
3323 tevent_req_received(req);
3324 return status;
3325 }
3326
3327 /* Steal possbile out parameters to the callers context */
3328 talloc_steal(mem_ctx, state->out_mem_ctx);
3329
3330 /* Return result */
3331 *result = state->orig.out.result;
3332
3333 tevent_req_received(req);
3334 return NT_STATUS_OK;
3335 }
3336
3337 NTSTATUS rpccli_srvsvc_NetShareCheck(struct rpc_pipe_client *cli,
3338 TALLOC_CTX *mem_ctx,
3339 const char *server_unc /* [in] [unique,charset(UTF16)] */,
3340 const char *device_name /* [in] [charset(UTF16)] */,
3341 enum srvsvc_ShareType *type /* [out] [ref] */,
3342 WERROR *werror)
3343 {
3344 struct srvsvc_NetShareCheck r;
3345 NTSTATUS status;
3346
3347 /* In parameters */
3348 r.in.server_unc = server_unc;
3349 r.in.device_name = device_name;
3350
3351 status = cli->dispatch(cli,
3352 mem_ctx,
3353 &ndr_table_srvsvc,
3354 NDR_SRVSVC_NETSHARECHECK,
3355 &r);
3356
3357 if (!NT_STATUS_IS_OK(status)) {
3358 return status;
3359 }
3360
3361 if (NT_STATUS_IS_ERR(status)) {
3362 return status;
3363 }
3364
3365 /* Return variables */
3366 *type = *r.out.type;
3367
3368 /* Return result */
3369 if (werror) {
3370 *werror = r.out.result;
3371 }
3372
3373 return werror_to_ntstatus(r.out.result);
3374 }
3375
3376 struct rpccli_srvsvc_NetSrvGetInfo_state {
3377 struct srvsvc_NetSrvGetInfo orig;
3378 struct srvsvc_NetSrvGetInfo tmp;
3379 TALLOC_CTX *out_mem_ctx;
3380 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3381 };
3382
3383 static void rpccli_srvsvc_NetSrvGetInfo_done(struct tevent_req *subreq);
3384
3385 struct tevent_req *rpccli_srvsvc_NetSrvGetInfo_send(TALLOC_CTX *mem_ctx,
3386 struct tevent_context *ev,
3387 struct rpc_pipe_client *cli,
3388 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3389 uint32_t _level /* [in] */,
3390 union srvsvc_NetSrvInfo *_info /* [out] [ref,switch_is(level)] */)
3391 {
3392 struct tevent_req *req;
3393 struct rpccli_srvsvc_NetSrvGetInfo_state *state;
3394 struct tevent_req *subreq;
3395
3396 req = tevent_req_create(mem_ctx, &state,
3397 struct rpccli_srvsvc_NetSrvGetInfo_state);
3398 if (req == NULL) {
3399 return NULL;
3400 }
3401 state->out_mem_ctx = NULL;
3402 state->dispatch_recv = cli->dispatch_recv;
3403
3404 /* In parameters */
3405 state->orig.in.server_unc = _server_unc;
3406 state->orig.in.level = _level;
3407
3408 /* Out parameters */
3409 state->orig.out.info = _info;
3410
3411 /* Result */
3412 ZERO_STRUCT(state->orig.out.result);
3413
3414 state->out_mem_ctx = talloc_named_const(state, 0,
3415 "rpccli_srvsvc_NetSrvGetInfo_out_memory");
3416 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3417 return tevent_req_post(req, ev);
3418 }
3419
3420 /* make a temporary copy, that we pass to the dispatch function */
3421 state->tmp = state->orig;
3422
3423 subreq = cli->dispatch_send(state, ev, cli,
3424 &ndr_table_srvsvc,
3425 NDR_SRVSVC_NETSRVGETINFO,
3426 &state->tmp);
3427 if (tevent_req_nomem(subreq, req)) {
3428 return tevent_req_post(req, ev);
3429 }
3430 tevent_req_set_callback(subreq, rpccli_srvsvc_NetSrvGetInfo_done, req);
3431 return req;
3432 }
3433
3434 static void rpccli_srvsvc_NetSrvGetInfo_done(struct tevent_req *subreq)
3435 {
3436 struct tevent_req *req = tevent_req_callback_data(
3437 subreq, struct tevent_req);
3438 struct rpccli_srvsvc_NetSrvGetInfo_state *state = tevent_req_data(
3439 req, struct rpccli_srvsvc_NetSrvGetInfo_state);
3440 NTSTATUS status;
3441 TALLOC_CTX *mem_ctx;
3442
3443 if (state->out_mem_ctx) {
3444 mem_ctx = state->out_mem_ctx;
3445 } else {
3446 mem_ctx = state;
3447 }
3448
3449 status = state->dispatch_recv(subreq, mem_ctx);
3450 TALLOC_FREE(subreq);
3451 if (!NT_STATUS_IS_OK(status)) {
3452 tevent_req_nterror(req, status);
3453 return;
3454 }
3455
3456 /* Copy out parameters */
3457 *state->orig.out.info = *state->tmp.out.info;
3458
3459 /* Copy result */
3460 state->orig.out.result = state->tmp.out.result;
3461
3462 /* Reset temporary structure */
3463 ZERO_STRUCT(state->tmp);
3464
3465 tevent_req_done(req);
3466 }
3467
3468 NTSTATUS rpccli_srvsvc_NetSrvGetInfo_recv(struct tevent_req *req,
3469 TALLOC_CTX *mem_ctx,
3470 WERROR *result)
3471 {
3472 struct rpccli_srvsvc_NetSrvGetInfo_state *state = tevent_req_data(
3473 req, struct rpccli_srvsvc_NetSrvGetInfo_state);
3474 NTSTATUS status;
3475
3476 if (tevent_req_is_nterror(req, &status)) {
3477 tevent_req_received(req);
3478 return status;
3479 }
3480
3481 /* Steal possbile out parameters to the callers context */
3482 talloc_steal(mem_ctx, state->out_mem_ctx);
3483
3484 /* Return result */
3485 *result = state->orig.out.result;
3486
3487 tevent_req_received(req);
3488 return NT_STATUS_OK;
3489 }
3490
3491 NTSTATUS rpccli_srvsvc_NetSrvGetInfo(struct rpc_pipe_client *cli,
3492 TALLOC_CTX *mem_ctx,
3493 const char *server_unc /* [in] [unique,charset(UTF16)] */,
3494 uint32_t level /* [in] */,
3495 union srvsvc_NetSrvInfo *info /* [out] [ref,switch_is(level)] */,
3496 WERROR *werror)
3497 {
3498 struct srvsvc_NetSrvGetInfo r;
3499 NTSTATUS status;
3500
3501 /* In parameters */
3502 r.in.server_unc = server_unc;
3503 r.in.level = level;
3504
3505 status = cli->dispatch(cli,
3506 mem_ctx,
3507 &ndr_table_srvsvc,
3508 NDR_SRVSVC_NETSRVGETINFO,
3509 &r);
3510
3511 if (!NT_STATUS_IS_OK(status)) {
3512 return status;
3513 }
3514
3515 if (NT_STATUS_IS_ERR(status)) {
3516 return status;
3517 }
3518
3519 /* Return variables */
3520 *info = *r.out.info;
3521
3522 /* Return result */
3523 if (werror) {
3524 *werror = r.out.result;
3525 }
3526
3527 return werror_to_ntstatus(r.out.result);
3528 }
3529
3530 struct rpccli_srvsvc_NetSrvSetInfo_state {
3531 struct srvsvc_NetSrvSetInfo orig;
3532 struct srvsvc_NetSrvSetInfo tmp;
3533 TALLOC_CTX *out_mem_ctx;
3534 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3535 };
3536
3537 static void rpccli_srvsvc_NetSrvSetInfo_done(struct tevent_req *subreq);
3538
3539 struct tevent_req *rpccli_srvsvc_NetSrvSetInfo_send(TALLOC_CTX *mem_ctx,
3540 struct tevent_context *ev,
3541 struct rpc_pipe_client *cli,
3542 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3543 uint32_t _level /* [in] */,
3544 union srvsvc_NetSrvInfo *_info /* [in] [ref,switch_is(level)] */,
3545 uint32_t *_parm_error /* [in,out] [unique] */)
3546 {
3547 struct tevent_req *req;
3548 struct rpccli_srvsvc_NetSrvSetInfo_state *state;
3549 struct tevent_req *subreq;
3550
3551 req = tevent_req_create(mem_ctx, &state,
3552 struct rpccli_srvsvc_NetSrvSetInfo_state);
3553 if (req == NULL) {
3554 return NULL;
3555 }
3556 state->out_mem_ctx = NULL;
3557 state->dispatch_recv = cli->dispatch_recv;
3558
3559 /* In parameters */
3560 state->orig.in.server_unc = _server_unc;
3561 state->orig.in.level = _level;
3562 state->orig.in.info = _info;
3563 state->orig.in.parm_error = _parm_error;
3564
3565 /* Out parameters */
3566 state->orig.out.parm_error = _parm_error;
3567
3568 /* Result */
3569 ZERO_STRUCT(state->orig.out.result);
3570
3571 state->out_mem_ctx = talloc_named_const(state, 0,
3572 "rpccli_srvsvc_NetSrvSetInfo_out_memory");
3573 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3574 return tevent_req_post(req, ev);
3575 }
3576
3577 /* make a temporary copy, that we pass to the dispatch function */
3578 state->tmp = state->orig;
3579
3580 subreq = cli->dispatch_send(state, ev, cli,
3581 &ndr_table_srvsvc,
3582 NDR_SRVSVC_NETSRVSETINFO,
3583 &state->tmp);
3584 if (tevent_req_nomem(subreq, req)) {
3585 return tevent_req_post(req, ev);
3586 }
3587 tevent_req_set_callback(subreq, rpccli_srvsvc_NetSrvSetInfo_done, req);
3588 return req;
3589 }
3590
3591 static void rpccli_srvsvc_NetSrvSetInfo_done(struct tevent_req *subreq)
3592 {
3593 struct tevent_req *req = tevent_req_callback_data(
3594 subreq, struct tevent_req);
3595 struct rpccli_srvsvc_NetSrvSetInfo_state *state = tevent_req_data(
3596 req, struct rpccli_srvsvc_NetSrvSetInfo_state);
3597 NTSTATUS status;
3598 TALLOC_CTX *mem_ctx;
3599
3600 if (state->out_mem_ctx) {
3601 mem_ctx = state->out_mem_ctx;
3602 } else {
3603 mem_ctx = state;
3604 }
3605
3606 status = state->dispatch_recv(subreq, mem_ctx);
3607 TALLOC_FREE(subreq);
3608 if (!NT_STATUS_IS_OK(status)) {
3609 tevent_req_nterror(req, status);
3610 return;
3611 }
3612
3613 /* Copy out parameters */
3614 if (state->orig.out.parm_error && state->tmp.out.parm_error) {
3615 *state->orig.out.parm_error = *state->tmp.out.parm_error;
3616 }
3617
3618 /* Copy result */
3619 state->orig.out.result = state->tmp.out.result;
3620
3621 /* Reset temporary structure */
3622 ZERO_STRUCT(state->tmp);
3623
3624 tevent_req_done(req);
3625 }
3626
3627 NTSTATUS rpccli_srvsvc_NetSrvSetInfo_recv(struct tevent_req *req,
3628 TALLOC_CTX *mem_ctx,
3629 WERROR *result)
3630 {
3631 struct rpccli_srvsvc_NetSrvSetInfo_state *state = tevent_req_data(
3632 req, struct rpccli_srvsvc_NetSrvSetInfo_state);
3633 NTSTATUS status;
3634
3635 if (tevent_req_is_nterror(req, &status)) {
3636 tevent_req_received(req);
3637 return status;
3638 }
3639
3640 /* Steal possbile out parameters to the callers context */
3641 talloc_steal(mem_ctx, state->out_mem_ctx);
3642
3643 /* Return result */
3644 *result = state->orig.out.result;
3645
3646 tevent_req_received(req);
3647 return NT_STATUS_OK;
3648 }
3649
3650 NTSTATUS rpccli_srvsvc_NetSrvSetInfo(struct rpc_pipe_client *cli,
3651 TALLOC_CTX *mem_ctx,
3652 const char *server_unc /* [in] [unique,charset(UTF16)] */,
3653 uint32_t level /* [in] */,
3654 union srvsvc_NetSrvInfo *info /* [in] [ref,switch_is(level)] */,
3655 uint32_t *parm_error /* [in,out] [unique] */,
3656 WERROR *werror)
3657 {
3658 struct srvsvc_NetSrvSetInfo r;
3659 NTSTATUS status;
3660
3661 /* In parameters */
3662 r.in.server_unc = server_unc;
3663 r.in.level = level;
3664 r.in.info = info;
3665 r.in.parm_error = parm_error;
3666
3667 status = cli->dispatch(cli,
3668 mem_ctx,
3669 &ndr_table_srvsvc,
3670 NDR_SRVSVC_NETSRVSETINFO,
3671 &r);
3672
3673 if (!NT_STATUS_IS_OK(status)) {
3674 return status;
3675 }
3676
3677 if (NT_STATUS_IS_ERR(status)) {
3678 return status;
3679 }
3680
3681 /* Return variables */
3682 if (parm_error && r.out.parm_error) {
3683 *parm_error = *r.out.parm_error;
3684 }
3685
3686 /* Return result */
3687 if (werror) {
3688 *werror = r.out.result;
3689 }
3690
3691 return werror_to_ntstatus(r.out.result);
3692 }
3693
3694 struct rpccli_srvsvc_NetDiskEnum_state {
3695 struct srvsvc_NetDiskEnum orig;
3696 struct srvsvc_NetDiskEnum tmp;
3697 TALLOC_CTX *out_mem_ctx;
3698 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3699 };
3700
3701 static void rpccli_srvsvc_NetDiskEnum_done(struct tevent_req *subreq);
3702
3703 struct tevent_req *rpccli_srvsvc_NetDiskEnum_send(TALLOC_CTX *mem_ctx,
3704 struct tevent_context *ev,
3705 struct rpc_pipe_client *cli,
3706 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3707 uint32_t _level /* [in] */,
3708 struct srvsvc_NetDiskInfo *_info /* [in,out] [ref] */,
3709 uint32_t _maxlen /* [in] */,
3710 uint32_t *_totalentries /* [out] [ref] */,
3711 uint32_t *_resume_handle /* [in,out] [unique] */)
3712 {
3713 struct tevent_req *req;
3714 struct rpccli_srvsvc_NetDiskEnum_state *state;
3715 struct tevent_req *subreq;
3716
3717 req = tevent_req_create(mem_ctx, &state,
3718 struct rpccli_srvsvc_NetDiskEnum_state);
3719 if (req == NULL) {
3720 return NULL;
3721 }
3722 state->out_mem_ctx = NULL;
3723 state->dispatch_recv = cli->dispatch_recv;
3724
3725 /* In parameters */
3726 state->orig.in.server_unc = _server_unc;
3727 state->orig.in.level = _level;
3728 state->orig.in.info = _info;
3729 state->orig.in.maxlen = _maxlen;
3730 state->orig.in.resume_handle = _resume_handle;
3731
3732 /* Out parameters */
3733 state->orig.out.info = _info;
3734 state->orig.out.totalentries = _totalentries;
3735 state->orig.out.resume_handle = _resume_handle;
3736
3737 /* Result */
3738 ZERO_STRUCT(state->orig.out.result);
3739
3740 state->out_mem_ctx = talloc_named_const(state, 0,
3741 "rpccli_srvsvc_NetDiskEnum_out_memory");
3742 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3743 return tevent_req_post(req, ev);
3744 }
3745
3746 /* make a temporary copy, that we pass to the dispatch function */
3747 state->tmp = state->orig;
3748
3749 subreq = cli->dispatch_send(state, ev, cli,
3750 &ndr_table_srvsvc,
3751 NDR_SRVSVC_NETDISKENUM,
3752 &state->tmp);
3753 if (tevent_req_nomem(subreq, req)) {
3754 return tevent_req_post(req, ev);
3755 }
3756 tevent_req_set_callback(subreq, rpccli_srvsvc_NetDiskEnum_done, req);
3757 return req;
3758 }
3759
3760 static void rpccli_srvsvc_NetDiskEnum_done(struct tevent_req *subreq)
3761 {
3762 struct tevent_req *req = tevent_req_callback_data(
3763 subreq, struct tevent_req);
3764 struct rpccli_srvsvc_NetDiskEnum_state *state = tevent_req_data(
3765 req, struct rpccli_srvsvc_NetDiskEnum_state);
3766 NTSTATUS status;
3767 TALLOC_CTX *mem_ctx;
3768
3769 if (state->out_mem_ctx) {
3770 mem_ctx = state->out_mem_ctx;
3771 } else {
3772 mem_ctx = state;
3773 }
3774
3775 status = state->dispatch_recv(subreq, mem_ctx);
3776 TALLOC_FREE(subreq);
3777 if (!NT_STATUS_IS_OK(status)) {
3778 tevent_req_nterror(req, status);
3779 return;
3780 }
3781
3782 /* Copy out parameters */
3783 *state->orig.out.info = *state->tmp.out.info;
3784 *state->orig.out.totalentries = *state->tmp.out.totalentries;
3785 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
3786 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
3787 }
3788
3789 /* Copy result */
3790 state->orig.out.result = state->tmp.out.result;
3791
3792 /* Reset temporary structure */
3793 ZERO_STRUCT(state->tmp);
3794
3795 tevent_req_done(req);
3796 }
3797
3798 NTSTATUS rpccli_srvsvc_NetDiskEnum_recv(struct tevent_req *req,
3799 TALLOC_CTX *mem_ctx,
3800 WERROR *result)
3801 {
3802 struct rpccli_srvsvc_NetDiskEnum_state *state = tevent_req_data(
3803 req, struct rpccli_srvsvc_NetDiskEnum_state);
3804 NTSTATUS status;
3805
3806 if (tevent_req_is_nterror(req, &status)) {
3807 tevent_req_received(req);
3808 return status;
3809 }
3810
3811 /* Steal possbile out parameters to the callers context */
3812 talloc_steal(mem_ctx, state->out_mem_ctx);
3813
3814 /* Return result */
3815 *result = state->orig.out.result;
3816
3817 tevent_req_received(req);
3818 return NT_STATUS_OK;
3819 }
3820
3821 NTSTATUS rpccli_srvsvc_NetDiskEnum(struct rpc_pipe_client *cli,
3822 TALLOC_CTX *mem_ctx,
3823 const char *server_unc /* [in] [unique,charset(UTF16)] */,
3824 uint32_t level /* [in] */,
3825 struct srvsvc_NetDiskInfo *info /* [in,out] [ref] */,
3826 uint32_t maxlen /* [in] */,
3827 uint32_t *totalentries /* [out] [ref] */,
3828 uint32_t *resume_handle /* [in,out] [unique] */,
3829 WERROR *werror)
3830 {
3831 struct srvsvc_NetDiskEnum r;
3832 NTSTATUS status;
3833
3834 /* In parameters */
3835 r.in.server_unc = server_unc;
3836 r.in.level = level;
3837 r.in.info = info;
3838 r.in.maxlen = maxlen;
3839 r.in.resume_handle = resume_handle;
3840
3841 status = cli->dispatch(cli,
3842 mem_ctx,
3843 &ndr_table_srvsvc,
3844 NDR_SRVSVC_NETDISKENUM,
3845 &r);
3846
3847 if (!NT_STATUS_IS_OK(status)) {
3848 return status;
3849 }
3850
3851 if (NT_STATUS_IS_ERR(status)) {
3852 return status;
3853 }
3854
3855 /* Return variables */
3856 *info = *r.out.info;
3857 *totalentries = *r.out.totalentries;
3858 if (resume_handle && r.out.resume_handle) {
3859 *resume_handle = *r.out.resume_handle;
3860 }
3861
3862 /* Return result */
3863 if (werror) {
3864 *werror = r.out.result;
3865 }
3866
3867 return werror_to_ntstatus(r.out.result);
3868 }
3869
3870 struct rpccli_srvsvc_NetServerStatisticsGet_state {
3871 struct srvsvc_NetServerStatisticsGet orig;
3872 struct srvsvc_NetServerStatisticsGet tmp;
3873 TALLOC_CTX *out_mem_ctx;
3874 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3875 };
3876
3877 static void rpccli_srvsvc_NetServerStatisticsGet_done(struct tevent_req *subreq);
3878
3879 struct tevent_req *rpccli_srvsvc_NetServerStatisticsGet_send(TALLOC_CTX *mem_ctx,
3880 struct tevent_context *ev,
3881 struct rpc_pipe_client *cli,
3882 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3883 const char *_service /* [in] [unique,charset(UTF16)] */,
3884 uint32_t _level /* [in] */,
3885 uint32_t _options /* [in] */,
3886 struct srvsvc_Statistics **_stats /* [out] [ref] */)
3887 {
3888 struct tevent_req *req;
3889 struct rpccli_srvsvc_NetServerStatisticsGet_state *state;
3890 struct tevent_req *subreq;
3891
3892 req = tevent_req_create(mem_ctx, &state,
3893 struct rpccli_srvsvc_NetServerStatisticsGet_state);
3894 if (req == NULL) {
3895 return NULL;
3896 }
3897 state->out_mem_ctx = NULL;
3898 state->dispatch_recv = cli->dispatch_recv;
3899
3900 /* In parameters */
3901 state->orig.in.server_unc = _server_unc;
3902 state->orig.in.service = _service;
3903 state->orig.in.level = _level;
3904 state->orig.in.options = _options;
3905
3906 /* Out parameters */
3907 state->orig.out.stats = _stats;
3908
3909 /* Result */
3910 ZERO_STRUCT(state->orig.out.result);
3911
3912 state->out_mem_ctx = talloc_named_const(state, 0,
3913 "rpccli_srvsvc_NetServerStatisticsGet_out_memory");
3914 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3915 return tevent_req_post(req, ev);
3916 }
3917
3918 /* make a temporary copy, that we pass to the dispatch function */
3919 state->tmp = state->orig;
3920
3921 subreq = cli->dispatch_send(state, ev, cli,
3922 &ndr_table_srvsvc,
3923 NDR_SRVSVC_NETSERVERSTATISTICSGET,
3924 &state->tmp);
3925 if (tevent_req_nomem(subreq, req)) {
3926 return tevent_req_post(req, ev);
3927 }
3928 tevent_req_set_callback(subreq, rpccli_srvsvc_NetServerStatisticsGet_done, req);
3929 return req;
3930 }
3931
3932 static void rpccli_srvsvc_NetServerStatisticsGet_done(struct tevent_req *subreq)
3933 {
3934 struct tevent_req *req = tevent_req_callback_data(
3935 subreq, struct tevent_req);
3936 struct rpccli_srvsvc_NetServerStatisticsGet_state *state = tevent_req_data(
3937 req, struct rpccli_srvsvc_NetServerStatisticsGet_state);
3938 NTSTATUS status;
3939 TALLOC_CTX *mem_ctx;
3940
3941 if (state->out_mem_ctx) {
3942 mem_ctx = state->out_mem_ctx;
3943 } else {
3944 mem_ctx = state;
3945 }
3946
3947 status = state->dispatch_recv(subreq, mem_ctx);
3948 TALLOC_FREE(subreq);
3949 if (!NT_STATUS_IS_OK(status)) {
3950 tevent_req_nterror(req, status);
3951 return;
3952 }
3953
3954 /* Copy out parameters */
3955 *state->orig.out.stats = *state->tmp.out.stats;
3956
3957 /* Copy result */
3958 state->orig.out.result = state->tmp.out.result;
3959
3960 /* Reset temporary structure */
3961 ZERO_STRUCT(state->tmp);
3962
3963 tevent_req_done(req);
3964 }
3965
3966 NTSTATUS rpccli_srvsvc_NetServerStatisticsGet_recv(struct tevent_req *req,
3967 TALLOC_CTX *mem_ctx,
3968 WERROR *result)
3969 {
3970 struct rpccli_srvsvc_NetServerStatisticsGet_state *state = tevent_req_data(
3971 req, struct rpccli_srvsvc_NetServerStatisticsGet_state);
3972 NTSTATUS status;
3973
3974 if (tevent_req_is_nterror(req, &status)) {
3975 tevent_req_received(req);
3976 return status;
3977 }
3978
3979 /* Steal possbile out parameters to the callers context */
3980 talloc_steal(mem_ctx, state->out_mem_ctx);
3981
3982 /* Return result */
3983 *result = state->orig.out.result;
3984
3985 tevent_req_received(req);
3986 return NT_STATUS_OK;
3987 }
3988
3989 NTSTATUS rpccli_srvsvc_NetServerStatisticsGet(struct rpc_pipe_client *cli,
3990 TALLOC_CTX *mem_ctx,
3991 const char *server_unc /* [in] [unique,charset(UTF16)] */,
3992 const char *service /* [in] [unique,charset(UTF16)] */,
3993 uint32_t level /* [in] */,
3994 uint32_t options /* [in] */,
3995 struct srvsvc_Statistics **stats /* [out] [ref] */,
3996 WERROR *werror)
3997 {
3998 struct srvsvc_NetServerStatisticsGet r;
3999 NTSTATUS status;
4000
4001 /* In parameters */
4002 r.in.server_unc = server_unc;
4003 r.in.service = service;
4004 r.in.level = level;
4005 r.in.options = options;
4006
4007 status = cli->dispatch(cli,
4008 mem_ctx,
4009 &ndr_table_srvsvc,
4010 NDR_SRVSVC_NETSERVERSTATISTICSGET,
4011 &r);
4012
4013 if (!NT_STATUS_IS_OK(status)) {
4014 return status;
4015 }
4016
4017 if (NT_STATUS_IS_ERR(status)) {
4018 return status;
4019 }
4020
4021 /* Return variables */
4022 *stats = *r.out.stats;
4023
4024 /* Return result */
4025 if (werror) {
4026 *werror = r.out.result;
4027 }
4028
4029 return werror_to_ntstatus(r.out.result);
4030 }
4031
4032 struct rpccli_srvsvc_NetTransportAdd_state {
4033 struct srvsvc_NetTransportAdd orig;
4034 struct srvsvc_NetTransportAdd tmp;
4035 TALLOC_CTX *out_mem_ctx;
4036 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4037 };
4038
4039 static void rpccli_srvsvc_NetTransportAdd_done(struct tevent_req *subreq);
4040
4041 struct tevent_req *rpccli_srvsvc_NetTransportAdd_send(TALLOC_CTX *mem_ctx,
4042 struct tevent_context *ev,
4043 struct rpc_pipe_client *cli,
4044 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4045 uint32_t _level /* [in] */,
4046 union srvsvc_NetTransportInfo _info /* [in] [switch_is(level)] */)
4047 {
4048 struct tevent_req *req;
4049 struct rpccli_srvsvc_NetTransportAdd_state *state;
4050 struct tevent_req *subreq;
4051
4052 req = tevent_req_create(mem_ctx, &state,
4053 struct rpccli_srvsvc_NetTransportAdd_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.server_unc = _server_unc;
4062 state->orig.in.level = _level;
4063 state->orig.in.info = _info;
4064
4065 /* Out parameters */
4066
4067 /* Result */
4068 ZERO_STRUCT(state->orig.out.result);
4069
4070 /* make a temporary copy, that we pass to the dispatch function */
4071 state->tmp = state->orig;
4072
4073 subreq = cli->dispatch_send(state, ev, cli,
4074 &ndr_table_srvsvc,
4075 NDR_SRVSVC_NETTRANSPORTADD,
4076 &state->tmp);
4077 if (tevent_req_nomem(subreq, req)) {
4078 return tevent_req_post(req, ev);
4079 }
4080 tevent_req_set_callback(subreq, rpccli_srvsvc_NetTransportAdd_done, req);
4081 return req;
4082 }
4083
4084 static void rpccli_srvsvc_NetTransportAdd_done(struct tevent_req *subreq)
4085 {
4086 struct tevent_req *req = tevent_req_callback_data(
4087 subreq, struct tevent_req);
4088 struct rpccli_srvsvc_NetTransportAdd_state *state = tevent_req_data(
4089 req, struct rpccli_srvsvc_NetTransportAdd_state);
4090 NTSTATUS status;
4091 TALLOC_CTX *mem_ctx;
4092
4093 if (state->out_mem_ctx) {
4094 mem_ctx = state->out_mem_ctx;
4095 } else {
4096 mem_ctx = state;
4097 }
4098
4099 status = state->dispatch_recv(subreq, mem_ctx);
4100 TALLOC_FREE(subreq);
4101 if (!NT_STATUS_IS_OK(status)) {
4102 tevent_req_nterror(req, status);
4103 return;
4104 }
4105
4106 /* Copy out parameters */
4107
4108 /* Copy result */
4109 state->orig.out.result = state->tmp.out.result;
4110
4111 /* Reset temporary structure */
4112 ZERO_STRUCT(state->tmp);
4113
4114 tevent_req_done(req);
4115 }
4116
4117 NTSTATUS rpccli_srvsvc_NetTransportAdd_recv(struct tevent_req *req,
4118 TALLOC_CTX *mem_ctx,
4119 WERROR *result)
4120 {
4121 struct rpccli_srvsvc_NetTransportAdd_state *state = tevent_req_data(
4122 req, struct rpccli_srvsvc_NetTransportAdd_state);
4123 NTSTATUS status;
4124
4125 if (tevent_req_is_nterror(req, &status)) {
4126 tevent_req_received(req);
4127 return status;
4128 }
4129
4130 /* Steal possbile out parameters to the callers context */
4131 talloc_steal(mem_ctx, state->out_mem_ctx);
4132
4133 /* Return result */
4134 *result = state->orig.out.result;
4135
4136 tevent_req_received(req);
4137 return NT_STATUS_OK;
4138 }
4139
4140 NTSTATUS rpccli_srvsvc_NetTransportAdd(struct rpc_pipe_client *cli,
4141 TALLOC_CTX *mem_ctx,
4142 const char *server_unc /* [in] [unique,charset(UTF16)] */,
4143 uint32_t level /* [in] */,
4144 union srvsvc_NetTransportInfo info /* [in] [switch_is(level)] */,
4145 WERROR *werror)
4146 {
4147 struct srvsvc_NetTransportAdd r;
4148 NTSTATUS status;
4149
4150 /* In parameters */
4151 r.in.server_unc = server_unc;
4152 r.in.level = level;
4153 r.in.info = info;
4154
4155 status = cli->dispatch(cli,
4156 mem_ctx,
4157 &ndr_table_srvsvc,
4158 NDR_SRVSVC_NETTRANSPORTADD,
4159 &r);
4160
4161 if (!NT_STATUS_IS_OK(status)) {
4162 return status;
4163 }
4164
4165 if (NT_STATUS_IS_ERR(status)) {
4166 return status;
4167 }
4168
4169 /* Return variables */
4170
4171 /* Return result */
4172 if (werror) {
4173 *werror = r.out.result;
4174 }
4175
4176 return werror_to_ntstatus(r.out.result);
4177 }
4178
4179 struct rpccli_srvsvc_NetTransportEnum_state {
4180 struct srvsvc_NetTransportEnum orig;
4181 struct srvsvc_NetTransportEnum tmp;
4182 TALLOC_CTX *out_mem_ctx;
4183 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4184 };
4185
4186 static void rpccli_srvsvc_NetTransportEnum_done(struct tevent_req *subreq);
4187
4188 struct tevent_req *rpccli_srvsvc_NetTransportEnum_send(TALLOC_CTX *mem_ctx,
4189 struct tevent_context *ev,
4190 struct rpc_pipe_client *cli,
4191 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4192 struct srvsvc_NetTransportInfoCtr *_transports /* [in,out] [ref] */,
4193 uint32_t _max_buffer /* [in] */,
4194 uint32_t *_totalentries /* [out] [ref] */,
4195 uint32_t *_resume_handle /* [in,out] [unique] */)
4196 {
4197 struct tevent_req *req;
4198 struct rpccli_srvsvc_NetTransportEnum_state *state;
4199 struct tevent_req *subreq;
4200
4201 req = tevent_req_create(mem_ctx, &state,
4202 struct rpccli_srvsvc_NetTransportEnum_state);
4203 if (req == NULL) {
4204 return NULL;
4205 }
4206 state->out_mem_ctx = NULL;
4207 state->dispatch_recv = cli->dispatch_recv;
4208
4209 /* In parameters */
4210 state->orig.in.server_unc = _server_unc;
4211 state->orig.in.transports = _transports;
4212 state->orig.in.max_buffer = _max_buffer;
4213 state->orig.in.resume_handle = _resume_handle;
4214
4215 /* Out parameters */
4216 state->orig.out.transports = _transports;
4217 state->orig.out.totalentries = _totalentries;
4218 state->orig.out.resume_handle = _resume_handle;
4219
4220 /* Result */
4221 ZERO_STRUCT(state->orig.out.result);
4222
4223 state->out_mem_ctx = talloc_named_const(state, 0,
4224 "rpccli_srvsvc_NetTransportEnum_out_memory");
4225 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4226 return tevent_req_post(req, ev);
4227 }
4228
4229 /* make a temporary copy, that we pass to the dispatch function */
4230 state->tmp = state->orig;
4231
4232 subreq = cli->dispatch_send(state, ev, cli,
4233 &ndr_table_srvsvc,
4234 NDR_SRVSVC_NETTRANSPORTENUM,
4235 &state->tmp);
4236 if (tevent_req_nomem(subreq, req)) {
4237 return tevent_req_post(req, ev);
4238 }
4239 tevent_req_set_callback(subreq, rpccli_srvsvc_NetTransportEnum_done, req);
4240 return req;
4241 }
4242
4243 static void rpccli_srvsvc_NetTransportEnum_done(struct tevent_req *subreq)
4244 {
4245 struct tevent_req *req = tevent_req_callback_data(
4246 subreq, struct tevent_req);
4247 struct rpccli_srvsvc_NetTransportEnum_state *state = tevent_req_data(
4248 req, struct rpccli_srvsvc_NetTransportEnum_state);
4249 NTSTATUS status;
4250 TALLOC_CTX *mem_ctx;
4251
4252 if (state->out_mem_ctx) {
4253 mem_ctx = state->out_mem_ctx;
4254 } else {
4255 mem_ctx = state;
4256 }
4257
4258 status = state->dispatch_recv(subreq, mem_ctx);
4259 TALLOC_FREE(subreq);
4260 if (!NT_STATUS_IS_OK(status)) {
4261 tevent_req_nterror(req, status);
4262 return;
4263 }
4264
4265 /* Copy out parameters */
4266 *state->orig.out.transports = *state->tmp.out.transports;
4267 *state->orig.out.totalentries = *state->tmp.out.totalentries;
4268 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
4269 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
4270 }
4271
4272 /* Copy result */
4273 state->orig.out.result = state->tmp.out.result;
4274
4275 /* Reset temporary structure */
4276 ZERO_STRUCT(state->tmp);
4277
4278 tevent_req_done(req);
4279 }
4280
4281 NTSTATUS rpccli_srvsvc_NetTransportEnum_recv(struct tevent_req *req,
4282 TALLOC_CTX *mem_ctx,
4283 WERROR *result)
4284 {
4285 struct rpccli_srvsvc_NetTransportEnum_state *state = tevent_req_data(
4286 req, struct rpccli_srvsvc_NetTransportEnum_state);
4287 NTSTATUS status;
4288
4289 if (tevent_req_is_nterror(req, &status)) {
4290 tevent_req_received(req);
4291 return status;
4292 }
4293
4294 /* Steal possbile out parameters to the callers context */
4295 talloc_steal(mem_ctx, state->out_mem_ctx);
4296
4297 /* Return result */
4298 *result = state->orig.out.result;
4299
4300 tevent_req_received(req);
4301 return NT_STATUS_OK;
4302 }
4303
4304 NTSTATUS rpccli_srvsvc_NetTransportEnum(struct rpc_pipe_client *cli,
4305 TALLOC_CTX *mem_ctx,
4306 const char *server_unc /* [in] [unique,charset(UTF16)] */,
4307 struct srvsvc_NetTransportInfoCtr *transports /* [in,out] [ref] */,
4308 uint32_t max_buffer /* [in] */,
4309 uint32_t *totalentries /* [out] [ref] */,
4310 uint32_t *resume_handle /* [in,out] [unique] */,
4311 WERROR *werror)
4312 {
4313 struct srvsvc_NetTransportEnum r;
4314 NTSTATUS status;
4315
4316 /* In parameters */
4317 r.in.server_unc = server_unc;
4318 r.in.transports = transports;
4319 r.in.max_buffer = max_buffer;
4320 r.in.resume_handle = resume_handle;
4321
4322 status = cli->dispatch(cli,
4323 mem_ctx,
4324 &ndr_table_srvsvc,
4325 NDR_SRVSVC_NETTRANSPORTENUM,
4326 &r);
4327
4328 if (!NT_STATUS_IS_OK(status)) {
4329 return status;
4330 }
4331
4332 if (NT_STATUS_IS_ERR(status)) {
4333 return status;
4334 }
4335
4336 /* Return variables */
4337 *transports = *r.out.transports;
4338 *totalentries = *r.out.totalentries;
4339 if (resume_handle && r.out.resume_handle) {
4340 *resume_handle = *r.out.resume_handle;
4341 }
4342
4343 /* Return result */
4344 if (werror) {
4345 *werror = r.out.result;
4346 }
4347
4348 return werror_to_ntstatus(r.out.result);
4349 }
4350
4351 struct rpccli_srvsvc_NetTransportDel_state {
4352 struct srvsvc_NetTransportDel orig;
4353 struct srvsvc_NetTransportDel tmp;
4354 TALLOC_CTX *out_mem_ctx;
4355 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4356 };
4357
4358 static void rpccli_srvsvc_NetTransportDel_done(struct tevent_req *subreq);
4359
4360 struct tevent_req *rpccli_srvsvc_NetTransportDel_send(TALLOC_CTX *mem_ctx,
4361 struct tevent_context *ev,
4362 struct rpc_pipe_client *cli,
4363 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4364 uint32_t _level /* [in] */,
4365 struct srvsvc_NetTransportInfo0 *_info0 /* [in] [ref] */)
4366 {
4367 struct tevent_req *req;
4368 struct rpccli_srvsvc_NetTransportDel_state *state;
4369 struct tevent_req *subreq;
4370
4371 req = tevent_req_create(mem_ctx, &state,
4372 struct rpccli_srvsvc_NetTransportDel_state);
4373 if (req == NULL) {
4374 return NULL;
4375 }
4376 state->out_mem_ctx = NULL;
4377 state->dispatch_recv = cli->dispatch_recv;
4378
4379 /* In parameters */
4380 state->orig.in.server_unc = _server_unc;
4381 state->orig.in.level = _level;
4382 state->orig.in.info0 = _info0;
4383
4384 /* Out parameters */
4385
4386 /* Result */
4387 ZERO_STRUCT(state->orig.out.result);
4388
4389 /* make a temporary copy, that we pass to the dispatch function */
4390 state->tmp = state->orig;
4391
4392 subreq = cli->dispatch_send(state, ev, cli,
4393 &ndr_table_srvsvc,
4394 NDR_SRVSVC_NETTRANSPORTDEL,
4395 &state->tmp);
4396 if (tevent_req_nomem(subreq, req)) {
4397 return tevent_req_post(req, ev);
4398 }
4399 tevent_req_set_callback(subreq, rpccli_srvsvc_NetTransportDel_done, req);
4400 return req;
4401 }
4402
4403 static void rpccli_srvsvc_NetTransportDel_done(struct tevent_req *subreq)
4404 {
4405 struct tevent_req *req = tevent_req_callback_data(
4406 subreq, struct tevent_req);
4407 struct rpccli_srvsvc_NetTransportDel_state *state = tevent_req_data(
4408 req, struct rpccli_srvsvc_NetTransportDel_state);
4409 NTSTATUS status;
4410 TALLOC_CTX *mem_ctx;
4411
4412 if (state->out_mem_ctx) {
4413 mem_ctx = state->out_mem_ctx;
4414 } else {
4415 mem_ctx = state;
4416 }
4417
4418 status = state->dispatch_recv(subreq, mem_ctx);
4419 TALLOC_FREE(subreq);
4420 if (!NT_STATUS_IS_OK(status)) {
4421 tevent_req_nterror(req, status);
4422 return;
4423 }
4424
4425 /* Copy out parameters */
4426
4427 /* Copy result */
4428 state->orig.out.result = state->tmp.out.result;
4429
4430 /* Reset temporary structure */
4431 ZERO_STRUCT(state->tmp);
4432
4433 tevent_req_done(req);
4434 }
4435
4436 NTSTATUS rpccli_srvsvc_NetTransportDel_recv(struct tevent_req *req,
4437 TALLOC_CTX *mem_ctx,
4438 WERROR *result)
4439 {
4440 struct rpccli_srvsvc_NetTransportDel_state *state = tevent_req_data(
4441 req, struct rpccli_srvsvc_NetTransportDel_state);
4442 NTSTATUS status;
4443
4444 if (tevent_req_is_nterror(req, &status)) {
4445 tevent_req_received(req);
4446 return status;
4447 }
4448
4449 /* Steal possbile out parameters to the callers context */
4450 talloc_steal(mem_ctx, state->out_mem_ctx);
4451
4452 /* Return result */
4453 *result = state->orig.out.result;
4454
4455 tevent_req_received(req);
4456 return NT_STATUS_OK;
4457 }
4458
4459 NTSTATUS rpccli_srvsvc_NetTransportDel(struct rpc_pipe_client *cli,
4460 TALLOC_CTX *mem_ctx,
4461 const char *server_unc /* [in] [unique,charset(UTF16)] */,
4462 uint32_t level /* [in] */,
4463 struct srvsvc_NetTransportInfo0 *info0 /* [in] [ref] */,
4464 WERROR *werror)
4465 {
4466 struct srvsvc_NetTransportDel r;
4467 NTSTATUS status;
4468
4469 /* In parameters */
4470 r.in.server_unc = server_unc;
4471 r.in.level = level;
4472 r.in.info0 = info0;
4473
4474 status = cli->dispatch(cli,
4475 mem_ctx,
4476 &ndr_table_srvsvc,
4477 NDR_SRVSVC_NETTRANSPORTDEL,
4478 &r);
4479
4480 if (!NT_STATUS_IS_OK(status)) {
4481 return status;
4482 }
4483
4484 if (NT_STATUS_IS_ERR(status)) {
4485 return status;
4486 }
4487
4488 /* Return variables */
4489
4490 /* Return result */
4491 if (werror) {
4492 *werror = r.out.result;
4493 }
4494
4495 return werror_to_ntstatus(r.out.result);
4496 }
4497
4498 struct rpccli_srvsvc_NetRemoteTOD_state {
4499 struct srvsvc_NetRemoteTOD orig;
4500 struct srvsvc_NetRemoteTOD tmp;
4501 TALLOC_CTX *out_mem_ctx;
4502 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4503 };
4504
4505 static void rpccli_srvsvc_NetRemoteTOD_done(struct tevent_req *subreq);
4506
4507 struct tevent_req *rpccli_srvsvc_NetRemoteTOD_send(TALLOC_CTX *mem_ctx,
4508 struct tevent_context *ev,
4509 struct rpc_pipe_client *cli,
4510 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4511 struct srvsvc_NetRemoteTODInfo **_info /* [out] [ref] */)
4512 {
4513 struct tevent_req *req;
4514 struct rpccli_srvsvc_NetRemoteTOD_state *state;
4515 struct tevent_req *subreq;
4516
4517 req = tevent_req_create(mem_ctx, &state,
4518 struct rpccli_srvsvc_NetRemoteTOD_state);
4519 if (req == NULL) {
4520 return NULL;
4521 }
4522 state->out_mem_ctx = NULL;
4523 state->dispatch_recv = cli->dispatch_recv;
4524
4525 /* In parameters */
4526 state->orig.in.server_unc = _server_unc;
4527
4528 /* Out parameters */
4529 state->orig.out.info = _info;
4530
4531 /* Result */
4532 ZERO_STRUCT(state->orig.out.result);
4533
4534 state->out_mem_ctx = talloc_named_const(state, 0,
4535 "rpccli_srvsvc_NetRemoteTOD_out_memory");
4536 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4537 return tevent_req_post(req, ev);
4538 }
4539
4540 /* make a temporary copy, that we pass to the dispatch function */
4541 state->tmp = state->orig;
4542
4543 subreq = cli->dispatch_send(state, ev, cli,
4544 &ndr_table_srvsvc,
4545 NDR_SRVSVC_NETREMOTETOD,
4546 &state->tmp);
4547 if (tevent_req_nomem(subreq, req)) {
4548 return tevent_req_post(req, ev);
4549 }
4550 tevent_req_set_callback(subreq, rpccli_srvsvc_NetRemoteTOD_done, req);
4551 return req;
4552 }
4553
4554 static void rpccli_srvsvc_NetRemoteTOD_done(struct tevent_req *subreq)
4555 {
4556 struct tevent_req *req = tevent_req_callback_data(
4557 subreq, struct tevent_req);
4558 struct rpccli_srvsvc_NetRemoteTOD_state *state = tevent_req_data(
4559 req, struct rpccli_srvsvc_NetRemoteTOD_state);
4560 NTSTATUS status;
4561 TALLOC_CTX *mem_ctx;
4562
4563 if (state->out_mem_ctx) {
4564 mem_ctx = state->out_mem_ctx;
4565 } else {
4566 mem_ctx = state;
4567 }
4568
4569 status = state->dispatch_recv(subreq, mem_ctx);
4570 TALLOC_FREE(subreq);
4571 if (!NT_STATUS_IS_OK(status)) {
4572 tevent_req_nterror(req, status);
4573 return;
4574 }
4575
4576 /* Copy out parameters */
4577 *state->orig.out.info = *state->tmp.out.info;
4578
4579 /* Copy result */
4580 state->orig.out.result = state->tmp.out.result;
4581
4582 /* Reset temporary structure */
4583 ZERO_STRUCT(state->tmp);
4584
4585 tevent_req_done(req);
4586 }
4587
4588 NTSTATUS rpccli_srvsvc_NetRemoteTOD_recv(struct tevent_req *req,
4589 TALLOC_CTX *mem_ctx,
4590 WERROR *result)
4591 {
4592 struct rpccli_srvsvc_NetRemoteTOD_state *state = tevent_req_data(
4593 req, struct rpccli_srvsvc_NetRemoteTOD_state);
4594 NTSTATUS status;
4595
4596 if (tevent_req_is_nterror(req, &status)) {
4597 tevent_req_received(req);
4598 return status;
4599 }
4600
4601 /* Steal possbile out parameters to the callers context */
4602 talloc_steal(mem_ctx, state->out_mem_ctx);
4603
4604 /* Return result */
4605 *result = state->orig.out.result;
4606
4607 tevent_req_received(req);
4608 return NT_STATUS_OK;
4609 }
4610
4611 NTSTATUS rpccli_srvsvc_NetRemoteTOD(struct rpc_pipe_client *cli,
4612 TALLOC_CTX *mem_ctx,
4613 const char *server_unc /* [in] [unique,charset(UTF16)] */,
4614 struct srvsvc_NetRemoteTODInfo **info /* [out] [ref] */,
4615 WERROR *werror)
4616 {
4617 struct srvsvc_NetRemoteTOD r;
4618 NTSTATUS status;
4619
4620 /* In parameters */
4621 r.in.server_unc = server_unc;
4622
4623 status = cli->dispatch(cli,
4624 mem_ctx,
4625 &ndr_table_srvsvc,
4626 NDR_SRVSVC_NETREMOTETOD,
4627 &r);
4628
4629 if (!NT_STATUS_IS_OK(status)) {
4630 return status;
4631 }
4632
4633 if (NT_STATUS_IS_ERR(status)) {
4634 return status;
4635 }
4636
4637 /* Return variables */
4638 *info = *r.out.info;
4639
4640 /* Return result */
4641 if (werror) {
4642 *werror = r.out.result;
4643 }
4644
4645 return werror_to_ntstatus(r.out.result);
4646 }
4647
4648 struct rpccli_srvsvc_NetSetServiceBits_state {
4649 struct srvsvc_NetSetServiceBits orig;
4650 struct srvsvc_NetSetServiceBits tmp;
4651 TALLOC_CTX *out_mem_ctx;
4652 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4653 };
4654
4655 static void rpccli_srvsvc_NetSetServiceBits_done(struct tevent_req *subreq);
4656
4657 struct tevent_req *rpccli_srvsvc_NetSetServiceBits_send(TALLOC_CTX *mem_ctx,
4658 struct tevent_context *ev,
4659 struct rpc_pipe_client *cli,
4660 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4661 const char *_transport /* [in] [unique,charset(UTF16)] */,
4662 uint32_t _servicebits /* [in] */,
4663 uint32_t _updateimmediately /* [in] */)
4664 {
4665 struct tevent_req *req;
4666 struct rpccli_srvsvc_NetSetServiceBits_state *state;
4667 struct tevent_req *subreq;
4668
4669 req = tevent_req_create(mem_ctx, &state,
4670 struct rpccli_srvsvc_NetSetServiceBits_state);
4671 if (req == NULL) {
4672 return NULL;
4673 }
4674 state->out_mem_ctx = NULL;
4675 state->dispatch_recv = cli->dispatch_recv;
4676
4677 /* In parameters */
4678 state->orig.in.server_unc = _server_unc;
4679 state->orig.in.transport = _transport;
4680 state->orig.in.servicebits = _servicebits;
4681 state->orig.in.updateimmediately = _updateimmediately;
4682
4683 /* Out parameters */
4684
4685 /* Result */
4686 ZERO_STRUCT(state->orig.out.result);
4687
4688 /* make a temporary copy, that we pass to the dispatch function */
4689 state->tmp = state->orig;
4690
4691 subreq = cli->dispatch_send(state, ev, cli,
4692 &ndr_table_srvsvc,
4693 NDR_SRVSVC_NETSETSERVICEBITS,
4694 &state->tmp);
4695 if (tevent_req_nomem(subreq, req)) {
4696 return tevent_req_post(req, ev);
4697 }
4698 tevent_req_set_callback(subreq, rpccli_srvsvc_NetSetServiceBits_done, req);
4699 return req;
4700 }
4701
4702 static void rpccli_srvsvc_NetSetServiceBits_done(struct tevent_req *subreq)
4703 {
4704 struct tevent_req *req = tevent_req_callback_data(
4705 subreq, struct tevent_req);
4706 struct rpccli_srvsvc_NetSetServiceBits_state *state = tevent_req_data(
4707 req, struct rpccli_srvsvc_NetSetServiceBits_state);
4708 NTSTATUS status;
4709 TALLOC_CTX *mem_ctx;
4710
4711 if (state->out_mem_ctx) {
4712 mem_ctx = state->out_mem_ctx;
4713 } else {
4714 mem_ctx = state;
4715 }
4716
4717 status = state->dispatch_recv(subreq, mem_ctx);
4718 TALLOC_FREE(subreq);
4719 if (!NT_STATUS_IS_OK(status)) {
4720 tevent_req_nterror(req, status);
4721 return;
4722 }
4723
4724 /* Copy out parameters */
4725
4726 /* Copy result */
4727 state->orig.out.result = state->tmp.out.result;
4728
4729 /* Reset temporary structure */
4730 ZERO_STRUCT(state->tmp);
4731
4732 tevent_req_done(req);
4733 }
4734
4735 NTSTATUS rpccli_srvsvc_NetSetServiceBits_recv(struct tevent_req *req,
4736 TALLOC_CTX *mem_ctx,
4737 WERROR *result)
4738 {
4739 struct rpccli_srvsvc_NetSetServiceBits_state *state = tevent_req_data(
4740 req, struct rpccli_srvsvc_NetSetServiceBits_state);
4741 NTSTATUS status;
4742
4743 if (tevent_req_is_nterror(req, &status)) {
4744 tevent_req_received(req);
4745 return status;
4746 }
4747
4748 /* Steal possbile out parameters to the callers context */
4749 talloc_steal(mem_ctx, state->out_mem_ctx);
4750
4751 /* Return result */
4752 *result = state->orig.out.result;
4753
4754 tevent_req_received(req);
4755 return NT_STATUS_OK;
4756 }
4757
4758 NTSTATUS rpccli_srvsvc_NetSetServiceBits(struct rpc_pipe_client *cli,
4759 TALLOC_CTX *mem_ctx,
4760 const char *server_unc /* [in] [unique,charset(UTF16)] */,
4761 const char *transport /* [in] [unique,charset(UTF16)] */,
4762 uint32_t servicebits /* [in] */,
4763 uint32_t updateimmediately /* [in] */,
4764 WERROR *werror)
4765 {
4766 struct srvsvc_NetSetServiceBits r;
4767 NTSTATUS status;
4768
4769 /* In parameters */
4770 r.in.server_unc = server_unc;
4771 r.in.transport = transport;
4772 r.in.servicebits = servicebits;
4773 r.in.updateimmediately = updateimmediately;
4774
4775 status = cli->dispatch(cli,
4776 mem_ctx,
4777 &ndr_table_srvsvc,
4778 NDR_SRVSVC_NETSETSERVICEBITS,
4779 &r);
4780
4781 if (!NT_STATUS_IS_OK(status)) {
4782 return status;
4783 }
4784
4785 if (NT_STATUS_IS_ERR(status)) {
4786 return status;
4787 }
4788
4789 /* Return variables */
4790
4791 /* Return result */
4792 if (werror) {
4793 *werror = r.out.result;
4794 }
4795
4796 return werror_to_ntstatus(r.out.result);
4797 }
4798
4799 struct rpccli_srvsvc_NetPathType_state {
4800 struct srvsvc_NetPathType orig;
4801 struct srvsvc_NetPathType tmp;
4802 TALLOC_CTX *out_mem_ctx;
4803 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4804 };
4805
4806 static void rpccli_srvsvc_NetPathType_done(struct tevent_req *subreq);
4807
4808 struct tevent_req *rpccli_srvsvc_NetPathType_send(TALLOC_CTX *mem_ctx,
4809 struct tevent_context *ev,
4810 struct rpc_pipe_client *cli,
4811 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4812 const char *_path /* [in] [charset(UTF16)] */,
4813 uint32_t _pathflags /* [in] */,
4814 uint32_t *_pathtype /* [out] [ref] */)
4815 {
4816 struct tevent_req *req;
4817 struct rpccli_srvsvc_NetPathType_state *state;
4818 struct tevent_req *subreq;
4819
4820 req = tevent_req_create(mem_ctx, &state,
4821 struct rpccli_srvsvc_NetPathType_state);
4822 if (req == NULL) {
4823 return NULL;
4824 }
4825 state->out_mem_ctx = NULL;
4826 state->dispatch_recv = cli->dispatch_recv;
4827
4828 /* In parameters */
4829 state->orig.in.server_unc = _server_unc;
4830 state->orig.in.path = _path;
4831 state->orig.in.pathflags = _pathflags;
4832
4833 /* Out parameters */
4834 state->orig.out.pathtype = _pathtype;
4835
4836 /* Result */
4837 ZERO_STRUCT(state->orig.out.result);
4838
4839 state->out_mem_ctx = talloc_named_const(state, 0,
4840 "rpccli_srvsvc_NetPathType_out_memory");
4841 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4842 return tevent_req_post(req, ev);
4843 }
4844
4845 /* make a temporary copy, that we pass to the dispatch function */
4846 state->tmp = state->orig;
4847
4848 subreq = cli->dispatch_send(state, ev, cli,
4849 &ndr_table_srvsvc,
4850 NDR_SRVSVC_NETPATHTYPE,
4851 &state->tmp);
4852 if (tevent_req_nomem(subreq, req)) {
4853 return tevent_req_post(req, ev);
4854 }
4855 tevent_req_set_callback(subreq, rpccli_srvsvc_NetPathType_done, req);
4856 return req;
4857 }
4858
4859 static void rpccli_srvsvc_NetPathType_done(struct tevent_req *subreq)
4860 {
4861 struct tevent_req *req = tevent_req_callback_data(
4862 subreq, struct tevent_req);
4863 struct rpccli_srvsvc_NetPathType_state *state = tevent_req_data(
4864 req, struct rpccli_srvsvc_NetPathType_state);
4865 NTSTATUS status;
4866 TALLOC_CTX *mem_ctx;
4867
4868 if (state->out_mem_ctx) {
4869 mem_ctx = state->out_mem_ctx;
4870 } else {
4871 mem_ctx = state;
4872 }
4873
4874 status = state->dispatch_recv(subreq, mem_ctx);
4875 TALLOC_FREE(subreq);
4876 if (!NT_STATUS_IS_OK(status)) {
4877 tevent_req_nterror(req, status);
4878 return;
4879 }
4880
4881 /* Copy out parameters */
4882 *state->orig.out.pathtype = *state->tmp.out.pathtype;
4883
4884 /* Copy result */
4885 state->orig.out.result = state->tmp.out.result;
4886
4887 /* Reset temporary structure */
4888 ZERO_STRUCT(state->tmp);
4889
4890 tevent_req_done(req);
4891 }
4892
4893 NTSTATUS rpccli_srvsvc_NetPathType_recv(struct tevent_req *req,
4894 TALLOC_CTX *mem_ctx,
4895 WERROR *result)
4896 {
4897 struct rpccli_srvsvc_NetPathType_state *state = tevent_req_data(
4898 req, struct rpccli_srvsvc_NetPathType_state);
4899 NTSTATUS status;
4900
4901 if (tevent_req_is_nterror(req, &status)) {
4902 tevent_req_received(req);
4903 return status;
4904 }
4905
4906 /* Steal possbile out parameters to the callers context */
4907 talloc_steal(mem_ctx, state->out_mem_ctx);
4908
4909 /* Return result */
4910 *result = state->orig.out.result;
4911
4912 tevent_req_received(req);
4913 return NT_STATUS_OK;
4914 }
4915
4916 NTSTATUS rpccli_srvsvc_NetPathType(struct rpc_pipe_client *cli,
4917 TALLOC_CTX *mem_ctx,
4918 const char *server_unc /* [in] [unique,charset(UTF16)] */,
4919 const char *path /* [in] [charset(UTF16)] */,
4920 uint32_t pathflags /* [in] */,
4921 uint32_t *pathtype /* [out] [ref] */,
4922 WERROR *werror)
4923 {
4924 struct srvsvc_NetPathType r;
4925 NTSTATUS status;
4926
4927 /* In parameters */
4928 r.in.server_unc = server_unc;
4929 r.in.path = path;
4930 r.in.pathflags = pathflags;
4931
4932 status = cli->dispatch(cli,
4933 mem_ctx,
4934 &ndr_table_srvsvc,
4935 NDR_SRVSVC_NETPATHTYPE,
4936 &r);
4937
4938 if (!NT_STATUS_IS_OK(status)) {
4939 return status;
4940 }
4941
4942 if (NT_STATUS_IS_ERR(status)) {
4943 return status;
4944 }
4945
4946 /* Return variables */
4947 *pathtype = *r.out.pathtype;
4948
4949 /* Return result */
4950 if (werror) {
4951 *werror = r.out.result;
4952 }
4953
4954 return werror_to_ntstatus(r.out.result);
4955 }
4956
4957 struct rpccli_srvsvc_NetPathCanonicalize_state {
4958 struct srvsvc_NetPathCanonicalize orig;
4959 struct srvsvc_NetPathCanonicalize tmp;
4960 TALLOC_CTX *out_mem_ctx;
4961 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4962 };
4963
4964 static void rpccli_srvsvc_NetPathCanonicalize_done(struct tevent_req *subreq);
4965
4966 struct tevent_req *rpccli_srvsvc_NetPathCanonicalize_send(TALLOC_CTX *mem_ctx,
4967 struct tevent_context *ev,
4968 struct rpc_pipe_client *cli,
4969 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4970 const char *_path /* [in] [charset(UTF16)] */,
4971 uint8_t *_can_path /* [out] [size_is(maxbuf)] */,
4972 uint32_t _maxbuf /* [in] */,
4973 const char *_prefix /* [in] [charset(UTF16)] */,
4974 uint32_t *_pathtype /* [in,out] [ref] */,
4975 uint32_t _pathflags /* [in] */)
4976 {
4977 struct tevent_req *req;
4978 struct rpccli_srvsvc_NetPathCanonicalize_state *state;
4979 struct tevent_req *subreq;
4980
4981 req = tevent_req_create(mem_ctx, &state,
4982 struct rpccli_srvsvc_NetPathCanonicalize_state);
4983 if (req == NULL) {
4984 return NULL;
4985 }
4986 state->out_mem_ctx = NULL;
4987 state->dispatch_recv = cli->dispatch_recv;
4988
4989 /* In parameters */
4990 state->orig.in.server_unc = _server_unc;
4991 state->orig.in.path = _path;
4992 state->orig.in.maxbuf = _maxbuf;
4993 state->orig.in.prefix = _prefix;
4994 state->orig.in.pathtype = _pathtype;
4995 state->orig.in.pathflags = _pathflags;
4996
4997 /* Out parameters */
4998 state->orig.out.can_path = _can_path;
4999 state->orig.out.pathtype = _pathtype;
5000
5001 /* Result */
5002 ZERO_STRUCT(state->orig.out.result);
5003
5004 state->out_mem_ctx = talloc_named_const(state, 0,
5005 "rpccli_srvsvc_NetPathCanonicalize_out_memory");
5006 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5007 return tevent_req_post(req, ev);
5008 }
5009
5010 /* make a temporary copy, that we pass to the dispatch function */
5011 state->tmp = state->orig;
5012
5013 subreq = cli->dispatch_send(state, ev, cli,
5014 &ndr_table_srvsvc,
5015 NDR_SRVSVC_NETPATHCANONICALIZE,
5016 &state->tmp);
5017 if (tevent_req_nomem(subreq, req)) {
5018 return tevent_req_post(req, ev);
5019 }
5020 tevent_req_set_callback(subreq, rpccli_srvsvc_NetPathCanonicalize_done, req);
5021 return req;
5022 }
5023
5024 static void rpccli_srvsvc_NetPathCanonicalize_done(struct tevent_req *subreq)
5025 {
5026 struct tevent_req *req = tevent_req_callback_data(
5027 subreq, struct tevent_req);
5028 struct rpccli_srvsvc_NetPathCanonicalize_state *state = tevent_req_data(
5029 req, struct rpccli_srvsvc_NetPathCanonicalize_state);
5030 NTSTATUS status;
5031 TALLOC_CTX *mem_ctx;
5032
5033 if (state->out_mem_ctx) {
5034 mem_ctx = state->out_mem_ctx;
5035 } else {
5036 mem_ctx = state;
5037 }
5038
5039 status = state->dispatch_recv(subreq, mem_ctx);
5040 TALLOC_FREE(subreq);
5041 if (!NT_STATUS_IS_OK(status)) {
5042 tevent_req_nterror(req, status);
5043 return;
5044 }
5045
5046 /* Copy out parameters */
5047 memcpy(state->orig.out.can_path, state->tmp.out.can_path, (state->tmp.in.maxbuf) * sizeof(*state->orig.out.can_path));
5048 *state->orig.out.pathtype = *state->tmp.out.pathtype;
5049
5050 /* Copy result */
5051 state->orig.out.result = state->tmp.out.result;
5052
5053 /* Reset temporary structure */
5054 ZERO_STRUCT(state->tmp);
5055
5056 tevent_req_done(req);
5057 }
5058
5059 NTSTATUS rpccli_srvsvc_NetPathCanonicalize_recv(struct tevent_req *req,
5060 TALLOC_CTX *mem_ctx,
5061 WERROR *result)
5062 {
5063 struct rpccli_srvsvc_NetPathCanonicalize_state *state = tevent_req_data(
5064 req, struct rpccli_srvsvc_NetPathCanonicalize_state);
5065 NTSTATUS status;
5066
5067 if (tevent_req_is_nterror(req, &status)) {
5068 tevent_req_received(req);
5069 return status;
5070 }
5071
5072 /* Steal possbile out parameters to the callers context */
5073 talloc_steal(mem_ctx, state->out_mem_ctx);
5074
5075 /* Return result */
5076 *result = state->orig.out.result;
5077
5078 tevent_req_received(req);
5079 return NT_STATUS_OK;
5080 }
5081
5082 NTSTATUS rpccli_srvsvc_NetPathCanonicalize(struct rpc_pipe_client *cli,
5083 TALLOC_CTX *mem_ctx,
5084 const char *server_unc /* [in] [unique,charset(UTF16)] */,
5085 const char *path /* [in] [charset(UTF16)] */,
5086 uint8_t *can_path /* [out] [size_is(maxbuf)] */,
5087 uint32_t maxbuf /* [in] */,
5088 const char *prefix /* [in] [charset(UTF16)] */,
5089 uint32_t *pathtype /* [in,out] [ref] */,
5090 uint32_t pathflags /* [in] */,
5091 WERROR *werror)
5092 {
5093 struct srvsvc_NetPathCanonicalize r;
5094 NTSTATUS status;
5095
5096 /* In parameters */
5097 r.in.server_unc = server_unc;
5098 r.in.path = path;
5099 r.in.maxbuf = maxbuf;
5100 r.in.prefix = prefix;
5101 r.in.pathtype = pathtype;
5102 r.in.pathflags = pathflags;
5103
5104 status = cli->dispatch(cli,
5105 mem_ctx,
5106 &ndr_table_srvsvc,
5107 NDR_SRVSVC_NETPATHCANONICALIZE,
5108 &r);
5109
5110 if (!NT_STATUS_IS_OK(status)) {
5111 return status;
5112 }
5113
5114 if (NT_STATUS_IS_ERR(status)) {
5115 return status;
5116 }
5117
5118 /* Return variables */
5119 memcpy(can_path, r.out.can_path, (r.in.maxbuf) * sizeof(*can_path));
5120 *pathtype = *r.out.pathtype;
5121
5122 /* Return result */
5123 if (werror) {
5124 *werror = r.out.result;
5125 }
5126
5127 return werror_to_ntstatus(r.out.result);
5128 }
5129
5130 struct rpccli_srvsvc_NetPathCompare_state {
5131 struct srvsvc_NetPathCompare orig;
5132 struct srvsvc_NetPathCompare tmp;
5133 TALLOC_CTX *out_mem_ctx;
5134 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5135 };
5136
5137 static void rpccli_srvsvc_NetPathCompare_done(struct tevent_req *subreq);
5138
5139 struct tevent_req *rpccli_srvsvc_NetPathCompare_send(TALLOC_CTX *mem_ctx,
5140 struct tevent_context *ev,
5141 struct rpc_pipe_client *cli,
5142 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5143 const char *_path1 /* [in] [charset(UTF16)] */,
5144 const char *_path2 /* [in] [charset(UTF16)] */,
5145 uint32_t _pathtype /* [in] */,
5146 uint32_t _pathflags /* [in] */)
5147 {
5148 struct tevent_req *req;
5149 struct rpccli_srvsvc_NetPathCompare_state *state;
5150 struct tevent_req *subreq;
5151
5152 req = tevent_req_create(mem_ctx, &state,
5153 struct rpccli_srvsvc_NetPathCompare_state);
5154 if (req == NULL) {
5155 return NULL;
5156 }
5157 state->out_mem_ctx = NULL;
5158 state->dispatch_recv = cli->dispatch_recv;
5159
5160 /* In parameters */
5161 state->orig.in.server_unc = _server_unc;
5162 state->orig.in.path1 = _path1;
5163 state->orig.in.path2 = _path2;
5164 state->orig.in.pathtype = _pathtype;
5165 state->orig.in.pathflags = _pathflags;
5166
5167 /* Out parameters */
5168
5169 /* Result */
5170 ZERO_STRUCT(state->orig.out.result);
5171
5172 /* make a temporary copy, that we pass to the dispatch function */
5173 state->tmp = state->orig;
5174
5175 subreq = cli->dispatch_send(state, ev, cli,
5176 &ndr_table_srvsvc,
5177 NDR_SRVSVC_NETPATHCOMPARE,
5178 &state->tmp);
5179 if (tevent_req_nomem(subreq, req)) {
5180 return tevent_req_post(req, ev);
5181 }
5182 tevent_req_set_callback(subreq, rpccli_srvsvc_NetPathCompare_done, req);
5183 return req;
5184 }
5185
5186 static void rpccli_srvsvc_NetPathCompare_done(struct tevent_req *subreq)
5187 {
5188 struct tevent_req *req = tevent_req_callback_data(
5189 subreq, struct tevent_req);
5190 struct rpccli_srvsvc_NetPathCompare_state *state = tevent_req_data(
5191 req, struct rpccli_srvsvc_NetPathCompare_state);
5192 NTSTATUS status;
5193 TALLOC_CTX *mem_ctx;
5194
5195 if (state->out_mem_ctx) {
5196 mem_ctx = state->out_mem_ctx;
5197 } else {
5198 mem_ctx = state;
5199 }
5200
5201 status = state->dispatch_recv(subreq, mem_ctx);
5202 TALLOC_FREE(subreq);
5203 if (!NT_STATUS_IS_OK(status)) {
5204 tevent_req_nterror(req, status);
5205 return;
5206 }
5207
5208 /* Copy out parameters */
5209
5210 /* Copy result */
5211 state->orig.out.result = state->tmp.out.result;
5212
5213 /* Reset temporary structure */
5214 ZERO_STRUCT(state->tmp);
5215
5216 tevent_req_done(req);
5217 }
5218
5219 NTSTATUS rpccli_srvsvc_NetPathCompare_recv(struct tevent_req *req,
5220 TALLOC_CTX *mem_ctx,
5221 WERROR *result)
5222 {
5223 struct rpccli_srvsvc_NetPathCompare_state *state = tevent_req_data(
5224 req, struct rpccli_srvsvc_NetPathCompare_state);
5225 NTSTATUS status;
5226
5227 if (tevent_req_is_nterror(req, &status)) {
5228 tevent_req_received(req);
5229 return status;
5230 }
5231
5232 /* Steal possbile out parameters to the callers context */
5233 talloc_steal(mem_ctx, state->out_mem_ctx);
5234
5235 /* Return result */
5236 *result = state->orig.out.result;
5237
5238 tevent_req_received(req);
5239 return NT_STATUS_OK;
5240 }
5241
5242 NTSTATUS rpccli_srvsvc_NetPathCompare(struct rpc_pipe_client *cli,
5243 TALLOC_CTX *mem_ctx,
5244 const char *server_unc /* [in] [unique,charset(UTF16)] */,
5245 const char *path1 /* [in] [charset(UTF16)] */,
5246 const char *path2 /* [in] [charset(UTF16)] */,
5247 uint32_t pathtype /* [in] */,
5248 uint32_t pathflags /* [in] */,
5249 WERROR *werror)
5250 {
5251 struct srvsvc_NetPathCompare r;
5252 NTSTATUS status;
5253
5254 /* In parameters */
5255 r.in.server_unc = server_unc;
5256 r.in.path1 = path1;
5257 r.in.path2 = path2;
5258 r.in.pathtype = pathtype;
5259 r.in.pathflags = pathflags;
5260
5261 status = cli->dispatch(cli,
5262 mem_ctx,
5263 &ndr_table_srvsvc,
5264 NDR_SRVSVC_NETPATHCOMPARE,
5265 &r);
5266
5267 if (!NT_STATUS_IS_OK(status)) {
5268 return status;
5269 }
5270
5271 if (NT_STATUS_IS_ERR(status)) {
5272 return status;
5273 }
5274
5275 /* Return variables */
5276
5277 /* Return result */
5278 if (werror) {
5279 *werror = r.out.result;
5280 }
5281
5282 return werror_to_ntstatus(r.out.result);
5283 }
5284
5285 struct rpccli_srvsvc_NetNameValidate_state {
5286 struct srvsvc_NetNameValidate orig;
5287 struct srvsvc_NetNameValidate tmp;
5288 TALLOC_CTX *out_mem_ctx;
5289 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5290 };
5291
5292 static void rpccli_srvsvc_NetNameValidate_done(struct tevent_req *subreq);
5293
5294 struct tevent_req *rpccli_srvsvc_NetNameValidate_send(TALLOC_CTX *mem_ctx,
5295 struct tevent_context *ev,
5296 struct rpc_pipe_client *cli,
5297 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5298 const char *_name /* [in] [charset(UTF16)] */,
5299 uint32_t _name_type /* [in] */,
5300 uint32_t _flags /* [in] */)
5301 {
5302 struct tevent_req *req;
5303 struct rpccli_srvsvc_NetNameValidate_state *state;
5304 struct tevent_req *subreq;
5305
5306 req = tevent_req_create(mem_ctx, &state,
5307 struct rpccli_srvsvc_NetNameValidate_state);
5308 if (req == NULL) {
5309 return NULL;
5310 }
5311 state->out_mem_ctx = NULL;
5312 state->dispatch_recv = cli->dispatch_recv;
5313
5314 /* In parameters */
5315 state->orig.in.server_unc = _server_unc;
5316 state->orig.in.name = _name;
5317 state->orig.in.name_type = _name_type;
5318 state->orig.in.flags = _flags;
5319
5320 /* Out parameters */
5321
5322 /* Result */
5323 ZERO_STRUCT(state->orig.out.result);
5324
5325 /* make a temporary copy, that we pass to the dispatch function */
5326 state->tmp = state->orig;
5327
5328 subreq = cli->dispatch_send(state, ev, cli,
5329 &ndr_table_srvsvc,
5330 NDR_SRVSVC_NETNAMEVALIDATE,
5331 &state->tmp);
5332 if (tevent_req_nomem(subreq, req)) {
5333 return tevent_req_post(req, ev);
5334 }
5335 tevent_req_set_callback(subreq, rpccli_srvsvc_NetNameValidate_done, req);
5336 return req;
5337 }
5338
5339 static void rpccli_srvsvc_NetNameValidate_done(struct tevent_req *subreq)
5340 {
5341 struct tevent_req *req = tevent_req_callback_data(
5342 subreq, struct tevent_req);
5343 struct rpccli_srvsvc_NetNameValidate_state *state = tevent_req_data(
5344 req, struct rpccli_srvsvc_NetNameValidate_state);
5345 NTSTATUS status;
5346 TALLOC_CTX *mem_ctx;
5347
5348 if (state->out_mem_ctx) {
5349 mem_ctx = state->out_mem_ctx;
5350 } else {
5351 mem_ctx = state;
5352 }
5353
5354 status = state->dispatch_recv(subreq, mem_ctx);
5355 TALLOC_FREE(subreq);
5356 if (!NT_STATUS_IS_OK(status)) {
5357 tevent_req_nterror(req, status);
5358 return;
5359 }
5360
5361 /* Copy out parameters */
5362
5363 /* Copy result */
5364 state->orig.out.result = state->tmp.out.result;
5365
5366 /* Reset temporary structure */
5367 ZERO_STRUCT(state->tmp);
5368
5369 tevent_req_done(req);
5370 }
5371
5372 NTSTATUS rpccli_srvsvc_NetNameValidate_recv(struct tevent_req *req,
5373 TALLOC_CTX *mem_ctx,
5374 WERROR *result)
5375 {
5376 struct rpccli_srvsvc_NetNameValidate_state *state = tevent_req_data(
5377 req, struct rpccli_srvsvc_NetNameValidate_state);
5378 NTSTATUS status;
5379
5380 if (tevent_req_is_nterror(req, &status)) {
5381 tevent_req_received(req);
5382 return status;
5383 }
5384
5385 /* Steal possbile out parameters to the callers context */
5386 talloc_steal(mem_ctx, state->out_mem_ctx);
5387
5388 /* Return result */
5389 *result = state->orig.out.result;
5390
5391 tevent_req_received(req);
5392 return NT_STATUS_OK;
5393 }
5394
5395 NTSTATUS rpccli_srvsvc_NetNameValidate(struct rpc_pipe_client *cli,
5396 TALLOC_CTX *mem_ctx,
5397 const char *server_unc /* [in] [unique,charset(UTF16)] */,
5398 const char *name /* [in] [charset(UTF16)] */,
5399 uint32_t name_type /* [in] */,
5400 uint32_t flags /* [in] */,
5401 WERROR *werror)
5402 {
5403 struct srvsvc_NetNameValidate r;
5404 NTSTATUS status;
5405
5406 /* In parameters */
5407 r.in.server_unc = server_unc;
5408 r.in.name = name;
5409 r.in.name_type = name_type;
5410 r.in.flags = flags;
5411
5412 status = cli->dispatch(cli,
5413 mem_ctx,
5414 &ndr_table_srvsvc,
5415 NDR_SRVSVC_NETNAMEVALIDATE,
5416 &r);
5417
5418 if (!NT_STATUS_IS_OK(status)) {
5419 return status;
5420 }
5421
5422 if (NT_STATUS_IS_ERR(status)) {
5423 return status;
5424 }
5425
5426 /* Return variables */
5427
5428 /* Return result */
5429 if (werror) {
5430 *werror = r.out.result;
5431 }
5432
5433 return werror_to_ntstatus(r.out.result);
5434 }
5435
5436 struct rpccli_srvsvc_NETRPRNAMECANONICALIZE_state {
5437 struct srvsvc_NETRPRNAMECANONICALIZE orig;
5438 struct srvsvc_NETRPRNAMECANONICALIZE tmp;
5439 TALLOC_CTX *out_mem_ctx;
5440 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5441 };
5442
5443 static void rpccli_srvsvc_NETRPRNAMECANONICALIZE_done(struct tevent_req *subreq);
5444
5445 struct tevent_req *rpccli_srvsvc_NETRPRNAMECANONICALIZE_send(TALLOC_CTX *mem_ctx,
5446 struct tevent_context *ev,
5447 struct rpc_pipe_client *cli)
5448 {
5449 struct tevent_req *req;
5450 struct rpccli_srvsvc_NETRPRNAMECANONICALIZE_state *state;
5451 struct tevent_req *subreq;
5452
5453 req = tevent_req_create(mem_ctx, &state,
5454 struct rpccli_srvsvc_NETRPRNAMECANONICALIZE_state);
5455 if (req == NULL) {
5456 return NULL;
5457 }
5458 state->out_mem_ctx = NULL;
5459 state->dispatch_recv = cli->dispatch_recv;
5460
5461 /* In parameters */
5462
5463 /* Out parameters */
5464
5465 /* Result */
5466 ZERO_STRUCT(state->orig.out.result);
5467
5468 /* make a temporary copy, that we pass to the dispatch function */
5469 state->tmp = state->orig;
5470
5471 subreq = cli->dispatch_send(state, ev, cli,
5472 &ndr_table_srvsvc,
5473 NDR_SRVSVC_NETRPRNAMECANONICALIZE,
5474 &state->tmp);
5475 if (tevent_req_nomem(subreq, req)) {
5476 return tevent_req_post(req, ev);
5477 }
5478 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRPRNAMECANONICALIZE_done, req);
5479 return req;
5480 }
5481
5482 static void rpccli_srvsvc_NETRPRNAMECANONICALIZE_done(struct tevent_req *subreq)
5483 {
5484 struct tevent_req *req = tevent_req_callback_data(
5485 subreq, struct tevent_req);
5486 struct rpccli_srvsvc_NETRPRNAMECANONICALIZE_state *state = tevent_req_data(
5487 req, struct rpccli_srvsvc_NETRPRNAMECANONICALIZE_state);
5488 NTSTATUS status;
5489 TALLOC_CTX *mem_ctx;
5490
5491 if (state->out_mem_ctx) {
5492 mem_ctx = state->out_mem_ctx;
5493 } else {
5494 mem_ctx = state;
5495 }
5496
5497 status = state->dispatch_recv(subreq, mem_ctx);
5498 TALLOC_FREE(subreq);
5499 if (!NT_STATUS_IS_OK(status)) {
5500 tevent_req_nterror(req, status);
5501 return;
5502 }
5503
5504 /* Copy out parameters */
5505
5506 /* Copy result */
5507 state->orig.out.result = state->tmp.out.result;
5508
5509 /* Reset temporary structure */
5510 ZERO_STRUCT(state->tmp);
5511
5512 tevent_req_done(req);
5513 }
5514
5515 NTSTATUS rpccli_srvsvc_NETRPRNAMECANONICALIZE_recv(struct tevent_req *req,
5516 TALLOC_CTX *mem_ctx,
5517 WERROR *result)
5518 {
5519 struct rpccli_srvsvc_NETRPRNAMECANONICALIZE_state *state = tevent_req_data(
5520 req, struct rpccli_srvsvc_NETRPRNAMECANONICALIZE_state);
5521 NTSTATUS status;
5522
5523 if (tevent_req_is_nterror(req, &status)) {
5524 tevent_req_received(req);
5525 return status;
5526 }
5527
5528 /* Steal possbile out parameters to the callers context */
5529 talloc_steal(mem_ctx, state->out_mem_ctx);
5530
5531 /* Return result */
5532 *result = state->orig.out.result;
5533
5534 tevent_req_received(req);
5535 return NT_STATUS_OK;
5536 }
5537
5538 NTSTATUS rpccli_srvsvc_NETRPRNAMECANONICALIZE(struct rpc_pipe_client *cli,
5539 TALLOC_CTX *mem_ctx,
5540 WERROR *werror)
5541 {
5542 struct srvsvc_NETRPRNAMECANONICALIZE r;
5543 NTSTATUS status;
5544
5545 /* In parameters */
5546
5547 status = cli->dispatch(cli,
5548 mem_ctx,
5549 &ndr_table_srvsvc,
5550 NDR_SRVSVC_NETRPRNAMECANONICALIZE,
5551 &r);
5552
5553 if (!NT_STATUS_IS_OK(status)) {
5554 return status;
5555 }
5556
5557 if (NT_STATUS_IS_ERR(status)) {
5558 return status;
5559 }
5560
5561 /* Return variables */
5562
5563 /* Return result */
5564 if (werror) {
5565 *werror = r.out.result;
5566 }
5567
5568 return werror_to_ntstatus(r.out.result);
5569 }
5570
5571 struct rpccli_srvsvc_NetPRNameCompare_state {
5572 struct srvsvc_NetPRNameCompare orig;
5573 struct srvsvc_NetPRNameCompare tmp;
5574 TALLOC_CTX *out_mem_ctx;
5575 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5576 };
5577
5578 static void rpccli_srvsvc_NetPRNameCompare_done(struct tevent_req *subreq);
5579
5580 struct tevent_req *rpccli_srvsvc_NetPRNameCompare_send(TALLOC_CTX *mem_ctx,
5581 struct tevent_context *ev,
5582 struct rpc_pipe_client *cli,
5583 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5584 const char *_name1 /* [in] [charset(UTF16)] */,
5585 const char *_name2 /* [in] [charset(UTF16)] */,
5586 uint32_t _name_type /* [in] */,
5587 uint32_t _flags /* [in] */)
5588 {
5589 struct tevent_req *req;
5590 struct rpccli_srvsvc_NetPRNameCompare_state *state;
5591 struct tevent_req *subreq;
5592
5593 req = tevent_req_create(mem_ctx, &state,
5594 struct rpccli_srvsvc_NetPRNameCompare_state);
5595 if (req == NULL) {
5596 return NULL;
5597 }
5598 state->out_mem_ctx = NULL;
5599 state->dispatch_recv = cli->dispatch_recv;
5600
5601 /* In parameters */
5602 state->orig.in.server_unc = _server_unc;
5603 state->orig.in.name1 = _name1;
5604 state->orig.in.name2 = _name2;
5605 state->orig.in.name_type = _name_type;
5606 state->orig.in.flags = _flags;
5607
5608 /* Out parameters */
5609
5610 /* Result */
5611 ZERO_STRUCT(state->orig.out.result);
5612
5613 /* make a temporary copy, that we pass to the dispatch function */
5614 state->tmp = state->orig;
5615
5616 subreq = cli->dispatch_send(state, ev, cli,
5617 &ndr_table_srvsvc,
5618 NDR_SRVSVC_NETPRNAMECOMPARE,
5619 &state->tmp);
5620 if (tevent_req_nomem(subreq, req)) {
5621 return tevent_req_post(req, ev);
5622 }
5623 tevent_req_set_callback(subreq, rpccli_srvsvc_NetPRNameCompare_done, req);
5624 return req;
5625 }
5626
5627 static void rpccli_srvsvc_NetPRNameCompare_done(struct tevent_req *subreq)
5628 {
5629 struct tevent_req *req = tevent_req_callback_data(
5630 subreq, struct tevent_req);
5631 struct rpccli_srvsvc_NetPRNameCompare_state *state = tevent_req_data(
5632 req, struct rpccli_srvsvc_NetPRNameCompare_state);
5633 NTSTATUS status;
5634 TALLOC_CTX *mem_ctx;
5635
5636 if (state->out_mem_ctx) {
5637 mem_ctx = state->out_mem_ctx;
5638 } else {
5639 mem_ctx = state;
5640 }
5641
5642 status = state->dispatch_recv(subreq, mem_ctx);
5643 TALLOC_FREE(subreq);
5644 if (!NT_STATUS_IS_OK(status)) {
5645 tevent_req_nterror(req, status);
5646 return;
5647 }
5648
5649 /* Copy out parameters */
5650
5651 /* Copy result */
5652 state->orig.out.result = state->tmp.out.result;
5653
5654 /* Reset temporary structure */
5655 ZERO_STRUCT(state->tmp);
5656
5657 tevent_req_done(req);
5658 }
5659
5660 NTSTATUS rpccli_srvsvc_NetPRNameCompare_recv(struct tevent_req *req,
5661 TALLOC_CTX *mem_ctx,
5662 WERROR *result)
5663 {
5664 struct rpccli_srvsvc_NetPRNameCompare_state *state = tevent_req_data(
5665 req, struct rpccli_srvsvc_NetPRNameCompare_state);
5666 NTSTATUS status;
5667
5668 if (tevent_req_is_nterror(req, &status)) {
5669 tevent_req_received(req);
5670 return status;
5671 }
5672
5673 /* Steal possbile out parameters to the callers context */
5674 talloc_steal(mem_ctx, state->out_mem_ctx);
5675
5676 /* Return result */
5677 *result = state->orig.out.result;
5678
5679 tevent_req_received(req);
5680 return NT_STATUS_OK;
5681 }
5682
5683 NTSTATUS rpccli_srvsvc_NetPRNameCompare(struct rpc_pipe_client *cli,
5684 TALLOC_CTX *mem_ctx,
5685 const char *server_unc /* [in] [unique,charset(UTF16)] */,
5686 const char *name1 /* [in] [charset(UTF16)] */,
5687 const char *name2 /* [in] [charset(UTF16)] */,
5688 uint32_t name_type /* [in] */,
5689 uint32_t flags /* [in] */,
5690 WERROR *werror)
5691 {
5692 struct srvsvc_NetPRNameCompare r;
5693 NTSTATUS status;
5694
5695 /* In parameters */
5696 r.in.server_unc = server_unc;
5697 r.in.name1 = name1;
5698 r.in.name2 = name2;
5699 r.in.name_type = name_type;
5700 r.in.flags = flags;
5701
5702 status = cli->dispatch(cli,
5703 mem_ctx,
5704 &ndr_table_srvsvc,
5705 NDR_SRVSVC_NETPRNAMECOMPARE,
5706 &r);
5707
5708 if (!NT_STATUS_IS_OK(status)) {
5709 return status;
5710 }
5711
5712 if (NT_STATUS_IS_ERR(status)) {
5713 return status;
5714 }
5715
5716 /* Return variables */
5717
5718 /* Return result */
5719 if (werror) {
5720 *werror = r.out.result;
5721 }
5722
5723 return werror_to_ntstatus(r.out.result);
5724 }
5725
5726 struct rpccli_srvsvc_NetShareEnum_state {
5727 struct srvsvc_NetShareEnum orig;
5728 struct srvsvc_NetShareEnum tmp;
5729 TALLOC_CTX *out_mem_ctx;
5730 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5731 };
5732
5733 static void rpccli_srvsvc_NetShareEnum_done(struct tevent_req *subreq);
5734
5735 struct tevent_req *rpccli_srvsvc_NetShareEnum_send(TALLOC_CTX *mem_ctx,
5736 struct tevent_context *ev,
5737 struct rpc_pipe_client *cli,
5738 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5739 struct srvsvc_NetShareInfoCtr *_info_ctr /* [in,out] [ref] */,
5740 uint32_t _max_buffer /* [in] */,
5741 uint32_t *_totalentries /* [out] [ref] */,
5742 uint32_t *_resume_handle /* [in,out] [unique] */)
5743 {
5744 struct tevent_req *req;
5745 struct rpccli_srvsvc_NetShareEnum_state *state;
5746 struct tevent_req *subreq;
5747
5748 req = tevent_req_create(mem_ctx, &state,
5749 struct rpccli_srvsvc_NetShareEnum_state);
5750 if (req == NULL) {
5751 return NULL;
5752 }
5753 state->out_mem_ctx = NULL;
5754 state->dispatch_recv = cli->dispatch_recv;
5755
5756 /* In parameters */
5757 state->orig.in.server_unc = _server_unc;
5758 state->orig.in.info_ctr = _info_ctr;
5759 state->orig.in.max_buffer = _max_buffer;
5760 state->orig.in.resume_handle = _resume_handle;
5761
5762 /* Out parameters */
5763 state->orig.out.info_ctr = _info_ctr;
5764 state->orig.out.totalentries = _totalentries;
5765 state->orig.out.resume_handle = _resume_handle;
5766
5767 /* Result */
5768 ZERO_STRUCT(state->orig.out.result);
5769
5770 state->out_mem_ctx = talloc_named_const(state, 0,
5771 "rpccli_srvsvc_NetShareEnum_out_memory");
5772 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5773 return tevent_req_post(req, ev);
5774 }
5775
5776 /* make a temporary copy, that we pass to the dispatch function */
5777 state->tmp = state->orig;
5778
5779 subreq = cli->dispatch_send(state, ev, cli,
5780 &ndr_table_srvsvc,
5781 NDR_SRVSVC_NETSHAREENUM,
5782 &state->tmp);
5783 if (tevent_req_nomem(subreq, req)) {
5784 return tevent_req_post(req, ev);
5785 }
5786 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareEnum_done, req);
5787 return req;
5788 }
5789
5790 static void rpccli_srvsvc_NetShareEnum_done(struct tevent_req *subreq)
5791 {
5792 struct tevent_req *req = tevent_req_callback_data(
5793 subreq, struct tevent_req);
5794 struct rpccli_srvsvc_NetShareEnum_state *state = tevent_req_data(
5795 req, struct rpccli_srvsvc_NetShareEnum_state);
5796 NTSTATUS status;
5797 TALLOC_CTX *mem_ctx;
5798
5799 if (state->out_mem_ctx) {
5800 mem_ctx = state->out_mem_ctx;
5801 } else {
5802 mem_ctx = state;
5803 }
5804
5805 status = state->dispatch_recv(subreq, mem_ctx);
5806 TALLOC_FREE(subreq);
5807 if (!NT_STATUS_IS_OK(status)) {
5808 tevent_req_nterror(req, status);
5809 return;
5810 }
5811
5812 /* Copy out parameters */
5813 *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
5814 *state->orig.out.totalentries = *state->tmp.out.totalentries;
5815 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
5816 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
5817 }
5818
5819 /* Copy result */
5820 state->orig.out.result = state->tmp.out.result;
5821
5822 /* Reset temporary structure */
5823 ZERO_STRUCT(state->tmp);
5824
5825 tevent_req_done(req);
5826 }
5827
5828 NTSTATUS rpccli_srvsvc_NetShareEnum_recv(struct tevent_req *req,
5829 TALLOC_CTX *mem_ctx,
5830 WERROR *result)
5831 {
5832 struct rpccli_srvsvc_NetShareEnum_state *state = tevent_req_data(
5833 req, struct rpccli_srvsvc_NetShareEnum_state);
5834 NTSTATUS status;
5835
5836 if (tevent_req_is_nterror(req, &status)) {
5837 tevent_req_received(req);
5838 return status;
5839 }
5840
5841 /* Steal possbile out parameters to the callers context */
5842 talloc_steal(mem_ctx, state->out_mem_ctx);
5843
5844 /* Return result */
5845 *result = state->orig.out.result;
5846
5847 tevent_req_received(req);
5848 return NT_STATUS_OK;
5849 }
5850
5851 NTSTATUS rpccli_srvsvc_NetShareEnum(struct rpc_pipe_client *cli,
5852 TALLOC_CTX *mem_ctx,
5853 const char *server_unc /* [in] [unique,charset(UTF16)] */,
5854 struct srvsvc_NetShareInfoCtr *info_ctr /* [in,out] [ref] */,
5855 uint32_t max_buffer /* [in] */,
5856 uint32_t *totalentries /* [out] [ref] */,
5857 uint32_t *resume_handle /* [in,out] [unique] */,
5858 WERROR *werror)
5859 {
5860 struct srvsvc_NetShareEnum r;
5861 NTSTATUS status;
5862
5863 /* In parameters */
5864 r.in.server_unc = server_unc;
5865 r.in.info_ctr = info_ctr;
5866 r.in.max_buffer = max_buffer;
5867 r.in.resume_handle = resume_handle;
5868
5869 status = cli->dispatch(cli,
5870 mem_ctx,
5871 &ndr_table_srvsvc,
5872 NDR_SRVSVC_NETSHAREENUM,
5873 &r);
5874
5875 if (!NT_STATUS_IS_OK(status)) {
5876 return status;
5877 }
5878
5879 if (NT_STATUS_IS_ERR(status)) {
5880 return status;
5881 }
5882
5883 /* Return variables */
5884 *info_ctr = *r.out.info_ctr;
5885 *totalentries = *r.out.totalentries;
5886 if (resume_handle && r.out.resume_handle) {
5887 *resume_handle = *r.out.resume_handle;
5888 }
5889
5890 /* Return result */
5891 if (werror) {
5892 *werror = r.out.result;
5893 }
5894
5895 return werror_to_ntstatus(r.out.result);
5896 }
5897
5898 struct rpccli_srvsvc_NetShareDelStart_state {
5899 struct srvsvc_NetShareDelStart orig;
5900 struct srvsvc_NetShareDelStart tmp;
5901 TALLOC_CTX *out_mem_ctx;
5902 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5903 };
5904
5905 static void rpccli_srvsvc_NetShareDelStart_done(struct tevent_req *subreq);
5906
5907 struct tevent_req *rpccli_srvsvc_NetShareDelStart_send(TALLOC_CTX *mem_ctx,
5908 struct tevent_context *ev,
5909 struct rpc_pipe_client *cli,
5910 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5911 const char *_share /* [in] [charset(UTF16)] */,
5912 uint32_t _reserved /* [in] */,
5913 struct policy_handle *_hnd /* [out] [unique] */)
5914 {
5915 struct tevent_req *req;
5916 struct rpccli_srvsvc_NetShareDelStart_state *state;
5917 struct tevent_req *subreq;
5918
5919 req = tevent_req_create(mem_ctx, &state,
5920 struct rpccli_srvsvc_NetShareDelStart_state);
5921 if (req == NULL) {
5922 return NULL;
5923 }
5924 state->out_mem_ctx = NULL;
5925 state->dispatch_recv = cli->dispatch_recv;
5926
5927 /* In parameters */
5928 state->orig.in.server_unc = _server_unc;
5929 state->orig.in.share = _share;
5930 state->orig.in.reserved = _reserved;
5931
5932 /* Out parameters */
5933 state->orig.out.hnd = _hnd;
5934
5935 /* Result */
5936 ZERO_STRUCT(state->orig.out.result);
5937
5938 state->out_mem_ctx = talloc_named_const(state, 0,
5939 "rpccli_srvsvc_NetShareDelStart_out_memory");
5940 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5941 return tevent_req_post(req, ev);
5942 }
5943
5944 /* make a temporary copy, that we pass to the dispatch function */
5945 state->tmp = state->orig;
5946
5947 subreq = cli->dispatch_send(state, ev, cli,
5948 &ndr_table_srvsvc,
5949 NDR_SRVSVC_NETSHAREDELSTART,
5950 &state->tmp);
5951 if (tevent_req_nomem(subreq, req)) {
5952 return tevent_req_post(req, ev);
5953 }
5954 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareDelStart_done, req);
5955 return req;
5956 }
5957
5958 static void rpccli_srvsvc_NetShareDelStart_done(struct tevent_req *subreq)
5959 {
5960 struct tevent_req *req = tevent_req_callback_data(
5961 subreq, struct tevent_req);
5962 struct rpccli_srvsvc_NetShareDelStart_state *state = tevent_req_data(
5963 req, struct rpccli_srvsvc_NetShareDelStart_state);
5964 NTSTATUS status;
5965 TALLOC_CTX *mem_ctx;
5966
5967 if (state->out_mem_ctx) {
5968 mem_ctx = state->out_mem_ctx;
5969 } else {
5970 mem_ctx = state;
5971 }
5972
5973 status = state->dispatch_recv(subreq, mem_ctx);
5974 TALLOC_FREE(subreq);
5975 if (!NT_STATUS_IS_OK(status)) {
5976 tevent_req_nterror(req, status);
5977 return;
5978 }
5979
5980 /* Copy out parameters */
5981 if (state->orig.out.hnd && state->tmp.out.hnd) {
5982 *state->orig.out.hnd = *state->tmp.out.hnd;
5983 }
5984
5985 /* Copy result */
5986 state->orig.out.result = state->tmp.out.result;
5987
5988 /* Reset temporary structure */
5989 ZERO_STRUCT(state->tmp);
5990
5991 tevent_req_done(req);
5992 }
5993
5994 NTSTATUS rpccli_srvsvc_NetShareDelStart_recv(struct tevent_req *req,
5995 TALLOC_CTX *mem_ctx,
5996 WERROR *result)
5997 {
5998 struct rpccli_srvsvc_NetShareDelStart_state *state = tevent_req_data(
5999 req, struct rpccli_srvsvc_NetShareDelStart_state);
6000 NTSTATUS status;
6001
6002 if (tevent_req_is_nterror(req, &status)) {
6003 tevent_req_received(req);
6004 return status;
6005 }
6006
6007 /* Steal possbile out parameters to the callers context */
6008 talloc_steal(mem_ctx, state->out_mem_ctx);
6009
6010 /* Return result */
6011 *result = state->orig.out.result;
6012
6013 tevent_req_received(req);
6014 return NT_STATUS_OK;
6015 }
6016
6017 NTSTATUS rpccli_srvsvc_NetShareDelStart(struct rpc_pipe_client *cli,
6018 TALLOC_CTX *mem_ctx,
6019 const char *server_unc /* [in] [unique,charset(UTF16)] */,
6020 const char *share /* [in] [charset(UTF16)] */,
6021 uint32_t reserved /* [in] */,
6022 struct policy_handle *hnd /* [out] [unique] */,
6023 WERROR *werror)
6024 {
6025 struct srvsvc_NetShareDelStart r;
6026 NTSTATUS status;
6027
6028 /* In parameters */
6029 r.in.server_unc = server_unc;
6030 r.in.share = share;
6031 r.in.reserved = reserved;
6032
6033 status = cli->dispatch(cli,
6034 mem_ctx,
6035 &ndr_table_srvsvc,
6036 NDR_SRVSVC_NETSHAREDELSTART,
6037 &r);
6038
6039 if (!NT_STATUS_IS_OK(status)) {
6040 return status;
6041 }
6042
6043 if (NT_STATUS_IS_ERR(status)) {
6044 return status;
6045 }
6046
6047 /* Return variables */
6048 if (hnd && r.out.hnd) {
6049 *hnd = *r.out.hnd;
6050 }
6051
6052 /* Return result */
6053 if (werror) {
6054 *werror = r.out.result;
6055 }
6056
6057 return werror_to_ntstatus(r.out.result);
6058 }
6059
6060 struct rpccli_srvsvc_NetShareDelCommit_state {
6061 struct srvsvc_NetShareDelCommit orig;
6062 struct srvsvc_NetShareDelCommit tmp;
6063 TALLOC_CTX *out_mem_ctx;
6064 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6065 };
6066
6067 static void rpccli_srvsvc_NetShareDelCommit_done(struct tevent_req *subreq);
6068
6069 struct tevent_req *rpccli_srvsvc_NetShareDelCommit_send(TALLOC_CTX *mem_ctx,
6070 struct tevent_context *ev,
6071 struct rpc_pipe_client *cli,
6072 struct policy_handle *_hnd /* [in,out] [unique] */)
6073 {
6074 struct tevent_req *req;
6075 struct rpccli_srvsvc_NetShareDelCommit_state *state;
6076 struct tevent_req *subreq;
6077
6078 req = tevent_req_create(mem_ctx, &state,
6079 struct rpccli_srvsvc_NetShareDelCommit_state);
6080 if (req == NULL) {
6081 return NULL;
6082 }
6083 state->out_mem_ctx = NULL;
6084 state->dispatch_recv = cli->dispatch_recv;
6085
6086 /* In parameters */
6087 state->orig.in.hnd = _hnd;
6088
6089 /* Out parameters */
6090 state->orig.out.hnd = _hnd;
6091
6092 /* Result */
6093 ZERO_STRUCT(state->orig.out.result);
6094
6095 state->out_mem_ctx = talloc_named_const(state, 0,
6096 "rpccli_srvsvc_NetShareDelCommit_out_memory");
6097 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6098 return tevent_req_post(req, ev);
6099 }
6100
6101 /* make a temporary copy, that we pass to the dispatch function */
6102 state->tmp = state->orig;
6103
6104 subreq = cli->dispatch_send(state, ev, cli,
6105 &ndr_table_srvsvc,
6106 NDR_SRVSVC_NETSHAREDELCOMMIT,
6107 &state->tmp);
6108 if (tevent_req_nomem(subreq, req)) {
6109 return tevent_req_post(req, ev);
6110 }
6111 tevent_req_set_callback(subreq, rpccli_srvsvc_NetShareDelCommit_done, req);
6112 return req;
6113 }
6114
6115 static void rpccli_srvsvc_NetShareDelCommit_done(struct tevent_req *subreq)
6116 {
6117 struct tevent_req *req = tevent_req_callback_data(
6118 subreq, struct tevent_req);
6119 struct rpccli_srvsvc_NetShareDelCommit_state *state = tevent_req_data(
6120 req, struct rpccli_srvsvc_NetShareDelCommit_state);
6121 NTSTATUS status;
6122 TALLOC_CTX *mem_ctx;
6123
6124 if (state->out_mem_ctx) {
6125 mem_ctx = state->out_mem_ctx;
6126 } else {
6127 mem_ctx = state;
6128 }
6129
6130 status = state->dispatch_recv(subreq, mem_ctx);
6131 TALLOC_FREE(subreq);
6132 if (!NT_STATUS_IS_OK(status)) {
6133 tevent_req_nterror(req, status);
6134 return;
6135 }
6136
6137 /* Copy out parameters */
6138 if (state->orig.out.hnd && state->tmp.out.hnd) {
6139 *state->orig.out.hnd = *state->tmp.out.hnd;
6140 }
6141
6142 /* Copy result */
6143 state->orig.out.result = state->tmp.out.result;
6144
6145 /* Reset temporary structure */
6146 ZERO_STRUCT(state->tmp);
6147
6148 tevent_req_done(req);
6149 }
6150
6151 NTSTATUS rpccli_srvsvc_NetShareDelCommit_recv(struct tevent_req *req,
6152 TALLOC_CTX *mem_ctx,
6153 WERROR *result)
6154 {
6155 struct rpccli_srvsvc_NetShareDelCommit_state *state = tevent_req_data(
6156 req, struct rpccli_srvsvc_NetShareDelCommit_state);
6157 NTSTATUS status;
6158
6159 if (tevent_req_is_nterror(req, &status)) {
6160 tevent_req_received(req);
6161 return status;
6162 }
6163
6164 /* Steal possbile out parameters to the callers context */
6165 talloc_steal(mem_ctx, state->out_mem_ctx);
6166
6167 /* Return result */
6168 *result = state->orig.out.result;
6169
6170 tevent_req_received(req);
6171 return NT_STATUS_OK;
6172 }
6173
6174 NTSTATUS rpccli_srvsvc_NetShareDelCommit(struct rpc_pipe_client *cli,
6175 TALLOC_CTX *mem_ctx,
6176 struct policy_handle *hnd /* [in,out] [unique] */,
6177 WERROR *werror)
6178 {
6179 struct srvsvc_NetShareDelCommit r;
6180 NTSTATUS status;
6181
6182 /* In parameters */
6183 r.in.hnd = hnd;
6184
6185 status = cli->dispatch(cli,
6186 mem_ctx,
6187 &ndr_table_srvsvc,
6188 NDR_SRVSVC_NETSHAREDELCOMMIT,
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 if (hnd && r.out.hnd) {
6201 *hnd = *r.out.hnd;
6202 }
6203
6204 /* Return result */
6205 if (werror) {
6206 *werror = r.out.result;
6207 }
6208
6209 return werror_to_ntstatus(r.out.result);
6210 }
6211
6212 struct rpccli_srvsvc_NetGetFileSecurity_state {
6213 struct srvsvc_NetGetFileSecurity orig;
6214 struct srvsvc_NetGetFileSecurity tmp;
6215 TALLOC_CTX *out_mem_ctx;
6216 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6217 };
6218
6219 static void rpccli_srvsvc_NetGetFileSecurity_done(struct tevent_req *subreq);
6220
6221 struct tevent_req *rpccli_srvsvc_NetGetFileSecurity_send(TALLOC_CTX *mem_ctx,
6222 struct tevent_context *ev,
6223 struct rpc_pipe_client *cli,
6224 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6225 const char *_share /* [in] [unique,charset(UTF16)] */,
6226 const char *_file /* [in] [charset(UTF16)] */,
6227 uint32_t _securityinformation /* [in] */,
6228 struct sec_desc_buf **_sd_buf /* [out] [ref] */)
6229 {
6230 struct tevent_req *req;
6231 struct rpccli_srvsvc_NetGetFileSecurity_state *state;
6232 struct tevent_req *subreq;
6233
6234 req = tevent_req_create(mem_ctx, &state,
6235 struct rpccli_srvsvc_NetGetFileSecurity_state);
6236 if (req == NULL) {
6237 return NULL;
6238 }
6239 state->out_mem_ctx = NULL;
6240 state->dispatch_recv = cli->dispatch_recv;
6241
6242 /* In parameters */
6243 state->orig.in.server_unc = _server_unc;
6244 state->orig.in.share = _share;
6245 state->orig.in.file = _file;
6246 state->orig.in.securityinformation = _securityinformation;
6247
6248 /* Out parameters */
6249 state->orig.out.sd_buf = _sd_buf;
6250
6251 /* Result */
6252 ZERO_STRUCT(state->orig.out.result);
6253
6254 state->out_mem_ctx = talloc_named_const(state, 0,
6255 "rpccli_srvsvc_NetGetFileSecurity_out_memory");
6256 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6257 return tevent_req_post(req, ev);
6258 }
6259
6260 /* make a temporary copy, that we pass to the dispatch function */
6261 state->tmp = state->orig;
6262
6263 subreq = cli->dispatch_send(state, ev, cli,
6264 &ndr_table_srvsvc,
6265 NDR_SRVSVC_NETGETFILESECURITY,
6266 &state->tmp);
6267 if (tevent_req_nomem(subreq, req)) {
6268 return tevent_req_post(req, ev);
6269 }
6270 tevent_req_set_callback(subreq, rpccli_srvsvc_NetGetFileSecurity_done, req);
6271 return req;
6272 }
6273
6274 static void rpccli_srvsvc_NetGetFileSecurity_done(struct tevent_req *subreq)
6275 {
6276 struct tevent_req *req = tevent_req_callback_data(
6277 subreq, struct tevent_req);
6278 struct rpccli_srvsvc_NetGetFileSecurity_state *state = tevent_req_data(
6279 req, struct rpccli_srvsvc_NetGetFileSecurity_state);
6280 NTSTATUS status;
6281 TALLOC_CTX *mem_ctx;
6282
6283 if (state->out_mem_ctx) {
6284 mem_ctx = state->out_mem_ctx;
6285 } else {
6286 mem_ctx = state;
6287 }
6288
6289 status = state->dispatch_recv(subreq, mem_ctx);
6290 TALLOC_FREE(subreq);
6291 if (!NT_STATUS_IS_OK(status)) {
6292 tevent_req_nterror(req, status);
6293 return;
6294 }
6295
6296 /* Copy out parameters */
6297 *state->orig.out.sd_buf = *state->tmp.out.sd_buf;
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
6308 NTSTATUS rpccli_srvsvc_NetGetFileSecurity_recv(struct tevent_req *req,
6309 TALLOC_CTX *mem_ctx,
6310 WERROR *result)
6311 {
6312 struct rpccli_srvsvc_NetGetFileSecurity_state *state = tevent_req_data(
6313 req, struct rpccli_srvsvc_NetGetFileSecurity_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
6331 NTSTATUS rpccli_srvsvc_NetGetFileSecurity(struct rpc_pipe_client *cli,
6332 TALLOC_CTX *mem_ctx,
6333 const char *server_unc /* [in] [unique,charset(UTF16)] */,
6334 const char *share /* [in] [unique,charset(UTF16)] */,
6335 const char *file /* [in] [charset(UTF16)] */,
6336 uint32_t securityinformation /* [in] */,
6337 struct sec_desc_buf **sd_buf /* [out] [ref] */,
6338 WERROR *werror)
6339 {
6340 struct srvsvc_NetGetFileSecurity r;
6341 NTSTATUS status;
6342
6343 /* In parameters */
6344 r.in.server_unc = server_unc;
6345 r.in.share = share;
6346 r.in.file = file;
6347 r.in.securityinformation = securityinformation;
6348
6349 status = cli->dispatch(cli,
6350 mem_ctx,
6351 &ndr_table_srvsvc,
6352 NDR_SRVSVC_NETGETFILESECURITY,
6353 &r);
6354
6355 if (!NT_STATUS_IS_OK(status)) {
6356 return status;
6357 }
6358
6359 if (NT_STATUS_IS_ERR(status)) {
6360 return status;
6361 }
6362
6363 /* Return variables */
6364 *sd_buf = *r.out.sd_buf;
6365
6366 /* Return result */
6367 if (werror) {
6368 *werror = r.out.result;
6369 }
6370
6371 return werror_to_ntstatus(r.out.result);
6372 }
6373
6374 struct rpccli_srvsvc_NetSetFileSecurity_state {
6375 struct srvsvc_NetSetFileSecurity orig;
6376 struct srvsvc_NetSetFileSecurity tmp;
6377 TALLOC_CTX *out_mem_ctx;
6378 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6379 };
6380
6381 static void rpccli_srvsvc_NetSetFileSecurity_done(struct tevent_req *subreq);
6382
6383 struct tevent_req *rpccli_srvsvc_NetSetFileSecurity_send(TALLOC_CTX *mem_ctx,
6384 struct tevent_context *ev,
6385 struct rpc_pipe_client *cli,
6386 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6387 const char *_share /* [in] [unique,charset(UTF16)] */,
6388 const char *_file /* [in] [charset(UTF16)] */,
6389 uint32_t _securityinformation /* [in] */,
6390 struct sec_desc_buf *_sd_buf /* [in] [ref] */)
6391 {
6392 struct tevent_req *req;
6393 struct rpccli_srvsvc_NetSetFileSecurity_state *state;
6394 struct tevent_req *subreq;
6395
6396 req = tevent_req_create(mem_ctx, &state,
6397 struct rpccli_srvsvc_NetSetFileSecurity_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.server_unc = _server_unc;
6406 state->orig.in.share = _share;
6407 state->orig.in.file = _file;
6408 state->orig.in.securityinformation = _securityinformation;
6409 state->orig.in.sd_buf = _sd_buf;
6410
6411 /* Out parameters */
6412
6413 /* Result */
6414 ZERO_STRUCT(state->orig.out.result);
6415
6416 /* make a temporary copy, that we pass to the dispatch function */
6417 state->tmp = state->orig;
6418
6419 subreq = cli->dispatch_send(state, ev, cli,
6420 &ndr_table_srvsvc,
6421 NDR_SRVSVC_NETSETFILESECURITY,
6422 &state->tmp);
6423 if (tevent_req_nomem(subreq, req)) {
6424 return tevent_req_post(req, ev);
6425 }
6426 tevent_req_set_callback(subreq, rpccli_srvsvc_NetSetFileSecurity_done, req);
6427 return req;
6428 }
6429
6430 static void rpccli_srvsvc_NetSetFileSecurity_done(struct tevent_req *subreq)
6431 {
6432 struct tevent_req *req = tevent_req_callback_data(
6433 subreq, struct tevent_req);
6434 struct rpccli_srvsvc_NetSetFileSecurity_state *state = tevent_req_data(
6435 req, struct rpccli_srvsvc_NetSetFileSecurity_state);
6436 NTSTATUS status;
6437 TALLOC_CTX *mem_ctx;
6438
6439 if (state->out_mem_ctx) {
6440 mem_ctx = state->out_mem_ctx;
6441 } else {
6442 mem_ctx = state;
6443 }
6444
6445 status = state->dispatch_recv(subreq, mem_ctx);
6446 TALLOC_FREE(subreq);
6447 if (!NT_STATUS_IS_OK(status)) {
6448 tevent_req_nterror(req, status);
6449 return;
6450 }
6451
6452 /* Copy out parameters */
6453
6454 /* Copy result */
6455 state->orig.out.result = state->tmp.out.result;
6456
6457 /* Reset temporary structure */
6458 ZERO_STRUCT(state->tmp);
6459
6460 tevent_req_done(req);
6461 }
6462
6463 NTSTATUS rpccli_srvsvc_NetSetFileSecurity_recv(struct tevent_req *req,
6464 TALLOC_CTX *mem_ctx,
6465 WERROR *result)
6466 {
6467 struct rpccli_srvsvc_NetSetFileSecurity_state *state = tevent_req_data(
6468 req, struct rpccli_srvsvc_NetSetFileSecurity_state);
6469 NTSTATUS status;
6470
6471 if (tevent_req_is_nterror(req, &status)) {
6472 tevent_req_received(req);
6473 return status;
6474 }
6475
6476 /* Steal possbile out parameters to the callers context */
6477 talloc_steal(mem_ctx, state->out_mem_ctx);
6478
6479 /* Return result */
6480 *result = state->orig.out.result;
6481
6482 tevent_req_received(req);
6483 return NT_STATUS_OK;
6484 }
6485
6486 NTSTATUS rpccli_srvsvc_NetSetFileSecurity(struct rpc_pipe_client *cli,
6487 TALLOC_CTX *mem_ctx,
6488 const char *server_unc /* [in] [unique,charset(UTF16)] */,
6489 const char *share /* [in] [unique,charset(UTF16)] */,
6490 const char *file /* [in] [charset(UTF16)] */,
6491 uint32_t securityinformation /* [in] */,
6492 struct sec_desc_buf *sd_buf /* [in] [ref] */,
6493 WERROR *werror)
6494 {
6495 struct srvsvc_NetSetFileSecurity r;
6496 NTSTATUS status;
6497
6498 /* In parameters */
6499 r.in.server_unc = server_unc;
6500 r.in.share = share;
6501 r.in.file = file;
6502 r.in.securityinformation = securityinformation;
6503 r.in.sd_buf = sd_buf;
6504
6505 status = cli->dispatch(cli,
6506 mem_ctx,
6507 &ndr_table_srvsvc,
6508 NDR_SRVSVC_NETSETFILESECURITY,
6509 &r);
6510
6511 if (!NT_STATUS_IS_OK(status)) {
6512 return status;
6513 }
6514
6515 if (NT_STATUS_IS_ERR(status)) {
6516 return status;
6517 }
6518
6519 /* Return variables */
6520
6521 /* Return result */
6522 if (werror) {
6523 *werror = r.out.result;
6524 }
6525
6526 return werror_to_ntstatus(r.out.result);
6527 }
6528
6529 struct rpccli_srvsvc_NetServerTransportAddEx_state {
6530 struct srvsvc_NetServerTransportAddEx orig;
6531 struct srvsvc_NetServerTransportAddEx tmp;
6532 TALLOC_CTX *out_mem_ctx;
6533 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6534 };
6535
6536 static void rpccli_srvsvc_NetServerTransportAddEx_done(struct tevent_req *subreq);
6537
6538 struct tevent_req *rpccli_srvsvc_NetServerTransportAddEx_send(TALLOC_CTX *mem_ctx,
6539 struct tevent_context *ev,
6540 struct rpc_pipe_client *cli,
6541 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6542 uint32_t _level /* [in] */,
6543 union srvsvc_NetTransportInfo _info /* [in] [switch_is(level)] */)
6544 {
6545 struct tevent_req *req;
6546 struct rpccli_srvsvc_NetServerTransportAddEx_state *state;
6547 struct tevent_req *subreq;
6548
6549 req = tevent_req_create(mem_ctx, &state,
6550 struct rpccli_srvsvc_NetServerTransportAddEx_state);
6551 if (req == NULL) {
6552 return NULL;
6553 }
6554 state->out_mem_ctx = NULL;
6555 state->dispatch_recv = cli->dispatch_recv;
6556
6557 /* In parameters */
6558 state->orig.in.server_unc = _server_unc;
6559 state->orig.in.level = _level;
6560 state->orig.in.info = _info;
6561
6562 /* Out parameters */
6563
6564 /* Result */
6565 ZERO_STRUCT(state->orig.out.result);
6566
6567 /* make a temporary copy, that we pass to the dispatch function */
6568 state->tmp = state->orig;
6569
6570 subreq = cli->dispatch_send(state, ev, cli,
6571 &ndr_table_srvsvc,
6572 NDR_SRVSVC_NETSERVERTRANSPORTADDEX,
6573 &state->tmp);
6574 if (tevent_req_nomem(subreq, req)) {
6575 return tevent_req_post(req, ev);
6576 }
6577 tevent_req_set_callback(subreq, rpccli_srvsvc_NetServerTransportAddEx_done, req);
6578 return req;
6579 }
6580
6581 static void rpccli_srvsvc_NetServerTransportAddEx_done(struct tevent_req *subreq)
6582 {
6583 struct tevent_req *req = tevent_req_callback_data(
6584 subreq, struct tevent_req);
6585 struct rpccli_srvsvc_NetServerTransportAddEx_state *state = tevent_req_data(
6586 req, struct rpccli_srvsvc_NetServerTransportAddEx_state);
6587 NTSTATUS status;
6588 TALLOC_CTX *mem_ctx;
6589
6590 if (state->out_mem_ctx) {
6591 mem_ctx = state->out_mem_ctx;
6592 } else {
6593 mem_ctx = state;
6594 }
6595
6596 status = state->dispatch_recv(subreq, mem_ctx);
6597 TALLOC_FREE(subreq);
6598 if (!NT_STATUS_IS_OK(status)) {
6599 tevent_req_nterror(req, status);
6600 return;
6601 }
6602
6603 /* Copy out parameters */
6604
6605 /* Copy result */
6606 state->orig.out.result = state->tmp.out.result;
6607
6608 /* Reset temporary structure */
6609 ZERO_STRUCT(state->tmp);
6610
6611 tevent_req_done(req);
6612 }
6613
6614 NTSTATUS rpccli_srvsvc_NetServerTransportAddEx_recv(struct tevent_req *req,
6615 TALLOC_CTX *mem_ctx,
6616 WERROR *result)
6617 {
6618 struct rpccli_srvsvc_NetServerTransportAddEx_state *state = tevent_req_data(
6619 req, struct rpccli_srvsvc_NetServerTransportAddEx_state);
6620 NTSTATUS status;
6621
6622 if (tevent_req_is_nterror(req, &status)) {
6623 tevent_req_received(req);
6624 return status;
6625 }
6626
6627 /* Steal possbile out parameters to the callers context */
6628 talloc_steal(mem_ctx, state->out_mem_ctx);
6629
6630 /* Return result */
6631 *result = state->orig.out.result;
6632
6633 tevent_req_received(req);
6634 return NT_STATUS_OK;
6635 }
6636
6637 NTSTATUS rpccli_srvsvc_NetServerTransportAddEx(struct rpc_pipe_client *cli,
6638 TALLOC_CTX *mem_ctx,
6639 const char *server_unc /* [in] [unique,charset(UTF16)] */,
6640 uint32_t level /* [in] */,
6641 union srvsvc_NetTransportInfo info /* [in] [switch_is(level)] */,
6642 WERROR *werror)
6643 {
6644 struct srvsvc_NetServerTransportAddEx r;
6645 NTSTATUS status;
6646
6647 /* In parameters */
6648 r.in.server_unc = server_unc;
6649 r.in.level = level;
6650 r.in.info = info;
6651
6652 status = cli->dispatch(cli,
6653 mem_ctx,
6654 &ndr_table_srvsvc,
6655 NDR_SRVSVC_NETSERVERTRANSPORTADDEX,
6656 &r);
6657
6658 if (!NT_STATUS_IS_OK(status)) {
6659 return status;
6660 }
6661
6662 if (NT_STATUS_IS_ERR(status)) {
6663 return status;
6664 }
6665
6666 /* Return variables */
6667
6668 /* Return result */
6669 if (werror) {
6670 *werror = r.out.result;
6671 }
6672
6673 return werror_to_ntstatus(r.out.result);
6674 }
6675
6676 struct rpccli_srvsvc_NetServerSetServiceBitsEx_state {
6677 struct srvsvc_NetServerSetServiceBitsEx orig;
6678 struct srvsvc_NetServerSetServiceBitsEx tmp;
6679 TALLOC_CTX *out_mem_ctx;
6680 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6681 };
6682
6683 static void rpccli_srvsvc_NetServerSetServiceBitsEx_done(struct tevent_req *subreq);
6684
6685 struct tevent_req *rpccli_srvsvc_NetServerSetServiceBitsEx_send(TALLOC_CTX *mem_ctx,
6686 struct tevent_context *ev,
6687 struct rpc_pipe_client *cli,
6688 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6689 const char *_emulated_server_unc /* [in] [unique,charset(UTF16)] */,
6690 const char *_transport /* [in] [unique,charset(UTF16)] */,
6691 uint32_t _servicebitsofinterest /* [in] */,
6692 uint32_t _servicebits /* [in] */,
6693 uint32_t _updateimmediately /* [in] */)
6694 {
6695 struct tevent_req *req;
6696 struct rpccli_srvsvc_NetServerSetServiceBitsEx_state *state;
6697 struct tevent_req *subreq;
6698
6699 req = tevent_req_create(mem_ctx, &state,
6700 struct rpccli_srvsvc_NetServerSetServiceBitsEx_state);
6701 if (req == NULL) {
6702 return NULL;
6703 }
6704 state->out_mem_ctx = NULL;
6705 state->dispatch_recv = cli->dispatch_recv;
6706
6707 /* In parameters */
6708 state->orig.in.server_unc = _server_unc;
6709 state->orig.in.emulated_server_unc = _emulated_server_unc;
6710 state->orig.in.transport = _transport;
6711 state->orig.in.servicebitsofinterest = _servicebitsofinterest;
6712 state->orig.in.servicebits = _servicebits;
6713 state->orig.in.updateimmediately = _updateimmediately;
6714
6715 /* Out parameters */
6716
6717 /* Result */
6718 ZERO_STRUCT(state->orig.out.result);
6719
6720 /* make a temporary copy, that we pass to the dispatch function */
6721 state->tmp = state->orig;
6722
6723 subreq = cli->dispatch_send(state, ev, cli,
6724 &ndr_table_srvsvc,
6725 NDR_SRVSVC_NETSERVERSETSERVICEBITSEX,
6726 &state->tmp);
6727 if (tevent_req_nomem(subreq, req)) {
6728 return tevent_req_post(req, ev);
6729 }
6730 tevent_req_set_callback(subreq, rpccli_srvsvc_NetServerSetServiceBitsEx_done, req);
6731 return req;
6732 }
6733
6734 static void rpccli_srvsvc_NetServerSetServiceBitsEx_done(struct tevent_req *subreq)
6735 {
6736 struct tevent_req *req = tevent_req_callback_data(
6737 subreq, struct tevent_req);
6738 struct rpccli_srvsvc_NetServerSetServiceBitsEx_state *state = tevent_req_data(
6739 req, struct rpccli_srvsvc_NetServerSetServiceBitsEx_state);
6740 NTSTATUS status;
6741 TALLOC_CTX *mem_ctx;
6742
6743 if (state->out_mem_ctx) {
6744 mem_ctx = state->out_mem_ctx;
6745 } else {
6746 mem_ctx = state;
6747 }
6748
6749 status = state->dispatch_recv(subreq, mem_ctx);
6750 TALLOC_FREE(subreq);
6751 if (!NT_STATUS_IS_OK(status)) {
6752 tevent_req_nterror(req, status);
6753 return;
6754 }
6755
6756 /* Copy out parameters */
6757
6758 /* Copy result */
6759 state->orig.out.result = state->tmp.out.result;
6760
6761 /* Reset temporary structure */
6762 ZERO_STRUCT(state->tmp);
6763
6764 tevent_req_done(req);
6765 }
6766
6767 NTSTATUS rpccli_srvsvc_NetServerSetServiceBitsEx_recv(struct tevent_req *req,
6768 TALLOC_CTX *mem_ctx,
6769 WERROR *result)
6770 {
6771 struct rpccli_srvsvc_NetServerSetServiceBitsEx_state *state = tevent_req_data(
6772 req, struct rpccli_srvsvc_NetServerSetServiceBitsEx_state);
6773 NTSTATUS status;
6774
6775 if (tevent_req_is_nterror(req, &status)) {
6776 tevent_req_received(req);
6777 return status;
6778 }
6779
6780 /* Steal possbile out parameters to the callers context */
6781 talloc_steal(mem_ctx, state->out_mem_ctx);
6782
6783 /* Return result */
6784 *result = state->orig.out.result;
6785
6786 tevent_req_received(req);
6787 return NT_STATUS_OK;
6788 }
6789
6790 NTSTATUS rpccli_srvsvc_NetServerSetServiceBitsEx(struct rpc_pipe_client *cli,
6791 TALLOC_CTX *mem_ctx,
6792 const char *server_unc /* [in] [unique,charset(UTF16)] */,
6793 const char *emulated_server_unc /* [in] [unique,charset(UTF16)] */,
6794 const char *transport /* [in] [unique,charset(UTF16)] */,
6795 uint32_t servicebitsofinterest /* [in] */,
6796 uint32_t servicebits /* [in] */,
6797 uint32_t updateimmediately /* [in] */,
6798 WERROR *werror)
6799 {
6800 struct srvsvc_NetServerSetServiceBitsEx r;
6801 NTSTATUS status;
6802
6803 /* In parameters */
6804 r.in.server_unc = server_unc;
6805 r.in.emulated_server_unc = emulated_server_unc;
6806 r.in.transport = transport;
6807 r.in.servicebitsofinterest = servicebitsofinterest;
6808 r.in.servicebits = servicebits;
6809 r.in.updateimmediately = updateimmediately;
6810
6811 status = cli->dispatch(cli,
6812 mem_ctx,
6813 &ndr_table_srvsvc,
6814 NDR_SRVSVC_NETSERVERSETSERVICEBITSEX,
6815 &r);
6816
6817 if (!NT_STATUS_IS_OK(status)) {
6818 return status;
6819 }
6820
6821 if (NT_STATUS_IS_ERR(status)) {
6822 return status;
6823 }
6824
6825 /* Return variables */
6826
6827 /* Return result */
6828 if (werror) {
6829 *werror = r.out.result;
6830 }
6831
6832 return werror_to_ntstatus(r.out.result);
6833 }
6834
6835 struct rpccli_srvsvc_NETRDFSGETVERSION_state {
6836 struct srvsvc_NETRDFSGETVERSION orig;
6837 struct srvsvc_NETRDFSGETVERSION tmp;
6838 TALLOC_CTX *out_mem_ctx;
6839 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6840 };
6841
6842 static void rpccli_srvsvc_NETRDFSGETVERSION_done(struct tevent_req *subreq);
6843
6844 struct tevent_req *rpccli_srvsvc_NETRDFSGETVERSION_send(TALLOC_CTX *mem_ctx,
6845 struct tevent_context *ev,
6846 struct rpc_pipe_client *cli)
6847 {
6848 struct tevent_req *req;
6849 struct rpccli_srvsvc_NETRDFSGETVERSION_state *state;
6850 struct tevent_req *subreq;
6851
6852 req = tevent_req_create(mem_ctx, &state,
6853 struct rpccli_srvsvc_NETRDFSGETVERSION_state);
6854 if (req == NULL) {
6855 return NULL;
6856 }
6857 state->out_mem_ctx = NULL;
6858 state->dispatch_recv = cli->dispatch_recv;
6859
6860 /* In parameters */
6861
6862 /* Out parameters */
6863
6864 /* Result */
6865 ZERO_STRUCT(state->orig.out.result);
6866
6867 /* make a temporary copy, that we pass to the dispatch function */
6868 state->tmp = state->orig;
6869
6870 subreq = cli->dispatch_send(state, ev, cli,
6871 &ndr_table_srvsvc,
6872 NDR_SRVSVC_NETRDFSGETVERSION,
6873 &state->tmp);
6874 if (tevent_req_nomem(subreq, req)) {
6875 return tevent_req_post(req, ev);
6876 }
6877 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSGETVERSION_done, req);
6878 return req;
6879 }
6880
6881 static void rpccli_srvsvc_NETRDFSGETVERSION_done(struct tevent_req *subreq)
6882 {
6883 struct tevent_req *req = tevent_req_callback_data(
6884 subreq, struct tevent_req);
6885 struct rpccli_srvsvc_NETRDFSGETVERSION_state *state = tevent_req_data(
6886 req, struct rpccli_srvsvc_NETRDFSGETVERSION_state);
6887 NTSTATUS status;
6888 TALLOC_CTX *mem_ctx;
6889
6890 if (state->out_mem_ctx) {
6891 mem_ctx = state->out_mem_ctx;
6892 } else {
6893 mem_ctx = state;
6894 }
6895
6896 status = state->dispatch_recv(subreq, mem_ctx);
6897 TALLOC_FREE(subreq);
6898 if (!NT_STATUS_IS_OK(status)) {
6899 tevent_req_nterror(req, status);
6900 return;
6901 }
6902
6903 /* Copy out parameters */
6904
6905 /* Copy result */
6906 state->orig.out.result = state->tmp.out.result;
6907
6908 /* Reset temporary structure */
6909 ZERO_STRUCT(state->tmp);
6910
6911 tevent_req_done(req);
6912 }
6913
6914 NTSTATUS rpccli_srvsvc_NETRDFSGETVERSION_recv(struct tevent_req *req,
6915 TALLOC_CTX *mem_ctx,
6916 WERROR *result)
6917 {
6918 struct rpccli_srvsvc_NETRDFSGETVERSION_state *state = tevent_req_data(
6919 req, struct rpccli_srvsvc_NETRDFSGETVERSION_state);
6920 NTSTATUS status;
6921
6922 if (tevent_req_is_nterror(req, &status)) {
6923 tevent_req_received(req);
6924 return status;
6925 }
6926
6927 /* Steal possbile out parameters to the callers context */
6928 talloc_steal(mem_ctx, state->out_mem_ctx);
6929
6930 /* Return result */
6931 *result = state->orig.out.result;
6932
6933 tevent_req_received(req);
6934 return NT_STATUS_OK;
6935 }
6936
6937 NTSTATUS rpccli_srvsvc_NETRDFSGETVERSION(struct rpc_pipe_client *cli,
6938 TALLOC_CTX *mem_ctx,
6939 WERROR *werror)
6940 {
6941 struct srvsvc_NETRDFSGETVERSION r;
6942 NTSTATUS status;
6943
6944 /* In parameters */
6945
6946 status = cli->dispatch(cli,
6947 mem_ctx,
6948 &ndr_table_srvsvc,
6949 NDR_SRVSVC_NETRDFSGETVERSION,
6950 &r);
6951
6952 if (!NT_STATUS_IS_OK(status)) {
6953 return status;
6954 }
6955
6956 if (NT_STATUS_IS_ERR(status)) {
6957 return status;
6958 }
6959
6960 /* Return variables */
6961
6962 /* Return result */
6963 if (werror) {
6964 *werror = r.out.result;
6965 }
6966
6967 return werror_to_ntstatus(r.out.result);
6968 }
6969
6970 struct rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_state {
6971 struct srvsvc_NETRDFSCREATELOCALPARTITION orig;
6972 struct srvsvc_NETRDFSCREATELOCALPARTITION tmp;
6973 TALLOC_CTX *out_mem_ctx;
6974 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6975 };
6976
6977 static void rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_done(struct tevent_req *subreq);
6978
6979 struct tevent_req *rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_send(TALLOC_CTX *mem_ctx,
6980 struct tevent_context *ev,
6981 struct rpc_pipe_client *cli)
6982 {
6983 struct tevent_req *req;
6984 struct rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_state *state;
6985 struct tevent_req *subreq;
6986
6987 req = tevent_req_create(mem_ctx, &state,
6988 struct rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_state);
6989 if (req == NULL) {
6990 return NULL;
6991 }
6992 state->out_mem_ctx = NULL;
6993 state->dispatch_recv = cli->dispatch_recv;
6994
6995 /* In parameters */
6996
6997 /* Out parameters */
6998
6999 /* Result */
7000 ZERO_STRUCT(state->orig.out.result);
7001
7002 /* make a temporary copy, that we pass to the dispatch function */
7003 state->tmp = state->orig;
7004
7005 subreq = cli->dispatch_send(state, ev, cli,
7006 &ndr_table_srvsvc,
7007 NDR_SRVSVC_NETRDFSCREATELOCALPARTITION,
7008 &state->tmp);
7009 if (tevent_req_nomem(subreq, req)) {
7010 return tevent_req_post(req, ev);
7011 }
7012 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_done, req);
7013 return req;
7014 }
7015
7016 static void rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_done(struct tevent_req *subreq)
7017 {
7018 struct tevent_req *req = tevent_req_callback_data(
7019 subreq, struct tevent_req);
7020 struct rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_state *state = tevent_req_data(
7021 req, struct rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_state);
7022 NTSTATUS status;
7023 TALLOC_CTX *mem_ctx;
7024
7025 if (state->out_mem_ctx) {
7026 mem_ctx = state->out_mem_ctx;
7027 } else {
7028 mem_ctx = state;
7029 }
7030
7031 status = state->dispatch_recv(subreq, mem_ctx);
7032 TALLOC_FREE(subreq);
7033 if (!NT_STATUS_IS_OK(status)) {
7034 tevent_req_nterror(req, status);
7035 return;
7036 }
7037
7038 /* Copy out parameters */
7039
7040 /* Copy result */
7041 state->orig.out.result = state->tmp.out.result;
7042
7043 /* Reset temporary structure */
7044 ZERO_STRUCT(state->tmp);
7045
7046 tevent_req_done(req);
7047 }
7048
7049 NTSTATUS rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_recv(struct tevent_req *req,
7050 TALLOC_CTX *mem_ctx,
7051 WERROR *result)
7052 {
7053 struct rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_state *state = tevent_req_data(
7054 req, struct rpccli_srvsvc_NETRDFSCREATELOCALPARTITION_state);
7055 NTSTATUS status;
7056
7057 if (tevent_req_is_nterror(req, &status)) {
7058 tevent_req_received(req);
7059 return status;
7060 }
7061
7062 /* Steal possbile out parameters to the callers context */
7063 talloc_steal(mem_ctx, state->out_mem_ctx);
7064
7065 /* Return result */
7066 *result = state->orig.out.result;
7067
7068 tevent_req_received(req);
7069 return NT_STATUS_OK;
7070 }
7071
7072 NTSTATUS rpccli_srvsvc_NETRDFSCREATELOCALPARTITION(struct rpc_pipe_client *cli,
7073 TALLOC_CTX *mem_ctx,
7074 WERROR *werror)
7075 {
7076 struct srvsvc_NETRDFSCREATELOCALPARTITION r;
7077 NTSTATUS status;
7078
7079 /* In parameters */
7080
7081 status = cli->dispatch(cli,
7082 mem_ctx,
7083 &ndr_table_srvsvc,
7084 NDR_SRVSVC_NETRDFSCREATELOCALPARTITION,
7085 &r);
7086
7087 if (!NT_STATUS_IS_OK(status)) {
7088 return status;
7089 }
7090
7091 if (NT_STATUS_IS_ERR(status)) {
7092 return status;
7093 }
7094
7095 /* Return variables */
7096
7097 /* Return result */
7098 if (werror) {
7099 *werror = r.out.result;
7100 }
7101
7102 return werror_to_ntstatus(r.out.result);
7103 }
7104
7105 struct rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_state {
7106 struct srvsvc_NETRDFSDELETELOCALPARTITION orig;
7107 struct srvsvc_NETRDFSDELETELOCALPARTITION tmp;
7108 TALLOC_CTX *out_mem_ctx;
7109 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7110 };
7111
7112 static void rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_done(struct tevent_req *subreq);
7113
7114 struct tevent_req *rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_send(TALLOC_CTX *mem_ctx,
7115 struct tevent_context *ev,
7116 struct rpc_pipe_client *cli)
7117 {
7118 struct tevent_req *req;
7119 struct rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_state *state;
7120 struct tevent_req *subreq;
7121
7122 req = tevent_req_create(mem_ctx, &state,
7123 struct rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_state);
7124 if (req == NULL) {
7125 return NULL;
7126 }
7127 state->out_mem_ctx = NULL;
7128 state->dispatch_recv = cli->dispatch_recv;
7129
7130 /* In parameters */
7131
7132 /* Out parameters */
7133
7134 /* Result */
7135 ZERO_STRUCT(state->orig.out.result);
7136
7137 /* make a temporary copy, that we pass to the dispatch function */
7138 state->tmp = state->orig;
7139
7140 subreq = cli->dispatch_send(state, ev, cli,
7141 &ndr_table_srvsvc,
7142 NDR_SRVSVC_NETRDFSDELETELOCALPARTITION,
7143 &state->tmp);
7144 if (tevent_req_nomem(subreq, req)) {
7145 return tevent_req_post(req, ev);
7146 }
7147 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_done, req);
7148 return req;
7149 }
7150
7151 static void rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_done(struct tevent_req *subreq)
7152 {
7153 struct tevent_req *req = tevent_req_callback_data(
7154 subreq, struct tevent_req);
7155 struct rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_state *state = tevent_req_data(
7156 req, struct rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_state);
7157 NTSTATUS status;
7158 TALLOC_CTX *mem_ctx;
7159
7160 if (state->out_mem_ctx) {
7161 mem_ctx = state->out_mem_ctx;
7162 } else {
7163 mem_ctx = state;
7164 }
7165
7166 status = state->dispatch_recv(subreq, mem_ctx);
7167 TALLOC_FREE(subreq);
7168 if (!NT_STATUS_IS_OK(status)) {
7169 tevent_req_nterror(req, status);
7170 return;
7171 }
7172
7173 /* Copy out parameters */
7174
7175 /* Copy result */
7176 state->orig.out.result = state->tmp.out.result;
7177
7178 /* Reset temporary structure */
7179 ZERO_STRUCT(state->tmp);
7180
7181 tevent_req_done(req);
7182 }
7183
7184 NTSTATUS rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_recv(struct tevent_req *req,
7185 TALLOC_CTX *mem_ctx,
7186 WERROR *result)
7187 {
7188 struct rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_state *state = tevent_req_data(
7189 req, struct rpccli_srvsvc_NETRDFSDELETELOCALPARTITION_state);
7190 NTSTATUS status;
7191
7192 if (tevent_req_is_nterror(req, &status)) {
7193 tevent_req_received(req);
7194 return status;
7195 }
7196
7197 /* Steal possbile out parameters to the callers context */
7198 talloc_steal(mem_ctx, state->out_mem_ctx);
7199
7200 /* Return result */
7201 *result = state->orig.out.result;
7202
7203 tevent_req_received(req);
7204 return NT_STATUS_OK;
7205 }
7206
7207 NTSTATUS rpccli_srvsvc_NETRDFSDELETELOCALPARTITION(struct rpc_pipe_client *cli,
7208 TALLOC_CTX *mem_ctx,
7209 WERROR *werror)
7210 {
7211 struct srvsvc_NETRDFSDELETELOCALPARTITION r;
7212 NTSTATUS status;
7213
7214 /* In parameters */
7215
7216 status = cli->dispatch(cli,
7217 mem_ctx,
7218 &ndr_table_srvsvc,
7219 NDR_SRVSVC_NETRDFSDELETELOCALPARTITION,
7220 &r);
7221
7222 if (!NT_STATUS_IS_OK(status)) {
7223 return status;
7224 }
7225
7226 if (NT_STATUS_IS_ERR(status)) {
7227 return status;
7228 }
7229
7230 /* Return variables */
7231
7232 /* Return result */
7233 if (werror) {
7234 *werror = r.out.result;
7235 }
7236
7237 return werror_to_ntstatus(r.out.result);
7238 }
7239
7240 struct rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_state {
7241 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE orig;
7242 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE tmp;
7243 TALLOC_CTX *out_mem_ctx;
7244 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7245 };
7246
7247 static void rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_done(struct tevent_req *subreq);
7248
7249 struct tevent_req *rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_send(TALLOC_CTX *mem_ctx,
7250 struct tevent_context *ev,
7251 struct rpc_pipe_client *cli)
7252 {
7253 struct tevent_req *req;
7254 struct rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_state *state;
7255 struct tevent_req *subreq;
7256
7257 req = tevent_req_create(mem_ctx, &state,
7258 struct rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_state);
7259 if (req == NULL) {
7260 return NULL;
7261 }
7262 state->out_mem_ctx = NULL;
7263 state->dispatch_recv = cli->dispatch_recv;
7264
7265 /* In parameters */
7266
7267 /* Out parameters */
7268
7269 /* Result */
7270 ZERO_STRUCT(state->orig.out.result);
7271
7272 /* make a temporary copy, that we pass to the dispatch function */
7273 state->tmp = state->orig;
7274
7275 subreq = cli->dispatch_send(state, ev, cli,
7276 &ndr_table_srvsvc,
7277 NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE,
7278 &state->tmp);
7279 if (tevent_req_nomem(subreq, req)) {
7280 return tevent_req_post(req, ev);
7281 }
7282 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_done, req);
7283 return req;
7284 }
7285
7286 static void rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_done(struct tevent_req *subreq)
7287 {
7288 struct tevent_req *req = tevent_req_callback_data(
7289 subreq, struct tevent_req);
7290 struct rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_state *state = tevent_req_data(
7291 req, struct rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_state);
7292 NTSTATUS status;
7293 TALLOC_CTX *mem_ctx;
7294
7295 if (state->out_mem_ctx) {
7296 mem_ctx = state->out_mem_ctx;
7297 } else {
7298 mem_ctx = state;
7299 }
7300
7301 status = state->dispatch_recv(subreq, mem_ctx);
7302 TALLOC_FREE(subreq);
7303 if (!NT_STATUS_IS_OK(status)) {
7304 tevent_req_nterror(req, status);
7305 return;
7306 }
7307
7308 /* Copy out parameters */
7309
7310 /* Copy result */
7311 state->orig.out.result = state->tmp.out.result;
7312
7313 /* Reset temporary structure */
7314 ZERO_STRUCT(state->tmp);
7315
7316 tevent_req_done(req);
7317 }
7318
7319 NTSTATUS rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_recv(struct tevent_req *req,
7320 TALLOC_CTX *mem_ctx,
7321 WERROR *result)
7322 {
7323 struct rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_state *state = tevent_req_data(
7324 req, struct rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE_state);
7325 NTSTATUS status;
7326
7327 if (tevent_req_is_nterror(req, &status)) {
7328 tevent_req_received(req);
7329 return status;
7330 }
7331
7332 /* Steal possbile out parameters to the callers context */
7333 talloc_steal(mem_ctx, state->out_mem_ctx);
7334
7335 /* Return result */
7336 *result = state->orig.out.result;
7337
7338 tevent_req_received(req);
7339 return NT_STATUS_OK;
7340 }
7341
7342 NTSTATUS rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct rpc_pipe_client *cli,
7343 TALLOC_CTX *mem_ctx,
7344 WERROR *werror)
7345 {
7346 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE r;
7347 NTSTATUS status;
7348
7349 /* In parameters */
7350
7351 status = cli->dispatch(cli,
7352 mem_ctx,
7353 &ndr_table_srvsvc,
7354 NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE,
7355 &r);
7356
7357 if (!NT_STATUS_IS_OK(status)) {
7358 return status;
7359 }
7360
7361 if (NT_STATUS_IS_ERR(status)) {
7362 return status;
7363 }
7364
7365 /* Return variables */
7366
7367 /* Return result */
7368 if (werror) {
7369 *werror = r.out.result;
7370 }
7371
7372 return werror_to_ntstatus(r.out.result);
7373 }
7374
7375 struct rpccli_srvsvc_NETRDFSSETSERVERINFO_state {
7376 struct srvsvc_NETRDFSSETSERVERINFO orig;
7377 struct srvsvc_NETRDFSSETSERVERINFO tmp;
7378 TALLOC_CTX *out_mem_ctx;
7379 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7380 };
7381
7382 static void rpccli_srvsvc_NETRDFSSETSERVERINFO_done(struct tevent_req *subreq);
7383
7384 struct tevent_req *rpccli_srvsvc_NETRDFSSETSERVERINFO_send(TALLOC_CTX *mem_ctx,
7385 struct tevent_context *ev,
7386 struct rpc_pipe_client *cli)
7387 {
7388 struct tevent_req *req;
7389 struct rpccli_srvsvc_NETRDFSSETSERVERINFO_state *state;
7390 struct tevent_req *subreq;
7391
7392 req = tevent_req_create(mem_ctx, &state,
7393 struct rpccli_srvsvc_NETRDFSSETSERVERINFO_state);
7394 if (req == NULL) {
7395 return NULL;
7396 }
7397 state->out_mem_ctx = NULL;
7398 state->dispatch_recv = cli->dispatch_recv;
7399
7400 /* In parameters */
7401
7402 /* Out parameters */
7403
7404 /* Result */
7405 ZERO_STRUCT(state->orig.out.result);
7406
7407 /* make a temporary copy, that we pass to the dispatch function */
7408 state->tmp = state->orig;
7409
7410 subreq = cli->dispatch_send(state, ev, cli,
7411 &ndr_table_srvsvc,
7412 NDR_SRVSVC_NETRDFSSETSERVERINFO,
7413 &state->tmp);
7414 if (tevent_req_nomem(subreq, req)) {
7415 return tevent_req_post(req, ev);
7416 }
7417 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSSETSERVERINFO_done, req);
7418 return req;
7419 }
7420
7421 static void rpccli_srvsvc_NETRDFSSETSERVERINFO_done(struct tevent_req *subreq)
7422 {
7423 struct tevent_req *req = tevent_req_callback_data(
7424 subreq, struct tevent_req);
7425 struct rpccli_srvsvc_NETRDFSSETSERVERINFO_state *state = tevent_req_data(
7426 req, struct rpccli_srvsvc_NETRDFSSETSERVERINFO_state);
7427 NTSTATUS status;
7428 TALLOC_CTX *mem_ctx;
7429
7430 if (state->out_mem_ctx) {
7431 mem_ctx = state->out_mem_ctx;
7432 } else {
7433 mem_ctx = state;
7434 }
7435
7436 status = state->dispatch_recv(subreq, mem_ctx);
7437 TALLOC_FREE(subreq);
7438 if (!NT_STATUS_IS_OK(status)) {
7439 tevent_req_nterror(req, status);
7440 return;
7441 }
7442
7443 /* Copy out parameters */
7444
7445 /* Copy result */
7446 state->orig.out.result = state->tmp.out.result;
7447
7448 /* Reset temporary structure */
7449 ZERO_STRUCT(state->tmp);
7450
7451 tevent_req_done(req);
7452 }
7453
7454 NTSTATUS rpccli_srvsvc_NETRDFSSETSERVERINFO_recv(struct tevent_req *req,
7455 TALLOC_CTX *mem_ctx,
7456 WERROR *result)
7457 {
7458 struct rpccli_srvsvc_NETRDFSSETSERVERINFO_state *state = tevent_req_data(
7459 req, struct rpccli_srvsvc_NETRDFSSETSERVERINFO_state);
7460 NTSTATUS status;
7461
7462 if (tevent_req_is_nterror(req, &status)) {
7463 tevent_req_received(req);
7464 return status;
7465 }
7466
7467 /* Steal possbile out parameters to the callers context */
7468 talloc_steal(mem_ctx, state->out_mem_ctx);
7469
7470 /* Return result */
7471 *result = state->orig.out.result;
7472
7473 tevent_req_received(req);
7474 return NT_STATUS_OK;
7475 }
7476
7477 NTSTATUS rpccli_srvsvc_NETRDFSSETSERVERINFO(struct rpc_pipe_client *cli,
7478 TALLOC_CTX *mem_ctx,
7479 WERROR *werror)
7480 {
7481 struct srvsvc_NETRDFSSETSERVERINFO r;
7482 NTSTATUS status;
7483
7484 /* In parameters */
7485
7486 status = cli->dispatch(cli,
7487 mem_ctx,
7488 &ndr_table_srvsvc,
7489 NDR_SRVSVC_NETRDFSSETSERVERINFO,
7490 &r);
7491
7492 if (!NT_STATUS_IS_OK(status)) {
7493 return status;
7494 }
7495
7496 if (NT_STATUS_IS_ERR(status)) {
7497 return status;
7498 }
7499
7500 /* Return variables */
7501
7502 /* Return result */
7503 if (werror) {
7504 *werror = r.out.result;
7505 }
7506
7507 return werror_to_ntstatus(r.out.result);
7508 }
7509
7510 struct rpccli_srvsvc_NETRDFSCREATEEXITPOINT_state {
7511 struct srvsvc_NETRDFSCREATEEXITPOINT orig;
7512 struct srvsvc_NETRDFSCREATEEXITPOINT tmp;
7513 TALLOC_CTX *out_mem_ctx;
7514 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7515 };
7516
7517 static void rpccli_srvsvc_NETRDFSCREATEEXITPOINT_done(struct tevent_req *subreq);
7518
7519 struct tevent_req *rpccli_srvsvc_NETRDFSCREATEEXITPOINT_send(TALLOC_CTX *mem_ctx,
7520 struct tevent_context *ev,
7521 struct rpc_pipe_client *cli)
7522 {
7523 struct tevent_req *req;
7524 struct rpccli_srvsvc_NETRDFSCREATEEXITPOINT_state *state;
7525 struct tevent_req *subreq;
7526
7527 req = tevent_req_create(mem_ctx, &state,
7528 struct rpccli_srvsvc_NETRDFSCREATEEXITPOINT_state);
7529 if (req == NULL) {
7530 return NULL;
7531 }
7532 state->out_mem_ctx = NULL;
7533 state->dispatch_recv = cli->dispatch_recv;
7534
7535 /* In parameters */
7536
7537 /* Out parameters */
7538
7539 /* Result */
7540 ZERO_STRUCT(state->orig.out.result);
7541
7542 /* make a temporary copy, that we pass to the dispatch function */
7543 state->tmp = state->orig;
7544
7545 subreq = cli->dispatch_send(state, ev, cli,
7546 &ndr_table_srvsvc,
7547 NDR_SRVSVC_NETRDFSCREATEEXITPOINT,
7548 &state->tmp);
7549 if (tevent_req_nomem(subreq, req)) {
7550 return tevent_req_post(req, ev);
7551 }
7552 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSCREATEEXITPOINT_done, req);
7553 return req;
7554 }
7555
7556 static void rpccli_srvsvc_NETRDFSCREATEEXITPOINT_done(struct tevent_req *subreq)
7557 {
7558 struct tevent_req *req = tevent_req_callback_data(
7559 subreq, struct tevent_req);
7560 struct rpccli_srvsvc_NETRDFSCREATEEXITPOINT_state *state = tevent_req_data(
7561 req, struct rpccli_srvsvc_NETRDFSCREATEEXITPOINT_state);
7562 NTSTATUS status;
7563 TALLOC_CTX *mem_ctx;
7564
7565 if (state->out_mem_ctx) {
7566 mem_ctx = state->out_mem_ctx;
7567 } else {
7568 mem_ctx = state;
7569 }
7570
7571 status = state->dispatch_recv(subreq, mem_ctx);
7572 TALLOC_FREE(subreq);
7573 if (!NT_STATUS_IS_OK(status)) {
7574 tevent_req_nterror(req, status);
7575 return;
7576 }
7577
7578 /* Copy out parameters */
7579
7580 /* Copy result */
7581 state->orig.out.result = state->tmp.out.result;
7582
7583 /* Reset temporary structure */
7584 ZERO_STRUCT(state->tmp);
7585
7586 tevent_req_done(req);
7587 }
7588
7589 NTSTATUS rpccli_srvsvc_NETRDFSCREATEEXITPOINT_recv(struct tevent_req *req,
7590 TALLOC_CTX *mem_ctx,
7591 WERROR *result)
7592 {
7593 struct rpccli_srvsvc_NETRDFSCREATEEXITPOINT_state *state = tevent_req_data(
7594 req, struct rpccli_srvsvc_NETRDFSCREATEEXITPOINT_state);
7595 NTSTATUS status;
7596
7597 if (tevent_req_is_nterror(req, &status)) {
7598 tevent_req_received(req);
7599 return status;
7600 }
7601
7602 /* Steal possbile out parameters to the callers context */
7603 talloc_steal(mem_ctx, state->out_mem_ctx);
7604
7605 /* Return result */
7606 *result = state->orig.out.result;
7607
7608 tevent_req_received(req);
7609 return NT_STATUS_OK;
7610 }
7611
7612 NTSTATUS rpccli_srvsvc_NETRDFSCREATEEXITPOINT(struct rpc_pipe_client *cli,
7613 TALLOC_CTX *mem_ctx,
7614 WERROR *werror)
7615 {
7616 struct srvsvc_NETRDFSCREATEEXITPOINT r;
7617 NTSTATUS status;
7618
7619 /* In parameters */
7620
7621 status = cli->dispatch(cli,
7622 mem_ctx,
7623 &ndr_table_srvsvc,
7624 NDR_SRVSVC_NETRDFSCREATEEXITPOINT,
7625 &r);
7626
7627 if (!NT_STATUS_IS_OK(status)) {
7628 return status;
7629 }
7630
7631 if (NT_STATUS_IS_ERR(status)) {
7632 return status;
7633 }
7634
7635 /* Return variables */
7636
7637 /* Return result */
7638 if (werror) {
7639 *werror = r.out.result;
7640 }
7641
7642 return werror_to_ntstatus(r.out.result);
7643 }
7644
7645 struct rpccli_srvsvc_NETRDFSDELETEEXITPOINT_state {
7646 struct srvsvc_NETRDFSDELETEEXITPOINT orig;
7647 struct srvsvc_NETRDFSDELETEEXITPOINT tmp;
7648 TALLOC_CTX *out_mem_ctx;
7649 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7650 };
7651
7652 static void rpccli_srvsvc_NETRDFSDELETEEXITPOINT_done(struct tevent_req *subreq);
7653
7654 struct tevent_req *rpccli_srvsvc_NETRDFSDELETEEXITPOINT_send(TALLOC_CTX *mem_ctx,
7655 struct tevent_context *ev,
7656 struct rpc_pipe_client *cli)
7657 {
7658 struct tevent_req *req;
7659 struct rpccli_srvsvc_NETRDFSDELETEEXITPOINT_state *state;
7660 struct tevent_req *subreq;
7661
7662 req = tevent_req_create(mem_ctx, &state,
7663 struct rpccli_srvsvc_NETRDFSDELETEEXITPOINT_state);
7664 if (req == NULL) {
7665 return NULL;
7666 }
7667 state->out_mem_ctx = NULL;
7668 state->dispatch_recv = cli->dispatch_recv;
7669
7670 /* In parameters */
7671
7672 /* Out parameters */
7673
7674 /* Result */
7675 ZERO_STRUCT(state->orig.out.result);
7676
7677 /* make a temporary copy, that we pass to the dispatch function */
7678 state->tmp = state->orig;
7679
7680 subreq = cli->dispatch_send(state, ev, cli,
7681 &ndr_table_srvsvc,
7682 NDR_SRVSVC_NETRDFSDELETEEXITPOINT,
7683 &state->tmp);
7684 if (tevent_req_nomem(subreq, req)) {
7685 return tevent_req_post(req, ev);
7686 }
7687 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSDELETEEXITPOINT_done, req);
7688 return req;
7689 }
7690
7691 static void rpccli_srvsvc_NETRDFSDELETEEXITPOINT_done(struct tevent_req *subreq)
7692 {
7693 struct tevent_req *req = tevent_req_callback_data(
7694 subreq, struct tevent_req);
7695 struct rpccli_srvsvc_NETRDFSDELETEEXITPOINT_state *state = tevent_req_data(
7696 req, struct rpccli_srvsvc_NETRDFSDELETEEXITPOINT_state);
7697 NTSTATUS status;
7698 TALLOC_CTX *mem_ctx;
7699
7700 if (state->out_mem_ctx) {
7701 mem_ctx = state->out_mem_ctx;
7702 } else {
7703 mem_ctx = state;
7704 }
7705
7706 status = state->dispatch_recv(subreq, mem_ctx);
7707 TALLOC_FREE(subreq);
7708 if (!NT_STATUS_IS_OK(status)) {
7709 tevent_req_nterror(req, status);
7710 return;
7711 }
7712
7713 /* Copy out parameters */
7714
7715 /* Copy result */
7716 state->orig.out.result = state->tmp.out.result;
7717
7718 /* Reset temporary structure */
7719 ZERO_STRUCT(state->tmp);
7720
7721 tevent_req_done(req);
7722 }
7723
7724 NTSTATUS rpccli_srvsvc_NETRDFSDELETEEXITPOINT_recv(struct tevent_req *req,
7725 TALLOC_CTX *mem_ctx,
7726 WERROR *result)
7727 {
7728 struct rpccli_srvsvc_NETRDFSDELETEEXITPOINT_state *state = tevent_req_data(
7729 req, struct rpccli_srvsvc_NETRDFSDELETEEXITPOINT_state);
7730 NTSTATUS status;
7731
7732 if (tevent_req_is_nterror(req, &status)) {
7733 tevent_req_received(req);
7734 return status;
7735 }
7736
7737 /* Steal possbile out parameters to the callers context */
7738 talloc_steal(mem_ctx, state->out_mem_ctx);
7739
7740 /* Return result */
7741 *result = state->orig.out.result;
7742
7743 tevent_req_received(req);
7744 return NT_STATUS_OK;
7745 }
7746
7747 NTSTATUS rpccli_srvsvc_NETRDFSDELETEEXITPOINT(struct rpc_pipe_client *cli,
7748 TALLOC_CTX *mem_ctx,
7749 WERROR *werror)
7750 {
7751 struct srvsvc_NETRDFSDELETEEXITPOINT r;
7752 NTSTATUS status;
7753
7754 /* In parameters */
7755
7756 status = cli->dispatch(cli,
7757 mem_ctx,
7758 &ndr_table_srvsvc,
7759 NDR_SRVSVC_NETRDFSDELETEEXITPOINT,
7760 &r);
7761
7762 if (!NT_STATUS_IS_OK(status)) {
7763 return status;
7764 }
7765
7766 if (NT_STATUS_IS_ERR(status)) {
7767 return status;
7768 }
7769
7770 /* Return variables */
7771
7772 /* Return result */
7773 if (werror) {
7774 *werror = r.out.result;
7775 }
7776
7777 return werror_to_ntstatus(r.out.result);
7778 }
7779
7780 struct rpccli_srvsvc_NETRDFSMODIFYPREFIX_state {
7781 struct srvsvc_NETRDFSMODIFYPREFIX orig;
7782 struct srvsvc_NETRDFSMODIFYPREFIX tmp;
7783 TALLOC_CTX *out_mem_ctx;
7784 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7785 };
7786
7787 static void rpccli_srvsvc_NETRDFSMODIFYPREFIX_done(struct tevent_req *subreq);
7788
7789 struct tevent_req *rpccli_srvsvc_NETRDFSMODIFYPREFIX_send(TALLOC_CTX *mem_ctx,
7790 struct tevent_context *ev,
7791 struct rpc_pipe_client *cli)
7792 {
7793 struct tevent_req *req;
7794 struct rpccli_srvsvc_NETRDFSMODIFYPREFIX_state *state;
7795 struct tevent_req *subreq;
7796
7797 req = tevent_req_create(mem_ctx, &state,
7798 struct rpccli_srvsvc_NETRDFSMODIFYPREFIX_state);
7799 if (req == NULL) {
7800 return NULL;
7801 }
7802 state->out_mem_ctx = NULL;
7803 state->dispatch_recv = cli->dispatch_recv;
7804
7805 /* In parameters */
7806
7807 /* Out parameters */
7808
7809 /* Result */
7810 ZERO_STRUCT(state->orig.out.result);
7811
7812 /* make a temporary copy, that we pass to the dispatch function */
7813 state->tmp = state->orig;
7814
7815 subreq = cli->dispatch_send(state, ev, cli,
7816 &ndr_table_srvsvc,
7817 NDR_SRVSVC_NETRDFSMODIFYPREFIX,
7818 &state->tmp);
7819 if (tevent_req_nomem(subreq, req)) {
7820 return tevent_req_post(req, ev);
7821 }
7822 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSMODIFYPREFIX_done, req);
7823 return req;
7824 }
7825
7826 static void rpccli_srvsvc_NETRDFSMODIFYPREFIX_done(struct tevent_req *subreq)
7827 {
7828 struct tevent_req *req = tevent_req_callback_data(
7829 subreq, struct tevent_req);
7830 struct rpccli_srvsvc_NETRDFSMODIFYPREFIX_state *state = tevent_req_data(
7831 req, struct rpccli_srvsvc_NETRDFSMODIFYPREFIX_state);
7832 NTSTATUS status;
7833 TALLOC_CTX *mem_ctx;
7834
7835 if (state->out_mem_ctx) {
7836 mem_ctx = state->out_mem_ctx;
7837 } else {
7838 mem_ctx = state;
7839 }
7840
7841 status = state->dispatch_recv(subreq, mem_ctx);
7842 TALLOC_FREE(subreq);
7843 if (!NT_STATUS_IS_OK(status)) {
7844 tevent_req_nterror(req, status);
7845 return;
7846 }
7847
7848 /* Copy out parameters */
7849
7850 /* Copy result */
7851 state->orig.out.result = state->tmp.out.result;
7852
7853 /* Reset temporary structure */
7854 ZERO_STRUCT(state->tmp);
7855
7856 tevent_req_done(req);
7857 }
7858
7859 NTSTATUS rpccli_srvsvc_NETRDFSMODIFYPREFIX_recv(struct tevent_req *req,
7860 TALLOC_CTX *mem_ctx,
7861 WERROR *result)
7862 {
7863 struct rpccli_srvsvc_NETRDFSMODIFYPREFIX_state *state = tevent_req_data(
7864 req, struct rpccli_srvsvc_NETRDFSMODIFYPREFIX_state);
7865 NTSTATUS status;
7866
7867 if (tevent_req_is_nterror(req, &status)) {
7868 tevent_req_received(req);
7869 return status;
7870 }
7871
7872 /* Steal possbile out parameters to the callers context */
7873 talloc_steal(mem_ctx, state->out_mem_ctx);
7874
7875 /* Return result */
7876 *result = state->orig.out.result;
7877
7878 tevent_req_received(req);
7879 return NT_STATUS_OK;
7880 }
7881
7882 NTSTATUS rpccli_srvsvc_NETRDFSMODIFYPREFIX(struct rpc_pipe_client *cli,
7883 TALLOC_CTX *mem_ctx,
7884 WERROR *werror)
7885 {
7886 struct srvsvc_NETRDFSMODIFYPREFIX r;
7887 NTSTATUS status;
7888
7889 /* In parameters */
7890
7891 status = cli->dispatch(cli,
7892 mem_ctx,
7893 &ndr_table_srvsvc,
7894 NDR_SRVSVC_NETRDFSMODIFYPREFIX,
7895 &r);
7896
7897 if (!NT_STATUS_IS_OK(status)) {
7898 return status;
7899 }
7900
7901 if (NT_STATUS_IS_ERR(status)) {
7902 return status;
7903 }
7904
7905 /* Return variables */
7906
7907 /* Return result */
7908 if (werror) {
7909 *werror = r.out.result;
7910 }
7911
7912 return werror_to_ntstatus(r.out.result);
7913 }
7914
7915 struct rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_state {
7916 struct srvsvc_NETRDFSFIXLOCALVOLUME orig;
7917 struct srvsvc_NETRDFSFIXLOCALVOLUME tmp;
7918 TALLOC_CTX *out_mem_ctx;
7919 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7920 };
7921
7922 static void rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_done(struct tevent_req *subreq);
7923
7924 struct tevent_req *rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_send(TALLOC_CTX *mem_ctx,
7925 struct tevent_context *ev,
7926 struct rpc_pipe_client *cli)
7927 {
7928 struct tevent_req *req;
7929 struct rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_state *state;
7930 struct tevent_req *subreq;
7931
7932 req = tevent_req_create(mem_ctx, &state,
7933 struct rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_state);
7934 if (req == NULL) {
7935 return NULL;
7936 }
7937 state->out_mem_ctx = NULL;
7938 state->dispatch_recv = cli->dispatch_recv;
7939
7940 /* In parameters */
7941
7942 /* Out parameters */
7943
7944 /* Result */
7945 ZERO_STRUCT(state->orig.out.result);
7946
7947 /* make a temporary copy, that we pass to the dispatch function */
7948 state->tmp = state->orig;
7949
7950 subreq = cli->dispatch_send(state, ev, cli,
7951 &ndr_table_srvsvc,
7952 NDR_SRVSVC_NETRDFSFIXLOCALVOLUME,
7953 &state->tmp);
7954 if (tevent_req_nomem(subreq, req)) {
7955 return tevent_req_post(req, ev);
7956 }
7957 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_done, req);
7958 return req;
7959 }
7960
7961 static void rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_done(struct tevent_req *subreq)
7962 {
7963 struct tevent_req *req = tevent_req_callback_data(
7964 subreq, struct tevent_req);
7965 struct rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_state *state = tevent_req_data(
7966 req, struct rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_state);
7967 NTSTATUS status;
7968 TALLOC_CTX *mem_ctx;
7969
7970 if (state->out_mem_ctx) {
7971 mem_ctx = state->out_mem_ctx;
7972 } else {
7973 mem_ctx = state;
7974 }
7975
7976 status = state->dispatch_recv(subreq, mem_ctx);
7977 TALLOC_FREE(subreq);
7978 if (!NT_STATUS_IS_OK(status)) {
7979 tevent_req_nterror(req, status);
7980 return;
7981 }
7982
7983 /* Copy out parameters */
7984
7985 /* Copy result */
7986 state->orig.out.result = state->tmp.out.result;
7987
7988 /* Reset temporary structure */
7989 ZERO_STRUCT(state->tmp);
7990
7991 tevent_req_done(req);
7992 }
7993
7994 NTSTATUS rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_recv(struct tevent_req *req,
7995 TALLOC_CTX *mem_ctx,
7996 WERROR *result)
7997 {
7998 struct rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_state *state = tevent_req_data(
7999 req, struct rpccli_srvsvc_NETRDFSFIXLOCALVOLUME_state);
8000 NTSTATUS status;
8001
8002 if (tevent_req_is_nterror(req, &status)) {
8003 tevent_req_received(req);
8004 return status;
8005 }
8006
8007 /* Steal possbile out parameters to the callers context */
8008 talloc_steal(mem_ctx, state->out_mem_ctx);
8009
8010 /* Return result */
8011 *result = state->orig.out.result;
8012
8013 tevent_req_received(req);
8014 return NT_STATUS_OK;
8015 }
8016
8017 NTSTATUS rpccli_srvsvc_NETRDFSFIXLOCALVOLUME(struct rpc_pipe_client *cli,
8018 TALLOC_CTX *mem_ctx,
8019 WERROR *werror)
8020 {
8021 struct srvsvc_NETRDFSFIXLOCALVOLUME r;
8022 NTSTATUS status;
8023
8024 /* In parameters */
8025
8026 status = cli->dispatch(cli,
8027 mem_ctx,
8028 &ndr_table_srvsvc,
8029 NDR_SRVSVC_NETRDFSFIXLOCALVOLUME,
8030 &r);
8031
8032 if (!NT_STATUS_IS_OK(status)) {
8033 return status;
8034 }
8035
8036 if (NT_STATUS_IS_ERR(status)) {
8037 return status;
8038 }
8039
8040 /* Return variables */
8041
8042 /* Return result */
8043 if (werror) {
8044 *werror = r.out.result;
8045 }
8046
8047 return werror_to_ntstatus(r.out.result);
8048 }
8049
8050 struct rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_state {
8051 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO orig;
8052 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO tmp;
8053 TALLOC_CTX *out_mem_ctx;
8054 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8055 };
8056
8057 static void rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_done(struct tevent_req *subreq);
8058
8059 struct tevent_req *rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_send(TALLOC_CTX *mem_ctx,
8060 struct tevent_context *ev,
8061 struct rpc_pipe_client *cli)
8062 {
8063 struct tevent_req *req;
8064 struct rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_state *state;
8065 struct tevent_req *subreq;
8066
8067 req = tevent_req_create(mem_ctx, &state,
8068 struct rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_state);
8069 if (req == NULL) {
8070 return NULL;
8071 }
8072 state->out_mem_ctx = NULL;
8073 state->dispatch_recv = cli->dispatch_recv;
8074
8075 /* In parameters */
8076
8077 /* Out parameters */
8078
8079 /* Result */
8080 ZERO_STRUCT(state->orig.out.result);
8081
8082 /* make a temporary copy, that we pass to the dispatch function */
8083 state->tmp = state->orig;
8084
8085 subreq = cli->dispatch_send(state, ev, cli,
8086 &ndr_table_srvsvc,
8087 NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO,
8088 &state->tmp);
8089 if (tevent_req_nomem(subreq, req)) {
8090 return tevent_req_post(req, ev);
8091 }
8092 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_done, req);
8093 return req;
8094 }
8095
8096 static void rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_done(struct tevent_req *subreq)
8097 {
8098 struct tevent_req *req = tevent_req_callback_data(
8099 subreq, struct tevent_req);
8100 struct rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_state *state = tevent_req_data(
8101 req, struct rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_state);
8102 NTSTATUS status;
8103 TALLOC_CTX *mem_ctx;
8104
8105 if (state->out_mem_ctx) {
8106 mem_ctx = state->out_mem_ctx;
8107 } else {
8108 mem_ctx = state;
8109 }
8110
8111 status = state->dispatch_recv(subreq, mem_ctx);
8112 TALLOC_FREE(subreq);
8113 if (!NT_STATUS_IS_OK(status)) {
8114 tevent_req_nterror(req, status);
8115 return;
8116 }
8117
8118 /* Copy out parameters */
8119
8120 /* Copy result */
8121 state->orig.out.result = state->tmp.out.result;
8122
8123 /* Reset temporary structure */
8124 ZERO_STRUCT(state->tmp);
8125
8126 tevent_req_done(req);
8127 }
8128
8129 NTSTATUS rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_recv(struct tevent_req *req,
8130 TALLOC_CTX *mem_ctx,
8131 WERROR *result)
8132 {
8133 struct rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_state *state = tevent_req_data(
8134 req, struct rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO_state);
8135 NTSTATUS status;
8136
8137 if (tevent_req_is_nterror(req, &status)) {
8138 tevent_req_received(req);
8139 return status;
8140 }
8141
8142 /* Steal possbile out parameters to the callers context */
8143 talloc_steal(mem_ctx, state->out_mem_ctx);
8144
8145 /* Return result */
8146 *result = state->orig.out.result;
8147
8148 tevent_req_received(req);
8149 return NT_STATUS_OK;
8150 }
8151
8152 NTSTATUS rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct rpc_pipe_client *cli,
8153 TALLOC_CTX *mem_ctx,
8154 WERROR *werror)
8155 {
8156 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO r;
8157 NTSTATUS status;
8158
8159 /* In parameters */
8160
8161 status = cli->dispatch(cli,
8162 mem_ctx,
8163 &ndr_table_srvsvc,
8164 NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO,
8165 &r);
8166
8167 if (!NT_STATUS_IS_OK(status)) {
8168 return status;
8169 }
8170
8171 if (NT_STATUS_IS_ERR(status)) {
8172 return status;
8173 }
8174
8175 /* Return variables */
8176
8177 /* Return result */
8178 if (werror) {
8179 *werror = r.out.result;
8180 }
8181
8182 return werror_to_ntstatus(r.out.result);
8183 }
8184
8185 struct rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_state {
8186 struct srvsvc_NETRSERVERTRANSPORTDELEX orig;
8187 struct srvsvc_NETRSERVERTRANSPORTDELEX tmp;
8188 TALLOC_CTX *out_mem_ctx;
8189 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8190 };
8191
8192 static void rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_done(struct tevent_req *subreq);
8193
8194 struct tevent_req *rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_send(TALLOC_CTX *mem_ctx,
8195 struct tevent_context *ev,
8196 struct rpc_pipe_client *cli)
8197 {
8198 struct tevent_req *req;
8199 struct rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_state *state;
8200 struct tevent_req *subreq;
8201
8202 req = tevent_req_create(mem_ctx, &state,
8203 struct rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_state);
8204 if (req == NULL) {
8205 return NULL;
8206 }
8207 state->out_mem_ctx = NULL;
8208 state->dispatch_recv = cli->dispatch_recv;
8209
8210 /* In parameters */
8211
8212 /* Out parameters */
8213
8214 /* Result */
8215 ZERO_STRUCT(state->orig.out.result);
8216
8217 /* make a temporary copy, that we pass to the dispatch function */
8218 state->tmp = state->orig;
8219
8220 subreq = cli->dispatch_send(state, ev, cli,
8221 &ndr_table_srvsvc,
8222 NDR_SRVSVC_NETRSERVERTRANSPORTDELEX,
8223 &state->tmp);
8224 if (tevent_req_nomem(subreq, req)) {
8225 return tevent_req_post(req, ev);
8226 }
8227 tevent_req_set_callback(subreq, rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_done, req);
8228 return req;
8229 }
8230
8231 static void rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_done(struct tevent_req *subreq)
8232 {
8233 struct tevent_req *req = tevent_req_callback_data(
8234 subreq, struct tevent_req);
8235 struct rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_state *state = tevent_req_data(
8236 req, struct rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_state);
8237 NTSTATUS status;
8238 TALLOC_CTX *mem_ctx;
8239
8240 if (state->out_mem_ctx) {
8241 mem_ctx = state->out_mem_ctx;
8242 } else {
8243 mem_ctx = state;
8244 }
8245
8246 status = state->dispatch_recv(subreq, mem_ctx);
8247 TALLOC_FREE(subreq);
8248 if (!NT_STATUS_IS_OK(status)) {
8249 tevent_req_nterror(req, status);
8250 return;
8251 }
8252
8253 /* Copy out parameters */
8254
8255 /* Copy result */
8256 state->orig.out.result = state->tmp.out.result;
8257
8258 /* Reset temporary structure */
8259 ZERO_STRUCT(state->tmp);
8260
8261 tevent_req_done(req);
8262 }
8263
8264 NTSTATUS rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_recv(struct tevent_req *req,
8265 TALLOC_CTX *mem_ctx,
8266 WERROR *result)
8267 {
8268 struct rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_state *state = tevent_req_data(
8269 req, struct rpccli_srvsvc_NETRSERVERTRANSPORTDELEX_state);
8270 NTSTATUS status;
8271
8272 if (tevent_req_is_nterror(req, &status)) {
8273 tevent_req_received(req);
8274 return status;
8275 }
8276
8277 /* Steal possbile out parameters to the callers context */
8278 talloc_steal(mem_ctx, state->out_mem_ctx);
8279
8280 /* Return result */
8281 *result = state->orig.out.result;
8282
8283 tevent_req_received(req);
8284 return NT_STATUS_OK;
8285 }
8286
8287 NTSTATUS rpccli_srvsvc_NETRSERVERTRANSPORTDELEX(struct rpc_pipe_client *cli,
8288 TALLOC_CTX *mem_ctx,
8289 WERROR *werror)
8290 {
8291 struct srvsvc_NETRSERVERTRANSPORTDELEX r;
8292 NTSTATUS status;
8293
8294 /* In parameters */
8295
8296 status = cli->dispatch(cli,
8297 mem_ctx,
8298 &ndr_table_srvsvc,
8299 NDR_SRVSVC_NETRSERVERTRANSPORTDELEX,
8300 &r);
8301
8302 if (!NT_STATUS_IS_OK(status)) {
8303 return status;
8304 }
8305
8306 if (NT_STATUS_IS_ERR(status)) {
8307 return status;
8308 }
8309
8310 /* Return variables */
8311
8312 /* Return result */
8313 if (werror) {
8314 *werror = r.out.result;
8315 }
8316
8317 return werror_to_ntstatus(r.out.result);
8318 }
8319