Linux: try harder not to lose any data

We would previously lose any data that was present on a cancelled URB.
Work harder to make sure this doesn't happen.

Add libusb_get_max_iso_packet_size()

As pointed out by Dennis Muhlestein, libusb_get_max_packet_size()
doesn't really do what the documentation might suggest because it
does not consider the number of transaction opportunities per
microframe.

Add a new function to do what is useful for isochronous I/O.

Linux: fix sending of zero length bulk packets

Note that there are is a kernel bug preventing this from working
properly at the moment, even after this fix.

Darwin: Don't cancel transfers on timeout

...because the OS does this for us.

Don't terminate enums with commas

g++ -pedantic doesn't like this
Reported by Eberhard Mattes

v1.0.2 release

Linux: fix config descriptor parsing on big-endian systems

Multi-byte fields in the configuration descriptors that come back from
usbfs are always in bus endian format.

Thanks to Joe Jezak for help investigating and fixing this.

Darwin: improve handling of disconnected devices

Darwin: fix parsing of config descriptors

This was a confusion between configuration numbers and zero-based
configuration indexes.

Eliminate -Wsign-compare compiler warnings

This was due to an API inconsistency which can be safely worked around.
Hopefully we'll remember to fix the API next time we come to break
things.

Make synchronous transfer APIs robust against signal interruption

libusb_control_transfer and libusb_bulk_transfer are designed to be
synchronous such that control is not returned until the transfer
definitively succeeds or fails.  That assumption is violated if a signal
interrupts these functions because there is no way for the application
to continue waiting for the transfer without resubmitting it.  This
patch changes these synchronous APIs so they do not abort in the case of
a signal interruption.

Signed-off-by: David Moore <dcm@acm.org>

pre-gcc-3.4 compatibility

The -fvisibility and -Wno-pointer-sign options are not available on
old GCC versions.

Fix memory leak in config descriptor parsing

Pointed out by Martin Koegler.

Update AUTHORS

v1.0.1 release

Add BUGS file

Probably missed a couple of outstanding issues

Darwin: get_config_descriptor bugfixes

Fix compilation of Darwin backend

My fault. Reported by ihryamzik@gmail.com

Darwin backend

Make endianness macros endian-independent

Implementation suggested by David Moore. Needed for proper universal
code support on Darwin.

Abstract clock reading into OS layer

This will differ on Linux and Darwin, at least.

[dsd: minor style tweaks]

Fix endianness in device descriptors

Pointed out by Nathan Hjelm.

Only link with librt on Linux

[dsd: tweak configure.ac change]

API docs: describe libusb_transfer_cb_fn type

Add some text describing the libusb_transfer_cb_fn function type
with the semantics I have gathered from reading other parts of
the API docs, referring to the proper section for more details.

[dsd: tweaked the description slightly]

Make empty array in struct compatible with C99

If the compiler is known to be running in C99 mode,
use "flexible array members" ("foo[]").

If the compiler is running in any other mode, continue
using the non-standard but widely common "foo[0]" syntax.

Avoid signedness errors in API docs example code

Decrement poll() result when internal pipe has been handled

When we receive data on the internal control pipe, we need to correctly
decrement the number of ready file descriptors before passing on the
remaining work to the OS implementation.

Prevent transfer from being submitted twice or improperly canceled

This ensures that tpriv->urbs and tpriv->iso_urbs are always set to NULL
whenever a transfer is not submitted.  In this way, submit_*_transfer()
and cancel_*_transfer() can error check to ensure that the transfer is
in the correct state to be either submitted or canceled, preventing
potential memory leaks or double frees.

Signed-off-by: David Moore <dcm@acm.org>

Linux: Fix race condition in cancel_bulk_transfer()

This fixes a race condition in cancel_bulk_transfer().  In the old
version, awaiting_reap and awaiting_discard are incremented in
cancel_bulk_transfer() and decremented in handle_bulk_completion().
However, since these events may take place in two different threads,
these variables may reach zero before all URBs have been canceled,
triggered spurious callbacks and duplicate frees.

This changes the logic to use a single variable "num_retired" to replace
both awaiting_reap and awaiting_discard.  num_retired is incremented
only in handle_bulk_completion() and thus there is no race.  The handler
will know that all URBs have been canceled when num_retired becomes
equal to num_urbs.

This change also simplifies a great deal of the logic in both functions
and is a net reduction in the amount of code.

Note that some variables such as "reap_action" probably need to still be
protected by a mutex, and this patch does not address that issue.

Signed-off-by: David Moore <dcm@acm.org>

v1.0.0 release

It's here!

EOL-whitespace fixes

Signed-off-by: Mikhail Gusarov <dottedmag@dottedmag.ent>

Linux: fix reading of active configuration

Shannon Chuang pointed out that we only read 1 byte into an
uninitialized integer, and then return the whole thing.

Fix double free in descriptor parsing error path

Pointed out by Shannon Chuang.

Improvements to multi-threaded I/O system

Documentation brushed up, and I realised that another function is
needed for tight event handling loops -- they must be able to check
if an open/close operation is trying to interrupt it.

SourceForge website upload system changed

v0.9.4 release

Pause event handling while opening and closing devices

Ludovic Rousseau found that crashes often occur if you close a device
while another thread is doing event handling.

Fix this by adding an internal control pipe, which the close routines
use to interrupt the event handler and obtain the event handling lock,
ensuring that no other thread is handling events while the device is
closed. After the close completes, it signals all the event handlers
to start up again using the usual mechanism.

Also modified libusb_open() to do a similar thing, so that event
handlers are interrupted in order to realise that a new poll fd has
appeared.

Add libusb_attach_kernel_driver()

Add support for re-attaching a driver to a device under Linux.

[dsd: fixed handling of return value, and added LIBUSB_ERROR_BUSY case]

Linux: handle low-level transfer errors

Handle more URB error status codes, thanks to Lou and Alan Stern.

Support for out-of-tree building

Contrary to libusb 0.1, libusb 1.0 does not support out-of-tree building
for the documentation part. This patch fixes that by using a
doxygen.cfg.in file, which contains @top_srcdir@ to refer to the
location of the libusb source code.

Document the logging style

Suggested by Lou.

Async I/O documentation touchups

Doc: fix typo in events lock section

v0.9.3 release

Reset internal transfer flags on submit

This fixes a problem pointed out by Lou, where resubmitting a transfer
that previously timed out never timed out again, as if the timeout had
been set to 0.

Add libusb_get_configuration prototype

Pointed out by Lou

v0.9.2 release

Linux: fix sysfs directory handling

The length of the directory name varies, e.g. when you have nested hubs.
Use dynamic allocation to be able to deal with any length of name.

Linux: correct usage of MAX_PATH

Thanks to clarification from Artem Egorkine, MAX_PATH already includes
space for the trailing NULL.

Linux: fix bulk/iso transfer double-cancellation

Reset counters to 0 so that it's possible to cancel a transfer twice
without breaking things. Not sure that I want to support this properly,
but this makes it work at least.

v0.9.1 release

Add missing GET_CONTEXT()

Linux: Compatibility with new sysfs descriptors file

As of 2.6.26, the descriptors file now includes all descriptors, not
just the active one.

Allow user data pointer to be passed through pollfd notification API

Introduce contexts to the API

Suggested by David Zeuthen. This allows multiple libraries in the same
process to independently use libusb without interfering.

Revert "Temporary workaround for event handling serialization issue"

This reverts commit 2d3a1111caff40ebb87983c861ff548cdc9e5946.
This was based on the assumption that dying threads would automatically
release mutexes, which is not the case.

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