/* GnuTLS modifications: */ #define SetErrnoFromWinsockError(x) errno = EIO; #define SetErrnoFromWinError(x) x #include #include #include #include #include #include #include #include "common.h" #if defined _WIN32 || defined __WIN32__ /* This file is part of PlibC. (C) 2005, 2006 Nils Durner (and other contributing authors) This library is free software; you can redistribute it and/or 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. This library is distributed in the hope that it will be useful, 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 this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /** * Code originally written by Wez Furlong * who originally placed it under the PHP License Version 3.0. * Adapted for GNUnet by Nils Durner . * GPLed with permission from Wez Furlong (see E-mail on * gnunet-developers, also quoted in the GNUnet CVS logs). * * @file src/select.c * @brief select implementation for Win32 * @author Wez Furlong * @author Nils Durner (GNUnet extensions) */ /** * Win32 select() will only work with sockets, so we roll our own * implementation here. * - If you supply only sockets, this simply passes through to winsock select(). * - If you supply file handles, there is no way to distinguish between * ready for read/write or OOB, so any set in which the handle is found will * be marked as ready. * - If you supply a mixture of handles and sockets, the system will interleave * calls between select() and WaitForMultipleObjects(). The time slicing may * cause this function call to take up to 100 ms longer than you specified. * - Pipes are not checked for writability or errors (errno = ENOSYS) */ int _win_select(int max_fd, fd_set * rfds, fd_set * wfds, fd_set * efds, const struct timeval *tv) { DWORD ms_total, limit; HANDLE handles[MAXIMUM_WAIT_OBJECTS], hPipes[MAXIMUM_WAIT_OBJECTS]; int handle_slot_to_fd[MAXIMUM_WAIT_OBJECTS]; int n_handles, i, iPipes; fd_set sock_read, sock_write, sock_except; fd_set aread, awrite, aexcept; int sock_max_fd; struct timeval tvslice; int retcode; #define SAFE_FD_ISSET(fd, set) (set != NULL && FD_ISSET(fd, set)) n_handles = 0; sock_max_fd = -1; iPipes = 0; /* calculate how long we need to wait in milliseconds */ if(tv == NULL) ms_total = INFINITE; else { ms_total = tv->tv_sec * 1000; ms_total += tv->tv_usec / 1000; } /* select() may be used as a portable way to sleep */ if (!(rfds || wfds || efds)) { Sleep(ms_total); return 0; } FD_ZERO(&sock_read); FD_ZERO(&sock_write); FD_ZERO(&sock_except); /* build an array of handles for non-sockets */ for(i = 0; i < max_fd; i++) { if(SAFE_FD_ISSET(i, rfds) || SAFE_FD_ISSET(i, wfds) || SAFE_FD_ISSET(i, efds)) { unsigned long ulVal; if (ioctlsocket(i, FIONREAD, &ulVal) != SOCKET_ERROR && _get_osfhandle(i) == -1) { /* socket */ if(SAFE_FD_ISSET(i, rfds)) FD_SET(i, &sock_read); if(SAFE_FD_ISSET(i, wfds)) FD_SET(i, &sock_write); if(SAFE_FD_ISSET(i, efds)) FD_SET(i, &sock_except); if(i > sock_max_fd) sock_max_fd = i; } else { if (GetFileType((HANDLE) i) == FILE_TYPE_PIPE) hPipes[iPipes++] = (HANDLE) i; /* Pipe */ else { handles[n_handles] = (HANDLE) _get_osfhandle(i); if ((DWORD) handles[n_handles] == 0xffffffff) handles[n_handles] = (HANDLE) i; handle_slot_to_fd[n_handles] = i; n_handles++; } } } } if((n_handles == 0) && (iPipes == 0)) { /* plain sockets only - let winsock handle the whole thing */ if ((retcode = select(max_fd, rfds, wfds, efds, tv)) == SOCKET_ERROR) SetErrnoFromWinsockError(WSAGetLastError()); return retcode; } /* mixture of handles and sockets; lets multiplex between * winsock and waiting on the handles */ FD_ZERO(&aread); FD_ZERO(&awrite); FD_ZERO(&aexcept); limit = GetTickCount() + ms_total; do { retcode = 0; if(sock_max_fd >= 0) { /* overwrite the zero'd sets here; the select call * will clear those that are not active */ aread = sock_read; awrite = sock_write; aexcept = sock_except; tvslice.tv_sec = 0; tvslice.tv_usec = 100000; if ((retcode = select(sock_max_fd + 1, &aread, &awrite, &aexcept, &tvslice)) == SOCKET_ERROR) { SetErrnoFromWinsockError(WSAGetLastError()); return -1; } } if(n_handles > 0) { /* check handles */ DWORD wret; wret = MsgWaitForMultipleObjects(n_handles, handles, FALSE, retcode > 0 ? 0 : 100, QS_ALLEVENTS); if(wret == WAIT_TIMEOUT) { /* set retcode to 0; this is the default. * select() may have set it to something else, * in which case we leave it alone, so this branch * does nothing */ ; } else if(wret == WAIT_FAILED) { SetErrnoFromWinError(GetLastError()); return -1; } else { for(i = 0; i < n_handles; i++) { if(WAIT_OBJECT_0 == WaitForSingleObject(handles[i], 0)) { if(SAFE_FD_ISSET(handle_slot_to_fd[i], rfds)) { FD_SET(handle_slot_to_fd[i], &aread); } if(SAFE_FD_ISSET(handle_slot_to_fd[i], wfds)) FD_SET(handle_slot_to_fd[i], &awrite); if(SAFE_FD_ISSET(handle_slot_to_fd[i], efds)) FD_SET(handle_slot_to_fd[i], &aexcept); retcode++; } } } } /* Poll Pipes */ for(i = 0; i < iPipes; i++) { DWORD dwBytes; if(SAFE_FD_ISSET(hPipes[i], rfds)) { if (! PeekNamedPipe(hPipes[i], NULL, 0, NULL, &dwBytes, NULL)) { retcode = -1; SetErrnoFromWinError(GetLastError()); } else if (dwBytes) { FD_SET((int) hPipes[i], &aread); retcode++; } } else if (SAFE_FD_ISSET(hPipes[i], wfds) || SAFE_FD_ISSET(hPipes[i], efds)) { errno = ENOSYS; return -1; /* Not implemented */ } } } while(retcode == 0 && (ms_total == INFINITE || GetTickCount() < limit)); if(rfds) *rfds = aread; if(wfds) *wfds = awrite; if(efds) *efds = aexcept; return retcode; } #endif /* _WIN32 || defined __WIN32__ */