fcf1fb171ba18ba0502b29684944bc3ec28a2085
[samba.git] / pidl / tests / samba3-cli.pl
1 #!/usr/bin/perl
2 # (C) 2007 Jelmer Vernooij <jelmer@samba.org>
3 # Published under the GNU General Public License
4 use strict;
5 use warnings;
6
7 use Test::More tests => 9;
8 use FindBin qw($RealBin);
9 use lib "$RealBin";
10 use Util;
11 use Parse::Pidl::Util qw(MyDumper);
12 use Parse::Pidl::Samba3::ClientNDR qw(ParseFunction ParseOutputArgument);
13 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv);
14
15 # Make sure GenerateFunctionInEnv and GenerateFunctionOutEnv work
16 my $fn = { ELEMENTS => [ { DIRECTION => ["in"], NAME => "foo" } ] };
17 is_deeply({ "foo" => "r.in.foo" }, GenerateFunctionInEnv($fn, "r."));
18 is_deeply({ "foo" => "r.in.foo" }, GenerateFunctionOutEnv($fn, "r."));
19
20 $fn = { ELEMENTS => [ { DIRECTION => ["out", "in"], NAME => "foo" } ] };
21 is_deeply({ "foo" => "r.in.foo" }, GenerateFunctionInEnv($fn, "r."));
22 is_deeply({ "foo" => "r.out.foo" }, GenerateFunctionOutEnv($fn, "r."));
23
24 $fn = { ELEMENTS => [ { DIRECTION => ["out"], NAME => "foo" } ] };
25 is_deeply({ }, GenerateFunctionInEnv($fn, "r."));
26 is_deeply({ "foo" => "r.out.foo" }, GenerateFunctionOutEnv($fn, "r."));
27
28 my $x = new Parse::Pidl::Samba3::ClientNDR();
29
30 $fn = { NAME => "bar", ELEMENTS => [ ] };
31 $x->ParseFunction("foo", $fn);
32 is($x->{res}, 
33 "struct rpccli_bar_state {
34         struct bar orig;
35         struct bar tmp;
36         TALLOC_CTX *out_mem_ctx;
37         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
38 };
39
40 static void rpccli_bar_done(struct tevent_req *subreq);
41
42 struct tevent_req *rpccli_bar_send(TALLOC_CTX *mem_ctx,
43                                    struct tevent_context *ev,
44                                    struct rpc_pipe_client *cli)
45 {
46         struct tevent_req *req;
47         struct rpccli_bar_state *state;
48         struct tevent_req *subreq;
49
50         req = tevent_req_create(mem_ctx, &state,
51                                 struct rpccli_bar_state);
52         if (req == NULL) {
53                 return NULL;
54         }
55         state->out_mem_ctx = NULL;
56         state->dispatch_recv = cli->dispatch_recv;
57
58         /* In parameters */
59
60         /* Out parameters */
61
62         /* make a temporary copy, that we pass to the dispatch function */
63         state->tmp = state->orig;
64
65         subreq = cli->dispatch_send(state, ev, cli,
66                                     &ndr_table_foo,
67                                     NDR_BAR,
68                                     &state->tmp);
69         if (tevent_req_nomem(subreq, req)) {
70                 return tevent_req_post(req, ev);
71         }
72         tevent_req_set_callback(subreq, rpccli_bar_done, req);
73         return req;
74 }
75
76 static void rpccli_bar_done(struct tevent_req *subreq)
77 {
78         struct tevent_req *req = tevent_req_callback_data(
79                 subreq, struct tevent_req);
80         struct rpccli_bar_state *state = tevent_req_data(
81                 req, struct rpccli_bar_state);
82         NTSTATUS status;
83         TALLOC_CTX *mem_ctx;
84
85         if (state->out_mem_ctx) {
86                 mem_ctx = state->out_mem_ctx;
87         } else {
88                 mem_ctx = state;
89         }
90
91         status = state->dispatch_recv(subreq, mem_ctx);
92         TALLOC_FREE(subreq);
93         if (!NT_STATUS_IS_OK(status)) {
94                 tevent_req_nterror(req, status);
95                 return;
96         }
97
98         /* Copy out parameters */
99
100         /* Reset temporary structure */
101         ZERO_STRUCT(state->tmp);
102
103         tevent_req_done(req);
104 }
105
106 NTSTATUS rpccli_bar_recv(struct tevent_req *req,
107                          TALLOC_CTX *mem_ctx)
108 {
109         struct rpccli_bar_state *state = tevent_req_data(
110                 req, struct rpccli_bar_state);
111         NTSTATUS status;
112
113         if (tevent_req_is_nterror(req, &status)) {
114                 tevent_req_received(req);
115                 return status;
116         }
117
118         /* Steal possbile out parameters to the callers context */
119         talloc_steal(mem_ctx, state->out_mem_ctx);
120
121         tevent_req_received(req);
122         return NT_STATUS_OK;
123 }
124
125 NTSTATUS rpccli_bar(struct rpc_pipe_client *cli,
126                     TALLOC_CTX *mem_ctx)
127 {
128         struct bar r;
129         NTSTATUS status;
130
131         /* In parameters */
132
133         status = cli->dispatch(cli,
134                                 mem_ctx,
135                                 &ndr_table_foo,
136                                 NDR_BAR,
137                                 &r);
138
139         if (!NT_STATUS_IS_OK(status)) {
140                 return status;
141         }
142
143         if (NT_STATUS_IS_ERR(status)) {
144                 return status;
145         }
146
147         /* Return variables */
148
149         /* Return result */
150         return NT_STATUS_OK;
151 }
152
153 ");
154
155 $x = new Parse::Pidl::Samba3::ClientNDR();
156
157 $fn = { NAME => "bar", ELEMENTS => [ ], RETURN_TYPE => "WERROR" };
158 $x->ParseFunction("foo", $fn);
159 is($x->{res}, 
160 "struct rpccli_bar_state {
161         struct bar orig;
162         struct bar tmp;
163         TALLOC_CTX *out_mem_ctx;
164         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
165 };
166
167 static void rpccli_bar_done(struct tevent_req *subreq);
168
169 struct tevent_req *rpccli_bar_send(TALLOC_CTX *mem_ctx,
170                                    struct tevent_context *ev,
171                                    struct rpc_pipe_client *cli)
172 {
173         struct tevent_req *req;
174         struct rpccli_bar_state *state;
175         struct tevent_req *subreq;
176
177         req = tevent_req_create(mem_ctx, &state,
178                                 struct rpccli_bar_state);
179         if (req == NULL) {
180                 return NULL;
181         }
182         state->out_mem_ctx = NULL;
183         state->dispatch_recv = cli->dispatch_recv;
184
185         /* In parameters */
186
187         /* Out parameters */
188
189         /* Result */
190         ZERO_STRUCT(state->orig.out.result);
191
192         /* make a temporary copy, that we pass to the dispatch function */
193         state->tmp = state->orig;
194
195         subreq = cli->dispatch_send(state, ev, cli,
196                                     &ndr_table_foo,
197                                     NDR_BAR,
198                                     &state->tmp);
199         if (tevent_req_nomem(subreq, req)) {
200                 return tevent_req_post(req, ev);
201         }
202         tevent_req_set_callback(subreq, rpccli_bar_done, req);
203         return req;
204 }
205
206 static void rpccli_bar_done(struct tevent_req *subreq)
207 {
208         struct tevent_req *req = tevent_req_callback_data(
209                 subreq, struct tevent_req);
210         struct rpccli_bar_state *state = tevent_req_data(
211                 req, struct rpccli_bar_state);
212         NTSTATUS status;
213         TALLOC_CTX *mem_ctx;
214
215         if (state->out_mem_ctx) {
216                 mem_ctx = state->out_mem_ctx;
217         } else {
218                 mem_ctx = state;
219         }
220
221         status = state->dispatch_recv(subreq, mem_ctx);
222         TALLOC_FREE(subreq);
223         if (!NT_STATUS_IS_OK(status)) {
224                 tevent_req_nterror(req, status);
225                 return;
226         }
227
228         /* Copy out parameters */
229
230         /* Copy result */
231         state->orig.out.result = state->tmp.out.result;
232
233         /* Reset temporary structure */
234         ZERO_STRUCT(state->tmp);
235
236         tevent_req_done(req);
237 }
238
239 NTSTATUS rpccli_bar_recv(struct tevent_req *req,
240                          TALLOC_CTX *mem_ctx,
241                          WERROR *result)
242 {
243         struct rpccli_bar_state *state = tevent_req_data(
244                 req, struct rpccli_bar_state);
245         NTSTATUS status;
246
247         if (tevent_req_is_nterror(req, &status)) {
248                 tevent_req_received(req);
249                 return status;
250         }
251
252         /* Steal possbile out parameters to the callers context */
253         talloc_steal(mem_ctx, state->out_mem_ctx);
254
255         /* Return result */
256         *result = state->orig.out.result;
257
258         tevent_req_received(req);
259         return NT_STATUS_OK;
260 }
261
262 NTSTATUS rpccli_bar(struct rpc_pipe_client *cli,
263                     TALLOC_CTX *mem_ctx,
264                     WERROR *werror)
265 {
266         struct bar r;
267         NTSTATUS status;
268
269         /* In parameters */
270
271         status = cli->dispatch(cli,
272                                 mem_ctx,
273                                 &ndr_table_foo,
274                                 NDR_BAR,
275                                 &r);
276
277         if (!NT_STATUS_IS_OK(status)) {
278                 return status;
279         }
280
281         if (NT_STATUS_IS_ERR(status)) {
282                 return status;
283         }
284
285         /* Return variables */
286
287         /* Return result */
288         if (werror) {
289                 *werror = r.out.result;
290         }
291
292         return werror_to_ntstatus(r.out.result);
293 }
294
295 ");
296
297 $x = new Parse::Pidl::Samba3::ClientNDR();
298
299 $fn = { NAME => "bar", ELEMENTS => [ ], RETURN_TYPE => "WERROR" };
300 my $e = { NAME => "foo", ORIGINAL => { FILE => "f", LINE => -1 },
301           LEVELS => [ { TYPE => "ARRAY", SIZE_IS => "mysize" }, { TYPE => "DATA", DATA_TYPE => "int" } ]};
302
303 $x->ParseOutputArgument($fn, $e);
304 is($x->{res}, "memcpy(foo, r.out.foo, (mysize) * sizeof(*foo));\n");