Recommit: Update libusb 1.0.9 to libusbx 1.0.16

third_party/libusb/src/libusb/os/poll_windows.c

 /*
  * poll_windows: poll compatibility wrapper for Windows
- * Copyright (C) 2009-2010 Pete Batard <pbatard@gmail.com>
+ * Copyright © 2012-2013 RealVNC Ltd.
+ * Copyright © 2009-2010 Pete Batard <pete@akeo.ie>
  * 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
+ * poll() and pipe() Windows compatibility layer for libusbx 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
+ *   twice, once in RW_READ and once in RW_WRITE 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>
+#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
+// compilers produce warnings if parenthesis are ommitted.
+#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};
+const struct winfd INVALID_WINFD = {-1, INVALID_HANDLE_VALUE, NULL, NULL, 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;
 
+#if !defined(_WIN32_WCE)
 // 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)
+#define Use_Duplicate_Handles (pCancelIoEx == NULL)
+
+static inline void setup_cancel_io(void)
+{
+        HMODULE hKernel32 = GetModuleHandleA("KERNEL32");
+        if (hKernel32 != NULL) {
+                pCancelIoEx = (BOOL (__stdcall *)(HANDLE,LPOVERLAPPED))
+                        GetProcAddress(hKernel32, "CancelIoEx");
+        }
+        usbi_dbg("Will use CancelIo%s for I/O cancellation",
+                Use_Duplicate_Handles?"":"Ex");
+}
+
+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) {
+        if (poll_fd[_index].itransfer && poll_fd[_index].cancel_fn) {
+                // Cancel outstanding transfer via the specific callback
+                (*poll_fd[_index].cancel_fn)(poll_fd[_index].itransfer);
+                return TRUE;
+        }
+        if (pCancelIoEx != NULL) {
                 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;
 }
+#else
+#define Use_Duplicate_Handles FALSE
+
+static __inline void setup_cancel_io()
+{
+        // No setup needed on WinCE
+}
+
+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 (poll_fd[_index].itransfer && poll_fd[_index].cancel_fn) {
+                // Cancel outstanding transfer via the specific callback
+                (*poll_fd[_index].cancel_fn)(poll_fd[_index].itransfer);
+        }
+        return TRUE;
+}
+#endif
 
 // 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":"");
+                setup_cancel_io();
                 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;
+        InterlockedExchange((LONG *)&compat_spinlock, 0);
 }
 
 // Internal function to retrieve the table index (and lock the fd mutex)
-int _fd_to_index_and_lock(int fd)
+static int _fd_to_index_and_lock(int fd)
 {
         int i;
 
-        if (fd <= 0)
+        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)
+static 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)
+static 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) {
+                        if (Use_Duplicate_Handles) {
                                 // 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;
+        InterlockedExchange((LONG *)&compat_spinlock, 0);
 }
 
 /*
  * Create a fake pipe.
- * As libusb only uses pipes for signaling, all we need from a pipe is an
+ * As libusbx 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));
+        overlapped = create_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];
+                        // Use index as the unique fd number
+                        poll_fd[i].fd = i;
+                        // Read end of the "pipe"
+                        filedes[0] = poll_fd[i].fd;
+                        // We can use the same handle for both ends
+                        filedes[1] = 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);
+        free_overlapped(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)
+struct winfd usbi_create_fd(HANDLE handle, int access_mode, struct usbi_transfer *itransfer, cancel_transfer *cancel_fn)
 {
-        int i, fd;
+        int i;
         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"
+        wfd.itransfer = itransfer;
+        wfd.cancel_fn = cancel_fn;
+
+        if ((access_mode != RW_READ) && (access_mode != RW_WRITE)) {
+                usbi_warn(NULL, "only one of RW_READ or RW_WRITE 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) {
+        if (access_mode == RW_READ) {
                 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) {
+        overlapped = create_overlapped();
+        if(overlapped == NULL) {
                 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;
+                        // Use index as the unique fd number
+                        wfd.fd = i;
                         // Attempt to emulate some of the CancelIoEx behaviour on platforms
                         // that don't have it
-                        if (!CancelIoEx_Available) {
+                        if (Use_Duplicate_Handles) {
                                 _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)
+static 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 (Use_Duplicate_Handles) {
                 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)
+void usbi_free_fd(struct winfd *wfd)
 {
         int _index;
 
         CHECK_INIT_POLLING;
 
-        _index = _fd_to_index_and_lock(fd);
+        _index = _fd_to_index_and_lock(wfd->fd);
         if (_index < 0) {
                 return;
         }
         _free_index(_index);
+        *wfd = INVALID_WINFD;
         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;
@@ skipping 203 matching lines @@
         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;
-                }
+                free_overlapped(poll_fd[_index].overlapped);
                 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;
+        UNUSED(buf);
 
         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);
 
@@ skipping 16 matching lines @@
         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;
+        UNUSED(buf);
 
         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);
 
@@ skipping 15 matching lines @@
                 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;
 }