1 /*
2 * Copyright (c) 2013 Niels Provos and Nick Mathewson
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include "event2/event-config.h"
28 #include "evconfig-private.h"
29 #include "tinytest.h"
30 #include "tinytest_macros.h"
31 #include <stdlib.h>
32
33 #include "event2/event.h"
34 #include "event2/util.h"
35 #include "event-internal.h"
36 #include "defer-internal.h"
37
38 #include "regress.h"
39 #include "regress_thread.h"
40
41 static void
timer_callback(evutil_socket_t fd,short what,void * arg)42 timer_callback(evutil_socket_t fd, short what, void *arg)
43 {
44 int *int_arg = arg;
45 *int_arg += 1;
46 (void)fd;
47 (void)what;
48 }
49 static void
simple_callback(struct event_callback * evcb,void * arg)50 simple_callback(struct event_callback *evcb, void *arg)
51 {
52 int *int_arg = arg;
53 *int_arg += 1;
54 (void)evcb;
55 }
56 static void
event_finalize_callback_1(struct event * ev,void * arg)57 event_finalize_callback_1(struct event *ev, void *arg)
58 {
59 int *int_arg = arg;
60 *int_arg += 100;
61 (void)ev;
62 }
63 static void
callback_finalize_callback_1(struct event_callback * evcb,void * arg)64 callback_finalize_callback_1(struct event_callback *evcb, void *arg)
65 {
66 int *int_arg = arg;
67 *int_arg += 100;
68 (void)evcb;
69 }
70
71
72 static void
test_fin_cb_invoked(void * arg)73 test_fin_cb_invoked(void *arg)
74 {
75 struct basic_test_data *data = arg;
76 struct event_base *base = data->base;
77
78 struct event *ev;
79 struct event ev2;
80 struct event_callback evcb;
81 int cb_called = 0;
82 int ev_called = 0;
83
84 const struct timeval ten_sec = {10,0};
85
86 event_deferred_cb_init_(&evcb, 0, simple_callback, &cb_called);
87 ev = evtimer_new(base, timer_callback, &ev_called);
88 /* Just finalize them; don't bother adding. */
89 event_free_finalize(0, ev, event_finalize_callback_1);
90 event_callback_finalize_(base, 0, &evcb, callback_finalize_callback_1);
91
92 event_base_dispatch(base);
93
94 tt_int_op(cb_called, ==, 100);
95 tt_int_op(ev_called, ==, 100);
96
97 ev_called = cb_called = 0;
98 event_base_assert_ok_(base);
99
100 /* Now try it when they're active. (actually, don't finalize: make
101 * sure activation can happen! */
102 ev = evtimer_new(base, timer_callback, &ev_called);
103 event_deferred_cb_init_(&evcb, 0, simple_callback, &cb_called);
104
105 event_active(ev, EV_TIMEOUT, 1);
106 event_callback_activate_(base, &evcb);
107
108 event_base_dispatch(base);
109 tt_int_op(cb_called, ==, 1);
110 tt_int_op(ev_called, ==, 1);
111
112 ev_called = cb_called = 0;
113 event_base_assert_ok_(base);
114
115 /* Great, it worked. Now activate and finalize and make sure only
116 * finalizing happens. */
117 event_active(ev, EV_TIMEOUT, 1);
118 event_callback_activate_(base, &evcb);
119 event_free_finalize(0, ev, event_finalize_callback_1);
120 event_callback_finalize_(base, 0, &evcb, callback_finalize_callback_1);
121
122 event_base_dispatch(base);
123 tt_int_op(cb_called, ==, 100);
124 tt_int_op(ev_called, ==, 100);
125
126 ev_called = 0;
127
128 event_base_assert_ok_(base);
129
130 /* Okay, now add but don't have it become active, and make sure *that*
131 * works. */
132 ev = evtimer_new(base, timer_callback, &ev_called);
133 event_add(ev, &ten_sec);
134 event_free_finalize(0, ev, event_finalize_callback_1);
135
136 event_base_dispatch(base);
137 tt_int_op(ev_called, ==, 100);
138
139 ev_called = 0;
140 event_base_assert_ok_(base);
141
142 /* Now try adding and deleting after finalizing. */
143 ev = evtimer_new(base, timer_callback, &ev_called);
144 evtimer_assign(&ev2, base, timer_callback, &ev_called);
145 event_add(ev, &ten_sec);
146 event_free_finalize(0, ev, event_finalize_callback_1);
147 event_finalize(0, &ev2, event_finalize_callback_1);
148
149 event_add(&ev2, &ten_sec);
150 event_del(ev);
151 event_active(&ev2, EV_TIMEOUT, 1);
152
153 event_base_dispatch(base);
154 tt_int_op(ev_called, ==, 200);
155
156 event_base_assert_ok_(base);
157
158 end:
159 ;
160 }
161
162 #ifndef EVENT__DISABLE_MM_REPLACEMENT
163 static void *
tfff_malloc(size_t n)164 tfff_malloc(size_t n)
165 {
166 return malloc(n);
167 }
168 static void *tfff_p1=NULL, *tfff_p2=NULL;
169 static int tfff_p1_freed=0, tfff_p2_freed=0;
170 static void
tfff_free(void * p)171 tfff_free(void *p)
172 {
173 if (! p)
174 return;
175 if (p == tfff_p1)
176 ++tfff_p1_freed;
177 if (p == tfff_p2)
178 ++tfff_p2_freed;
179 free(p);
180 }
181 static void *
tfff_realloc(void * p,size_t sz)182 tfff_realloc(void *p, size_t sz)
183 {
184 return realloc(p,sz);
185 }
186 #endif
187
188 static void
test_fin_free_finalize(void * arg)189 test_fin_free_finalize(void *arg)
190 {
191 #ifdef EVENT__DISABLE_MM_REPLACEMENT
192 tinytest_set_test_skipped_();
193 #else
194 struct event_base *base = NULL;
195 struct event *ev, *ev2;
196 int ev_called = 0;
197 int ev2_called = 0;
198
199 (void)arg;
200
201 event_set_mem_functions(tfff_malloc, tfff_realloc, tfff_free);
202
203 base = event_base_new();
204 tt_assert(base);
205
206 ev = evtimer_new(base, timer_callback, &ev_called);
207 ev2 = evtimer_new(base, timer_callback, &ev2_called);
208 tfff_p1 = ev;
209 tfff_p2 = ev2;
210 event_free_finalize(0, ev, event_finalize_callback_1);
211 event_finalize(0, ev2, event_finalize_callback_1);
212
213 event_base_dispatch(base);
214
215 tt_int_op(ev_called, ==, 100);
216 tt_int_op(ev2_called, ==, 100);
217
218 event_base_assert_ok_(base);
219 tt_int_op(tfff_p1_freed, ==, 1);
220 tt_int_op(tfff_p2_freed, ==, 0);
221
222 event_free(ev2);
223
224 end:
225 if (base)
226 event_base_free(base);
227 #endif
228 }
229
230 /* For test_fin_within_cb */
231 struct event_and_count {
232 struct event *ev;
233 struct event *ev2;
234 int count;
235 };
236 static void
event_finalize_callback_2(struct event * ev,void * arg)237 event_finalize_callback_2(struct event *ev, void *arg)
238 {
239 struct event_and_count *evc = arg;
240 evc->count += 100;
241 event_free(ev);
242 }
243 static void
timer_callback_2(evutil_socket_t fd,short what,void * arg)244 timer_callback_2(evutil_socket_t fd, short what, void *arg)
245 {
246 struct event_and_count *evc = arg;
247 event_finalize(0, evc->ev, event_finalize_callback_2);
248 event_finalize(0, evc->ev2, event_finalize_callback_2);
249 ++ evc->count;
250 (void)fd;
251 (void)what;
252 }
253
254 static void
test_fin_within_cb(void * arg)255 test_fin_within_cb(void *arg)
256 {
257 struct basic_test_data *data = arg;
258 struct event_base *base = data->base;
259
260 struct event_and_count evc1, evc2;
261 evc1.count = evc2.count = 0;
262 evc2.ev2 = evc1.ev = evtimer_new(base, timer_callback_2, &evc1);
263 evc1.ev2 = evc2.ev = evtimer_new(base, timer_callback_2, &evc2);
264
265 /* Activate both. The first one will have its callback run, which
266 * will finalize both of them, preventing the second one's callback
267 * from running. */
268 event_active(evc1.ev, EV_TIMEOUT, 1);
269 event_active(evc2.ev, EV_TIMEOUT, 1);
270
271 event_base_dispatch(base);
272 tt_int_op(evc1.count, ==, 101);
273 tt_int_op(evc2.count, ==, 100);
274
275 event_base_assert_ok_(base);
276 /* Now try with EV_PERSIST events. */
277 evc1.count = evc2.count = 0;
278 evc2.ev2 = evc1.ev = event_new(base, -1, EV_PERSIST, timer_callback_2, &evc1);
279 evc1.ev2 = evc2.ev = event_new(base, -1, EV_PERSIST, timer_callback_2, &evc2);
280
281 event_active(evc1.ev, EV_TIMEOUT, 1);
282 event_active(evc2.ev, EV_TIMEOUT, 1);
283
284 event_base_dispatch(base);
285 tt_int_op(evc1.count, ==, 101);
286 tt_int_op(evc2.count, ==, 100);
287
288 event_base_assert_ok_(base);
289 end:
290 ;
291 }
292
293 static void
event_finalize_callback_free(struct event * ev,void * arg)294 event_finalize_callback_free(struct event *ev, void *arg)
295 {
296 struct event_base *base = arg;
297 int err;
298 if (base) {
299 err = event_assign(ev, base, -1, EV_TIMEOUT, NULL, NULL);
300 tt_int_op(err, ==, 0);
301 test_ok += 1;
302 } else {
303 free(ev);
304 test_ok += 1;
305 }
306
307 end:
308 ;
309 }
310 static void
test_fin_debug_use_after_free(void * arg)311 test_fin_debug_use_after_free(void *arg)
312 {
313 struct basic_test_data *data = arg;
314 struct event_base *base = data->base;
315 struct event *ev;
316
317 tt_ptr_op(ev = event_new(base, -1, EV_TIMEOUT, NULL, base), !=, NULL);
318 tt_int_op(event_add(ev, NULL), ==, 0);
319 tt_int_op(event_finalize(0, ev, event_finalize_callback_free), ==, 0);
320
321 // Dispatch base to trigger callbacks
322 event_base_dispatch(base);
323 event_base_assert_ok_(base);
324 tt_int_op(test_ok, ==, 1);
325
326 // Now add again, since we did event_assign in event_finalize_callback_free
327 // This used to fail in event_debug_assert_is_setup_
328 tt_int_op(event_add(ev, NULL), ==, 0);
329
330 // Finalize and dispatch again
331 tt_int_op(event_finalize(0, ev, event_finalize_callback_free), ==, 0);
332 event_base_dispatch(base);
333 event_base_assert_ok_(base);
334 tt_int_op(test_ok, ==, 2);
335
336 end:
337 ;
338 }
339
340 #if 0
341 static void
342 timer_callback_3(evutil_socket_t *fd, short what, void *arg)
343 {
344 (void)fd;
345 (void)what;
346
347 }
348 static void
349 test_fin_many(void *arg)
350 {
351 struct basic_test_data *data = arg;
352 struct event_base *base = data->base;
353
354 struct event *ev1, *ev2;
355 struct event_callback evcb1, evcb2;
356 int ev1_count = 0, ev2_count = 0;
357 int evcb1_count = 0, evcb2_count = 0;
358 struct event_callback *array[4];
359
360 int n;
361
362 /* First attempt: call finalize_many with no events running */
363 ev1 = evtimer_new(base, timer_callback, &ev1_count);
364 ev1 = evtimer_new(base, timer_callback, &ev2_count);
365 event_deferred_cb_init_(&evcb1, 0, simple_callback, &evcb1_called);
366 event_deferred_cb_init_(&evcb2, 0, simple_callback, &evcb2_called);
367 array[0] = &ev1->ev_evcallback;
368 array[1] = &ev2->ev_evcallback;
369 array[2] = &evcb1;
370 array[3] = &evcb2;
371
372
373
374 n = event_callback_finalize_many(base, 4, array,
375 callback_finalize_callback_1);
376
377 }
378 #endif
379
380
381 #define TEST(name, flags) \
382 { #name, test_fin_##name, (flags), &basic_setup, NULL }
383
384 struct testcase_t finalize_testcases[] = {
385
386 TEST(cb_invoked, TT_FORK|TT_NEED_BASE),
387 TEST(free_finalize, TT_FORK),
388 TEST(within_cb, TT_FORK|TT_NEED_BASE),
389 TEST(debug_use_after_free, TT_FORK|TT_NEED_BASE|TT_ENABLE_DEBUG_MODE),
390 // TEST(many, TT_FORK|TT_NEED_BASE),
391
392
393 END_OF_TESTCASES
394 };
395
396