lib/tevent: change to LGPLv3+
[jra/samba/.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-2009
6
7      ** NOTE! The following LGPL license applies to the tevent
8      ** library. This does NOT imply that all of Samba is released
9      ** under the LGPL
10
11    This library is free software; you can redistribute it and/or
12    modify it under the terms of the GNU Lesser General Public
13    License as published by the Free Software Foundation; either
14    version 3 of the License, or (at your option) any later version.
15
16    This library is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19    Lesser General Public License for more details.
20
21    You should have received a copy of the GNU Lesser General Public
22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "replace.h"
26 #include "system/filesys.h"
27 #include "system/select.h"
28 #include "tevent.h"
29 #include "tevent_util.h"
30 #include "tevent_internal.h"
31
32 struct select_event_context {
33         /* a pointer back to the generic event_context */
34         struct tevent_context *ev;
35
36         /* the maximum file descriptor number in fd_events */
37         int maxfd;
38
39         /* information for exiting from the event loop */
40         int exit_code;
41
42         /* this is incremented when the loop over events causes something which
43            could change the events yet to be processed */
44         uint32_t destruction_count;
45 };
46
47 /*
48   create a select_event_context structure.
49 */
50 static int select_event_context_init(struct tevent_context *ev)
51 {
52         struct select_event_context *select_ev;
53
54         select_ev = talloc_zero(ev, struct select_event_context);
55         if (!select_ev) return -1;
56         select_ev->ev = ev;
57
58         ev->additional_data = select_ev;
59         return 0;
60 }
61
62 /*
63   recalculate the maxfd
64 */
65 static void calc_maxfd(struct select_event_context *select_ev)
66 {
67         struct tevent_fd *fde;
68
69         select_ev->maxfd = 0;
70         for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
71                 if (fde->fd > select_ev->maxfd) {
72                         select_ev->maxfd = fde->fd;
73                 }
74         }
75 }
76
77
78 /* to mark the ev->maxfd invalid
79  * this means we need to recalculate it
80  */
81 #define EVENT_INVALID_MAXFD (-1)
82
83 /*
84   destroy an fd_event
85 */
86 static int select_event_fd_destructor(struct tevent_fd *fde)
87 {
88         struct tevent_context *ev = fde->event_ctx;
89         struct select_event_context *select_ev = NULL;
90
91         if (ev) {
92                 select_ev = talloc_get_type(ev->additional_data,
93                                             struct select_event_context);
94
95                 if (select_ev->maxfd == fde->fd) {
96                         select_ev->maxfd = EVENT_INVALID_MAXFD;
97                 }
98
99                 select_ev->destruction_count++;
100         }
101
102         return tevent_common_fd_destructor(fde);
103 }
104
105 /*
106   add a fd based event
107   return NULL on failure (memory allocation error)
108 */
109 static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
110                                              int fd, uint16_t flags,
111                                              tevent_fd_handler_t handler,
112                                              void *private_data,
113                                              const char *handler_name,
114                                              const char *location)
115 {
116         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
117                                                            struct select_event_context);
118         struct tevent_fd *fde;
119
120         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
121                                    handler, private_data,
122                                    handler_name, location);
123         if (!fde) return NULL;
124
125         if (fde->fd > select_ev->maxfd) {
126                 select_ev->maxfd = fde->fd;
127         }
128         talloc_set_destructor(fde, select_event_fd_destructor);
129
130         return fde;
131 }
132
133 /*
134   event loop handling using select()
135 */
136 static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp)
137 {
138         fd_set r_fds, w_fds;
139         struct tevent_fd *fde;
140         int selrtn;
141         uint32_t destruction_count = ++select_ev->destruction_count;
142
143         /* we maybe need to recalculate the maxfd */
144         if (select_ev->maxfd == EVENT_INVALID_MAXFD) {
145                 calc_maxfd(select_ev);
146         }
147
148         FD_ZERO(&r_fds);
149         FD_ZERO(&w_fds);
150
151         /* setup any fd events */
152         for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
153                 if (fde->flags & TEVENT_FD_READ) {
154                         FD_SET(fde->fd, &r_fds);
155                 }
156                 if (fde->flags & TEVENT_FD_WRITE) {
157                         FD_SET(fde->fd, &w_fds);
158                 }
159         }
160
161         if (select_ev->ev->signal_events &&
162             tevent_common_check_signal(select_ev->ev)) {
163                 return 0;
164         }
165
166         selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
167
168         if (selrtn == -1 && errno == EINTR && 
169             select_ev->ev->signal_events) {
170                 tevent_common_check_signal(select_ev->ev);
171                 return 0;
172         }
173
174         if (selrtn == -1 && errno == EBADF) {
175                 /* the socket is dead! this should never
176                    happen as the socket should have first been
177                    made readable and that should have removed
178                    the event, so this must be a bug. This is a
179                    fatal error. */
180                 tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
181                              "ERROR: EBADF on select_event_loop_once\n");
182                 select_ev->exit_code = EBADF;
183                 return -1;
184         }
185
186         if (selrtn == 0 && tvalp) {
187                 /* we don't care about a possible delay here */
188                 tevent_common_loop_timer_delay(select_ev->ev);
189                 return 0;
190         }
191
192         if (selrtn > 0) {
193                 /* at least one file descriptor is ready - check
194                    which ones and call the handler, being careful to allow
195                    the handler to remove itself when called */
196                 for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
197                         uint16_t flags = 0;
198
199                         if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
200                         if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
201                         if (flags) {
202                                 fde->handler(select_ev->ev, fde, flags, fde->private_data);
203                                 if (destruction_count != select_ev->destruction_count) {
204                                         break;
205                                 }
206                         }
207                 }
208         }
209
210         return 0;
211 }               
212
213 /*
214   do a single event loop using the events defined in ev 
215 */
216 static int select_event_loop_once(struct tevent_context *ev)
217 {
218         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
219                                                            struct select_event_context);
220         struct timeval tval;
221
222         tval = tevent_common_loop_timer_delay(ev);
223         if (ev_timeval_is_zero(&tval)) {
224                 return 0;
225         }
226
227         return select_event_loop_select(select_ev, &tval);
228 }
229
230 /*
231   return on failure or (with 0) if all fd events are removed
232 */
233 static int select_event_loop_wait(struct tevent_context *ev)
234 {
235         struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
236                                                            struct select_event_context);
237         select_ev->exit_code = 0;
238
239         while (ev->fd_events && select_ev->exit_code == 0) {
240                 if (select_event_loop_once(ev) != 0) {
241                         break;
242                 }
243         }
244
245         return select_ev->exit_code;
246 }
247
248 static const struct tevent_ops select_event_ops = {
249         .context_init   = select_event_context_init,
250         .add_fd         = select_event_add_fd,
251         .set_fd_close_fn= tevent_common_fd_set_close_fn,
252         .get_fd_flags   = tevent_common_fd_get_flags,
253         .set_fd_flags   = tevent_common_fd_set_flags,
254         .add_timer      = tevent_common_add_timer,
255         .add_signal     = tevent_common_add_signal,
256         .loop_once      = select_event_loop_once,
257         .loop_wait      = select_event_loop_wait,
258 };
259
260 bool tevent_select_init(void)
261 {
262         return tevent_register_backend("select", &select_event_ops);
263 }