Share RPC binding string utility functions.
[samba.git] / source3 / librpc / gen_ndr / srv_epmapper.c
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
9 static 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
82 static 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
155 static 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
242 static 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
329 static 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
404 static 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
477 static 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
550 static 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 */
625 static 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
637 void 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
643 NTSTATUS rpc_epmapper_init(void)
644 {
645         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "epmapper", "epmapper", &ndr_table_epmapper.syntax_id, api_epmapper_cmds, sizeof(api_epmapper_cmds) / sizeof(struct api_struct));
646 }