Make some fatal errors non-fatal. This means we generate invalid code in
[tprouty/samba.git] / pidl / lib / Parse / Pidl / Samba3 / ClientNDR.pm
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
7
8 package Parse::Pidl::Samba3::ClientNDR;
9
10 use Exporter;
11 @ISA = qw(Exporter);
12 @EXPORT_OK = qw(ParseFunction $res $res_hdr ParseOutputArgument);
13
14 use strict;
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);
19
20 use vars qw($VERSION);
21 $VERSION = '0.01';
22
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;"); }
28
29 sub genpad($)
30 {
31         my ($s) = @_;
32         my $nt = int((length($s)+1)/8);
33         my $lt = ($nt*8)-1;
34         my $ns = (length($s)-$lt);
35         return "\t"x($nt)." "x($ns);
36 }
37
38 sub new($)
39 {
40         my ($class) = shift;
41         my $self = { res => "", res_hdr => "", tabs => "" };
42         bless($self, $class);
43 }
44
45 sub ElementDirection($)
46 {
47         my ($e) = @_;
48
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"));
52         return "[in,out]";
53 }
54
55 sub HeaderProperties($$)
56 {
57         my($props,$ignores) = @_;
58         my $ret = "";
59
60         foreach my $d (keys %{$props}) {
61                 next if (grep(/^$d$/, @$ignores));
62                 if($props->{$d} ne "1") {
63                         $ret.= "$d($props->{$d}),";
64                 } else {
65                         $ret.="$d,";
66                 }
67         }
68
69         if ($ret) {
70                 return "[" . substr($ret, 0, -1) . "]";
71         }
72 }
73
74 sub ParseOutputArgument($$$)
75 {
76         my ($self, $fn, $e) = @_;
77         my $level = 0;
78
79         if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY") {
80                 $self->pidl("return NT_STATUS_NOT_SUPPORTED;");
81                 error($e->{ORIGINAL}, "[out] argument is not a pointer or array");
82                 return;
83         }
84
85         if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
86                 $level = 1;
87                 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
88                         $self->pidl("if ($e->{NAME} && r.out.$e->{NAME}) {");
89                         $self->indent;
90                 }
91         }
92
93         if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") {
94                 # This is a call to GenerateFunctionInEnv intentionally. 
95                 # Since the data is being copied into a user-provided data 
96                 # structure, the user should be able to know the size beforehand 
97                 # to allocate a structure of the right size.
98                 my $env = GenerateFunctionInEnv($fn, "r.");
99                 my $size_is = ParseExpr($e->{LEVELS}[$level]->{SIZE_IS}, $env, $e->{ORIGINAL});
100                 $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is * sizeof(*$e->{NAME}));");
101         } else {
102                 $self->pidl("*$e->{NAME} = *r.out.$e->{NAME};");
103         }
104
105         if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
106                 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
107                         $self->deindent;
108                         $self->pidl("}");
109                 }
110         }
111 }
112
113 sub ParseFunction($$$)
114 {
115         my ($self, $if, $fn) = @_;
116
117         my $fn_args = "";
118         my $uif = uc($if);
119         my $ufn = "NDR_".uc($fn->{NAME});
120         my $fn_str = "NTSTATUS rpccli_$fn->{NAME}";
121         my $pad = genpad($fn_str);
122
123         $fn_args .= "struct rpc_pipe_client *cli,\n" . $pad . "TALLOC_CTX *mem_ctx";
124
125         foreach (@{$fn->{ELEMENTS}}) {
126                 my $dir = ElementDirection($_);
127                 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
128                 $fn_args .= ",\n" . $pad . DeclLong($_) . " /* $dir $prop */";
129         }
130
131         if (defined($fn->{RETURN_TYPE}) && ($fn->{RETURN_TYPE} eq "WERROR")) {
132                 $fn_args .= ",\n" . $pad . "WERROR *werror";
133         }
134
135         $self->fn_declare("$fn_str($fn_args)");
136         $self->pidl("{");
137         $self->indent;
138         $self->pidl("struct $fn->{NAME} r;");
139         $self->pidl("NTSTATUS status;");
140         $self->pidl("");
141         $self->pidl("/* In parameters */");
142
143         foreach (@{$fn->{ELEMENTS}}) {
144                 if (grep(/in/, @{$_->{DIRECTION}})) {
145                         $self->pidl("r.in.$_->{NAME} = $_->{NAME};");
146                 }
147         }
148
149         $self->pidl("");
150         $self->pidl("if (DEBUGLEVEL >= 10) {");
151         $self->indent;
152         $self->pidl("NDR_PRINT_IN_DEBUG($fn->{NAME}, &r);");
153         $self->deindent;
154         $self->pidl("}");
155         $self->pidl("");
156         $self->pidl("status = cli_do_rpc_ndr(cli,");
157         $self->pidl("\t\t\tmem_ctx,");
158         $self->pidl("\t\t\t&ndr_table_$if,");
159         $self->pidl("\t\t\t$ufn,");
160         $self->pidl("\t\t\t&r);");
161         $self->pidl("");
162
163         $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
164         $self->indent;
165         $self->pidl("return status;");
166         $self->deindent;
167         $self->pidl("}");
168
169         $self->pidl("");
170         $self->pidl("if (DEBUGLEVEL >= 10) {");
171         $self->indent;
172         $self->pidl("NDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);");
173         $self->deindent;
174         $self->pidl("}");
175         $self->pidl("");
176         $self->pidl("if (NT_STATUS_IS_ERR(status)) {");
177         $self->indent;
178         $self->pidl("return status;");
179         $self->deindent;
180         $self->pidl("}");
181         $self->pidl("");
182         $self->pidl("/* Return variables */");
183         foreach my $e (@{$fn->{ELEMENTS}}) {
184                 next unless (grep(/out/, @{$e->{DIRECTION}}));
185
186                 $self->ParseOutputArgument($fn, $e);
187
188         }
189
190         $self->pidl("");
191         $self->pidl("/* Return result */");
192         if (not $fn->{RETURN_TYPE}) {
193                 $self->pidl("return NT_STATUS_OK;");
194         } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") {
195                 $self->pidl("return r.out.result;");
196         } elsif ($fn->{RETURN_TYPE} eq "WERROR") {
197                 $self->pidl("if (werror) {");
198                 $self->indent;
199                 $self->pidl("*werror = r.out.result;");
200                 $self->deindent;
201                 $self->pidl("}");
202                 $self->pidl("");
203                 $self->pidl("return werror_to_ntstatus(r.out.result);");
204         } else {
205                 warning($fn->{ORIGINAL}, "Unable to convert $fn->{RETURN_TYPE} to NTSTATUS");
206                 $self->pidl("return NT_STATUS_OK;");
207         }
208
209         $self->deindent;
210         $self->pidl("}");
211         $self->pidl("");
212 }
213
214 sub ParseInterface($$)
215 {
216         my ($self, $if) = @_;
217
218         my $uif = uc($if->{NAME});
219
220         $self->pidl_hdr("#ifndef __CLI_$uif\__");
221         $self->pidl_hdr("#define __CLI_$uif\__");
222         foreach (@{$if->{FUNCTIONS}}) {
223                 next if ($_->{PROPERTIES}{noopnum});
224                 $self->ParseFunction($if->{NAME}, $_);
225         }
226         $self->pidl_hdr("#endif /* __CLI_$uif\__ */");
227 }
228
229 sub Parse($$$$)
230 {
231         my($self,$ndr,$header,$ndr_header) = @_;
232
233         $self->pidl("/*");
234         $self->pidl(" * Unix SMB/CIFS implementation.");
235         $self->pidl(" * client auto-generated by pidl. DO NOT MODIFY!");
236         $self->pidl(" */");
237         $self->pidl("");
238         $self->pidl("#include \"includes.h\"");
239         $self->pidl("#include \"$header\"");
240         $self->pidl_hdr("#include \"$ndr_header\"");
241         $self->pidl("");
242         
243         foreach (@$ndr) {
244                 $self->ParseInterface($_) if ($_->{TYPE} eq "INTERFACE");
245         }
246
247         return ($self->{res}, $self->{res_hdr});
248 }
249
250 1;