1 /**************************************************************************** 2 * Copyright (c) 1998-2012,2013 Free Software Foundation, Inc. * 3 * * 4 * Permission is hereby granted, free of charge, to any person obtaining a * 5 * copy of this software and associated documentation files (the * 6 * "Software"), to deal in the Software without restriction, including * 7 * without limitation the rights to use, copy, modify, merge, publish, * 8 * distribute, distribute with modifications, sublicense, and/or sell * 9 * copies of the Software, and to permit persons to whom the Software is * 10 * furnished to do so, subject to the following conditions: * 11 * * 12 * The above copyright notice and this permission notice shall be included * 13 * in all copies or substantial portions of the Software. * 14 * * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 22 * * 23 * Except as contained in this notice, the name(s) of the above copyright * 24 * holders shall not be used in advertising or otherwise to promote the * 25 * sale, use or other dealings in this Software without prior written * 26 * authorization. * 27 ****************************************************************************/ 28 29 /**************************************************************************** 30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * 31 * and: Eric S. Raymond <esr@snark.thyrsus.com> * 32 * and: Thomas E. Dickey 1996-on * 33 ****************************************************************************/ 34 35 /* 36 ** lib_twait.c 37 ** 38 ** The routine _nc_timed_wait(). 39 ** 40 ** (This file was originally written by Eric Raymond; however except for 41 ** comments, none of the original code remains - T.Dickey). 42 */ 43 44 #include <curses.priv.h> 45 46 #if defined __HAIKU__ && defined __BEOS__ 47 #undef __BEOS__ 48 #endif 49 50 #ifdef __BEOS__ 51 #undef false 52 #undef true 53 #include <OS.h> 54 #endif 55 56 #if USE_KLIBC_KBD 57 #define INCL_KBD 58 #include <os2.h> 59 #endif 60 61 #if USE_FUNC_POLL 62 # if HAVE_SYS_TIME_H 63 # include <sys/time.h> 64 # endif 65 #elif HAVE_SELECT 66 # if HAVE_SYS_TIME_H && HAVE_SYS_TIME_SELECT 67 # include <sys/time.h> 68 # endif 69 # if HAVE_SYS_SELECT_H 70 # include <sys/select.h> 71 # endif 72 #endif 73 #ifdef __MINGW32__ 74 # include <sys/time.h> 75 #endif 76 #undef CUR 77 78 MODULE_ID("$Id: lib_twait.c,v 1.67 2013/02/18 09:22:27 tom Exp $") 79 80 static long 81 _nc_gettime(TimeType * t0, int first) 82 { 83 long res; 84 85 #if PRECISE_GETTIME 86 TimeType t1; 87 gettimeofday(&t1, (struct timezone *) 0); 88 if (first) { 89 *t0 = t1; 90 res = 0; 91 } else { 92 /* .tv_sec and .tv_usec are unsigned, be careful when subtracting */ 93 if (t0->tv_usec > t1.tv_usec) { 94 t1.tv_usec += 1000000; /* Convert 1s in 1e6 microsecs */ 95 t1.tv_sec--; 96 } 97 res = (t1.tv_sec - t0->tv_sec) * 1000 98 + (t1.tv_usec - t0->tv_usec) / 1000; 99 } 100 #else 101 time_t t1 = time((time_t *) 0); 102 if (first) { 103 *t0 = t1; 104 } 105 res = (t1 - *t0) * 1000; 106 #endif 107 TR(TRACE_IEVENT, ("%s time: %ld msec", first ? "get" : "elapsed", res)); 108 return res; 109 } 110 111 #ifdef NCURSES_WGETCH_EVENTS 112 NCURSES_EXPORT(int) 113 _nc_eventlist_timeout(_nc_eventlist * evl) 114 { 115 int event_delay = -1; 116 int n; 117 118 if (evl != 0) { 119 120 for (n = 0; n < evl->count; ++n) { 121 _nc_event *ev = evl->events[n]; 122 123 if (ev->type == _NC_EVENT_TIMEOUT_MSEC) { 124 event_delay = ev->data.timeout_msec; 125 if (event_delay < 0) 126 event_delay = INT_MAX; /* FIXME Is this defined? */ 127 } 128 } 129 } 130 return event_delay; 131 } 132 #endif /* NCURSES_WGETCH_EVENTS */ 133 134 #if (USE_FUNC_POLL || HAVE_SELECT) 135 # define MAYBE_UNUSED 136 #else 137 # define MAYBE_UNUSED GCC_UNUSED 138 #endif 139 140 #if (USE_FUNC_POLL || HAVE_SELECT) 141 # define MAYBE_UNUSED 142 #else 143 # define MAYBE_UNUSED GCC_UNUSED 144 #endif 145 146 /* 147 * Wait a specified number of milliseconds, returning nonzero if the timer 148 * didn't expire before there is activity on the specified file descriptors. 149 * The file-descriptors are specified by the mode: 150 * TW_NONE 0 - none (absolute time) 151 * TW_INPUT 1 - ncurses' normal input-descriptor 152 * TW_MOUSE 2 - mouse descriptor, if any 153 * TW_ANY 3 - either input or mouse. 154 * TW_EVENT 4 - 155 * Experimental: if NCURSES_WGETCH_EVENTS is defined, (mode & 4) determines 156 * whether to pay attention to evl argument. If set, the smallest of 157 * millisecond and of timeout of evl is taken. 158 * 159 * We return a mask that corresponds to the mode (e.g., 2 for mouse activity). 160 * 161 * If the milliseconds given are -1, the wait blocks until activity on the 162 * descriptors. 163 */ 164 NCURSES_EXPORT(int) 165 _nc_timed_wait(SCREEN *sp MAYBE_UNUSED, 166 int mode MAYBE_UNUSED, 167 int milliseconds, 168 int *timeleft 169 EVENTLIST_2nd(_nc_eventlist * evl)) 170 { 171 int count; 172 int result = TW_NONE; 173 TimeType t0; 174 #if (USE_FUNC_POLL || HAVE_SELECT) 175 int fd; 176 #endif 177 178 #ifdef NCURSES_WGETCH_EVENTS 179 int timeout_is_event = 0; 180 int n; 181 #endif 182 183 #if USE_FUNC_POLL 184 #define MIN_FDS 2 185 struct pollfd fd_list[MIN_FDS]; 186 struct pollfd *fds = fd_list; 187 #elif defined(__BEOS__) 188 #elif HAVE_SELECT 189 fd_set set; 190 #endif 191 192 #if USE_KLIBC_KBD 193 fd_set saved_set; 194 KBDKEYINFO ki; 195 struct timeval tv; 196 #endif 197 198 long starttime, returntime; 199 200 TR(TRACE_IEVENT, ("start twait: %d milliseconds, mode: %d", 201 milliseconds, mode)); 202 203 #ifdef NCURSES_WGETCH_EVENTS 204 if (mode & TW_EVENT) { 205 int event_delay = _nc_eventlist_timeout(evl); 206 207 if (event_delay >= 0 208 && (milliseconds >= event_delay || milliseconds < 0)) { 209 milliseconds = event_delay; 210 timeout_is_event = 1; 211 } 212 } 213 #endif 214 215 #if PRECISE_GETTIME && HAVE_NANOSLEEP 216 retry: 217 #endif 218 starttime = _nc_gettime(&t0, TRUE); 219 220 count = 0; 221 (void) count; 222 223 #ifdef NCURSES_WGETCH_EVENTS 224 if ((mode & TW_EVENT) && evl) 225 evl->result_flags = 0; 226 #endif 227 228 #if USE_FUNC_POLL 229 memset(fd_list, 0, sizeof(fd_list)); 230 231 #ifdef NCURSES_WGETCH_EVENTS 232 if ((mode & TW_EVENT) && evl) { 233 fds = typeMalloc(struct pollfd, MIN_FDS + evl->count); 234 if (fds == 0) 235 return TW_NONE; 236 } 237 #endif 238 239 if (mode & TW_INPUT) { 240 fds[count].fd = sp->_ifd; 241 fds[count].events = POLLIN; 242 count++; 243 } 244 if ((mode & TW_MOUSE) 245 && (fd = sp->_mouse_fd) >= 0) { 246 fds[count].fd = fd; 247 fds[count].events = POLLIN; 248 count++; 249 } 250 #ifdef NCURSES_WGETCH_EVENTS 251 if ((mode & TW_EVENT) && evl) { 252 for (n = 0; n < evl->count; ++n) { 253 _nc_event *ev = evl->events[n]; 254 255 if (ev->type == _NC_EVENT_FILE 256 && (ev->data.fev.flags & _NC_EVENT_FILE_READABLE)) { 257 fds[count].fd = ev->data.fev.fd; 258 fds[count].events = POLLIN; 259 count++; 260 } 261 } 262 } 263 #endif 264 265 result = poll(fds, (size_t) count, milliseconds); 266 267 #ifdef NCURSES_WGETCH_EVENTS 268 if ((mode & TW_EVENT) && evl) { 269 int c; 270 271 if (!result) 272 count = 0; 273 274 for (n = 0; n < evl->count; ++n) { 275 _nc_event *ev = evl->events[n]; 276 277 if (ev->type == _NC_EVENT_FILE 278 && (ev->data.fev.flags & _NC_EVENT_FILE_READABLE)) { 279 ev->data.fev.result = 0; 280 for (c = 0; c < count; c++) 281 if (fds[c].fd == ev->data.fev.fd 282 && fds[c].revents & POLLIN) { 283 ev->data.fev.result |= _NC_EVENT_FILE_READABLE; 284 evl->result_flags |= _NC_EVENT_FILE_READABLE; 285 } 286 } else if (ev->type == _NC_EVENT_TIMEOUT_MSEC 287 && !result && timeout_is_event) { 288 evl->result_flags |= _NC_EVENT_TIMEOUT_MSEC; 289 } 290 } 291 } 292 #endif 293 294 #elif defined(__BEOS__) 295 /* 296 * BeOS's select() is declared in socket.h, so the configure script does 297 * not see it. That's just as well, since that function works only for 298 * sockets. This (using snooze and ioctl) was distilled from Be's patch 299 * for ncurses which uses a separate thread to simulate select(). 300 * 301 * FIXME: the return values from the ioctl aren't very clear if we get 302 * interrupted. 303 * 304 * FIXME: this assumes mode&1 if milliseconds < 0 (see lib_getch.c). 305 */ 306 result = TW_NONE; 307 if (mode & TW_INPUT) { 308 int step = (milliseconds < 0) ? 0 : 5000; 309 bigtime_t d; 310 bigtime_t useconds = milliseconds * 1000; 311 int n, howmany; 312 313 if (useconds <= 0) /* we're here to go _through_ the loop */ 314 useconds = 1; 315 316 for (d = 0; d < useconds; d += step) { 317 n = 0; 318 howmany = ioctl(0, 'ichr', &n); 319 if (howmany >= 0 && n > 0) { 320 result = 1; 321 break; 322 } 323 if (useconds > 1 && step > 0) { 324 snooze(step); 325 milliseconds -= (step / 1000); 326 if (milliseconds <= 0) { 327 milliseconds = 0; 328 break; 329 } 330 } 331 } 332 } else if (milliseconds > 0) { 333 snooze(milliseconds * 1000); 334 milliseconds = 0; 335 } 336 #elif HAVE_SELECT 337 /* 338 * select() modifies the fd_set arguments; do this in the 339 * loop. 340 */ 341 FD_ZERO(&set); 342 343 #if !USE_KLIBC_KBD 344 if (mode & TW_INPUT) { 345 FD_SET(sp->_ifd, &set); 346 count = sp->_ifd + 1; 347 } 348 #endif 349 if ((mode & TW_MOUSE) 350 && (fd = sp->_mouse_fd) >= 0) { 351 FD_SET(fd, &set); 352 count = max(fd, count) + 1; 353 } 354 #ifdef NCURSES_WGETCH_EVENTS 355 if ((mode & TW_EVENT) && evl) { 356 for (n = 0; n < evl->count; ++n) { 357 _nc_event *ev = evl->events[n]; 358 359 if (ev->type == _NC_EVENT_FILE 360 && (ev->data.fev.flags & _NC_EVENT_FILE_READABLE)) { 361 FD_SET(ev->data.fev.fd, &set); 362 count = max(ev->data.fev.fd + 1, count); 363 } 364 } 365 } 366 #endif 367 368 #if USE_KLIBC_KBD 369 for (saved_set = set;; set = saved_set) { 370 if ((mode & TW_INPUT) 371 && (sp->_extended_key 372 || (KbdPeek(&ki, 0) == 0 373 && (ki.fbStatus & KBDTRF_FINAL_CHAR_IN)))) { 374 FD_ZERO(&set); 375 FD_SET(sp->_ifd, &set); 376 result = 1; 377 break; 378 } 379 380 tv.tv_sec = 0; 381 tv.tv_usec = (milliseconds == 0) ? 0 : (10 * 1000); 382 383 if ((result = select(count, &set, NULL, NULL, &tv)) != 0) 384 break; 385 386 /* Time out ? */ 387 if (milliseconds >= 0 && _nc_gettime(&t0, FALSE) >= milliseconds) { 388 result = 0; 389 break; 390 } 391 } 392 #else 393 if (milliseconds >= 0) { 394 struct timeval ntimeout; 395 ntimeout.tv_sec = milliseconds / 1000; 396 ntimeout.tv_usec = (milliseconds % 1000) * 1000; 397 result = select(count, &set, NULL, NULL, &ntimeout); 398 } else { 399 result = select(count, &set, NULL, NULL, NULL); 400 } 401 #endif 402 403 #ifdef NCURSES_WGETCH_EVENTS 404 if ((mode & TW_EVENT) && evl) { 405 evl->result_flags = 0; 406 for (n = 0; n < evl->count; ++n) { 407 _nc_event *ev = evl->events[n]; 408 409 if (ev->type == _NC_EVENT_FILE 410 && (ev->data.fev.flags & _NC_EVENT_FILE_READABLE)) { 411 ev->data.fev.result = 0; 412 if (FD_ISSET(ev->data.fev.fd, &set)) { 413 ev->data.fev.result |= _NC_EVENT_FILE_READABLE; 414 evl->result_flags |= _NC_EVENT_FILE_READABLE; 415 } 416 } else if (ev->type == _NC_EVENT_TIMEOUT_MSEC 417 && !result && timeout_is_event) 418 evl->result_flags |= _NC_EVENT_TIMEOUT_MSEC; 419 } 420 } 421 #endif 422 423 #endif /* USE_FUNC_POLL, etc */ 424 425 returntime = _nc_gettime(&t0, FALSE); 426 427 if (milliseconds >= 0) 428 milliseconds -= (int) (returntime - starttime); 429 430 #ifdef NCURSES_WGETCH_EVENTS 431 if (evl) { 432 evl->result_flags = 0; 433 for (n = 0; n < evl->count; ++n) { 434 _nc_event *ev = evl->events[n]; 435 436 if (ev->type == _NC_EVENT_TIMEOUT_MSEC) { 437 long diff = (returntime - starttime); 438 if (ev->data.timeout_msec <= diff) 439 ev->data.timeout_msec = 0; 440 else 441 ev->data.timeout_msec -= diff; 442 } 443 444 } 445 } 446 #endif 447 448 #if PRECISE_GETTIME && HAVE_NANOSLEEP 449 /* 450 * If the timeout hasn't expired, and we've gotten no data, 451 * this is probably a system where 'select()' needs to be left 452 * alone so that it can complete. Make this process sleep, 453 * then come back for more. 454 */ 455 if (result == 0 && milliseconds > 100) { 456 napms(100); /* FIXME: this won't be right if I recur! */ 457 milliseconds -= 100; 458 goto retry; 459 } 460 #endif 461 462 /* return approximate time left in milliseconds */ 463 if (timeleft) 464 *timeleft = milliseconds; 465 466 TR(TRACE_IEVENT, ("end twait: returned %d (%d), remaining time %d msec", 467 result, errno, milliseconds)); 468 469 /* 470 * Both 'poll()' and 'select()' return the number of file descriptors 471 * that are active. Translate this back to the mask that denotes which 472 * file-descriptors, so that we don't need all of this system-specific 473 * code everywhere. 474 */ 475 if (result != 0) { 476 if (result > 0) { 477 result = 0; 478 #if USE_FUNC_POLL 479 for (count = 0; count < MIN_FDS; count++) { 480 if ((mode & (1 << count)) 481 && (fds[count].revents & POLLIN)) { 482 result |= (1 << count); 483 } 484 } 485 #elif defined(__BEOS__) 486 result = TW_INPUT; /* redundant, but simple */ 487 #elif HAVE_SELECT 488 if ((mode & TW_MOUSE) 489 && (fd = sp->_mouse_fd) >= 0 490 && FD_ISSET(fd, &set)) 491 result |= TW_MOUSE; 492 if ((mode & TW_INPUT) 493 && FD_ISSET(sp->_ifd, &set)) 494 result |= TW_INPUT; 495 #endif 496 } else 497 result = 0; 498 } 499 #ifdef NCURSES_WGETCH_EVENTS 500 if ((mode & TW_EVENT) && evl && evl->result_flags) 501 result |= TW_EVENT; 502 #endif 503 504 #if USE_FUNC_POLL 505 #ifdef NCURSES_WGETCH_EVENTS 506 if (fds != fd_list) 507 free((char *) fds); 508 #endif 509 #endif 510 511 return (result); 512 } 513