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 genpad);
15 use Parse::Pidl::NDR qw(ContainsPipe);
16 use Parse::Pidl::Typelist qw(mapTypeName);
17 use Parse::Pidl::Samba4 qw(choose_header is_intree DeclLong);
18 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv);
20 use vars qw($VERSION);
25 sub indent($) { my ($self) = @_; $self->{tabs}.="\t"; }
26 sub deindent($) { my ($self) = @_; $self->{tabs} = substr($self->{tabs}, 1); }
27 sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= $txt ? "$self->{tabs}$txt\n" : "\n"; }
28 sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; }
29 sub pidl_both($$) { my ($self, $txt) = @_; $self->{hdr} .= "$txt\n"; $self->{res_hdr} .= "$txt\n"; }
30 sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); }
35 my $self = { res => "", res_hdr => "", tabs => "" };
39 sub ParseFunctionHasPipes($$)
43 foreach my $e (@{$fn->{ELEMENTS}}) {
44 return 1 if ContainsPipe($e, $e->{LEVELS}[0]);
50 sub ParseFunction_r_State($$$$)
52 my ($self, $if, $fn, $name) = @_;
55 $self->pidl("struct dcerpc_$name\_r_state {");
57 $self->pidl("TALLOC_CTX *out_mem_ctx;");
61 $self->pidl("static void dcerpc_$name\_r_done(struct tevent_req *subreq);");
65 sub ParseFunction_r_Send($$$$)
67 my ($self, $if, $fn, $name) = @_;
70 my $proto = "struct tevent_req *dcerpc_$name\_r_send(TALLOC_CTX *mem_ctx,\n";
71 $proto .= "\tstruct tevent_context *ev,\n",
72 $proto .= "\tstruct dcerpc_binding_handle *h,\n",
73 $proto .= "\tstruct $name *r)";
75 $self->fn_declare($proto);
80 $self->pidl("struct tevent_req *req;");
81 $self->pidl("struct dcerpc_$name\_r_state *state;");
82 $self->pidl("struct tevent_req *subreq;");
85 $self->pidl("req = tevent_req_create(mem_ctx, &state,");
86 $self->pidl("\t\t\tstruct dcerpc_$name\_r_state);");
87 $self->pidl("if (req == NULL) {");
89 $self->pidl("return NULL;");
95 foreach my $e (@{$fn->{ELEMENTS}}) {
96 next unless grep(/out/, @{$e->{DIRECTION}});
97 next if ContainsPipe($e, $e->{LEVELS}[0]);
103 if ($out_params > 0) {
104 $self->pidl("state->out_mem_ctx = talloc_new(state);");
105 $self->pidl("if (tevent_req_nomem(state->out_mem_ctx, req)) {");
107 $self->pidl("return tevent_req_post(req, ev);");
110 $submem = "state->out_mem_ctx";
112 $self->pidl("state->out_mem_ctx = NULL;");
117 $self->pidl("subreq = dcerpc_binding_handle_call_send(state, ev, h,");
118 $self->pidl("\t\tNULL, &ndr_table_$if->{NAME},");
119 $self->pidl("\t\tNDR_$uname, $submem, r);");
120 $self->pidl("if (tevent_req_nomem(subreq, req)) {");
122 $self->pidl("return tevent_req_post(req, ev);");
125 $self->pidl("tevent_req_set_callback(subreq, dcerpc_$name\_r_done, req);");
128 $self->pidl("return req;");
134 sub ParseFunction_r_Done($$$$)
136 my ($self, $if, $fn, $name) = @_;
137 my $uname = uc $name;
139 my $proto = "static void dcerpc_$name\_r_done(struct tevent_req *subreq)";
141 $self->pidl("$proto");
145 $self->pidl("struct tevent_req *req =");
146 $self->pidl("\ttevent_req_callback_data(subreq,");
147 $self->pidl("\tstruct tevent_req);");
148 $self->pidl("NTSTATUS status;");
151 $self->pidl("status = dcerpc_binding_handle_call_recv(subreq);");
152 $self->pidl("TALLOC_FREE(subreq);");
153 $self->pidl("if (tevent_req_nterror(req, status)) {");
155 $self->pidl("return;");
160 $self->pidl("tevent_req_done(req);");
166 sub ParseFunction_r_Recv($$$$)
168 my ($self, $if, $fn, $name) = @_;
169 my $uname = uc $name;
171 my $proto = "NTSTATUS dcerpc_$name\_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)";
173 $self->fn_declare($proto);
178 $self->pidl("struct dcerpc_$name\_r_state *state =");
179 $self->pidl("\ttevent_req_data(req,");
180 $self->pidl("\tstruct dcerpc_$name\_r_state);");
181 $self->pidl("NTSTATUS status;");
184 $self->pidl("if (tevent_req_is_nterror(req, &status)) {");
186 $self->pidl("tevent_req_received(req);");
187 $self->pidl("return status;");
192 $self->pidl("talloc_steal(mem_ctx, state->out_mem_ctx);");
195 $self->pidl("tevent_req_received(req);");
196 $self->pidl("return NT_STATUS_OK;");
202 sub ParseFunction_r_Sync($$$$)
204 my ($self, $if, $fn, $name) = @_;
205 my $uname = uc $name;
207 if ($self->ParseFunctionHasPipes($fn)) {
208 $self->pidl_both("/*");
209 $self->pidl_both(" * The following function is skipped because");
210 $self->pidl_both(" * it uses pipes:");
211 $self->pidl_both(" *");
212 $self->pidl_both(" * dcerpc_$name\_r()");
213 $self->pidl_both(" */");
214 $self->pidl_both("");
218 my $proto = "NTSTATUS dcerpc_$name\_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct $name *r)";
220 $self->fn_declare($proto);
224 $self->pidl("NTSTATUS status;");
227 $self->pidl("status = dcerpc_binding_handle_call(h,");
228 $self->pidl("\t\tNULL, &ndr_table_$if->{NAME},");
229 $self->pidl("\t\tNDR_$uname, mem_ctx, r);");
231 $self->pidl("return status;");
238 sub ElementDirection($)
242 return "[in,out]" if (has_property($e, "in") and has_property($e, "out"));
243 return "[in]" if (has_property($e, "in"));
244 return "[out]" if (has_property($e, "out"));
248 sub HeaderProperties($$)
250 my($props,$ignores) = @_;
253 foreach my $d (sort(keys %{$props})) {
254 next if (grep(/^$d$/, @$ignores));
255 if($props->{$d} ne "1") {
256 $ret.= "$d($props->{$d}),";
263 return "[" . substr($ret, 0, -1) . "]";
267 sub ParseCopyArgument($$$$$)
269 my ($self, $fn, $e, $r, $i) = @_;
270 my $l = $e->{LEVELS}[0];
272 if ($l->{TYPE} eq "ARRAY" and $l->{IS_FIXED} == 1) {
273 $self->pidl("memcpy(${r}$e->{NAME}, ${i}$e->{NAME}, sizeof(${r}$e->{NAME}));");
275 $self->pidl("${r}$e->{NAME} = ${i}$e->{NAME};");
279 sub ParseInvalidResponse($$)
281 my ($self, $type) = @_;
283 if ($type eq "sync") {
284 $self->pidl("return NT_STATUS_INVALID_NETWORK_RESPONSE;");
285 } elsif ($type eq "async") {
286 $self->pidl("tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);");
287 $self->pidl("return;");
289 die("ParseInvalidResponse($type)");
293 sub ParseOutputArgument($$$$$$)
295 my ($self, $fn, $e, $r, $o, $invalid_response_type) = @_;
298 if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY") {
299 fatal($e->{ORIGINAL}, "[out] argument is not a pointer or array");
303 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
305 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
306 $self->pidl("if ($o$e->{NAME} && ${r}out.$e->{NAME}) {");
311 if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") {
312 # This is a call to GenerateFunctionInEnv intentionally.
313 # Since the data is being copied into a user-provided data
314 # structure, the user should be able to know the size beforehand
315 # to allocate a structure of the right size.
316 my $in_env = GenerateFunctionInEnv($fn, $r);
317 my $out_env = GenerateFunctionOutEnv($fn, $r);
318 my $l = $e->{LEVELS}[$level];
321 if (grep(/in/, @{$e->{DIRECTION}})) {
322 $in_var = ParseExpr($e->{NAME}, $in_env, $e->{ORIGINAL});
324 my $out_var = ParseExpr($e->{NAME}, $out_env, $e->{ORIGINAL});
326 my $in_size_is = undef;
327 my $out_size_is = undef;
328 my $out_length_is = undef;
330 my $avail_len = undef;
331 my $needed_len = undef;
335 my $copy_len_var = "_copy_len_$e->{NAME}";
336 $self->pidl("size_t $copy_len_var;");
338 if (not defined($l->{SIZE_IS})) {
339 if (not $l->{IS_ZERO_TERMINATED}) {
340 fatal($e->{ORIGINAL}, "no size known for [out] array `$e->{NAME}'");
342 if (has_property($e, "charset")) {
343 $avail_len = "ndr_charset_length($in_var, CH_UNIX)";
344 $needed_len = "ndr_charset_length($out_var, CH_UNIX)";
346 $avail_len = "ndr_string_length($in_var, sizeof(*$in_var))";
347 $needed_len = "ndr_string_length($out_var, sizeof(*$out_var))";
353 $in_size_is = ParseExpr($l->{SIZE_IS}, $in_env, $e->{ORIGINAL});
354 $out_size_is = ParseExpr($l->{SIZE_IS}, $out_env, $e->{ORIGINAL});
355 $out_length_is = $out_size_is;
356 if (defined($l->{LENGTH_IS})) {
357 $out_length_is = ParseExpr($l->{LENGTH_IS}, $out_env, $e->{ORIGINAL});
359 if (has_property($e, "charset")) {
360 if (defined($in_var)) {
361 $avail_len = "ndr_charset_length($in_var, CH_UNIX)";
363 $avail_len = $out_length_is;
365 $needed_len = "ndr_charset_length($out_var, CH_UNIX)";
369 if ($out_size_is ne $in_size_is) {
370 $self->pidl("if (($out_size_is) > ($in_size_is)) {");
372 $self->ParseInvalidResponse($invalid_response_type);
376 if ($out_length_is ne $out_size_is) {
377 $self->pidl("if (($out_length_is) > ($out_size_is)) {");
379 $self->ParseInvalidResponse($invalid_response_type);
383 if (defined($needed_len)) {
384 $self->pidl("$copy_len_var = $needed_len;");
385 $self->pidl("if ($copy_len_var > $avail_len) {");
387 $self->ParseInvalidResponse($invalid_response_type);
391 $self->pidl("$copy_len_var = $out_length_is;");
394 my $dest_ptr = "$o$e->{NAME}";
395 my $elem_size = "sizeof(*$dest_ptr)";
396 $self->pidl("if ($dest_ptr != $out_var) {");
398 if (has_property($e, "charset")) {
399 $dest_ptr = "discard_const_p(uint8_t *, $dest_ptr)";
401 $self->pidl("memcpy($dest_ptr, $out_var, $copy_len_var * $elem_size);");
408 $self->pidl("*$o$e->{NAME} = *${r}out.$e->{NAME};");
411 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
412 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
419 sub ParseFunction_State($$$$)
421 my ($self, $if, $fn, $name) = @_;
423 my $state_str = "struct dcerpc_$name\_state";
424 my $done_fn = "dcerpc_$name\_done";
426 $self->pidl("$state_str {");
428 $self->pidl("struct $name orig;");
429 $self->pidl("struct $name tmp;");
430 $self->pidl("TALLOC_CTX *out_mem_ctx;");
434 $self->pidl("static void $done_fn(struct tevent_req *subreq);");
438 sub ParseFunction_Send($$$$)
440 my ($self, $if, $fn, $name) = @_;
443 my $state_str = "struct dcerpc_$name\_state";
444 my $done_fn = "dcerpc_$name\_done";
445 my $out_mem_ctx = "dcerpc_$name\_out_memory";
446 my $fn_str = "struct tevent_req *dcerpc_$name\_send";
447 my $pad = genpad($fn_str);
449 $fn_args .= "TALLOC_CTX *mem_ctx";
450 $fn_args .= ",\n" . $pad . "struct tevent_context *ev";
451 $fn_args .= ",\n" . $pad . "struct dcerpc_binding_handle *h";
453 foreach (@{$fn->{ELEMENTS}}) {
454 my $dir = ElementDirection($_);
455 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
456 $fn_args .= ",\n" . $pad . DeclLong($_, "_") . " /* $dir $prop */";
459 $self->fn_declare("$fn_str($fn_args)");
462 $self->pidl("struct tevent_req *req;");
463 $self->pidl("$state_str *state;");
464 $self->pidl("struct tevent_req *subreq;");
466 $self->pidl("req = tevent_req_create(mem_ctx, &state,");
467 $self->pidl("\t\t\t$state_str);");
468 $self->pidl("if (req == NULL) {");
470 $self->pidl("return NULL;");
473 $self->pidl("state->out_mem_ctx = NULL;");
476 $self->pidl("/* In parameters */");
477 foreach my $e (@{$fn->{ELEMENTS}}) {
478 next unless (grep(/in/, @{$e->{DIRECTION}}));
480 $self->ParseCopyArgument($fn, $e, "state->orig.in.", "_");
485 $self->pidl("/* Out parameters */");
486 foreach my $e (@{$fn->{ELEMENTS}}) {
487 next unless grep(/out/, @{$e->{DIRECTION}});
489 $self->ParseCopyArgument($fn, $e, "state->orig.out.", "_");
491 next if ContainsPipe($e, $e->{LEVELS}[0]);
497 if (defined($fn->{RETURN_TYPE})) {
498 $self->pidl("/* Result */");
499 $self->pidl("NDR_ZERO_STRUCT(state->orig.out.result);");
503 if ($out_params > 0) {
504 $self->pidl("state->out_mem_ctx = talloc_named_const(state, 0,");
505 $self->pidl("\t\t \"$out_mem_ctx\");");
506 $self->pidl("if (tevent_req_nomem(state->out_mem_ctx, req)) {");
508 $self->pidl("return tevent_req_post(req, ev);");
514 $self->pidl("/* make a temporary copy, that we pass to the dispatch function */");
515 $self->pidl("state->tmp = state->orig;");
518 $self->pidl("subreq = dcerpc_$name\_r_send(state, ev, h, &state->tmp);");
519 $self->pidl("if (tevent_req_nomem(subreq, req)) {");
521 $self->pidl("return tevent_req_post(req, ev);");
524 $self->pidl("tevent_req_set_callback(subreq, $done_fn, req);");
525 $self->pidl("return req;");
531 sub ParseFunction_Done($$$$)
533 my ($self, $if, $fn, $name) = @_;
535 my $state_str = "struct dcerpc_$name\_state";
536 my $done_fn = "dcerpc_$name\_done";
538 $self->pidl("static void $done_fn(struct tevent_req *subreq)");
541 $self->pidl("struct tevent_req *req = tevent_req_callback_data(");
542 $self->pidl("\tsubreq, struct tevent_req);");
543 $self->pidl("$state_str *state = tevent_req_data(");
544 $self->pidl("\treq, $state_str);");
545 $self->pidl("NTSTATUS status;");
546 $self->pidl("TALLOC_CTX *mem_ctx;");
549 $self->pidl("if (state->out_mem_ctx) {");
551 $self->pidl("mem_ctx = state->out_mem_ctx;");
553 $self->pidl("} else {");
555 $self->pidl("mem_ctx = state;");
560 $self->pidl("status = dcerpc_$name\_r_recv(subreq, mem_ctx);");
561 $self->pidl("TALLOC_FREE(subreq);");
562 $self->pidl("if (tevent_req_nterror(req, status)) {");
564 $self->pidl("return;");
569 $self->pidl("/* Copy out parameters */");
570 foreach my $e (@{$fn->{ELEMENTS}}) {
571 next if ContainsPipe($e, $e->{LEVELS}[0]);
572 next unless (grep(/out/, @{$e->{DIRECTION}}));
574 $self->ParseOutputArgument($fn, $e,
581 if (defined($fn->{RETURN_TYPE})) {
582 $self->pidl("/* Copy result */");
583 $self->pidl("state->orig.out.result = state->tmp.out.result;");
587 $self->pidl("/* Reset temporary structure */");
588 $self->pidl("NDR_ZERO_STRUCT(state->tmp);");
591 $self->pidl("tevent_req_done(req);");
597 sub ParseFunction_Recv($$$$)
599 my ($self, $if, $fn, $name) = @_;
602 my $state_str = "struct dcerpc_$name\_state";
603 my $fn_str = "NTSTATUS dcerpc_$name\_recv";
604 my $pad = genpad($fn_str);
606 $fn_args .= "struct tevent_req *req,\n" . $pad . "TALLOC_CTX *mem_ctx";
608 if (defined($fn->{RETURN_TYPE})) {
609 $fn_args .= ",\n" . $pad . mapTypeName($fn->{RETURN_TYPE}). " *result";
612 $self->fn_declare("$fn_str($fn_args)");
615 $self->pidl("$state_str *state = tevent_req_data(");
616 $self->pidl("\treq, $state_str);");
617 $self->pidl("NTSTATUS status;");
619 $self->pidl("if (tevent_req_is_nterror(req, &status)) {");
621 $self->pidl("tevent_req_received(req);");
622 $self->pidl("return status;");
627 $self->pidl("/* Steal possible out parameters to the callers context */");
628 $self->pidl("talloc_steal(mem_ctx, state->out_mem_ctx);");
631 if (defined($fn->{RETURN_TYPE})) {
632 $self->pidl("/* Return result */");
633 $self->pidl("*result = state->orig.out.result;");
637 $self->pidl("tevent_req_received(req);");
638 $self->pidl("return NT_STATUS_OK;");
644 sub ParseFunction_Sync($$$$)
646 my ($self, $if, $fn, $name) = @_;
648 if ($self->ParseFunctionHasPipes($fn)) {
649 $self->pidl_both("/*");
650 $self->pidl_both(" * The following function is skipped because");
651 $self->pidl_both(" * it uses pipes:");
652 $self->pidl_both(" *");
653 $self->pidl_both(" * dcerpc_$name()");
654 $self->pidl_both(" */");
655 $self->pidl_both("");
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->fn_declare("$fn_str($fn_args)");
679 $self->pidl("struct $name r;");
680 $self->pidl("NTSTATUS status;");
683 $self->pidl("/* In parameters */");
684 foreach my $e (@{$fn->{ELEMENTS}}) {
685 next unless (grep(/in/, @{$e->{DIRECTION}}));
687 $self->ParseCopyArgument($fn, $e, "r.in.", "_");
691 $self->pidl("/* Out parameters */");
692 foreach my $e (@{$fn->{ELEMENTS}}) {
693 next unless grep(/out/, @{$e->{DIRECTION}});
695 $self->ParseCopyArgument($fn, $e, "r.out.", "_");
699 if (defined($fn->{RETURN_TYPE})) {
700 $self->pidl("/* Result */");
701 $self->pidl("NDR_ZERO_STRUCT(r.out.result);");
705 $self->pidl("status = dcerpc_$name\_r(h, mem_ctx, &r);");
706 $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
708 $self->pidl("return status;");
713 $self->pidl("/* Return variables */");
714 foreach my $e (@{$fn->{ELEMENTS}}) {
715 next if ContainsPipe($e, $e->{LEVELS}[0]);
716 next unless (grep(/out/, @{$e->{DIRECTION}}));
718 $self->ParseOutputArgument($fn, $e, "r.", "_", "sync");
722 $self->pidl("/* Return result */");
723 if ($fn->{RETURN_TYPE}) {
724 $self->pidl("*result = r.out.result;");
728 $self->pidl("return NT_STATUS_OK;");
735 #####################################################################
737 sub ParseFunction($$$)
739 my ($self, $if, $fn) = @_;
741 if ($self->ParseFunctionHasPipes($fn)) {
742 $self->pidl_both("/*");
743 $self->pidl_both(" * The following function is skipped because");
744 $self->pidl_both(" * it uses pipes:");
745 $self->pidl_both(" *");
746 $self->pidl_both(" * dcerpc_$fn->{NAME}_r_send()");
747 $self->pidl_both(" * dcerpc_$fn->{NAME}_r_recv()");
748 $self->pidl_both(" * dcerpc_$fn->{NAME}_r()");
749 $self->pidl_both(" *");
750 $self->pidl_both(" * dcerpc_$fn->{NAME}_send()");
751 $self->pidl_both(" * dcerpc_$fn->{NAME}_recv()");
752 $self->pidl_both(" * dcerpc_$fn->{NAME}()");
753 $self->pidl_both(" */");
754 $self->pidl_both("");
755 warning($fn->{ORIGINAL}, "$fn->{NAME}: dcerpc client does not support pipe yet");
759 $self->ParseFunction_r_State($if, $fn, $fn->{NAME});
760 $self->ParseFunction_r_Send($if, $fn, $fn->{NAME});
761 $self->ParseFunction_r_Done($if, $fn, $fn->{NAME});
762 $self->ParseFunction_r_Recv($if, $fn, $fn->{NAME});
763 $self->ParseFunction_r_Sync($if, $fn, $fn->{NAME});
765 foreach my $e (@{$fn->{ELEMENTS}}) {
766 next unless (grep(/out/, @{$e->{DIRECTION}}));
768 my $reason = "is not a pointer or array";
770 # TODO: make this fatal at NDR level
771 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
772 if ($e->{LEVELS}[1]->{TYPE} eq "DATA" and
773 $e->{LEVELS}[1]->{DATA_TYPE} eq "string") {
774 $reason = "is a pointer to type 'string'";
775 } elsif ($e->{LEVELS}[1]->{TYPE} eq "ARRAY" and
776 $e->{LEVELS}[1]->{IS_ZERO_TERMINATED}) {
778 } elsif ($e->{LEVELS}[1]->{TYPE} eq "ARRAY" and
779 not defined($e->{LEVELS}[1]->{SIZE_IS})) {
780 $reason = "is a pointer to an unsized array";
785 if ($e->{LEVELS}[0]->{TYPE} eq "ARRAY") {
786 if (not defined($e->{LEVELS}[0]->{SIZE_IS})) {
787 $reason = "is an unsized array";
793 $self->pidl_both("/*");
794 $self->pidl_both(" * The following functions are skipped because");
795 $self->pidl_both(" * an [out] argument $e->{NAME} $reason:");
796 $self->pidl_both(" *");
797 $self->pidl_both(" * dcerpc_$fn->{NAME}_send()");
798 $self->pidl_both(" * dcerpc_$fn->{NAME}_recv()");
799 $self->pidl_both(" * dcerpc_$fn->{NAME}()");
800 $self->pidl_both(" */");
801 $self->pidl_both("");
803 error($e->{ORIGINAL}, "$fn->{NAME}: [out] argument '$e->{NAME}' $reason, skip client functions");
807 $self->ParseFunction_State($if, $fn, $fn->{NAME});
808 $self->ParseFunction_Send($if, $fn, $fn->{NAME});
809 $self->ParseFunction_Done($if, $fn, $fn->{NAME});
810 $self->ParseFunction_Recv($if, $fn, $fn->{NAME});
811 $self->ParseFunction_Sync($if, $fn, $fn->{NAME});
818 #####################################################################
819 # parse the interface definitions
820 sub ParseInterface($$)
822 my ($self, $if) = @_;
823 my $ifu = uc($if->{NAME});
825 $self->pidl_hdr("#ifndef _HEADER_RPC_$if->{NAME}");
826 $self->pidl_hdr("#define _HEADER_RPC_$if->{NAME}");
829 if (defined $if->{PROPERTIES}->{uuid}) {
830 $self->pidl_hdr("extern const struct ndr_interface_table ndr_table_$if->{NAME};");
834 $self->pidl("/* $if->{NAME} - client functions generated by pidl */");
837 foreach my $fn (@{$if->{FUNCTIONS}}) {
838 next if defined($done{$fn->{NAME}});
839 next if has_property($fn, "noopnum");
840 next if has_property($fn, "todo");
841 $self->ParseFunction($if, $fn);
842 $done{$fn->{NAME}} = 1;
845 $self->pidl_hdr("#endif /* _HEADER_RPC_$if->{NAME} */");
850 my($self,$ndr,$header,$ndr_header,$client_header) = @_;
852 $self->pidl("/* client functions auto-generated by pidl */");
855 $self->pidl("#include \"includes.h\"");
857 $self->pidl("#ifndef _GNU_SOURCE");
858 $self->pidl("#define _GNU_SOURCE");
859 $self->pidl("#endif");
860 $self->pidl("#include <stdio.h>");
861 $self->pidl("#include <stdbool.h>");
862 $self->pidl("#include <stdlib.h>");
863 $self->pidl("#include <stdint.h>");
864 $self->pidl("#include <stdarg.h>");
865 $self->pidl("#include <string.h>");
866 $self->pidl("#include <core/ntstatus.h>");
868 $self->pidl("#include <tevent.h>");
869 $self->pidl(choose_header("lib/util/tevent_ntstatus.h", "util/tevent_ntstatus.h")."");
870 $self->pidl("#include \"$ndr_header\"");
871 $self->pidl("#include \"$client_header\"");
874 $self->pidl_hdr(choose_header("librpc/rpc/dcerpc.h", "dcerpc.h")."");
875 $self->pidl_hdr("#include \"$header\"");
877 foreach my $x (@{$ndr}) {
878 ($x->{TYPE} eq "INTERFACE") && $self->ParseInterface($x);
881 return ($self->{res},$self->{res_hdr});