| /* |
| * poll_windows: poll compatibility wrapper for Windows |
| * Copyright (C) 2009-2010 Pete Batard <pbatard@gmail.com> |
| * With contributions from Michael Plante, Orin Eman et al. |
| * Parts of poll implementation from libusb-win32, by Stephan Meyer et al. |
| * |
| * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| /* |
| * poll() and pipe() Windows compatibility layer for libusb 1.0 |
| * |
| * The way this layer works is by using OVERLAPPED with async I/O transfers, as |
| * OVERLAPPED have an associated event which is flagged for I/O completion. |
| * |
| * For USB pollable async I/O, you would typically: |
| * - obtain a Windows HANDLE to a file or device that has been opened in |
| * OVERLAPPED mode |
| * - call usbi_create_fd with this handle to obtain a custom fd. |
| * Note that if you need simultaneous R/W access, you need to call create_fd |
| * twice, once in _O_RDONLY and once in _O_WRONLY mode to obtain 2 separate |
| * pollable fds |
| * - leave the core functions call the poll routine and flag POLLIN/POLLOUT |
| * |
| * The pipe pollable synchronous I/O works using the overlapped event associated |
| * with a fake pipe. The read/write functions are only meant to be used in that |
| * context. |
| */ |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <io.h> |
| |
| #include <libusbi.h> |
| |
| // Uncomment to debug the polling layer |
| //#define DEBUG_POLL_WINDOWS |
| #if defined(DEBUG_POLL_WINDOWS) |
| #define poll_dbg usbi_dbg |
| #else |
| // MSVC++ < 2005 cannot use a variadic argument and non MSVC |
| // compilers produce warnings if parenthesis are omitted. |
| #if defined(_MSC_VER) && _MSC_VER < 1400 |
| #define poll_dbg |
| #else |
| #define poll_dbg(...) |
| #endif |
| #endif |
| |
| #if defined(_PREFAST_) |
| #pragma warning(disable:28719) |
| #endif |
| |
| #if defined(__CYGWIN__) |
| // cygwin produces a warning unless these prototypes are defined |
| extern int _open(char* name, int flags); |
| extern int _close(int fd); |
| extern int _snprintf(char *buffer, size_t count, const char *format, ...); |
| #define NUL_DEVICE "/dev/null" |
| #else |
| #define NUL_DEVICE "NUL" |
| #endif |
| |
| #define CHECK_INIT_POLLING do {if(!is_polling_set) init_polling();} while(0) |
| |
| // public fd data |
| const struct winfd INVALID_WINFD = {-1, INVALID_HANDLE_VALUE, NULL, RW_NONE}; |
| struct winfd poll_fd[MAX_FDS]; |
| // internal fd data |
| struct { |
| CRITICAL_SECTION mutex; // lock for fds |
| // Additional variables for XP CancelIoEx partial emulation |
| HANDLE original_handle; |
| DWORD thread_id; |
| } _poll_fd[MAX_FDS]; |
| |
| // globals |
| BOOLEAN is_polling_set = FALSE; |
| LONG pipe_number = 0; |
| static volatile LONG compat_spinlock = 0; |
| |
| // CancelIoEx, available on Vista and later only, provides the ability to cancel |
| // a single transfer (OVERLAPPED) when used. As it may not be part of any of the |
| // platform headers, we hook into the Kernel32 system DLL directly to seek it. |
| static BOOL (__stdcall *pCancelIoEx)(HANDLE, LPOVERLAPPED) = NULL; |
| #define CancelIoEx_Available (pCancelIoEx != NULL) |
| static __inline BOOL cancel_io(int _index) |
| { |
| if ((_index < 0) || (_index >= MAX_FDS)) { |
| return FALSE; |
| } |
| |
| if ( (poll_fd[_index].fd < 0) || (poll_fd[_index].handle == INVALID_HANDLE_VALUE) |
| || (poll_fd[_index].handle == 0) || (poll_fd[_index].overlapped == NULL) ) { |
| return TRUE; |
| } |
| if (CancelIoEx_Available) { |
| return (*pCancelIoEx)(poll_fd[_index].handle, poll_fd[_index].overlapped); |
| } |
| if (_poll_fd[_index].thread_id == GetCurrentThreadId()) { |
| return CancelIo(poll_fd[_index].handle); |
| } |
| usbi_warn(NULL, "Unable to cancel I/O that was started from another thread"); |
| return FALSE; |
| } |
| |
| // Init |
| void init_polling(void) |
| { |
| int i; |
| |
| while (InterlockedExchange((LONG *)&compat_spinlock, 1) == 1) { |
| SleepEx(0, TRUE); |
| } |
| if (!is_polling_set) { |
| pCancelIoEx = (BOOL (__stdcall *)(HANDLE,LPOVERLAPPED)) |
| GetProcAddress(GetModuleHandleA("KERNEL32"), "CancelIoEx"); |
| usbi_dbg("Will use CancelIo%s for I/O cancellation", |
| CancelIoEx_Available?"Ex":""); |
| for (i=0; i<MAX_FDS; i++) { |
| poll_fd[i] = INVALID_WINFD; |
| _poll_fd[i].original_handle = INVALID_HANDLE_VALUE; |
| _poll_fd[i].thread_id = 0; |
| InitializeCriticalSection(&_poll_fd[i].mutex); |
| } |
| is_polling_set = TRUE; |
| } |
| compat_spinlock = 0; |
| } |
| |
| // Internal function to retrieve the table index (and lock the fd mutex) |
| int _fd_to_index_and_lock(int fd) |
| { |
| int i; |
| |
| if (fd <= 0) |
| return -1; |
| |
| for (i=0; i<MAX_FDS; i++) { |
| if (poll_fd[i].fd == fd) { |
| EnterCriticalSection(&_poll_fd[i].mutex); |
| // fd might have changed before we got to critical |
| if (poll_fd[i].fd != fd) { |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| continue; |
| } |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| OVERLAPPED *create_overlapped(void) |
| { |
| OVERLAPPED *overlapped = (OVERLAPPED*) calloc(1, sizeof(OVERLAPPED)); |
| if (overlapped == NULL) { |
| return NULL; |
| } |
| overlapped->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); |
| if(overlapped->hEvent == NULL) { |
| free (overlapped); |
| return NULL; |
| } |
| return overlapped; |
| } |
| |
| void free_overlapped(OVERLAPPED *overlapped) |
| { |
| if (overlapped == NULL) |
| return; |
| |
| if ( (overlapped->hEvent != 0) |
| && (overlapped->hEvent != INVALID_HANDLE_VALUE) ) { |
| CloseHandle(overlapped->hEvent); |
| } |
| free(overlapped); |
| } |
| |
| void reset_overlapped(OVERLAPPED *overlapped) |
| { |
| HANDLE event_handle; |
| if (overlapped == NULL) |
| return; |
| |
| event_handle = overlapped->hEvent; |
| if (event_handle != NULL) { |
| ResetEvent(event_handle); |
| } |
| memset(overlapped, 0, sizeof(OVERLAPPED)); |
| overlapped->hEvent = event_handle; |
| } |
| |
| void exit_polling(void) |
| { |
| int i; |
| |
| while (InterlockedExchange((LONG *)&compat_spinlock, 1) == 1) { |
| SleepEx(0, TRUE); |
| } |
| if (is_polling_set) { |
| is_polling_set = FALSE; |
| |
| for (i=0; i<MAX_FDS; i++) { |
| // Cancel any async I/O (handle can be invalid) |
| cancel_io(i); |
| // If anything was pending on that I/O, it should be |
| // terminating, and we should be able to access the fd |
| // mutex lock before too long |
| EnterCriticalSection(&_poll_fd[i].mutex); |
| if ( (poll_fd[i].fd > 0) && (poll_fd[i].handle != INVALID_HANDLE_VALUE) && (poll_fd[i].handle != 0) |
| && (GetFileType(poll_fd[i].handle) == FILE_TYPE_UNKNOWN) ) { |
| _close(poll_fd[i].fd); |
| } |
| free_overlapped(poll_fd[i].overlapped); |
| if (!CancelIoEx_Available) { |
| // Close duplicate handle |
| if (_poll_fd[i].original_handle != INVALID_HANDLE_VALUE) { |
| CloseHandle(poll_fd[i].handle); |
| } |
| } |
| poll_fd[i] = INVALID_WINFD; |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| DeleteCriticalSection(&_poll_fd[i].mutex); |
| } |
| } |
| compat_spinlock = 0; |
| } |
| |
| /* |
| * Create a fake pipe. |
| * As libusb only uses pipes for signaling, all we need from a pipe is an |
| * event. To that extent, we create a single wfd and overlapped as a means |
| * to access that event. |
| */ |
| int usbi_pipe(int filedes[2]) |
| { |
| int i; |
| OVERLAPPED* overlapped; |
| |
| CHECK_INIT_POLLING; |
| |
| overlapped = (OVERLAPPED*) calloc(1, sizeof(OVERLAPPED)); |
| if (overlapped == NULL) { |
| return -1; |
| } |
| // The overlapped must have status pending for signaling to work in poll |
| overlapped->Internal = STATUS_PENDING; |
| overlapped->InternalHigh = 0; |
| |
| // Read end of the "pipe" |
| filedes[0] = _open(NUL_DEVICE, _O_WRONLY); |
| if (filedes[0] < 0) { |
| usbi_err(NULL, "could not create pipe: errno %d", errno); |
| goto out1; |
| } |
| // We can use the same handle for both ends |
| filedes[1] = filedes[0]; |
| poll_dbg("pipe filedes = %d", filedes[0]); |
| |
| // Note: manual reset must be true (second param) as the reset occurs in read |
| overlapped->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); |
| if(!overlapped->hEvent) { |
| goto out2; |
| } |
| |
| for (i=0; i<MAX_FDS; i++) { |
| if (poll_fd[i].fd < 0) { |
| EnterCriticalSection(&_poll_fd[i].mutex); |
| // fd might have been allocated before we got to critical |
| if (poll_fd[i].fd >= 0) { |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| continue; |
| } |
| |
| poll_fd[i].fd = filedes[0]; |
| poll_fd[i].handle = DUMMY_HANDLE; |
| poll_fd[i].overlapped = overlapped; |
| // There's no polling on the write end, so we just use READ for our needs |
| poll_fd[i].rw = RW_READ; |
| _poll_fd[i].original_handle = INVALID_HANDLE_VALUE; |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| return 0; |
| } |
| } |
| |
| CloseHandle(overlapped->hEvent); |
| out2: |
| _close(filedes[0]); |
| out1: |
| free(overlapped); |
| return -1; |
| } |
| |
| /* |
| * Create both an fd and an OVERLAPPED from an open Windows handle, so that |
| * it can be used with our polling function |
| * The handle MUST support overlapped transfers (usually requires CreateFile |
| * with FILE_FLAG_OVERLAPPED) |
| * Return a pollable file descriptor struct, or INVALID_WINFD on error |
| * |
| * Note that the fd returned by this function is a per-transfer fd, rather |
| * than a per-session fd and cannot be used for anything else but our |
| * custom functions (the fd itself points to the NUL: device) |
| * if you plan to do R/W on the same handle, you MUST create 2 fds: one for |
| * read and one for write. Using a single R/W fd is unsupported and will |
| * produce unexpected results |
| */ |
| struct winfd usbi_create_fd(HANDLE handle, int access_mode) |
| { |
| int i, fd; |
| struct winfd wfd = INVALID_WINFD; |
| OVERLAPPED* overlapped = NULL; |
| |
| CHECK_INIT_POLLING; |
| |
| if ((handle == 0) || (handle == INVALID_HANDLE_VALUE)) { |
| return INVALID_WINFD; |
| } |
| |
| if ((access_mode != _O_RDONLY) && (access_mode != _O_WRONLY)) { |
| usbi_warn(NULL, "only one of _O_RDONLY or _O_WRONLY are supported.\n" |
| "If you want to poll for R/W simultaneously, create multiple fds from the same handle."); |
| return INVALID_WINFD; |
| } |
| if (access_mode == _O_RDONLY) { |
| wfd.rw = RW_READ; |
| } else { |
| wfd.rw = RW_WRITE; |
| } |
| |
| // Ensure that we get a non system conflicting unique fd, using |
| // the same fd attribution system as the pipe ends |
| fd = _open(NUL_DEVICE, _O_WRONLY); |
| if (fd < 0) { |
| return INVALID_WINFD; |
| } |
| |
| overlapped = create_overlapped(); |
| if(overlapped == NULL) { |
| _close(fd); |
| return INVALID_WINFD; |
| } |
| |
| for (i=0; i<MAX_FDS; i++) { |
| if (poll_fd[i].fd < 0) { |
| EnterCriticalSection(&_poll_fd[i].mutex); |
| // fd might have been removed before we got to critical |
| if (poll_fd[i].fd >= 0) { |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| continue; |
| } |
| wfd.fd = fd; |
| // Attempt to emulate some of the CancelIoEx behaviour on platforms |
| // that don't have it |
| if (!CancelIoEx_Available) { |
| _poll_fd[i].thread_id = GetCurrentThreadId(); |
| if (!DuplicateHandle(GetCurrentProcess(), handle, GetCurrentProcess(), |
| &wfd.handle, 0, TRUE, DUPLICATE_SAME_ACCESS)) { |
| usbi_dbg("could not duplicate handle for CancelIo - using original one"); |
| wfd.handle = handle; |
| // Make sure we won't close the original handle on fd deletion then |
| _poll_fd[i].original_handle = INVALID_HANDLE_VALUE; |
| } else { |
| _poll_fd[i].original_handle = handle; |
| } |
| } else { |
| wfd.handle = handle; |
| } |
| wfd.overlapped = overlapped; |
| memcpy(&poll_fd[i], &wfd, sizeof(struct winfd)); |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| return wfd; |
| } |
| } |
| free_overlapped(overlapped); |
| _close(fd); |
| return INVALID_WINFD; |
| } |
| |
| void _free_index(int _index) |
| { |
| // Cancel any async IO (Don't care about the validity of our handles for this) |
| cancel_io(_index); |
| // close fake handle for devices |
| if ( (poll_fd[_index].handle != INVALID_HANDLE_VALUE) && (poll_fd[_index].handle != 0) |
| && (GetFileType(poll_fd[_index].handle) == FILE_TYPE_UNKNOWN) ) { |
| _close(poll_fd[_index].fd); |
| } |
| // close the duplicate handle (if we have an actual duplicate) |
| if (!CancelIoEx_Available) { |
| if (_poll_fd[_index].original_handle != INVALID_HANDLE_VALUE) { |
| CloseHandle(poll_fd[_index].handle); |
| } |
| _poll_fd[_index].original_handle = INVALID_HANDLE_VALUE; |
| _poll_fd[_index].thread_id = 0; |
| } |
| free_overlapped(poll_fd[_index].overlapped); |
| poll_fd[_index] = INVALID_WINFD; |
| } |
| |
| /* |
| * Release a pollable file descriptor. |
| * |
| * Note that the associated Windows handle is not closed by this call |
| */ |
| void usbi_free_fd(int fd) |
| { |
| int _index; |
| |
| CHECK_INIT_POLLING; |
| |
| _index = _fd_to_index_and_lock(fd); |
| if (_index < 0) { |
| return; |
| } |
| _free_index(_index); |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| } |
| |
| /* |
| * The functions below perform various conversions between fd, handle and OVERLAPPED |
| */ |
| struct winfd fd_to_winfd(int fd) |
| { |
| int i; |
| struct winfd wfd; |
| |
| CHECK_INIT_POLLING; |
| |
| if (fd <= 0) |
| return INVALID_WINFD; |
| |
| for (i=0; i<MAX_FDS; i++) { |
| if (poll_fd[i].fd == fd) { |
| EnterCriticalSection(&_poll_fd[i].mutex); |
| // fd might have been deleted before we got to critical |
| if (poll_fd[i].fd != fd) { |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| continue; |
| } |
| memcpy(&wfd, &poll_fd[i], sizeof(struct winfd)); |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| return wfd; |
| } |
| } |
| return INVALID_WINFD; |
| } |
| |
| struct winfd handle_to_winfd(HANDLE handle) |
| { |
| int i; |
| struct winfd wfd; |
| |
| CHECK_INIT_POLLING; |
| |
| if ((handle == 0) || (handle == INVALID_HANDLE_VALUE)) |
| return INVALID_WINFD; |
| |
| for (i=0; i<MAX_FDS; i++) { |
| if (poll_fd[i].handle == handle) { |
| EnterCriticalSection(&_poll_fd[i].mutex); |
| // fd might have been deleted before we got to critical |
| if (poll_fd[i].handle != handle) { |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| continue; |
| } |
| memcpy(&wfd, &poll_fd[i], sizeof(struct winfd)); |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| return wfd; |
| } |
| } |
| return INVALID_WINFD; |
| } |
| |
| struct winfd overlapped_to_winfd(OVERLAPPED* overlapped) |
| { |
| int i; |
| struct winfd wfd; |
| |
| CHECK_INIT_POLLING; |
| |
| if (overlapped == NULL) |
| return INVALID_WINFD; |
| |
| for (i=0; i<MAX_FDS; i++) { |
| if (poll_fd[i].overlapped == overlapped) { |
| EnterCriticalSection(&_poll_fd[i].mutex); |
| // fd might have been deleted before we got to critical |
| if (poll_fd[i].overlapped != overlapped) { |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| continue; |
| } |
| memcpy(&wfd, &poll_fd[i], sizeof(struct winfd)); |
| LeaveCriticalSection(&_poll_fd[i].mutex); |
| return wfd; |
| } |
| } |
| return INVALID_WINFD; |
| } |
| |
| /* |
| * POSIX poll equivalent, using Windows OVERLAPPED |
| * Currently, this function only accepts one of POLLIN or POLLOUT per fd |
| * (but you can create multiple fds from the same handle for read and write) |
| */ |
| int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout) |
| { |
| unsigned i; |
| int _index, object_index, triggered; |
| HANDLE *handles_to_wait_on; |
| int *handle_to_index; |
| DWORD nb_handles_to_wait_on = 0; |
| DWORD ret; |
| |
| CHECK_INIT_POLLING; |
| |
| triggered = 0; |
| handles_to_wait_on = (HANDLE*) calloc(nfds+1, sizeof(HANDLE)); // +1 for fd_update |
| handle_to_index = (int*) calloc(nfds, sizeof(int)); |
| if ((handles_to_wait_on == NULL) || (handle_to_index == NULL)) { |
| errno = ENOMEM; |
| triggered = -1; |
| goto poll_exit; |
| } |
| |
| for (i = 0; i < nfds; ++i) { |
| fds[i].revents = 0; |
| |
| // Only one of POLLIN or POLLOUT can be selected with this version of poll (not both) |
| if ((fds[i].events & ~POLLIN) && (!(fds[i].events & POLLOUT))) { |
| fds[i].revents |= POLLERR; |
| errno = EACCES; |
| usbi_warn(NULL, "unsupported set of events"); |
| triggered = -1; |
| goto poll_exit; |
| } |
| |
| _index = _fd_to_index_and_lock(fds[i].fd); |
| poll_dbg("fd[%d]=%d: (overlapped=%p) got events %04X", i, poll_fd[_index].fd, poll_fd[_index].overlapped, fds[i].events); |
| |
| if ( (_index < 0) || (poll_fd[_index].handle == INVALID_HANDLE_VALUE) |
| || (poll_fd[_index].handle == 0) || (poll_fd[_index].overlapped == NULL)) { |
| fds[i].revents |= POLLNVAL | POLLERR; |
| errno = EBADF; |
| if (_index >= 0) { |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| } |
| usbi_warn(NULL, "invalid fd"); |
| triggered = -1; |
| goto poll_exit; |
| } |
| |
| // IN or OUT must match our fd direction |
| if ((fds[i].events & POLLIN) && (poll_fd[_index].rw != RW_READ)) { |
| fds[i].revents |= POLLNVAL | POLLERR; |
| errno = EBADF; |
| usbi_warn(NULL, "attempted POLLIN on fd without READ access"); |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| triggered = -1; |
| goto poll_exit; |
| } |
| |
| if ((fds[i].events & POLLOUT) && (poll_fd[_index].rw != RW_WRITE)) { |
| fds[i].revents |= POLLNVAL | POLLERR; |
| errno = EBADF; |
| usbi_warn(NULL, "attempted POLLOUT on fd without WRITE access"); |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| triggered = -1; |
| goto poll_exit; |
| } |
| |
| // The following macro only works if overlapped I/O was reported pending |
| if ( (HasOverlappedIoCompleted(poll_fd[_index].overlapped)) |
| || (HasOverlappedIoCompletedSync(poll_fd[_index].overlapped)) ) { |
| poll_dbg(" completed"); |
| // checks above should ensure this works: |
| fds[i].revents = fds[i].events; |
| triggered++; |
| } else { |
| handles_to_wait_on[nb_handles_to_wait_on] = poll_fd[_index].overlapped->hEvent; |
| handle_to_index[nb_handles_to_wait_on] = i; |
| nb_handles_to_wait_on++; |
| } |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| } |
| |
| // If nothing was triggered, wait on all fds that require it |
| if ((timeout != 0) && (triggered == 0) && (nb_handles_to_wait_on != 0)) { |
| if (timeout < 0) { |
| poll_dbg("starting infinite wait for %d handles...", (int)nb_handles_to_wait_on); |
| } else { |
| poll_dbg("starting %d ms wait for %d handles...", timeout, (int)nb_handles_to_wait_on); |
| } |
| ret = WaitForMultipleObjects(nb_handles_to_wait_on, handles_to_wait_on, |
| FALSE, (timeout<0)?INFINITE:(DWORD)timeout); |
| object_index = ret-WAIT_OBJECT_0; |
| if ((object_index >= 0) && ((DWORD)object_index < nb_handles_to_wait_on)) { |
| poll_dbg(" completed after wait"); |
| i = handle_to_index[object_index]; |
| _index = _fd_to_index_and_lock(fds[i].fd); |
| fds[i].revents = fds[i].events; |
| triggered++; |
| if (_index >= 0) { |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| } |
| } else if (ret == WAIT_TIMEOUT) { |
| poll_dbg(" timed out"); |
| triggered = 0; // 0 = timeout |
| } else { |
| errno = EIO; |
| triggered = -1; // error |
| } |
| } |
| |
| poll_exit: |
| if (handles_to_wait_on != NULL) { |
| free(handles_to_wait_on); |
| } |
| if (handle_to_index != NULL) { |
| free(handle_to_index); |
| } |
| return triggered; |
| } |
| |
| /* |
| * close a fake pipe fd |
| */ |
| int usbi_close(int fd) |
| { |
| int _index; |
| int r = -1; |
| |
| CHECK_INIT_POLLING; |
| |
| _index = _fd_to_index_and_lock(fd); |
| |
| if (_index < 0) { |
| errno = EBADF; |
| } else { |
| if (poll_fd[_index].overlapped != NULL) { |
| // Must be a different event for each end of the pipe |
| CloseHandle(poll_fd[_index].overlapped->hEvent); |
| free(poll_fd[_index].overlapped); |
| } |
| r = _close(poll_fd[_index].fd); |
| if (r != 0) { |
| errno = EIO; |
| } |
| poll_fd[_index] = INVALID_WINFD; |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| } |
| return r; |
| } |
| |
| /* |
| * synchronous write for fake "pipe" signaling |
| */ |
| ssize_t usbi_write(int fd, const void *buf, size_t count) |
| { |
| int _index; |
| |
| CHECK_INIT_POLLING; |
| |
| if (count != sizeof(unsigned char)) { |
| usbi_err(NULL, "this function should only used for signaling"); |
| return -1; |
| } |
| |
| _index = _fd_to_index_and_lock(fd); |
| |
| if ( (_index < 0) || (poll_fd[_index].overlapped == NULL) ) { |
| errno = EBADF; |
| if (_index >= 0) { |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| } |
| return -1; |
| } |
| |
| poll_dbg("set pipe event (fd = %d, thread = %08X)", _index, GetCurrentThreadId()); |
| SetEvent(poll_fd[_index].overlapped->hEvent); |
| poll_fd[_index].overlapped->Internal = STATUS_WAIT_0; |
| // If two threads write on the pipe at the same time, we need to |
| // process two separate reads => use the overlapped as a counter |
| poll_fd[_index].overlapped->InternalHigh++; |
| |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| return sizeof(unsigned char); |
| } |
| |
| /* |
| * synchronous read for fake "pipe" signaling |
| */ |
| ssize_t usbi_read(int fd, void *buf, size_t count) |
| { |
| int _index; |
| ssize_t r = -1; |
| |
| CHECK_INIT_POLLING; |
| |
| if (count != sizeof(unsigned char)) { |
| usbi_err(NULL, "this function should only used for signaling"); |
| return -1; |
| } |
| |
| _index = _fd_to_index_and_lock(fd); |
| |
| if (_index < 0) { |
| errno = EBADF; |
| return -1; |
| } |
| |
| if (WaitForSingleObject(poll_fd[_index].overlapped->hEvent, INFINITE) != WAIT_OBJECT_0) { |
| usbi_warn(NULL, "waiting for event failed: %d", (int)GetLastError()); |
| errno = EIO; |
| goto out; |
| } |
| |
| poll_dbg("clr pipe event (fd = %d, thread = %08X)", _index, GetCurrentThreadId()); |
| poll_fd[_index].overlapped->InternalHigh--; |
| // Don't reset unless we don't have any more events to process |
| if (poll_fd[_index].overlapped->InternalHigh <= 0) { |
| ResetEvent(poll_fd[_index].overlapped->hEvent); |
| poll_fd[_index].overlapped->Internal = STATUS_PENDING; |
| } |
| |
| r = sizeof(unsigned char); |
| |
| out: |
| LeaveCriticalSection(&_poll_fd[_index].mutex); |
| return r; |
| } |