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