Overflow handling

a fix for SIGSEGV in handle_bulk_completion()

We cannot dereference tpriv after calling
usbi_handle_transfer_cancellation() because that function may invoke
the user-supplied callback which may free the transfer.

Refine configuration selection again

At Alan Stern's suggestion, just offer the bare "set configuration" and
"get configuration" functionality, and let applications worry about the
specific race conditions and unusual situations.

docs update

Add a THANKS file, make copyright notices easily accessible, update TODO

round up poll timeout

Pointed out by Richard Röjfors, otherwise we end up busy-looping with
a poll() timeout of 0.

fix doc about libusb_open()

libusb_open() returns int instead of libusb_device_handle.

Signed-off-by: Felipe Balbi <me@felipebalbi.com>
[dsd: small correction]

Temporary workaround for event handling serialization issue

Ludovic Rousseau pointed out that libusb_unlock_events() is not called
when a thread gets terminated with a signal, meaning that event waiters
will not be woken up in this case.

Add a temporary hack to libusb_event_handler_active() so that at least
the other threads will realise on the next iteration of their event
handling loop.

The real fix will likely involve reworking most of this.

Refine libusb_set_configuration() semantics

Applications will generally want to set a configuration before claiming
interfaces. The problem is that the interface may already be set, and
someone else may have claimed an interface (meaning that all calls to
set_configuration will fail, even if it's for the same configuration).

There are now 2 options:
1. Use the new libusb_get_configuration() to determine active
   configuration before calling libusb_set_configuration()
2. Or just call libusb_set_configuration() as usual, which will do
   nothing if that configuration is already active.

v0.9.0 release

First libusb-1.0 beta release

Take lock before raising event waiters condition

This avoids a race between the user checking for active event handler
and then blocking on the condition variable

Implement serialization of event handlers

Now offers a mechanism to wait for events while another thread is
doing the event handling. Complicates things for MT async apps, but
then again it's a bit of a tricky combination to start with.

allow LIBUSB_DEBUG env var to control message verbosity at runtime

Based on ideas from Ludovic Rousseau

don't print messages by default

Add libusb_set_debug() API to set message verbosity.

Ludovic Rousseau pointed out that applications may close stdout/stderr
descriptors, which might then be reused.

Fix memory leak in libusb_control_transfer

Pointed out by David Engraf: we weren't freeing the transfer buffer

Linux: fix handling of ioctl failure

The return value of some ioctl commands in linux_usbfs.c are not
handeled correct. The ioctl function returns != 0 and errno is set with
the error code.

critical memory leak in handle_events

This patch closes a critical memory leak in handle_events. The fds
variable is malloced but never freed. When I'm calling
handle_events with a timeout of 0, my system runs out of memory after a
few seconds.

More informative libusb_open() return code

Hopefully one of the last API tweaks...

Fix endianness with descriptor handling

Alan Stern pointed out that usbfs gives host-endian data, but sysfs gives
bus-endian.

Backend documentation for porting efforts

Hopefully comprehensive enough for people to get started.

Linux: fix caching of guessed configuration

Reported and tested by Xiaofan Chen

Linux: fix bulk transfer early completion

We were forgetting about the remaining urbs when a non-final urb
completed early.

[dsd: some touchups and a warning message for a corner case that we don't handle]

Handle hot-unplugging

This involved moving from select() to poll() because there is no way to
distinguish usbfs's POLLERR condition with select().

Documentation work

Endianness of control setup packets

Document behaviour where host-endian and bus-endian (little) should be
used respectively.

Also remove packed attribute from libusb_control_setup as all fields
are naturally aligned.

Document that releasing interface causes SET_INTERFACE control request

Support unconfigured devices

Linux: fix caching of active configuration for non-sysfs

Fetch configurations by index (not value)

Otherwise there is no way to know which values to look for.

Linux: comprehensive sysfs vs usbfs access

Be more flexible when certain parts of sysfs are not available.

Linux: no need to store usbfs node path

This can be computed from bus number and device address

Rework configuration handling

libusb no longer caches descriptors in libusb_device but backends are
intended to be able to provide copies from memory. In the common linux
case we can use sysfs.

libusb_get_device_list() can return negative error code

Linux: fix clear_halt implementation

The ioctl expects an integer.
Bug found with the assistance of Soumen Mondal

Documentation work

Partially based on some libusb-devel discussions

Linux: enumerate devices and descriptors from sysfs

Suggested by Alan Stern. This avoids waking up any suspended USB devices.
sysfs is not available on all systems, so the usbfs mechanism is still
in place as a fallback.

documentation touchups

more error code sanitization

Isochronous transfer helper functions

free open devices on exit

move descriptor parsing into main library

OS modules now provide functionality for fetching device/config
descriptors

Detect endpoint halts and unsupported control requests

Linux: fix logical URB allocation

We were allocating the wrong number of URBs for transfers of size
multiples of 16k.

add functionality for querying and detaching kernel driver

Descriptor reading functionality

sanitized error returns from synchronous I/O functions

implement libusb_reset_device()

Add functionality to clear endpoint halt conditions

Fix libusb_get_device_list return value

It was documented to return the list length, but was returning 0.

Well-defined error codes for some operations

Also renamed set_interface_altsetting to set_interface_alt_setting for
better consistency

Add libusb_set_configuration()

rename LIBUSB_ERROR_NOMEM to LIBUSB_ERROR_NO_MEM
improves consistency

Linux: better EACCES handling

Rename reference counting API

This improves consistency with the naming style of other functions

Linux: use read-only access to enumerate devices and descriptors

Write access is not needed until later.
Also fix handling of open() error code.

document pollfd notifiers

Allow multiple interfaces to be claimed

Documentation improvements

detect short descriptor reads

remove "references" and "referenced by" listings in documentation

Use typedef ptr types in parameters and return types

This is passed through to the docs

Expose bus number and device address

standardised error codes

Fix descriptor handling memory leaks

Rename endpoint_type to transfer_type

Matches the USB specs more closely

Remove a FIXME comment

it can't.

Fix unlocked flying_transfers list access

Remove libusb_cancel_transfer_sync

This wasn't a particularly nice API. Cancellation should be handled by
the completion handler.

remove extra timeout check

If select() didn't timeout then don't check for more timeouts

Documentation touchups

Detail that interrupt polling interval is fixed to endpoint bInterval,
and that data may be transferred even on a timeout condition.

add threaded example program

libusb_device mutex protection

mutex protection for device and handle lists

lock flying_transfers during transfer removal

pollfds mutex protection

flying_transfers mutex protection

This marks the beginnings of thread safety

Linux: fix control transfer cancellation

set correct endpoint type for isochronous transfers

Pointed out by Felix Domke

Linux: fire multiple URBs at once for split transfers

This results in a significant performance increase for bulk transfers
larger than 16kb, and fixes a bug where data would be spliced and mixed
between two simultaneously submitted transfers to the same endpoint.

It also allows isochronous transfers larger than 16kb to be submitted.

This commit also improves cancellation - the library now understands
what is going on.

Constify some return data

Make it clear that apps should not mess with these structures

Rename libusb_poll() to libusb_handle_events()

Isochronous endpoint I/O

Due to variable-sized structures, this involved changing allocation
mechanism. All transfers must now be allocated and freed through
libusb.

A synchronous function is missing, and I could do with writing a few
more helper functions to simplify things.

distcheck fix for docs

Support for changing altsetting

Will probably be suject to later consideration w.r.t. claiming of endpoints

it's called bmRequestType

Save transfer flags before invoking callback

The callback may free the transfer, in which case we can't read the flags
after it has returned.

API documentation

Hopefully mostly complete. Some constants were renamed and move into
enums.

Fix get_device_list for realloc case

get_device_list can modify pointer passed to it with realloc, but this
case wasn't handled and caused crash on my machine. Fixed

Signed-off-by: Vasily Khoruzhick <anarsoul@gmail.com>

Beginnings of cross-platform abstraction

This also includes a libusb_get_pollfds API change

Add transfer flags

Simplify libusb_fill_control_transfer()

Transfer length can be inferred from the setup packet.

get_device fixup

Rename API away from "devh" and fix implementation to match header

Rename descriptor-getting functions

Based on feedback from Tim Roberts

Simplify cancellation API

No need to provide the device here.

Rename libusb_dev_handle to libusb_device_handle

Move synchronous I/O implementation to its own file

Separate transfer allocation and submission

Leads to some hefty API changes. Now we're much more similar to the
Linux kernel model.

Problems with dealing with asynchronous control transfers are passed
on to the user, basically you must allocate a buffer, start with the
setup, and put the data after. This won't make much sense until
documented (soon...)

Rework URB API naming

Now refer to everything as "transfers" as consistent with the USB spec
libusb_transfer is now a kind of transfer handle. To reduce confusion
with libusb_bulk_transfer and libusb_control_transfer, those have been
renamed to libusb_{control,bulk}_transfer_request.

Add fallback on /proc/bus/usb

/dev/bus/usb is a relatively new thing probably not present on every
system

Persistent libusb_device storage

Devices are now assigned a session ID (currently busnum:devaddr) which
is used to distinguish unique devices.

Now multiple callers of libusb_get_device_list will get the same
libusb_device structure instances.

Add convenience function to find and open a device by USB VID+PID

Lots of libusb apps I write are simple test apps not intended to be real
apps. Having a function available to quickly locate my device will be
handy in such situations.