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

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

Samba 3.5.0: Initial import
File size: 15.1 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_epmapper.h"
8
9static bool api_epm_Insert(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 epm_Insert *r;
17
18 call = &ndr_table_epmapper.calls[NDR_EPM_INSERT];
19
20 r = talloc(talloc_tos(), struct epm_Insert);
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(epm_Insert, r);
45 }
46
47 r->out.result = _epm_Insert(p, r);
48
49 if (p->rng_fault_state) {
50 talloc_free(r);
51 /* Return true here, srv_pipe_hnd.c will take care */
52 return true;
53 }
54
55 if (DEBUGLEVEL >= 10) {
56 NDR_PRINT_OUT_DEBUG(epm_Insert, r);
57 }
58
59 push = ndr_push_init_ctx(r, NULL);
60 if (push == NULL) {
61 talloc_free(r);
62 return false;
63 }
64
65 ndr_err = call->ndr_push(push, NDR_OUT, r);
66 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
67 talloc_free(r);
68 return false;
69 }
70
71 blob = ndr_push_blob(push);
72 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
73 talloc_free(r);
74 return false;
75 }
76
77 talloc_free(r);
78
79 return true;
80}
81
82static bool api_epm_Delete(pipes_struct *p)
83{
84 const struct ndr_interface_call *call;
85 struct ndr_pull *pull;
86 struct ndr_push *push;
87 enum ndr_err_code ndr_err;
88 DATA_BLOB blob;
89 struct epm_Delete *r;
90
91 call = &ndr_table_epmapper.calls[NDR_EPM_DELETE];
92
93 r = talloc(talloc_tos(), struct epm_Delete);
94 if (r == NULL) {
95 return false;
96 }
97
98 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
99 talloc_free(r);
100 return false;
101 }
102
103 pull = ndr_pull_init_blob(&blob, r, NULL);
104 if (pull == NULL) {
105 talloc_free(r);
106 return false;
107 }
108
109 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
110 ndr_err = call->ndr_pull(pull, NDR_IN, r);
111 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
112 talloc_free(r);
113 return false;
114 }
115
116 if (DEBUGLEVEL >= 10) {
117 NDR_PRINT_IN_DEBUG(epm_Delete, r);
118 }
119
120 r->out.result = _epm_Delete(p, r);
121
122 if (p->rng_fault_state) {
123 talloc_free(r);
124 /* Return true here, srv_pipe_hnd.c will take care */
125 return true;
126 }
127
128 if (DEBUGLEVEL >= 10) {
129 NDR_PRINT_OUT_DEBUG(epm_Delete, r);
130 }
131
132 push = ndr_push_init_ctx(r, NULL);
133 if (push == NULL) {
134 talloc_free(r);
135 return false;
136 }
137
138 ndr_err = call->ndr_push(push, NDR_OUT, r);
139 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
140 talloc_free(r);
141 return false;
142 }
143
144 blob = ndr_push_blob(push);
145 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
146 talloc_free(r);
147 return false;
148 }
149
150 talloc_free(r);
151
152 return true;
153}
154
155static bool api_epm_Lookup(pipes_struct *p)
156{
157 const struct ndr_interface_call *call;
158 struct ndr_pull *pull;
159 struct ndr_push *push;
160 enum ndr_err_code ndr_err;
161 DATA_BLOB blob;
162 struct epm_Lookup *r;
163
164 call = &ndr_table_epmapper.calls[NDR_EPM_LOOKUP];
165
166 r = talloc(talloc_tos(), struct epm_Lookup);
167 if (r == NULL) {
168 return false;
169 }
170
171 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
172 talloc_free(r);
173 return false;
174 }
175
176 pull = ndr_pull_init_blob(&blob, r, NULL);
177 if (pull == NULL) {
178 talloc_free(r);
179 return false;
180 }
181
182 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
183 ndr_err = call->ndr_pull(pull, NDR_IN, r);
184 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
185 talloc_free(r);
186 return false;
187 }
188
189 if (DEBUGLEVEL >= 10) {
190 NDR_PRINT_IN_DEBUG(epm_Lookup, r);
191 }
192
193 ZERO_STRUCT(r->out);
194 r->out.entry_handle = r->in.entry_handle;
195 r->out.num_ents = talloc_zero(r, uint32_t);
196 if (r->out.num_ents == NULL) {
197 talloc_free(r);
198 return false;
199 }
200
201 r->out.entries = talloc_zero_array(r, struct epm_entry_t, r->in.max_ents);
202 if (r->out.entries == NULL) {
203 talloc_free(r);
204 return false;
205 }
206
207 r->out.result = _epm_Lookup(p, r);
208
209 if (p->rng_fault_state) {
210 talloc_free(r);
211 /* Return true here, srv_pipe_hnd.c will take care */
212 return true;
213 }
214
215 if (DEBUGLEVEL >= 10) {
216 NDR_PRINT_OUT_DEBUG(epm_Lookup, r);
217 }
218
219 push = ndr_push_init_ctx(r, NULL);
220 if (push == NULL) {
221 talloc_free(r);
222 return false;
223 }
224
225 ndr_err = call->ndr_push(push, NDR_OUT, r);
226 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
227 talloc_free(r);
228 return false;
229 }
230
231 blob = ndr_push_blob(push);
232 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
233 talloc_free(r);
234 return false;
235 }
236
237 talloc_free(r);
238
239 return true;
240}
241
242static bool api_epm_Map(pipes_struct *p)
243{
244 const struct ndr_interface_call *call;
245 struct ndr_pull *pull;
246 struct ndr_push *push;
247 enum ndr_err_code ndr_err;
248 DATA_BLOB blob;
249 struct epm_Map *r;
250
251 call = &ndr_table_epmapper.calls[NDR_EPM_MAP];
252
253 r = talloc(talloc_tos(), struct epm_Map);
254 if (r == NULL) {
255 return false;
256 }
257
258 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
259 talloc_free(r);
260 return false;
261 }
262
263 pull = ndr_pull_init_blob(&blob, r, NULL);
264 if (pull == NULL) {
265 talloc_free(r);
266 return false;
267 }
268
269 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
270 ndr_err = call->ndr_pull(pull, NDR_IN, r);
271 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
272 talloc_free(r);
273 return false;
274 }
275
276 if (DEBUGLEVEL >= 10) {
277 NDR_PRINT_IN_DEBUG(epm_Map, r);
278 }
279
280 ZERO_STRUCT(r->out);
281 r->out.entry_handle = r->in.entry_handle;
282 r->out.num_towers = talloc_zero(r, uint32_t);
283 if (r->out.num_towers == NULL) {
284 talloc_free(r);
285 return false;
286 }
287
288 r->out.towers = talloc_zero_array(r, struct epm_twr_p_t, r->in.max_towers);
289 if (r->out.towers == NULL) {
290 talloc_free(r);
291 return false;
292 }
293
294 r->out.result = _epm_Map(p, r);
295
296 if (p->rng_fault_state) {
297 talloc_free(r);
298 /* Return true here, srv_pipe_hnd.c will take care */
299 return true;
300 }
301
302 if (DEBUGLEVEL >= 10) {
303 NDR_PRINT_OUT_DEBUG(epm_Map, r);
304 }
305
306 push = ndr_push_init_ctx(r, NULL);
307 if (push == NULL) {
308 talloc_free(r);
309 return false;
310 }
311
312 ndr_err = call->ndr_push(push, NDR_OUT, r);
313 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
314 talloc_free(r);
315 return false;
316 }
317
318 blob = ndr_push_blob(push);
319 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
320 talloc_free(r);
321 return false;
322 }
323
324 talloc_free(r);
325
326 return true;
327}
328
329static bool api_epm_LookupHandleFree(pipes_struct *p)
330{
331 const struct ndr_interface_call *call;
332 struct ndr_pull *pull;
333 struct ndr_push *push;
334 enum ndr_err_code ndr_err;
335 DATA_BLOB blob;
336 struct epm_LookupHandleFree *r;
337
338 call = &ndr_table_epmapper.calls[NDR_EPM_LOOKUPHANDLEFREE];
339
340 r = talloc(talloc_tos(), struct epm_LookupHandleFree);
341 if (r == NULL) {
342 return false;
343 }
344
345 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
346 talloc_free(r);
347 return false;
348 }
349
350 pull = ndr_pull_init_blob(&blob, r, NULL);
351 if (pull == NULL) {
352 talloc_free(r);
353 return false;
354 }
355
356 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
357 ndr_err = call->ndr_pull(pull, NDR_IN, r);
358 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
359 talloc_free(r);
360 return false;
361 }
362
363 if (DEBUGLEVEL >= 10) {
364 NDR_PRINT_IN_DEBUG(epm_LookupHandleFree, r);
365 }
366
367 ZERO_STRUCT(r->out);
368 r->out.entry_handle = r->in.entry_handle;
369 r->out.result = _epm_LookupHandleFree(p, r);
370
371 if (p->rng_fault_state) {
372 talloc_free(r);
373 /* Return true here, srv_pipe_hnd.c will take care */
374 return true;
375 }
376
377 if (DEBUGLEVEL >= 10) {
378 NDR_PRINT_OUT_DEBUG(epm_LookupHandleFree, r);
379 }
380
381 push = ndr_push_init_ctx(r, NULL);
382 if (push == NULL) {
383 talloc_free(r);
384 return false;
385 }
386
387 ndr_err = call->ndr_push(push, NDR_OUT, r);
388 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
389 talloc_free(r);
390 return false;
391 }
392
393 blob = ndr_push_blob(push);
394 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
395 talloc_free(r);
396 return false;
397 }
398
399 talloc_free(r);
400
401 return true;
402}
403
404static bool api_epm_InqObject(pipes_struct *p)
405{
406 const struct ndr_interface_call *call;
407 struct ndr_pull *pull;
408 struct ndr_push *push;
409 enum ndr_err_code ndr_err;
410 DATA_BLOB blob;
411 struct epm_InqObject *r;
412
413 call = &ndr_table_epmapper.calls[NDR_EPM_INQOBJECT];
414
415 r = talloc(talloc_tos(), struct epm_InqObject);
416 if (r == NULL) {
417 return false;
418 }
419
420 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
421 talloc_free(r);
422 return false;
423 }
424
425 pull = ndr_pull_init_blob(&blob, r, NULL);
426 if (pull == NULL) {
427 talloc_free(r);
428 return false;
429 }
430
431 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
432 ndr_err = call->ndr_pull(pull, NDR_IN, r);
433 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
434 talloc_free(r);
435 return false;
436 }
437
438 if (DEBUGLEVEL >= 10) {
439 NDR_PRINT_IN_DEBUG(epm_InqObject, r);
440 }
441
442 r->out.result = _epm_InqObject(p, r);
443
444 if (p->rng_fault_state) {
445 talloc_free(r);
446 /* Return true here, srv_pipe_hnd.c will take care */
447 return true;
448 }
449
450 if (DEBUGLEVEL >= 10) {
451 NDR_PRINT_OUT_DEBUG(epm_InqObject, r);
452 }
453
454 push = ndr_push_init_ctx(r, NULL);
455 if (push == NULL) {
456 talloc_free(r);
457 return false;
458 }
459
460 ndr_err = call->ndr_push(push, NDR_OUT, r);
461 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
462 talloc_free(r);
463 return false;
464 }
465
466 blob = ndr_push_blob(push);
467 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
468 talloc_free(r);
469 return false;
470 }
471
472 talloc_free(r);
473
474 return true;
475}
476
477static bool api_epm_MgmtDelete(pipes_struct *p)
478{
479 const struct ndr_interface_call *call;
480 struct ndr_pull *pull;
481 struct ndr_push *push;
482 enum ndr_err_code ndr_err;
483 DATA_BLOB blob;
484 struct epm_MgmtDelete *r;
485
486 call = &ndr_table_epmapper.calls[NDR_EPM_MGMTDELETE];
487
488 r = talloc(talloc_tos(), struct epm_MgmtDelete);
489 if (r == NULL) {
490 return false;
491 }
492
493 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
494 talloc_free(r);
495 return false;
496 }
497
498 pull = ndr_pull_init_blob(&blob, r, NULL);
499 if (pull == NULL) {
500 talloc_free(r);
501 return false;
502 }
503
504 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
505 ndr_err = call->ndr_pull(pull, NDR_IN, r);
506 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
507 talloc_free(r);
508 return false;
509 }
510
511 if (DEBUGLEVEL >= 10) {
512 NDR_PRINT_IN_DEBUG(epm_MgmtDelete, r);
513 }
514
515 r->out.result = _epm_MgmtDelete(p, r);
516
517 if (p->rng_fault_state) {
518 talloc_free(r);
519 /* Return true here, srv_pipe_hnd.c will take care */
520 return true;
521 }
522
523 if (DEBUGLEVEL >= 10) {
524 NDR_PRINT_OUT_DEBUG(epm_MgmtDelete, r);
525 }
526
527 push = ndr_push_init_ctx(r, NULL);
528 if (push == NULL) {
529 talloc_free(r);
530 return false;
531 }
532
533 ndr_err = call->ndr_push(push, NDR_OUT, r);
534 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
535 talloc_free(r);
536 return false;
537 }
538
539 blob = ndr_push_blob(push);
540 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
541 talloc_free(r);
542 return false;
543 }
544
545 talloc_free(r);
546
547 return true;
548}
549
550static bool api_epm_MapAuth(pipes_struct *p)
551{
552 const struct ndr_interface_call *call;
553 struct ndr_pull *pull;
554 struct ndr_push *push;
555 enum ndr_err_code ndr_err;
556 DATA_BLOB blob;
557 struct epm_MapAuth *r;
558
559 call = &ndr_table_epmapper.calls[NDR_EPM_MAPAUTH];
560
561 r = talloc(talloc_tos(), struct epm_MapAuth);
562 if (r == NULL) {
563 return false;
564 }
565
566 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
567 talloc_free(r);
568 return false;
569 }
570
571 pull = ndr_pull_init_blob(&blob, r, NULL);
572 if (pull == NULL) {
573 talloc_free(r);
574 return false;
575 }
576
577 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
578 ndr_err = call->ndr_pull(pull, NDR_IN, r);
579 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
580 talloc_free(r);
581 return false;
582 }
583
584 if (DEBUGLEVEL >= 10) {
585 NDR_PRINT_IN_DEBUG(epm_MapAuth, r);
586 }
587
588 r->out.result = _epm_MapAuth(p, r);
589
590 if (p->rng_fault_state) {
591 talloc_free(r);
592 /* Return true here, srv_pipe_hnd.c will take care */
593 return true;
594 }
595
596 if (DEBUGLEVEL >= 10) {
597 NDR_PRINT_OUT_DEBUG(epm_MapAuth, r);
598 }
599
600 push = ndr_push_init_ctx(r, NULL);
601 if (push == NULL) {
602 talloc_free(r);
603 return false;
604 }
605
606 ndr_err = call->ndr_push(push, NDR_OUT, r);
607 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
608 talloc_free(r);
609 return false;
610 }
611
612 blob = ndr_push_blob(push);
613 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
614 talloc_free(r);
615 return false;
616 }
617
618 talloc_free(r);
619
620 return true;
621}
622
623
624/* Tables */
625static struct api_struct api_epmapper_cmds[] =
626{
627 {"EPM_INSERT", NDR_EPM_INSERT, api_epm_Insert},
628 {"EPM_DELETE", NDR_EPM_DELETE, api_epm_Delete},
629 {"EPM_LOOKUP", NDR_EPM_LOOKUP, api_epm_Lookup},
630 {"EPM_MAP", NDR_EPM_MAP, api_epm_Map},
631 {"EPM_LOOKUPHANDLEFREE", NDR_EPM_LOOKUPHANDLEFREE, api_epm_LookupHandleFree},
632 {"EPM_INQOBJECT", NDR_EPM_INQOBJECT, api_epm_InqObject},
633 {"EPM_MGMTDELETE", NDR_EPM_MGMTDELETE, api_epm_MgmtDelete},
634 {"EPM_MAPAUTH", NDR_EPM_MAPAUTH, api_epm_MapAuth},
635};
636
637void epmapper_get_pipe_fns(struct api_struct **fns, int *n_fns)
638{
639 *fns = api_epmapper_cmds;
640 *n_fns = sizeof(api_epmapper_cmds) / sizeof(struct api_struct);
641}
642
643NTSTATUS rpc_epmapper_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
644{
645 if (cli->pipes_struct == NULL) {
646 return NT_STATUS_INVALID_PARAMETER;
647 }
648
649 switch (opnum)
650 {
651 case NDR_EPM_INSERT: {
652 struct epm_Insert *r = (struct epm_Insert *)_r;
653 r->out.result = _epm_Insert(cli->pipes_struct, r);
654 return NT_STATUS_OK;
655 }
656
657 case NDR_EPM_DELETE: {
658 struct epm_Delete *r = (struct epm_Delete *)_r;
659 r->out.result = _epm_Delete(cli->pipes_struct, r);
660 return NT_STATUS_OK;
661 }
662
663 case NDR_EPM_LOOKUP: {
664 struct epm_Lookup *r = (struct epm_Lookup *)_r;
665 ZERO_STRUCT(r->out);
666 r->out.entry_handle = r->in.entry_handle;
667 r->out.num_ents = talloc_zero(mem_ctx, uint32_t);
668 if (r->out.num_ents == NULL) {
669 return NT_STATUS_NO_MEMORY;
670 }
671
672 r->out.entries = talloc_zero_array(mem_ctx, struct epm_entry_t, r->in.max_ents);
673 if (r->out.entries == NULL) {
674 return NT_STATUS_NO_MEMORY;
675 }
676
677 r->out.result = _epm_Lookup(cli->pipes_struct, r);
678 return NT_STATUS_OK;
679 }
680
681 case NDR_EPM_MAP: {
682 struct epm_Map *r = (struct epm_Map *)_r;
683 ZERO_STRUCT(r->out);
684 r->out.entry_handle = r->in.entry_handle;
685 r->out.num_towers = talloc_zero(mem_ctx, uint32_t);
686 if (r->out.num_towers == NULL) {
687 return NT_STATUS_NO_MEMORY;
688 }
689
690 r->out.towers = talloc_zero_array(mem_ctx, struct epm_twr_p_t, r->in.max_towers);
691 if (r->out.towers == NULL) {
692 return NT_STATUS_NO_MEMORY;
693 }
694
695 r->out.result = _epm_Map(cli->pipes_struct, r);
696 return NT_STATUS_OK;
697 }
698
699 case NDR_EPM_LOOKUPHANDLEFREE: {
700 struct epm_LookupHandleFree *r = (struct epm_LookupHandleFree *)_r;
701 ZERO_STRUCT(r->out);
702 r->out.entry_handle = r->in.entry_handle;
703 r->out.result = _epm_LookupHandleFree(cli->pipes_struct, r);
704 return NT_STATUS_OK;
705 }
706
707 case NDR_EPM_INQOBJECT: {
708 struct epm_InqObject *r = (struct epm_InqObject *)_r;
709 r->out.result = _epm_InqObject(cli->pipes_struct, r);
710 return NT_STATUS_OK;
711 }
712
713 case NDR_EPM_MGMTDELETE: {
714 struct epm_MgmtDelete *r = (struct epm_MgmtDelete *)_r;
715 r->out.result = _epm_MgmtDelete(cli->pipes_struct, r);
716 return NT_STATUS_OK;
717 }
718
719 case NDR_EPM_MAPAUTH: {
720 struct epm_MapAuth *r = (struct epm_MapAuth *)_r;
721 r->out.result = _epm_MapAuth(cli->pipes_struct, r);
722 return NT_STATUS_OK;
723 }
724
725 default:
726 return NT_STATUS_NOT_IMPLEMENTED;
727 }
728}
729
730NTSTATUS rpc_epmapper_init(void)
731{
732 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "epmapper", "epmapper", &ndr_table_epmapper, api_epmapper_cmds, sizeof(api_epmapper_cmds) / sizeof(struct api_struct));
733}
Note: See TracBrowser for help on using the repository browser.