1 ###################################################
2 # Samba3 client generator for IDL structures
3 # on top of Samba4 style NDR functions
4 # Copyright jelmer@samba.org 2005-2006
5 # Copyright gd@samba.org 2008
6 # released under the GNU GPL
8 package Parse::Pidl::Samba3::ClientNDR;
12 @EXPORT_OK = qw(ParseFunction $res $res_hdr ParseOutputArgument);
15 use Parse::Pidl qw(fatal warning error);
16 use Parse::Pidl::Util qw(has_property ParseExpr);
17 use Parse::Pidl::Samba4 qw(DeclLong);
18 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv);
20 use vars qw($VERSION);
23 sub indent($) { my ($self) = @_; $self->{tabs}.="\t"; }
24 sub deindent($) { my ($self) = @_; $self->{tabs} = substr($self->{tabs}, 1); }
25 sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= $txt ? "$self->{tabs}$txt\n" : "\n"; }
26 sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; }
27 sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); }
32 my $nt = int((length($s)+1)/8);
34 my $ns = (length($s)-$lt);
35 return "\t"x($nt)." "x($ns);
41 my $self = { res => "", res_hdr => "", tabs => "" };
45 sub ElementDirection($)
49 return "[in,out]" if (has_property($e, "in") and has_property($e, "out"));
50 return "[in]" if (has_property($e, "in"));
51 return "[out]" if (has_property($e, "out"));
55 sub HeaderProperties($$)
57 my($props,$ignores) = @_;
60 foreach my $d (keys %{$props}) {
61 next if (grep(/^$d$/, @$ignores));
62 if($props->{$d} ne "1") {
63 $ret.= "$d($props->{$d}),";
70 return "[" . substr($ret, 0, -1) . "]";
74 sub ParseOutputArgument($$$;$$)
76 my ($self, $fn, $e, $r, $o) = @_;
78 $r = "r." unless defined($r);
79 $o = "" unless defined($o);
81 if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY") {
82 $self->pidl("return NT_STATUS_NOT_SUPPORTED;");
83 error($e->{ORIGINAL}, "[out] argument is not a pointer or array");
87 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
89 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
90 $self->pidl("if ($o$e->{NAME} && ${r}out.$e->{NAME}) {");
95 if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") {
96 # This is a call to GenerateFunctionInEnv intentionally.
97 # Since the data is being copied into a user-provided data
98 # structure, the user should be able to know the size beforehand
99 # to allocate a structure of the right size.
100 my $env = GenerateFunctionInEnv($fn, $r);
101 my $l = $e->{LEVELS}[$level];
102 unless (defined($l->{SIZE_IS})) {
103 error($e->{ORIGINAL}, "no size known for [out] array `$e->{NAME}'");
104 $self->pidl('#error No size known for [out] array `$e->{NAME}');
106 my $size_is = ParseExpr($l->{SIZE_IS}, $env, $e->{ORIGINAL});
107 if (has_property($e, "charset")) {
108 $self->pidl("memcpy(CONST_DISCARD(char *, $o$e->{NAME}), ${r}out.$e->{NAME}, $size_is * sizeof(*$o$e->{NAME}));");
110 $self->pidl("memcpy($o$e->{NAME}, ${r}out.$e->{NAME}, $size_is * sizeof(*$o$e->{NAME}));");
114 $self->pidl("*$o$e->{NAME} = *${r}out.$e->{NAME};");
117 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
118 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
125 sub ParseFunctionAsyncState($$$)
127 my ($self, $if, $fn) = @_;
129 my $state_str = "struct rpccli_$fn->{NAME}_state";
130 my $done_fn = "rpccli_$fn->{NAME}_done";
132 $self->pidl("$state_str {");
134 $self->pidl("struct $fn->{NAME} orig;");
135 $self->pidl("struct $fn->{NAME} tmp;");
136 $self->pidl("TALLOC_CTX *out_mem_ctx;");
137 $self->pidl("NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);");
141 $self->pidl("static void $done_fn(struct tevent_req *subreq);");
145 sub ParseFunctionAsyncSend($$$)
147 my ($self, $if, $fn) = @_;
151 my $ufn = "NDR_".uc($fn->{NAME});
152 my $state_str = "struct rpccli_$fn->{NAME}_state";
153 my $done_fn = "rpccli_$fn->{NAME}_done";
154 my $out_mem_ctx = "rpccli_$fn->{NAME}_out_memory";
155 my $fn_str = "struct tevent_req *rpccli_$fn->{NAME}_send";
156 my $pad = genpad($fn_str);
158 $fn_args .= "TALLOC_CTX *mem_ctx";
159 $fn_args .= ",\n" . $pad . "struct tevent_context *ev";
160 $fn_args .= ",\n" . $pad . "struct rpc_pipe_client *cli";
162 foreach (@{$fn->{ELEMENTS}}) {
163 my $dir = ElementDirection($_);
164 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
165 $fn_args .= ",\n" . $pad . DeclLong($_, "_") . " /* $dir $prop */";
168 $self->fn_declare("$fn_str($fn_args)");
171 $self->pidl("struct tevent_req *req;");
172 $self->pidl("$state_str *state;");
173 $self->pidl("struct tevent_req *subreq;");
175 $self->pidl("req = tevent_req_create(mem_ctx, &state,");
176 $self->pidl("\t\t\t$state_str);");
177 $self->pidl("if (req == NULL) {");
179 $self->pidl("return NULL;");
182 $self->pidl("state->out_mem_ctx = NULL;");
183 $self->pidl("state->dispatch_recv = cli->dispatch_recv;");
186 $self->pidl("/* In parameters */");
187 foreach (@{$fn->{ELEMENTS}}) {
188 if (grep(/in/, @{$_->{DIRECTION}})) {
189 $self->pidl("state->orig.in.$_->{NAME} = _$_->{NAME};");
195 $self->pidl("/* Out parameters */");
196 foreach (@{$fn->{ELEMENTS}}) {
197 if (grep(/out/, @{$_->{DIRECTION}})) {
198 $self->pidl("state->orig.out.$_->{NAME} = _$_->{NAME};");
204 if (defined($fn->{RETURN_TYPE})) {
205 $self->pidl("/* Result */");
206 $self->pidl("ZERO_STRUCT(state->orig.out.result);");
210 if ($out_params > 0) {
211 $self->pidl("state->out_mem_ctx = talloc_named_const(state, 0,");
212 $self->pidl("\t\t \"$out_mem_ctx\");");
213 $self->pidl("if (tevent_req_nomem(state->out_mem_ctx, req)) {");
215 $self->pidl("return tevent_req_post(req, ev);");
221 $self->pidl("/* make a temporary copy, that we pass to the dispatch function */");
222 $self->pidl("state->tmp = state->orig;");
225 $self->pidl("subreq = cli->dispatch_send(state, ev, cli,");
226 $self->pidl("\t\t\t &ndr_table_$if,");
227 $self->pidl("\t\t\t $ufn,");
228 $self->pidl("\t\t\t &state->tmp);");
229 $self->pidl("if (tevent_req_nomem(subreq, req)) {");
231 $self->pidl("return tevent_req_post(req, ev);");
234 $self->pidl("tevent_req_set_callback(subreq, $done_fn, req);");
235 $self->pidl("return req;");
241 sub ParseFunctionAsyncDone($$$)
243 my ($self, $if, $fn) = @_;
245 my $state_str = "struct rpccli_$fn->{NAME}_state";
246 my $done_fn = "rpccli_$fn->{NAME}_done";
248 $self->pidl("static void $done_fn(struct tevent_req *subreq)");
251 $self->pidl("struct tevent_req *req = tevent_req_callback_data(");
252 $self->pidl("\tsubreq, struct tevent_req);");
253 $self->pidl("$state_str *state = tevent_req_data(");
254 $self->pidl("\treq, $state_str);");
255 $self->pidl("NTSTATUS status;");
256 $self->pidl("TALLOC_CTX *mem_ctx;");
259 $self->pidl("if (state->out_mem_ctx) {");
261 $self->pidl("mem_ctx = state->out_mem_ctx;");
263 $self->pidl("} else {");
265 $self->pidl("mem_ctx = state;");
270 $self->pidl("status = state->dispatch_recv(subreq, mem_ctx);");
271 $self->pidl("TALLOC_FREE(subreq);");
272 $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
274 $self->pidl("tevent_req_nterror(req, status);");
275 $self->pidl("return;");
280 $self->pidl("/* Copy out parameters */");
281 foreach my $e (@{$fn->{ELEMENTS}}) {
282 next unless (grep(/out/, @{$e->{DIRECTION}}));
284 $self->ParseOutputArgument($fn, $e, "state->tmp.", "state->orig.out.");
288 if (defined($fn->{RETURN_TYPE})) {
289 $self->pidl("/* Copy result */");
290 $self->pidl("state->orig.out.result = state->tmp.out.result;");
294 $self->pidl("/* Reset temporary structure */");
295 $self->pidl("ZERO_STRUCT(state->tmp);");
298 $self->pidl("tevent_req_done(req);");
304 sub ParseFunctionAsyncRecv($$$)
306 my ($self, $if, $fn) = @_;
309 my $state_str = "struct rpccli_$fn->{NAME}_state";
310 my $fn_str = "NTSTATUS rpccli_$fn->{NAME}_recv";
311 my $pad = genpad($fn_str);
313 $fn_args .= "struct tevent_req *req,\n" . $pad . "TALLOC_CTX *mem_ctx";
315 if (defined($fn->{RETURN_TYPE})) {
316 $fn_args .= ",\n" . $pad . "$fn->{RETURN_TYPE} *result";
319 $self->fn_declare("$fn_str($fn_args)");
322 $self->pidl("$state_str *state = tevent_req_data(");
323 $self->pidl("\treq, $state_str);");
324 $self->pidl("NTSTATUS status;");
326 $self->pidl("if (tevent_req_is_nterror(req, &status)) {");
328 $self->pidl("tevent_req_received(req);");
329 $self->pidl("return status;");
334 $self->pidl("/* Steal possbile out parameters to the callers context */");
335 $self->pidl("talloc_steal(mem_ctx, state->out_mem_ctx);");
338 if (defined($fn->{RETURN_TYPE})) {
339 $self->pidl("/* Return result */");
340 $self->pidl("*result = state->orig.out.result;");
344 $self->pidl("tevent_req_received(req);");
345 $self->pidl("return NT_STATUS_OK;");
351 sub ParseFunctionSync($$$)
353 my ($self, $if, $fn) = @_;
357 my $ufn = "NDR_".uc($fn->{NAME});
358 my $fn_str = "NTSTATUS rpccli_$fn->{NAME}";
359 my $pad = genpad($fn_str);
361 $fn_args .= "struct rpc_pipe_client *cli,\n" . $pad . "TALLOC_CTX *mem_ctx";
363 foreach (@{$fn->{ELEMENTS}}) {
364 my $dir = ElementDirection($_);
365 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
366 $fn_args .= ",\n" . $pad . DeclLong($_) . " /* $dir $prop */";
369 if (defined($fn->{RETURN_TYPE}) && ($fn->{RETURN_TYPE} eq "WERROR")) {
370 $fn_args .= ",\n" . $pad . "WERROR *werror";
373 $self->fn_declare("$fn_str($fn_args)");
376 $self->pidl("struct $fn->{NAME} r;");
377 $self->pidl("NTSTATUS status;");
379 $self->pidl("/* In parameters */");
381 foreach (@{$fn->{ELEMENTS}}) {
382 if (grep(/in/, @{$_->{DIRECTION}})) {
383 $self->pidl("r.in.$_->{NAME} = $_->{NAME};");
388 $self->pidl("status = cli->dispatch(cli,");
389 $self->pidl("\t\t\tmem_ctx,");
390 $self->pidl("\t\t\t&ndr_table_$if,");
391 $self->pidl("\t\t\t$ufn,");
392 $self->pidl("\t\t\t&r);");
395 $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
397 $self->pidl("return status;");
402 $self->pidl("if (NT_STATUS_IS_ERR(status)) {");
404 $self->pidl("return status;");
408 $self->pidl("/* Return variables */");
409 foreach my $e (@{$fn->{ELEMENTS}}) {
410 next unless (grep(/out/, @{$e->{DIRECTION}}));
412 $self->ParseOutputArgument($fn, $e);
417 $self->pidl("/* Return result */");
418 if (not $fn->{RETURN_TYPE}) {
419 $self->pidl("return NT_STATUS_OK;");
420 } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") {
421 $self->pidl("return r.out.result;");
422 } elsif ($fn->{RETURN_TYPE} eq "WERROR") {
423 $self->pidl("if (werror) {");
425 $self->pidl("*werror = r.out.result;");
429 $self->pidl("return werror_to_ntstatus(r.out.result);");
431 warning($fn->{ORIGINAL}, "Unable to convert $fn->{RETURN_TYPE} to NTSTATUS");
432 $self->pidl("return NT_STATUS_OK;");
440 sub ParseFunction($$$)
442 my ($self, $if, $fn) = @_;
444 $self->ParseFunctionAsyncState($if, $fn);
445 $self->ParseFunctionAsyncSend($if, $fn);
446 $self->ParseFunctionAsyncDone($if, $fn);
447 $self->ParseFunctionAsyncRecv($if, $fn);
449 $self->ParseFunctionSync($if, $fn);
452 sub ParseInterface($$)
454 my ($self, $if) = @_;
456 my $uif = uc($if->{NAME});
458 $self->pidl_hdr("#ifndef __CLI_$uif\__");
459 $self->pidl_hdr("#define __CLI_$uif\__");
460 foreach (@{$if->{FUNCTIONS}}) {
461 next if ($_->{PROPERTIES}{noopnum});
462 $self->ParseFunction($if->{NAME}, $_);
464 $self->pidl_hdr("#endif /* __CLI_$uif\__ */");
469 my($self,$ndr,$header,$ndr_header) = @_;
472 $self->pidl(" * Unix SMB/CIFS implementation.");
473 $self->pidl(" * client auto-generated by pidl. DO NOT MODIFY!");
476 $self->pidl("#include \"includes.h\"");
477 $self->pidl("#include \"$header\"");
478 $self->pidl_hdr("#include \"$ndr_header\"");
482 $self->ParseInterface($_) if ($_->{TYPE} eq "INTERFACE");
485 return ($self->{res}, $self->{res_hdr});