?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:smbd: make sure we always have a valid talloc stackframe
[Samba.git] / librpc / gen_ndr / cli_wkssvc.c
blobb8465d9bef5813b644e2a925fcfcabd10389a92e
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_wkssvc.h"
8
9 struct rpccli_wkssvc_NetWkstaGetInfo_state {
10 struct wkssvc_NetWkstaGetInfo orig;
11 struct wkssvc_NetWkstaGetInfo 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_wkssvc_NetWkstaGetInfo_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_wkssvc_NetWkstaGetInfo_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli,
21 const char *_server_name /* [in] [unique,charset(UTF16)] */,
22 uint32_t _level /* [in] */,
23 union wkssvc_NetWkstaInfo *_info /* [out] [ref,switch_is(level)] */)
24 {
25 struct tevent_req *req;
26 struct rpccli_wkssvc_NetWkstaGetInfo_state *state;
27 struct tevent_req *subreq;
28
29 req = tevent_req_create(mem_ctx, &state,
30 struct rpccli_wkssvc_NetWkstaGetInfo_state);
31 if (req == NULL) {
32 return NULL;
33 }
34 state->out_mem_ctx = NULL;
35 state->dispatch_recv = cli->dispatch_recv;
36
37 /* In parameters */
38 state->orig.in.server_name = _server_name;
39 state->orig.in.level = _level;
40
41 /* Out parameters */
42 state->orig.out.info = _info;
43
44 /* Result */
45 ZERO_STRUCT(state->orig.out.result);
46
47 state->out_mem_ctx = talloc_named_const(state, 0,
48 "rpccli_wkssvc_NetWkstaGetInfo_out_memory");
49 if (tevent_req_nomem(state->out_mem_ctx, req)) {
50 return tevent_req_post(req, ev);
51 }
52
53 /* make a temporary copy, that we pass to the dispatch function */
54 state->tmp = state->orig;
55
56 subreq = cli->dispatch_send(state, ev, cli,
57 &ndr_table_wkssvc,
58 NDR_WKSSVC_NETWKSTAGETINFO,
59 &state->tmp);
60 if (tevent_req_nomem(subreq, req)) {
61 return tevent_req_post(req, ev);
62 }
63 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaGetInfo_done, req);
64 return req;
65 }
66
67 static void rpccli_wkssvc_NetWkstaGetInfo_done(struct tevent_req *subreq)
68 {
69 struct tevent_req *req = tevent_req_callback_data(
70 subreq, struct tevent_req);
71 struct rpccli_wkssvc_NetWkstaGetInfo_state *state = tevent_req_data(
72 req, struct rpccli_wkssvc_NetWkstaGetInfo_state);
73 NTSTATUS status;
74 TALLOC_CTX *mem_ctx;
75
76 if (state->out_mem_ctx) {
77 mem_ctx = state->out_mem_ctx;
78 } else {
79 mem_ctx = state;
80 }
81
82 status = state->dispatch_recv(subreq, mem_ctx);
83 TALLOC_FREE(subreq);
84 if (!NT_STATUS_IS_OK(status)) {
85 tevent_req_nterror(req, status);
86 return;
87 }
88
89 /* Copy out parameters */
90 *state->orig.out.info = *state->tmp.out.info;
91
92 /* Copy result */
93 state->orig.out.result = state->tmp.out.result;
94
95 /* Reset temporary structure */
96 ZERO_STRUCT(state->tmp);
97
98 tevent_req_done(req);
99 }
100
101 NTSTATUS rpccli_wkssvc_NetWkstaGetInfo_recv(struct tevent_req *req,
102 TALLOC_CTX *mem_ctx,
103 WERROR *result)
104 {
105 struct rpccli_wkssvc_NetWkstaGetInfo_state *state = tevent_req_data(
106 req, struct rpccli_wkssvc_NetWkstaGetInfo_state);
107 NTSTATUS status;
108
109 if (tevent_req_is_nterror(req, &status)) {
110 tevent_req_received(req);
111 return status;
112 }
113
114 /* Steal possbile out parameters to the callers context */
115 talloc_steal(mem_ctx, state->out_mem_ctx);
116
117 /* Return result */
118 *result = state->orig.out.result;
119
120 tevent_req_received(req);
121 return NT_STATUS_OK;
122 }
123
124 NTSTATUS rpccli_wkssvc_NetWkstaGetInfo(struct rpc_pipe_client *cli,
125 TALLOC_CTX *mem_ctx,
126 const char *server_name /* [in] [unique,charset(UTF16)] */,
127 uint32_t level /* [in] */,
128 union wkssvc_NetWkstaInfo *info /* [out] [ref,switch_is(level)] */,
129 WERROR *werror)
130 {
131 struct wkssvc_NetWkstaGetInfo r;
132 NTSTATUS status;
133
134 /* In parameters */
135 r.in.server_name = server_name;
136 r.in.level = level;
137
138 status = cli->dispatch(cli,
139 mem_ctx,
140 &ndr_table_wkssvc,
141 NDR_WKSSVC_NETWKSTAGETINFO,
142 &r);
143
144 if (!NT_STATUS_IS_OK(status)) {
145 return status;
146 }
147
148 if (NT_STATUS_IS_ERR(status)) {
149 return status;
150 }
151
152 /* Return variables */
153 *info = *r.out.info;
154
155 /* Return result */
156 if (werror) {
157 *werror = r.out.result;
158 }
159
160 return werror_to_ntstatus(r.out.result);
161 }
162
163 struct rpccli_wkssvc_NetWkstaSetInfo_state {
164 struct wkssvc_NetWkstaSetInfo orig;
165 struct wkssvc_NetWkstaSetInfo tmp;
166 TALLOC_CTX *out_mem_ctx;
167 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
168 };
169
170 static void rpccli_wkssvc_NetWkstaSetInfo_done(struct tevent_req *subreq);
171
172 struct tevent_req *rpccli_wkssvc_NetWkstaSetInfo_send(TALLOC_CTX *mem_ctx,
173 struct tevent_context *ev,
174 struct rpc_pipe_client *cli,
175 const char *_server_name /* [in] [unique,charset(UTF16)] */,
176 uint32_t _level /* [in] */,
177 union wkssvc_NetWkstaInfo *_info /* [in] [ref,switch_is(level)] */,
178 uint32_t *_parm_error /* [in,out] [ref] */)
179 {
180 struct tevent_req *req;
181 struct rpccli_wkssvc_NetWkstaSetInfo_state *state;
182 struct tevent_req *subreq;
183
184 req = tevent_req_create(mem_ctx, &state,
185 struct rpccli_wkssvc_NetWkstaSetInfo_state);
186 if (req == NULL) {
187 return NULL;
188 }
189 state->out_mem_ctx = NULL;
190 state->dispatch_recv = cli->dispatch_recv;
191
192 /* In parameters */
193 state->orig.in.server_name = _server_name;
194 state->orig.in.level = _level;
195 state->orig.in.info = _info;
196 state->orig.in.parm_error = _parm_error;
197
198 /* Out parameters */
199 state->orig.out.parm_error = _parm_error;
200
201 /* Result */
202 ZERO_STRUCT(state->orig.out.result);
203
204 state->out_mem_ctx = talloc_named_const(state, 0,
205 "rpccli_wkssvc_NetWkstaSetInfo_out_memory");
206 if (tevent_req_nomem(state->out_mem_ctx, req)) {
207 return tevent_req_post(req, ev);
208 }
209
210 /* make a temporary copy, that we pass to the dispatch function */
211 state->tmp = state->orig;
212
213 subreq = cli->dispatch_send(state, ev, cli,
214 &ndr_table_wkssvc,
215 NDR_WKSSVC_NETWKSTASETINFO,
216 &state->tmp);
217 if (tevent_req_nomem(subreq, req)) {
218 return tevent_req_post(req, ev);
219 }
220 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaSetInfo_done, req);
221 return req;
222 }
223
224 static void rpccli_wkssvc_NetWkstaSetInfo_done(struct tevent_req *subreq)
225 {
226 struct tevent_req *req = tevent_req_callback_data(
227 subreq, struct tevent_req);
228 struct rpccli_wkssvc_NetWkstaSetInfo_state *state = tevent_req_data(
229 req, struct rpccli_wkssvc_NetWkstaSetInfo_state);
230 NTSTATUS status;
231 TALLOC_CTX *mem_ctx;
232
233 if (state->out_mem_ctx) {
234 mem_ctx = state->out_mem_ctx;
235 } else {
236 mem_ctx = state;
237 }
238
239 status = state->dispatch_recv(subreq, mem_ctx);
240 TALLOC_FREE(subreq);
241 if (!NT_STATUS_IS_OK(status)) {
242 tevent_req_nterror(req, status);
243 return;
244 }
245
246 /* Copy out parameters */
247 *state->orig.out.parm_error = *state->tmp.out.parm_error;
248
249 /* Copy result */
250 state->orig.out.result = state->tmp.out.result;
251
252 /* Reset temporary structure */
253 ZERO_STRUCT(state->tmp);
254
255 tevent_req_done(req);
256 }
257
258 NTSTATUS rpccli_wkssvc_NetWkstaSetInfo_recv(struct tevent_req *req,
259 TALLOC_CTX *mem_ctx,
260 WERROR *result)
261 {
262 struct rpccli_wkssvc_NetWkstaSetInfo_state *state = tevent_req_data(
263 req, struct rpccli_wkssvc_NetWkstaSetInfo_state);
264 NTSTATUS status;
265
266 if (tevent_req_is_nterror(req, &status)) {
267 tevent_req_received(req);
268 return status;
269 }
270
271 /* Steal possbile out parameters to the callers context */
272 talloc_steal(mem_ctx, state->out_mem_ctx);
273
274 /* Return result */
275 *result = state->orig.out.result;
276
277 tevent_req_received(req);
278 return NT_STATUS_OK;
279 }
280
281 NTSTATUS rpccli_wkssvc_NetWkstaSetInfo(struct rpc_pipe_client *cli,
282 TALLOC_CTX *mem_ctx,
283 const char *server_name /* [in] [unique,charset(UTF16)] */,
284 uint32_t level /* [in] */,
285 union wkssvc_NetWkstaInfo *info /* [in] [ref,switch_is(level)] */,
286 uint32_t *parm_error /* [in,out] [ref] */,
287 WERROR *werror)
288 {
289 struct wkssvc_NetWkstaSetInfo r;
290 NTSTATUS status;
291
292 /* In parameters */
293 r.in.server_name = server_name;
294 r.in.level = level;
295 r.in.info = info;
296 r.in.parm_error = parm_error;
297
298 status = cli->dispatch(cli,
299 mem_ctx,
300 &ndr_table_wkssvc,
301 NDR_WKSSVC_NETWKSTASETINFO,
302 &r);
303
304 if (!NT_STATUS_IS_OK(status)) {
305 return status;
306 }
307
308 if (NT_STATUS_IS_ERR(status)) {
309 return status;
310 }
311
312 /* Return variables */
313 *parm_error = *r.out.parm_error;
314
315 /* Return result */
316 if (werror) {
317 *werror = r.out.result;
318 }
319
320 return werror_to_ntstatus(r.out.result);
321 }
322
323 struct rpccli_wkssvc_NetWkstaEnumUsers_state {
324 struct wkssvc_NetWkstaEnumUsers orig;
325 struct wkssvc_NetWkstaEnumUsers tmp;
326 TALLOC_CTX *out_mem_ctx;
327 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
328 };
329
330 static void rpccli_wkssvc_NetWkstaEnumUsers_done(struct tevent_req *subreq);
331
332 struct tevent_req *rpccli_wkssvc_NetWkstaEnumUsers_send(TALLOC_CTX *mem_ctx,
333 struct tevent_context *ev,
334 struct rpc_pipe_client *cli,
335 const char *_server_name /* [in] [unique,charset(UTF16)] */,
336 struct wkssvc_NetWkstaEnumUsersInfo *_info /* [in,out] [ref] */,
337 uint32_t _prefmaxlen /* [in] */,
338 uint32_t *_entries_read /* [out] [ref] */,
339 uint32_t *_resume_handle /* [in,out] [unique] */)
340 {
341 struct tevent_req *req;
342 struct rpccli_wkssvc_NetWkstaEnumUsers_state *state;
343 struct tevent_req *subreq;
344
345 req = tevent_req_create(mem_ctx, &state,
346 struct rpccli_wkssvc_NetWkstaEnumUsers_state);
347 if (req == NULL) {
348 return NULL;
349 }
350 state->out_mem_ctx = NULL;
351 state->dispatch_recv = cli->dispatch_recv;
352
353 /* In parameters */
354 state->orig.in.server_name = _server_name;
355 state->orig.in.info = _info;
356 state->orig.in.prefmaxlen = _prefmaxlen;
357 state->orig.in.resume_handle = _resume_handle;
358
359 /* Out parameters */
360 state->orig.out.info = _info;
361 state->orig.out.entries_read = _entries_read;
362 state->orig.out.resume_handle = _resume_handle;
363
364 /* Result */
365 ZERO_STRUCT(state->orig.out.result);
366
367 state->out_mem_ctx = talloc_named_const(state, 0,
368 "rpccli_wkssvc_NetWkstaEnumUsers_out_memory");
369 if (tevent_req_nomem(state->out_mem_ctx, req)) {
370 return tevent_req_post(req, ev);
371 }
372
373 /* make a temporary copy, that we pass to the dispatch function */
374 state->tmp = state->orig;
375
376 subreq = cli->dispatch_send(state, ev, cli,
377 &ndr_table_wkssvc,
378 NDR_WKSSVC_NETWKSTAENUMUSERS,
379 &state->tmp);
380 if (tevent_req_nomem(subreq, req)) {
381 return tevent_req_post(req, ev);
382 }
383 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaEnumUsers_done, req);
384 return req;
385 }
386
387 static void rpccli_wkssvc_NetWkstaEnumUsers_done(struct tevent_req *subreq)
388 {
389 struct tevent_req *req = tevent_req_callback_data(
390 subreq, struct tevent_req);
391 struct rpccli_wkssvc_NetWkstaEnumUsers_state *state = tevent_req_data(
392 req, struct rpccli_wkssvc_NetWkstaEnumUsers_state);
393 NTSTATUS status;
394 TALLOC_CTX *mem_ctx;
395
396 if (state->out_mem_ctx) {
397 mem_ctx = state->out_mem_ctx;
398 } else {
399 mem_ctx = state;
400 }
401
402 status = state->dispatch_recv(subreq, mem_ctx);
403 TALLOC_FREE(subreq);
404 if (!NT_STATUS_IS_OK(status)) {
405 tevent_req_nterror(req, status);
406 return;
407 }
408
409 /* Copy out parameters */
410 *state->orig.out.info = *state->tmp.out.info;
411 *state->orig.out.entries_read = *state->tmp.out.entries_read;
412 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
413 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
414 }
415
416 /* Copy result */
417 state->orig.out.result = state->tmp.out.result;
418
419 /* Reset temporary structure */
420 ZERO_STRUCT(state->tmp);
421
422 tevent_req_done(req);
423 }
424
425 NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers_recv(struct tevent_req *req,
426 TALLOC_CTX *mem_ctx,
427 WERROR *result)
428 {
429 struct rpccli_wkssvc_NetWkstaEnumUsers_state *state = tevent_req_data(
430 req, struct rpccli_wkssvc_NetWkstaEnumUsers_state);
431 NTSTATUS status;
432
433 if (tevent_req_is_nterror(req, &status)) {
434 tevent_req_received(req);
435 return status;
436 }
437
438 /* Steal possbile out parameters to the callers context */
439 talloc_steal(mem_ctx, state->out_mem_ctx);
440
441 /* Return result */
442 *result = state->orig.out.result;
443
444 tevent_req_received(req);
445 return NT_STATUS_OK;
446 }
447
448 NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers(struct rpc_pipe_client *cli,
449 TALLOC_CTX *mem_ctx,
450 const char *server_name /* [in] [unique,charset(UTF16)] */,
451 struct wkssvc_NetWkstaEnumUsersInfo *info /* [in,out] [ref] */,
452 uint32_t prefmaxlen /* [in] */,
453 uint32_t *entries_read /* [out] [ref] */,
454 uint32_t *resume_handle /* [in,out] [unique] */,
455 WERROR *werror)
456 {
457 struct wkssvc_NetWkstaEnumUsers r;
458 NTSTATUS status;
459
460 /* In parameters */
461 r.in.server_name = server_name;
462 r.in.info = info;
463 r.in.prefmaxlen = prefmaxlen;
464 r.in.resume_handle = resume_handle;
465
466 status = cli->dispatch(cli,
467 mem_ctx,
468 &ndr_table_wkssvc,
469 NDR_WKSSVC_NETWKSTAENUMUSERS,
470 &r);
471
472 if (!NT_STATUS_IS_OK(status)) {
473 return status;
474 }
475
476 if (NT_STATUS_IS_ERR(status)) {
477 return status;
478 }
479
480 /* Return variables */
481 *info = *r.out.info;
482 *entries_read = *r.out.entries_read;
483 if (resume_handle && r.out.resume_handle) {
484 *resume_handle = *r.out.resume_handle;
485 }
486
487 /* Return result */
488 if (werror) {
489 *werror = r.out.result;
490 }
491
492 return werror_to_ntstatus(r.out.result);
493 }
494
495 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state {
496 struct wkssvc_NetrWkstaUserGetInfo orig;
497 struct wkssvc_NetrWkstaUserGetInfo tmp;
498 TALLOC_CTX *out_mem_ctx;
499 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
500 };
501
502 static void rpccli_wkssvc_NetrWkstaUserGetInfo_done(struct tevent_req *subreq);
503
504 struct tevent_req *rpccli_wkssvc_NetrWkstaUserGetInfo_send(TALLOC_CTX *mem_ctx,
505 struct tevent_context *ev,
506 struct rpc_pipe_client *cli,
507 const char *_unknown /* [in] [unique,charset(UTF16)] */,
508 uint32_t _level /* [in] */,
509 union wkssvc_NetrWkstaUserInfo *_info /* [out] [ref,switch_is(level)] */)
510 {
511 struct tevent_req *req;
512 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state;
513 struct tevent_req *subreq;
514
515 req = tevent_req_create(mem_ctx, &state,
516 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state);
517 if (req == NULL) {
518 return NULL;
519 }
520 state->out_mem_ctx = NULL;
521 state->dispatch_recv = cli->dispatch_recv;
522
523 /* In parameters */
524 state->orig.in.unknown = _unknown;
525 state->orig.in.level = _level;
526
527 /* Out parameters */
528 state->orig.out.info = _info;
529
530 /* Result */
531 ZERO_STRUCT(state->orig.out.result);
532
533 state->out_mem_ctx = talloc_named_const(state, 0,
534 "rpccli_wkssvc_NetrWkstaUserGetInfo_out_memory");
535 if (tevent_req_nomem(state->out_mem_ctx, req)) {
536 return tevent_req_post(req, ev);
537 }
538
539 /* make a temporary copy, that we pass to the dispatch function */
540 state->tmp = state->orig;
541
542 subreq = cli->dispatch_send(state, ev, cli,
543 &ndr_table_wkssvc,
544 NDR_WKSSVC_NETRWKSTAUSERGETINFO,
545 &state->tmp);
546 if (tevent_req_nomem(subreq, req)) {
547 return tevent_req_post(req, ev);
548 }
549 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaUserGetInfo_done, req);
550 return req;
551 }
552
553 static void rpccli_wkssvc_NetrWkstaUserGetInfo_done(struct tevent_req *subreq)
554 {
555 struct tevent_req *req = tevent_req_callback_data(
556 subreq, struct tevent_req);
557 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state = tevent_req_data(
558 req, struct rpccli_wkssvc_NetrWkstaUserGetInfo_state);
559 NTSTATUS status;
560 TALLOC_CTX *mem_ctx;
561
562 if (state->out_mem_ctx) {
563 mem_ctx = state->out_mem_ctx;
564 } else {
565 mem_ctx = state;
566 }
567
568 status = state->dispatch_recv(subreq, mem_ctx);
569 TALLOC_FREE(subreq);
570 if (!NT_STATUS_IS_OK(status)) {
571 tevent_req_nterror(req, status);
572 return;
573 }
574
575 /* Copy out parameters */
576 *state->orig.out.info = *state->tmp.out.info;
577
578 /* Copy result */
579 state->orig.out.result = state->tmp.out.result;
580
581 /* Reset temporary structure */
582 ZERO_STRUCT(state->tmp);
583
584 tevent_req_done(req);
585 }
586
587 NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo_recv(struct tevent_req *req,
588 TALLOC_CTX *mem_ctx,
589 WERROR *result)
590 {
591 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state = tevent_req_data(
592 req, struct rpccli_wkssvc_NetrWkstaUserGetInfo_state);
593 NTSTATUS status;
594
595 if (tevent_req_is_nterror(req, &status)) {
596 tevent_req_received(req);
597 return status;
598 }
599
600 /* Steal possbile out parameters to the callers context */
601 talloc_steal(mem_ctx, state->out_mem_ctx);
602
603 /* Return result */
604 *result = state->orig.out.result;
605
606 tevent_req_received(req);
607 return NT_STATUS_OK;
608 }
609
610 NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo(struct rpc_pipe_client *cli,
611 TALLOC_CTX *mem_ctx,
612 const char *unknown /* [in] [unique,charset(UTF16)] */,
613 uint32_t level /* [in] */,
614 union wkssvc_NetrWkstaUserInfo *info /* [out] [ref,switch_is(level)] */,
615 WERROR *werror)
616 {
617 struct wkssvc_NetrWkstaUserGetInfo r;
618 NTSTATUS status;
619
620 /* In parameters */
621 r.in.unknown = unknown;
622 r.in.level = level;
623
624 status = cli->dispatch(cli,
625 mem_ctx,
626 &ndr_table_wkssvc,
627 NDR_WKSSVC_NETRWKSTAUSERGETINFO,
628 &r);
629
630 if (!NT_STATUS_IS_OK(status)) {
631 return status;
632 }
633
634 if (NT_STATUS_IS_ERR(status)) {
635 return status;
636 }
637
638 /* Return variables */
639 *info = *r.out.info;
640
641 /* Return result */
642 if (werror) {
643 *werror = r.out.result;
644 }
645
646 return werror_to_ntstatus(r.out.result);
647 }
648
649 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state {
650 struct wkssvc_NetrWkstaUserSetInfo orig;
651 struct wkssvc_NetrWkstaUserSetInfo tmp;
652 TALLOC_CTX *out_mem_ctx;
653 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
654 };
655
656 static void rpccli_wkssvc_NetrWkstaUserSetInfo_done(struct tevent_req *subreq);
657
658 struct tevent_req *rpccli_wkssvc_NetrWkstaUserSetInfo_send(TALLOC_CTX *mem_ctx,
659 struct tevent_context *ev,
660 struct rpc_pipe_client *cli,
661 const char *_unknown /* [in] [unique,charset(UTF16)] */,
662 uint32_t _level /* [in] */,
663 union wkssvc_NetrWkstaUserInfo *_info /* [in] [ref,switch_is(level)] */,
664 uint32_t *_parm_err /* [in,out] [unique] */)
665 {
666 struct tevent_req *req;
667 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state;
668 struct tevent_req *subreq;
669
670 req = tevent_req_create(mem_ctx, &state,
671 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state);
672 if (req == NULL) {
673 return NULL;
674 }
675 state->out_mem_ctx = NULL;
676 state->dispatch_recv = cli->dispatch_recv;
677
678 /* In parameters */
679 state->orig.in.unknown = _unknown;
680 state->orig.in.level = _level;
681 state->orig.in.info = _info;
682 state->orig.in.parm_err = _parm_err;
683
684 /* Out parameters */
685 state->orig.out.parm_err = _parm_err;
686
687 /* Result */
688 ZERO_STRUCT(state->orig.out.result);
689
690 state->out_mem_ctx = talloc_named_const(state, 0,
691 "rpccli_wkssvc_NetrWkstaUserSetInfo_out_memory");
692 if (tevent_req_nomem(state->out_mem_ctx, req)) {
693 return tevent_req_post(req, ev);
694 }
695
696 /* make a temporary copy, that we pass to the dispatch function */
697 state->tmp = state->orig;
698
699 subreq = cli->dispatch_send(state, ev, cli,
700 &ndr_table_wkssvc,
701 NDR_WKSSVC_NETRWKSTAUSERSETINFO,
702 &state->tmp);
703 if (tevent_req_nomem(subreq, req)) {
704 return tevent_req_post(req, ev);
705 }
706 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaUserSetInfo_done, req);
707 return req;
708 }
709
710 static void rpccli_wkssvc_NetrWkstaUserSetInfo_done(struct tevent_req *subreq)
711 {
712 struct tevent_req *req = tevent_req_callback_data(
713 subreq, struct tevent_req);
714 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state = tevent_req_data(
715 req, struct rpccli_wkssvc_NetrWkstaUserSetInfo_state);
716 NTSTATUS status;
717 TALLOC_CTX *mem_ctx;
718
719 if (state->out_mem_ctx) {
720 mem_ctx = state->out_mem_ctx;
721 } else {
722 mem_ctx = state;
723 }
724
725 status = state->dispatch_recv(subreq, mem_ctx);
726 TALLOC_FREE(subreq);
727 if (!NT_STATUS_IS_OK(status)) {
728 tevent_req_nterror(req, status);
729 return;
730 }
731
732 /* Copy out parameters */
733 if (state->orig.out.parm_err && state->tmp.out.parm_err) {
734 *state->orig.out.parm_err = *state->tmp.out.parm_err;
735 }
736
737 /* Copy result */
738 state->orig.out.result = state->tmp.out.result;
739
740 /* Reset temporary structure */
741 ZERO_STRUCT(state->tmp);
742
743 tevent_req_done(req);
744 }
745
746 NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo_recv(struct tevent_req *req,
747 TALLOC_CTX *mem_ctx,
748 WERROR *result)
749 {
750 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state = tevent_req_data(
751 req, struct rpccli_wkssvc_NetrWkstaUserSetInfo_state);
752 NTSTATUS status;
753
754 if (tevent_req_is_nterror(req, &status)) {
755 tevent_req_received(req);
756 return status;
757 }
758
759 /* Steal possbile out parameters to the callers context */
760 talloc_steal(mem_ctx, state->out_mem_ctx);
761
762 /* Return result */
763 *result = state->orig.out.result;
764
765 tevent_req_received(req);
766 return NT_STATUS_OK;
767 }
768
769 NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo(struct rpc_pipe_client *cli,
770 TALLOC_CTX *mem_ctx,
771 const char *unknown /* [in] [unique,charset(UTF16)] */,
772 uint32_t level /* [in] */,
773 union wkssvc_NetrWkstaUserInfo *info /* [in] [ref,switch_is(level)] */,
774 uint32_t *parm_err /* [in,out] [unique] */,
775 WERROR *werror)
776 {
777 struct wkssvc_NetrWkstaUserSetInfo r;
778 NTSTATUS status;
779
780 /* In parameters */
781 r.in.unknown = unknown;
782 r.in.level = level;
783 r.in.info = info;
784 r.in.parm_err = parm_err;
785
786 status = cli->dispatch(cli,
787 mem_ctx,
788 &ndr_table_wkssvc,
789 NDR_WKSSVC_NETRWKSTAUSERSETINFO,
790 &r);
791
792 if (!NT_STATUS_IS_OK(status)) {
793 return status;
794 }
795
796 if (NT_STATUS_IS_ERR(status)) {
797 return status;
798 }
799
800 /* Return variables */
801 if (parm_err && r.out.parm_err) {
802 *parm_err = *r.out.parm_err;
803 }
804
805 /* Return result */
806 if (werror) {
807 *werror = r.out.result;
808 }
809
810 return werror_to_ntstatus(r.out.result);
811 }
812
813 struct rpccli_wkssvc_NetWkstaTransportEnum_state {
814 struct wkssvc_NetWkstaTransportEnum orig;
815 struct wkssvc_NetWkstaTransportEnum tmp;
816 TALLOC_CTX *out_mem_ctx;
817 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
818 };
819
820 static void rpccli_wkssvc_NetWkstaTransportEnum_done(struct tevent_req *subreq);
821
822 struct tevent_req *rpccli_wkssvc_NetWkstaTransportEnum_send(TALLOC_CTX *mem_ctx,
823 struct tevent_context *ev,
824 struct rpc_pipe_client *cli,
825 const char *_server_name /* [in] [unique,charset(UTF16)] */,
826 struct wkssvc_NetWkstaTransportInfo *_info /* [in,out] [ref] */,
827 uint32_t _max_buffer /* [in] */,
828 uint32_t *_total_entries /* [out] [ref] */,
829 uint32_t *_resume_handle /* [in,out] [unique] */)
830 {
831 struct tevent_req *req;
832 struct rpccli_wkssvc_NetWkstaTransportEnum_state *state;
833 struct tevent_req *subreq;
834
835 req = tevent_req_create(mem_ctx, &state,
836 struct rpccli_wkssvc_NetWkstaTransportEnum_state);
837 if (req == NULL) {
838 return NULL;
839 }
840 state->out_mem_ctx = NULL;
841 state->dispatch_recv = cli->dispatch_recv;
842
843 /* In parameters */
844 state->orig.in.server_name = _server_name;
845 state->orig.in.info = _info;
846 state->orig.in.max_buffer = _max_buffer;
847 state->orig.in.resume_handle = _resume_handle;
848
849 /* Out parameters */
850 state->orig.out.info = _info;
851 state->orig.out.total_entries = _total_entries;
852 state->orig.out.resume_handle = _resume_handle;
853
854 /* Result */
855 ZERO_STRUCT(state->orig.out.result);
856
857 state->out_mem_ctx = talloc_named_const(state, 0,
858 "rpccli_wkssvc_NetWkstaTransportEnum_out_memory");
859 if (tevent_req_nomem(state->out_mem_ctx, req)) {
860 return tevent_req_post(req, ev);
861 }
862
863 /* make a temporary copy, that we pass to the dispatch function */
864 state->tmp = state->orig;
865
866 subreq = cli->dispatch_send(state, ev, cli,
867 &ndr_table_wkssvc,
868 NDR_WKSSVC_NETWKSTATRANSPORTENUM,
869 &state->tmp);
870 if (tevent_req_nomem(subreq, req)) {
871 return tevent_req_post(req, ev);
872 }
873 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaTransportEnum_done, req);
874 return req;
875 }
876
877 static void rpccli_wkssvc_NetWkstaTransportEnum_done(struct tevent_req *subreq)
878 {
879 struct tevent_req *req = tevent_req_callback_data(
880 subreq, struct tevent_req);
881 struct rpccli_wkssvc_NetWkstaTransportEnum_state *state = tevent_req_data(
882 req, struct rpccli_wkssvc_NetWkstaTransportEnum_state);
883 NTSTATUS status;
884 TALLOC_CTX *mem_ctx;
885
886 if (state->out_mem_ctx) {
887 mem_ctx = state->out_mem_ctx;
888 } else {
889 mem_ctx = state;
890 }
891
892 status = state->dispatch_recv(subreq, mem_ctx);
893 TALLOC_FREE(subreq);
894 if (!NT_STATUS_IS_OK(status)) {
895 tevent_req_nterror(req, status);
896 return;
897 }
898
899 /* Copy out parameters */
900 *state->orig.out.info = *state->tmp.out.info;
901 *state->orig.out.total_entries = *state->tmp.out.total_entries;
902 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
903 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
904 }
905
906 /* Copy result */
907 state->orig.out.result = state->tmp.out.result;
908
909 /* Reset temporary structure */
910 ZERO_STRUCT(state->tmp);
911
912 tevent_req_done(req);
913 }
914
915 NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum_recv(struct tevent_req *req,
916 TALLOC_CTX *mem_ctx,
917 WERROR *result)
918 {
919 struct rpccli_wkssvc_NetWkstaTransportEnum_state *state = tevent_req_data(
920 req, struct rpccli_wkssvc_NetWkstaTransportEnum_state);
921 NTSTATUS status;
922
923 if (tevent_req_is_nterror(req, &status)) {
924 tevent_req_received(req);
925 return status;
926 }
927
928 /* Steal possbile out parameters to the callers context */
929 talloc_steal(mem_ctx, state->out_mem_ctx);
930
931 /* Return result */
932 *result = state->orig.out.result;
933
934 tevent_req_received(req);
935 return NT_STATUS_OK;
936 }
937
938 NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum(struct rpc_pipe_client *cli,
939 TALLOC_CTX *mem_ctx,
940 const char *server_name /* [in] [unique,charset(UTF16)] */,
941 struct wkssvc_NetWkstaTransportInfo *info /* [in,out] [ref] */,
942 uint32_t max_buffer /* [in] */,
943 uint32_t *total_entries /* [out] [ref] */,
944 uint32_t *resume_handle /* [in,out] [unique] */,
945 WERROR *werror)
946 {
947 struct wkssvc_NetWkstaTransportEnum r;
948 NTSTATUS status;
949
950 /* In parameters */
951 r.in.server_name = server_name;
952 r.in.info = info;
953 r.in.max_buffer = max_buffer;
954 r.in.resume_handle = resume_handle;
955
956 status = cli->dispatch(cli,
957 mem_ctx,
958 &ndr_table_wkssvc,
959 NDR_WKSSVC_NETWKSTATRANSPORTENUM,
960 &r);
961
962 if (!NT_STATUS_IS_OK(status)) {
963 return status;
964 }
965
966 if (NT_STATUS_IS_ERR(status)) {
967 return status;
968 }
969
970 /* Return variables */
971 *info = *r.out.info;
972 *total_entries = *r.out.total_entries;
973 if (resume_handle && r.out.resume_handle) {
974 *resume_handle = *r.out.resume_handle;
975 }
976
977 /* Return result */
978 if (werror) {
979 *werror = r.out.result;
980 }
981
982 return werror_to_ntstatus(r.out.result);
983 }
984
985 struct rpccli_wkssvc_NetrWkstaTransportAdd_state {
986 struct wkssvc_NetrWkstaTransportAdd orig;
987 struct wkssvc_NetrWkstaTransportAdd tmp;
988 TALLOC_CTX *out_mem_ctx;
989 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
990 };
991
992 static void rpccli_wkssvc_NetrWkstaTransportAdd_done(struct tevent_req *subreq);
993
994 struct tevent_req *rpccli_wkssvc_NetrWkstaTransportAdd_send(TALLOC_CTX *mem_ctx,
995 struct tevent_context *ev,
996 struct rpc_pipe_client *cli,
997 const char *_server_name /* [in] [unique,charset(UTF16)] */,
998 uint32_t _level /* [in] */,
999 struct wkssvc_NetWkstaTransportInfo0 *_info0 /* [in] [ref] */,
1000 uint32_t *_parm_err /* [in,out] [unique] */)
1001 {
1002 struct tevent_req *req;
1003 struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state;
1004 struct tevent_req *subreq;
1005
1006 req = tevent_req_create(mem_ctx, &state,
1007 struct rpccli_wkssvc_NetrWkstaTransportAdd_state);
1008 if (req == NULL) {
1009 return NULL;
1010 }
1011 state->out_mem_ctx = NULL;
1012 state->dispatch_recv = cli->dispatch_recv;
1013
1014 /* In parameters */
1015 state->orig.in.server_name = _server_name;
1016 state->orig.in.level = _level;
1017 state->orig.in.info0 = _info0;
1018 state->orig.in.parm_err = _parm_err;
1019
1020 /* Out parameters */
1021 state->orig.out.parm_err = _parm_err;
1022
1023 /* Result */
1024 ZERO_STRUCT(state->orig.out.result);
1025
1026 state->out_mem_ctx = talloc_named_const(state, 0,
1027 "rpccli_wkssvc_NetrWkstaTransportAdd_out_memory");
1028 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1029 return tevent_req_post(req, ev);
1030 }
1031
1032 /* make a temporary copy, that we pass to the dispatch function */
1033 state->tmp = state->orig;
1034
1035 subreq = cli->dispatch_send(state, ev, cli,
1036 &ndr_table_wkssvc,
1037 NDR_WKSSVC_NETRWKSTATRANSPORTADD,
1038 &state->tmp);
1039 if (tevent_req_nomem(subreq, req)) {
1040 return tevent_req_post(req, ev);
1041 }
1042 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaTransportAdd_done, req);
1043 return req;
1044 }
1045
1046 static void rpccli_wkssvc_NetrWkstaTransportAdd_done(struct tevent_req *subreq)
1047 {
1048 struct tevent_req *req = tevent_req_callback_data(
1049 subreq, struct tevent_req);
1050 struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state = tevent_req_data(
1051 req, struct rpccli_wkssvc_NetrWkstaTransportAdd_state);
1052 NTSTATUS status;
1053 TALLOC_CTX *mem_ctx;
1054
1055 if (state->out_mem_ctx) {
1056 mem_ctx = state->out_mem_ctx;
1057 } else {
1058 mem_ctx = state;
1059 }
1060
1061 status = state->dispatch_recv(subreq, mem_ctx);
1062 TALLOC_FREE(subreq);
1063 if (!NT_STATUS_IS_OK(status)) {
1064 tevent_req_nterror(req, status);
1065 return;
1066 }
1067
1068 /* Copy out parameters */
1069 if (state->orig.out.parm_err && state->tmp.out.parm_err) {
1070 *state->orig.out.parm_err = *state->tmp.out.parm_err;
1071 }
1072
1073 /* Copy result */
1074 state->orig.out.result = state->tmp.out.result;
1075
1076 /* Reset temporary structure */
1077 ZERO_STRUCT(state->tmp);
1078
1079 tevent_req_done(req);
1080 }
1081
1082 NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd_recv(struct tevent_req *req,
1083 TALLOC_CTX *mem_ctx,
1084 WERROR *result)
1085 {
1086 struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state = tevent_req_data(
1087 req, struct rpccli_wkssvc_NetrWkstaTransportAdd_state);
1088 NTSTATUS status;
1089
1090 if (tevent_req_is_nterror(req, &status)) {
1091 tevent_req_received(req);
1092 return status;
1093 }
1094
1095 /* Steal possbile out parameters to the callers context */
1096 talloc_steal(mem_ctx, state->out_mem_ctx);
1097
1098 /* Return result */
1099 *result = state->orig.out.result;
1100
1101 tevent_req_received(req);
1102 return NT_STATUS_OK;
1103 }
1104
1105 NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd(struct rpc_pipe_client *cli,
1106 TALLOC_CTX *mem_ctx,
1107 const char *server_name /* [in] [unique,charset(UTF16)] */,
1108 uint32_t level /* [in] */,
1109 struct wkssvc_NetWkstaTransportInfo0 *info0 /* [in] [ref] */,
1110 uint32_t *parm_err /* [in,out] [unique] */,
1111 WERROR *werror)
1112 {
1113 struct wkssvc_NetrWkstaTransportAdd r;
1114 NTSTATUS status;
1115
1116 /* In parameters */
1117 r.in.server_name = server_name;
1118 r.in.level = level;
1119 r.in.info0 = info0;
1120 r.in.parm_err = parm_err;
1121
1122 status = cli->dispatch(cli,
1123 mem_ctx,
1124 &ndr_table_wkssvc,
1125 NDR_WKSSVC_NETRWKSTATRANSPORTADD,
1126 &r);
1127
1128 if (!NT_STATUS_IS_OK(status)) {
1129 return status;
1130 }
1131
1132 if (NT_STATUS_IS_ERR(status)) {
1133 return status;
1134 }
1135
1136 /* Return variables */
1137 if (parm_err && r.out.parm_err) {
1138 *parm_err = *r.out.parm_err;
1139 }
1140
1141 /* Return result */
1142 if (werror) {
1143 *werror = r.out.result;
1144 }
1145
1146 return werror_to_ntstatus(r.out.result);
1147 }
1148
1149 struct rpccli_wkssvc_NetrWkstaTransportDel_state {
1150 struct wkssvc_NetrWkstaTransportDel orig;
1151 struct wkssvc_NetrWkstaTransportDel tmp;
1152 TALLOC_CTX *out_mem_ctx;
1153 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1154 };
1155
1156 static void rpccli_wkssvc_NetrWkstaTransportDel_done(struct tevent_req *subreq);
1157
1158 struct tevent_req *rpccli_wkssvc_NetrWkstaTransportDel_send(TALLOC_CTX *mem_ctx,
1159 struct tevent_context *ev,
1160 struct rpc_pipe_client *cli,
1161 const char *_server_name /* [in] [unique,charset(UTF16)] */,
1162 const char *_transport_name /* [in] [unique,charset(UTF16)] */,
1163 uint32_t _unknown3 /* [in] */)
1164 {
1165 struct tevent_req *req;
1166 struct rpccli_wkssvc_NetrWkstaTransportDel_state *state;
1167 struct tevent_req *subreq;
1168
1169 req = tevent_req_create(mem_ctx, &state,
1170 struct rpccli_wkssvc_NetrWkstaTransportDel_state);
1171 if (req == NULL) {
1172 return NULL;
1173 }
1174 state->out_mem_ctx = NULL;
1175 state->dispatch_recv = cli->dispatch_recv;
1176
1177 /* In parameters */
1178 state->orig.in.server_name = _server_name;
1179 state->orig.in.transport_name = _transport_name;
1180 state->orig.in.unknown3 = _unknown3;
1181
1182 /* Out parameters */
1183
1184 /* Result */
1185 ZERO_STRUCT(state->orig.out.result);
1186
1187 /* make a temporary copy, that we pass to the dispatch function */
1188 state->tmp = state->orig;
1189
1190 subreq = cli->dispatch_send(state, ev, cli,
1191 &ndr_table_wkssvc,
1192 NDR_WKSSVC_NETRWKSTATRANSPORTDEL,
1193 &state->tmp);
1194 if (tevent_req_nomem(subreq, req)) {
1195 return tevent_req_post(req, ev);
1196 }
1197 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaTransportDel_done, req);
1198 return req;
1199 }
1200
1201 static void rpccli_wkssvc_NetrWkstaTransportDel_done(struct tevent_req *subreq)
1202 {
1203 struct tevent_req *req = tevent_req_callback_data(
1204 subreq, struct tevent_req);
1205 struct rpccli_wkssvc_NetrWkstaTransportDel_state *state = tevent_req_data(
1206 req, struct rpccli_wkssvc_NetrWkstaTransportDel_state);
1207 NTSTATUS status;
1208 TALLOC_CTX *mem_ctx;
1209
1210 if (state->out_mem_ctx) {
1211 mem_ctx = state->out_mem_ctx;
1212 } else {
1213 mem_ctx = state;
1214 }
1215
1216 status = state->dispatch_recv(subreq, mem_ctx);
1217 TALLOC_FREE(subreq);
1218 if (!NT_STATUS_IS_OK(status)) {
1219 tevent_req_nterror(req, status);
1220 return;
1221 }
1222
1223 /* Copy out parameters */
1224
1225 /* Copy result */
1226 state->orig.out.result = state->tmp.out.result;
1227
1228 /* Reset temporary structure */
1229 ZERO_STRUCT(state->tmp);
1230
1231 tevent_req_done(req);
1232 }
1233
1234 NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel_recv(struct tevent_req *req,
1235 TALLOC_CTX *mem_ctx,
1236 WERROR *result)
1237 {
1238 struct rpccli_wkssvc_NetrWkstaTransportDel_state *state = tevent_req_data(
1239 req, struct rpccli_wkssvc_NetrWkstaTransportDel_state);
1240 NTSTATUS status;
1241
1242 if (tevent_req_is_nterror(req, &status)) {
1243 tevent_req_received(req);
1244 return status;
1245 }
1246
1247 /* Steal possbile out parameters to the callers context */
1248 talloc_steal(mem_ctx, state->out_mem_ctx);
1249
1250 /* Return result */
1251 *result = state->orig.out.result;
1252
1253 tevent_req_received(req);
1254 return NT_STATUS_OK;
1255 }
1256
1257 NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel(struct rpc_pipe_client *cli,
1258 TALLOC_CTX *mem_ctx,
1259 const char *server_name /* [in] [unique,charset(UTF16)] */,
1260 const char *transport_name /* [in] [unique,charset(UTF16)] */,
1261 uint32_t unknown3 /* [in] */,
1262 WERROR *werror)
1263 {
1264 struct wkssvc_NetrWkstaTransportDel r;
1265 NTSTATUS status;
1266
1267 /* In parameters */
1268 r.in.server_name = server_name;
1269 r.in.transport_name = transport_name;
1270 r.in.unknown3 = unknown3;
1271
1272 status = cli->dispatch(cli,
1273 mem_ctx,
1274 &ndr_table_wkssvc,
1275 NDR_WKSSVC_NETRWKSTATRANSPORTDEL,
1276 &r);
1277
1278 if (!NT_STATUS_IS_OK(status)) {
1279 return status;
1280 }
1281
1282 if (NT_STATUS_IS_ERR(status)) {
1283 return status;
1284 }
1285
1286 /* Return variables */
1287
1288 /* Return result */
1289 if (werror) {
1290 *werror = r.out.result;
1291 }
1292
1293 return werror_to_ntstatus(r.out.result);
1294 }
1295
1296 struct rpccli_wkssvc_NetrUseAdd_state {
1297 struct wkssvc_NetrUseAdd orig;
1298 struct wkssvc_NetrUseAdd tmp;
1299 TALLOC_CTX *out_mem_ctx;
1300 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1301 };
1302
1303 static void rpccli_wkssvc_NetrUseAdd_done(struct tevent_req *subreq);
1304
1305 struct tevent_req *rpccli_wkssvc_NetrUseAdd_send(TALLOC_CTX *mem_ctx,
1306 struct tevent_context *ev,
1307 struct rpc_pipe_client *cli,
1308 const char *_server_name /* [in] [unique,charset(UTF16)] */,
1309 uint32_t _level /* [in] */,
1310 union wkssvc_NetrUseGetInfoCtr *_ctr /* [in] [ref,switch_is(level)] */,
1311 uint32_t *_parm_err /* [in,out] [unique] */)
1312 {
1313 struct tevent_req *req;
1314 struct rpccli_wkssvc_NetrUseAdd_state *state;
1315 struct tevent_req *subreq;
1316
1317 req = tevent_req_create(mem_ctx, &state,
1318 struct rpccli_wkssvc_NetrUseAdd_state);
1319 if (req == NULL) {
1320 return NULL;
1321 }
1322 state->out_mem_ctx = NULL;
1323 state->dispatch_recv = cli->dispatch_recv;
1324
1325 /* In parameters */
1326 state->orig.in.server_name = _server_name;
1327 state->orig.in.level = _level;
1328 state->orig.in.ctr = _ctr;
1329 state->orig.in.parm_err = _parm_err;
1330
1331 /* Out parameters */
1332 state->orig.out.parm_err = _parm_err;
1333
1334 /* Result */
1335 ZERO_STRUCT(state->orig.out.result);
1336
1337 state->out_mem_ctx = talloc_named_const(state, 0,
1338 "rpccli_wkssvc_NetrUseAdd_out_memory");
1339 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1340 return tevent_req_post(req, ev);
1341 }
1342
1343 /* make a temporary copy, that we pass to the dispatch function */
1344 state->tmp = state->orig;
1345
1346 subreq = cli->dispatch_send(state, ev, cli,
1347 &ndr_table_wkssvc,
1348 NDR_WKSSVC_NETRUSEADD,
1349 &state->tmp);
1350 if (tevent_req_nomem(subreq, req)) {
1351 return tevent_req_post(req, ev);
1352 }
1353 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseAdd_done, req);
1354 return req;
1355 }
1356
1357 static void rpccli_wkssvc_NetrUseAdd_done(struct tevent_req *subreq)
1358 {
1359 struct tevent_req *req = tevent_req_callback_data(
1360 subreq, struct tevent_req);
1361 struct rpccli_wkssvc_NetrUseAdd_state *state = tevent_req_data(
1362 req, struct rpccli_wkssvc_NetrUseAdd_state);
1363 NTSTATUS status;
1364 TALLOC_CTX *mem_ctx;
1365
1366 if (state->out_mem_ctx) {
1367 mem_ctx = state->out_mem_ctx;
1368 } else {
1369 mem_ctx = state;
1370 }
1371
1372 status = state->dispatch_recv(subreq, mem_ctx);
1373 TALLOC_FREE(subreq);
1374 if (!NT_STATUS_IS_OK(status)) {
1375 tevent_req_nterror(req, status);
1376 return;
1377 }
1378
1379 /* Copy out parameters */
1380 if (state->orig.out.parm_err && state->tmp.out.parm_err) {
1381 *state->orig.out.parm_err = *state->tmp.out.parm_err;
1382 }
1383
1384 /* Copy result */
1385 state->orig.out.result = state->tmp.out.result;
1386
1387 /* Reset temporary structure */
1388 ZERO_STRUCT(state->tmp);
1389
1390 tevent_req_done(req);
1391 }
1392
1393 NTSTATUS rpccli_wkssvc_NetrUseAdd_recv(struct tevent_req *req,
1394 TALLOC_CTX *mem_ctx,
1395 WERROR *result)
1396 {
1397 struct rpccli_wkssvc_NetrUseAdd_state *state = tevent_req_data(
1398 req, struct rpccli_wkssvc_NetrUseAdd_state);
1399 NTSTATUS status;
1400
1401 if (tevent_req_is_nterror(req, &status)) {
1402 tevent_req_received(req);
1403 return status;
1404 }
1405
1406 /* Steal possbile out parameters to the callers context */
1407 talloc_steal(mem_ctx, state->out_mem_ctx);
1408
1409 /* Return result */
1410 *result = state->orig.out.result;
1411
1412 tevent_req_received(req);
1413 return NT_STATUS_OK;
1414 }
1415
1416 NTSTATUS rpccli_wkssvc_NetrUseAdd(struct rpc_pipe_client *cli,
1417 TALLOC_CTX *mem_ctx,
1418 const char *server_name /* [in] [unique,charset(UTF16)] */,
1419 uint32_t level /* [in] */,
1420 union wkssvc_NetrUseGetInfoCtr *ctr /* [in] [ref,switch_is(level)] */,
1421 uint32_t *parm_err /* [in,out] [unique] */,
1422 WERROR *werror)
1423 {
1424 struct wkssvc_NetrUseAdd r;
1425 NTSTATUS status;
1426
1427 /* In parameters */
1428 r.in.server_name = server_name;
1429 r.in.level = level;
1430 r.in.ctr = ctr;
1431 r.in.parm_err = parm_err;
1432
1433 status = cli->dispatch(cli,
1434 mem_ctx,
1435 &ndr_table_wkssvc,
1436 NDR_WKSSVC_NETRUSEADD,
1437 &r);
1438
1439 if (!NT_STATUS_IS_OK(status)) {
1440 return status;
1441 }
1442
1443 if (NT_STATUS_IS_ERR(status)) {
1444 return status;
1445 }
1446
1447 /* Return variables */
1448 if (parm_err && r.out.parm_err) {
1449 *parm_err = *r.out.parm_err;
1450 }
1451
1452 /* Return result */
1453 if (werror) {
1454 *werror = r.out.result;
1455 }
1456
1457 return werror_to_ntstatus(r.out.result);
1458 }
1459
1460 struct rpccli_wkssvc_NetrUseGetInfo_state {
1461 struct wkssvc_NetrUseGetInfo orig;
1462 struct wkssvc_NetrUseGetInfo tmp;
1463 TALLOC_CTX *out_mem_ctx;
1464 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1465 };
1466
1467 static void rpccli_wkssvc_NetrUseGetInfo_done(struct tevent_req *subreq);
1468
1469 struct tevent_req *rpccli_wkssvc_NetrUseGetInfo_send(TALLOC_CTX *mem_ctx,
1470 struct tevent_context *ev,
1471 struct rpc_pipe_client *cli,
1472 const char *_server_name /* [in] [unique,charset(UTF16)] */,
1473 const char *_use_name /* [in] [ref,charset(UTF16)] */,
1474 uint32_t _level /* [in] */,
1475 union wkssvc_NetrUseGetInfoCtr *_ctr /* [out] [ref,switch_is(level)] */)
1476 {
1477 struct tevent_req *req;
1478 struct rpccli_wkssvc_NetrUseGetInfo_state *state;
1479 struct tevent_req *subreq;
1480
1481 req = tevent_req_create(mem_ctx, &state,
1482 struct rpccli_wkssvc_NetrUseGetInfo_state);
1483 if (req == NULL) {
1484 return NULL;
1485 }
1486 state->out_mem_ctx = NULL;
1487 state->dispatch_recv = cli->dispatch_recv;
1488
1489 /* In parameters */
1490 state->orig.in.server_name = _server_name;
1491 state->orig.in.use_name = _use_name;
1492 state->orig.in.level = _level;
1493
1494 /* Out parameters */
1495 state->orig.out.ctr = _ctr;
1496
1497 /* Result */
1498 ZERO_STRUCT(state->orig.out.result);
1499
1500 state->out_mem_ctx = talloc_named_const(state, 0,
1501 "rpccli_wkssvc_NetrUseGetInfo_out_memory");
1502 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1503 return tevent_req_post(req, ev);
1504 }
1505
1506 /* make a temporary copy, that we pass to the dispatch function */
1507 state->tmp = state->orig;
1508
1509 subreq = cli->dispatch_send(state, ev, cli,
1510 &ndr_table_wkssvc,
1511 NDR_WKSSVC_NETRUSEGETINFO,
1512 &state->tmp);
1513 if (tevent_req_nomem(subreq, req)) {
1514 return tevent_req_post(req, ev);
1515 }
1516 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseGetInfo_done, req);
1517 return req;
1518 }
1519
1520 static void rpccli_wkssvc_NetrUseGetInfo_done(struct tevent_req *subreq)
1521 {
1522 struct tevent_req *req = tevent_req_callback_data(
1523 subreq, struct tevent_req);
1524 struct rpccli_wkssvc_NetrUseGetInfo_state *state = tevent_req_data(
1525 req, struct rpccli_wkssvc_NetrUseGetInfo_state);
1526 NTSTATUS status;
1527 TALLOC_CTX *mem_ctx;
1528
1529 if (state->out_mem_ctx) {
1530 mem_ctx = state->out_mem_ctx;
1531 } else {
1532 mem_ctx = state;
1533 }
1534
1535 status = state->dispatch_recv(subreq, mem_ctx);
1536 TALLOC_FREE(subreq);
1537 if (!NT_STATUS_IS_OK(status)) {
1538 tevent_req_nterror(req, status);
1539 return;
1540 }
1541
1542 /* Copy out parameters */
1543 *state->orig.out.ctr = *state->tmp.out.ctr;
1544
1545 /* Copy result */
1546 state->orig.out.result = state->tmp.out.result;
1547
1548 /* Reset temporary structure */
1549 ZERO_STRUCT(state->tmp);
1550
1551 tevent_req_done(req);
1552 }
1553
1554 NTSTATUS rpccli_wkssvc_NetrUseGetInfo_recv(struct tevent_req *req,
1555 TALLOC_CTX *mem_ctx,
1556 WERROR *result)
1557 {
1558 struct rpccli_wkssvc_NetrUseGetInfo_state *state = tevent_req_data(
1559 req, struct rpccli_wkssvc_NetrUseGetInfo_state);
1560 NTSTATUS status;
1561
1562 if (tevent_req_is_nterror(req, &status)) {
1563 tevent_req_received(req);
1564 return status;
1565 }
1566
1567 /* Steal possbile out parameters to the callers context */
1568 talloc_steal(mem_ctx, state->out_mem_ctx);
1569
1570 /* Return result */
1571 *result = state->orig.out.result;
1572
1573 tevent_req_received(req);
1574 return NT_STATUS_OK;
1575 }
1576
1577 NTSTATUS rpccli_wkssvc_NetrUseGetInfo(struct rpc_pipe_client *cli,
1578 TALLOC_CTX *mem_ctx,
1579 const char *server_name /* [in] [unique,charset(UTF16)] */,
1580 const char *use_name /* [in] [ref,charset(UTF16)] */,
1581 uint32_t level /* [in] */,
1582 union wkssvc_NetrUseGetInfoCtr *ctr /* [out] [ref,switch_is(level)] */,
1583 WERROR *werror)
1584 {
1585 struct wkssvc_NetrUseGetInfo r;
1586 NTSTATUS status;
1587
1588 /* In parameters */
1589 r.in.server_name = server_name;
1590 r.in.use_name = use_name;
1591 r.in.level = level;
1592
1593 status = cli->dispatch(cli,
1594 mem_ctx,
1595 &ndr_table_wkssvc,
1596 NDR_WKSSVC_NETRUSEGETINFO,
1597 &r);
1598
1599 if (!NT_STATUS_IS_OK(status)) {
1600 return status;
1601 }
1602
1603 if (NT_STATUS_IS_ERR(status)) {
1604 return status;
1605 }
1606
1607 /* Return variables */
1608 *ctr = *r.out.ctr;
1609
1610 /* Return result */
1611 if (werror) {
1612 *werror = r.out.result;
1613 }
1614
1615 return werror_to_ntstatus(r.out.result);
1616 }
1617
1618 struct rpccli_wkssvc_NetrUseDel_state {
1619 struct wkssvc_NetrUseDel orig;
1620 struct wkssvc_NetrUseDel tmp;
1621 TALLOC_CTX *out_mem_ctx;
1622 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1623 };
1624
1625 static void rpccli_wkssvc_NetrUseDel_done(struct tevent_req *subreq);
1626
1627 struct tevent_req *rpccli_wkssvc_NetrUseDel_send(TALLOC_CTX *mem_ctx,
1628 struct tevent_context *ev,
1629 struct rpc_pipe_client *cli,
1630 const char *_server_name /* [in] [unique,charset(UTF16)] */,
1631 const char *_use_name /* [in] [ref,charset(UTF16)] */,
1632 uint32_t _force_cond /* [in] */)
1633 {
1634 struct tevent_req *req;
1635 struct rpccli_wkssvc_NetrUseDel_state *state;
1636 struct tevent_req *subreq;
1637
1638 req = tevent_req_create(mem_ctx, &state,
1639 struct rpccli_wkssvc_NetrUseDel_state);
1640 if (req == NULL) {
1641 return NULL;
1642 }
1643 state->out_mem_ctx = NULL;
1644 state->dispatch_recv = cli->dispatch_recv;
1645
1646 /* In parameters */
1647 state->orig.in.server_name = _server_name;
1648 state->orig.in.use_name = _use_name;
1649 state->orig.in.force_cond = _force_cond;
1650
1651 /* Out parameters */
1652
1653 /* Result */
1654 ZERO_STRUCT(state->orig.out.result);
1655
1656 /* make a temporary copy, that we pass to the dispatch function */
1657 state->tmp = state->orig;
1658
1659 subreq = cli->dispatch_send(state, ev, cli,
1660 &ndr_table_wkssvc,
1661 NDR_WKSSVC_NETRUSEDEL,
1662 &state->tmp);
1663 if (tevent_req_nomem(subreq, req)) {
1664 return tevent_req_post(req, ev);
1665 }
1666 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseDel_done, req);
1667 return req;
1668 }
1669
1670 static void rpccli_wkssvc_NetrUseDel_done(struct tevent_req *subreq)
1671 {
1672 struct tevent_req *req = tevent_req_callback_data(
1673 subreq, struct tevent_req);
1674 struct rpccli_wkssvc_NetrUseDel_state *state = tevent_req_data(
1675 req, struct rpccli_wkssvc_NetrUseDel_state);
1676 NTSTATUS status;
1677 TALLOC_CTX *mem_ctx;
1678
1679 if (state->out_mem_ctx) {
1680 mem_ctx = state->out_mem_ctx;
1681 } else {
1682 mem_ctx = state;
1683 }
1684
1685 status = state->dispatch_recv(subreq, mem_ctx);
1686 TALLOC_FREE(subreq);
1687 if (!NT_STATUS_IS_OK(status)) {
1688 tevent_req_nterror(req, status);
1689 return;
1690 }
1691
1692 /* Copy out parameters */
1693
1694 /* Copy result */
1695 state->orig.out.result = state->tmp.out.result;
1696
1697 /* Reset temporary structure */
1698 ZERO_STRUCT(state->tmp);
1699
1700 tevent_req_done(req);
1701 }
1702
1703 NTSTATUS rpccli_wkssvc_NetrUseDel_recv(struct tevent_req *req,
1704 TALLOC_CTX *mem_ctx,
1705 WERROR *result)
1706 {
1707 struct rpccli_wkssvc_NetrUseDel_state *state = tevent_req_data(
1708 req, struct rpccli_wkssvc_NetrUseDel_state);
1709 NTSTATUS status;
1710
1711 if (tevent_req_is_nterror(req, &status)) {
1712 tevent_req_received(req);
1713 return status;
1714 }
1715
1716 /* Steal possbile out parameters to the callers context */
1717 talloc_steal(mem_ctx, state->out_mem_ctx);
1718
1719 /* Return result */
1720 *result = state->orig.out.result;
1721
1722 tevent_req_received(req);
1723 return NT_STATUS_OK;
1724 }
1725
1726 NTSTATUS rpccli_wkssvc_NetrUseDel(struct rpc_pipe_client *cli,
1727 TALLOC_CTX *mem_ctx,
1728 const char *server_name /* [in] [unique,charset(UTF16)] */,
1729 const char *use_name /* [in] [ref,charset(UTF16)] */,
1730 uint32_t force_cond /* [in] */,
1731 WERROR *werror)
1732 {
1733 struct wkssvc_NetrUseDel r;
1734 NTSTATUS status;
1735
1736 /* In parameters */
1737 r.in.server_name = server_name;
1738 r.in.use_name = use_name;
1739 r.in.force_cond = force_cond;
1740
1741 status = cli->dispatch(cli,
1742 mem_ctx,
1743 &ndr_table_wkssvc,
1744 NDR_WKSSVC_NETRUSEDEL,
1745 &r);
1746
1747 if (!NT_STATUS_IS_OK(status)) {
1748 return status;
1749 }
1750
1751 if (NT_STATUS_IS_ERR(status)) {
1752 return status;
1753 }
1754
1755 /* Return variables */
1756
1757 /* Return result */
1758 if (werror) {
1759 *werror = r.out.result;
1760 }
1761
1762 return werror_to_ntstatus(r.out.result);
1763 }
1764
1765 struct rpccli_wkssvc_NetrUseEnum_state {
1766 struct wkssvc_NetrUseEnum orig;
1767 struct wkssvc_NetrUseEnum tmp;
1768 TALLOC_CTX *out_mem_ctx;
1769 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1770 };
1771
1772 static void rpccli_wkssvc_NetrUseEnum_done(struct tevent_req *subreq);
1773
1774 struct tevent_req *rpccli_wkssvc_NetrUseEnum_send(TALLOC_CTX *mem_ctx,
1775 struct tevent_context *ev,
1776 struct rpc_pipe_client *cli,
1777 const char *_server_name /* [in] [unique,charset(UTF16)] */,
1778 struct wkssvc_NetrUseEnumInfo *_info /* [in,out] [ref] */,
1779 uint32_t _prefmaxlen /* [in] */,
1780 uint32_t *_entries_read /* [out] [ref] */,
1781 uint32_t *_resume_handle /* [in,out] [unique] */)
1782 {
1783 struct tevent_req *req;
1784 struct rpccli_wkssvc_NetrUseEnum_state *state;
1785 struct tevent_req *subreq;
1786
1787 req = tevent_req_create(mem_ctx, &state,
1788 struct rpccli_wkssvc_NetrUseEnum_state);
1789 if (req == NULL) {
1790 return NULL;
1791 }
1792 state->out_mem_ctx = NULL;
1793 state->dispatch_recv = cli->dispatch_recv;
1794
1795 /* In parameters */
1796 state->orig.in.server_name = _server_name;
1797 state->orig.in.info = _info;
1798 state->orig.in.prefmaxlen = _prefmaxlen;
1799 state->orig.in.resume_handle = _resume_handle;
1800
1801 /* Out parameters */
1802 state->orig.out.info = _info;
1803 state->orig.out.entries_read = _entries_read;
1804 state->orig.out.resume_handle = _resume_handle;
1805
1806 /* Result */
1807 ZERO_STRUCT(state->orig.out.result);
1808
1809 state->out_mem_ctx = talloc_named_const(state, 0,
1810 "rpccli_wkssvc_NetrUseEnum_out_memory");
1811 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1812 return tevent_req_post(req, ev);
1813 }
1814
1815 /* make a temporary copy, that we pass to the dispatch function */
1816 state->tmp = state->orig;
1817
1818 subreq = cli->dispatch_send(state, ev, cli,
1819 &ndr_table_wkssvc,
1820 NDR_WKSSVC_NETRUSEENUM,
1821 &state->tmp);
1822 if (tevent_req_nomem(subreq, req)) {
1823 return tevent_req_post(req, ev);
1824 }
1825 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseEnum_done, req);
1826 return req;
1827 }
1828
1829 static void rpccli_wkssvc_NetrUseEnum_done(struct tevent_req *subreq)
1830 {
1831 struct tevent_req *req = tevent_req_callback_data(
1832 subreq, struct tevent_req);
1833 struct rpccli_wkssvc_NetrUseEnum_state *state = tevent_req_data(
1834 req, struct rpccli_wkssvc_NetrUseEnum_state);
1835 NTSTATUS status;
1836 TALLOC_CTX *mem_ctx;
1837
1838 if (state->out_mem_ctx) {
1839 mem_ctx = state->out_mem_ctx;
1840 } else {
1841 mem_ctx = state;
1842 }
1843
1844 status = state->dispatch_recv(subreq, mem_ctx);
1845 TALLOC_FREE(subreq);
1846 if (!NT_STATUS_IS_OK(status)) {
1847 tevent_req_nterror(req, status);
1848 return;
1849 }
1850
1851 /* Copy out parameters */
1852 *state->orig.out.info = *state->tmp.out.info;
1853 *state->orig.out.entries_read = *state->tmp.out.entries_read;
1854 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
1855 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
1856 }
1857
1858 /* Copy result */
1859 state->orig.out.result = state->tmp.out.result;
1860
1861 /* Reset temporary structure */
1862 ZERO_STRUCT(state->tmp);
1863
1864 tevent_req_done(req);
1865 }
1866
1867 NTSTATUS rpccli_wkssvc_NetrUseEnum_recv(struct tevent_req *req,
1868 TALLOC_CTX *mem_ctx,
1869 WERROR *result)
1870 {
1871 struct rpccli_wkssvc_NetrUseEnum_state *state = tevent_req_data(
1872 req, struct rpccli_wkssvc_NetrUseEnum_state);
1873 NTSTATUS status;
1874
1875 if (tevent_req_is_nterror(req, &status)) {
1876 tevent_req_received(req);
1877 return status;
1878 }
1879
1880 /* Steal possbile out parameters to the callers context */
1881 talloc_steal(mem_ctx, state->out_mem_ctx);
1882
1883 /* Return result */
1884 *result = state->orig.out.result;
1885
1886 tevent_req_received(req);
1887 return NT_STATUS_OK;
1888 }
1889
1890 NTSTATUS rpccli_wkssvc_NetrUseEnum(struct rpc_pipe_client *cli,
1891 TALLOC_CTX *mem_ctx,
1892 const char *server_name /* [in] [unique,charset(UTF16)] */,
1893 struct wkssvc_NetrUseEnumInfo *info /* [in,out] [ref] */,
1894 uint32_t prefmaxlen /* [in] */,
1895 uint32_t *entries_read /* [out] [ref] */,
1896 uint32_t *resume_handle /* [in,out] [unique] */,
1897 WERROR *werror)
1898 {
1899 struct wkssvc_NetrUseEnum r;
1900 NTSTATUS status;
1901
1902 /* In parameters */
1903 r.in.server_name = server_name;
1904 r.in.info = info;
1905 r.in.prefmaxlen = prefmaxlen;
1906 r.in.resume_handle = resume_handle;
1907
1908 status = cli->dispatch(cli,
1909 mem_ctx,
1910 &ndr_table_wkssvc,
1911 NDR_WKSSVC_NETRUSEENUM,
1912 &r);
1913
1914 if (!NT_STATUS_IS_OK(status)) {
1915 return status;
1916 }
1917
1918 if (NT_STATUS_IS_ERR(status)) {
1919 return status;
1920 }
1921
1922 /* Return variables */
1923 *info = *r.out.info;
1924 *entries_read = *r.out.entries_read;
1925 if (resume_handle && r.out.resume_handle) {
1926 *resume_handle = *r.out.resume_handle;
1927 }
1928
1929 /* Return result */
1930 if (werror) {
1931 *werror = r.out.result;
1932 }
1933
1934 return werror_to_ntstatus(r.out.result);
1935 }
1936
1937 struct rpccli_wkssvc_NetrMessageBufferSend_state {
1938 struct wkssvc_NetrMessageBufferSend orig;
1939 struct wkssvc_NetrMessageBufferSend tmp;
1940 TALLOC_CTX *out_mem_ctx;
1941 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1942 };
1943
1944 static void rpccli_wkssvc_NetrMessageBufferSend_done(struct tevent_req *subreq);
1945
1946 struct tevent_req *rpccli_wkssvc_NetrMessageBufferSend_send(TALLOC_CTX *mem_ctx,
1947 struct tevent_context *ev,
1948 struct rpc_pipe_client *cli,
1949 const char *_server_name /* [in] [unique,charset(UTF16)] */,
1950 const char *_message_name /* [in] [ref,charset(UTF16)] */,
1951 const char *_message_sender_name /* [in] [unique,charset(UTF16)] */,
1952 uint8_t *_message_buffer /* [in] [ref,size_is(message_size)] */,
1953 uint32_t _message_size /* [in] */)
1954 {
1955 struct tevent_req *req;
1956 struct rpccli_wkssvc_NetrMessageBufferSend_state *state;
1957 struct tevent_req *subreq;
1958
1959 req = tevent_req_create(mem_ctx, &state,
1960 struct rpccli_wkssvc_NetrMessageBufferSend_state);
1961 if (req == NULL) {
1962 return NULL;
1963 }
1964 state->out_mem_ctx = NULL;
1965 state->dispatch_recv = cli->dispatch_recv;
1966
1967 /* In parameters */
1968 state->orig.in.server_name = _server_name;
1969 state->orig.in.message_name = _message_name;
1970 state->orig.in.message_sender_name = _message_sender_name;
1971 state->orig.in.message_buffer = _message_buffer;
1972 state->orig.in.message_size = _message_size;
1973
1974 /* Out parameters */
1975
1976 /* Result */
1977 ZERO_STRUCT(state->orig.out.result);
1978
1979 /* make a temporary copy, that we pass to the dispatch function */
1980 state->tmp = state->orig;
1981
1982 subreq = cli->dispatch_send(state, ev, cli,
1983 &ndr_table_wkssvc,
1984 NDR_WKSSVC_NETRMESSAGEBUFFERSEND,
1985 &state->tmp);
1986 if (tevent_req_nomem(subreq, req)) {
1987 return tevent_req_post(req, ev);
1988 }
1989 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrMessageBufferSend_done, req);
1990 return req;
1991 }
1992
1993 static void rpccli_wkssvc_NetrMessageBufferSend_done(struct tevent_req *subreq)
1994 {
1995 struct tevent_req *req = tevent_req_callback_data(
1996 subreq, struct tevent_req);
1997 struct rpccli_wkssvc_NetrMessageBufferSend_state *state = tevent_req_data(
1998 req, struct rpccli_wkssvc_NetrMessageBufferSend_state);
1999 NTSTATUS status;
2000 TALLOC_CTX *mem_ctx;
2001
2002 if (state->out_mem_ctx) {
2003 mem_ctx = state->out_mem_ctx;
2004 } else {
2005 mem_ctx = state;
2006 }
2007
2008 status = state->dispatch_recv(subreq, mem_ctx);
2009 TALLOC_FREE(subreq);
2010 if (!NT_STATUS_IS_OK(status)) {
2011 tevent_req_nterror(req, status);
2012 return;
2013 }
2014
2015 /* Copy out parameters */
2016
2017 /* Copy result */
2018 state->orig.out.result = state->tmp.out.result;
2019
2020 /* Reset temporary structure */
2021 ZERO_STRUCT(state->tmp);
2022
2023 tevent_req_done(req);
2024 }
2025
2026 NTSTATUS rpccli_wkssvc_NetrMessageBufferSend_recv(struct tevent_req *req,
2027 TALLOC_CTX *mem_ctx,
2028 WERROR *result)
2029 {
2030 struct rpccli_wkssvc_NetrMessageBufferSend_state *state = tevent_req_data(
2031 req, struct rpccli_wkssvc_NetrMessageBufferSend_state);
2032 NTSTATUS status;
2033
2034 if (tevent_req_is_nterror(req, &status)) {
2035 tevent_req_received(req);
2036 return status;
2037 }
2038
2039 /* Steal possbile out parameters to the callers context */
2040 talloc_steal(mem_ctx, state->out_mem_ctx);
2041
2042 /* Return result */
2043 *result = state->orig.out.result;
2044
2045 tevent_req_received(req);
2046 return NT_STATUS_OK;
2047 }
2048
2049 NTSTATUS rpccli_wkssvc_NetrMessageBufferSend(struct rpc_pipe_client *cli,
2050 TALLOC_CTX *mem_ctx,
2051 const char *server_name /* [in] [unique,charset(UTF16)] */,
2052 const char *message_name /* [in] [ref,charset(UTF16)] */,
2053 const char *message_sender_name /* [in] [unique,charset(UTF16)] */,
2054 uint8_t *message_buffer /* [in] [ref,size_is(message_size)] */,
2055 uint32_t message_size /* [in] */,
2056 WERROR *werror)
2057 {
2058 struct wkssvc_NetrMessageBufferSend r;
2059 NTSTATUS status;
2060
2061 /* In parameters */
2062 r.in.server_name = server_name;
2063 r.in.message_name = message_name;
2064 r.in.message_sender_name = message_sender_name;
2065 r.in.message_buffer = message_buffer;
2066 r.in.message_size = message_size;
2067
2068 status = cli->dispatch(cli,
2069 mem_ctx,
2070 &ndr_table_wkssvc,
2071 NDR_WKSSVC_NETRMESSAGEBUFFERSEND,
2072 &r);
2073
2074 if (!NT_STATUS_IS_OK(status)) {
2075 return status;
2076 }
2077
2078 if (NT_STATUS_IS_ERR(status)) {
2079 return status;
2080 }
2081
2082 /* Return variables */
2083
2084 /* Return result */
2085 if (werror) {
2086 *werror = r.out.result;
2087 }
2088
2089 return werror_to_ntstatus(r.out.result);
2090 }
2091
2092 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state {
2093 struct wkssvc_NetrWorkstationStatisticsGet orig;
2094 struct wkssvc_NetrWorkstationStatisticsGet tmp;
2095 TALLOC_CTX *out_mem_ctx;
2096 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2097 };
2098
2099 static void rpccli_wkssvc_NetrWorkstationStatisticsGet_done(struct tevent_req *subreq);
2100
2101 struct tevent_req *rpccli_wkssvc_NetrWorkstationStatisticsGet_send(TALLOC_CTX *mem_ctx,
2102 struct tevent_context *ev,
2103 struct rpc_pipe_client *cli,
2104 const char *_server_name /* [in] [unique,charset(UTF16)] */,
2105 const char *_unknown2 /* [in] [unique,charset(UTF16)] */,
2106 uint32_t _unknown3 /* [in] */,
2107 uint32_t _unknown4 /* [in] */,
2108 struct wkssvc_NetrWorkstationStatistics **_info /* [out] [ref] */)
2109 {
2110 struct tevent_req *req;
2111 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state;
2112 struct tevent_req *subreq;
2113
2114 req = tevent_req_create(mem_ctx, &state,
2115 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state);
2116 if (req == NULL) {
2117 return NULL;
2118 }
2119 state->out_mem_ctx = NULL;
2120 state->dispatch_recv = cli->dispatch_recv;
2121
2122 /* In parameters */
2123 state->orig.in.server_name = _server_name;
2124 state->orig.in.unknown2 = _unknown2;
2125 state->orig.in.unknown3 = _unknown3;
2126 state->orig.in.unknown4 = _unknown4;
2127
2128 /* Out parameters */
2129 state->orig.out.info = _info;
2130
2131 /* Result */
2132 ZERO_STRUCT(state->orig.out.result);
2133
2134 state->out_mem_ctx = talloc_named_const(state, 0,
2135 "rpccli_wkssvc_NetrWorkstationStatisticsGet_out_memory");
2136 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2137 return tevent_req_post(req, ev);
2138 }
2139
2140 /* make a temporary copy, that we pass to the dispatch function */
2141 state->tmp = state->orig;
2142
2143 subreq = cli->dispatch_send(state, ev, cli,
2144 &ndr_table_wkssvc,
2145 NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
2146 &state->tmp);
2147 if (tevent_req_nomem(subreq, req)) {
2148 return tevent_req_post(req, ev);
2149 }
2150 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWorkstationStatisticsGet_done, req);
2151 return req;
2152 }
2153
2154 static void rpccli_wkssvc_NetrWorkstationStatisticsGet_done(struct tevent_req *subreq)
2155 {
2156 struct tevent_req *req = tevent_req_callback_data(
2157 subreq, struct tevent_req);
2158 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state = tevent_req_data(
2159 req, struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state);
2160 NTSTATUS status;
2161 TALLOC_CTX *mem_ctx;
2162
2163 if (state->out_mem_ctx) {
2164 mem_ctx = state->out_mem_ctx;
2165 } else {
2166 mem_ctx = state;
2167 }
2168
2169 status = state->dispatch_recv(subreq, mem_ctx);
2170 TALLOC_FREE(subreq);
2171 if (!NT_STATUS_IS_OK(status)) {
2172 tevent_req_nterror(req, status);
2173 return;
2174 }
2175
2176 /* Copy out parameters */
2177 *state->orig.out.info = *state->tmp.out.info;
2178
2179 /* Copy result */
2180 state->orig.out.result = state->tmp.out.result;
2181
2182 /* Reset temporary structure */
2183 ZERO_STRUCT(state->tmp);
2184
2185 tevent_req_done(req);
2186 }
2187
2188 NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet_recv(struct tevent_req *req,
2189 TALLOC_CTX *mem_ctx,
2190 WERROR *result)
2191 {
2192 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state = tevent_req_data(
2193 req, struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state);
2194 NTSTATUS status;
2195
2196 if (tevent_req_is_nterror(req, &status)) {
2197 tevent_req_received(req);
2198 return status;
2199 }
2200
2201 /* Steal possbile out parameters to the callers context */
2202 talloc_steal(mem_ctx, state->out_mem_ctx);
2203
2204 /* Return result */
2205 *result = state->orig.out.result;
2206
2207 tevent_req_received(req);
2208 return NT_STATUS_OK;
2209 }
2210
2211 NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet(struct rpc_pipe_client *cli,
2212 TALLOC_CTX *mem_ctx,
2213 const char *server_name /* [in] [unique,charset(UTF16)] */,
2214 const char *unknown2 /* [in] [unique,charset(UTF16)] */,
2215 uint32_t unknown3 /* [in] */,
2216 uint32_t unknown4 /* [in] */,
2217 struct wkssvc_NetrWorkstationStatistics **info /* [out] [ref] */,
2218 WERROR *werror)
2219 {
2220 struct wkssvc_NetrWorkstationStatisticsGet r;
2221 NTSTATUS status;
2222
2223 /* In parameters */
2224 r.in.server_name = server_name;
2225 r.in.unknown2 = unknown2;
2226 r.in.unknown3 = unknown3;
2227 r.in.unknown4 = unknown4;
2228
2229 status = cli->dispatch(cli,
2230 mem_ctx,
2231 &ndr_table_wkssvc,
2232 NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
2233 &r);
2234
2235 if (!NT_STATUS_IS_OK(status)) {
2236 return status;
2237 }
2238
2239 if (NT_STATUS_IS_ERR(status)) {
2240 return status;
2241 }
2242
2243 /* Return variables */
2244 *info = *r.out.info;
2245
2246 /* Return result */
2247 if (werror) {
2248 *werror = r.out.result;
2249 }
2250
2251 return werror_to_ntstatus(r.out.result);
2252 }
2253
2254 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state {
2255 struct wkssvc_NetrLogonDomainNameAdd orig;
2256 struct wkssvc_NetrLogonDomainNameAdd tmp;
2257 TALLOC_CTX *out_mem_ctx;
2258 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2259 };
2260
2261 static void rpccli_wkssvc_NetrLogonDomainNameAdd_done(struct tevent_req *subreq);
2262
2263 struct tevent_req *rpccli_wkssvc_NetrLogonDomainNameAdd_send(TALLOC_CTX *mem_ctx,
2264 struct tevent_context *ev,
2265 struct rpc_pipe_client *cli,
2266 const char *_domain_name /* [in] [ref,charset(UTF16)] */)
2267 {
2268 struct tevent_req *req;
2269 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state;
2270 struct tevent_req *subreq;
2271
2272 req = tevent_req_create(mem_ctx, &state,
2273 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state);
2274 if (req == NULL) {
2275 return NULL;
2276 }
2277 state->out_mem_ctx = NULL;
2278 state->dispatch_recv = cli->dispatch_recv;
2279
2280 /* In parameters */
2281 state->orig.in.domain_name = _domain_name;
2282
2283 /* Out parameters */
2284
2285 /* Result */
2286 ZERO_STRUCT(state->orig.out.result);
2287
2288 /* make a temporary copy, that we pass to the dispatch function */
2289 state->tmp = state->orig;
2290
2291 subreq = cli->dispatch_send(state, ev, cli,
2292 &ndr_table_wkssvc,
2293 NDR_WKSSVC_NETRLOGONDOMAINNAMEADD,
2294 &state->tmp);
2295 if (tevent_req_nomem(subreq, req)) {
2296 return tevent_req_post(req, ev);
2297 }
2298 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrLogonDomainNameAdd_done, req);
2299 return req;
2300 }
2301
2302 static void rpccli_wkssvc_NetrLogonDomainNameAdd_done(struct tevent_req *subreq)
2303 {
2304 struct tevent_req *req = tevent_req_callback_data(
2305 subreq, struct tevent_req);
2306 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state = tevent_req_data(
2307 req, struct rpccli_wkssvc_NetrLogonDomainNameAdd_state);
2308 NTSTATUS status;
2309 TALLOC_CTX *mem_ctx;
2310
2311 if (state->out_mem_ctx) {
2312 mem_ctx = state->out_mem_ctx;
2313 } else {
2314 mem_ctx = state;
2315 }
2316
2317 status = state->dispatch_recv(subreq, mem_ctx);
2318 TALLOC_FREE(subreq);
2319 if (!NT_STATUS_IS_OK(status)) {
2320 tevent_req_nterror(req, status);
2321 return;
2322 }
2323
2324 /* Copy out parameters */
2325
2326 /* Copy result */
2327 state->orig.out.result = state->tmp.out.result;
2328
2329 /* Reset temporary structure */
2330 ZERO_STRUCT(state->tmp);
2331
2332 tevent_req_done(req);
2333 }
2334
2335 NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd_recv(struct tevent_req *req,
2336 TALLOC_CTX *mem_ctx,
2337 WERROR *result)
2338 {
2339 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state = tevent_req_data(
2340 req, struct rpccli_wkssvc_NetrLogonDomainNameAdd_state);
2341 NTSTATUS status;
2342
2343 if (tevent_req_is_nterror(req, &status)) {
2344 tevent_req_received(req);
2345 return status;
2346 }
2347
2348 /* Steal possbile out parameters to the callers context */
2349 talloc_steal(mem_ctx, state->out_mem_ctx);
2350
2351 /* Return result */
2352 *result = state->orig.out.result;
2353
2354 tevent_req_received(req);
2355 return NT_STATUS_OK;
2356 }
2357
2358 NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd(struct rpc_pipe_client *cli,
2359 TALLOC_CTX *mem_ctx,
2360 const char *domain_name /* [in] [ref,charset(UTF16)] */,
2361 WERROR *werror)
2362 {
2363 struct wkssvc_NetrLogonDomainNameAdd r;
2364 NTSTATUS status;
2365
2366 /* In parameters */
2367 r.in.domain_name = domain_name;
2368
2369 status = cli->dispatch(cli,
2370 mem_ctx,
2371 &ndr_table_wkssvc,
2372 NDR_WKSSVC_NETRLOGONDOMAINNAMEADD,
2373 &r);
2374
2375 if (!NT_STATUS_IS_OK(status)) {
2376 return status;
2377 }
2378
2379 if (NT_STATUS_IS_ERR(status)) {
2380 return status;
2381 }
2382
2383 /* Return variables */
2384
2385 /* Return result */
2386 if (werror) {
2387 *werror = r.out.result;
2388 }
2389
2390 return werror_to_ntstatus(r.out.result);
2391 }
2392
2393 struct rpccli_wkssvc_NetrLogonDomainNameDel_state {
2394 struct wkssvc_NetrLogonDomainNameDel orig;
2395 struct wkssvc_NetrLogonDomainNameDel tmp;
2396 TALLOC_CTX *out_mem_ctx;
2397 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2398 };
2399
2400 static void rpccli_wkssvc_NetrLogonDomainNameDel_done(struct tevent_req *subreq);
2401
2402 struct tevent_req *rpccli_wkssvc_NetrLogonDomainNameDel_send(TALLOC_CTX *mem_ctx,
2403 struct tevent_context *ev,
2404 struct rpc_pipe_client *cli,
2405 const char *_domain_name /* [in] [ref,charset(UTF16)] */)
2406 {
2407 struct tevent_req *req;
2408 struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state;
2409 struct tevent_req *subreq;
2410
2411 req = tevent_req_create(mem_ctx, &state,
2412 struct rpccli_wkssvc_NetrLogonDomainNameDel_state);
2413 if (req == NULL) {
2414 return NULL;
2415 }
2416 state->out_mem_ctx = NULL;
2417 state->dispatch_recv = cli->dispatch_recv;
2418
2419 /* In parameters */
2420 state->orig.in.domain_name = _domain_name;
2421
2422 /* Out parameters */
2423
2424 /* Result */
2425 ZERO_STRUCT(state->orig.out.result);
2426
2427 /* make a temporary copy, that we pass to the dispatch function */
2428 state->tmp = state->orig;
2429
2430 subreq = cli->dispatch_send(state, ev, cli,
2431 &ndr_table_wkssvc,
2432 NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL,
2433 &state->tmp);
2434 if (tevent_req_nomem(subreq, req)) {
2435 return tevent_req_post(req, ev);
2436 }
2437 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrLogonDomainNameDel_done, req);
2438 return req;
2439 }
2440
2441 static void rpccli_wkssvc_NetrLogonDomainNameDel_done(struct tevent_req *subreq)
2442 {
2443 struct tevent_req *req = tevent_req_callback_data(
2444 subreq, struct tevent_req);
2445 struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state = tevent_req_data(
2446 req, struct rpccli_wkssvc_NetrLogonDomainNameDel_state);
2447 NTSTATUS status;
2448 TALLOC_CTX *mem_ctx;
2449
2450 if (state->out_mem_ctx) {
2451 mem_ctx = state->out_mem_ctx;
2452 } else {
2453 mem_ctx = state;
2454 }
2455
2456 status = state->dispatch_recv(subreq, mem_ctx);
2457 TALLOC_FREE(subreq);
2458 if (!NT_STATUS_IS_OK(status)) {
2459 tevent_req_nterror(req, status);
2460 return;
2461 }
2462
2463 /* Copy out parameters */
2464
2465 /* Copy result */
2466 state->orig.out.result = state->tmp.out.result;
2467
2468 /* Reset temporary structure */
2469 ZERO_STRUCT(state->tmp);
2470
2471 tevent_req_done(req);
2472 }
2473
2474 NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel_recv(struct tevent_req *req,
2475 TALLOC_CTX *mem_ctx,
2476 WERROR *result)
2477 {
2478 struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state = tevent_req_data(
2479 req, struct rpccli_wkssvc_NetrLogonDomainNameDel_state);
2480 NTSTATUS status;
2481
2482 if (tevent_req_is_nterror(req, &status)) {
2483 tevent_req_received(req);
2484 return status;
2485 }
2486
2487 /* Steal possbile out parameters to the callers context */
2488 talloc_steal(mem_ctx, state->out_mem_ctx);
2489
2490 /* Return result */
2491 *result = state->orig.out.result;
2492
2493 tevent_req_received(req);
2494 return NT_STATUS_OK;
2495 }
2496
2497 NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel(struct rpc_pipe_client *cli,
2498 TALLOC_CTX *mem_ctx,
2499 const char *domain_name /* [in] [ref,charset(UTF16)] */,
2500 WERROR *werror)
2501 {
2502 struct wkssvc_NetrLogonDomainNameDel r;
2503 NTSTATUS status;
2504
2505 /* In parameters */
2506 r.in.domain_name = domain_name;
2507
2508 status = cli->dispatch(cli,
2509 mem_ctx,
2510 &ndr_table_wkssvc,
2511 NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL,
2512 &r);
2513
2514 if (!NT_STATUS_IS_OK(status)) {
2515 return status;
2516 }
2517
2518 if (NT_STATUS_IS_ERR(status)) {
2519 return status;
2520 }
2521
2522 /* Return variables */
2523
2524 /* Return result */
2525 if (werror) {
2526 *werror = r.out.result;
2527 }
2528
2529 return werror_to_ntstatus(r.out.result);
2530 }
2531
2532 struct rpccli_wkssvc_NetrJoinDomain_state {
2533 struct wkssvc_NetrJoinDomain orig;
2534 struct wkssvc_NetrJoinDomain tmp;
2535 TALLOC_CTX *out_mem_ctx;
2536 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2537 };
2538
2539 static void rpccli_wkssvc_NetrJoinDomain_done(struct tevent_req *subreq);
2540
2541 struct tevent_req *rpccli_wkssvc_NetrJoinDomain_send(TALLOC_CTX *mem_ctx,
2542 struct tevent_context *ev,
2543 struct rpc_pipe_client *cli,
2544 const char *_server_name /* [in] [unique,charset(UTF16)] */,
2545 const char *_domain_name /* [in] [ref,charset(UTF16)] */,
2546 const char *_account_ou /* [in] [unique,charset(UTF16)] */,
2547 const char *_Account /* [in] [unique,charset(UTF16)] */,
2548 const char *_password /* [in] [unique,charset(UTF16)] */,
2549 uint32_t _join_flags /* [in] */)
2550 {
2551 struct tevent_req *req;
2552 struct rpccli_wkssvc_NetrJoinDomain_state *state;
2553 struct tevent_req *subreq;
2554
2555 req = tevent_req_create(mem_ctx, &state,
2556 struct rpccli_wkssvc_NetrJoinDomain_state);
2557 if (req == NULL) {
2558 return NULL;
2559 }
2560 state->out_mem_ctx = NULL;
2561 state->dispatch_recv = cli->dispatch_recv;
2562
2563 /* In parameters */
2564 state->orig.in.server_name = _server_name;
2565 state->orig.in.domain_name = _domain_name;
2566 state->orig.in.account_ou = _account_ou;
2567 state->orig.in.Account = _Account;
2568 state->orig.in.password = _password;
2569 state->orig.in.join_flags = _join_flags;
2570
2571 /* Out parameters */
2572
2573 /* Result */
2574 ZERO_STRUCT(state->orig.out.result);
2575
2576 /* make a temporary copy, that we pass to the dispatch function */
2577 state->tmp = state->orig;
2578
2579 subreq = cli->dispatch_send(state, ev, cli,
2580 &ndr_table_wkssvc,
2581 NDR_WKSSVC_NETRJOINDOMAIN,
2582 &state->tmp);
2583 if (tevent_req_nomem(subreq, req)) {
2584 return tevent_req_post(req, ev);
2585 }
2586 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrJoinDomain_done, req);
2587 return req;
2588 }
2589
2590 static void rpccli_wkssvc_NetrJoinDomain_done(struct tevent_req *subreq)
2591 {
2592 struct tevent_req *req = tevent_req_callback_data(
2593 subreq, struct tevent_req);
2594 struct rpccli_wkssvc_NetrJoinDomain_state *state = tevent_req_data(
2595 req, struct rpccli_wkssvc_NetrJoinDomain_state);
2596 NTSTATUS status;
2597 TALLOC_CTX *mem_ctx;
2598
2599 if (state->out_mem_ctx) {
2600 mem_ctx = state->out_mem_ctx;
2601 } else {
2602 mem_ctx = state;
2603 }
2604
2605 status = state->dispatch_recv(subreq, mem_ctx);
2606 TALLOC_FREE(subreq);
2607 if (!NT_STATUS_IS_OK(status)) {
2608 tevent_req_nterror(req, status);
2609 return;
2610 }
2611
2612 /* Copy out parameters */
2613
2614 /* Copy result */
2615 state->orig.out.result = state->tmp.out.result;
2616
2617 /* Reset temporary structure */
2618 ZERO_STRUCT(state->tmp);
2619
2620 tevent_req_done(req);
2621 }
2622
2623 NTSTATUS rpccli_wkssvc_NetrJoinDomain_recv(struct tevent_req *req,
2624 TALLOC_CTX *mem_ctx,
2625 WERROR *result)
2626 {
2627 struct rpccli_wkssvc_NetrJoinDomain_state *state = tevent_req_data(
2628 req, struct rpccli_wkssvc_NetrJoinDomain_state);
2629 NTSTATUS status;
2630
2631 if (tevent_req_is_nterror(req, &status)) {
2632 tevent_req_received(req);
2633 return status;
2634 }
2635
2636 /* Steal possbile out parameters to the callers context */
2637 talloc_steal(mem_ctx, state->out_mem_ctx);
2638
2639 /* Return result */
2640 *result = state->orig.out.result;
2641
2642 tevent_req_received(req);
2643 return NT_STATUS_OK;
2644 }
2645
2646 NTSTATUS rpccli_wkssvc_NetrJoinDomain(struct rpc_pipe_client *cli,
2647 TALLOC_CTX *mem_ctx,
2648 const char *server_name /* [in] [unique,charset(UTF16)] */,
2649 const char *domain_name /* [in] [ref,charset(UTF16)] */,
2650 const char *account_ou /* [in] [unique,charset(UTF16)] */,
2651 const char *Account /* [in] [unique,charset(UTF16)] */,
2652 const char *password /* [in] [unique,charset(UTF16)] */,
2653 uint32_t join_flags /* [in] */,
2654 WERROR *werror)
2655 {
2656 struct wkssvc_NetrJoinDomain r;
2657 NTSTATUS status;
2658
2659 /* In parameters */
2660 r.in.server_name = server_name;
2661 r.in.domain_name = domain_name;
2662 r.in.account_ou = account_ou;
2663 r.in.Account = Account;
2664 r.in.password = password;
2665 r.in.join_flags = join_flags;
2666
2667 status = cli->dispatch(cli,
2668 mem_ctx,
2669 &ndr_table_wkssvc,
2670 NDR_WKSSVC_NETRJOINDOMAIN,
2671 &r);
2672
2673 if (!NT_STATUS_IS_OK(status)) {
2674 return status;
2675 }
2676
2677 if (NT_STATUS_IS_ERR(status)) {
2678 return status;
2679 }
2680
2681 /* Return variables */
2682
2683 /* Return result */
2684 if (werror) {
2685 *werror = r.out.result;
2686 }
2687
2688 return werror_to_ntstatus(r.out.result);
2689 }
2690
2691 struct rpccli_wkssvc_NetrUnjoinDomain_state {
2692 struct wkssvc_NetrUnjoinDomain orig;
2693 struct wkssvc_NetrUnjoinDomain tmp;
2694 TALLOC_CTX *out_mem_ctx;
2695 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2696 };
2697
2698 static void rpccli_wkssvc_NetrUnjoinDomain_done(struct tevent_req *subreq);
2699
2700 struct tevent_req *rpccli_wkssvc_NetrUnjoinDomain_send(TALLOC_CTX *mem_ctx,
2701 struct tevent_context *ev,
2702 struct rpc_pipe_client *cli,
2703 const char *_server_name /* [in] [unique,charset(UTF16)] */,
2704 const char *_Account /* [in] [unique,charset(UTF16)] */,
2705 const char *_password /* [in] [unique,charset(UTF16)] */,
2706 uint32_t _unjoin_flags /* [in] */)
2707 {
2708 struct tevent_req *req;
2709 struct rpccli_wkssvc_NetrUnjoinDomain_state *state;
2710 struct tevent_req *subreq;
2711
2712 req = tevent_req_create(mem_ctx, &state,
2713 struct rpccli_wkssvc_NetrUnjoinDomain_state);
2714 if (req == NULL) {
2715 return NULL;
2716 }
2717 state->out_mem_ctx = NULL;
2718 state->dispatch_recv = cli->dispatch_recv;
2719
2720 /* In parameters */
2721 state->orig.in.server_name = _server_name;
2722 state->orig.in.Account = _Account;
2723 state->orig.in.password = _password;
2724 state->orig.in.unjoin_flags = _unjoin_flags;
2725
2726 /* Out parameters */
2727
2728 /* Result */
2729 ZERO_STRUCT(state->orig.out.result);
2730
2731 /* make a temporary copy, that we pass to the dispatch function */
2732 state->tmp = state->orig;
2733
2734 subreq = cli->dispatch_send(state, ev, cli,
2735 &ndr_table_wkssvc,
2736 NDR_WKSSVC_NETRUNJOINDOMAIN,
2737 &state->tmp);
2738 if (tevent_req_nomem(subreq, req)) {
2739 return tevent_req_post(req, ev);
2740 }
2741 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUnjoinDomain_done, req);
2742 return req;
2743 }
2744
2745 static void rpccli_wkssvc_NetrUnjoinDomain_done(struct tevent_req *subreq)
2746 {
2747 struct tevent_req *req = tevent_req_callback_data(
2748 subreq, struct tevent_req);
2749 struct rpccli_wkssvc_NetrUnjoinDomain_state *state = tevent_req_data(
2750 req, struct rpccli_wkssvc_NetrUnjoinDomain_state);
2751 NTSTATUS status;
2752 TALLOC_CTX *mem_ctx;
2753
2754 if (state->out_mem_ctx) {
2755 mem_ctx = state->out_mem_ctx;
2756 } else {
2757 mem_ctx = state;
2758 }
2759
2760 status = state->dispatch_recv(subreq, mem_ctx);
2761 TALLOC_FREE(subreq);
2762 if (!NT_STATUS_IS_OK(status)) {
2763 tevent_req_nterror(req, status);
2764 return;
2765 }
2766
2767 /* Copy out parameters */
2768
2769 /* Copy result */
2770 state->orig.out.result = state->tmp.out.result;
2771
2772 /* Reset temporary structure */
2773 ZERO_STRUCT(state->tmp);
2774
2775 tevent_req_done(req);
2776 }
2777
2778 NTSTATUS rpccli_wkssvc_NetrUnjoinDomain_recv(struct tevent_req *req,
2779 TALLOC_CTX *mem_ctx,
2780 WERROR *result)
2781 {
2782 struct rpccli_wkssvc_NetrUnjoinDomain_state *state = tevent_req_data(
2783 req, struct rpccli_wkssvc_NetrUnjoinDomain_state);
2784 NTSTATUS status;
2785
2786 if (tevent_req_is_nterror(req, &status)) {
2787 tevent_req_received(req);
2788 return status;
2789 }
2790
2791 /* Steal possbile out parameters to the callers context */
2792 talloc_steal(mem_ctx, state->out_mem_ctx);
2793
2794 /* Return result */
2795 *result = state->orig.out.result;
2796
2797 tevent_req_received(req);
2798 return NT_STATUS_OK;
2799 }
2800
2801 NTSTATUS rpccli_wkssvc_NetrUnjoinDomain(struct rpc_pipe_client *cli,
2802 TALLOC_CTX *mem_ctx,
2803 const char *server_name /* [in] [unique,charset(UTF16)] */,
2804 const char *Account /* [in] [unique,charset(UTF16)] */,
2805 const char *password /* [in] [unique,charset(UTF16)] */,
2806 uint32_t unjoin_flags /* [in] */,
2807 WERROR *werror)
2808 {
2809 struct wkssvc_NetrUnjoinDomain r;
2810 NTSTATUS status;
2811
2812 /* In parameters */
2813 r.in.server_name = server_name;
2814 r.in.Account = Account;
2815 r.in.password = password;
2816 r.in.unjoin_flags = unjoin_flags;
2817
2818 status = cli->dispatch(cli,
2819 mem_ctx,
2820 &ndr_table_wkssvc,
2821 NDR_WKSSVC_NETRUNJOINDOMAIN,
2822 &r);
2823
2824 if (!NT_STATUS_IS_OK(status)) {
2825 return status;
2826 }
2827
2828 if (NT_STATUS_IS_ERR(status)) {
2829 return status;
2830 }
2831
2832 /* Return variables */
2833
2834 /* Return result */
2835 if (werror) {
2836 *werror = r.out.result;
2837 }
2838
2839 return werror_to_ntstatus(r.out.result);
2840 }
2841
2842 struct rpccli_wkssvc_NetrRenameMachineInDomain_state {
2843 struct wkssvc_NetrRenameMachineInDomain orig;
2844 struct wkssvc_NetrRenameMachineInDomain tmp;
2845 TALLOC_CTX *out_mem_ctx;
2846 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2847 };
2848
2849 static void rpccli_wkssvc_NetrRenameMachineInDomain_done(struct tevent_req *subreq);
2850
2851 struct tevent_req *rpccli_wkssvc_NetrRenameMachineInDomain_send(TALLOC_CTX *mem_ctx,
2852 struct tevent_context *ev,
2853 struct rpc_pipe_client *cli,
2854 const char *_server_name /* [in] [unique,charset(UTF16)] */,
2855 const char *_NewMachineName /* [in] [unique,charset(UTF16)] */,
2856 const char *_Account /* [in] [unique,charset(UTF16)] */,
2857 const char *_password /* [in] [unique,charset(UTF16)] */,
2858 uint32_t _RenameOptions /* [in] */)
2859 {
2860 struct tevent_req *req;
2861 struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state;
2862 struct tevent_req *subreq;
2863
2864 req = tevent_req_create(mem_ctx, &state,
2865 struct rpccli_wkssvc_NetrRenameMachineInDomain_state);
2866 if (req == NULL) {
2867 return NULL;
2868 }
2869 state->out_mem_ctx = NULL;
2870 state->dispatch_recv = cli->dispatch_recv;
2871
2872 /* In parameters */
2873 state->orig.in.server_name = _server_name;
2874 state->orig.in.NewMachineName = _NewMachineName;
2875 state->orig.in.Account = _Account;
2876 state->orig.in.password = _password;
2877 state->orig.in.RenameOptions = _RenameOptions;
2878
2879 /* Out parameters */
2880
2881 /* Result */
2882 ZERO_STRUCT(state->orig.out.result);
2883
2884 /* make a temporary copy, that we pass to the dispatch function */
2885 state->tmp = state->orig;
2886
2887 subreq = cli->dispatch_send(state, ev, cli,
2888 &ndr_table_wkssvc,
2889 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
2890 &state->tmp);
2891 if (tevent_req_nomem(subreq, req)) {
2892 return tevent_req_post(req, ev);
2893 }
2894 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRenameMachineInDomain_done, req);
2895 return req;
2896 }
2897
2898 static void rpccli_wkssvc_NetrRenameMachineInDomain_done(struct tevent_req *subreq)
2899 {
2900 struct tevent_req *req = tevent_req_callback_data(
2901 subreq, struct tevent_req);
2902 struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state = tevent_req_data(
2903 req, struct rpccli_wkssvc_NetrRenameMachineInDomain_state);
2904 NTSTATUS status;
2905 TALLOC_CTX *mem_ctx;
2906
2907 if (state->out_mem_ctx) {
2908 mem_ctx = state->out_mem_ctx;
2909 } else {
2910 mem_ctx = state;
2911 }
2912
2913 status = state->dispatch_recv(subreq, mem_ctx);
2914 TALLOC_FREE(subreq);
2915 if (!NT_STATUS_IS_OK(status)) {
2916 tevent_req_nterror(req, status);
2917 return;
2918 }
2919
2920 /* Copy out parameters */
2921
2922 /* Copy result */
2923 state->orig.out.result = state->tmp.out.result;
2924
2925 /* Reset temporary structure */
2926 ZERO_STRUCT(state->tmp);
2927
2928 tevent_req_done(req);
2929 }
2930
2931 NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain_recv(struct tevent_req *req,
2932 TALLOC_CTX *mem_ctx,
2933 WERROR *result)
2934 {
2935 struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state = tevent_req_data(
2936 req, struct rpccli_wkssvc_NetrRenameMachineInDomain_state);
2937 NTSTATUS status;
2938
2939 if (tevent_req_is_nterror(req, &status)) {
2940 tevent_req_received(req);
2941 return status;
2942 }
2943
2944 /* Steal possbile out parameters to the callers context */
2945 talloc_steal(mem_ctx, state->out_mem_ctx);
2946
2947 /* Return result */
2948 *result = state->orig.out.result;
2949
2950 tevent_req_received(req);
2951 return NT_STATUS_OK;
2952 }
2953
2954 NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain(struct rpc_pipe_client *cli,
2955 TALLOC_CTX *mem_ctx,
2956 const char *server_name /* [in] [unique,charset(UTF16)] */,
2957 const char *NewMachineName /* [in] [unique,charset(UTF16)] */,
2958 const char *Account /* [in] [unique,charset(UTF16)] */,
2959 const char *password /* [in] [unique,charset(UTF16)] */,
2960 uint32_t RenameOptions /* [in] */,
2961 WERROR *werror)
2962 {
2963 struct wkssvc_NetrRenameMachineInDomain r;
2964 NTSTATUS status;
2965
2966 /* In parameters */
2967 r.in.server_name = server_name;
2968 r.in.NewMachineName = NewMachineName;
2969 r.in.Account = Account;
2970 r.in.password = password;
2971 r.in.RenameOptions = RenameOptions;
2972
2973 status = cli->dispatch(cli,
2974 mem_ctx,
2975 &ndr_table_wkssvc,
2976 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
2977 &r);
2978
2979 if (!NT_STATUS_IS_OK(status)) {
2980 return status;
2981 }
2982
2983 if (NT_STATUS_IS_ERR(status)) {
2984 return status;
2985 }
2986
2987 /* Return variables */
2988
2989 /* Return result */
2990 if (werror) {
2991 *werror = r.out.result;
2992 }
2993
2994 return werror_to_ntstatus(r.out.result);
2995 }
2996
2997 struct rpccli_wkssvc_NetrValidateName_state {
2998 struct wkssvc_NetrValidateName orig;
2999 struct wkssvc_NetrValidateName tmp;
3000 TALLOC_CTX *out_mem_ctx;
3001 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3002 };
3003
3004 static void rpccli_wkssvc_NetrValidateName_done(struct tevent_req *subreq);
3005
3006 struct tevent_req *rpccli_wkssvc_NetrValidateName_send(TALLOC_CTX *mem_ctx,
3007 struct tevent_context *ev,
3008 struct rpc_pipe_client *cli,
3009 const char *_server_name /* [in] [unique,charset(UTF16)] */,
3010 const char *_name /* [in] [ref,charset(UTF16)] */,
3011 const char *_Account /* [in] [unique,charset(UTF16)] */,
3012 const char *_Password /* [in] [unique,charset(UTF16)] */,
3013 enum wkssvc_NetValidateNameType _name_type /* [in] */)
3014 {
3015 struct tevent_req *req;
3016 struct rpccli_wkssvc_NetrValidateName_state *state;
3017 struct tevent_req *subreq;
3018
3019 req = tevent_req_create(mem_ctx, &state,
3020 struct rpccli_wkssvc_NetrValidateName_state);
3021 if (req == NULL) {
3022 return NULL;
3023 }
3024 state->out_mem_ctx = NULL;
3025 state->dispatch_recv = cli->dispatch_recv;
3026
3027 /* In parameters */
3028 state->orig.in.server_name = _server_name;
3029 state->orig.in.name = _name;
3030 state->orig.in.Account = _Account;
3031 state->orig.in.Password = _Password;
3032 state->orig.in.name_type = _name_type;
3033
3034 /* Out parameters */
3035
3036 /* Result */
3037 ZERO_STRUCT(state->orig.out.result);
3038
3039 /* make a temporary copy, that we pass to the dispatch function */
3040 state->tmp = state->orig;
3041
3042 subreq = cli->dispatch_send(state, ev, cli,
3043 &ndr_table_wkssvc,
3044 NDR_WKSSVC_NETRVALIDATENAME,
3045 &state->tmp);
3046 if (tevent_req_nomem(subreq, req)) {
3047 return tevent_req_post(req, ev);
3048 }
3049 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrValidateName_done, req);
3050 return req;
3051 }
3052
3053 static void rpccli_wkssvc_NetrValidateName_done(struct tevent_req *subreq)
3054 {
3055 struct tevent_req *req = tevent_req_callback_data(
3056 subreq, struct tevent_req);
3057 struct rpccli_wkssvc_NetrValidateName_state *state = tevent_req_data(
3058 req, struct rpccli_wkssvc_NetrValidateName_state);
3059 NTSTATUS status;
3060 TALLOC_CTX *mem_ctx;
3061
3062 if (state->out_mem_ctx) {
3063 mem_ctx = state->out_mem_ctx;
3064 } else {
3065 mem_ctx = state;
3066 }
3067
3068 status = state->dispatch_recv(subreq, mem_ctx);
3069 TALLOC_FREE(subreq);
3070 if (!NT_STATUS_IS_OK(status)) {
3071 tevent_req_nterror(req, status);
3072 return;
3073 }
3074
3075 /* Copy out parameters */
3076
3077 /* Copy result */
3078 state->orig.out.result = state->tmp.out.result;
3079
3080 /* Reset temporary structure */
3081 ZERO_STRUCT(state->tmp);
3082
3083 tevent_req_done(req);
3084 }
3085
3086 NTSTATUS rpccli_wkssvc_NetrValidateName_recv(struct tevent_req *req,
3087 TALLOC_CTX *mem_ctx,
3088 WERROR *result)
3089 {
3090 struct rpccli_wkssvc_NetrValidateName_state *state = tevent_req_data(
3091 req, struct rpccli_wkssvc_NetrValidateName_state);
3092 NTSTATUS status;
3093
3094 if (tevent_req_is_nterror(req, &status)) {
3095 tevent_req_received(req);
3096 return status;
3097 }
3098
3099 /* Steal possbile out parameters to the callers context */
3100 talloc_steal(mem_ctx, state->out_mem_ctx);
3101
3102 /* Return result */
3103 *result = state->orig.out.result;
3104
3105 tevent_req_received(req);
3106 return NT_STATUS_OK;
3107 }
3108
3109 NTSTATUS rpccli_wkssvc_NetrValidateName(struct rpc_pipe_client *cli,
3110 TALLOC_CTX *mem_ctx,
3111 const char *server_name /* [in] [unique,charset(UTF16)] */,
3112 const char *name /* [in] [ref,charset(UTF16)] */,
3113 const char *Account /* [in] [unique,charset(UTF16)] */,
3114 const char *Password /* [in] [unique,charset(UTF16)] */,
3115 enum wkssvc_NetValidateNameType name_type /* [in] */,
3116 WERROR *werror)
3117 {
3118 struct wkssvc_NetrValidateName r;
3119 NTSTATUS status;
3120
3121 /* In parameters */
3122 r.in.server_name = server_name;
3123 r.in.name = name;
3124 r.in.Account = Account;
3125 r.in.Password = Password;
3126 r.in.name_type = name_type;
3127
3128 status = cli->dispatch(cli,
3129 mem_ctx,
3130 &ndr_table_wkssvc,
3131 NDR_WKSSVC_NETRVALIDATENAME,
3132 &r);
3133
3134 if (!NT_STATUS_IS_OK(status)) {
3135 return status;
3136 }
3137
3138 if (NT_STATUS_IS_ERR(status)) {
3139 return status;
3140 }
3141
3142 /* Return variables */
3143
3144 /* Return result */
3145 if (werror) {
3146 *werror = r.out.result;
3147 }
3148
3149 return werror_to_ntstatus(r.out.result);
3150 }
3151
3152 struct rpccli_wkssvc_NetrGetJoinInformation_state {
3153 struct wkssvc_NetrGetJoinInformation orig;
3154 struct wkssvc_NetrGetJoinInformation tmp;
3155 TALLOC_CTX *out_mem_ctx;
3156 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3157 };
3158
3159 static void rpccli_wkssvc_NetrGetJoinInformation_done(struct tevent_req *subreq);
3160
3161 struct tevent_req *rpccli_wkssvc_NetrGetJoinInformation_send(TALLOC_CTX *mem_ctx,
3162 struct tevent_context *ev,
3163 struct rpc_pipe_client *cli,
3164 const char *_server_name /* [in] [unique,charset(UTF16)] */,
3165 const char **_name_buffer /* [in,out] [ref,charset(UTF16)] */,
3166 enum wkssvc_NetJoinStatus *_name_type /* [out] [ref] */)
3167 {
3168 struct tevent_req *req;
3169 struct rpccli_wkssvc_NetrGetJoinInformation_state *state;
3170 struct tevent_req *subreq;
3171
3172 req = tevent_req_create(mem_ctx, &state,
3173 struct rpccli_wkssvc_NetrGetJoinInformation_state);
3174 if (req == NULL) {
3175 return NULL;
3176 }
3177 state->out_mem_ctx = NULL;
3178 state->dispatch_recv = cli->dispatch_recv;
3179
3180 /* In parameters */
3181 state->orig.in.server_name = _server_name;
3182 state->orig.in.name_buffer = _name_buffer;
3183
3184 /* Out parameters */
3185 state->orig.out.name_buffer = _name_buffer;
3186 state->orig.out.name_type = _name_type;
3187
3188 /* Result */
3189 ZERO_STRUCT(state->orig.out.result);
3190
3191 state->out_mem_ctx = talloc_named_const(state, 0,
3192 "rpccli_wkssvc_NetrGetJoinInformation_out_memory");
3193 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3194 return tevent_req_post(req, ev);
3195 }
3196
3197 /* make a temporary copy, that we pass to the dispatch function */
3198 state->tmp = state->orig;
3199
3200 subreq = cli->dispatch_send(state, ev, cli,
3201 &ndr_table_wkssvc,
3202 NDR_WKSSVC_NETRGETJOININFORMATION,
3203 &state->tmp);
3204 if (tevent_req_nomem(subreq, req)) {
3205 return tevent_req_post(req, ev);
3206 }
3207 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinInformation_done, req);
3208 return req;
3209 }
3210
3211 static void rpccli_wkssvc_NetrGetJoinInformation_done(struct tevent_req *subreq)
3212 {
3213 struct tevent_req *req = tevent_req_callback_data(
3214 subreq, struct tevent_req);
3215 struct rpccli_wkssvc_NetrGetJoinInformation_state *state = tevent_req_data(
3216 req, struct rpccli_wkssvc_NetrGetJoinInformation_state);
3217 NTSTATUS status;
3218 TALLOC_CTX *mem_ctx;
3219
3220 if (state->out_mem_ctx) {
3221 mem_ctx = state->out_mem_ctx;
3222 } else {
3223 mem_ctx = state;
3224 }
3225
3226 status = state->dispatch_recv(subreq, mem_ctx);
3227 TALLOC_FREE(subreq);
3228 if (!NT_STATUS_IS_OK(status)) {
3229 tevent_req_nterror(req, status);
3230 return;
3231 }
3232
3233 /* Copy out parameters */
3234 *state->orig.out.name_buffer = *state->tmp.out.name_buffer;
3235 *state->orig.out.name_type = *state->tmp.out.name_type;
3236
3237 /* Copy result */
3238 state->orig.out.result = state->tmp.out.result;
3239
3240 /* Reset temporary structure */
3241 ZERO_STRUCT(state->tmp);
3242
3243 tevent_req_done(req);
3244 }
3245
3246 NTSTATUS rpccli_wkssvc_NetrGetJoinInformation_recv(struct tevent_req *req,
3247 TALLOC_CTX *mem_ctx,
3248 WERROR *result)
3249 {
3250 struct rpccli_wkssvc_NetrGetJoinInformation_state *state = tevent_req_data(
3251 req, struct rpccli_wkssvc_NetrGetJoinInformation_state);
3252 NTSTATUS status;
3253
3254 if (tevent_req_is_nterror(req, &status)) {
3255 tevent_req_received(req);
3256 return status;
3257 }
3258
3259 /* Steal possbile out parameters to the callers context */
3260 talloc_steal(mem_ctx, state->out_mem_ctx);
3261
3262 /* Return result */
3263 *result = state->orig.out.result;
3264
3265 tevent_req_received(req);
3266 return NT_STATUS_OK;
3267 }
3268
3269 NTSTATUS rpccli_wkssvc_NetrGetJoinInformation(struct rpc_pipe_client *cli,
3270 TALLOC_CTX *mem_ctx,
3271 const char *server_name /* [in] [unique,charset(UTF16)] */,
3272 const char **name_buffer /* [in,out] [ref,charset(UTF16)] */,
3273 enum wkssvc_NetJoinStatus *name_type /* [out] [ref] */,
3274 WERROR *werror)
3275 {
3276 struct wkssvc_NetrGetJoinInformation r;
3277 NTSTATUS status;
3278
3279 /* In parameters */
3280 r.in.server_name = server_name;
3281 r.in.name_buffer = name_buffer;
3282
3283 status = cli->dispatch(cli,
3284 mem_ctx,
3285 &ndr_table_wkssvc,
3286 NDR_WKSSVC_NETRGETJOININFORMATION,
3287 &r);
3288
3289 if (!NT_STATUS_IS_OK(status)) {
3290 return status;
3291 }
3292
3293 if (NT_STATUS_IS_ERR(status)) {
3294 return status;
3295 }
3296
3297 /* Return variables */
3298 *name_buffer = *r.out.name_buffer;
3299 *name_type = *r.out.name_type;
3300
3301 /* Return result */
3302 if (werror) {
3303 *werror = r.out.result;
3304 }
3305
3306 return werror_to_ntstatus(r.out.result);
3307 }
3308
3309 struct rpccli_wkssvc_NetrGetJoinableOus_state {
3310 struct wkssvc_NetrGetJoinableOus orig;
3311 struct wkssvc_NetrGetJoinableOus tmp;
3312 TALLOC_CTX *out_mem_ctx;
3313 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3314 };
3315
3316 static void rpccli_wkssvc_NetrGetJoinableOus_done(struct tevent_req *subreq);
3317
3318 struct tevent_req *rpccli_wkssvc_NetrGetJoinableOus_send(TALLOC_CTX *mem_ctx,
3319 struct tevent_context *ev,
3320 struct rpc_pipe_client *cli,
3321 const char *_server_name /* [in] [unique,charset(UTF16)] */,
3322 const char *_domain_name /* [in] [ref,charset(UTF16)] */,
3323 const char *_Account /* [in] [unique,charset(UTF16)] */,
3324 const char *_unknown /* [in] [unique,charset(UTF16)] */,
3325 uint32_t *_num_ous /* [in,out] [ref] */,
3326 const char ***_ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */)
3327 {
3328 struct tevent_req *req;
3329 struct rpccli_wkssvc_NetrGetJoinableOus_state *state;
3330 struct tevent_req *subreq;
3331
3332 req = tevent_req_create(mem_ctx, &state,
3333 struct rpccli_wkssvc_NetrGetJoinableOus_state);
3334 if (req == NULL) {
3335 return NULL;
3336 }
3337 state->out_mem_ctx = NULL;
3338 state->dispatch_recv = cli->dispatch_recv;
3339
3340 /* In parameters */
3341 state->orig.in.server_name = _server_name;
3342 state->orig.in.domain_name = _domain_name;
3343 state->orig.in.Account = _Account;
3344 state->orig.in.unknown = _unknown;
3345 state->orig.in.num_ous = _num_ous;
3346
3347 /* Out parameters */
3348 state->orig.out.num_ous = _num_ous;
3349 state->orig.out.ous = _ous;
3350
3351 /* Result */
3352 ZERO_STRUCT(state->orig.out.result);
3353
3354 state->out_mem_ctx = talloc_named_const(state, 0,
3355 "rpccli_wkssvc_NetrGetJoinableOus_out_memory");
3356 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3357 return tevent_req_post(req, ev);
3358 }
3359
3360 /* make a temporary copy, that we pass to the dispatch function */
3361 state->tmp = state->orig;
3362
3363 subreq = cli->dispatch_send(state, ev, cli,
3364 &ndr_table_wkssvc,
3365 NDR_WKSSVC_NETRGETJOINABLEOUS,
3366 &state->tmp);
3367 if (tevent_req_nomem(subreq, req)) {
3368 return tevent_req_post(req, ev);
3369 }
3370 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinableOus_done, req);
3371 return req;
3372 }
3373
3374 static void rpccli_wkssvc_NetrGetJoinableOus_done(struct tevent_req *subreq)
3375 {
3376 struct tevent_req *req = tevent_req_callback_data(
3377 subreq, struct tevent_req);
3378 struct rpccli_wkssvc_NetrGetJoinableOus_state *state = tevent_req_data(
3379 req, struct rpccli_wkssvc_NetrGetJoinableOus_state);
3380 NTSTATUS status;
3381 TALLOC_CTX *mem_ctx;
3382
3383 if (state->out_mem_ctx) {
3384 mem_ctx = state->out_mem_ctx;
3385 } else {
3386 mem_ctx = state;
3387 }
3388
3389 status = state->dispatch_recv(subreq, mem_ctx);
3390 TALLOC_FREE(subreq);
3391 if (!NT_STATUS_IS_OK(status)) {
3392 tevent_req_nterror(req, status);
3393 return;
3394 }
3395
3396 /* Copy out parameters */
3397 *state->orig.out.num_ous = *state->tmp.out.num_ous;
3398 *state->orig.out.ous = *state->tmp.out.ous;
3399
3400 /* Copy result */
3401 state->orig.out.result = state->tmp.out.result;
3402
3403 /* Reset temporary structure */
3404 ZERO_STRUCT(state->tmp);
3405
3406 tevent_req_done(req);
3407 }
3408
3409 NTSTATUS rpccli_wkssvc_NetrGetJoinableOus_recv(struct tevent_req *req,
3410 TALLOC_CTX *mem_ctx,
3411 WERROR *result)
3412 {
3413 struct rpccli_wkssvc_NetrGetJoinableOus_state *state = tevent_req_data(
3414 req, struct rpccli_wkssvc_NetrGetJoinableOus_state);
3415 NTSTATUS status;
3416
3417 if (tevent_req_is_nterror(req, &status)) {
3418 tevent_req_received(req);
3419 return status;
3420 }
3421
3422 /* Steal possbile out parameters to the callers context */
3423 talloc_steal(mem_ctx, state->out_mem_ctx);
3424
3425 /* Return result */
3426 *result = state->orig.out.result;
3427
3428 tevent_req_received(req);
3429 return NT_STATUS_OK;
3430 }
3431
3432 NTSTATUS rpccli_wkssvc_NetrGetJoinableOus(struct rpc_pipe_client *cli,
3433 TALLOC_CTX *mem_ctx,
3434 const char *server_name /* [in] [unique,charset(UTF16)] */,
3435 const char *domain_name /* [in] [ref,charset(UTF16)] */,
3436 const char *Account /* [in] [unique,charset(UTF16)] */,
3437 const char *unknown /* [in] [unique,charset(UTF16)] */,
3438 uint32_t *num_ous /* [in,out] [ref] */,
3439 const char ***ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */,
3440 WERROR *werror)
3441 {
3442 struct wkssvc_NetrGetJoinableOus r;
3443 NTSTATUS status;
3444
3445 /* In parameters */
3446 r.in.server_name = server_name;
3447 r.in.domain_name = domain_name;
3448 r.in.Account = Account;
3449 r.in.unknown = unknown;
3450 r.in.num_ous = num_ous;
3451
3452 status = cli->dispatch(cli,
3453 mem_ctx,
3454 &ndr_table_wkssvc,
3455 NDR_WKSSVC_NETRGETJOINABLEOUS,
3456 &r);
3457
3458 if (!NT_STATUS_IS_OK(status)) {
3459 return status;
3460 }
3461
3462 if (NT_STATUS_IS_ERR(status)) {
3463 return status;
3464 }
3465
3466 /* Return variables */
3467 *num_ous = *r.out.num_ous;
3468 *ous = *r.out.ous;
3469
3470 /* Return result */
3471 if (werror) {
3472 *werror = r.out.result;
3473 }
3474
3475 return werror_to_ntstatus(r.out.result);
3476 }
3477
3478 struct rpccli_wkssvc_NetrJoinDomain2_state {
3479 struct wkssvc_NetrJoinDomain2 orig;
3480 struct wkssvc_NetrJoinDomain2 tmp;
3481 TALLOC_CTX *out_mem_ctx;
3482 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3483 };
3484
3485 static void rpccli_wkssvc_NetrJoinDomain2_done(struct tevent_req *subreq);
3486
3487 struct tevent_req *rpccli_wkssvc_NetrJoinDomain2_send(TALLOC_CTX *mem_ctx,
3488 struct tevent_context *ev,
3489 struct rpc_pipe_client *cli,
3490 const char *_server_name /* [in] [unique,charset(UTF16)] */,
3491 const char *_domain_name /* [in] [ref,charset(UTF16)] */,
3492 const char *_account_ou /* [in] [unique,charset(UTF16)] */,
3493 const char *_admin_account /* [in] [unique,charset(UTF16)] */,
3494 struct wkssvc_PasswordBuffer *_encrypted_password /* [in] [unique] */,
3495 uint32_t _join_flags /* [in] */)
3496 {
3497 struct tevent_req *req;
3498 struct rpccli_wkssvc_NetrJoinDomain2_state *state;
3499 struct tevent_req *subreq;
3500
3501 req = tevent_req_create(mem_ctx, &state,
3502 struct rpccli_wkssvc_NetrJoinDomain2_state);
3503 if (req == NULL) {
3504 return NULL;
3505 }
3506 state->out_mem_ctx = NULL;
3507 state->dispatch_recv = cli->dispatch_recv;
3508
3509 /* In parameters */
3510 state->orig.in.server_name = _server_name;
3511 state->orig.in.domain_name = _domain_name;
3512 state->orig.in.account_ou = _account_ou;
3513 state->orig.in.admin_account = _admin_account;
3514 state->orig.in.encrypted_password = _encrypted_password;
3515 state->orig.in.join_flags = _join_flags;
3516
3517 /* Out parameters */
3518
3519 /* Result */
3520 ZERO_STRUCT(state->orig.out.result);
3521
3522 /* make a temporary copy, that we pass to the dispatch function */
3523 state->tmp = state->orig;
3524
3525 subreq = cli->dispatch_send(state, ev, cli,
3526 &ndr_table_wkssvc,
3527 NDR_WKSSVC_NETRJOINDOMAIN2,
3528 &state->tmp);
3529 if (tevent_req_nomem(subreq, req)) {
3530 return tevent_req_post(req, ev);
3531 }
3532 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrJoinDomain2_done, req);
3533 return req;
3534 }
3535
3536 static void rpccli_wkssvc_NetrJoinDomain2_done(struct tevent_req *subreq)
3537 {
3538 struct tevent_req *req = tevent_req_callback_data(
3539 subreq, struct tevent_req);
3540 struct rpccli_wkssvc_NetrJoinDomain2_state *state = tevent_req_data(
3541 req, struct rpccli_wkssvc_NetrJoinDomain2_state);
3542 NTSTATUS status;
3543 TALLOC_CTX *mem_ctx;
3544
3545 if (state->out_mem_ctx) {
3546 mem_ctx = state->out_mem_ctx;
3547 } else {
3548 mem_ctx = state;
3549 }
3550
3551 status = state->dispatch_recv(subreq, mem_ctx);
3552 TALLOC_FREE(subreq);
3553 if (!NT_STATUS_IS_OK(status)) {
3554 tevent_req_nterror(req, status);
3555 return;
3556 }
3557
3558 /* Copy out parameters */
3559
3560 /* Copy result */
3561 state->orig.out.result = state->tmp.out.result;
3562
3563 /* Reset temporary structure */
3564 ZERO_STRUCT(state->tmp);
3565
3566 tevent_req_done(req);
3567 }
3568
3569 NTSTATUS rpccli_wkssvc_NetrJoinDomain2_recv(struct tevent_req *req,
3570 TALLOC_CTX *mem_ctx,
3571 WERROR *result)
3572 {
3573 struct rpccli_wkssvc_NetrJoinDomain2_state *state = tevent_req_data(
3574 req, struct rpccli_wkssvc_NetrJoinDomain2_state);
3575 NTSTATUS status;
3576
3577 if (tevent_req_is_nterror(req, &status)) {
3578 tevent_req_received(req);
3579 return status;
3580 }
3581
3582 /* Steal possbile out parameters to the callers context */
3583 talloc_steal(mem_ctx, state->out_mem_ctx);
3584
3585 /* Return result */
3586 *result = state->orig.out.result;
3587
3588 tevent_req_received(req);
3589 return NT_STATUS_OK;
3590 }
3591
3592 NTSTATUS rpccli_wkssvc_NetrJoinDomain2(struct rpc_pipe_client *cli,
3593 TALLOC_CTX *mem_ctx,
3594 const char *server_name /* [in] [unique,charset(UTF16)] */,
3595 const char *domain_name /* [in] [ref,charset(UTF16)] */,
3596 const char *account_ou /* [in] [unique,charset(UTF16)] */,
3597 const char *admin_account /* [in] [unique,charset(UTF16)] */,
3598 struct wkssvc_PasswordBuffer *encrypted_password /* [in] [unique] */,
3599 uint32_t join_flags /* [in] */,
3600 WERROR *werror)
3601 {
3602 struct wkssvc_NetrJoinDomain2 r;
3603 NTSTATUS status;
3604
3605 /* In parameters */
3606 r.in.server_name = server_name;
3607 r.in.domain_name = domain_name;
3608 r.in.account_ou = account_ou;
3609 r.in.admin_account = admin_account;
3610 r.in.encrypted_password = encrypted_password;
3611 r.in.join_flags = join_flags;
3612
3613 status = cli->dispatch(cli,
3614 mem_ctx,
3615 &ndr_table_wkssvc,
3616 NDR_WKSSVC_NETRJOINDOMAIN2,
3617 &r);
3618
3619 if (!NT_STATUS_IS_OK(status)) {
3620 return status;
3621 }
3622
3623 if (NT_STATUS_IS_ERR(status)) {
3624 return status;
3625 }
3626
3627 /* Return variables */
3628
3629 /* Return result */
3630 if (werror) {
3631 *werror = r.out.result;
3632 }
3633
3634 return werror_to_ntstatus(r.out.result);
3635 }
3636
3637 struct rpccli_wkssvc_NetrUnjoinDomain2_state {
3638 struct wkssvc_NetrUnjoinDomain2 orig;
3639 struct wkssvc_NetrUnjoinDomain2 tmp;
3640 TALLOC_CTX *out_mem_ctx;
3641 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3642 };
3643
3644 static void rpccli_wkssvc_NetrUnjoinDomain2_done(struct tevent_req *subreq);
3645
3646 struct tevent_req *rpccli_wkssvc_NetrUnjoinDomain2_send(TALLOC_CTX *mem_ctx,
3647 struct tevent_context *ev,
3648 struct rpc_pipe_client *cli,
3649 const char *_server_name /* [in] [unique,charset(UTF16)] */,
3650 const char *_account /* [in] [unique,charset(UTF16)] */,
3651 struct wkssvc_PasswordBuffer *_encrypted_password /* [in] [unique] */,
3652 uint32_t _unjoin_flags /* [in] */)
3653 {
3654 struct tevent_req *req;
3655 struct rpccli_wkssvc_NetrUnjoinDomain2_state *state;
3656 struct tevent_req *subreq;
3657
3658 req = tevent_req_create(mem_ctx, &state,
3659 struct rpccli_wkssvc_NetrUnjoinDomain2_state);
3660 if (req == NULL) {
3661 return NULL;
3662 }
3663 state->out_mem_ctx = NULL;
3664 state->dispatch_recv = cli->dispatch_recv;
3665
3666 /* In parameters */
3667 state->orig.in.server_name = _server_name;
3668 state->orig.in.account = _account;
3669 state->orig.in.encrypted_password = _encrypted_password;
3670 state->orig.in.unjoin_flags = _unjoin_flags;
3671
3672 /* Out parameters */
3673
3674 /* Result */
3675 ZERO_STRUCT(state->orig.out.result);
3676
3677 /* make a temporary copy, that we pass to the dispatch function */
3678 state->tmp = state->orig;
3679
3680 subreq = cli->dispatch_send(state, ev, cli,
3681 &ndr_table_wkssvc,
3682 NDR_WKSSVC_NETRUNJOINDOMAIN2,
3683 &state->tmp);
3684 if (tevent_req_nomem(subreq, req)) {
3685 return tevent_req_post(req, ev);
3686 }
3687 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUnjoinDomain2_done, req);
3688 return req;
3689 }
3690
3691 static void rpccli_wkssvc_NetrUnjoinDomain2_done(struct tevent_req *subreq)
3692 {
3693 struct tevent_req *req = tevent_req_callback_data(
3694 subreq, struct tevent_req);
3695 struct rpccli_wkssvc_NetrUnjoinDomain2_state *state = tevent_req_data(
3696 req, struct rpccli_wkssvc_NetrUnjoinDomain2_state);
3697 NTSTATUS status;
3698 TALLOC_CTX *mem_ctx;
3699
3700 if (state->out_mem_ctx) {
3701 mem_ctx = state->out_mem_ctx;
3702 } else {
3703 mem_ctx = state;
3704 }
3705
3706 status = state->dispatch_recv(subreq, mem_ctx);
3707 TALLOC_FREE(subreq);
3708 if (!NT_STATUS_IS_OK(status)) {
3709 tevent_req_nterror(req, status);
3710 return;
3711 }
3712
3713 /* Copy out parameters */
3714
3715 /* Copy result */
3716 state->orig.out.result = state->tmp.out.result;
3717
3718 /* Reset temporary structure */
3719 ZERO_STRUCT(state->tmp);
3720
3721 tevent_req_done(req);
3722 }
3723
3724 NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2_recv(struct tevent_req *req,
3725 TALLOC_CTX *mem_ctx,
3726 WERROR *result)
3727 {
3728 struct rpccli_wkssvc_NetrUnjoinDomain2_state *state = tevent_req_data(
3729 req, struct rpccli_wkssvc_NetrUnjoinDomain2_state);
3730 NTSTATUS status;
3731
3732 if (tevent_req_is_nterror(req, &status)) {
3733 tevent_req_received(req);
3734 return status;
3735 }
3736
3737 /* Steal possbile out parameters to the callers context */
3738 talloc_steal(mem_ctx, state->out_mem_ctx);
3739
3740 /* Return result */
3741 *result = state->orig.out.result;
3742
3743 tevent_req_received(req);
3744 return NT_STATUS_OK;
3745 }
3746
3747 NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2(struct rpc_pipe_client *cli,
3748 TALLOC_CTX *mem_ctx,
3749 const char *server_name /* [in] [unique,charset(UTF16)] */,
3750 const char *account /* [in] [unique,charset(UTF16)] */,
3751 struct wkssvc_PasswordBuffer *encrypted_password /* [in] [unique] */,
3752 uint32_t unjoin_flags /* [in] */,
3753 WERROR *werror)
3754 {
3755 struct wkssvc_NetrUnjoinDomain2 r;
3756 NTSTATUS status;
3757
3758 /* In parameters */
3759 r.in.server_name = server_name;
3760 r.in.account = account;
3761 r.in.encrypted_password = encrypted_password;
3762 r.in.unjoin_flags = unjoin_flags;
3763
3764 status = cli->dispatch(cli,
3765 mem_ctx,
3766 &ndr_table_wkssvc,
3767 NDR_WKSSVC_NETRUNJOINDOMAIN2,
3768 &r);
3769
3770 if (!NT_STATUS_IS_OK(status)) {
3771 return status;
3772 }
3773
3774 if (NT_STATUS_IS_ERR(status)) {
3775 return status;
3776 }
3777
3778 /* Return variables */
3779
3780 /* Return result */
3781 if (werror) {
3782 *werror = r.out.result;
3783 }
3784
3785 return werror_to_ntstatus(r.out.result);
3786 }
3787
3788 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state {
3789 struct wkssvc_NetrRenameMachineInDomain2 orig;
3790 struct wkssvc_NetrRenameMachineInDomain2 tmp;
3791 TALLOC_CTX *out_mem_ctx;
3792 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3793 };
3794
3795 static void rpccli_wkssvc_NetrRenameMachineInDomain2_done(struct tevent_req *subreq);
3796
3797 struct tevent_req *rpccli_wkssvc_NetrRenameMachineInDomain2_send(TALLOC_CTX *mem_ctx,
3798 struct tevent_context *ev,
3799 struct rpc_pipe_client *cli,
3800 const char *_server_name /* [in] [unique,charset(UTF16)] */,
3801 const char *_NewMachineName /* [in] [unique,charset(UTF16)] */,
3802 const char *_Account /* [in] [unique,charset(UTF16)] */,
3803 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */,
3804 uint32_t _RenameOptions /* [in] */)
3805 {
3806 struct tevent_req *req;
3807 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state;
3808 struct tevent_req *subreq;
3809
3810 req = tevent_req_create(mem_ctx, &state,
3811 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state);
3812 if (req == NULL) {
3813 return NULL;
3814 }
3815 state->out_mem_ctx = NULL;
3816 state->dispatch_recv = cli->dispatch_recv;
3817
3818 /* In parameters */
3819 state->orig.in.server_name = _server_name;
3820 state->orig.in.NewMachineName = _NewMachineName;
3821 state->orig.in.Account = _Account;
3822 state->orig.in.EncryptedPassword = _EncryptedPassword;
3823 state->orig.in.RenameOptions = _RenameOptions;
3824
3825 /* Out parameters */
3826
3827 /* Result */
3828 ZERO_STRUCT(state->orig.out.result);
3829
3830 /* make a temporary copy, that we pass to the dispatch function */
3831 state->tmp = state->orig;
3832
3833 subreq = cli->dispatch_send(state, ev, cli,
3834 &ndr_table_wkssvc,
3835 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2,
3836 &state->tmp);
3837 if (tevent_req_nomem(subreq, req)) {
3838 return tevent_req_post(req, ev);
3839 }
3840 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRenameMachineInDomain2_done, req);
3841 return req;
3842 }
3843
3844 static void rpccli_wkssvc_NetrRenameMachineInDomain2_done(struct tevent_req *subreq)
3845 {
3846 struct tevent_req *req = tevent_req_callback_data(
3847 subreq, struct tevent_req);
3848 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state = tevent_req_data(
3849 req, struct rpccli_wkssvc_NetrRenameMachineInDomain2_state);
3850 NTSTATUS status;
3851 TALLOC_CTX *mem_ctx;
3852
3853 if (state->out_mem_ctx) {
3854 mem_ctx = state->out_mem_ctx;
3855 } else {
3856 mem_ctx = state;
3857 }
3858
3859 status = state->dispatch_recv(subreq, mem_ctx);
3860 TALLOC_FREE(subreq);
3861 if (!NT_STATUS_IS_OK(status)) {
3862 tevent_req_nterror(req, status);
3863 return;
3864 }
3865
3866 /* Copy out parameters */
3867
3868 /* Copy result */
3869 state->orig.out.result = state->tmp.out.result;
3870
3871 /* Reset temporary structure */
3872 ZERO_STRUCT(state->tmp);
3873
3874 tevent_req_done(req);
3875 }
3876
3877 NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2_recv(struct tevent_req *req,
3878 TALLOC_CTX *mem_ctx,
3879 WERROR *result)
3880 {
3881 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state = tevent_req_data(
3882 req, struct rpccli_wkssvc_NetrRenameMachineInDomain2_state);
3883 NTSTATUS status;
3884
3885 if (tevent_req_is_nterror(req, &status)) {
3886 tevent_req_received(req);
3887 return status;
3888 }
3889
3890 /* Steal possbile out parameters to the callers context */
3891 talloc_steal(mem_ctx, state->out_mem_ctx);
3892
3893 /* Return result */
3894 *result = state->orig.out.result;
3895
3896 tevent_req_received(req);
3897 return NT_STATUS_OK;
3898 }
3899
3900 NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2(struct rpc_pipe_client *cli,
3901 TALLOC_CTX *mem_ctx,
3902 const char *server_name /* [in] [unique,charset(UTF16)] */,
3903 const char *NewMachineName /* [in] [unique,charset(UTF16)] */,
3904 const char *Account /* [in] [unique,charset(UTF16)] */,
3905 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
3906 uint32_t RenameOptions /* [in] */,
3907 WERROR *werror)
3908 {
3909 struct wkssvc_NetrRenameMachineInDomain2 r;
3910 NTSTATUS status;
3911
3912 /* In parameters */
3913 r.in.server_name = server_name;
3914 r.in.NewMachineName = NewMachineName;
3915 r.in.Account = Account;
3916 r.in.EncryptedPassword = EncryptedPassword;
3917 r.in.RenameOptions = RenameOptions;
3918
3919 status = cli->dispatch(cli,
3920 mem_ctx,
3921 &ndr_table_wkssvc,
3922 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2,
3923 &r);
3924
3925 if (!NT_STATUS_IS_OK(status)) {
3926 return status;
3927 }
3928
3929 if (NT_STATUS_IS_ERR(status)) {
3930 return status;
3931 }
3932
3933 /* Return variables */
3934
3935 /* Return result */
3936 if (werror) {
3937 *werror = r.out.result;
3938 }
3939
3940 return werror_to_ntstatus(r.out.result);
3941 }
3942
3943 struct rpccli_wkssvc_NetrValidateName2_state {
3944 struct wkssvc_NetrValidateName2 orig;
3945 struct wkssvc_NetrValidateName2 tmp;
3946 TALLOC_CTX *out_mem_ctx;
3947 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3948 };
3949
3950 static void rpccli_wkssvc_NetrValidateName2_done(struct tevent_req *subreq);
3951
3952 struct tevent_req *rpccli_wkssvc_NetrValidateName2_send(TALLOC_CTX *mem_ctx,
3953 struct tevent_context *ev,
3954 struct rpc_pipe_client *cli,
3955 const char *_server_name /* [in] [unique,charset(UTF16)] */,
3956 const char *_name /* [in] [ref,charset(UTF16)] */,
3957 const char *_Account /* [in] [unique,charset(UTF16)] */,
3958 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */,
3959 enum wkssvc_NetValidateNameType _name_type /* [in] */)
3960 {
3961 struct tevent_req *req;
3962 struct rpccli_wkssvc_NetrValidateName2_state *state;
3963 struct tevent_req *subreq;
3964
3965 req = tevent_req_create(mem_ctx, &state,
3966 struct rpccli_wkssvc_NetrValidateName2_state);
3967 if (req == NULL) {
3968 return NULL;
3969 }
3970 state->out_mem_ctx = NULL;
3971 state->dispatch_recv = cli->dispatch_recv;
3972
3973 /* In parameters */
3974 state->orig.in.server_name = _server_name;
3975 state->orig.in.name = _name;
3976 state->orig.in.Account = _Account;
3977 state->orig.in.EncryptedPassword = _EncryptedPassword;
3978 state->orig.in.name_type = _name_type;
3979
3980 /* Out parameters */
3981
3982 /* Result */
3983 ZERO_STRUCT(state->orig.out.result);
3984
3985 /* make a temporary copy, that we pass to the dispatch function */
3986 state->tmp = state->orig;
3987
3988 subreq = cli->dispatch_send(state, ev, cli,
3989 &ndr_table_wkssvc,
3990 NDR_WKSSVC_NETRVALIDATENAME2,
3991 &state->tmp);
3992 if (tevent_req_nomem(subreq, req)) {
3993 return tevent_req_post(req, ev);
3994 }
3995 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrValidateName2_done, req);
3996 return req;
3997 }
3998
3999 static void rpccli_wkssvc_NetrValidateName2_done(struct tevent_req *subreq)
4000 {
4001 struct tevent_req *req = tevent_req_callback_data(
4002 subreq, struct tevent_req);
4003 struct rpccli_wkssvc_NetrValidateName2_state *state = tevent_req_data(
4004 req, struct rpccli_wkssvc_NetrValidateName2_state);
4005 NTSTATUS status;
4006 TALLOC_CTX *mem_ctx;
4007
4008 if (state->out_mem_ctx) {
4009 mem_ctx = state->out_mem_ctx;
4010 } else {
4011 mem_ctx = state;
4012 }
4013
4014 status = state->dispatch_recv(subreq, mem_ctx);
4015 TALLOC_FREE(subreq);
4016 if (!NT_STATUS_IS_OK(status)) {
4017 tevent_req_nterror(req, status);
4018 return;
4019 }
4020
4021 /* Copy out parameters */
4022
4023 /* Copy result */
4024 state->orig.out.result = state->tmp.out.result;
4025
4026 /* Reset temporary structure */
4027 ZERO_STRUCT(state->tmp);
4028
4029 tevent_req_done(req);
4030 }
4031
4032 NTSTATUS rpccli_wkssvc_NetrValidateName2_recv(struct tevent_req *req,
4033 TALLOC_CTX *mem_ctx,
4034 WERROR *result)
4035 {
4036 struct rpccli_wkssvc_NetrValidateName2_state *state = tevent_req_data(
4037 req, struct rpccli_wkssvc_NetrValidateName2_state);
4038 NTSTATUS status;
4039
4040 if (tevent_req_is_nterror(req, &status)) {
4041 tevent_req_received(req);
4042 return status;
4043 }
4044
4045 /* Steal possbile out parameters to the callers context */
4046 talloc_steal(mem_ctx, state->out_mem_ctx);
4047
4048 /* Return result */
4049 *result = state->orig.out.result;
4050
4051 tevent_req_received(req);
4052 return NT_STATUS_OK;
4053 }
4054
4055 NTSTATUS rpccli_wkssvc_NetrValidateName2(struct rpc_pipe_client *cli,
4056 TALLOC_CTX *mem_ctx,
4057 const char *server_name /* [in] [unique,charset(UTF16)] */,
4058 const char *name /* [in] [ref,charset(UTF16)] */,
4059 const char *Account /* [in] [unique,charset(UTF16)] */,
4060 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
4061 enum wkssvc_NetValidateNameType name_type /* [in] */,
4062 WERROR *werror)
4063 {
4064 struct wkssvc_NetrValidateName2 r;
4065 NTSTATUS status;
4066
4067 /* In parameters */
4068 r.in.server_name = server_name;
4069 r.in.name = name;
4070 r.in.Account = Account;
4071 r.in.EncryptedPassword = EncryptedPassword;
4072 r.in.name_type = name_type;
4073
4074 status = cli->dispatch(cli,
4075 mem_ctx,
4076 &ndr_table_wkssvc,
4077 NDR_WKSSVC_NETRVALIDATENAME2,
4078 &r);
4079
4080 if (!NT_STATUS_IS_OK(status)) {
4081 return status;
4082 }
4083
4084 if (NT_STATUS_IS_ERR(status)) {
4085 return status;
4086 }
4087
4088 /* Return variables */
4089
4090 /* Return result */
4091 if (werror) {
4092 *werror = r.out.result;
4093 }
4094
4095 return werror_to_ntstatus(r.out.result);
4096 }
4097
4098 struct rpccli_wkssvc_NetrGetJoinableOus2_state {
4099 struct wkssvc_NetrGetJoinableOus2 orig;
4100 struct wkssvc_NetrGetJoinableOus2 tmp;
4101 TALLOC_CTX *out_mem_ctx;
4102 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4103 };
4104
4105 static void rpccli_wkssvc_NetrGetJoinableOus2_done(struct tevent_req *subreq);
4106
4107 struct tevent_req *rpccli_wkssvc_NetrGetJoinableOus2_send(TALLOC_CTX *mem_ctx,
4108 struct tevent_context *ev,
4109 struct rpc_pipe_client *cli,
4110 const char *_server_name /* [in] [unique,charset(UTF16)] */,
4111 const char *_domain_name /* [in] [ref,charset(UTF16)] */,
4112 const char *_Account /* [in] [unique,charset(UTF16)] */,
4113 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */,
4114 uint32_t *_num_ous /* [in,out] [ref] */,
4115 const char ***_ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */)
4116 {
4117 struct tevent_req *req;
4118 struct rpccli_wkssvc_NetrGetJoinableOus2_state *state;
4119 struct tevent_req *subreq;
4120
4121 req = tevent_req_create(mem_ctx, &state,
4122 struct rpccli_wkssvc_NetrGetJoinableOus2_state);
4123 if (req == NULL) {
4124 return NULL;
4125 }
4126 state->out_mem_ctx = NULL;
4127 state->dispatch_recv = cli->dispatch_recv;
4128
4129 /* In parameters */
4130 state->orig.in.server_name = _server_name;
4131 state->orig.in.domain_name = _domain_name;
4132 state->orig.in.Account = _Account;
4133 state->orig.in.EncryptedPassword = _EncryptedPassword;
4134 state->orig.in.num_ous = _num_ous;
4135
4136 /* Out parameters */
4137 state->orig.out.num_ous = _num_ous;
4138 state->orig.out.ous = _ous;
4139
4140 /* Result */
4141 ZERO_STRUCT(state->orig.out.result);
4142
4143 state->out_mem_ctx = talloc_named_const(state, 0,
4144 "rpccli_wkssvc_NetrGetJoinableOus2_out_memory");
4145 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4146 return tevent_req_post(req, ev);
4147 }
4148
4149 /* make a temporary copy, that we pass to the dispatch function */
4150 state->tmp = state->orig;
4151
4152 subreq = cli->dispatch_send(state, ev, cli,
4153 &ndr_table_wkssvc,
4154 NDR_WKSSVC_NETRGETJOINABLEOUS2,
4155 &state->tmp);
4156 if (tevent_req_nomem(subreq, req)) {
4157 return tevent_req_post(req, ev);
4158 }
4159 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinableOus2_done, req);
4160 return req;
4161 }
4162
4163 static void rpccli_wkssvc_NetrGetJoinableOus2_done(struct tevent_req *subreq)
4164 {
4165 struct tevent_req *req = tevent_req_callback_data(
4166 subreq, struct tevent_req);
4167 struct rpccli_wkssvc_NetrGetJoinableOus2_state *state = tevent_req_data(
4168 req, struct rpccli_wkssvc_NetrGetJoinableOus2_state);
4169 NTSTATUS status;
4170 TALLOC_CTX *mem_ctx;
4171
4172 if (state->out_mem_ctx) {
4173 mem_ctx = state->out_mem_ctx;
4174 } else {
4175 mem_ctx = state;
4176 }
4177
4178 status = state->dispatch_recv(subreq, mem_ctx);
4179 TALLOC_FREE(subreq);
4180 if (!NT_STATUS_IS_OK(status)) {
4181 tevent_req_nterror(req, status);
4182 return;
4183 }
4184
4185 /* Copy out parameters */
4186 *state->orig.out.num_ous = *state->tmp.out.num_ous;
4187 *state->orig.out.ous = *state->tmp.out.ous;
4188
4189 /* Copy result */
4190 state->orig.out.result = state->tmp.out.result;
4191
4192 /* Reset temporary structure */
4193 ZERO_STRUCT(state->tmp);
4194
4195 tevent_req_done(req);
4196 }
4197
4198 NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2_recv(struct tevent_req *req,
4199 TALLOC_CTX *mem_ctx,
4200 WERROR *result)
4201 {
4202 struct rpccli_wkssvc_NetrGetJoinableOus2_state *state = tevent_req_data(
4203 req, struct rpccli_wkssvc_NetrGetJoinableOus2_state);
4204 NTSTATUS status;
4205
4206 if (tevent_req_is_nterror(req, &status)) {
4207 tevent_req_received(req);
4208 return status;
4209 }
4210
4211 /* Steal possbile out parameters to the callers context */
4212 talloc_steal(mem_ctx, state->out_mem_ctx);
4213
4214 /* Return result */
4215 *result = state->orig.out.result;
4216
4217 tevent_req_received(req);
4218 return NT_STATUS_OK;
4219 }
4220
4221 NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2(struct rpc_pipe_client *cli,
4222 TALLOC_CTX *mem_ctx,
4223 const char *server_name /* [in] [unique,charset(UTF16)] */,
4224 const char *domain_name /* [in] [ref,charset(UTF16)] */,
4225 const char *Account /* [in] [unique,charset(UTF16)] */,
4226 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
4227 uint32_t *num_ous /* [in,out] [ref] */,
4228 const char ***ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */,
4229 WERROR *werror)
4230 {
4231 struct wkssvc_NetrGetJoinableOus2 r;
4232 NTSTATUS status;
4233
4234 /* In parameters */
4235 r.in.server_name = server_name;
4236 r.in.domain_name = domain_name;
4237 r.in.Account = Account;
4238 r.in.EncryptedPassword = EncryptedPassword;
4239 r.in.num_ous = num_ous;
4240
4241 status = cli->dispatch(cli,
4242 mem_ctx,
4243 &ndr_table_wkssvc,
4244 NDR_WKSSVC_NETRGETJOINABLEOUS2,
4245 &r);
4246
4247 if (!NT_STATUS_IS_OK(status)) {
4248 return status;
4249 }
4250
4251 if (NT_STATUS_IS_ERR(status)) {
4252 return status;
4253 }
4254
4255 /* Return variables */
4256 *num_ous = *r.out.num_ous;
4257 *ous = *r.out.ous;
4258
4259 /* Return result */
4260 if (werror) {
4261 *werror = r.out.result;
4262 }
4263
4264 return werror_to_ntstatus(r.out.result);
4265 }
4266
4267 struct rpccli_wkssvc_NetrAddAlternateComputerName_state {
4268 struct wkssvc_NetrAddAlternateComputerName orig;
4269 struct wkssvc_NetrAddAlternateComputerName tmp;
4270 TALLOC_CTX *out_mem_ctx;
4271 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4272 };
4273
4274 static void rpccli_wkssvc_NetrAddAlternateComputerName_done(struct tevent_req *subreq);
4275
4276 struct tevent_req *rpccli_wkssvc_NetrAddAlternateComputerName_send(TALLOC_CTX *mem_ctx,
4277 struct tevent_context *ev,
4278 struct rpc_pipe_client *cli,
4279 const char *_server_name /* [in] [unique,charset(UTF16)] */,
4280 const char *_NewAlternateMachineName /* [in] [unique,charset(UTF16)] */,
4281 const char *_Account /* [in] [unique,charset(UTF16)] */,
4282 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */,
4283 uint32_t _Reserved /* [in] */)
4284 {
4285 struct tevent_req *req;
4286 struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state;
4287 struct tevent_req *subreq;
4288
4289 req = tevent_req_create(mem_ctx, &state,
4290 struct rpccli_wkssvc_NetrAddAlternateComputerName_state);
4291 if (req == NULL) {
4292 return NULL;
4293 }
4294 state->out_mem_ctx = NULL;
4295 state->dispatch_recv = cli->dispatch_recv;
4296
4297 /* In parameters */
4298 state->orig.in.server_name = _server_name;
4299 state->orig.in.NewAlternateMachineName = _NewAlternateMachineName;
4300 state->orig.in.Account = _Account;
4301 state->orig.in.EncryptedPassword = _EncryptedPassword;
4302 state->orig.in.Reserved = _Reserved;
4303
4304 /* Out parameters */
4305
4306 /* Result */
4307 ZERO_STRUCT(state->orig.out.result);
4308
4309 /* make a temporary copy, that we pass to the dispatch function */
4310 state->tmp = state->orig;
4311
4312 subreq = cli->dispatch_send(state, ev, cli,
4313 &ndr_table_wkssvc,
4314 NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME,
4315 &state->tmp);
4316 if (tevent_req_nomem(subreq, req)) {
4317 return tevent_req_post(req, ev);
4318 }
4319 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrAddAlternateComputerName_done, req);
4320 return req;
4321 }
4322
4323 static void rpccli_wkssvc_NetrAddAlternateComputerName_done(struct tevent_req *subreq)
4324 {
4325 struct tevent_req *req = tevent_req_callback_data(
4326 subreq, struct tevent_req);
4327 struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state = tevent_req_data(
4328 req, struct rpccli_wkssvc_NetrAddAlternateComputerName_state);
4329 NTSTATUS status;
4330 TALLOC_CTX *mem_ctx;
4331
4332 if (state->out_mem_ctx) {
4333 mem_ctx = state->out_mem_ctx;
4334 } else {
4335 mem_ctx = state;
4336 }
4337
4338 status = state->dispatch_recv(subreq, mem_ctx);
4339 TALLOC_FREE(subreq);
4340 if (!NT_STATUS_IS_OK(status)) {
4341 tevent_req_nterror(req, status);
4342 return;
4343 }
4344
4345 /* Copy out parameters */
4346
4347 /* Copy result */
4348 state->orig.out.result = state->tmp.out.result;
4349
4350 /* Reset temporary structure */
4351 ZERO_STRUCT(state->tmp);
4352
4353 tevent_req_done(req);
4354 }
4355
4356 NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName_recv(struct tevent_req *req,
4357 TALLOC_CTX *mem_ctx,
4358 WERROR *result)
4359 {
4360 struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state = tevent_req_data(
4361 req, struct rpccli_wkssvc_NetrAddAlternateComputerName_state);
4362 NTSTATUS status;
4363
4364 if (tevent_req_is_nterror(req, &status)) {
4365 tevent_req_received(req);
4366 return status;
4367 }
4368
4369 /* Steal possbile out parameters to the callers context */
4370 talloc_steal(mem_ctx, state->out_mem_ctx);
4371
4372 /* Return result */
4373 *result = state->orig.out.result;
4374
4375 tevent_req_received(req);
4376 return NT_STATUS_OK;
4377 }
4378
4379 NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName(struct rpc_pipe_client *cli,
4380 TALLOC_CTX *mem_ctx,
4381 const char *server_name /* [in] [unique,charset(UTF16)] */,
4382 const char *NewAlternateMachineName /* [in] [unique,charset(UTF16)] */,
4383 const char *Account /* [in] [unique,charset(UTF16)] */,
4384 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
4385 uint32_t Reserved /* [in] */,
4386 WERROR *werror)
4387 {
4388 struct wkssvc_NetrAddAlternateComputerName r;
4389 NTSTATUS status;
4390
4391 /* In parameters */
4392 r.in.server_name = server_name;
4393 r.in.NewAlternateMachineName = NewAlternateMachineName;
4394 r.in.Account = Account;
4395 r.in.EncryptedPassword = EncryptedPassword;
4396 r.in.Reserved = Reserved;
4397
4398 status = cli->dispatch(cli,
4399 mem_ctx,
4400 &ndr_table_wkssvc,
4401 NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME,
4402 &r);
4403
4404 if (!NT_STATUS_IS_OK(status)) {
4405 return status;
4406 }
4407
4408 if (NT_STATUS_IS_ERR(status)) {
4409 return status;
4410 }
4411
4412 /* Return variables */
4413
4414 /* Return result */
4415 if (werror) {
4416 *werror = r.out.result;
4417 }
4418
4419 return werror_to_ntstatus(r.out.result);
4420 }
4421
4422 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state {
4423 struct wkssvc_NetrRemoveAlternateComputerName orig;
4424 struct wkssvc_NetrRemoveAlternateComputerName tmp;
4425 TALLOC_CTX *out_mem_ctx;
4426 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4427 };
4428
4429 static void rpccli_wkssvc_NetrRemoveAlternateComputerName_done(struct tevent_req *subreq);
4430
4431 struct tevent_req *rpccli_wkssvc_NetrRemoveAlternateComputerName_send(TALLOC_CTX *mem_ctx,
4432 struct tevent_context *ev,
4433 struct rpc_pipe_client *cli,
4434 const char *_server_name /* [in] [unique,charset(UTF16)] */,
4435 const char *_AlternateMachineNameToRemove /* [in] [unique,charset(UTF16)] */,
4436 const char *_Account /* [in] [unique,charset(UTF16)] */,
4437 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */,
4438 uint32_t _Reserved /* [in] */)
4439 {
4440 struct tevent_req *req;
4441 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state;
4442 struct tevent_req *subreq;
4443
4444 req = tevent_req_create(mem_ctx, &state,
4445 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state);
4446 if (req == NULL) {
4447 return NULL;
4448 }
4449 state->out_mem_ctx = NULL;
4450 state->dispatch_recv = cli->dispatch_recv;
4451
4452 /* In parameters */
4453 state->orig.in.server_name = _server_name;
4454 state->orig.in.AlternateMachineNameToRemove = _AlternateMachineNameToRemove;
4455 state->orig.in.Account = _Account;
4456 state->orig.in.EncryptedPassword = _EncryptedPassword;
4457 state->orig.in.Reserved = _Reserved;
4458
4459 /* Out parameters */
4460
4461 /* Result */
4462 ZERO_STRUCT(state->orig.out.result);
4463
4464 /* make a temporary copy, that we pass to the dispatch function */
4465 state->tmp = state->orig;
4466
4467 subreq = cli->dispatch_send(state, ev, cli,
4468 &ndr_table_wkssvc,
4469 NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME,
4470 &state->tmp);
4471 if (tevent_req_nomem(subreq, req)) {
4472 return tevent_req_post(req, ev);
4473 }
4474 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRemoveAlternateComputerName_done, req);
4475 return req;
4476 }
4477
4478 static void rpccli_wkssvc_NetrRemoveAlternateComputerName_done(struct tevent_req *subreq)
4479 {
4480 struct tevent_req *req = tevent_req_callback_data(
4481 subreq, struct tevent_req);
4482 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state = tevent_req_data(
4483 req, struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state);
4484 NTSTATUS status;
4485 TALLOC_CTX *mem_ctx;
4486
4487 if (state->out_mem_ctx) {
4488 mem_ctx = state->out_mem_ctx;
4489 } else {
4490 mem_ctx = state;
4491 }
4492
4493 status = state->dispatch_recv(subreq, mem_ctx);
4494 TALLOC_FREE(subreq);
4495 if (!NT_STATUS_IS_OK(status)) {
4496 tevent_req_nterror(req, status);
4497 return;
4498 }
4499
4500 /* Copy out parameters */
4501
4502 /* Copy result */
4503 state->orig.out.result = state->tmp.out.result;
4504
4505 /* Reset temporary structure */
4506 ZERO_STRUCT(state->tmp);
4507
4508 tevent_req_done(req);
4509 }
4510
4511 NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName_recv(struct tevent_req *req,
4512 TALLOC_CTX *mem_ctx,
4513 WERROR *result)
4514 {
4515 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state = tevent_req_data(
4516 req, struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state);
4517 NTSTATUS status;
4518
4519 if (tevent_req_is_nterror(req, &status)) {
4520 tevent_req_received(req);
4521 return status;
4522 }
4523
4524 /* Steal possbile out parameters to the callers context */
4525 talloc_steal(mem_ctx, state->out_mem_ctx);
4526
4527 /* Return result */
4528 *result = state->orig.out.result;
4529
4530 tevent_req_received(req);
4531 return NT_STATUS_OK;
4532 }
4533
4534 NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName(struct rpc_pipe_client *cli,
4535 TALLOC_CTX *mem_ctx,
4536 const char *server_name /* [in] [unique,charset(UTF16)] */,
4537 const char *AlternateMachineNameToRemove /* [in] [unique,charset(UTF16)] */,
4538 const char *Account /* [in] [unique,charset(UTF16)] */,
4539 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
4540 uint32_t Reserved /* [in] */,
4541 WERROR *werror)
4542 {
4543 struct wkssvc_NetrRemoveAlternateComputerName r;
4544 NTSTATUS status;
4545
4546 /* In parameters */
4547 r.in.server_name = server_name;
4548 r.in.AlternateMachineNameToRemove = AlternateMachineNameToRemove;
4549 r.in.Account = Account;
4550 r.in.EncryptedPassword = EncryptedPassword;
4551 r.in.Reserved = Reserved;
4552
4553 status = cli->dispatch(cli,
4554 mem_ctx,
4555 &ndr_table_wkssvc,
4556 NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME,
4557 &r);
4558
4559 if (!NT_STATUS_IS_OK(status)) {
4560 return status;
4561 }
4562
4563 if (NT_STATUS_IS_ERR(status)) {
4564 return status;
4565 }
4566
4567 /* Return variables */
4568
4569 /* Return result */
4570 if (werror) {
4571 *werror = r.out.result;
4572 }
4573
4574 return werror_to_ntstatus(r.out.result);
4575 }
4576
4577 struct rpccli_wkssvc_NetrSetPrimaryComputername_state {
4578 struct wkssvc_NetrSetPrimaryComputername orig;
4579 struct wkssvc_NetrSetPrimaryComputername tmp;
4580 TALLOC_CTX *out_mem_ctx;
4581 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4582 };
4583
4584 static void rpccli_wkssvc_NetrSetPrimaryComputername_done(struct tevent_req *subreq);
4585
4586 struct tevent_req *rpccli_wkssvc_NetrSetPrimaryComputername_send(TALLOC_CTX *mem_ctx,
4587 struct tevent_context *ev,
4588 struct rpc_pipe_client *cli,
4589 const char *_server_name /* [in] [unique,charset(UTF16)] */,
4590 const char *_primary_name /* [in] [unique,charset(UTF16)] */,
4591 const char *_Account /* [in] [unique,charset(UTF16)] */,
4592 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */,
4593 uint32_t _Reserved /* [in] */)
4594 {
4595 struct tevent_req *req;
4596 struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state;
4597 struct tevent_req *subreq;
4598
4599 req = tevent_req_create(mem_ctx, &state,
4600 struct rpccli_wkssvc_NetrSetPrimaryComputername_state);
4601 if (req == NULL) {
4602 return NULL;
4603 }
4604 state->out_mem_ctx = NULL;
4605 state->dispatch_recv = cli->dispatch_recv;
4606
4607 /* In parameters */
4608 state->orig.in.server_name = _server_name;
4609 state->orig.in.primary_name = _primary_name;
4610 state->orig.in.Account = _Account;
4611 state->orig.in.EncryptedPassword = _EncryptedPassword;
4612 state->orig.in.Reserved = _Reserved;
4613
4614 /* Out parameters */
4615
4616 /* Result */
4617 ZERO_STRUCT(state->orig.out.result);
4618
4619 /* make a temporary copy, that we pass to the dispatch function */
4620 state->tmp = state->orig;
4621
4622 subreq = cli->dispatch_send(state, ev, cli,
4623 &ndr_table_wkssvc,
4624 NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4625 &state->tmp);
4626 if (tevent_req_nomem(subreq, req)) {
4627 return tevent_req_post(req, ev);
4628 }
4629 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrSetPrimaryComputername_done, req);
4630 return req;
4631 }
4632
4633 static void rpccli_wkssvc_NetrSetPrimaryComputername_done(struct tevent_req *subreq)
4634 {
4635 struct tevent_req *req = tevent_req_callback_data(
4636 subreq, struct tevent_req);
4637 struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state = tevent_req_data(
4638 req, struct rpccli_wkssvc_NetrSetPrimaryComputername_state);
4639 NTSTATUS status;
4640 TALLOC_CTX *mem_ctx;
4641
4642 if (state->out_mem_ctx) {
4643 mem_ctx = state->out_mem_ctx;
4644 } else {
4645 mem_ctx = state;
4646 }
4647
4648 status = state->dispatch_recv(subreq, mem_ctx);
4649 TALLOC_FREE(subreq);
4650 if (!NT_STATUS_IS_OK(status)) {
4651 tevent_req_nterror(req, status);
4652 return;
4653 }
4654
4655 /* Copy out parameters */
4656
4657 /* Copy result */
4658 state->orig.out.result = state->tmp.out.result;
4659
4660 /* Reset temporary structure */
4661 ZERO_STRUCT(state->tmp);
4662
4663 tevent_req_done(req);
4664 }
4665
4666 NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername_recv(struct tevent_req *req,
4667 TALLOC_CTX *mem_ctx,
4668 WERROR *result)
4669 {
4670 struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state = tevent_req_data(
4671 req, struct rpccli_wkssvc_NetrSetPrimaryComputername_state);
4672 NTSTATUS status;
4673
4674 if (tevent_req_is_nterror(req, &status)) {
4675 tevent_req_received(req);
4676 return status;
4677 }
4678
4679 /* Steal possbile out parameters to the callers context */
4680 talloc_steal(mem_ctx, state->out_mem_ctx);
4681
4682 /* Return result */
4683 *result = state->orig.out.result;
4684
4685 tevent_req_received(req);
4686 return NT_STATUS_OK;
4687 }
4688
4689 NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername(struct rpc_pipe_client *cli,
4690 TALLOC_CTX *mem_ctx,
4691 const char *server_name /* [in] [unique,charset(UTF16)] */,
4692 const char *primary_name /* [in] [unique,charset(UTF16)] */,
4693 const char *Account /* [in] [unique,charset(UTF16)] */,
4694 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
4695 uint32_t Reserved /* [in] */,
4696 WERROR *werror)
4697 {
4698 struct wkssvc_NetrSetPrimaryComputername r;
4699 NTSTATUS status;
4700
4701 /* In parameters */
4702 r.in.server_name = server_name;
4703 r.in.primary_name = primary_name;
4704 r.in.Account = Account;
4705 r.in.EncryptedPassword = EncryptedPassword;
4706 r.in.Reserved = Reserved;
4707
4708 status = cli->dispatch(cli,
4709 mem_ctx,
4710 &ndr_table_wkssvc,
4711 NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
4712 &r);
4713
4714 if (!NT_STATUS_IS_OK(status)) {
4715 return status;
4716 }
4717
4718 if (NT_STATUS_IS_ERR(status)) {
4719 return status;
4720 }
4721
4722 /* Return variables */
4723
4724 /* Return result */
4725 if (werror) {
4726 *werror = r.out.result;
4727 }
4728
4729 return werror_to_ntstatus(r.out.result);
4730 }
4731
4732 struct rpccli_wkssvc_NetrEnumerateComputerNames_state {
4733 struct wkssvc_NetrEnumerateComputerNames orig;
4734 struct wkssvc_NetrEnumerateComputerNames tmp;
4735 TALLOC_CTX *out_mem_ctx;
4736 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4737 };
4738
4739 static void rpccli_wkssvc_NetrEnumerateComputerNames_done(struct tevent_req *subreq);
4740
4741 struct tevent_req *rpccli_wkssvc_NetrEnumerateComputerNames_send(TALLOC_CTX *mem_ctx,
4742 struct tevent_context *ev,
4743 struct rpc_pipe_client *cli,
4744 const char *_server_name /* [in] [unique,charset(UTF16)] */,
4745 enum wkssvc_ComputerNameType _name_type /* [in] */,
4746 uint32_t _Reserved /* [in] */,
4747 struct wkssvc_ComputerNamesCtr **_ctr /* [out] [ref] */)
4748 {
4749 struct tevent_req *req;
4750 struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state;
4751 struct tevent_req *subreq;
4752
4753 req = tevent_req_create(mem_ctx, &state,
4754 struct rpccli_wkssvc_NetrEnumerateComputerNames_state);
4755 if (req == NULL) {
4756 return NULL;
4757 }
4758 state->out_mem_ctx = NULL;
4759 state->dispatch_recv = cli->dispatch_recv;
4760
4761 /* In parameters */
4762 state->orig.in.server_name = _server_name;
4763 state->orig.in.name_type = _name_type;
4764 state->orig.in.Reserved = _Reserved;
4765
4766 /* Out parameters */
4767 state->orig.out.ctr = _ctr;
4768
4769 /* Result */
4770 ZERO_STRUCT(state->orig.out.result);
4771
4772 state->out_mem_ctx = talloc_named_const(state, 0,
4773 "rpccli_wkssvc_NetrEnumerateComputerNames_out_memory");
4774 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4775 return tevent_req_post(req, ev);
4776 }
4777
4778 /* make a temporary copy, that we pass to the dispatch function */
4779 state->tmp = state->orig;
4780
4781 subreq = cli->dispatch_send(state, ev, cli,
4782 &ndr_table_wkssvc,
4783 NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4784 &state->tmp);
4785 if (tevent_req_nomem(subreq, req)) {
4786 return tevent_req_post(req, ev);
4787 }
4788 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrEnumerateComputerNames_done, req);
4789 return req;
4790 }
4791
4792 static void rpccli_wkssvc_NetrEnumerateComputerNames_done(struct tevent_req *subreq)
4793 {
4794 struct tevent_req *req = tevent_req_callback_data(
4795 subreq, struct tevent_req);
4796 struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state = tevent_req_data(
4797 req, struct rpccli_wkssvc_NetrEnumerateComputerNames_state);
4798 NTSTATUS status;
4799 TALLOC_CTX *mem_ctx;
4800
4801 if (state->out_mem_ctx) {
4802 mem_ctx = state->out_mem_ctx;
4803 } else {
4804 mem_ctx = state;
4805 }
4806
4807 status = state->dispatch_recv(subreq, mem_ctx);
4808 TALLOC_FREE(subreq);
4809 if (!NT_STATUS_IS_OK(status)) {
4810 tevent_req_nterror(req, status);
4811 return;
4812 }
4813
4814 /* Copy out parameters */
4815 *state->orig.out.ctr = *state->tmp.out.ctr;
4816
4817 /* Copy result */
4818 state->orig.out.result = state->tmp.out.result;
4819
4820 /* Reset temporary structure */
4821 ZERO_STRUCT(state->tmp);
4822
4823 tevent_req_done(req);
4824 }
4825
4826 NTSTATUS rpccli_wkssvc_NetrEnumerateComputerNames_recv(struct tevent_req *req,
4827 TALLOC_CTX *mem_ctx,
4828 WERROR *result)
4829 {
4830 struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state = tevent_req_data(
4831 req, struct rpccli_wkssvc_NetrEnumerateComputerNames_state);
4832 NTSTATUS status;
4833
4834 if (tevent_req_is_nterror(req, &status)) {
4835 tevent_req_received(req);
4836 return status;
4837 }
4838
4839 /* Steal possbile out parameters to the callers context */
4840 talloc_steal(mem_ctx, state->out_mem_ctx);
4841
4842 /* Return result */
4843 *result = state->orig.out.result;
4844
4845 tevent_req_received(req);
4846 return NT_STATUS_OK;
4847 }
4848
4849 NTSTATUS rpccli_wkssvc_NetrEnumerateComputerNames(struct rpc_pipe_client *cli,
4850 TALLOC_CTX *mem_ctx,
4851 const char *server_name /* [in] [unique,charset(UTF16)] */,
4852 enum wkssvc_ComputerNameType name_type /* [in] */,
4853 uint32_t Reserved /* [in] */,
4854 struct wkssvc_ComputerNamesCtr **ctr /* [out] [ref] */,
4855 WERROR *werror)
4856 {
4857 struct wkssvc_NetrEnumerateComputerNames r;
4858 NTSTATUS status;
4859
4860 /* In parameters */
4861 r.in.server_name = server_name;
4862 r.in.name_type = name_type;
4863 r.in.Reserved = Reserved;
4864
4865 status = cli->dispatch(cli,
4866 mem_ctx,
4867 &ndr_table_wkssvc,
4868 NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES,
4869 &r);
4870
4871 if (!NT_STATUS_IS_OK(status)) {
4872 return status;
4873 }
4874
4875 if (NT_STATUS_IS_ERR(status)) {
4876 return status;
4877 }
4878
4879 /* Return variables */
4880 *ctr = *r.out.ctr;
4881
4882 /* Return result */
4883 if (werror) {
4884 *werror = r.out.result;
4885 }
4886
4887 return werror_to_ntstatus(r.out.result);
4888 }
4889
Samba GIT mirror