1: /* fdwatch.c - fd watcher routines, either select() or poll()
2: **
3: ** Copyright © 1999,2000 by Jef Poskanzer <jef@mail.acme.com>.
4: ** All rights reserved.
5: **
6: ** Redistribution and use in source and binary forms, with or without
7: ** modification, are permitted provided that the following conditions
8: ** are met:
9: ** 1. Redistributions of source code must retain the above copyright
10: ** notice, this list of conditions and the following disclaimer.
11: ** 2. Redistributions in binary form must reproduce the above copyright
12: ** notice, this list of conditions and the following disclaimer in the
13: ** documentation and/or other materials provided with the distribution.
14: **
15: ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16: ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17: ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18: ** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19: ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20: ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21: ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23: ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24: ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25: ** SUCH DAMAGE.
26: */
27:
28: #include <sys/types.h>
29: #include <stdlib.h>
30: #include <unistd.h>
31: #include <string.h>
32: #include <sys/time.h>
33: #include <sys/resource.h>
34: #include <syslog.h>
35: #include <fcntl.h>
36:
37: #ifndef MIN
38: #define MIN(a,b) ((a) < (b) ? (a) : (b))
39: #endif
40:
41: #ifdef HAVE_POLL_H
42: #include <poll.h>
43: #else /* HAVE_POLL_H */
44: #ifdef HAVE_SYS_POLL_H
45: #include <sys/poll.h>
46: #endif /* HAVE_SYS_POLL_H */
47: #endif /* HAVE_POLL_H */
48:
49: #ifdef HAVE_SYS_DEVPOLL_H
50: #include <sys/devpoll.h>
51: #ifndef HAVE_DEVPOLL
52: #define HAVE_DEVPOLL
53: #endif /* !HAVE_DEVPOLL */
54: #endif /* HAVE_SYS_DEVPOLL_H */
55:
56: #ifdef HAVE_SYS_EVENT_H
57: #include <sys/event.h>
58: #endif /* HAVE_SYS_EVENT_H */
59:
60: #include "fdwatch.h"
61:
62: #ifdef HAVE_SELECT
63: #ifndef FD_SET
64: #define NFDBITS 32
65: #define FD_SETSIZE 32
66: #define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
67: #define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
68: #define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
69: #define FD_ZERO(p) bzero((char*)(p), sizeof(*(p)))
70: #endif /* !FD_SET */
71: #endif /* HAVE_SELECT */
72:
73: static int nfiles;
74: static long nwatches;
75: static int* fd_rw;
76: static void** fd_data;
77: static int nreturned, next_ridx;
78:
79: #ifdef HAVE_KQUEUE
80:
81: #define WHICH "kevent"
82: #define INIT( nfiles ) kqueue_init( nfiles )
83: #define ADD_FD( fd, rw ) kqueue_add_fd( fd, rw )
84: #define DEL_FD( fd ) kqueue_del_fd( fd )
85: #define WATCH( timeout_msecs ) kqueue_watch( timeout_msecs )
86: #define CHECK_FD( fd ) kqueue_check_fd( fd )
87: #define GET_FD( ridx ) kqueue_get_fd( ridx )
88:
89: static int kqueue_init( int nfiles );
90: static void kqueue_add_fd( int fd, int rw );
91: static void kqueue_del_fd( int fd );
92: static int kqueue_watch( long timeout_msecs );
93: static int kqueue_check_fd( int fd );
94: static int kqueue_get_fd( int ridx );
95:
96: #else /* HAVE_KQUEUE */
97: # ifdef HAVE_DEVPOLL
98:
99: #define WHICH "devpoll"
100: #define INIT( nfiles ) devpoll_init( nfiles )
101: #define ADD_FD( fd, rw ) devpoll_add_fd( fd, rw )
102: #define DEL_FD( fd ) devpoll_del_fd( fd )
103: #define WATCH( timeout_msecs ) devpoll_watch( timeout_msecs )
104: #define CHECK_FD( fd ) devpoll_check_fd( fd )
105: #define GET_FD( ridx ) devpoll_get_fd( ridx )
106:
107: static int devpoll_init( int nfiles );
108: static void devpoll_add_fd( int fd, int rw );
109: static void devpoll_del_fd( int fd );
110: static int devpoll_watch( long timeout_msecs );
111: static int devpoll_check_fd( int fd );
112: static int devpoll_get_fd( int ridx );
113:
114: # else /* HAVE_DEVPOLL */
115: # ifdef HAVE_POLL
116:
117: #define WHICH "poll"
118: #define INIT( nfiles ) poll_init( nfiles )
119: #define ADD_FD( fd, rw ) poll_add_fd( fd, rw )
120: #define DEL_FD( fd ) poll_del_fd( fd )
121: #define WATCH( timeout_msecs ) poll_watch( timeout_msecs )
122: #define CHECK_FD( fd ) poll_check_fd( fd )
123: #define GET_FD( ridx ) poll_get_fd( ridx )
124:
125: static int poll_init( int nfiles );
126: static void poll_add_fd( int fd, int rw );
127: static void poll_del_fd( int fd );
128: static int poll_watch( long timeout_msecs );
129: static int poll_check_fd( int fd );
130: static int poll_get_fd( int ridx );
131:
132: # else /* HAVE_POLL */
133: # ifdef HAVE_SELECT
134:
135: #define WHICH "select"
136: #define INIT( nfiles ) select_init( nfiles )
137: #define ADD_FD( fd, rw ) select_add_fd( fd, rw )
138: #define DEL_FD( fd ) select_del_fd( fd )
139: #define WATCH( timeout_msecs ) select_watch( timeout_msecs )
140: #define CHECK_FD( fd ) select_check_fd( fd )
141: #define GET_FD( ridx ) select_get_fd( ridx )
142:
143: static int select_init( int nfiles );
144: static void select_add_fd( int fd, int rw );
145: static void select_del_fd( int fd );
146: static int select_watch( long timeout_msecs );
147: static int select_check_fd( int fd );
148: static int select_get_fd( int ridx );
149:
150: # endif /* HAVE_SELECT */
151: # endif /* HAVE_POLL */
152: # endif /* HAVE_DEVPOLL */
153: #endif /* HAVE_KQUEUE */
154:
155:
156: /* Routines. */
157:
158: /* Figure out how many file descriptors the system allows, and
159: ** initialize the fdwatch data structures. Returns -1 on failure.
160: */
161: int
162: fdwatch_get_nfiles( void )
163: {
164: int i;
165: #ifdef RLIMIT_NOFILE
166: struct rlimit rl;
167: #endif /* RLIMIT_NOFILE */
168:
169: /* Figure out how many fd's we can have. */
170: nfiles = getdtablesize();
171: #ifdef RLIMIT_NOFILE
172: /* If we have getrlimit(), use that, and attempt to raise the limit. */
173: if ( getrlimit( RLIMIT_NOFILE, &rl ) == 0 )
174: {
175: nfiles = rl.rlim_cur;
176: if ( rl.rlim_max == RLIM_INFINITY )
177: rl.rlim_cur = 8192; /* arbitrary */
178: else if ( rl.rlim_max > rl.rlim_cur )
179: rl.rlim_cur = rl.rlim_max;
180: if ( setrlimit( RLIMIT_NOFILE, &rl ) == 0 )
181: nfiles = rl.rlim_cur;
182: }
183: #endif /* RLIMIT_NOFILE */
184:
185: #if defined(HAVE_SELECT) && ! ( defined(HAVE_POLL) || defined(HAVE_DEVPOLL) || defined(HAVE_KQUEUE) )
186: /* If we use select(), then we must limit ourselves to FD_SETSIZE. */
187: nfiles = MIN( nfiles, FD_SETSIZE );
188: #endif /* HAVE_SELECT && ! ( HAVE_POLL || HAVE_DEVPOLL || HAVE_KQUEUE ) */
189:
190: /* Initialize the fdwatch data structures. */
191: nwatches = 0;
192: fd_rw = (int*) malloc( sizeof(int) * nfiles );
193: fd_data = (void**) malloc( sizeof(void*) * nfiles );
194: if ( fd_rw == (int*) 0 || fd_data == (void**) 0 )
195: return -1;
196: for ( i = 0; i < nfiles; ++i )
197: fd_rw[i] = -1;
198: if ( INIT( nfiles ) == -1 )
199: return -1;
200:
201: return nfiles;
202: }
203:
204:
205: /* Add a descriptor to the watch list. rw is either FDW_READ or FDW_WRITE. */
206: void
207: fdwatch_add_fd( int fd, void* client_data, int rw )
208: {
209: if ( fd < 0 || fd >= nfiles || fd_rw[fd] != -1 )
210: {
211: syslog( LOG_ERR, "bad fd (%d) passed to fdwatch_add_fd!", fd );
212: return;
213: }
214: ADD_FD( fd, rw );
215: fd_rw[fd] = rw;
216: fd_data[fd] = client_data;
217: }
218:
219:
220: /* Remove a descriptor from the watch list. */
221: void
222: fdwatch_del_fd( int fd )
223: {
224: if ( fd < 0 || fd >= nfiles || fd_rw[fd] == -1 )
225: {
226: syslog( LOG_ERR, "bad fd (%d) passed to fdwatch_del_fd!", fd );
227: return;
228: }
229: DEL_FD( fd );
230: fd_rw[fd] = -1;
231: fd_data[fd] = (void*) 0;
232: }
233:
234: /* Do the watch. Return value is the number of descriptors that are ready,
235: ** or 0 if the timeout expired, or -1 on errors. A timeout of INFTIM means
236: ** wait indefinitely.
237: */
238: int
239: fdwatch( long timeout_msecs )
240: {
241: ++nwatches;
242: nreturned = WATCH( timeout_msecs );
243: next_ridx = 0;
244: return nreturned;
245: }
246:
247:
248: /* Check if a descriptor was ready. */
249: int
250: fdwatch_check_fd( int fd )
251: {
252: if ( fd < 0 || fd >= nfiles || fd_rw[fd] == -1 )
253: {
254: syslog( LOG_ERR, "bad fd (%d) passed to fdwatch_check_fd!", fd );
255: return 0;
256: }
257: return CHECK_FD( fd );
258: }
259:
260:
261: void*
262: fdwatch_get_next_client_data( void )
263: {
264: int fd;
265:
266: if ( next_ridx >= nreturned )
267: return (void*) -1;
268: fd = GET_FD( next_ridx++ );
269: if ( fd < 0 || fd >= nfiles )
270: return (void*) 0;
271: return fd_data[fd];
272: }
273:
274:
275: /* Generate debugging statistics syslog message. */
276: void
277: fdwatch_logstats( long secs )
278: {
279: if ( secs > 0 )
280: syslog(
281: LOG_INFO, " fdwatch - %ld %ss (%g/sec)",
282: nwatches, WHICH, (float) nwatches / secs );
283: nwatches = 0;
284: }
285:
286:
287: #ifdef HAVE_KQUEUE
288:
289: static int maxkqevents;
290: static struct kevent* kqevents;
291: static int nkqevents;
292: static struct kevent* kqrevents;
293: static int* kqrfdidx;
294: static int kq;
295:
296:
297: static int
298: kqueue_init( int nfiles )
299: {
300: kq = kqueue();
301: if ( kq == -1 )
302: return -1;
303: maxkqevents = nfiles * 2;
304: kqevents = (struct kevent*) malloc( sizeof(struct kevent) * maxkqevents );
305: kqrevents = (struct kevent*) malloc( sizeof(struct kevent) * nfiles );
306: kqrfdidx = (int*) malloc( sizeof(int) * nfiles );
307: if ( kqevents == (struct kevent*) 0 || kqrevents == (struct kevent*) 0 ||
308: kqrfdidx == (int*) 0 )
309: return -1;
310: (void) memset( kqevents, 0, sizeof(struct kevent) * maxkqevents );
311: (void) memset( kqrfdidx, 0, sizeof(int) * nfiles );
312: return 0;
313: }
314:
315:
316: static void
317: kqueue_add_fd( int fd, int rw )
318: {
319: if ( nkqevents >= maxkqevents )
320: {
321: syslog( LOG_ERR, "too many kqevents in kqueue_add_fd!" );
322: return;
323: }
324: kqevents[nkqevents].ident = fd;
325: kqevents[nkqevents].flags = EV_ADD;
326: switch ( rw )
327: {
328: case FDW_READ: kqevents[nkqevents].filter = EVFILT_READ; break;
329: case FDW_WRITE: kqevents[nkqevents].filter = EVFILT_WRITE; break;
330: default: break;
331: }
332: ++nkqevents;
333: }
334:
335:
336: static void
337: kqueue_del_fd( int fd )
338: {
339: if ( nkqevents >= maxkqevents )
340: {
341: syslog( LOG_ERR, "too many kqevents in kqueue_del_fd!" );
342: return;
343: }
344: kqevents[nkqevents].ident = fd;
345: kqevents[nkqevents].flags = EV_DELETE;
346: switch ( fd_rw[fd] )
347: {
348: case FDW_READ: kqevents[nkqevents].filter = EVFILT_READ; break;
349: case FDW_WRITE: kqevents[nkqevents].filter = EVFILT_WRITE; break;
350: }
351: ++nkqevents;
352: }
353:
354:
355: static int
356: kqueue_watch( long timeout_msecs )
357: {
358: int i, r;
359:
360: if ( timeout_msecs == INFTIM )
361: r = kevent(
362: kq, kqevents, nkqevents, kqrevents, nfiles, (struct timespec*) 0 );
363: else
364: {
365: struct timespec ts;
366: ts.tv_sec = timeout_msecs / 1000L;
367: ts.tv_nsec = ( timeout_msecs % 1000L ) * 1000000L;
368: r = kevent( kq, kqevents, nkqevents, kqrevents, nfiles, &ts );
369: }
370: nkqevents = 0;
371: if ( r == -1 )
372: return -1;
373:
374: for ( i = 0; i < r; ++i )
375: kqrfdidx[kqrevents[i].ident] = i;
376:
377: return r;
378: }
379:
380:
381: static int
382: kqueue_check_fd( int fd )
383: {
384: int ridx = kqrfdidx[fd];
385:
386: if ( ridx < 0 || ridx >= nfiles )
387: {
388: syslog( LOG_ERR, "bad ridx (%d) in kqueue_check_fd!", ridx );
389: return 0;
390: }
391: if ( ridx >= nreturned )
392: return 0;
393: if ( kqrevents[ridx].ident != fd )
394: return 0;
395: if ( kqrevents[ridx].flags & EV_ERROR )
396: return 0;
397: switch ( fd_rw[fd] )
398: {
399: case FDW_READ: return kqrevents[ridx].filter == EVFILT_READ;
400: case FDW_WRITE: return kqrevents[ridx].filter == EVFILT_WRITE;
401: default: return 0;
402: }
403: }
404:
405:
406: static int
407: kqueue_get_fd( int ridx )
408: {
409: if ( ridx < 0 || ridx >= nfiles )
410: {
411: syslog( LOG_ERR, "bad ridx (%d) in kqueue_get_fd!", ridx );
412: return -1;
413: }
414: return kqrevents[ridx].ident;
415: }
416:
417: #else /* HAVE_KQUEUE */
418:
419:
420: # ifdef HAVE_DEVPOLL
421:
422: static int maxdpevents;
423: static struct pollfd* dpevents;
424: static int ndpevents;
425: static struct pollfd* dprevents;
426: static int* dp_rfdidx;
427: static int dp;
428:
429:
430: static int
431: devpoll_init( int nfiles )
432: {
433: dp = open( "/dev/poll", O_RDWR );
434: if ( dp == -1 )
435: return -1;
436: (void) fcntl( dp, F_SETFD, 1 );
437: maxdpevents = nfiles * 2;
438: dpevents = (struct pollfd*) malloc( sizeof(struct pollfd) * maxdpevents );
439: dprevents = (struct pollfd*) malloc( sizeof(struct pollfd) * nfiles );
440: dp_rfdidx = (int*) malloc( sizeof(int) * nfiles );
441: if ( dpevents == (struct pollfd*) 0 || dprevents == (struct pollfd*) 0 ||
442: dp_rfdidx == (int*) 0 )
443: return -1;
444: (void) memset( dp_rfdidx, 0, sizeof(int) * nfiles );
445: return 0;
446: }
447:
448:
449: static void
450: devpoll_add_fd( int fd, int rw )
451: {
452: if ( ndpevents >= maxdpevents )
453: {
454: syslog( LOG_ERR, "too many fds in devpoll_add_fd!" );
455: return;
456: }
457: dpevents[ndpevents].fd = fd;
458: switch ( rw )
459: {
460: case FDW_READ: dpevents[ndpevents].events = POLLIN; break;
461: case FDW_WRITE: dpevents[ndpevents].events = POLLOUT; break;
462: default: break;
463: }
464: ++ndpevents;
465: }
466:
467:
468: static void
469: devpoll_del_fd( int fd )
470: {
471: if ( ndpevents >= maxdpevents )
472: {
473: syslog( LOG_ERR, "too many fds in devpoll_del_fd!" );
474: return;
475: }
476: dpevents[ndpevents].fd = fd;
477: dpevents[ndpevents].events = POLLREMOVE;
478: ++ndpevents;
479: }
480:
481:
482: static int
483: devpoll_watch( long timeout_msecs )
484: {
485: int i, r;
486: struct dvpoll dvp;
487:
488: r = sizeof(struct pollfd) * ndpevents;
489: if ( r > 0 && write( dp, dpevents, r ) != r )
490: return -1;
491:
492: ndpevents = 0;
493: dvp.dp_fds = dprevents;
494: dvp.dp_nfds = nfiles;
495: dvp.dp_timeout = (int) timeout_msecs;
496:
497: r = ioctl( dp, DP_POLL, &dvp );
498: if ( r == -1 )
499: return -1;
500:
501: for ( i = 0; i < r; ++i )
502: dp_rfdidx[dprevents[i].fd] = i;
503:
504: return r;
505: }
506:
507:
508: static int
509: devpoll_check_fd( int fd )
510: {
511: int ridx = dp_rfdidx[fd];
512:
513: if ( ridx < 0 || ridx >= nfiles )
514: {
515: syslog( LOG_ERR, "bad ridx (%d) in devpoll_check_fd!", ridx );
516: return 0;
517: }
518: if ( ridx >= nreturned )
519: return 0;
520: if ( dprevents[ridx].fd != fd )
521: return 0;
522: if ( dprevents[ridx].revents & POLLERR )
523: return 0;
524: switch ( fd_rw[fd] )
525: {
526: case FDW_READ: return dprevents[ridx].revents & ( POLLIN | POLLHUP | POLLNVAL );
527: case FDW_WRITE: return dprevents[ridx].revents & ( POLLOUT | POLLHUP | POLLNVAL );
528: default: return 0;
529: }
530: }
531:
532:
533: static int
534: devpoll_get_fd( int ridx )
535: {
536: if ( ridx < 0 || ridx >= nfiles )
537: {
538: syslog( LOG_ERR, "bad ridx (%d) in devpoll_get_fd!", ridx );
539: return -1;
540: }
541: return dprevents[ridx].fd;
542: }
543:
544:
545: # else /* HAVE_DEVPOLL */
546:
547:
548: # ifdef HAVE_POLL
549:
550: static struct pollfd* pollfds;
551: static int npoll_fds;
552: static int* poll_fdidx;
553: static int* poll_rfdidx;
554:
555:
556: static int
557: poll_init( int nfiles )
558: {
559: int i;
560:
561: pollfds = (struct pollfd*) malloc( sizeof(struct pollfd) * nfiles );
562: poll_fdidx = (int*) malloc( sizeof(int) * nfiles );
563: poll_rfdidx = (int*) malloc( sizeof(int) * nfiles );
564: if ( pollfds == (struct pollfd*) 0 || poll_fdidx == (int*) 0 ||
565: poll_rfdidx == (int*) 0 )
566: return -1;
567: for ( i = 0; i < nfiles; ++i )
568: pollfds[i].fd = poll_fdidx[i] = -1;
569: return 0;
570: }
571:
572:
573: static void
574: poll_add_fd( int fd, int rw )
575: {
576: if ( npoll_fds >= nfiles )
577: {
578: syslog( LOG_ERR, "too many fds in poll_add_fd!" );
579: return;
580: }
581: pollfds[npoll_fds].fd = fd;
582: switch ( rw )
583: {
584: case FDW_READ: pollfds[npoll_fds].events = POLLIN; break;
585: case FDW_WRITE: pollfds[npoll_fds].events = POLLOUT; break;
586: default: break;
587: }
588: poll_fdidx[fd] = npoll_fds;
589: ++npoll_fds;
590: }
591:
592:
593: static void
594: poll_del_fd( int fd )
595: {
596: int idx = poll_fdidx[fd];
597:
598: if ( idx < 0 || idx >= nfiles )
599: {
600: syslog( LOG_ERR, "bad idx (%d) in poll_del_fd!", idx );
601: return;
602: }
603: --npoll_fds;
604: pollfds[idx] = pollfds[npoll_fds];
605: poll_fdidx[pollfds[idx].fd] = idx;
606: pollfds[npoll_fds].fd = -1;
607: poll_fdidx[fd] = -1;
608: }
609:
610:
611: static int
612: poll_watch( long timeout_msecs )
613: {
614: int r, ridx, i;
615:
616: r = poll( pollfds, npoll_fds, (int) timeout_msecs );
617: if ( r <= 0 )
618: return r;
619:
620: ridx = 0;
621: for ( i = 0; i < npoll_fds; ++i )
622: if ( pollfds[i].revents &
623: ( POLLIN | POLLOUT | POLLERR | POLLHUP | POLLNVAL ) )
624: {
625: poll_rfdidx[ridx++] = pollfds[i].fd;
626: if ( ridx == r )
627: break;
628: }
629:
630: return ridx; /* should be equal to r */
631: }
632:
633:
634: static int
635: poll_check_fd( int fd )
636: {
637: int fdidx = poll_fdidx[fd];
638:
639: if ( fdidx < 0 || fdidx >= nfiles )
640: {
641: syslog( LOG_ERR, "bad fdidx (%d) in poll_check_fd!", fdidx );
642: return 0;
643: }
644: if ( pollfds[fdidx].revents & POLLERR )
645: return 0;
646: switch ( fd_rw[fd] )
647: {
648: case FDW_READ: return pollfds[fdidx].revents & ( POLLIN | POLLHUP | POLLNVAL );
649: case FDW_WRITE: return pollfds[fdidx].revents & ( POLLOUT | POLLHUP | POLLNVAL );
650: default: return 0;
651: }
652: }
653:
654:
655: static int
656: poll_get_fd( int ridx )
657: {
658: if ( ridx < 0 || ridx >= nfiles )
659: {
660: syslog( LOG_ERR, "bad ridx (%d) in poll_get_fd!", ridx );
661: return -1;
662: }
663: return poll_rfdidx[ridx];
664: }
665:
666: # else /* HAVE_POLL */
667:
668:
669: # ifdef HAVE_SELECT
670:
671: static fd_set master_rfdset;
672: static fd_set master_wfdset;
673: static fd_set working_rfdset;
674: static fd_set working_wfdset;
675: static int* select_fds;
676: static int* select_fdidx;
677: static int* select_rfdidx;
678: static int nselect_fds;
679: static int maxfd;
680: static int maxfd_changed;
681:
682:
683: static int
684: select_init( int nfiles )
685: {
686: int i;
687:
688: FD_ZERO( &master_rfdset );
689: FD_ZERO( &master_wfdset );
690: select_fds = (int*) malloc( sizeof(int) * nfiles );
691: select_fdidx = (int*) malloc( sizeof(int) * nfiles );
692: select_rfdidx = (int*) malloc( sizeof(int) * nfiles );
693: if ( select_fds == (int*) 0 || select_fdidx == (int*) 0 ||
694: select_rfdidx == (int*) 0 )
695: return -1;
696: nselect_fds = 0;
697: maxfd = -1;
698: maxfd_changed = 0;
699: for ( i = 0; i < nfiles; ++i )
700: select_fds[i] = select_fdidx[i] = -1;
701: return 0;
702: }
703:
704:
705: static void
706: select_add_fd( int fd, int rw )
707: {
708: if ( nselect_fds >= nfiles )
709: {
710: syslog( LOG_ERR, "too many fds in select_add_fd!" );
711: return;
712: }
713: select_fds[nselect_fds] = fd;
714: switch ( rw )
715: {
716: case FDW_READ: FD_SET( fd, &master_rfdset ); break;
717: case FDW_WRITE: FD_SET( fd, &master_wfdset ); break;
718: default: break;
719: }
720: if ( fd > maxfd )
721: maxfd = fd;
722: select_fdidx[fd] = nselect_fds;
723: ++nselect_fds;
724: }
725:
726:
727: static void
728: select_del_fd( int fd )
729: {
730: int idx = select_fdidx[fd];
731:
732: if ( idx < 0 || idx >= nfiles )
733: {
734: syslog( LOG_ERR, "bad idx (%d) in select_del_fd!", idx );
735: return;
736: }
737:
738: --nselect_fds;
739: select_fds[idx] = select_fds[nselect_fds];
740: select_fdidx[select_fds[idx]] = idx;
741: select_fds[nselect_fds] = -1;
742: select_fdidx[fd] = -1;
743:
744: FD_CLR( fd, &master_rfdset );
745: FD_CLR( fd, &master_wfdset );
746:
747: if ( fd >= maxfd )
748: maxfd_changed = 1;
749: }
750:
751:
752: static int
753: select_get_maxfd( void )
754: {
755: if ( maxfd_changed )
756: {
757: int i;
758: maxfd = -1;
759: for ( i = 0; i < nselect_fds; ++i )
760: if ( select_fds[i] > maxfd )
761: maxfd = select_fds[i];
762: maxfd_changed = 0;
763: }
764: return maxfd;
765: }
766:
767:
768: static int
769: select_watch( long timeout_msecs )
770: {
771: int mfd;
772: int r, idx, ridx;
773:
774: working_rfdset = master_rfdset;
775: working_wfdset = master_wfdset;
776: mfd = select_get_maxfd();
777: if ( timeout_msecs == INFTIM )
778: r = select(
779: mfd + 1, &working_rfdset, &working_wfdset, (fd_set*) 0,
780: (struct timeval*) 0 );
781: else
782: {
783: struct timeval timeout;
784: timeout.tv_sec = timeout_msecs / 1000L;
785: timeout.tv_usec = ( timeout_msecs % 1000L ) * 1000L;
786: r = select(
787: mfd + 1, &working_rfdset, &working_wfdset, (fd_set*) 0, &timeout );
788: }
789: if ( r <= 0 )
790: return r;
791:
792: ridx = 0;
793: for ( idx = 0; idx < nselect_fds; ++idx )
794: if ( select_check_fd( select_fds[idx] ) )
795: {
796: select_rfdidx[ridx++] = select_fds[idx];
797: if ( ridx == r )
798: break;
799: }
800:
801: return ridx; /* should be equal to r */
802: }
803:
804:
805: static int
806: select_check_fd( int fd )
807: {
808: switch ( fd_rw[fd] )
809: {
810: case FDW_READ: return FD_ISSET( fd, &working_rfdset );
811: case FDW_WRITE: return FD_ISSET( fd, &working_wfdset );
812: default: return 0;
813: }
814: }
815:
816:
817: static int
818: select_get_fd( int ridx )
819: {
820: if ( ridx < 0 || ridx >= nfiles )
821: {
822: syslog( LOG_ERR, "bad ridx (%d) in select_get_fd!", ridx );
823: return -1;
824: }
825: return select_rfdidx[ridx];
826: }
827:
828: # endif /* HAVE_SELECT */
829:
830: # endif /* HAVE_POLL */
831:
832: # endif /* HAVE_DEVPOLL */
833:
834: #endif /* HAVE_KQUEUE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to fdwatch.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / thttpd