Return to poll.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src

Annotation of embedaddon/dnsmasq/src/poll.c, revision 1.1.1.1

1.1       misho       1: /* dnsmasq is Copyright (c) 2000-2016 Simon Kelley
                      2: 
                      3:    This program is free software; you can redistribute it and/or modify
                      4:    it under the terms of the GNU General Public License as published by
                      5:    the Free Software Foundation; version 2 dated June, 1991, or
                      6:    (at your option) version 3 dated 29 June, 2007.
                      7:  
                      8:    This program is distributed in the hope that it will be useful,
                      9:    but WITHOUT ANY WARRANTY; without even the implied warranty of
                     10:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     11:    GNU General Public License for more details.
                     12:      
                     13:    You should have received a copy of the GNU General Public License
                     14:    along with this program.  If not, see <http://www.gnu.org/licenses/>.
                     15: */
                     16: 
                     17: #include "dnsmasq.h"
                     18: 
                     19: /* Wrapper for poll(). Allocates and extends array of struct pollfds,
                     20:    keeps them in fd order so that we can set and test conditions on
                     21:    fd using a simple but efficient binary chop. */
                     22: 
                     23: /* poll_reset()
                     24:    poll_listen(fd, event)
                     25:    .
                     26:    .
                     27:    poll_listen(fd, event);
                     28: 
                     29:    hits = do_poll(timeout);
                     30: 
                     31:    if (poll_check(fd, event)
                     32:     .
                     33:     .
                     34: 
                     35:    if (poll_check(fd, event)
                     36:     .
                     37:     .
                     38: 
                     39:     event is OR of POLLIN, POLLOUT, POLLERR, etc
                     40: */
                     41: 
                     42: static struct pollfd *pollfds = NULL;
                     43: static nfds_t nfds, arrsize = 0;
                     44: 
                     45: /* Binary search. Returns either the pollfd with fd, or
                     46:    if the fd doesn't match, or return equals nfds, the entry
                     47:    to the left of which a new record should be inserted. */
                     48: static nfds_t fd_search(int fd)
                     49: {
                     50:   nfds_t left, right, mid;
                     51:   
                     52:   if ((right = nfds) == 0)
                     53:     return 0;
                     54:   
                     55:   left = 0;
                     56:   
                     57:   while (1)
                     58:     {
                     59:       if (right == left + 1)
                     60:        return (pollfds[left].fd >= fd) ? left : right;
                     61:       
                     62:       mid = (left + right)/2;
                     63:       
                     64:       if (pollfds[mid].fd > fd)
                     65:        right = mid;
                     66:       else 
                     67:        left = mid;
                     68:     }
                     69: }
                     70: 
                     71: void poll_reset(void)
                     72: {
                     73:   nfds = 0;
                     74: }
                     75: 
                     76: int do_poll(int timeout)
                     77: {
                     78:   return poll(pollfds, nfds, timeout);
                     79: }
                     80: 
                     81: int poll_check(int fd, short event)
                     82: {
                     83:   nfds_t i = fd_search(fd);
                     84:   
                     85:   if (i < nfds && pollfds[i].fd == fd)
                     86:     return pollfds[i].revents & event;
                     87: 
                     88:   return 0;
                     89: }
                     90: 
                     91: void poll_listen(int fd, short event)
                     92: {
                     93:    nfds_t i = fd_search(fd);
                     94:   
                     95:    if (i < nfds && pollfds[i].fd == fd)
                     96:      pollfds[i].events |= event;
                     97:    else
                     98:      {
                     99:        if (arrsize != nfds)
                    100:         memmove(&pollfds[i+1], &pollfds[i], (nfds - i) * sizeof(struct pollfd));
                    101:        else
                    102:         {
                    103:           /* Array too small, extend. */
                    104:           struct pollfd *new;
                    105: 
                    106:           arrsize = (arrsize == 0) ? 64 : arrsize * 2;
                    107: 
                    108:           if (!(new = whine_malloc(arrsize * sizeof(struct pollfd))))
                    109:             return;
                    110: 
                    111:           if (pollfds)
                    112:             {
                    113:               memcpy(new, pollfds, i * sizeof(struct pollfd));
                    114:               memcpy(&new[i+1], &pollfds[i], (nfds - i) * sizeof(struct pollfd));
                    115:               free(pollfds);
                    116:             }
                    117:           
                    118:           pollfds = new;
                    119:         }
                    120:        
                    121:        pollfds[i].fd = fd;
                    122:        pollfds[i].events = event;
                    123:        nfds++;
                    124:      }
                    125: }