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

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

Samba 3.5.0: Initial import
File size: 39.5 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
4 */
5
6#include "includes.h"
7#include "../librpc/gen_ndr/srv_dfs.h"
8
9static bool api_dfs_GetManagerVersion(pipes_struct *p)
10{
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
15 DATA_BLOB blob;
16 struct dfs_GetManagerVersion *r;
17
18 call = &ndr_table_netdfs.calls[NDR_DFS_GETMANAGERVERSION];
19
20 r = talloc(talloc_tos(), struct dfs_GetManagerVersion);
21 if (r == NULL) {
22 return false;
23 }
24
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26 talloc_free(r);
27 return false;
28 }
29
30 pull = ndr_pull_init_blob(&blob, r, NULL);
31 if (pull == NULL) {
32 talloc_free(r);
33 return false;
34 }
35
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 ndr_err = call->ndr_pull(pull, NDR_IN, r);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39 talloc_free(r);
40 return false;
41 }
42
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(dfs_GetManagerVersion, r);
45 }
46
47 ZERO_STRUCT(r->out);
48 r->out.version = talloc_zero(r, enum dfs_ManagerVersion);
49 if (r->out.version == NULL) {
50 talloc_free(r);
51 return false;
52 }
53
54 _dfs_GetManagerVersion(p, r);
55
56 if (p->rng_fault_state) {
57 talloc_free(r);
58 /* Return true here, srv_pipe_hnd.c will take care */
59 return true;
60 }
61
62 if (DEBUGLEVEL >= 10) {
63 NDR_PRINT_OUT_DEBUG(dfs_GetManagerVersion, r);
64 }
65
66 push = ndr_push_init_ctx(r, NULL);
67 if (push == NULL) {
68 talloc_free(r);
69 return false;
70 }
71
72 ndr_err = call->ndr_push(push, NDR_OUT, r);
73 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
74 talloc_free(r);
75 return false;
76 }
77
78 blob = ndr_push_blob(push);
79 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
80 talloc_free(r);
81 return false;
82 }
83
84 talloc_free(r);
85
86 return true;
87}
88
89static bool api_dfs_Add(pipes_struct *p)
90{
91 const struct ndr_interface_call *call;
92 struct ndr_pull *pull;
93 struct ndr_push *push;
94 enum ndr_err_code ndr_err;
95 DATA_BLOB blob;
96 struct dfs_Add *r;
97
98 call = &ndr_table_netdfs.calls[NDR_DFS_ADD];
99
100 r = talloc(talloc_tos(), struct dfs_Add);
101 if (r == NULL) {
102 return false;
103 }
104
105 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
106 talloc_free(r);
107 return false;
108 }
109
110 pull = ndr_pull_init_blob(&blob, r, NULL);
111 if (pull == NULL) {
112 talloc_free(r);
113 return false;
114 }
115
116 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
117 ndr_err = call->ndr_pull(pull, NDR_IN, r);
118 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
119 talloc_free(r);
120 return false;
121 }
122
123 if (DEBUGLEVEL >= 10) {
124 NDR_PRINT_IN_DEBUG(dfs_Add, r);
125 }
126
127 r->out.result = _dfs_Add(p, r);
128
129 if (p->rng_fault_state) {
130 talloc_free(r);
131 /* Return true here, srv_pipe_hnd.c will take care */
132 return true;
133 }
134
135 if (DEBUGLEVEL >= 10) {
136 NDR_PRINT_OUT_DEBUG(dfs_Add, r);
137 }
138
139 push = ndr_push_init_ctx(r, NULL);
140 if (push == NULL) {
141 talloc_free(r);
142 return false;
143 }
144
145 ndr_err = call->ndr_push(push, NDR_OUT, r);
146 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
147 talloc_free(r);
148 return false;
149 }
150
151 blob = ndr_push_blob(push);
152 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
153 talloc_free(r);
154 return false;
155 }
156
157 talloc_free(r);
158
159 return true;
160}
161
162static bool api_dfs_Remove(pipes_struct *p)
163{
164 const struct ndr_interface_call *call;
165 struct ndr_pull *pull;
166 struct ndr_push *push;
167 enum ndr_err_code ndr_err;
168 DATA_BLOB blob;
169 struct dfs_Remove *r;
170
171 call = &ndr_table_netdfs.calls[NDR_DFS_REMOVE];
172
173 r = talloc(talloc_tos(), struct dfs_Remove);
174 if (r == NULL) {
175 return false;
176 }
177
178 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
179 talloc_free(r);
180 return false;
181 }
182
183 pull = ndr_pull_init_blob(&blob, r, NULL);
184 if (pull == NULL) {
185 talloc_free(r);
186 return false;
187 }
188
189 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
190 ndr_err = call->ndr_pull(pull, NDR_IN, r);
191 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
192 talloc_free(r);
193 return false;
194 }
195
196 if (DEBUGLEVEL >= 10) {
197 NDR_PRINT_IN_DEBUG(dfs_Remove, r);
198 }
199
200 r->out.result = _dfs_Remove(p, r);
201
202 if (p->rng_fault_state) {
203 talloc_free(r);
204 /* Return true here, srv_pipe_hnd.c will take care */
205 return true;
206 }
207
208 if (DEBUGLEVEL >= 10) {
209 NDR_PRINT_OUT_DEBUG(dfs_Remove, r);
210 }
211
212 push = ndr_push_init_ctx(r, NULL);
213 if (push == NULL) {
214 talloc_free(r);
215 return false;
216 }
217
218 ndr_err = call->ndr_push(push, NDR_OUT, r);
219 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
220 talloc_free(r);
221 return false;
222 }
223
224 blob = ndr_push_blob(push);
225 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
226 talloc_free(r);
227 return false;
228 }
229
230 talloc_free(r);
231
232 return true;
233}
234
235static bool api_dfs_SetInfo(pipes_struct *p)
236{
237 const struct ndr_interface_call *call;
238 struct ndr_pull *pull;
239 struct ndr_push *push;
240 enum ndr_err_code ndr_err;
241 DATA_BLOB blob;
242 struct dfs_SetInfo *r;
243
244 call = &ndr_table_netdfs.calls[NDR_DFS_SETINFO];
245
246 r = talloc(talloc_tos(), struct dfs_SetInfo);
247 if (r == NULL) {
248 return false;
249 }
250
251 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
252 talloc_free(r);
253 return false;
254 }
255
256 pull = ndr_pull_init_blob(&blob, r, NULL);
257 if (pull == NULL) {
258 talloc_free(r);
259 return false;
260 }
261
262 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
263 ndr_err = call->ndr_pull(pull, NDR_IN, r);
264 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
265 talloc_free(r);
266 return false;
267 }
268
269 if (DEBUGLEVEL >= 10) {
270 NDR_PRINT_IN_DEBUG(dfs_SetInfo, r);
271 }
272
273 r->out.result = _dfs_SetInfo(p, r);
274
275 if (p->rng_fault_state) {
276 talloc_free(r);
277 /* Return true here, srv_pipe_hnd.c will take care */
278 return true;
279 }
280
281 if (DEBUGLEVEL >= 10) {
282 NDR_PRINT_OUT_DEBUG(dfs_SetInfo, r);
283 }
284
285 push = ndr_push_init_ctx(r, NULL);
286 if (push == NULL) {
287 talloc_free(r);
288 return false;
289 }
290
291 ndr_err = call->ndr_push(push, NDR_OUT, r);
292 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
293 talloc_free(r);
294 return false;
295 }
296
297 blob = ndr_push_blob(push);
298 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
299 talloc_free(r);
300 return false;
301 }
302
303 talloc_free(r);
304
305 return true;
306}
307
308static bool api_dfs_GetInfo(pipes_struct *p)
309{
310 const struct ndr_interface_call *call;
311 struct ndr_pull *pull;
312 struct ndr_push *push;
313 enum ndr_err_code ndr_err;
314 DATA_BLOB blob;
315 struct dfs_GetInfo *r;
316
317 call = &ndr_table_netdfs.calls[NDR_DFS_GETINFO];
318
319 r = talloc(talloc_tos(), struct dfs_GetInfo);
320 if (r == NULL) {
321 return false;
322 }
323
324 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
325 talloc_free(r);
326 return false;
327 }
328
329 pull = ndr_pull_init_blob(&blob, r, NULL);
330 if (pull == NULL) {
331 talloc_free(r);
332 return false;
333 }
334
335 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
336 ndr_err = call->ndr_pull(pull, NDR_IN, r);
337 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
338 talloc_free(r);
339 return false;
340 }
341
342 if (DEBUGLEVEL >= 10) {
343 NDR_PRINT_IN_DEBUG(dfs_GetInfo, r);
344 }
345
346 ZERO_STRUCT(r->out);
347 r->out.info = talloc_zero(r, union dfs_Info);
348 if (r->out.info == NULL) {
349 talloc_free(r);
350 return false;
351 }
352
353 r->out.result = _dfs_GetInfo(p, r);
354
355 if (p->rng_fault_state) {
356 talloc_free(r);
357 /* Return true here, srv_pipe_hnd.c will take care */
358 return true;
359 }
360
361 if (DEBUGLEVEL >= 10) {
362 NDR_PRINT_OUT_DEBUG(dfs_GetInfo, r);
363 }
364
365 push = ndr_push_init_ctx(r, NULL);
366 if (push == NULL) {
367 talloc_free(r);
368 return false;
369 }
370
371 ndr_err = call->ndr_push(push, NDR_OUT, r);
372 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
373 talloc_free(r);
374 return false;
375 }
376
377 blob = ndr_push_blob(push);
378 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
379 talloc_free(r);
380 return false;
381 }
382
383 talloc_free(r);
384
385 return true;
386}
387
388static bool api_dfs_Enum(pipes_struct *p)
389{
390 const struct ndr_interface_call *call;
391 struct ndr_pull *pull;
392 struct ndr_push *push;
393 enum ndr_err_code ndr_err;
394 DATA_BLOB blob;
395 struct dfs_Enum *r;
396
397 call = &ndr_table_netdfs.calls[NDR_DFS_ENUM];
398
399 r = talloc(talloc_tos(), struct dfs_Enum);
400 if (r == NULL) {
401 return false;
402 }
403
404 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
405 talloc_free(r);
406 return false;
407 }
408
409 pull = ndr_pull_init_blob(&blob, r, NULL);
410 if (pull == NULL) {
411 talloc_free(r);
412 return false;
413 }
414
415 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
416 ndr_err = call->ndr_pull(pull, NDR_IN, r);
417 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
418 talloc_free(r);
419 return false;
420 }
421
422 if (DEBUGLEVEL >= 10) {
423 NDR_PRINT_IN_DEBUG(dfs_Enum, r);
424 }
425
426 ZERO_STRUCT(r->out);
427 r->out.info = r->in.info;
428 r->out.total = r->in.total;
429 r->out.result = _dfs_Enum(p, r);
430
431 if (p->rng_fault_state) {
432 talloc_free(r);
433 /* Return true here, srv_pipe_hnd.c will take care */
434 return true;
435 }
436
437 if (DEBUGLEVEL >= 10) {
438 NDR_PRINT_OUT_DEBUG(dfs_Enum, r);
439 }
440
441 push = ndr_push_init_ctx(r, NULL);
442 if (push == NULL) {
443 talloc_free(r);
444 return false;
445 }
446
447 ndr_err = call->ndr_push(push, NDR_OUT, r);
448 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
449 talloc_free(r);
450 return false;
451 }
452
453 blob = ndr_push_blob(push);
454 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
455 talloc_free(r);
456 return false;
457 }
458
459 talloc_free(r);
460
461 return true;
462}
463
464static bool api_dfs_Rename(pipes_struct *p)
465{
466 const struct ndr_interface_call *call;
467 struct ndr_pull *pull;
468 struct ndr_push *push;
469 enum ndr_err_code ndr_err;
470 DATA_BLOB blob;
471 struct dfs_Rename *r;
472
473 call = &ndr_table_netdfs.calls[NDR_DFS_RENAME];
474
475 r = talloc(talloc_tos(), struct dfs_Rename);
476 if (r == NULL) {
477 return false;
478 }
479
480 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
481 talloc_free(r);
482 return false;
483 }
484
485 pull = ndr_pull_init_blob(&blob, r, NULL);
486 if (pull == NULL) {
487 talloc_free(r);
488 return false;
489 }
490
491 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
492 ndr_err = call->ndr_pull(pull, NDR_IN, r);
493 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
494 talloc_free(r);
495 return false;
496 }
497
498 if (DEBUGLEVEL >= 10) {
499 NDR_PRINT_IN_DEBUG(dfs_Rename, r);
500 }
501
502 r->out.result = _dfs_Rename(p, r);
503
504 if (p->rng_fault_state) {
505 talloc_free(r);
506 /* Return true here, srv_pipe_hnd.c will take care */
507 return true;
508 }
509
510 if (DEBUGLEVEL >= 10) {
511 NDR_PRINT_OUT_DEBUG(dfs_Rename, r);
512 }
513
514 push = ndr_push_init_ctx(r, NULL);
515 if (push == NULL) {
516 talloc_free(r);
517 return false;
518 }
519
520 ndr_err = call->ndr_push(push, NDR_OUT, r);
521 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
522 talloc_free(r);
523 return false;
524 }
525
526 blob = ndr_push_blob(push);
527 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
528 talloc_free(r);
529 return false;
530 }
531
532 talloc_free(r);
533
534 return true;
535}
536
537static bool api_dfs_Move(pipes_struct *p)
538{
539 const struct ndr_interface_call *call;
540 struct ndr_pull *pull;
541 struct ndr_push *push;
542 enum ndr_err_code ndr_err;
543 DATA_BLOB blob;
544 struct dfs_Move *r;
545
546 call = &ndr_table_netdfs.calls[NDR_DFS_MOVE];
547
548 r = talloc(talloc_tos(), struct dfs_Move);
549 if (r == NULL) {
550 return false;
551 }
552
553 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
554 talloc_free(r);
555 return false;
556 }
557
558 pull = ndr_pull_init_blob(&blob, r, NULL);
559 if (pull == NULL) {
560 talloc_free(r);
561 return false;
562 }
563
564 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
565 ndr_err = call->ndr_pull(pull, NDR_IN, r);
566 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
567 talloc_free(r);
568 return false;
569 }
570
571 if (DEBUGLEVEL >= 10) {
572 NDR_PRINT_IN_DEBUG(dfs_Move, r);
573 }
574
575 r->out.result = _dfs_Move(p, r);
576
577 if (p->rng_fault_state) {
578 talloc_free(r);
579 /* Return true here, srv_pipe_hnd.c will take care */
580 return true;
581 }
582
583 if (DEBUGLEVEL >= 10) {
584 NDR_PRINT_OUT_DEBUG(dfs_Move, r);
585 }
586
587 push = ndr_push_init_ctx(r, NULL);
588 if (push == NULL) {
589 talloc_free(r);
590 return false;
591 }
592
593 ndr_err = call->ndr_push(push, NDR_OUT, r);
594 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
595 talloc_free(r);
596 return false;
597 }
598
599 blob = ndr_push_blob(push);
600 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
601 talloc_free(r);
602 return false;
603 }
604
605 talloc_free(r);
606
607 return true;
608}
609
610static bool api_dfs_ManagerGetConfigInfo(pipes_struct *p)
611{
612 const struct ndr_interface_call *call;
613 struct ndr_pull *pull;
614 struct ndr_push *push;
615 enum ndr_err_code ndr_err;
616 DATA_BLOB blob;
617 struct dfs_ManagerGetConfigInfo *r;
618
619 call = &ndr_table_netdfs.calls[NDR_DFS_MANAGERGETCONFIGINFO];
620
621 r = talloc(talloc_tos(), struct dfs_ManagerGetConfigInfo);
622 if (r == NULL) {
623 return false;
624 }
625
626 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
627 talloc_free(r);
628 return false;
629 }
630
631 pull = ndr_pull_init_blob(&blob, r, NULL);
632 if (pull == NULL) {
633 talloc_free(r);
634 return false;
635 }
636
637 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
638 ndr_err = call->ndr_pull(pull, NDR_IN, r);
639 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
640 talloc_free(r);
641 return false;
642 }
643
644 if (DEBUGLEVEL >= 10) {
645 NDR_PRINT_IN_DEBUG(dfs_ManagerGetConfigInfo, r);
646 }
647
648 r->out.result = _dfs_ManagerGetConfigInfo(p, r);
649
650 if (p->rng_fault_state) {
651 talloc_free(r);
652 /* Return true here, srv_pipe_hnd.c will take care */
653 return true;
654 }
655
656 if (DEBUGLEVEL >= 10) {
657 NDR_PRINT_OUT_DEBUG(dfs_ManagerGetConfigInfo, r);
658 }
659
660 push = ndr_push_init_ctx(r, NULL);
661 if (push == NULL) {
662 talloc_free(r);
663 return false;
664 }
665
666 ndr_err = call->ndr_push(push, NDR_OUT, r);
667 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
668 talloc_free(r);
669 return false;
670 }
671
672 blob = ndr_push_blob(push);
673 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
674 talloc_free(r);
675 return false;
676 }
677
678 talloc_free(r);
679
680 return true;
681}
682
683static bool api_dfs_ManagerSendSiteInfo(pipes_struct *p)
684{
685 const struct ndr_interface_call *call;
686 struct ndr_pull *pull;
687 struct ndr_push *push;
688 enum ndr_err_code ndr_err;
689 DATA_BLOB blob;
690 struct dfs_ManagerSendSiteInfo *r;
691
692 call = &ndr_table_netdfs.calls[NDR_DFS_MANAGERSENDSITEINFO];
693
694 r = talloc(talloc_tos(), struct dfs_ManagerSendSiteInfo);
695 if (r == NULL) {
696 return false;
697 }
698
699 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
700 talloc_free(r);
701 return false;
702 }
703
704 pull = ndr_pull_init_blob(&blob, r, NULL);
705 if (pull == NULL) {
706 talloc_free(r);
707 return false;
708 }
709
710 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
711 ndr_err = call->ndr_pull(pull, NDR_IN, r);
712 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
713 talloc_free(r);
714 return false;
715 }
716
717 if (DEBUGLEVEL >= 10) {
718 NDR_PRINT_IN_DEBUG(dfs_ManagerSendSiteInfo, r);
719 }
720
721 r->out.result = _dfs_ManagerSendSiteInfo(p, r);
722
723 if (p->rng_fault_state) {
724 talloc_free(r);
725 /* Return true here, srv_pipe_hnd.c will take care */
726 return true;
727 }
728
729 if (DEBUGLEVEL >= 10) {
730 NDR_PRINT_OUT_DEBUG(dfs_ManagerSendSiteInfo, r);
731 }
732
733 push = ndr_push_init_ctx(r, NULL);
734 if (push == NULL) {
735 talloc_free(r);
736 return false;
737 }
738
739 ndr_err = call->ndr_push(push, NDR_OUT, r);
740 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
741 talloc_free(r);
742 return false;
743 }
744
745 blob = ndr_push_blob(push);
746 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
747 talloc_free(r);
748 return false;
749 }
750
751 talloc_free(r);
752
753 return true;
754}
755
756static bool api_dfs_AddFtRoot(pipes_struct *p)
757{
758 const struct ndr_interface_call *call;
759 struct ndr_pull *pull;
760 struct ndr_push *push;
761 enum ndr_err_code ndr_err;
762 DATA_BLOB blob;
763 struct dfs_AddFtRoot *r;
764
765 call = &ndr_table_netdfs.calls[NDR_DFS_ADDFTROOT];
766
767 r = talloc(talloc_tos(), struct dfs_AddFtRoot);
768 if (r == NULL) {
769 return false;
770 }
771
772 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
773 talloc_free(r);
774 return false;
775 }
776
777 pull = ndr_pull_init_blob(&blob, r, NULL);
778 if (pull == NULL) {
779 talloc_free(r);
780 return false;
781 }
782
783 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
784 ndr_err = call->ndr_pull(pull, NDR_IN, r);
785 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
786 talloc_free(r);
787 return false;
788 }
789
790 if (DEBUGLEVEL >= 10) {
791 NDR_PRINT_IN_DEBUG(dfs_AddFtRoot, r);
792 }
793
794 ZERO_STRUCT(r->out);
795 r->out.unknown2 = r->in.unknown2;
796 r->out.result = _dfs_AddFtRoot(p, r);
797
798 if (p->rng_fault_state) {
799 talloc_free(r);
800 /* Return true here, srv_pipe_hnd.c will take care */
801 return true;
802 }
803
804 if (DEBUGLEVEL >= 10) {
805 NDR_PRINT_OUT_DEBUG(dfs_AddFtRoot, r);
806 }
807
808 push = ndr_push_init_ctx(r, NULL);
809 if (push == NULL) {
810 talloc_free(r);
811 return false;
812 }
813
814 ndr_err = call->ndr_push(push, NDR_OUT, r);
815 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
816 talloc_free(r);
817 return false;
818 }
819
820 blob = ndr_push_blob(push);
821 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
822 talloc_free(r);
823 return false;
824 }
825
826 talloc_free(r);
827
828 return true;
829}
830
831static bool api_dfs_RemoveFtRoot(pipes_struct *p)
832{
833 const struct ndr_interface_call *call;
834 struct ndr_pull *pull;
835 struct ndr_push *push;
836 enum ndr_err_code ndr_err;
837 DATA_BLOB blob;
838 struct dfs_RemoveFtRoot *r;
839
840 call = &ndr_table_netdfs.calls[NDR_DFS_REMOVEFTROOT];
841
842 r = talloc(talloc_tos(), struct dfs_RemoveFtRoot);
843 if (r == NULL) {
844 return false;
845 }
846
847 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
848 talloc_free(r);
849 return false;
850 }
851
852 pull = ndr_pull_init_blob(&blob, r, NULL);
853 if (pull == NULL) {
854 talloc_free(r);
855 return false;
856 }
857
858 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
859 ndr_err = call->ndr_pull(pull, NDR_IN, r);
860 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
861 talloc_free(r);
862 return false;
863 }
864
865 if (DEBUGLEVEL >= 10) {
866 NDR_PRINT_IN_DEBUG(dfs_RemoveFtRoot, r);
867 }
868
869 ZERO_STRUCT(r->out);
870 r->out.unknown = r->in.unknown;
871 r->out.result = _dfs_RemoveFtRoot(p, r);
872
873 if (p->rng_fault_state) {
874 talloc_free(r);
875 /* Return true here, srv_pipe_hnd.c will take care */
876 return true;
877 }
878
879 if (DEBUGLEVEL >= 10) {
880 NDR_PRINT_OUT_DEBUG(dfs_RemoveFtRoot, r);
881 }
882
883 push = ndr_push_init_ctx(r, NULL);
884 if (push == NULL) {
885 talloc_free(r);
886 return false;
887 }
888
889 ndr_err = call->ndr_push(push, NDR_OUT, r);
890 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
891 talloc_free(r);
892 return false;
893 }
894
895 blob = ndr_push_blob(push);
896 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
897 talloc_free(r);
898 return false;
899 }
900
901 talloc_free(r);
902
903 return true;
904}
905
906static bool api_dfs_AddStdRoot(pipes_struct *p)
907{
908 const struct ndr_interface_call *call;
909 struct ndr_pull *pull;
910 struct ndr_push *push;
911 enum ndr_err_code ndr_err;
912 DATA_BLOB blob;
913 struct dfs_AddStdRoot *r;
914
915 call = &ndr_table_netdfs.calls[NDR_DFS_ADDSTDROOT];
916
917 r = talloc(talloc_tos(), struct dfs_AddStdRoot);
918 if (r == NULL) {
919 return false;
920 }
921
922 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
923 talloc_free(r);
924 return false;
925 }
926
927 pull = ndr_pull_init_blob(&blob, r, NULL);
928 if (pull == NULL) {
929 talloc_free(r);
930 return false;
931 }
932
933 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
934 ndr_err = call->ndr_pull(pull, NDR_IN, r);
935 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
936 talloc_free(r);
937 return false;
938 }
939
940 if (DEBUGLEVEL >= 10) {
941 NDR_PRINT_IN_DEBUG(dfs_AddStdRoot, r);
942 }
943
944 r->out.result = _dfs_AddStdRoot(p, r);
945
946 if (p->rng_fault_state) {
947 talloc_free(r);
948 /* Return true here, srv_pipe_hnd.c will take care */
949 return true;
950 }
951
952 if (DEBUGLEVEL >= 10) {
953 NDR_PRINT_OUT_DEBUG(dfs_AddStdRoot, r);
954 }
955
956 push = ndr_push_init_ctx(r, NULL);
957 if (push == NULL) {
958 talloc_free(r);
959 return false;
960 }
961
962 ndr_err = call->ndr_push(push, NDR_OUT, r);
963 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
964 talloc_free(r);
965 return false;
966 }
967
968 blob = ndr_push_blob(push);
969 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
970 talloc_free(r);
971 return false;
972 }
973
974 talloc_free(r);
975
976 return true;
977}
978
979static bool api_dfs_RemoveStdRoot(pipes_struct *p)
980{
981 const struct ndr_interface_call *call;
982 struct ndr_pull *pull;
983 struct ndr_push *push;
984 enum ndr_err_code ndr_err;
985 DATA_BLOB blob;
986 struct dfs_RemoveStdRoot *r;
987
988 call = &ndr_table_netdfs.calls[NDR_DFS_REMOVESTDROOT];
989
990 r = talloc(talloc_tos(), struct dfs_RemoveStdRoot);
991 if (r == NULL) {
992 return false;
993 }
994
995 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
996 talloc_free(r);
997 return false;
998 }
999
1000 pull = ndr_pull_init_blob(&blob, r, NULL);
1001 if (pull == NULL) {
1002 talloc_free(r);
1003 return false;
1004 }
1005
1006 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1007 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1008 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1009 talloc_free(r);
1010 return false;
1011 }
1012
1013 if (DEBUGLEVEL >= 10) {
1014 NDR_PRINT_IN_DEBUG(dfs_RemoveStdRoot, r);
1015 }
1016
1017 r->out.result = _dfs_RemoveStdRoot(p, r);
1018
1019 if (p->rng_fault_state) {
1020 talloc_free(r);
1021 /* Return true here, srv_pipe_hnd.c will take care */
1022 return true;
1023 }
1024
1025 if (DEBUGLEVEL >= 10) {
1026 NDR_PRINT_OUT_DEBUG(dfs_RemoveStdRoot, r);
1027 }
1028
1029 push = ndr_push_init_ctx(r, NULL);
1030 if (push == NULL) {
1031 talloc_free(r);
1032 return false;
1033 }
1034
1035 ndr_err = call->ndr_push(push, NDR_OUT, r);
1036 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1037 talloc_free(r);
1038 return false;
1039 }
1040
1041 blob = ndr_push_blob(push);
1042 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1043 talloc_free(r);
1044 return false;
1045 }
1046
1047 talloc_free(r);
1048
1049 return true;
1050}
1051
1052static bool api_dfs_ManagerInitialize(pipes_struct *p)
1053{
1054 const struct ndr_interface_call *call;
1055 struct ndr_pull *pull;
1056 struct ndr_push *push;
1057 enum ndr_err_code ndr_err;
1058 DATA_BLOB blob;
1059 struct dfs_ManagerInitialize *r;
1060
1061 call = &ndr_table_netdfs.calls[NDR_DFS_MANAGERINITIALIZE];
1062
1063 r = talloc(talloc_tos(), struct dfs_ManagerInitialize);
1064 if (r == NULL) {
1065 return false;
1066 }
1067
1068 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1069 talloc_free(r);
1070 return false;
1071 }
1072
1073 pull = ndr_pull_init_blob(&blob, r, NULL);
1074 if (pull == NULL) {
1075 talloc_free(r);
1076 return false;
1077 }
1078
1079 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1080 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1081 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1082 talloc_free(r);
1083 return false;
1084 }
1085
1086 if (DEBUGLEVEL >= 10) {
1087 NDR_PRINT_IN_DEBUG(dfs_ManagerInitialize, r);
1088 }
1089
1090 r->out.result = _dfs_ManagerInitialize(p, r);
1091
1092 if (p->rng_fault_state) {
1093 talloc_free(r);
1094 /* Return true here, srv_pipe_hnd.c will take care */
1095 return true;
1096 }
1097
1098 if (DEBUGLEVEL >= 10) {
1099 NDR_PRINT_OUT_DEBUG(dfs_ManagerInitialize, r);
1100 }
1101
1102 push = ndr_push_init_ctx(r, NULL);
1103 if (push == NULL) {
1104 talloc_free(r);
1105 return false;
1106 }
1107
1108 ndr_err = call->ndr_push(push, NDR_OUT, r);
1109 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1110 talloc_free(r);
1111 return false;
1112 }
1113
1114 blob = ndr_push_blob(push);
1115 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1116 talloc_free(r);
1117 return false;
1118 }
1119
1120 talloc_free(r);
1121
1122 return true;
1123}
1124
1125static bool api_dfs_AddStdRootForced(pipes_struct *p)
1126{
1127 const struct ndr_interface_call *call;
1128 struct ndr_pull *pull;
1129 struct ndr_push *push;
1130 enum ndr_err_code ndr_err;
1131 DATA_BLOB blob;
1132 struct dfs_AddStdRootForced *r;
1133
1134 call = &ndr_table_netdfs.calls[NDR_DFS_ADDSTDROOTFORCED];
1135
1136 r = talloc(talloc_tos(), struct dfs_AddStdRootForced);
1137 if (r == NULL) {
1138 return false;
1139 }
1140
1141 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1142 talloc_free(r);
1143 return false;
1144 }
1145
1146 pull = ndr_pull_init_blob(&blob, r, NULL);
1147 if (pull == NULL) {
1148 talloc_free(r);
1149 return false;
1150 }
1151
1152 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1153 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1154 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1155 talloc_free(r);
1156 return false;
1157 }
1158
1159 if (DEBUGLEVEL >= 10) {
1160 NDR_PRINT_IN_DEBUG(dfs_AddStdRootForced, r);
1161 }
1162
1163 r->out.result = _dfs_AddStdRootForced(p, r);
1164
1165 if (p->rng_fault_state) {
1166 talloc_free(r);
1167 /* Return true here, srv_pipe_hnd.c will take care */
1168 return true;
1169 }
1170
1171 if (DEBUGLEVEL >= 10) {
1172 NDR_PRINT_OUT_DEBUG(dfs_AddStdRootForced, r);
1173 }
1174
1175 push = ndr_push_init_ctx(r, NULL);
1176 if (push == NULL) {
1177 talloc_free(r);
1178 return false;
1179 }
1180
1181 ndr_err = call->ndr_push(push, NDR_OUT, r);
1182 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1183 talloc_free(r);
1184 return false;
1185 }
1186
1187 blob = ndr_push_blob(push);
1188 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1189 talloc_free(r);
1190 return false;
1191 }
1192
1193 talloc_free(r);
1194
1195 return true;
1196}
1197
1198static bool api_dfs_GetDcAddress(pipes_struct *p)
1199{
1200 const struct ndr_interface_call *call;
1201 struct ndr_pull *pull;
1202 struct ndr_push *push;
1203 enum ndr_err_code ndr_err;
1204 DATA_BLOB blob;
1205 struct dfs_GetDcAddress *r;
1206
1207 call = &ndr_table_netdfs.calls[NDR_DFS_GETDCADDRESS];
1208
1209 r = talloc(talloc_tos(), struct dfs_GetDcAddress);
1210 if (r == NULL) {
1211 return false;
1212 }
1213
1214 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1215 talloc_free(r);
1216 return false;
1217 }
1218
1219 pull = ndr_pull_init_blob(&blob, r, NULL);
1220 if (pull == NULL) {
1221 talloc_free(r);
1222 return false;
1223 }
1224
1225 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1226 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1227 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1228 talloc_free(r);
1229 return false;
1230 }
1231
1232 if (DEBUGLEVEL >= 10) {
1233 NDR_PRINT_IN_DEBUG(dfs_GetDcAddress, r);
1234 }
1235
1236 ZERO_STRUCT(r->out);
1237 r->out.server_fullname = r->in.server_fullname;
1238 r->out.is_root = r->in.is_root;
1239 r->out.ttl = r->in.ttl;
1240 r->out.result = _dfs_GetDcAddress(p, r);
1241
1242 if (p->rng_fault_state) {
1243 talloc_free(r);
1244 /* Return true here, srv_pipe_hnd.c will take care */
1245 return true;
1246 }
1247
1248 if (DEBUGLEVEL >= 10) {
1249 NDR_PRINT_OUT_DEBUG(dfs_GetDcAddress, r);
1250 }
1251
1252 push = ndr_push_init_ctx(r, NULL);
1253 if (push == NULL) {
1254 talloc_free(r);
1255 return false;
1256 }
1257
1258 ndr_err = call->ndr_push(push, NDR_OUT, r);
1259 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1260 talloc_free(r);
1261 return false;
1262 }
1263
1264 blob = ndr_push_blob(push);
1265 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1266 talloc_free(r);
1267 return false;
1268 }
1269
1270 talloc_free(r);
1271
1272 return true;
1273}
1274
1275static bool api_dfs_SetDcAddress(pipes_struct *p)
1276{
1277 const struct ndr_interface_call *call;
1278 struct ndr_pull *pull;
1279 struct ndr_push *push;
1280 enum ndr_err_code ndr_err;
1281 DATA_BLOB blob;
1282 struct dfs_SetDcAddress *r;
1283
1284 call = &ndr_table_netdfs.calls[NDR_DFS_SETDCADDRESS];
1285
1286 r = talloc(talloc_tos(), struct dfs_SetDcAddress);
1287 if (r == NULL) {
1288 return false;
1289 }
1290
1291 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1292 talloc_free(r);
1293 return false;
1294 }
1295
1296 pull = ndr_pull_init_blob(&blob, r, NULL);
1297 if (pull == NULL) {
1298 talloc_free(r);
1299 return false;
1300 }
1301
1302 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1303 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1304 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1305 talloc_free(r);
1306 return false;
1307 }
1308
1309 if (DEBUGLEVEL >= 10) {
1310 NDR_PRINT_IN_DEBUG(dfs_SetDcAddress, r);
1311 }
1312
1313 r->out.result = _dfs_SetDcAddress(p, r);
1314
1315 if (p->rng_fault_state) {
1316 talloc_free(r);
1317 /* Return true here, srv_pipe_hnd.c will take care */
1318 return true;
1319 }
1320
1321 if (DEBUGLEVEL >= 10) {
1322 NDR_PRINT_OUT_DEBUG(dfs_SetDcAddress, r);
1323 }
1324
1325 push = ndr_push_init_ctx(r, NULL);
1326 if (push == NULL) {
1327 talloc_free(r);
1328 return false;
1329 }
1330
1331 ndr_err = call->ndr_push(push, NDR_OUT, r);
1332 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1333 talloc_free(r);
1334 return false;
1335 }
1336
1337 blob = ndr_push_blob(push);
1338 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1339 talloc_free(r);
1340 return false;
1341 }
1342
1343 talloc_free(r);
1344
1345 return true;
1346}
1347
1348static bool api_dfs_FlushFtTable(pipes_struct *p)
1349{
1350 const struct ndr_interface_call *call;
1351 struct ndr_pull *pull;
1352 struct ndr_push *push;
1353 enum ndr_err_code ndr_err;
1354 DATA_BLOB blob;
1355 struct dfs_FlushFtTable *r;
1356
1357 call = &ndr_table_netdfs.calls[NDR_DFS_FLUSHFTTABLE];
1358
1359 r = talloc(talloc_tos(), struct dfs_FlushFtTable);
1360 if (r == NULL) {
1361 return false;
1362 }
1363
1364 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1365 talloc_free(r);
1366 return false;
1367 }
1368
1369 pull = ndr_pull_init_blob(&blob, r, NULL);
1370 if (pull == NULL) {
1371 talloc_free(r);
1372 return false;
1373 }
1374
1375 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1376 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1377 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1378 talloc_free(r);
1379 return false;
1380 }
1381
1382 if (DEBUGLEVEL >= 10) {
1383 NDR_PRINT_IN_DEBUG(dfs_FlushFtTable, r);
1384 }
1385
1386 r->out.result = _dfs_FlushFtTable(p, r);
1387
1388 if (p->rng_fault_state) {
1389 talloc_free(r);
1390 /* Return true here, srv_pipe_hnd.c will take care */
1391 return true;
1392 }
1393
1394 if (DEBUGLEVEL >= 10) {
1395 NDR_PRINT_OUT_DEBUG(dfs_FlushFtTable, r);
1396 }
1397
1398 push = ndr_push_init_ctx(r, NULL);
1399 if (push == NULL) {
1400 talloc_free(r);
1401 return false;
1402 }
1403
1404 ndr_err = call->ndr_push(push, NDR_OUT, r);
1405 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1406 talloc_free(r);
1407 return false;
1408 }
1409
1410 blob = ndr_push_blob(push);
1411 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1412 talloc_free(r);
1413 return false;
1414 }
1415
1416 talloc_free(r);
1417
1418 return true;
1419}
1420
1421static bool api_dfs_Add2(pipes_struct *p)
1422{
1423 const struct ndr_interface_call *call;
1424 struct ndr_pull *pull;
1425 struct ndr_push *push;
1426 enum ndr_err_code ndr_err;
1427 DATA_BLOB blob;
1428 struct dfs_Add2 *r;
1429
1430 call = &ndr_table_netdfs.calls[NDR_DFS_ADD2];
1431
1432 r = talloc(talloc_tos(), struct dfs_Add2);
1433 if (r == NULL) {
1434 return false;
1435 }
1436
1437 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1438 talloc_free(r);
1439 return false;
1440 }
1441
1442 pull = ndr_pull_init_blob(&blob, r, NULL);
1443 if (pull == NULL) {
1444 talloc_free(r);
1445 return false;
1446 }
1447
1448 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1449 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1450 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1451 talloc_free(r);
1452 return false;
1453 }
1454
1455 if (DEBUGLEVEL >= 10) {
1456 NDR_PRINT_IN_DEBUG(dfs_Add2, r);
1457 }
1458
1459 r->out.result = _dfs_Add2(p, r);
1460
1461 if (p->rng_fault_state) {
1462 talloc_free(r);
1463 /* Return true here, srv_pipe_hnd.c will take care */
1464 return true;
1465 }
1466
1467 if (DEBUGLEVEL >= 10) {
1468 NDR_PRINT_OUT_DEBUG(dfs_Add2, r);
1469 }
1470
1471 push = ndr_push_init_ctx(r, NULL);
1472 if (push == NULL) {
1473 talloc_free(r);
1474 return false;
1475 }
1476
1477 ndr_err = call->ndr_push(push, NDR_OUT, r);
1478 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1479 talloc_free(r);
1480 return false;
1481 }
1482
1483 blob = ndr_push_blob(push);
1484 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1485 talloc_free(r);
1486 return false;
1487 }
1488
1489 talloc_free(r);
1490
1491 return true;
1492}
1493
1494static bool api_dfs_Remove2(pipes_struct *p)
1495{
1496 const struct ndr_interface_call *call;
1497 struct ndr_pull *pull;
1498 struct ndr_push *push;
1499 enum ndr_err_code ndr_err;
1500 DATA_BLOB blob;
1501 struct dfs_Remove2 *r;
1502
1503 call = &ndr_table_netdfs.calls[NDR_DFS_REMOVE2];
1504
1505 r = talloc(talloc_tos(), struct dfs_Remove2);
1506 if (r == NULL) {
1507 return false;
1508 }
1509
1510 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1511 talloc_free(r);
1512 return false;
1513 }
1514
1515 pull = ndr_pull_init_blob(&blob, r, NULL);
1516 if (pull == NULL) {
1517 talloc_free(r);
1518 return false;
1519 }
1520
1521 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1522 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1523 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1524 talloc_free(r);
1525 return false;
1526 }
1527
1528 if (DEBUGLEVEL >= 10) {
1529 NDR_PRINT_IN_DEBUG(dfs_Remove2, r);
1530 }
1531
1532 r->out.result = _dfs_Remove2(p, r);
1533
1534 if (p->rng_fault_state) {
1535 talloc_free(r);
1536 /* Return true here, srv_pipe_hnd.c will take care */
1537 return true;
1538 }
1539
1540 if (DEBUGLEVEL >= 10) {
1541 NDR_PRINT_OUT_DEBUG(dfs_Remove2, r);
1542 }
1543
1544 push = ndr_push_init_ctx(r, NULL);
1545 if (push == NULL) {
1546 talloc_free(r);
1547 return false;
1548 }
1549
1550 ndr_err = call->ndr_push(push, NDR_OUT, r);
1551 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1552 talloc_free(r);
1553 return false;
1554 }
1555
1556 blob = ndr_push_blob(push);
1557 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1558 talloc_free(r);
1559 return false;
1560 }
1561
1562 talloc_free(r);
1563
1564 return true;
1565}
1566
1567static bool api_dfs_EnumEx(pipes_struct *p)
1568{
1569 const struct ndr_interface_call *call;
1570 struct ndr_pull *pull;
1571 struct ndr_push *push;
1572 enum ndr_err_code ndr_err;
1573 DATA_BLOB blob;
1574 struct dfs_EnumEx *r;
1575
1576 call = &ndr_table_netdfs.calls[NDR_DFS_ENUMEX];
1577
1578 r = talloc(talloc_tos(), struct dfs_EnumEx);
1579 if (r == NULL) {
1580 return false;
1581 }
1582
1583 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1584 talloc_free(r);
1585 return false;
1586 }
1587
1588 pull = ndr_pull_init_blob(&blob, r, NULL);
1589 if (pull == NULL) {
1590 talloc_free(r);
1591 return false;
1592 }
1593
1594 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1595 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1596 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1597 talloc_free(r);
1598 return false;
1599 }
1600
1601 if (DEBUGLEVEL >= 10) {
1602 NDR_PRINT_IN_DEBUG(dfs_EnumEx, r);
1603 }
1604
1605 ZERO_STRUCT(r->out);
1606 r->out.info = r->in.info;
1607 r->out.total = r->in.total;
1608 r->out.result = _dfs_EnumEx(p, r);
1609
1610 if (p->rng_fault_state) {
1611 talloc_free(r);
1612 /* Return true here, srv_pipe_hnd.c will take care */
1613 return true;
1614 }
1615
1616 if (DEBUGLEVEL >= 10) {
1617 NDR_PRINT_OUT_DEBUG(dfs_EnumEx, r);
1618 }
1619
1620 push = ndr_push_init_ctx(r, NULL);
1621 if (push == NULL) {
1622 talloc_free(r);
1623 return false;
1624 }
1625
1626 ndr_err = call->ndr_push(push, NDR_OUT, r);
1627 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1628 talloc_free(r);
1629 return false;
1630 }
1631
1632 blob = ndr_push_blob(push);
1633 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1634 talloc_free(r);
1635 return false;
1636 }
1637
1638 talloc_free(r);
1639
1640 return true;
1641}
1642
1643static bool api_dfs_SetInfo2(pipes_struct *p)
1644{
1645 const struct ndr_interface_call *call;
1646 struct ndr_pull *pull;
1647 struct ndr_push *push;
1648 enum ndr_err_code ndr_err;
1649 DATA_BLOB blob;
1650 struct dfs_SetInfo2 *r;
1651
1652 call = &ndr_table_netdfs.calls[NDR_DFS_SETINFO2];
1653
1654 r = talloc(talloc_tos(), struct dfs_SetInfo2);
1655 if (r == NULL) {
1656 return false;
1657 }
1658
1659 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1660 talloc_free(r);
1661 return false;
1662 }
1663
1664 pull = ndr_pull_init_blob(&blob, r, NULL);
1665 if (pull == NULL) {
1666 talloc_free(r);
1667 return false;
1668 }
1669
1670 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1671 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1672 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1673 talloc_free(r);
1674 return false;
1675 }
1676
1677 if (DEBUGLEVEL >= 10) {
1678 NDR_PRINT_IN_DEBUG(dfs_SetInfo2, r);
1679 }
1680
1681 r->out.result = _dfs_SetInfo2(p, r);
1682
1683 if (p->rng_fault_state) {
1684 talloc_free(r);
1685 /* Return true here, srv_pipe_hnd.c will take care */
1686 return true;
1687 }
1688
1689 if (DEBUGLEVEL >= 10) {
1690 NDR_PRINT_OUT_DEBUG(dfs_SetInfo2, r);
1691 }
1692
1693 push = ndr_push_init_ctx(r, NULL);
1694 if (push == NULL) {
1695 talloc_free(r);
1696 return false;
1697 }
1698
1699 ndr_err = call->ndr_push(push, NDR_OUT, r);
1700 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1701 talloc_free(r);
1702 return false;
1703 }
1704
1705 blob = ndr_push_blob(push);
1706 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1707 talloc_free(r);
1708 return false;
1709 }
1710
1711 talloc_free(r);
1712
1713 return true;
1714}
1715
1716
1717/* Tables */
1718static struct api_struct api_netdfs_cmds[] =
1719{
1720 {"DFS_GETMANAGERVERSION", NDR_DFS_GETMANAGERVERSION, api_dfs_GetManagerVersion},
1721 {"DFS_ADD", NDR_DFS_ADD, api_dfs_Add},
1722 {"DFS_REMOVE", NDR_DFS_REMOVE, api_dfs_Remove},
1723 {"DFS_SETINFO", NDR_DFS_SETINFO, api_dfs_SetInfo},
1724 {"DFS_GETINFO", NDR_DFS_GETINFO, api_dfs_GetInfo},
1725 {"DFS_ENUM", NDR_DFS_ENUM, api_dfs_Enum},
1726 {"DFS_RENAME", NDR_DFS_RENAME, api_dfs_Rename},
1727 {"DFS_MOVE", NDR_DFS_MOVE, api_dfs_Move},
1728 {"DFS_MANAGERGETCONFIGINFO", NDR_DFS_MANAGERGETCONFIGINFO, api_dfs_ManagerGetConfigInfo},
1729 {"DFS_MANAGERSENDSITEINFO", NDR_DFS_MANAGERSENDSITEINFO, api_dfs_ManagerSendSiteInfo},
1730 {"DFS_ADDFTROOT", NDR_DFS_ADDFTROOT, api_dfs_AddFtRoot},
1731 {"DFS_REMOVEFTROOT", NDR_DFS_REMOVEFTROOT, api_dfs_RemoveFtRoot},
1732 {"DFS_ADDSTDROOT", NDR_DFS_ADDSTDROOT, api_dfs_AddStdRoot},
1733 {"DFS_REMOVESTDROOT", NDR_DFS_REMOVESTDROOT, api_dfs_RemoveStdRoot},
1734 {"DFS_MANAGERINITIALIZE", NDR_DFS_MANAGERINITIALIZE, api_dfs_ManagerInitialize},
1735 {"DFS_ADDSTDROOTFORCED", NDR_DFS_ADDSTDROOTFORCED, api_dfs_AddStdRootForced},
1736 {"DFS_GETDCADDRESS", NDR_DFS_GETDCADDRESS, api_dfs_GetDcAddress},
1737 {"DFS_SETDCADDRESS", NDR_DFS_SETDCADDRESS, api_dfs_SetDcAddress},
1738 {"DFS_FLUSHFTTABLE", NDR_DFS_FLUSHFTTABLE, api_dfs_FlushFtTable},
1739 {"DFS_ADD2", NDR_DFS_ADD2, api_dfs_Add2},
1740 {"DFS_REMOVE2", NDR_DFS_REMOVE2, api_dfs_Remove2},
1741 {"DFS_ENUMEX", NDR_DFS_ENUMEX, api_dfs_EnumEx},
1742 {"DFS_SETINFO2", NDR_DFS_SETINFO2, api_dfs_SetInfo2},
1743};
1744
1745void netdfs_get_pipe_fns(struct api_struct **fns, int *n_fns)
1746{
1747 *fns = api_netdfs_cmds;
1748 *n_fns = sizeof(api_netdfs_cmds) / sizeof(struct api_struct);
1749}
1750
1751NTSTATUS rpc_netdfs_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
1752{
1753 if (cli->pipes_struct == NULL) {
1754 return NT_STATUS_INVALID_PARAMETER;
1755 }
1756
1757 switch (opnum)
1758 {
1759 case NDR_DFS_GETMANAGERVERSION: {
1760 struct dfs_GetManagerVersion *r = (struct dfs_GetManagerVersion *)_r;
1761 ZERO_STRUCT(r->out);
1762 r->out.version = talloc_zero(mem_ctx, enum dfs_ManagerVersion);
1763 if (r->out.version == NULL) {
1764 return NT_STATUS_NO_MEMORY;
1765 }
1766
1767 _dfs_GetManagerVersion(cli->pipes_struct, r);
1768 return NT_STATUS_OK;
1769 }
1770
1771 case NDR_DFS_ADD: {
1772 struct dfs_Add *r = (struct dfs_Add *)_r;
1773 r->out.result = _dfs_Add(cli->pipes_struct, r);
1774 return NT_STATUS_OK;
1775 }
1776
1777 case NDR_DFS_REMOVE: {
1778 struct dfs_Remove *r = (struct dfs_Remove *)_r;
1779 r->out.result = _dfs_Remove(cli->pipes_struct, r);
1780 return NT_STATUS_OK;
1781 }
1782
1783 case NDR_DFS_SETINFO: {
1784 struct dfs_SetInfo *r = (struct dfs_SetInfo *)_r;
1785 r->out.result = _dfs_SetInfo(cli->pipes_struct, r);
1786 return NT_STATUS_OK;
1787 }
1788
1789 case NDR_DFS_GETINFO: {
1790 struct dfs_GetInfo *r = (struct dfs_GetInfo *)_r;
1791 ZERO_STRUCT(r->out);
1792 r->out.info = talloc_zero(mem_ctx, union dfs_Info);
1793 if (r->out.info == NULL) {
1794 return NT_STATUS_NO_MEMORY;
1795 }
1796
1797 r->out.result = _dfs_GetInfo(cli->pipes_struct, r);
1798 return NT_STATUS_OK;
1799 }
1800
1801 case NDR_DFS_ENUM: {
1802 struct dfs_Enum *r = (struct dfs_Enum *)_r;
1803 ZERO_STRUCT(r->out);
1804 r->out.info = r->in.info;
1805 r->out.total = r->in.total;
1806 r->out.result = _dfs_Enum(cli->pipes_struct, r);
1807 return NT_STATUS_OK;
1808 }
1809
1810 case NDR_DFS_RENAME: {
1811 struct dfs_Rename *r = (struct dfs_Rename *)_r;
1812 r->out.result = _dfs_Rename(cli->pipes_struct, r);
1813 return NT_STATUS_OK;
1814 }
1815
1816 case NDR_DFS_MOVE: {
1817 struct dfs_Move *r = (struct dfs_Move *)_r;
1818 r->out.result = _dfs_Move(cli->pipes_struct, r);
1819 return NT_STATUS_OK;
1820 }
1821
1822 case NDR_DFS_MANAGERGETCONFIGINFO: {
1823 struct dfs_ManagerGetConfigInfo *r = (struct dfs_ManagerGetConfigInfo *)_r;
1824 r->out.result = _dfs_ManagerGetConfigInfo(cli->pipes_struct, r);
1825 return NT_STATUS_OK;
1826 }
1827
1828 case NDR_DFS_MANAGERSENDSITEINFO: {
1829 struct dfs_ManagerSendSiteInfo *r = (struct dfs_ManagerSendSiteInfo *)_r;
1830 r->out.result = _dfs_ManagerSendSiteInfo(cli->pipes_struct, r);
1831 return NT_STATUS_OK;
1832 }
1833
1834 case NDR_DFS_ADDFTROOT: {
1835 struct dfs_AddFtRoot *r = (struct dfs_AddFtRoot *)_r;
1836 ZERO_STRUCT(r->out);
1837 r->out.unknown2 = r->in.unknown2;
1838 r->out.result = _dfs_AddFtRoot(cli->pipes_struct, r);
1839 return NT_STATUS_OK;
1840 }
1841
1842 case NDR_DFS_REMOVEFTROOT: {
1843 struct dfs_RemoveFtRoot *r = (struct dfs_RemoveFtRoot *)_r;
1844 ZERO_STRUCT(r->out);
1845 r->out.unknown = r->in.unknown;
1846 r->out.result = _dfs_RemoveFtRoot(cli->pipes_struct, r);
1847 return NT_STATUS_OK;
1848 }
1849
1850 case NDR_DFS_ADDSTDROOT: {
1851 struct dfs_AddStdRoot *r = (struct dfs_AddStdRoot *)_r;
1852 r->out.result = _dfs_AddStdRoot(cli->pipes_struct, r);
1853 return NT_STATUS_OK;
1854 }
1855
1856 case NDR_DFS_REMOVESTDROOT: {
1857 struct dfs_RemoveStdRoot *r = (struct dfs_RemoveStdRoot *)_r;
1858 r->out.result = _dfs_RemoveStdRoot(cli->pipes_struct, r);
1859 return NT_STATUS_OK;
1860 }
1861
1862 case NDR_DFS_MANAGERINITIALIZE: {
1863 struct dfs_ManagerInitialize *r = (struct dfs_ManagerInitialize *)_r;
1864 r->out.result = _dfs_ManagerInitialize(cli->pipes_struct, r);
1865 return NT_STATUS_OK;
1866 }
1867
1868 case NDR_DFS_ADDSTDROOTFORCED: {
1869 struct dfs_AddStdRootForced *r = (struct dfs_AddStdRootForced *)_r;
1870 r->out.result = _dfs_AddStdRootForced(cli->pipes_struct, r);
1871 return NT_STATUS_OK;
1872 }
1873
1874 case NDR_DFS_GETDCADDRESS: {
1875 struct dfs_GetDcAddress *r = (struct dfs_GetDcAddress *)_r;
1876 ZERO_STRUCT(r->out);
1877 r->out.server_fullname = r->in.server_fullname;
1878 r->out.is_root = r->in.is_root;
1879 r->out.ttl = r->in.ttl;
1880 r->out.result = _dfs_GetDcAddress(cli->pipes_struct, r);
1881 return NT_STATUS_OK;
1882 }
1883
1884 case NDR_DFS_SETDCADDRESS: {
1885 struct dfs_SetDcAddress *r = (struct dfs_SetDcAddress *)_r;
1886 r->out.result = _dfs_SetDcAddress(cli->pipes_struct, r);
1887 return NT_STATUS_OK;
1888 }
1889
1890 case NDR_DFS_FLUSHFTTABLE: {
1891 struct dfs_FlushFtTable *r = (struct dfs_FlushFtTable *)_r;
1892 r->out.result = _dfs_FlushFtTable(cli->pipes_struct, r);
1893 return NT_STATUS_OK;
1894 }
1895
1896 case NDR_DFS_ADD2: {
1897 struct dfs_Add2 *r = (struct dfs_Add2 *)_r;
1898 r->out.result = _dfs_Add2(cli->pipes_struct, r);
1899 return NT_STATUS_OK;
1900 }
1901
1902 case NDR_DFS_REMOVE2: {
1903 struct dfs_Remove2 *r = (struct dfs_Remove2 *)_r;
1904 r->out.result = _dfs_Remove2(cli->pipes_struct, r);
1905 return NT_STATUS_OK;
1906 }
1907
1908 case NDR_DFS_ENUMEX: {
1909 struct dfs_EnumEx *r = (struct dfs_EnumEx *)_r;
1910 ZERO_STRUCT(r->out);
1911 r->out.info = r->in.info;
1912 r->out.total = r->in.total;
1913 r->out.result = _dfs_EnumEx(cli->pipes_struct, r);
1914 return NT_STATUS_OK;
1915 }
1916
1917 case NDR_DFS_SETINFO2: {
1918 struct dfs_SetInfo2 *r = (struct dfs_SetInfo2 *)_r;
1919 r->out.result = _dfs_SetInfo2(cli->pipes_struct, r);
1920 return NT_STATUS_OK;
1921 }
1922
1923 default:
1924 return NT_STATUS_NOT_IMPLEMENTED;
1925 }
1926}
1927
1928NTSTATUS rpc_netdfs_init(void)
1929{
1930 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "netdfs", "netdfs", &ndr_table_netdfs, api_netdfs_cmds, sizeof(api_netdfs_cmds) / sizeof(struct api_struct));
1931}
Note: See TracBrowser for help on using the repository browser.