poll.c 6.05 KB
Newer Older
1 2 3 4 5 6 7
/* This file is part of the Sofia-SIP package.

   Copyright (C) 2005 Nokia Corporation.

   Contact: Pekka Pessi <pekka.pessi@nokia.com>

   This file is originally from GNU C library.
8

9 10
   Copyright (C) 1994,1996,1997,1998,1999,2001,2002
   Free Software Foundation, Inc.
11

12
   This library is free software; you can redistribute it and/or
13 14 15 16
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

17
   This library is distributed in the hope that it will be useful,
18 19 20 21 22 23 24 25 26 27 28
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include "config.h"

29
#if HAVE_SELECT
30

31 32 33 34
#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif

35 36
#include "sofia-sip/su.h"

37
#if HAVE_ALLOCA_H
38
#include <alloca.h>
39 40 41 42 43 44
#endif

#if HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

45 46 47 48
#include <string.h>

#include "sofia-sip/su_wait.h"

49 50 51 52
#undef NBBY
#undef NFDBITS
#undef FDSETSIZE
#undef roundup
53

54 55
#define	NBBY  8					/* bits in a byte */
#define NFDBITS	(sizeof(long) * NBBY)		/* bits per mask */
56

57 58
#define FDSETSIZE(n) (((n) + NFDBITS - 1) / NFDBITS * (NFDBITS / NBBY))
#define roundup(n, x) (((n) + (x) - 1) / (x) * (x))
59

60
/* Emulated poll() using select().
61

62
This is used by su_wait().
63

64 65 66 67 68
Poll the file descriptors described by the NFDS structures starting at
FDS.  If TIMEOUT is nonzero and not -1, allow TIMEOUT milliseconds for
an event to occur; if TIMEOUT is -1, block until an event occurs.
Returns the number of file descriptors with events, zero if timed out,
or -1 for errors.  */
69 70 71

int poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
72 73 74 75
  struct timeval tv;
  struct pollfd *f;
  int ready;
  int maxfd = 0;
76 77

#if HAVE_ALLOCA_H
78 79 80
  static int max_fd_size;
  int bytes;
  fd_set *rset, *wset, *xset;
81

82 83
  if (!max_fd_size)
    max_fd_size = getdtablesize ();
84

85
  bytes = FDSETSIZE (max_fd_size);
86

87 88 89 90 91 92 93 94 95
  rset = alloca (bytes);
  wset = alloca (bytes);
  xset = alloca (bytes);

  /* We can't call FD_ZERO, since FD_ZERO only works with sets
     of exactly __FD_SETSIZE size.  */
  memset (rset, 0, bytes);
  memset (wset, 0, bytes);
  memset (xset, 0, bytes);
96
#else
97
  fd_set rset[1], wset[1], xset[1];
98

99 100 101 102
  FD_ZERO(rset);
  FD_ZERO(wset);
  FD_ZERO(xset);
#endif
103

104
  for (f = fds; f < &fds[nfds]; ++f)
105
    {
106 107
      f->revents = 0;
      if (f->fd >= 0)
108 109
	{
#if HAVE_ALLOCA_H
110
	  if (f->fd >= max_fd_size)
111
	    {
112 113 114 115 116
	      /* The user provides a file descriptor number which is higher
		 than the maximum we got from the `getdtablesize' call.
		 Maybe this is ok so enlarge the arrays.  */
	      fd_set *nrset, *nwset, *nxset;
	      int nbytes;
117

118 119
	      max_fd_size = roundup (f->fd, NFDBITS);
	      nbytes = FDSETSIZE (max_fd_size);
120

121 122 123
	      nrset = alloca (nbytes);
	      nwset = alloca (nbytes);
	      nxset = alloca (nbytes);
124

125 126 127
	      memset ((char *) nrset + bytes, 0, nbytes - bytes);
	      memset ((char *) nwset + bytes, 0, nbytes - bytes);
	      memset ((char *) nxset + bytes, 0, nbytes - bytes);
128

129 130 131
	      rset = memcpy (nrset, rset, bytes);
	      wset = memcpy (nwset, wset, bytes);
	      xset = memcpy (nxset, xset, bytes);
132

133
	      bytes = nbytes;
134 135
	    }
#else
136 137 138 139
	  if (f->fd >= FD_SETSIZE) {
	    errno = EBADF;
	    return -1;
	  }
140 141
#endif /* HAVE_ALLOCA_H */

142 143 144 145 146 147 148 149
	  if (f->events & POLLIN)
	    FD_SET (f->fd, rset);
	  if (f->events & POLLOUT)
	    FD_SET (f->fd, wset);
	  if (f->events & POLLPRI)
	    FD_SET (f->fd, xset);
	  if (f->fd > maxfd && (f->events & (POLLIN|POLLOUT|POLLPRI)))
	    maxfd = f->fd;
150 151 152
	}
    }

