usb 2.1.2 → 2.3.0

package/libusb/libusb/os/poll_posix.c

@@ -1,84 +0,0 @@
-/*
- * poll_posix: poll compatibility wrapper for POSIX systems
- * Copyright © 2013 RealVNC Ltd.
- *
- * 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
- *
- */
-
-#include <config.h>
-
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdlib.h>
-
-#include "libusbi.h"
-
-int usbi_pipe(int pipefd[2])
-{
-#if defined(HAVE_PIPE2)
-	int ret = pipe2(pipefd, O_CLOEXEC);
-#else
-	int ret = pipe(pipefd);
-#endif
-
-	if (ret != 0) {
-		usbi_err(NULL, "failed to create pipe (%d)", errno);
-		return ret;
-	}
-
-#if !defined(HAVE_PIPE2) && defined(FD_CLOEXEC)
-	ret = fcntl(pipefd[0], F_GETFD);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to get pipe fd flags (%d)", errno);
-		goto err_close_pipe;
-	}
-	ret = fcntl(pipefd[0], F_SETFD, ret | FD_CLOEXEC);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to set pipe fd flags (%d)", errno);
-		goto err_close_pipe;
-	}
-
-	ret = fcntl(pipefd[1], F_GETFD);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to get pipe fd flags (%d)", errno);
-		goto err_close_pipe;
-	}
-	ret = fcntl(pipefd[1], F_SETFD, ret | FD_CLOEXEC);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to set pipe fd flags (%d)", errno);
-		goto err_close_pipe;
-	}
-#endif
-
-	ret = fcntl(pipefd[1], F_GETFL);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to get pipe fd status flags (%d)", errno);
-		goto err_close_pipe;
-	}
-	ret = fcntl(pipefd[1], F_SETFL, ret | O_NONBLOCK);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to set pipe fd status flags (%d)", errno);
-		goto err_close_pipe;
-	}
-
-	return 0;
-
-err_close_pipe:
-	close(pipefd[0]);
-	close(pipefd[1]);
-	return ret;
-}

package/libusb/libusb/os/poll_posix.h

@@ -1,14 +0,0 @@
-#ifndef LIBUSB_POLL_POSIX_H
-#define LIBUSB_POLL_POSIX_H
-
-#define usbi_write write
-#define usbi_read read
-#define usbi_close close
-#define usbi_poll poll
-
-int usbi_pipe(int pipefd[2]);
-
-#define usbi_inc_fds_ref(x, y)
-#define usbi_dec_fds_ref(x, y)
-
-#endif /* LIBUSB_POLL_POSIX_H */

package/libusb/libusb/os/poll_windows.c

