[lib-fix] fixed sending broadcasts bigger than memfd threshold
[platform/upstream/dbus.git] / bus / expirelist.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* expirelist.c  List of items that expire
3  *
4  * Copyright (C) 2003  Red Hat, Inc.
5  *
6  * Licensed under the Academic Free License version 2.1
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  */
23
24 #include <config.h>
25 #include "expirelist.h"
26 #include "test.h"
27 #include <dbus/dbus-internals.h>
28 #include <dbus/dbus-mainloop.h>
29 #include <dbus/dbus-timeout.h>
30
31 struct BusExpireList
32 {
33   DBusList      *items; /**< List of BusExpireItem */
34   DBusTimeout   *timeout;
35   DBusLoop      *loop;
36   BusExpireFunc  expire_func;
37   void          *data;
38   int            expire_after; /**< Expire after milliseconds (thousandths) */
39 };
40
41 static dbus_bool_t expire_timeout_handler (void *data);
42
43 BusExpireList*
44 bus_expire_list_new (DBusLoop      *loop,
45                      int            expire_after,
46                      BusExpireFunc  expire_func,
47                      void          *data)
48 {
49   BusExpireList *list;
50
51   list = dbus_new0 (BusExpireList, 1);
52   if (list == NULL)
53     return NULL;
54
55   list->expire_func = expire_func;
56   list->data = data;
57   list->loop = loop;
58   list->expire_after = expire_after;
59
60   list->timeout = _dbus_timeout_new (100, /* irrelevant */
61                                      expire_timeout_handler,
62                                      list, NULL);
63   if (list->timeout == NULL)
64     goto failed;
65
66   _dbus_timeout_set_enabled (list->timeout, FALSE);
67
68   if (!_dbus_loop_add_timeout (list->loop, list->timeout))
69     goto failed;
70
71   return list;
72
73  failed:
74   if (list->timeout)
75     _dbus_timeout_unref (list->timeout);
76
77   dbus_free (list);
78
79   return NULL;
80 }
81
82 void
83 bus_expire_list_free (BusExpireList *list)
84 {
85   _dbus_assert (list->items == NULL);
86
87   _dbus_loop_remove_timeout (list->loop, list->timeout);
88
89   _dbus_timeout_unref (list->timeout);
90
91   dbus_free (list);
92 }
93
94 void
95 bus_expire_timeout_set_interval (DBusTimeout   *timeout,
96                                  int            next_interval)
97 {
98   if (next_interval >= 0)
99     {
100       _dbus_timeout_set_interval (timeout,
101                                   next_interval);
102       _dbus_timeout_set_enabled (timeout, TRUE);
103
104       _dbus_verbose ("Enabled an expire timeout with interval %d\n",
105                      next_interval);
106     }
107   else if (dbus_timeout_get_enabled (timeout))
108     {
109       _dbus_timeout_set_enabled (timeout, FALSE);
110
111       _dbus_verbose ("Disabled an expire timeout\n");
112     }
113   else
114     _dbus_verbose ("No need to disable this expire timeout\n");
115 }
116
117 void
118 bus_expire_list_recheck_immediately (BusExpireList *list)
119 {
120   _dbus_verbose ("setting interval on expire list to 0 for immediate recheck\n");
121
122   bus_expire_timeout_set_interval (list->timeout, 0);
123 }
124
125 static int
126 do_expiration_with_monotonic_time (BusExpireList *list,
127                                    long           tv_sec,
128                                    long           tv_usec)
129 {
130   DBusList *link;
131   int next_interval, min_wait_time, items_to_expire;
132
133   next_interval = -1;
134   min_wait_time = 3600 * 1000; /* this is reset anyway if used */
135   items_to_expire = 0;
136   
137   link = _dbus_list_get_first_link (&list->items);
138   while (link != NULL)
139     {
140       DBusList *next = _dbus_list_get_next_link (&list->items, link);
141       double elapsed;
142       BusExpireItem *item;
143
144       item = link->data;
145
146       elapsed = ELAPSED_MILLISECONDS_SINCE (item->added_tv_sec,
147                                             item->added_tv_usec,
148                                             tv_sec, tv_usec);
149
150       if (((item->added_tv_sec == 0) && (item->added_tv_usec == 0)) ||
151           ((list->expire_after > 0) && (elapsed >= (double) list->expire_after)))
152         {
153           _dbus_verbose ("Expiring an item %p\n", item);
154
155           /* If the expire function fails, we just end up expiring
156            * this item next time we walk through the list. This would
157            * be an indeterminate time normally, so we set up the
158            * next_interval to be "shortly" (just enough to avoid
159            * a busy loop)
160            */
161           if (!(* list->expire_func) (list, link, list->data))
162             {
163               next_interval = _dbus_get_oom_wait ();
164               break;
165             }
166         }
167       else if (list->expire_after > 0)
168         {
169           double to_wait;
170
171           items_to_expire = 1;
172           to_wait = (double) list->expire_after - elapsed;
173           if (min_wait_time > to_wait)
174             min_wait_time = to_wait;
175         }
176
177       link = next;
178     }
179
180   if (next_interval < 0 && items_to_expire)
181     next_interval = min_wait_time;
182
183   return next_interval;
184 }
185
186 static void
187 bus_expirelist_expire (BusExpireList *list)
188 {
189   int next_interval;
190
191   next_interval = -1;
192
193   if (list->items != NULL)
194     {
195       long tv_sec, tv_usec;
196
197       _dbus_get_monotonic_time (&tv_sec, &tv_usec);
198
199       next_interval = do_expiration_with_monotonic_time (list, tv_sec, tv_usec);
200     }
201
202   bus_expire_timeout_set_interval (list->timeout, next_interval);
203 }
204
205 static dbus_bool_t
206 expire_timeout_handler (void *data)
207 {
208   BusExpireList *list = data;
209
210   _dbus_verbose ("Running\n");
211
212   /* note that this may remove the timeout */
213   bus_expirelist_expire (list);
214
215   return TRUE;
216 }
217
218 void
219 bus_expire_list_remove_link (BusExpireList *list,
220                              DBusList      *link)
221 {
222   _dbus_list_remove_link (&list->items, link);
223 }
224
225 dbus_bool_t
226 bus_expire_list_remove (BusExpireList *list,
227                         BusExpireItem *item)
228 {
229   return _dbus_list_remove (&list->items, item);
230 }
231
232 void
233 bus_expire_list_unlink (BusExpireList *list,
234                         DBusList      *link)
235 {
236   _dbus_list_unlink (&list->items, link);
237 }
238
239 dbus_bool_t
240 bus_expire_list_add (BusExpireList *list,
241                      BusExpireItem *item)
242 {
243   dbus_bool_t ret;
244
245   ret = _dbus_list_prepend (&list->items, item);
246   if (ret && !dbus_timeout_get_enabled (list->timeout))
247     bus_expire_timeout_set_interval (list->timeout, 0);
248
249   return ret;
250 }
251
252 void
253 bus_expire_list_add_link (BusExpireList *list,
254                           DBusList      *link)
255 {
256   _dbus_assert (link->data != NULL);
257   
258   _dbus_list_prepend_link (&list->items, link);
259
260   if (!dbus_timeout_get_enabled (list->timeout))
261     bus_expire_timeout_set_interval (list->timeout, 0);
262 }
263
264 DBusList*
265 bus_expire_list_get_first_link (BusExpireList *list)
266 {
267   return _dbus_list_get_first_link (&list->items);
268 }
269
270 DBusList*
271 bus_expire_list_get_next_link (BusExpireList *list,
272                                DBusList      *link)
273 {
274   return _dbus_list_get_next_link (&list->items, link);
275 }
276
277 dbus_bool_t
278 bus_expire_list_contains_item (BusExpireList *list,
279                                BusExpireItem *item)
280 {
281   return _dbus_list_find_last (&list->items, item) != NULL;
282 }
283
284 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
285
286 typedef struct
287 {
288   BusExpireItem item;
289   int expire_count;
290 } TestExpireItem;
291
292 static dbus_bool_t
293 test_expire_func (BusExpireList *list,
294                   DBusList      *link,
295                   void          *data)
296 {
297   TestExpireItem *t;
298
299   t = (TestExpireItem*) link->data;
300
301   t->expire_count += 1;
302
303   return TRUE;
304 }
305
306 static void
307 time_add_milliseconds (long *tv_sec,
308                        long *tv_usec,
309                        int   milliseconds)
310 {
311   *tv_sec = *tv_sec + milliseconds / 1000;
312   *tv_usec = *tv_usec + milliseconds * 1000;
313   if (*tv_usec >= 1000000)
314     {
315       *tv_usec -= 1000000;
316       *tv_sec += 1;
317     }
318 }
319
320 dbus_bool_t
321 bus_expire_list_test (const DBusString *test_data_dir)
322 {
323   DBusLoop *loop;
324   BusExpireList *list;
325   long tv_sec, tv_usec;
326   long tv_sec_not_expired, tv_usec_not_expired;
327   long tv_sec_expired, tv_usec_expired;
328   long tv_sec_past, tv_usec_past;
329   TestExpireItem *item;
330   int next_interval;
331   dbus_bool_t result = FALSE;
332
333
334   loop = _dbus_loop_new ();
335   _dbus_assert (loop != NULL);
336
337 #define EXPIRE_AFTER 100
338   
339   list = bus_expire_list_new (loop, EXPIRE_AFTER,
340                               test_expire_func, NULL);
341   _dbus_assert (list != NULL);
342
343   _dbus_get_monotonic_time (&tv_sec, &tv_usec);
344
345   tv_sec_not_expired = tv_sec;
346   tv_usec_not_expired = tv_usec;
347   time_add_milliseconds (&tv_sec_not_expired,
348                          &tv_usec_not_expired, EXPIRE_AFTER - 1);
349
350   tv_sec_expired = tv_sec;
351   tv_usec_expired = tv_usec;
352   time_add_milliseconds (&tv_sec_expired,
353                          &tv_usec_expired, EXPIRE_AFTER);
354   
355
356   tv_sec_past = tv_sec - 1;
357   tv_usec_past = tv_usec;
358
359   item = dbus_new0 (TestExpireItem, 1);
360
361   if (item == NULL)
362     goto oom;
363
364   item->item.added_tv_sec = tv_sec;
365   item->item.added_tv_usec = tv_usec;
366   if (!bus_expire_list_add (list, &item->item))
367     _dbus_assert_not_reached ("out of memory");
368
369   next_interval =
370     do_expiration_with_monotonic_time (list, tv_sec_not_expired,
371                                        tv_usec_not_expired);
372   _dbus_assert (item->expire_count == 0);
373   _dbus_verbose ("next_interval = %d\n", next_interval);
374   _dbus_assert (next_interval == 1);
375   
376   next_interval =
377     do_expiration_with_monotonic_time (list, tv_sec_expired,
378                                        tv_usec_expired);
379   _dbus_assert (item->expire_count == 1);
380   _dbus_verbose ("next_interval = %d\n", next_interval);
381   _dbus_assert (next_interval == -1);
382
383   next_interval =
384     do_expiration_with_monotonic_time (list, tv_sec_past,
385                                        tv_usec_past);
386   _dbus_assert (item->expire_count == 1);
387   _dbus_verbose ("next_interval = %d\n", next_interval);
388   _dbus_assert (next_interval == 1000 + EXPIRE_AFTER);
389
390   bus_expire_list_remove (list, &item->item);
391   dbus_free (item);
392   
393   bus_expire_list_free (list);
394   _dbus_loop_unref (loop);
395   
396   result = TRUE;
397
398  oom:
399   return result;
400 }
401
402 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */