s3-utils/net_rpc_printer.c: print more info on write error
[Samba/gebeck_regimport.git] / lib / tevent / tevent_timed.c
blobf7c39697d9d11ab25e873fd202cc64d64c97b601
1 /*
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
11 ** under the LGPL
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/>.
27 #include "replace.h"
28 #include "system/time.h"
29 #include "tevent.h"
30 #include "tevent_internal.h"
31 #include "tevent_util.h"
33 /**
34 compare two timeval structures.
35 Return -1 if tv1 < tv2
36 Return 0 if tv1 == tv2
37 Return 1 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;
45 return 0;
48 /**
49 return a zero timeval
51 struct timeval tevent_timeval_zero(void)
53 struct timeval tv;
54 tv.tv_sec = 0;
55 tv.tv_usec = 0;
56 return tv;
59 /**
60 return a timeval for the current time
62 struct timeval tevent_timeval_current(void)
64 struct timeval tv;
65 gettimeofday(&tv, NULL);
66 return tv;
69 /**
70 return a timeval struct with the given elements
72 struct timeval tevent_timeval_set(uint32_t secs, uint32_t usecs)
74 struct timeval tv;
75 tv.tv_sec = secs;
76 tv.tv_usec = usecs;
77 return tv;
80 /**
81 return the difference between two timevals as a timeval
82 if tv1 comes after tv2, then return a zero timeval
83 (this is *tv2 - *tv1)
85 struct timeval tevent_timeval_until(const struct timeval *tv1,
86 const struct timeval *tv2)
88 struct timeval t;
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) {
94 t.tv_sec--;
95 t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
96 } else {
97 t.tv_usec = tv2->tv_usec - tv1->tv_usec;
99 return t;
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,
111 uint32_t usecs)
113 struct timeval tv2 = *tv;
114 tv2.tv_sec += secs;
115 tv2.tv_usec += usecs;
116 tv2.tv_sec += tv2.tv_usec / 1000000;
117 tv2.tv_usec = tv2.tv_usec % 1000000;
119 return tv2;
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);
140 if (te->event_ctx) {
141 DLIST_REMOVE(te->event_ctx->timer_events, te);
144 return 0;
147 static int tevent_common_timed_deny_destructor(struct tevent_timer *te)
149 return -1;
153 add a timed event
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,
159 void *private_data,
160 const char *handler_name,
161 const char *location)
163 struct tevent_timer *te, *last_te, *cur_te;
165 te = talloc(mem_ctx?mem_ctx:ev, struct tevent_timer);
166 if (te == NULL) return NULL;
168 te->event_ctx = ev;
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 */
177 last_te = NULL;
178 for (cur_te = ev->timer_events; cur_te; cur_te = cur_te->next) {
179 /* if the new event comes before the current one break */
180 if (tevent_timeval_compare(&te->next_event, &cur_te->next_event) < 0) {
181 break;
184 last_te = cur_te;
187 DLIST_ADD_AFTER(ev->timer_events, te, last_te);
189 talloc_set_destructor(te, tevent_common_timed_destructor);
191 tevent_debug(ev, TEVENT_DEBUG_TRACE,
192 "Added timed event \"%s\": %p\n",
193 handler_name, te);
194 return te;
198 do a single event loop using the events defined in ev
200 return the delay until the next timed event,
201 or zero if a timed event was triggered
203 struct timeval tevent_common_loop_timer_delay(struct tevent_context *ev)
205 struct timeval current_time = tevent_timeval_zero();
206 struct tevent_timer *te = ev->timer_events;
208 if (!te) {
209 /* have a default tick time of 30 seconds. This guarantees
210 that code that uses its own timeout checking will be
211 able to proceed eventually */
212 return tevent_timeval_set(30, 0);
216 * work out the right timeout for the next timed event
218 * avoid the syscall to gettimeofday() if the timed event should
219 * be triggered directly
221 * if there's a delay till the next timed event, we're done
222 * with just returning the delay
224 if (!tevent_timeval_is_zero(&te->next_event)) {
225 struct timeval delay;
227 current_time = tevent_timeval_current();
229 delay = tevent_timeval_until(&current_time, &te->next_event);
230 if (!tevent_timeval_is_zero(&delay)) {
231 return delay;
236 * ok, we have a timed event that we'll process ...
239 /* deny the handler to free the event */
240 talloc_set_destructor(te, tevent_common_timed_deny_destructor);
242 /* We need to remove the timer from the list before calling the
243 * handler because in a semi-async inner event loop called from the
244 * handler we don't want to come across this event again -- vl */
245 DLIST_REMOVE(ev->timer_events, te);
248 * If the timed event was registered for a zero current_time,
249 * then we pass a zero timeval here too! To avoid the
250 * overhead of gettimeofday() calls.
252 * otherwise we pass the current time
254 te->handler(ev, te, current_time, te->private_data);
256 /* The destructor isn't necessary anymore, we've already removed the
257 * event from the list. */
258 talloc_set_destructor(te, NULL);
260 tevent_debug(te->event_ctx, TEVENT_DEBUG_TRACE,
261 "Ending timer event %p \"%s\"\n",
262 te, te->handler_name);
264 talloc_free(te);
266 return tevent_timeval_zero();