@@ -1,447 +0,0 @@
-/*
- * poll_windows: poll compatibility wrapper for Windows
- * Copyright © 2017 Chris Dickens <christopher.a.dickens@gmail.com>
- *
- * 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.
- * - 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 <config.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-
-#include "libusbi.h"
-#include "windows_common.h"
-
-// public fd data
-const struct winfd INVALID_WINFD = { -1, NULL };
-
-// private data
-struct file_descriptor {
-	enum fd_type { FD_TYPE_PIPE, FD_TYPE_TRANSFER } type;
-	OVERLAPPED overlapped;
-	int refcount;
-};
-
-static usbi_mutex_static_t fd_table_lock = USBI_MUTEX_INITIALIZER;
-
-static struct file_descriptor **fd_table;
-static size_t fd_count;
-static size_t fd_size;
-#define INC_FDS_EACH 256
-
-static void usbi_dec_fd_table()
-{
-	fd_count--;
-	if (fd_count == 0) {
-		free(fd_table);
-		fd_size = 0;
-		fd_table = NULL;
-	}
-}
-
-static void smart_realloc_fd_table_space(int inc)
-{
-	if (fd_table == NULL || fd_count + inc > fd_size) {
-		struct file_descriptor **p = (struct file_descriptor **)realloc(fd_table, (fd_size + INC_FDS_EACH) * sizeof(struct file_descriptor *));
-		if (p != NULL) {
-			memset(p + fd_size, 0, INC_FDS_EACH * sizeof(struct file_descriptor *));
-			fd_size += INC_FDS_EACH;
-			fd_table = p;
-		}
-	}
-}
-
-static struct file_descriptor *create_fd(enum fd_type type)
-{
-	struct file_descriptor *fd = calloc(1, sizeof(*fd));
-	if (fd == NULL)
-		return NULL;
-	fd->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-	if (fd->overlapped.hEvent == NULL) {
-		free(fd);
-		return NULL;
-	}
-	fd->type = type;
-	fd->refcount = 1;
-	return fd;
-}
-
-static void free_fd(struct file_descriptor *fd)
-{
-	CloseHandle(fd->overlapped.hEvent);
-	free(fd);
-}
-
-/*
- * Create both an fd and an OVERLAPPED, 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.
- * 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(void)
-{
-	struct file_descriptor *fd;
-	struct winfd wfd;
-
-	fd = create_fd(FD_TYPE_TRANSFER);
-	if (fd == NULL)
-		return INVALID_WINFD;
-
-	usbi_mutex_static_lock(&fd_table_lock);
-
-	smart_realloc_fd_table_space(1);
-
-	for (wfd.fd = 0; wfd.fd < fd_size; wfd.fd++) {
-		if (fd_table[wfd.fd] != NULL)
-			continue;
-		fd_table[wfd.fd] = fd;
-		fd_count++;
-		break;
-	}
-	usbi_mutex_static_unlock(&fd_table_lock);
-
-	if (wfd.fd == fd_size) {
-		free_fd(fd);
-		return INVALID_WINFD;
-	}
-
-	wfd.overlapped = &fd->overlapped;
-
-	return wfd;
-}
-
-void usbi_inc_fds_ref(struct pollfd *fds, unsigned int nfds)
-{
-	int n;
-	usbi_mutex_static_lock(&fd_table_lock);
-	for (n = 0; n < nfds; ++n) {
-		fd_table[fds[n].fd]->refcount++;
-	}
-	usbi_mutex_static_unlock(&fd_table_lock);
-}
-
-void usbi_dec_fds_ref(struct pollfd *fds, unsigned int nfds)
-{
-	int n;
-	struct file_descriptor *fd;
-
-	usbi_mutex_static_lock(&fd_table_lock);
-	for (n = 0; n < nfds; ++n) {
-		fd = fd_table[fds[n].fd];
-		fd->refcount--;
-		//FD_TYPE_PIPE map fd to two _fd
-		if (fd->refcount == 0 || (fd->refcount == 1 && fd->type == FD_TYPE_PIPE))
-		{
-			if (fd->type == FD_TYPE_PIPE) {
-				// InternalHigh is our reference count
-				fd->overlapped.InternalHigh--;
-				if (fd->overlapped.InternalHigh == 0)
-					free_fd(fd);
-			}
-			else {
-				free_fd(fd);
-			}
-			fd_table[fds[n].fd] = NULL;
-			usbi_dec_fd_table();
-		}
-	}
-	usbi_mutex_static_unlock(&fd_table_lock);
-}
-
-
-static int check_pollfds(struct pollfd *fds, unsigned int nfds,
-	HANDLE *wait_handles, DWORD *nb_wait_handles)
-{
-	struct file_descriptor *fd;
-	unsigned int n;
-	int nready = 0;
-
-	usbi_mutex_static_lock(&fd_table_lock);
-
-	for (n = 0; n < nfds; ++n) {
-		fds[n].revents = 0;
-
-		// Keep it simple - only allow either POLLIN *or* POLLOUT
-		assert((fds[n].events == POLLIN) || (fds[n].events == POLLOUT));
-		if ((fds[n].events != POLLIN) && (fds[n].events != POLLOUT)) {
-			fds[n].revents = POLLNVAL;
-			nready++;
-			continue;
-		}
-
-		if ((fds[n].fd >= 0) && (fds[n].fd < fd_size))
-			fd = fd_table[fds[n].fd];
-		else
-			fd = NULL;
-
-		assert(fd != NULL);
-		if (fd == NULL) {
-			fds[n].revents = POLLNVAL;
-			nready++;
-			continue;
-		}
-
-		if (HasOverlappedIoCompleted(&fd->overlapped)
-				&& (WaitForSingleObject(fd->overlapped.hEvent, 0) == WAIT_OBJECT_0)) {
-			fds[n].revents = fds[n].events;
-			nready++;
-		} else if (wait_handles != NULL) {
-			if (*nb_wait_handles == MAXIMUM_WAIT_OBJECTS) {
-				usbi_warn(NULL, "too many HANDLEs to wait on");
-				continue;
-			}
-			wait_handles[*nb_wait_handles] = fd->overlapped.hEvent;
-			(*nb_wait_handles)++;
-		}
-	}
-
-	usbi_mutex_static_unlock(&fd_table_lock);
-
-	return nready;
-}
-/*
- * 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)
-{
-	HANDLE wait_handles[MAXIMUM_WAIT_OBJECTS];
-	DWORD nb_wait_handles = 0;
-	DWORD ret;
-	int nready;
-
-	nready = check_pollfds(fds, nfds, wait_handles, &nb_wait_handles);
-
-	// If nothing was triggered, wait on all fds that require it
-	if ((nready == 0) && (nb_wait_handles != 0) && (timeout != 0)) {
-		ret = WaitForMultipleObjects(nb_wait_handles, wait_handles,
-			FALSE, (timeout < 0) ? INFINITE : (DWORD)timeout);
-		if (ret < (WAIT_OBJECT_0 + nb_wait_handles)) {
-			nready = check_pollfds(fds, nfds, NULL, NULL);
-		} else if (ret != WAIT_TIMEOUT) {
-			if (ret == WAIT_FAILED)
-				usbi_err(NULL, "WaitForMultipleObjects failed: %u", (unsigned int)GetLastError());
-			nready = -1;
-		}
-	}
-
-	return nready;
-}
-
-/*
- * close a fake file descriptor
- */
-int usbi_close(int _fd)
-{
-	struct file_descriptor *fd;
-
-	if (_fd < 0 || _fd >= fd_size)
-		goto err_badfd;
-
-	usbi_mutex_static_lock(&fd_table_lock);
-	fd = fd_table[_fd];
-	fd->refcount--;
-	//FD_TYPE_PIPE map fd to two _fd
-	if(fd->refcount==0 || (fd->refcount == 1 && fd->type == FD_TYPE_PIPE))
-	{	fd_table[_fd] = NULL;
-		usbi_dec_fd_table();
-
-		if (fd->type == FD_TYPE_PIPE) {
-			// InternalHigh is our reference count
-			fd->overlapped.InternalHigh--;
-			if (fd->overlapped.InternalHigh == 0)
-				free_fd(fd);
-		}
-		else {
-			free_fd(fd);
-		}
-	}
-	usbi_mutex_static_unlock(&fd_table_lock);
-
-	if (fd == NULL)
-		goto err_badfd;
-
-	return 0;
-
-err_badfd:
-	errno = EBADF;
-	return -1;
-}
-
-/*
-* 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])
-{
-	struct file_descriptor *fd;
-	int r_fd = -1, w_fd = -1;
-	int i;
-
-	fd = create_fd(FD_TYPE_PIPE);
-	if (fd == NULL) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	// Use InternalHigh as a reference count
-	fd->overlapped.Internal = STATUS_PENDING;
-	fd->overlapped.InternalHigh = 2;
-
-	usbi_mutex_static_lock(&fd_table_lock);
-	do {
-		smart_realloc_fd_table_space(2);
-
-		for (i = 0; i < fd_size; i++) {
-			if (fd_table[i] != NULL)
-				continue;
-			if (r_fd == -1) {
-				r_fd = i;
-			} else if (w_fd == -1) {
-				w_fd = i;
-				break;
-			}
-		}
-
-		if (i == fd_size)
-			break;
-
-		fd_table[r_fd] = fd;
-		fd_table[w_fd] = fd;
-
-		fd->refcount++; //this fd reference twice for r and w.
-
-		fd_count += 2;
-
-	} while (0);
-	usbi_mutex_static_unlock(&fd_table_lock);
-
-	if (i == fd_size) {
-		free_fd(fd);
-		errno = EMFILE;
-		return -1;
-	}
-
-	filedes[0] = r_fd;
-	filedes[1] = w_fd;
-
-	return 0;
-}
-
-/*
- * synchronous write for fake "pipe" signaling
- */
-ssize_t usbi_write(int fd, const void *buf, size_t count)
-{
-	int error = EBADF;
-
-	UNUSED(buf);
-
-	if (fd < 0 || fd >= fd_size)
-		goto err_out;
-
-	if (count != sizeof(unsigned char)) {
-		usbi_err(NULL, "this function should only used for signaling");
-		error = EINVAL;
-		goto err_out;
-	}
-
-	usbi_mutex_static_lock(&fd_table_lock);
-	if ((fd_table[fd] != NULL) && (fd_table[fd]->type == FD_TYPE_PIPE)) {
-		assert(fd_table[fd]->overlapped.Internal == STATUS_PENDING);
-		assert(fd_table[fd]->overlapped.InternalHigh == 2);
-		fd_table[fd]->overlapped.Internal = STATUS_WAIT_0;
-		SetEvent(fd_table[fd]->overlapped.hEvent);
-		error = 0;
-	}
-	usbi_mutex_static_unlock(&fd_table_lock);
-
-	if (error)
-		goto err_out;
-
-	return sizeof(unsigned char);
-
-err_out:
-	errno = error;
-	return -1;
-}
-
-/*
- * synchronous read for fake "pipe" signaling
- */
-ssize_t usbi_read(int fd, void *buf, size_t count)
-{
-	int error = EBADF;
-
-	UNUSED(buf);
-
-	if (fd < 0 || fd >= fd_size)
-		goto err_out;
-
-	if (count != sizeof(unsigned char)) {
-		usbi_err(NULL, "this function should only used for signaling");
-		error = EINVAL;
-		goto err_out;
-	}
-
-	usbi_mutex_static_lock(&fd_table_lock);
-	if ((fd_table[fd] != NULL) && (fd_table[fd]->type == FD_TYPE_PIPE)) {
-		assert(fd_table[fd]->overlapped.Internal == STATUS_WAIT_0);
-		assert(fd_table[fd]->overlapped.InternalHigh == 2);
-		fd_table[fd]->overlapped.Internal = STATUS_PENDING;
-		ResetEvent(fd_table[fd]->overlapped.hEvent);
-		error = 0;
-	}
-	usbi_mutex_static_unlock(&fd_table_lock);
-
-	if (error)
-		goto err_out;
-
-	return sizeof(unsigned char);
-
-err_out:
-	errno = error;
-	return -1;
-}

