efb3ff564c498465b209b6af33b3f9b5e3430065
[gd/samba-autobuild/.git] / lib / tevent / tevent_select.c
1 /* 
2    Unix SMB/CIFS implementation.
3    main select loop and event handling
4    Copyright (C) Andrew Tridgell        2003-2005
5    Copyright (C) Stefan Metzmacher      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 /*
22   This is SAMBA's default event loop code
23
24 */
25
26 #include "replace.h"
27 #include "system/filesys.h"
28 #include "system/select.h"
29 #include "tevent.h"
30 #include "tevent_util.h"
31 #include "tevent_internal.h"
32
33 struct select_event_context {
34         /* a pointer back to the generic event_context */
35         struct event_context *ev;
36
37         /* list of filedescriptor events */
38         struct fd_event *fd_events;
39
40         /* list of timed events */
41         struct timed_event *timed_events;
42
43         /* the maximum file descriptor number in fd_events */
44         int maxfd;
45
46         /* information for exiting from the event loop */
47         int exit_code;
48
49         /* this is incremented when the loop over events causes something which
50            could change the events yet to be processed */
51         uint32_t destruction_count;
52 };
53
54 /*
55   create a select_event_context structure.
56 */
57 static int select_event_context_init(struct event_context *ev)
58 {
59         struct select_event_context *select_ev;
60
61         select_ev = talloc_zero(ev, struct select_event_context);
62         if (!select_ev) return -1;
63         select_ev->ev = ev;
64
65         ev->additional_data = select_ev;
66         return 0;
67 }
68
69 /*
70   recalculate the maxfd
71 */
72 static void calc_maxfd(struct select_event_context *select_ev)
73 {
74         struct fd_event *fde;
75
76         select_ev->maxfd = 0;
77         for (fde = select_ev->fd_events; fde; fde = fde->next) {
78                 if (fde->fd > select_ev->maxfd) {
79                         select_ev->maxfd = fde->fd;
80                 }
81         }
82 }
83
84
85 /* to mark the ev->maxfd invalid
86  * this means we need to recalculate it
87  */
88 #define EVENT_INVALID_MAXFD (-1)
89
90 /*
91   destroy an fd_event
92 */
93 static int select_event_fd_destructor(struct fd_event *fde)
94 {
95         struct event_context *ev = fde->event_ctx;
96         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
97                                                            struct select_event_context);
98
99         if (select_ev->maxfd == fde->fd) {
100                 select_ev->maxfd = EVENT_INVALID_MAXFD;
101         }
102
103         DLIST_REMOVE(select_ev->fd_events, fde);
104         select_ev->destruction_count++;
105
106         if (fde->flags & EVENT_FD_AUTOCLOSE) {
107                 close(fde->fd);
108                 fde->fd = -1;
109         }
110
111         return 0;
112 }
113
114 /*
115   add a fd based event
116   return NULL on failure (memory allocation error)
117 */
118 static struct fd_event *select_event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
119                                          int fd, uint16_t flags,
120                                          event_fd_handler_t handler,
121                                          void *private_data)
122 {
123         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
124                                                            struct select_event_context);
125         struct fd_event *fde;
126
127         fde = talloc(mem_ctx?mem_ctx:ev, struct fd_event);
128         if (!fde) return NULL;
129
130         fde->event_ctx          = ev;
131         fde->fd                 = fd;
132         fde->flags              = flags;
133         fde->handler            = handler;
134         fde->private_data       = private_data;
135         fde->additional_flags   = 0;
136         fde->additional_data    = NULL;
137
138         DLIST_ADD(select_ev->fd_events, fde);
139         if (fde->fd > select_ev->maxfd) {
140                 select_ev->maxfd = fde->fd;
141         }
142         talloc_set_destructor(fde, select_event_fd_destructor);
143
144         return fde;
145 }
146
147
148 /*
149   return the fd event flags
150 */
151 static uint16_t select_event_get_fd_flags(struct fd_event *fde)
152 {
153         return fde->flags;
154 }
155
156 /*
157   set the fd event flags
158 */
159 static void select_event_set_fd_flags(struct fd_event *fde, uint16_t flags)
160 {
161         struct event_context *ev;
162         struct select_event_context *select_ev;
163
164         if (fde->flags == flags) return;
165
166         ev = fde->event_ctx;
167         select_ev = talloc_get_type(ev->additional_data, struct select_event_context);
168
169         fde->flags = flags;
170 }
171
172 /*
173   event loop handling using select()
174 */
175 static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp)
176 {
177         fd_set r_fds, w_fds;
178         struct fd_event *fde;
179         int selrtn;
180         uint32_t destruction_count = ++select_ev->destruction_count;
181
182         /* we maybe need to recalculate the maxfd */
183         if (select_ev->maxfd == EVENT_INVALID_MAXFD) {
184                 calc_maxfd(select_ev);
185         }
186
187         FD_ZERO(&r_fds);
188         FD_ZERO(&w_fds);
189
190         /* setup any fd events */
191         for (fde = select_ev->fd_events; fde; fde = fde->next) {
192                 if (fde->flags & EVENT_FD_READ) {
193                         FD_SET(fde->fd, &r_fds);
194                 }
195                 if (fde->flags & EVENT_FD_WRITE) {
196                         FD_SET(fde->fd, &w_fds);
197                 }
198         }
199
200         if (select_ev->ev->num_signal_handlers && 
201             common_event_check_signal(select_ev->ev)) {
202                 return 0;
203         }
204
205         selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
206
207         if (selrtn == -1 && errno == EINTR && 
208             select_ev->ev->num_signal_handlers) {
209                 common_event_check_signal(select_ev->ev);
210                 return 0;
211         }
212
213         if (selrtn == -1 && errno == EBADF) {
214                 /* the socket is dead! this should never
215                    happen as the socket should have first been
216                    made readable and that should have removed
217                    the event, so this must be a bug. This is a
218                    fatal error. */
219                 ev_debug(select_ev->ev, EV_DEBUG_FATAL,
220                          "ERROR: EBADF on select_event_loop_once\n");
221                 select_ev->exit_code = EBADF;
222                 return -1;
223         }
224
225         if (selrtn == 0 && tvalp) {
226                 /* we don't care about a possible delay here */
227                 common_event_loop_timer_delay(select_ev->ev);
228                 return 0;
229         }
230
231         if (selrtn > 0) {
232                 /* at least one file descriptor is ready - check
233                    which ones and call the handler, being careful to allow
234                    the handler to remove itself when called */
235                 for (fde = select_ev->fd_events; fde; fde = fde->next) {
236                         uint16_t flags = 0;
237
238                         if (FD_ISSET(fde->fd, &r_fds)) flags |= EVENT_FD_READ;
239                         if (FD_ISSET(fde->fd, &w_fds)) flags |= EVENT_FD_WRITE;
240                         if (flags) {
241                                 fde->handler(select_ev->ev, fde, flags, fde->private_data);
242                                 if (destruction_count != select_ev->destruction_count) {
243                                         break;
244                                 }
245                         }
246                 }
247         }
248
249         return 0;
250 }               
251
252 /*
253   do a single event loop using the events defined in ev 
254 */
255 static int select_event_loop_once(struct event_context *ev)
256 {
257         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
258                                                            struct select_event_context);
259         struct timeval tval;
260
261         tval = common_event_loop_timer_delay(ev);
262         if (ev_timeval_is_zero(&tval)) {
263                 return 0;
264         }
265
266         return select_event_loop_select(select_ev, &tval);
267 }
268
269 /*
270   return on failure or (with 0) if all fd events are removed
271 */
272 static int select_event_loop_wait(struct event_context *ev)
273 {
274         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
275                                                            struct select_event_context);
276         select_ev->exit_code = 0;
277
278         while (select_ev->fd_events && select_ev->exit_code == 0) {
279                 if (select_event_loop_once(ev) != 0) {
280                         break;
281                 }
282         }
283
284         return select_ev->exit_code;
285 }
286
287 static const struct event_ops select_event_ops = {
288         .context_init   = select_event_context_init,
289         .add_fd         = select_event_add_fd,
290         .get_fd_flags   = select_event_get_fd_flags,
291         .set_fd_flags   = select_event_set_fd_flags,
292         .add_timer      = common_event_add_timed,
293         .add_signal     = common_event_add_signal,
294         .loop_once      = select_event_loop_once,
295         .loop_wait      = select_event_loop_wait,
296 };
297
298 bool events_select_init(void)
299 {
300         return event_register_backend("select", &select_event_ops);
301 }
302