1 ###################################################
2 # client calls generator
3 # Copyright tridge@samba.org 2003
4 # Copyright jelmer@samba.org 2005-2006
5 # released under the GNU GPL
7 package Parse
::Pidl
::Samba4
::NDR
::Client
;
11 @EXPORT_OK = qw(Parse);
13 use Parse
::Pidl
qw(fatal warning error);
14 use Parse
::Pidl
::Util
qw(has_property ParseExpr);
15 use Parse
::Pidl
::Typelist
qw(mapTypeName);
16 use Parse
::Pidl
::Samba4
qw(choose_header is_intree DeclLong);
17 use Parse
::Pidl
::Samba4
::Header
qw(GenerateFunctionInEnv GenerateFunctionOutEnv);
19 use vars
qw($VERSION);
24 sub indent($) { my ($self) = @_; $self->{tabs}.="\t"; }
25 sub deindent($) { my ($self) = @_; $self->{tabs} = substr($self->{tabs}, 1); }
26 sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= $txt ? "$self->{tabs}$txt\n" : "\n"; }
27 sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; }
28 sub pidl_both($$) { my ($self, $txt) = @_; $self->{hdr} .= "$txt\n"; $self->{res_hdr} .= "$txt\n"; }
29 sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); }
34 my $nt = int((length($s)+1)/8);
36 my $ns = (length($s)-$lt);
37 return "\t"x($nt)." "x($ns);
43 my $self = { res => "", res_hdr => "", tabs => "" };
47 sub ParseFunction_r_State($$$$)
49 my ($self, $if, $fn, $name) = @_;
52 $self->pidl("struct dcerpc_$name\_r_state {");
54 $self->pidl("TALLOC_CTX *out_mem_ctx;");
58 $self->pidl("static void dcerpc_$name\_r_done(struct tevent_req *subreq);");
62 sub ParseFunction_r_Send($$$$)
64 my ($self, $if, $fn, $name) = @_;
67 my $proto = "struct tevent_req *dcerpc_$name\_r_send(TALLOC_CTX *mem_ctx,\n";
68 $proto .= "\tstruct tevent_context *ev,\n",
69 $proto .= "\tstruct dcerpc_binding_handle *h,\n",
70 $proto .= "\tstruct $name *r)";
72 $self->fn_declare($proto);
77 $self->pidl("struct tevent_req *req;");
78 $self->pidl("struct dcerpc_$name\_r_state *state;");
79 $self->pidl("struct tevent_req *subreq;");
82 $self->pidl("req = tevent_req_create(mem_ctx, &state,");
83 $self->pidl("\t\t\tstruct dcerpc_$name\_r_state);");
84 $self->pidl("if (req == NULL) {");
86 $self->pidl("return NULL;");
92 foreach (@{$fn->{ELEMENTS}}) {
93 if (grep(/out/, @{$_->{DIRECTION}})) {
99 if ($out_params > 0) {
100 $self->pidl("state->out_mem_ctx = talloc_new(state);");
101 $self->pidl("if (tevent_req_nomem(state->out_mem_ctx, req)) {");
103 $self->pidl("return tevent_req_post(req, ev);");
107 $submem = "state->out_mem_ctx";
109 $self->pidl("state->out_mem_ctx = NULL;");
113 $self->pidl("subreq = dcerpc_binding_handle_call_send(state, ev, h,");
114 $self->pidl("\t\tNULL, &ndr_table_$if->{NAME},");
115 $self->pidl("\t\tNDR_$uname, $submem, r);");
116 $self->pidl("if (tevent_req_nomem(subreq, req)) {");
118 $self->pidl("return tevent_req_post(req, ev);");
121 $self->pidl("tevent_req_set_callback(subreq, dcerpc_$name\_r_done, req);");
124 $self->pidl("return req;");
130 sub ParseFunction_r_Done($$$$)
132 my ($self, $if, $fn, $name) = @_;
133 my $uname = uc $name;
135 my $proto = "static void dcerpc_$name\_r_done(struct tevent_req *subreq)";
137 $self->pidl("$proto");
141 $self->pidl("struct tevent_req *req =");
142 $self->pidl("\ttevent_req_callback_data(subreq,");
143 $self->pidl("\tstruct tevent_req);");
144 $self->pidl("NTSTATUS status;");
147 $self->pidl("status = dcerpc_binding_handle_call_recv(subreq);");
148 $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
150 $self->pidl("tevent_req_nterror(req, status);");
151 $self->pidl("return;");
156 $self->pidl("tevent_req_done(req);");
162 sub ParseFunction_r_Recv($$$$)
164 my ($if, $fn, $name) = @_;
165 my ($self, $if, $fn, $name) = @_;
166 my $uname = uc $name;
168 my $proto = "NTSTATUS dcerpc_$name\_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)";
170 $self->fn_declare($proto);
175 $self->pidl("struct dcerpc_$name\_r_state *state =");
176 $self->pidl("\ttevent_req_data(req,");
177 $self->pidl("\tstruct dcerpc_$name\_r_state);");
178 $self->pidl("NTSTATUS status;");
181 $self->pidl("if (tevent_req_is_nterror(req, &status)) {");
183 $self->pidl("tevent_req_received(req);");
184 $self->pidl("return status;");
189 $self->pidl("talloc_steal(mem_ctx, state->out_mem_ctx);");
192 $self->pidl("tevent_req_received(req);");
193 $self->pidl("return NT_STATUS_OK;");
199 sub ParseFunction_r_Sync($$$$)
201 my ($if, $fn, $name) = @_;
202 my ($self, $if, $fn, $name) = @_;
203 my $uname = uc $name;
205 my $proto = "NTSTATUS dcerpc_$name\_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct $name *r)";
207 $self->fn_declare($proto);
211 $self->pidl("NTSTATUS status;");
214 $self->pidl("status = dcerpc_binding_handle_call(h,");
215 $self->pidl("\t\tNULL, &ndr_table_$if->{NAME},");
216 $self->pidl("\t\tNDR_$uname, mem_ctx, r);");
218 $self->pidl("return status;");
225 sub ParseFunction_Compat_Sync($$$$)
227 my ($if, $fn, $name) = @_;
228 my ($self, $if, $fn, $name) = @_;
229 my $uname = uc $name;
231 my $proto = "NTSTATUS dcerpc_$name\_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct $name *r)";
233 $self->pidl_hdr("#ifdef DCERPC_CALL_$uname\_COMPAT");
234 $self->pidl_hdr("#define dcerpc_$name(p, m, r) dcerpc_$name\_compat(p, m, r)");
235 $self->pidl_hdr("#endif /* DCERPC_CALL_$uname\_COMPAT */");
237 $self->fn_declare($proto);
240 $self->pidl("NTSTATUS status;");
243 $self->pidl("status = dcerpc_$name\_r(p->binding_handle, mem_ctx, r);");
246 $self->pidl("if (NT_STATUS_IS_RPC(status)) {");
248 $self->pidl("status = NT_STATUS_NET_WRITE_FAULT;");
253 if (defined($fn->{RETURN_TYPE}) and $fn->{RETURN_TYPE} eq "NTSTATUS") {
254 $self->pidl("if (NT_STATUS_IS_OK(status)) {");
256 $self->pidl("status = r->out.result;");
262 $self->pidl("return status;");
269 sub ElementDirection($)
273 return "[in,out]" if (has_property($e, "in") and has_property($e, "out"));
274 return "[in]" if (has_property($e, "in"));
275 return "[out]" if (has_property($e, "out"));
279 sub HeaderProperties($$)
281 my($props,$ignores) = @_;
284 foreach my $d (keys %{$props}) {
285 next if (grep(/^$d$/, @$ignores));
286 if($props->{$d} ne "1") {
287 $ret.= "$d($props->{$d}),";
294 return "[" . substr($ret, 0, -1) . "]";
298 sub ParseCopyArgument($$$$$)
300 my ($self, $fn, $e, $r, $i) = @_;
301 my $l = $e->{LEVELS}[0];
303 if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED} == 1) {
304 $self->pidl("memcpy(${r}$e->{NAME}, ${i}$e->{NAME}, sizeof(${r}$e->{NAME}));");
306 $self->pidl("${r}$e->{NAME} = ${i}$e->{NAME};");
310 sub ParseInvalidResponse($$)
312 my ($self, $type) = @_;
314 if ($type eq "sync") {
315 $self->pidl("return NT_STATUS_INVALID_NETWORK_RESPONSE;");
316 } elsif ($type eq "async") {
317 $self->pidl("tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);");
318 $self->pidl("return;");
320 die("ParseInvalidResponse($type)");
324 sub ParseOutputArgument($$$$$$)
326 my ($self, $fn, $e, $r, $o, $invalid_response_type) = @_;
329 if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY") {
330 fatal($e->{ORIGINAL}, "[out] argument is not a pointer or array");
334 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
336 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
337 $self->pidl("if ($o$e->{NAME} && ${r}out.$e->{NAME}) {");
342 if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") {
343 # This is a call to GenerateFunctionInEnv intentionally.
344 # Since the data is being copied into a user-provided data
345 # structure, the user should be able to know the size beforehand
346 # to allocate a structure of the right size.
347 my $in_env = GenerateFunctionInEnv($fn, $r);
348 my $out_env = GenerateFunctionOutEnv($fn, $r);
349 my $l = $e->{LEVELS}[$level];
352 if (grep(/in/, @{$e->{DIRECTION}})) {
353 $in_var = ParseExpr($e->{NAME}, $in_env, $e->{ORIGINAL});
355 my $out_var = ParseExpr($e->{NAME}, $out_env, $e->{ORIGINAL});
357 my $in_size_is = undef;
358 my $out_size_is = undef;
359 my $out_length_is = undef;
361 my $avail_len = undef;
362 my $needed_len = undef;
366 my $copy_len_var = "_copy_len_$e->{NAME}";
367 $self->pidl("size_t $copy_len_var;");
369 unless (defined($l->{SIZE_IS})) {
370 fatal($e->{ORIGINAL}, "no size known for [out] array `$e->{NAME}'");
372 $in_size_is = ParseExpr($l->{SIZE_IS}, $in_env, $e->{ORIGINAL});
373 $out_size_is = ParseExpr($l->{SIZE_IS}, $out_env, $e->{ORIGINAL});
374 $out_length_is = $out_size_is;
375 if (defined($l->{LENGTH_IS})) {
376 $out_length_is = ParseExpr($l->{LENGTH_IS}, $out_env, $e->{ORIGINAL});
378 if (has_property($e, "charset")) {
379 if (defined($in_var)) {
380 $avail_len = "ndr_charset_length($in_var, CH_UNIX)";
382 $avail_len = $out_length_is;
384 $needed_len = "ndr_charset_length($out_var, CH_UNIX)";
388 if ($out_size_is ne $in_size_is) {
389 $self->pidl("if (($out_size_is) > ($in_size_is)) {");
391 $self->ParseInvalidResponse($invalid_response_type);
395 if ($out_length_is ne $out_size_is) {
396 $self->pidl("if (($out_length_is) > ($out_size_is)) {");
398 $self->ParseInvalidResponse($invalid_response_type);
402 if (defined($needed_len)) {
403 $self->pidl("$copy_len_var = $needed_len;");
404 $self->pidl("if ($copy_len_var > $avail_len) {");
406 $self->ParseInvalidResponse($invalid_response_type);
410 $self->pidl("$copy_len_var = $out_length_is;");
413 if (has_property($e, "charset")) {
414 $self->pidl("memcpy(discard_const_p(uint8_t *, $o$e->{NAME}), $out_var, $copy_len_var * sizeof(*$o$e->{NAME}));");
416 $self->pidl("memcpy($o$e->{NAME}, $out_var, $copy_len_var * sizeof(*$o$e->{NAME}));");
422 $self->pidl("*$o$e->{NAME} = *${r}out.$e->{NAME};");
425 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
426 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
433 sub ParseFunction_State($$$$)
435 my ($self, $if, $fn, $name) = @_;
437 my $state_str = "struct dcerpc_$name\_state";
438 my $done_fn = "dcerpc_$name\_done";
440 $self->pidl("$state_str {");
442 $self->pidl("struct $name orig;");
443 $self->pidl("struct $name tmp;");
444 $self->pidl("TALLOC_CTX *out_mem_ctx;");
448 $self->pidl("static void $done_fn(struct tevent_req *subreq);");
452 sub ParseFunction_Send($$$$)
454 my ($self, $if, $fn, $name) = @_;
457 my $state_str = "struct dcerpc_$name\_state";
458 my $done_fn = "dcerpc_$name\_done";
459 my $out_mem_ctx = "dcerpc_$name\_out_memory";
460 my $fn_str = "struct tevent_req *dcerpc_$name\_send";
461 my $pad = genpad($fn_str);
463 $fn_args .= "TALLOC_CTX *mem_ctx";
464 $fn_args .= ",\n" . $pad . "struct tevent_context *ev";
465 $fn_args .= ",\n" . $pad . "struct dcerpc_binding_handle *h";
467 foreach (@{$fn->{ELEMENTS}}) {
468 my $dir = ElementDirection($_);
469 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
470 $fn_args .= ",\n" . $pad . DeclLong($_, "_") . " /* $dir $prop */";
473 $self->fn_declare("$fn_str($fn_args)");
476 $self->pidl("struct tevent_req *req;");
477 $self->pidl("$state_str *state;");
478 $self->pidl("struct tevent_req *subreq;");
480 $self->pidl("req = tevent_req_create(mem_ctx, &state,");
481 $self->pidl("\t\t\t$state_str);");
482 $self->pidl("if (req == NULL) {");
484 $self->pidl("return NULL;");
487 $self->pidl("state->out_mem_ctx = NULL;");
490 $self->pidl("/* In parameters */");
491 foreach my $e (@{$fn->{ELEMENTS}}) {
492 next unless (grep(/in/, @{$e->{DIRECTION}}));
494 $self->ParseCopyArgument($fn, $e, "state->orig.in.", "_");
499 $self->pidl("/* Out parameters */");
500 foreach my $e (@{$fn->{ELEMENTS}}) {
501 next unless grep(/out/, @{$e->{DIRECTION}});
503 $self->ParseCopyArgument($fn, $e, "state->orig.out.", "_");
508 if (defined($fn->{RETURN_TYPE})) {
509 $self->pidl("/* Result */");
510 $self->pidl("ZERO_STRUCT(state->orig.out.result);");
514 if ($out_params > 0) {
515 $self->pidl("state->out_mem_ctx = talloc_named_const(state, 0,");
516 $self->pidl("\t\t \"$out_mem_ctx\");");
517 $self->pidl("if (tevent_req_nomem(state->out_mem_ctx, req)) {");
519 $self->pidl("return tevent_req_post(req, ev);");
525 $self->pidl("/* make a temporary copy, that we pass to the dispatch function */");
526 $self->pidl("state->tmp = state->orig;");
529 $self->pidl("subreq = dcerpc_$name\_r_send(state, ev, h, &state->tmp);");
530 $self->pidl("if (tevent_req_nomem(subreq, req)) {");
532 $self->pidl("return tevent_req_post(req, ev);");
535 $self->pidl("tevent_req_set_callback(subreq, $done_fn, req);");
536 $self->pidl("return req;");
542 sub ParseFunction_Done($$$$)
544 my ($self, $if, $fn, $name) = @_;
546 my $state_str = "struct dcerpc_$name\_state";
547 my $done_fn = "dcerpc_$name\_done";
549 $self->pidl("static void $done_fn(struct tevent_req *subreq)");
552 $self->pidl("struct tevent_req *req = tevent_req_callback_data(");
553 $self->pidl("\tsubreq, struct tevent_req);");
554 $self->pidl("$state_str *state = tevent_req_data(");
555 $self->pidl("\treq, $state_str);");
556 $self->pidl("NTSTATUS status;");
557 $self->pidl("TALLOC_CTX *mem_ctx;");
560 $self->pidl("if (state->out_mem_ctx) {");
562 $self->pidl("mem_ctx = state->out_mem_ctx;");
564 $self->pidl("} else {");
566 $self->pidl("mem_ctx = state;");
571 $self->pidl("status = dcerpc_$name\_r_recv(subreq, mem_ctx);");
572 $self->pidl("TALLOC_FREE(subreq);");
573 $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
575 $self->pidl("tevent_req_nterror(req, status);");
576 $self->pidl("return;");
581 $self->pidl("/* Copy out parameters */");
582 foreach my $e (@{$fn->{ELEMENTS}}) {
583 next unless (grep(/out/, @{$e->{DIRECTION}}));
585 $self->ParseOutputArgument($fn, $e,
592 if (defined($fn->{RETURN_TYPE})) {
593 $self->pidl("/* Copy result */");
594 $self->pidl("state->orig.out.result = state->tmp.out.result;");
598 $self->pidl("/* Reset temporary structure */");
599 $self->pidl("ZERO_STRUCT(state->tmp);");
602 $self->pidl("tevent_req_done(req);");
608 sub ParseFunction_Recv($$$$)
610 my ($self, $if, $fn, $name) = @_;
613 my $state_str = "struct dcerpc_$name\_state";
614 my $fn_str = "NTSTATUS dcerpc_$name\_recv";
615 my $pad = genpad($fn_str);
617 $fn_args .= "struct tevent_req *req,\n" . $pad . "TALLOC_CTX *mem_ctx";
619 if (defined($fn->{RETURN_TYPE})) {
620 $fn_args .= ",\n" . $pad . mapTypeName($fn->{RETURN_TYPE}). " *result";
623 $self->fn_declare("$fn_str($fn_args)");
626 $self->pidl("$state_str *state = tevent_req_data(");
627 $self->pidl("\treq, $state_str);");
628 $self->pidl("NTSTATUS status;");
630 $self->pidl("if (tevent_req_is_nterror(req, &status)) {");
632 $self->pidl("tevent_req_received(req);");
633 $self->pidl("return status;");
638 $self->pidl("/* Steal possible out parameters to the callers context */");
639 $self->pidl("talloc_steal(mem_ctx, state->out_mem_ctx);");
642 if (defined($fn->{RETURN_TYPE})) {
643 $self->pidl("/* Return result */");
644 $self->pidl("*result = state->orig.out.result;");
648 $self->pidl("tevent_req_received(req);");
649 $self->pidl("return NT_STATUS_OK;");
655 sub ParseFunction_Sync($$$$)
657 my ($self, $if, $fn, $name) = @_;
659 my $uname = uc $name;
661 my $fn_str = "NTSTATUS dcerpc_$name";
662 my $pad = genpad($fn_str);
664 $fn_args .= "struct dcerpc_binding_handle *h,\n" . $pad . "TALLOC_CTX *mem_ctx";
666 foreach (@{$fn->{ELEMENTS}}) {
667 my $dir = ElementDirection($_);
668 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
669 $fn_args .= ",\n" . $pad . DeclLong($_, "_") . " /* $dir $prop */";
672 if (defined($fn->{RETURN_TYPE})) {
673 $fn_args .= ",\n" . $pad . mapTypeName($fn->{RETURN_TYPE}). " *result";
676 $self->pidl_hdr("#ifndef DCERPC_CALL_$uname\_COMPAT");
677 $self->fn_declare("$fn_str($fn_args)");
678 $self->pidl_hdr("#endif /* DCERPC_CALL_$uname\_COMPAT */");
681 $self->pidl("struct $name r;");
682 $self->pidl("NTSTATUS status;");
685 $self->pidl("/* In parameters */");
686 foreach my $e (@{$fn->{ELEMENTS}}) {
687 next unless (grep(/in/, @{$e->{DIRECTION}}));
689 $self->ParseCopyArgument($fn, $e, "r.in.", "_");
693 $self->pidl("status = dcerpc_$name\_r(h, mem_ctx, &r);");
694 $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
696 $self->pidl("return status;");
701 $self->pidl("/* Return variables */");
702 foreach my $e (@{$fn->{ELEMENTS}}) {
703 next unless (grep(/out/, @{$e->{DIRECTION}}));
705 $self->ParseOutputArgument($fn, $e, "r.", "_", "sync");
709 $self->pidl("/* Return result */");
710 if ($fn->{RETURN_TYPE}) {
711 $self->pidl("*result = r.out.result;");
715 $self->pidl("return NT_STATUS_OK;");
722 #####################################################################
724 sub ParseFunction($$$)
726 my ($self, $if, $fn) = @_;
728 $self->ParseFunction_r_State($if, $fn, $fn->{NAME});
729 $self->ParseFunction_r_Send($if, $fn, $fn->{NAME});
730 $self->ParseFunction_r_Done($if, $fn, $fn->{NAME});
731 $self->ParseFunction_r_Recv($if, $fn, $fn->{NAME});
732 $self->ParseFunction_r_Sync($if, $fn, $fn->{NAME});
734 $self->ParseFunction_Compat_Sync($if, $fn, $fn->{NAME});
736 foreach my $e (@{$fn->{ELEMENTS}}) {
737 next unless (grep(/out/, @{$e->{DIRECTION}}));
739 my $reason = "is not a pointer or array";
741 # TODO: make this fatal at NDR level
742 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
743 if ($e->{LEVELS}[1]->{TYPE} eq "DATA" and
744 $e->{LEVELS}[1]->{DATA_TYPE} eq "string") {
745 $reason = "is a pointer to type 'string'";
746 } elsif ($e->{LEVELS}[1]->{TYPE} eq "ARRAY" and
747 not defined($e->{LEVELS}[1]->{SIZE_IS})) {
748 $reason = "is a pointer to an unsized array";
753 if ($e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
754 if (not defined($e->{LEVELS}[0]->{SIZE_IS})) {
755 $reason = "is an unsized array";
761 $self->pidl_both("/*");
762 $self->pidl_both(" * The following functions are skipped because");
763 $self->pidl_both(" * an [out] argument $e->{NAME} $reason:");
764 $self->pidl_both(" *");
765 $self->pidl_both(" * dcerpc_$fn->{NAME}_send()");
766 $self->pidl_both(" * dcerpc_$fn->{NAME}_recv()");
767 $self->pidl_both(" * dcerpc_$fn->{NAME}()");
768 $self->pidl_both(" */");
769 $self->pidl_both("");
771 error($e->{ORIGINAL}, "$fn->{NAME}: [out] argument '$e->{NAME}' $reason, skip client functions");
775 $self->ParseFunction_State($if, $fn, $fn->{NAME});
776 $self->ParseFunction_Send($if, $fn, $fn->{NAME});
777 $self->ParseFunction_Done($if, $fn, $fn->{NAME});
778 $self->ParseFunction_Recv($if, $fn, $fn->{NAME});
779 $self->ParseFunction_Sync($if, $fn, $fn->{NAME});
786 #####################################################################
787 # parse the interface definitions
788 sub ParseInterface($$)
790 my ($self, $if) = @_;
791 my $ifu = uc($if->{NAME});
793 $self->pidl_hdr("#ifndef _HEADER_RPC_$if->{NAME}");
794 $self->pidl_hdr("#define _HEADER_RPC_$if->{NAME}");
797 if (defined $if->{PROPERTIES}->{uuid}) {
798 $self->pidl_hdr("extern const struct ndr_interface_table ndr_table_$if->{NAME};");
802 $self->pidl_hdr("#ifdef DCERPC_IFACE_$ifu\_COMPAT");
803 foreach my $fn (@{$if->{FUNCTIONS}}) {
804 next if has_property($fn, "noopnum");
805 next if has_property($fn, "todo");
806 my $fnu = uc($fn->{NAME});
807 $self->pidl_hdr("#define DCERPC_CALL_$fnu\_COMPAT 1");
809 $self->pidl_hdr("#endif /* DCERPC_IFACE_$ifu\_COMPAT */");
812 $self->pidl("/* $if->{NAME} - client functions generated by pidl */");
815 foreach my $fn (@{$if->{FUNCTIONS}}) {
816 next if defined($done{$fn->{NAME}});
817 next if has_property($fn, "noopnum");
818 next if has_property($fn, "todo");
819 $self->ParseFunction($if, $fn);
820 $done{$fn->{NAME}} = 1;
823 $self->pidl_hdr("#endif /* _HEADER_RPC_$if->{NAME} */");
828 my($self,$ndr,$header,$ndr_header,$client_header) = @_;
830 $self->pidl("/* client functions auto-generated by pidl */");
833 $self->pidl("#include \"includes.h\"");
835 $self->pidl("#ifndef _GNU_SOURCE");
836 $self->pidl("#define _GNU_SOURCE");
837 $self->pidl("#endif");
838 $self->pidl("#include <stdio.h>");
839 $self->pidl("#include <stdbool.h>");
840 $self->pidl("#include <stdlib.h>");
841 $self->pidl("#include <stdint.h>");
842 $self->pidl("#include <stdarg.h>");
843 $self->pidl("#include <string.h>");
844 $self->pidl("#include <core/ntstatus.h>");
846 $self->pidl("#include <tevent.h>");
847 $self->pidl(choose_header("lib/util/tevent_ntstatus.h", "util/tevent_ntstatus.h")."");
848 $self->pidl("#include \"$ndr_header\"");
849 $self->pidl("#include \"$client_header\"");
852 $self->pidl_hdr(choose_header("librpc/rpc/dcerpc.h", "dcerpc.h")."");
853 $self->pidl_hdr("#include \"$header\"");
855 foreach my $x (@{$ndr}) {
856 ($x->{TYPE} eq "INTERFACE") && $self->ParseInterface($x);
859 return ($self->{res},$self->{res_hdr});