package/libusb/libusb/os/poll_windows.h

@@ -1,98 +0,0 @@
-/*
- * Windows compat: POSIX compatibility wrapper
- * Copyright © 2012-2013 RealVNC Ltd.
- * Copyright © 2009-2010 Pete Batard <pete@akeo.ie>
- * Copyright © 2016-2018 Chris Dickens <christopher.a.dickens@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
- *
- */
-#pragma once
-
-#if defined(_MSC_VER)
-// disable /W4 MSVC warnings that are benign
-#pragma warning(disable:4127) // conditional expression is constant
-#endif
-
-// Handle synchronous completion through the overlapped structure
-#if !defined(STATUS_REPARSE)	// reuse the REPARSE status code
-#define STATUS_REPARSE ((LONG)0x00000104L)
-#endif
-#define STATUS_COMPLETED_SYNCHRONOUSLY	STATUS_REPARSE
-#if defined(_WIN32_WCE)
-// WinCE doesn't have a HasOverlappedIoCompleted() macro, so attempt to emulate it
-#define HasOverlappedIoCompleted(lpOverlapped) (((DWORD)(lpOverlapped)->Internal) != STATUS_PENDING)
-#endif
-#define HasOverlappedIoCompletedSync(lpOverlapped)	(((DWORD)(lpOverlapped)->Internal) == STATUS_COMPLETED_SYNCHRONOUSLY)
-
-#define DUMMY_HANDLE ((HANDLE)(LONG_PTR)-2)
-
-#define POLLIN      0x0001    /* There is data to read */
-#define POLLPRI     0x0002    /* There is urgent data to read */
-#define POLLOUT     0x0004    /* Writing now will not block */
-#define POLLERR     0x0008    /* Error condition */
-#define POLLHUP     0x0010    /* Hung up */
-#define POLLNVAL    0x0020    /* Invalid request: fd not open */
-
-struct pollfd {
-	int fd;		/* file descriptor */
-	short events;	/* requested events */
-	short revents;	/* returned events */
-};
-
-struct winfd {
-	int fd;				// what's exposed to libusb core
-	OVERLAPPED *overlapped;		// what will report our I/O status
-};
-
-extern const struct winfd INVALID_WINFD;
-
-struct winfd usbi_create_fd(void);
-
-int usbi_pipe(int pipefd[2]);
-int usbi_poll(struct pollfd *fds, unsigned int nfds, int timeout);
-ssize_t usbi_write(int fd, const void *buf, size_t count);
-ssize_t usbi_read(int fd, void *buf, size_t count);
-int usbi_close(int fd);
-
-void usbi_inc_fds_ref(struct pollfd *fds, unsigned int nfds);
-void usbi_dec_fds_ref(struct pollfd *fds, unsigned int nfds);
-
-/*
- * Timeval operations
- */
-#if defined(DDKBUILD)
-#include <winsock.h>	// defines timeval functions on DDK
-#endif
-
-#if !defined(TIMESPEC_TO_TIMEVAL)
-#define TIMESPEC_TO_TIMEVAL(tv, ts) {                   \
-	(tv)->tv_sec = (long)(ts)->tv_sec;                  \
-	(tv)->tv_usec = (long)(ts)->tv_nsec / 1000;         \
-}
-#endif
-#if !defined(timersub)
-#define timersub(a, b, result)                          \
-do {                                                    \
-	(result)->tv_sec = (a)->tv_sec - (b)->tv_sec;       \
-	(result)->tv_usec = (a)->tv_usec - (b)->tv_usec;    \
-	if ((result)->tv_usec < 0) {                        \
-		--(result)->tv_sec;                             \
-		(result)->tv_usec += 1000000;                   \
-	}                                                   \
-} while (0)
-#endif