153 154
  tv.tv_sec = timeout / 1000;
  tv.tv_usec = (timeout % 1000) * 1000;
155

156
  while (1)
157
    {
158 159
      ready = select (maxfd + 1, rset, wset, xset,
		      timeout == -1 ? NULL : &tv);
160

161 162 163
      /* It might be that one or more of the file descriptors is invalid.
	 We now try to find and mark them and then try again.  */
      if (ready == -1 && errno == EBADF)
164
	{
165
	  struct timeval sngl_tv;
166
#if HAVE_ALLOCA_H
167 168 169 170 171 172 173 174
	  fd_set *sngl_rset = alloca (bytes);
	  fd_set *sngl_wset = alloca (bytes);
	  fd_set *sngl_xset = alloca (bytes);

	  /* Clear the original set.  */
	  memset (rset, 0, bytes);
	  memset (wset, 0, bytes);
	  memset (xset, 0, bytes);
175
#else
176 177 178
	  fd_set sngl_rset[1];
	  fd_set sngl_wset[1];
	  fd_set sngl_xset[1];
179

180 181 182
	  FD_ZERO(rset);
	  FD_ZERO(wset);
	  FD_ZERO(xset);
183 184
#endif

185 186 187
	  /* This means we don't wait for input.  */
	  sngl_tv.tv_sec = 0;
	  sngl_tv.tv_usec = 0;
188

189
	  maxfd = -1;
190

191 192
	  /* Reset the return value.  */
	  ready = 0;
193

194 195 196 197 198
	  for (f = fds; f < &fds[nfds]; ++f)
	    if (f->fd != -1 && (f->events & (POLLIN|POLLOUT|POLLPRI))
		&& (f->revents & POLLNVAL) == 0)
	      {
		int n;
199 200

#if HAVE_ALLOCA_H
201 202 203
		memset (sngl_rset, 0, bytes);
		memset (sngl_wset, 0, bytes);
		memset (sngl_xset, 0, bytes);
204
#else
205 206 207
		FD_ZERO(rset);
		FD_ZERO(wset);
		FD_ZERO(xset);
208 209
#endif

210 211 212 213 214 215 216 217 218 219 220 221
		if (f->events & POLLIN)
		  FD_SET (f->fd, sngl_rset);
		if (f->events & POLLOUT)
		  FD_SET (f->fd, sngl_wset);
		if (f->events & POLLPRI)
		  FD_SET (f->fd, sngl_xset);

		n = select (f->fd + 1, sngl_rset, sngl_wset, sngl_xset,
			    &sngl_tv);
		if (n != -1)
		  {
		    /* This descriptor is ok.  */
222
		    if (f->events & POLLIN)
223
		      FD_SET (f->fd, rset);
224
		    if (f->events & POLLOUT)
225
		      FD_SET (f->fd, wset);
226
		    if (f->events & POLLPRI)
227 228 229 230 231 232 233 234 235 236 237 238
		      FD_SET (f->fd, xset);
		    if (f->fd > maxfd)
		      maxfd = f->fd;
		    if (n > 0)
		      /* Count it as being available.  */
		      ++ready;
		  }
		else if (errno == EBADF)
		  f->revents |= POLLNVAL;
	      }
	  /* Try again.  */
	  continue;
239 240
	}

241
      break;
242 243
    }

244
  if (ready > 0)
245 246 247 248 249 250 251 252 253 254 255 256 257 258
    for (f = fds; f < &fds[nfds]; ++f)
      {
	if (f->fd >= 0)
	  {
	    if (FD_ISSET (f->fd, rset))
	      f->revents |= POLLIN;
	    if (FD_ISSET (f->fd, wset))
	      f->revents |= POLLOUT;
	    if (FD_ISSET (f->fd, xset))
	      f->revents |= POLLPRI;
	  }
      }

  return ready;
259 260 261
}

#endif