2 Unix SMB/CIFS implementation.
4 common events code for timed events
6 Copyright (C) Andrew Tridgell 2003-2006
7 Copyright (C) Stefan Metzmacher 2005-2009
9 ** NOTE! The following LGPL license applies to the tevent
10 ** library. This does NOT imply that all of Samba is released
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 3 of the License, or (at your option) any later version.
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, see <http://www.gnu.org/licenses/>.
28 #include "system/time.h"
30 #include "tevent_internal.h"
31 #include "tevent_util.h"
34 compare two timeval structures.
35 Return -1 if tv1 < tv2
36 Return 0 if tv1 == tv2
39 int tevent_timeval_compare(const struct timeval
*tv1
, const struct timeval
*tv2
)
41 if (tv1
->tv_sec
> tv2
->tv_sec
) return 1;
42 if (tv1
->tv_sec
< tv2
->tv_sec
) return -1;
43 if (tv1
->tv_usec
> tv2
->tv_usec
) return 1;
44 if (tv1
->tv_usec
< tv2
->tv_usec
) return -1;
51 struct timeval
tevent_timeval_zero(void)
60 return a timeval for the current time
62 struct timeval
tevent_timeval_current(void)
65 gettimeofday(&tv
, NULL
);
70 return a timeval struct with the given elements
72 struct timeval
tevent_timeval_set(uint32_t secs
, uint32_t usecs
)
81 return the difference between two timevals as a timeval
82 if tv1 comes after tv2, then return a zero timeval
85 struct timeval
tevent_timeval_until(const struct timeval
*tv1
,
86 const struct timeval
*tv2
)
89 if (tevent_timeval_compare(tv1
, tv2
) >= 0) {
90 return tevent_timeval_zero();
92 t
.tv_sec
= tv2
->tv_sec
- tv1
->tv_sec
;
93 if (tv1
->tv_usec
> tv2
->tv_usec
) {
95 t
.tv_usec
= 1000000 - (tv1
->tv_usec
- tv2
->tv_usec
);
97 t
.tv_usec
= tv2
->tv_usec
- tv1
->tv_usec
;
103 return true if a timeval is zero
105 bool tevent_timeval_is_zero(const struct timeval
*tv
)
107 return tv
->tv_sec
== 0 && tv
->tv_usec
== 0;
110 struct timeval
tevent_timeval_add(const struct timeval
*tv
, uint32_t secs
,
113 struct timeval tv2
= *tv
;
115 tv2
.tv_usec
+= usecs
;
116 tv2
.tv_sec
+= tv2
.tv_usec
/ 1000000;
117 tv2
.tv_usec
= tv2
.tv_usec
% 1000000;
123 return a timeval in the future with a specified offset
125 struct timeval
tevent_timeval_current_ofs(uint32_t secs
, uint32_t usecs
)
127 struct timeval tv
= tevent_timeval_current();
128 return tevent_timeval_add(&tv
, secs
, usecs
);
132 destroy a timed event
134 static int tevent_common_timed_destructor(struct tevent_timer
*te
)
136 tevent_debug(te
->event_ctx
, TEVENT_DEBUG_TRACE
,
137 "Destroying timer event %p \"%s\"\n",
138 te
, te
->handler_name
);
141 DLIST_REMOVE(te
->event_ctx
->timer_events
, te
);
147 static int tevent_common_timed_deny_destructor(struct tevent_timer
*te
)
154 return NULL on failure (memory allocation error)
156 struct tevent_timer
*tevent_common_add_timer(struct tevent_context
*ev
, TALLOC_CTX
*mem_ctx
,
157 struct timeval next_event
,
158 tevent_timer_handler_t handler
,
160 const char *handler_name
,
161 const char *location
)
163 struct tevent_timer
*te
, *prev_te
, *cur_te
;
165 te
= talloc(mem_ctx
?mem_ctx
:ev
, struct tevent_timer
);
166 if (te
== NULL
) return NULL
;
169 te
->next_event
= next_event
;
170 te
->handler
= handler
;
171 te
->private_data
= private_data
;
172 te
->handler_name
= handler_name
;
173 te
->location
= location
;
174 te
->additional_data
= NULL
;
176 /* keep the list ordered */
179 * we traverse the list from the tail
180 * because it's much more likely that
181 * timers are added at the end of the list
183 for (cur_te
= DLIST_TAIL(ev
->timer_events
);
185 cur_te
= DLIST_PREV(cur_te
))
190 * if the new event comes before the current
191 * we continue searching
193 ret
= tevent_timeval_compare(&te
->next_event
,
194 &cur_te
->next_event
);
203 DLIST_ADD_AFTER(ev
->timer_events
, te
, prev_te
);
205 talloc_set_destructor(te
, tevent_common_timed_destructor
);
207 tevent_debug(ev
, TEVENT_DEBUG_TRACE
,
208 "Added timed event \"%s\": %p\n",
214 do a single event loop using the events defined in ev
216 return the delay until the next timed event,
217 or zero if a timed event was triggered
219 struct timeval
tevent_common_loop_timer_delay(struct tevent_context
*ev
)
221 struct timeval current_time
= tevent_timeval_zero();
222 struct tevent_timer
*te
= ev
->timer_events
;
225 /* have a default tick time of 30 seconds. This guarantees
226 that code that uses its own timeout checking will be
227 able to proceed eventually */
228 return tevent_timeval_set(30, 0);
232 * work out the right timeout for the next timed event
234 * avoid the syscall to gettimeofday() if the timed event should
235 * be triggered directly
237 * if there's a delay till the next timed event, we're done
238 * with just returning the delay
240 if (!tevent_timeval_is_zero(&te
->next_event
)) {
241 struct timeval delay
;
243 current_time
= tevent_timeval_current();
245 delay
= tevent_timeval_until(¤t_time
, &te
->next_event
);
246 if (!tevent_timeval_is_zero(&delay
)) {
252 * ok, we have a timed event that we'll process ...
255 /* deny the handler to free the event */
256 talloc_set_destructor(te
, tevent_common_timed_deny_destructor
);
258 /* We need to remove the timer from the list before calling the
259 * handler because in a semi-async inner event loop called from the
260 * handler we don't want to come across this event again -- vl */
261 DLIST_REMOVE(ev
->timer_events
, te
);
263 tevent_debug(te
->event_ctx
, TEVENT_DEBUG_TRACE
,
264 "Running timer event %p \"%s\"\n",
265 te
, te
->handler_name
);
268 * If the timed event was registered for a zero current_time,
269 * then we pass a zero timeval here too! To avoid the
270 * overhead of gettimeofday() calls.
272 * otherwise we pass the current time
274 te
->handler(ev
, te
, current_time
, te
->private_data
);
276 /* The destructor isn't necessary anymore, we've already removed the
277 * event from the list. */
278 talloc_set_destructor(te
, NULL
);
280 tevent_debug(te
->event_ctx
, TEVENT_DEBUG_TRACE
,
281 "Ending timer event %p \"%s\"\n",
282 te
, te
->handler_name
);
286 return tevent_timeval_zero();