source: trunk/server/source3/lib/events.c@ 421

Last change on this file since 421 was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 6.6 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Timed event library.
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Volker Lendecke 2005
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#include "includes.h"
22#include <tevent_internal.h>
23
24void event_fd_set_writeable(struct tevent_fd *fde)
25{
26 TEVENT_FD_WRITEABLE(fde);
27}
28
29void event_fd_set_not_writeable(struct tevent_fd *fde)
30{
31 TEVENT_FD_NOT_WRITEABLE(fde);
32}
33
34void event_fd_set_readable(struct tevent_fd *fde)
35{
36 TEVENT_FD_READABLE(fde);
37}
38
39void event_fd_set_not_readable(struct tevent_fd *fde)
40{
41 TEVENT_FD_NOT_READABLE(fde);
42}
43
44/*
45 * Return if there's something in the queue
46 */
47
48bool event_add_to_select_args(struct tevent_context *ev,
49 const struct timeval *now,
50 fd_set *read_fds, fd_set *write_fds,
51 struct timeval *timeout, int *maxfd)
52{
53 struct tevent_fd *fde;
54 struct timeval diff;
55 bool ret = false;
56
57 for (fde = ev->fd_events; fde; fde = fde->next) {
58 if (fde->flags & EVENT_FD_READ) {
59 FD_SET(fde->fd, read_fds);
60 ret = true;
61 }
62 if (fde->flags & EVENT_FD_WRITE) {
63 FD_SET(fde->fd, write_fds);
64 ret = true;
65 }
66
67 if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE))
68 && (fde->fd > *maxfd)) {
69 *maxfd = fde->fd;
70 }
71 }
72
73 if (ev->immediate_events != NULL) {
74 *timeout = timeval_zero();
75 return true;
76 }
77
78 if (ev->timer_events == NULL) {
79 return ret;
80 }
81
82 diff = timeval_until(now, &ev->timer_events->next_event);
83 *timeout = timeval_min(timeout, &diff);
84
85 return true;
86}
87
88bool run_events(struct tevent_context *ev,
89 int selrtn, fd_set *read_fds, fd_set *write_fds)
90{
91 struct tevent_fd *fde;
92 struct timeval now;
93
94 if (ev->signal_events &&
95 tevent_common_check_signal(ev)) {
96 return true;
97 }
98
99 if (ev->immediate_events &&
100 tevent_common_loop_immediate(ev)) {
101 return true;
102 }
103
104 GetTimeOfDay(&now);
105
106 if ((ev->timer_events != NULL)
107 && (timeval_compare(&now, &ev->timer_events->next_event) >= 0)) {
108
109 DEBUG(10, ("Running timed event \"%s\" %p\n",
110 ev->timer_events->handler_name, ev->timer_events));
111
112 ev->timer_events->handler(ev, ev->timer_events, now,
113 ev->timer_events->private_data);
114 return true;
115 }
116
117 if (selrtn == 0) {
118 /*
119 * No fd ready
120 */
121 return false;
122 }
123
124 for (fde = ev->fd_events; fde; fde = fde->next) {
125 uint16 flags = 0;
126
127 if (FD_ISSET(fde->fd, read_fds)) flags |= EVENT_FD_READ;
128 if (FD_ISSET(fde->fd, write_fds)) flags |= EVENT_FD_WRITE;
129
130 if (flags & fde->flags) {
131 fde->handler(ev, fde, flags, fde->private_data);
132 return true;
133 }
134 }
135
136 return false;
137}
138
139
140struct timeval *get_timed_events_timeout(struct tevent_context *ev,
141 struct timeval *to_ret)
142{
143 struct timeval now;
144
145 if ((ev->timer_events == NULL) && (ev->immediate_events == NULL)) {
146 return NULL;
147 }
148 if (ev->immediate_events != NULL) {
149 *to_ret = timeval_zero();
150 return to_ret;
151 }
152
153 now = timeval_current();
154 *to_ret = timeval_until(&now, &ev->timer_events->next_event);
155
156 DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret->tv_sec,
157 (int)to_ret->tv_usec));
158
159 return to_ret;
160}
161
162static int s3_event_loop_once(struct tevent_context *ev, const char *location)
163{
164 struct timeval now, to;
165 fd_set r_fds, w_fds;
166 int maxfd = 0;
167 int ret;
168
169 FD_ZERO(&r_fds);
170 FD_ZERO(&w_fds);
171
172 to.tv_sec = 9999; /* Max timeout */
173 to.tv_usec = 0;
174
175 if (run_events(ev, 0, NULL, NULL)) {
176 return 0;
177 }
178
179 GetTimeOfDay(&now);
180
181 if (!event_add_to_select_args(ev, &now, &r_fds, &w_fds, &to, &maxfd)) {
182 return -1;
183 }
184
185 ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
186
187 if (ret == -1 && errno != EINTR) {
188 tevent_debug(ev, TEVENT_DEBUG_FATAL,
189 "sys_select() failed: %d:%s\n",
190 errno, strerror(errno));
191 return -1;
192 }
193
194 run_events(ev, ret, &r_fds, &w_fds);
195 return 0;
196}
197
198void event_context_reinit(struct tevent_context *ev)
199{
200 tevent_common_context_destructor(ev);
201 return;
202}
203
204static int s3_event_context_init(struct tevent_context *ev)
205{
206 return 0;
207}
208
209void dump_event_list(struct tevent_context *ev)
210{
211 struct tevent_timer *te;
212 struct tevent_fd *fe;
213 struct timeval evt, now;
214
215 if (!ev) {
216 return;
217 }
218
219 now = timeval_current();
220
221 DEBUG(10,("dump_event_list:\n"));
222
223 for (te = ev->timer_events; te; te = te->next) {
224
225 evt = timeval_until(&now, &te->next_event);
226
227 DEBUGADD(10,("Timed Event \"%s\" %p handled in %d seconds (at %s)\n",
228 te->handler_name,
229 te,
230 (int)evt.tv_sec,
231 http_timestring(talloc_tos(), te->next_event.tv_sec)));
232 }
233
234 for (fe = ev->fd_events; fe; fe = fe->next) {
235
236 DEBUGADD(10,("FD Event %d %p, flags: 0x%04x\n",
237 fe->fd,
238 fe,
239 fe->flags));
240 }
241}
242
243static const struct tevent_ops s3_event_ops = {
244 .context_init = s3_event_context_init,
245 .add_fd = tevent_common_add_fd,
246 .set_fd_close_fn = tevent_common_fd_set_close_fn,
247 .get_fd_flags = tevent_common_fd_get_flags,
248 .set_fd_flags = tevent_common_fd_set_flags,
249 .add_timer = tevent_common_add_timer,
250 .schedule_immediate = tevent_common_schedule_immediate,
251 .add_signal = tevent_common_add_signal,
252 .loop_once = s3_event_loop_once,
253 .loop_wait = tevent_common_loop_wait,
254};
255
256static bool s3_tevent_init(void)
257{
258 static bool initialized;
259 if (initialized) {
260 return true;
261 }
262 initialized = tevent_register_backend("s3", &s3_event_ops);
263 tevent_set_default_backend("s3");
264 return initialized;
265}
266
267/*
268 this is used to catch debug messages from events
269*/
270static void s3_event_debug(void *context, enum tevent_debug_level level,
271 const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
272
273static void s3_event_debug(void *context, enum tevent_debug_level level,
274 const char *fmt, va_list ap)
275{
276 int samba_level = -1;
277 char *s = NULL;
278 switch (level) {
279 case TEVENT_DEBUG_FATAL:
280 samba_level = 0;
281 break;
282 case TEVENT_DEBUG_ERROR:
283 samba_level = 1;
284 break;
285 case TEVENT_DEBUG_WARNING:
286 samba_level = 2;
287 break;
288 case TEVENT_DEBUG_TRACE:
289 samba_level = 11;
290 break;
291
292 };
293 if (vasprintf(&s, fmt, ap) == -1) {
294 return;
295 }
296 DEBUG(samba_level, ("s3_event: %s", s));
297 free(s);
298}
299
300struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
301{
302 struct tevent_context *ev;
303
304 s3_tevent_init();
305
306 ev = tevent_context_init_byname(mem_ctx, "s3");
307 if (ev) {
308 tevent_set_debug(ev, s3_event_debug, NULL);
309 }
310
311 return ev;
312}
313
Note: See TracBrowser for help on using the repository browser.