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 32struct 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 43/* 44 create a select_event_context structure. 45*/ 46static int select_event_context_init(struct tevent_context *ev) 47{ 48 struct select_event_context *select_ev; 49 50 select_ev = talloc_zero(ev, struct select_event_context); 51 if (!select_ev) return -1; 52 select_ev->ev = ev; 53 54 ev->additional_data = select_ev; 55 return 0; 56} 57 58/* 59 recalculate the maxfd 60*/ 61static void calc_maxfd(struct select_event_context *select_ev) 62{ 63 struct tevent_fd *fde; 64 65 select_ev->maxfd = 0; 66 for (fde = select_ev->ev->fd_events; fde; fde = fde->next) { 67 if (fde->fd > select_ev->maxfd) { 68 select_ev->maxfd = fde->fd; 69 } 70 } 71} 72 73 74/* to mark the ev->maxfd invalid 75 * this means we need to recalculate it 76 */ 77#define EVENT_INVALID_MAXFD (-1) 78 79/* 80 destroy an fd_event 81*/ 82static int select_event_fd_destructor(struct tevent_fd *fde) 83{ 84 struct tevent_context *ev = fde->event_ctx; 85 struct select_event_context *select_ev = NULL; 86 87 if (ev) { 88 select_ev = talloc_get_type(ev->additional_data, 89 struct select_event_context); 90 91 if (select_ev->maxfd == fde->fd) { 92 select_ev->maxfd = EVENT_INVALID_MAXFD; 93 } 94 } 95 96 return tevent_common_fd_destructor(fde); 97} 98 99/* 100 add a fd based event 101 return NULL on failure (memory allocation error) 102*/ 103static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx, 104 int fd, uint16_t flags, 105 tevent_fd_handler_t handler, 106 void *private_data, 107 const char *handler_name, 108 const char *location) 109{ 110 struct select_event_context *select_ev = talloc_get_type(ev->additional_data, 111 struct select_event_context); 112 struct tevent_fd *fde; 113 114 if (fd < 0 || fd >= FD_SETSIZE) { 115 errno = EBADF; 116 return NULL; 117 } 118 119 fde = tevent_common_add_fd(ev, mem_ctx, fd, flags, 120 handler, private_data, 121 handler_name, location); 122 if (!fde) return NULL; 123 124 if (fde->fd > select_ev->maxfd) { 125 select_ev->maxfd = fde->fd; 126 } 127 talloc_set_destructor(fde, select_event_fd_destructor); 128 129 return fde; 130} 131 132/* 133 event loop handling using select() 134*/ 135static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp) 136{ 137 fd_set r_fds, w_fds; 138 struct tevent_fd *fde; 139 int selrtn; 140 141 /* we maybe need to recalculate the maxfd */ 142 if (select_ev->maxfd == EVENT_INVALID_MAXFD) { 143 calc_maxfd(select_ev); 144 } 145 146 FD_ZERO(&r_fds); 147 FD_ZERO(&w_fds); 148 149 /* setup any fd events */ 150 for (fde = select_ev->ev->fd_events; fde; fde = fde->next) { 151 if (fde->fd < 0 || fde->fd >= FD_SETSIZE) { 152 errno = EBADF; 153 return -1; 154 } 155 156 if (fde->flags & TEVENT_FD_READ) { 157 FD_SET(fde->fd, &r_fds); 158 } 159 if (fde->flags & TEVENT_FD_WRITE) { 160 FD_SET(fde->fd, &w_fds); 161 } 162 } 163 164 if (select_ev->ev->signal_events && 165 tevent_common_check_signal(select_ev->ev)) { 166 return 0; 167 } 168 169 selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp); 170 171 if (selrtn == -1 && errno == EINTR && 172 select_ev->ev->signal_events) { 173 tevent_common_check_signal(select_ev->ev); 174 return 0; 175 } 176 177 if (selrtn == -1 && errno == EBADF) { 178 /* the socket is dead! this should never 179 happen as the socket should have first been 180 made readable and that should have removed 181 the event, so this must be a bug. This is a 182 fatal error. */ 183 tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL, 184 "ERROR: EBADF on select_event_loop_once\n"); 185 select_ev->exit_code = EBADF; 186 return -1; 187 } 188 189 if (selrtn == 0 && tvalp) { 190 /* we don't care about a possible delay here */ 191 tevent_common_loop_timer_delay(select_ev->ev); 192 return 0; 193 } 194 195 if (selrtn > 0) { 196 /* at least one file descriptor is ready - check 197 which ones and call the handler, being careful to allow 198 the handler to remove itself when called */ 199 for (fde = select_ev->ev->fd_events; fde; fde = fde->next) { 200 uint16_t flags = 0; 201 202 if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ; 203 if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE; 204 if (flags) { 205 fde->handler(select_ev->ev, fde, flags, fde->private_data); 206 break; 207 } 208 } 209 } 210 211 return 0; 212} 213 214/* 215 do a single event loop using the events defined in ev 216*/ 217static int select_event_loop_once(struct tevent_context *ev, const char *location) 218{ 219 struct select_event_context *select_ev = talloc_get_type(ev->additional_data, 220 struct select_event_context); 221 struct timeval tval; 222 223 if (ev->signal_events && 224 tevent_common_check_signal(ev)) { 225 return 0; 226 } 227 228 if (ev->immediate_events && 229 tevent_common_loop_immediate(ev)) { 230 return 0; 231 } 232 233 tval = tevent_common_loop_timer_delay(ev); 234 if (tevent_timeval_is_zero(&tval)) { 235 return 0; 236 } 237 238 return select_event_loop_select(select_ev, &tval); 239} 240 241static const struct tevent_ops select_event_ops = { 242 .context_init = select_event_context_init, 243 .add_fd = select_event_add_fd, 244 .set_fd_close_fn = tevent_common_fd_set_close_fn, 245 .get_fd_flags = tevent_common_fd_get_flags, 246 .set_fd_flags = tevent_common_fd_set_flags, 247 .add_timer = tevent_common_add_timer, 248 .schedule_immediate = tevent_common_schedule_immediate, 249 .add_signal = tevent_common_add_signal, 250 .loop_once = select_event_loop_once, 251 .loop_wait = tevent_common_loop_wait, 252}; 253 254bool tevent_select_init(void) 255{ 256 return tevent_register_backend("select", &select_event_ops); 257} 258