update lib/replace from samba4
[vlendec/samba-autobuild/.git] / ctdb / lib / events / events_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 "includes.h"
27 #include "system/filesys.h"
28 #include "system/select.h"
29 #include "lib/util/dlinklist.h"
30 #include "lib/events/events.h"
31 #include "lib/events/events_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                 DEBUG(0,("ERROR: EBADF on select_event_loop_once\n"));
220                 select_ev->exit_code = EBADF;
221                 return -1;
222         }
223
224         if (selrtn == 0 && tvalp) {
225                 /* we don't care about a possible delay here */
226                 common_event_loop_timer_delay(select_ev->ev);
227                 return 0;
228         }
229
230         if (selrtn > 0) {
231                 /* at least one file descriptor is ready - check
232                    which ones and call the handler, being careful to allow
233                    the handler to remove itself when called */
234                 for (fde = select_ev->fd_events; fde; fde = fde->next) {
235                         uint16_t flags = 0;
236
237                         if (FD_ISSET(fde->fd, &r_fds)) flags |= EVENT_FD_READ;
238                         if (FD_ISSET(fde->fd, &w_fds)) flags |= EVENT_FD_WRITE;
239                         if (flags) {
240                                 fde->handler(select_ev->ev, fde, flags, fde->private_data);
241                                 if (destruction_count != select_ev->destruction_count) {
242                                         break;
243                                 }
244                         }
245                 }
246         }
247
248         return 0;
249 }               
250
251 /*
252   do a single event loop using the events defined in ev 
253 */
254 static int select_event_loop_once(struct event_context *ev)
255 {
256         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
257                                                            struct select_event_context);
258         struct timeval tval;
259
260         tval = common_event_loop_timer_delay(ev);
261         if (timeval_is_zero(&tval)) {
262                 return 0;
263         }
264
265         return select_event_loop_select(select_ev, &tval);
266 }
267
268 /*
269   return on failure or (with 0) if all fd events are removed
270 */
271 static int select_event_loop_wait(struct event_context *ev)
272 {
273         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
274                                                            struct select_event_context);
275         select_ev->exit_code = 0;
276
277         while (select_ev->fd_events && select_ev->exit_code == 0) {
278                 if (select_event_loop_once(ev) != 0) {
279                         break;
280                 }
281         }
282
283         return select_ev->exit_code;
284 }
285
286 static const struct event_ops select_event_ops = {
287         .context_init   = select_event_context_init,
288         .add_fd         = select_event_add_fd,
289         .get_fd_flags   = select_event_get_fd_flags,
290         .set_fd_flags   = select_event_set_fd_flags,
291         .add_timed      = common_event_add_timed,
292         .add_signal     = common_event_add_signal,
293         .loop_once      = select_event_loop_once,
294         .loop_wait      = select_event_loop_wait,
295 };
296
297 bool events_select_init(void)
298 {
299         return event_register_backend("select", &select_event_ops);
300 }
301
302 #if _SAMBA_BUILD_
303 NTSTATUS s4_events_select_init(void)
304 {
305         if (!events_select_init()) {
306                 return NT_STATUS_INTERNAL_ERROR;
307         }
308         return NT_STATUS_OK;
309 }
310 #endif