1 /*
2 * Unix SMB/CIFS implementation.
3 *
4 * testing of some tevent_req aspects
5 *
6 * Copyright (C) Volker Lendecke 2018
7 *
8 * ** NOTE! The following LGPL license applies to the tevent
9 * ** library. This does NOT imply that all of Samba is released
10 * ** under the LGPL
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 3 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27 #include "tevent.h"
28 #include "torture/torture.h"
29 #include "torture/local/proto.h"
30 #include "lib/util/tevent_unix.h"
31 #include "lib/util/tevent_req_profile.h"
32 #include "lib/util/time_basic.h"
33
34 struct tevent_req_create_state {
35 uint8_t val;
36 };
37
test_tevent_req_create(struct torture_context * tctx,const void * test_data)38 static bool test_tevent_req_create(struct torture_context *tctx,
39 const void *test_data)
40 {
41 struct tevent_req *req;
42 struct tevent_req_create_state *state;
43
44 req = tevent_req_create(tctx, &state,
45 struct tevent_req_create_state);
46 torture_assert_not_null(tctx, req, "tevent_req_create failed\n");
47 torture_assert_int_equal(tctx, state->val, 0, "state not initialized\n");
48
49 TALLOC_FREE(req);
50
51 return true;
52 }
53
54 struct profile1_state {
55 uint8_t dummy;
56 };
57
test_tevent_req_profile1(struct torture_context * tctx,const void * test_data)58 static bool test_tevent_req_profile1(struct torture_context *tctx,
59 const void *test_data)
60 {
61 struct tevent_req *req;
62 struct profile1_state *state;
63 const struct tevent_req_profile *p1;
64 struct tevent_req_profile *p2;
65 struct timeval start, stop;
66 bool ok;
67 int cmp;
68
69 req = tevent_req_create(tctx, &state, struct profile1_state);
70 torture_assert_not_null(tctx, req, "tevent_req_create failed\n");
71
72 p1 = tevent_req_get_profile(req);
73 torture_assert(tctx, p1 == NULL, "profile not initialized to NULL\n");
74
75 ok = tevent_req_set_profile(req);
76 torture_assert(tctx, ok, "set_profile failed\n");
77
78 tevent_req_done(req);
79
80 p2 = tevent_req_move_profile(req, tctx);
81 torture_assert_not_null(tctx, p2, "get_profile failed\n");
82
83 /* Demonstrate sure "p2" outlives req */
84 TALLOC_FREE(req);
85
86 tevent_req_profile_get_start(p2, NULL, &start);
87 tevent_req_profile_get_stop(p2, NULL, &stop);
88
89 cmp = tevent_timeval_compare(&start, &stop);
90 torture_assert(tctx, cmp <= 0, "stop before start\n");
91
92 TALLOC_FREE(p2);
93
94 return true;
95 }
96
97 struct profile2_state {
98 uint8_t dummy;
99 };
100
101 static void profile2_done(struct tevent_req *subreq);
102
profile2_send(TALLOC_CTX * mem_ctx,struct tevent_context * ev)103 static struct tevent_req *profile2_send(TALLOC_CTX *mem_ctx,
104 struct tevent_context *ev)
105 {
106 struct tevent_req *req, *subreq;
107 struct profile2_state *state;
108 bool ok;
109
110 req = tevent_req_create(mem_ctx, &state, struct profile2_state);
111 if (req == NULL) {
112 return NULL;
113 }
114
115 ok = tevent_req_set_profile(req);
116 if (!ok) {
117 return tevent_req_post(req, ev);
118 }
119
120 subreq = tevent_wakeup_send(
121 state,
122 ev,
123 tevent_timeval_current_ofs(0, 1));
124 if (tevent_req_nomem(subreq, req)) {
125 return tevent_req_post(req, ev);
126 }
127 tevent_req_set_callback(subreq, profile2_done, req);
128
129 return req;
130 }
131
profile2_done(struct tevent_req * subreq)132 static void profile2_done(struct tevent_req *subreq)
133 {
134 struct tevent_req *req = tevent_req_callback_data(
135 subreq, struct tevent_req);
136 bool ok;
137
138 ok = tevent_wakeup_recv(subreq);
139 if (!ok) {
140 tevent_req_oom(req);
141 return;
142 }
143 tevent_req_done(req);
144 }
145
profile2_recv(struct tevent_req * req,TALLOC_CTX * mem_ctx,struct tevent_req_profile ** profile)146 static int profile2_recv(struct tevent_req *req,
147 TALLOC_CTX *mem_ctx,
148 struct tevent_req_profile **profile)
149 {
150 int err;
151
152 if (tevent_req_is_unix_error(req, &err)) {
153 return err;
154 }
155
156 *profile = tevent_req_move_profile(req, mem_ctx);
157
158 return 0;
159 }
160
test_tevent_req_profile2(struct torture_context * tctx,const void * test_data)161 static bool test_tevent_req_profile2(struct torture_context *tctx,
162 const void *test_data)
163 {
164 struct tevent_context *ev;
165 struct tevent_req *req;
166 struct tevent_req_profile *p1 = NULL;
167 struct tevent_req_profile *p2 = NULL;
168 const char *str1, *str2;
169 struct timeval tv1, tv2;
170 pid_t pid1, pid2;
171 enum tevent_req_state state1, state2;
172 uint64_t err1, err2;
173 char *printstring;
174 ssize_t pack_len;
175 int err;
176 bool ok;
177
178 ev = samba_tevent_context_init(tctx);
179 torture_assert_not_null(tctx, ev, "samba_tevent_context_init failed\n");
180
181 req = profile2_send(tctx, ev);
182 torture_assert_not_null(tctx, req, "profile2_send failed\n");
183
184 ok = tevent_req_poll_unix(req, ev, &err);
185 torture_assert(tctx, ok, "tevent_req_poll_unix failed\n");
186
187 err = profile2_recv(req, tctx, &p1);
188 torture_assert_int_equal(tctx, err, 0, "profile2_recv failed\n");
189
190 TALLOC_FREE(req);
191 TALLOC_FREE(ev);
192
193 printstring = tevent_req_profile_string(tctx, p1, 0, UINT_MAX);
194 torture_assert_not_null(
195 tctx,
196 printstring,
197 "tevent_req_profile_string failed\n");
198 printf("%s\n", printstring);
199
200 pack_len = tevent_req_profile_pack(p1, NULL, 0);
201 torture_assert(tctx, pack_len>0, "profile_pack failed\n");
202
203 {
204 uint8_t buf[pack_len];
205 ssize_t unpack_len;
206
207 tevent_req_profile_pack(p1, buf, sizeof(buf));
208 dump_data(10, buf, sizeof(buf));
209
210 unpack_len = tevent_req_profile_unpack(
211 buf,
212 pack_len,
213 tctx,
214 &p2);
215 torture_assert_int_equal(tctx,
216 pack_len,
217 unpack_len,
218 "profile_unpack failed\n");
219 }
220
221 printstring = tevent_req_profile_string(tctx, p2, 0, UINT_MAX);
222 torture_assert_not_null(
223 tctx,
224 printstring,
225 "tevent_req_profile_string failed\n");
226 printf("%s\n", printstring);
227
228 tevent_req_profile_get_name(p1, &str1);
229 tevent_req_profile_get_name(p2, &str2);
230 torture_assert_str_equal(tctx, str1, str2, "names differ\n");
231
232 tevent_req_profile_get_start(p1, &str1, &tv1);
233 tevent_req_profile_get_start(p2, &str2, &tv2);
234 torture_assert_str_equal(tctx, str1, str2, "start strings differ\n");
235 torture_assert(tctx,
236 tevent_timeval_compare(&tv1, &tv2) == 0,
237 "start times differ\n");
238
239 tevent_req_profile_get_stop(p1, &str1, &tv1);
240 tevent_req_profile_get_stop(p2, &str2, &tv2);
241 torture_assert_str_equal(tctx, str1, str2, "stop strings differ\n");
242 torture_assert(tctx,
243 tevent_timeval_compare(&tv1, &tv2) == 0,
244 "stop times differ\n");
245
246 tevent_req_profile_get_status(p1, &pid1, &state1, &err1);
247 tevent_req_profile_get_status(p2, &pid2, &state2, &err2);
248 torture_assert_int_equal(tctx, pid1, pid2, "pids differ\n");
249 torture_assert_int_equal(tctx, state1, state2, "states differ\n");
250 torture_assert_int_equal(tctx, err1, err2, "user errors differ\n");
251
252 str1 = tevent_req_profile_string(p1, p1, 0, UINT_MAX);
253 torture_assert_not_null(tctx, str1, "profile_string failed\n");
254 str2 = tevent_req_profile_string(p2, p2, 0, UINT_MAX);
255 torture_assert_not_null(tctx, str2, "profile_string failed\n");
256
257 torture_assert_str_equal(tctx, str1, str2, "result strings differ\n");
258
259 TALLOC_FREE(p1);
260 TALLOC_FREE(p2);
261
262 return true;
263 }
264
torture_local_tevent_req(TALLOC_CTX * mem_ctx)265 struct torture_suite *torture_local_tevent_req(TALLOC_CTX *mem_ctx)
266 {
267 struct torture_suite *suite;
268
269 suite = torture_suite_create(mem_ctx, "tevent_req");
270
271 torture_suite_add_simple_tcase_const(
272 suite,
273 "create",
274 test_tevent_req_create,
275 NULL);
276 torture_suite_add_simple_tcase_const(
277 suite,
278 "profile1",
279 test_tevent_req_profile1,
280 NULL);
281 torture_suite_add_simple_tcase_const(
282 suite,
283 "profile2",
284 test_tevent_req_profile2,
285 NULL);
286
287 return suite;
288 }
289