diff options
| -rw-r--r-- | configure.ac | 9 | ||||
| -rw-r--r-- | libusb/version_nano.h | 2 | ||||
| -rw-r--r-- | tests/Makefile.am | 13 | ||||
| -rw-r--r-- | tests/umockdev.c | 1144 |
4 files changed, 1166 insertions, 2 deletions
diff --git a/configure.ac b/configure.ac index 97712d9..d4f1251 100644 --- a/configure.ac +++ b/configure.ac @@ -179,6 +179,14 @@ linux) dnl system has udev. use it or fail! AC_CHECK_HEADER([libudev.h], [], [AC_MSG_ERROR([udev support requested but libudev header not installed])]) AC_CHECK_LIB([udev], [udev_new], [], [AC_MSG_ERROR([udev support requested but libudev not installed])]) + + # We can build umockdev tests (if available) + PKG_PROG_PKG_CONFIG + PKG_CHECK_MODULES(UMOCKDEV, umockdev-1.0 >= 0.16.0, ac_have_umockdev=yes, ac_have_umockdev=no) + PKG_CHECK_MODULES(UMOCKDEV_HOTPLUG, umockdev-1.0 >= 0.17.7, ac_umockdev_hotplug=yes, ac_umockdev_hotplug=no) + if test "x$ac_umockdev_hotplug" = xyes; then + AC_DEFINE([UMOCKDEV_HOTPLUG], [1], [UMockdev hotplug code is not racy]) + fi else AC_CHECK_HEADERS([asm/types.h]) AC_CHECK_HEADER([linux/netlink.h], [], [AC_MSG_ERROR([Linux netlink header not found])]) @@ -358,6 +366,7 @@ AC_ARG_ENABLE([tests-build], AM_CONDITIONAL([BUILD_EXAMPLES], [test "x$build_examples" != xno]) AM_CONDITIONAL([BUILD_TESTS], [test "x$build_tests" != xno]) +AM_CONDITIONAL([BUILD_UMOCKDEV_TEST], [test "x$ac_have_umockdev" = xyes -a "x$log_enabled" != xno]) AM_CONDITIONAL([CREATE_IMPORT_LIB], [test "x$create_import_lib" = xyes]) AM_CONDITIONAL([OS_DARWIN], [test "x$backend" = xdarwin]) AM_CONDITIONAL([OS_HAIKU], [test "x$backend" = xhaiku]) diff --git a/libusb/version_nano.h b/libusb/version_nano.h index 2819c18..727861c 100644 --- a/libusb/version_nano.h +++ b/libusb/version_nano.h @@ -1 +1 @@ -#define LIBUSB_NANO 11700 +#define LIBUSB_NANO 11701 diff --git a/tests/Makefile.am b/tests/Makefile.am index cb8fad9..cf6237e 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -2,6 +2,17 @@ AM_CPPFLAGS = -I$(top_srcdir)/libusb LDADD = ../libusb/libusb-1.0.la LIBS = +stress_SOURCES = stress.c libusb_testlib.h testlib.c + noinst_PROGRAMS = stress -stress_SOURCES = stress.c libusb_testlib.h testlib.c +if BUILD_UMOCKDEV_TEST +# NOTE: We add libumockdev-preload.so so that we can run tests in-process +# We also use -Wl,-lxxx as the compiler doesn't need it and libtool +# would reorder the flags otherwise. +umockdev_CPPFLAGS = ${UMOCKDEV_CFLAGS} -I$(top_srcdir)/libusb +umockdev_LDFLAGS = -Wl,--push-state,--no-as-needed -Wl,-lumockdev-preload -Wl,--pop-state ${UMOCKDEV_LIBS} +umockdev_SOURCES = umockdev.c + +noinst_PROGRAMS += umockdev +endif diff --git a/tests/umockdev.c b/tests/umockdev.c new file mode 100644 index 0000000..1eda532 --- /dev/null +++ b/tests/umockdev.c @@ -0,0 +1,1144 @@ +/* + * libusb umockdev based tests + * + * Copyright (C) 2022 Benjamin Berg <bberg@redhat.com> + * + * This program 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 program 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 program; If not, see <http://www.gnu.org/licenses/>. + */ + +#include "config.h" +#include <glib.h> +#include <glib/gstdio.h> +#include <unistd.h> +#include <string.h> +#include <errno.h> +#include <linux/ioctl.h> +#include <linux/usbdevice_fs.h> + +#include "libusb.h" + +#include "umockdev.h" + +#define UNUSED_DATA __attribute__ ((unused)) gconstpointer unused_data + +/* avoid leak reports inside assertions; leaking stuff on assertion failures does not matter in tests */ +#if !defined(__clang__) +#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak" +#pragma GCC diagnostic ignored "-Wanalyzer-file-leak" +#endif + +typedef struct { + pid_t thread; + libusb_context *ctx; + enum libusb_log_level level; + char *str; +} LogMessage; + +static void +log_message_free(LogMessage *msg) +{ + g_free(msg->str); + g_free(msg); +} +G_DEFINE_AUTOPTR_CLEANUP_FUNC(LogMessage, log_message_free) + +typedef struct _UsbChat UsbChat; + +struct _UsbChat { + gboolean submit; + gboolean reap; + UsbChat *reaps; + UsbChat *next; + + /* struct usbdevfs_urb */ + unsigned char type; + unsigned char endpoint; + int status; + unsigned int flags; + const unsigned char *buffer; + int buffer_length; + int actual_length; + + /* <submit urb> */ + UMockdevIoctlData *submit_urb; +}; + +typedef struct { + UMockdevTestbed *testbed; + UMockdevIoctlBase *handler; + struct libusb_context *ctx; + + gchar *root_dir; + gchar *sys_dir; + + gboolean libusb_log_silence; + GList *libusb_log; + + UsbChat *chat; + GList *flying_urbs; + GList *discarded_urbs; + + /* GMutex confuses tsan unecessarily */ + pthread_mutex_t mutex; +} UMockdevTestbedFixture; + +/* Global for log handler */ +static UMockdevTestbedFixture *cur_fixture = NULL; + +static void +log_handler(libusb_context *ctx, enum libusb_log_level level, const char *str) +{ + /* May be called from different threads without synchronization! */ + LogMessage *msg; + pid_t tid = gettid(); + + g_assert (cur_fixture != NULL); + g_assert(pthread_mutex_lock(&cur_fixture->mutex) == 0); + + msg = g_new0(LogMessage, 1); + msg->ctx = ctx; + msg->level = level; + msg->str = g_strchomp (g_strdup(str)); + msg->thread = tid; + + if (!cur_fixture->libusb_log_silence) + g_printerr("%s\n", msg->str); + + cur_fixture->libusb_log = g_list_append(cur_fixture->libusb_log, msg); + pthread_mutex_unlock(&cur_fixture->mutex); +} + +static void +log_handler_null(libusb_context *ctx, enum libusb_log_level level, const char *str) +{ + (void) ctx; + (void) level; + (void) str; +} + +static void +clear_libusb_log(UMockdevTestbedFixture * fixture, enum libusb_log_level level) +{ + g_assert(pthread_mutex_lock(&fixture->mutex) == 0); + + while (fixture->libusb_log) { + LogMessage *msg = fixture->libusb_log->data; + + g_assert(msg->ctx == fixture->ctx); + + if (msg->level < level) { + pthread_mutex_unlock(&fixture->mutex); + return; + } + + fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log); + log_message_free(msg); + } + pthread_mutex_unlock(&fixture->mutex); +} + +static void +assert_libusb_log_msg(UMockdevTestbedFixture * fixture, enum libusb_log_level level, const char *re) +{ + g_assert(pthread_mutex_lock(&fixture->mutex) == 0); + + while (fixture->libusb_log) { + g_autoptr(LogMessage) msg = NULL; + + if (fixture->libusb_log == NULL) + g_error ("No level %d message found searching for %s", level, re); + + msg = fixture->libusb_log->data; + fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log); + + if (msg->ctx != fixture->ctx) + g_error ("Saw unexpected message \"%s\" from context %p while %p was expected", + msg->str, msg->ctx, fixture->ctx); + + if (msg->level == level && g_regex_match_simple(re, msg->str, 0, 0)) { + pthread_mutex_unlock(&fixture->mutex); + return; + } + + /* Allow skipping INFO and DEBUG messages */ + if (msg->level >= LIBUSB_LOG_LEVEL_INFO) + continue; + + g_error ("Searched for \"%s\" (%d) but found \"%s\" (%d)", re, level, msg->str, msg->level); + } + + pthread_mutex_unlock(&fixture->mutex); + g_error ("Searched for \"%s\" (%d) but no message matched", re, level); +} + +static void +assert_libusb_no_log_msg(UMockdevTestbedFixture * fixture, enum libusb_log_level level, const char *re) +{ + g_assert(pthread_mutex_lock(&fixture->mutex) == 0); + + while (fixture->libusb_log) { + g_autoptr(LogMessage) msg = NULL; + gboolean matching; + + msg = fixture->libusb_log->data; + fixture->libusb_log = g_list_delete_link(fixture->libusb_log, fixture->libusb_log); + + g_assert(msg->ctx == fixture->ctx); + + matching = (msg->level == level && g_regex_match_simple(re, msg->str, 0, 0)); + + /* Allow skipping INFO and DEBUG messages */ + if (!matching && msg->level >= LIBUSB_LOG_LEVEL_INFO) + continue; + + g_error ("Asserting \"%s\" (%d) not logged and found \"%s\" (%d)", re, level, msg->str, msg->level); + } + + pthread_mutex_unlock(&fixture->mutex); +} + +static void +dump_buffer(const unsigned char *buffer, int len) +{ + g_autoptr(GString) line = NULL; + + line = g_string_new (""); + for (gint i = 0; i < len; i++) { + g_string_append_printf(line, "%02x ", buffer[i]); + if ((i + 1) % 16 == 0) { + g_printerr(" %s\n", line->str); + g_string_set_size(line, 0); + } + } + + if (line->len) + g_printerr(" %s\n", line->str); +} + +static gint +cmp_ioctl_data_addr(const void *data, const void *addr) +{ + return ((const UMockdevIoctlData*) data)->client_addr != (gulong) addr; +} + +static gboolean +handle_ioctl_cb (UMockdevIoctlBase *handler, UMockdevIoctlClient *client, UMockdevTestbedFixture *fixture) +{ + UMockdevIoctlData *ioctl_arg; + long int request; + struct usbdevfs_urb *urb; + + (void) handler; + + request = umockdev_ioctl_client_get_request (client); + ioctl_arg = umockdev_ioctl_client_get_arg (client); + + /* NOTE: We share the address space, dereferencing pointers *will* work. + * However, to make tsan work, we still stick to the API that resolves + * the data into a local copy! */ + + switch (request) { + case USBDEVFS_GET_CAPABILITIES: { + g_autoptr(UMockdevIoctlData) d = NULL; + d = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(guint32), NULL); + + *(guint32*) d->data = USBDEVFS_CAP_BULK_SCATTER_GATHER | + USBDEVFS_CAP_BULK_CONTINUATION | + USBDEVFS_CAP_NO_PACKET_SIZE_LIM | + USBDEVFS_CAP_REAP_AFTER_DISCONNECT | + USBDEVFS_CAP_ZERO_PACKET; + + umockdev_ioctl_client_complete(client, 0, 0); + return TRUE; + } + + case USBDEVFS_CLAIMINTERFACE: + case USBDEVFS_RELEASEINTERFACE: + case USBDEVFS_CLEAR_HALT: + case USBDEVFS_RESET: + case USBDEVFS_RESETEP: + umockdev_ioctl_client_complete(client, 0, 0); + return TRUE; + + case USBDEVFS_SUBMITURB: { + g_autoptr(UMockdevIoctlData) urb_buffer = NULL; + g_autoptr(UMockdevIoctlData) urb_data = NULL; + gsize buflen; + + if (!fixture->chat || !fixture->chat->submit) + return FALSE; + + buflen = fixture->chat->buffer_length; + if (fixture->chat->type == USBDEVFS_URB_TYPE_CONTROL) + buflen = 8; + + urb_data = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(struct usbdevfs_urb), NULL); + urb = (struct usbdevfs_urb*) urb_data->data; + urb_buffer = umockdev_ioctl_data_resolve(urb_data, G_STRUCT_OFFSET(struct usbdevfs_urb, buffer), urb->buffer_length, NULL); + + if (fixture->chat->type == urb->type && + fixture->chat->endpoint == urb->endpoint && + fixture->chat->buffer_length == urb->buffer_length && + (fixture->chat->buffer == NULL || memcmp (fixture->chat->buffer, urb_buffer->data, buflen) == 0)) { + fixture->flying_urbs = g_list_append (fixture->flying_urbs, umockdev_ioctl_data_ref(urb_data)); + + if (fixture->chat->reaps) + fixture->chat->reaps->submit_urb = urb_data; + + if (fixture->chat->status) + umockdev_ioctl_client_complete(client, -1, -fixture->chat->status); + else + umockdev_ioctl_client_complete(client, 0, 0); + + if (fixture->chat->next) + fixture->chat = fixture->chat->next; + else + fixture->chat += 1; + return TRUE; + } + + /* chat message didn't match, don't accept it */ + g_printerr("Could not process submit urb:\n"); + g_printerr(" t: %d, ep: %d, actual_length: %d, buffer_length: %d\n", + urb->type, urb->endpoint, urb->actual_length, urb->buffer_length); + if (urb->type == USBDEVFS_URB_TYPE_CONTROL || urb->endpoint & LIBUSB_ENDPOINT_IN) + dump_buffer(urb->buffer, urb->buffer_length); + g_printerr("Looking for:\n"); + g_printerr(" t: %d, ep: %d, actual_length: %d, buffer_length: %d\n", + fixture->chat->type, fixture->chat->endpoint, + fixture->chat->actual_length, fixture->chat->buffer_length); + if (fixture->chat->buffer) + dump_buffer(fixture->chat->buffer, buflen); + + return FALSE; + } + + case USBDEVFS_REAPURB: + case USBDEVFS_REAPURBNDELAY: { + g_autoptr(UMockdevIoctlData) urb_ptr = NULL; + g_autoptr(UMockdevIoctlData) urb_data = NULL; + + if (fixture->discarded_urbs) { + urb_data = fixture->discarded_urbs->data; + urb = (struct usbdevfs_urb*) urb_data->data; + fixture->discarded_urbs = g_list_delete_link(fixture->discarded_urbs, fixture->discarded_urbs); + urb->status = -ENOENT; + + urb_ptr = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(gpointer), NULL); + umockdev_ioctl_data_set_ptr(urb_ptr, 0, urb_data); + + umockdev_ioctl_client_complete(client, 0, 0); + return TRUE; + } + + if (fixture->chat && fixture->chat->reap) { + GList *l = g_list_find(fixture->flying_urbs, fixture->chat->submit_urb); + + if (l) { + fixture->flying_urbs = g_list_remove_link(fixture->flying_urbs, fixture->flying_urbs); + + urb_data = fixture->chat->submit_urb; + urb = (struct usbdevfs_urb*) urb_data->data; + urb->actual_length = fixture->chat->actual_length; + if (urb->type == USBDEVFS_URB_TYPE_CONTROL && urb->actual_length) + urb->actual_length -= 8; + if (fixture->chat->buffer) + memcpy(urb->buffer, fixture->chat->buffer, fixture->chat->actual_length); + urb->status = fixture->chat->status; + + urb_ptr = umockdev_ioctl_data_resolve(ioctl_arg, 0, sizeof(gpointer), NULL); + umockdev_ioctl_data_set_ptr(urb_ptr, 0, urb_data); + if (fixture->chat->next) + fixture->chat = fixture->chat->next; + else + fixture->chat += 1; + umockdev_ioctl_client_complete(client, 0, 0); + return TRUE; + } + } + + /* Nothing to reap */ + umockdev_ioctl_client_complete(client, -1, EAGAIN); + return TRUE; + } + + case USBDEVFS_DISCARDURB: { + GList *l = g_list_find_custom(fixture->flying_urbs, *(void**) ioctl_arg->data, cmp_ioctl_data_addr); + + if (l) { + fixture->discarded_urbs = g_list_append(fixture->discarded_urbs, l->data); + fixture->flying_urbs = g_list_delete_link(fixture->flying_urbs, l); + umockdev_ioctl_client_complete(client, 0, 0); + } else { + umockdev_ioctl_client_complete(client, -1, EINVAL); + } + + return TRUE; + } + + default: + return FALSE; + } +} + +static void +test_fixture_add_canon(UMockdevTestbedFixture * fixture) +{ + /* Setup first, so we can be sure libusb_open works when the add uevent + * happens. + */ + g_assert_cmpint(umockdev_testbed_attach_ioctl(fixture->testbed, "/dev/bus/usb/001/001", fixture->handler, NULL), ==, 1); + + /* NOTE: add_device would not create a file, needed for device emulation */ + /* XXX: Racy, see https://github.com/martinpitt/umockdev/issues/173 */ + umockdev_testbed_add_from_string(fixture->testbed, + "P: /devices/usb1\n" + "N: bus/usb/001/001\n" + "E: SUBSYSTEM=usb\n" + "E: DRIVER=usb\n" + "E: BUSNUM=001\n" + "E: DEVNUM=001\n" + "E: DEVNAME=/dev/bus/usb/001/001\n" + "E: DEVTYPE=usb_device\n" + "A: bConfigurationValue=1\\n\n" + "A: busnum=1\\n\n" + "A: devnum=1\\n\n" + "A: bConfigurationValue=1\\n\n" + "A: speed=480\\n\n" + /* descriptor from a Canon PowerShot SX200; VID 04a9 PID 31c0 */ + "H: descriptors=" + "1201000200000040a904c03102000102" + "030109022700010100c0010904000003" + "06010100070581020002000705020200" + "020007058303080009\n", + NULL); +} + +static void +test_fixture_setup_libusb(UMockdevTestbedFixture * fixture, int devcount) +{ + libusb_device **devs = NULL; + + libusb_init (&fixture->ctx); + + /* Supress global log messages completely + * (though, in some tests it might be interesting to check there are no real ones). + */ + libusb_set_log_cb (NULL, log_handler_null, LIBUSB_LOG_CB_GLOBAL); + libusb_set_option (fixture->ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_DEBUG); + g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, devcount); + libusb_free_device_list(devs, TRUE); + libusb_set_log_cb (fixture->ctx, log_handler, LIBUSB_LOG_CB_CONTEXT); +} + +static void +test_fixture_setup_common(UMockdevTestbedFixture * fixture) +{ + g_assert(cur_fixture == NULL); + cur_fixture = fixture; + + pthread_mutex_init(&fixture->mutex, NULL); + + fixture->testbed = umockdev_testbed_new(); + g_assert(fixture->testbed != NULL); + fixture->root_dir = umockdev_testbed_get_root_dir(fixture->testbed); + fixture->sys_dir = umockdev_testbed_get_sys_dir(fixture->testbed); + + fixture->handler = umockdev_ioctl_base_new(); + g_object_connect(fixture->handler, "signal-after::handle-ioctl", handle_ioctl_cb, fixture, NULL); +} + +static void +test_fixture_setup_empty(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + test_fixture_setup_common(fixture); + + test_fixture_setup_libusb(fixture, 0); +} + +static void +test_fixture_setup_with_canon(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + test_fixture_setup_common(fixture); + + test_fixture_add_canon(fixture); + + test_fixture_setup_libusb(fixture, 1); +} + +static void +test_fixture_teardown(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + g_assert(cur_fixture == fixture); + + /* Abort if there are any warnings/errors in the log */ + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO); + + if (fixture->ctx) { + libusb_device **devs = NULL; + int count = libusb_get_device_list(fixture->ctx, &devs); + libusb_free_device_list(devs, TRUE); + + libusb_exit (fixture->ctx); + + /* libusb_exit should result in the correct number of devices being destroyed */ + for (int i = 0; i < count; i++) + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_unref_device"); + + assert_libusb_no_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_unref_device"); + } + libusb_set_log_cb (NULL, NULL, LIBUSB_LOG_CB_GLOBAL); + cur_fixture = NULL; + + /* Abort if there are any warnings/errors in the log */ + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO); + fixture->ctx = NULL; + g_assert_null(fixture->libusb_log); + + g_clear_object(&fixture->handler); + g_clear_object(&fixture->testbed); + + /* verify that temp dir gets cleaned up properly */ + g_assert(!g_file_test(fixture->root_dir, G_FILE_TEST_EXISTS)); + g_free(fixture->root_dir); + g_free(fixture->sys_dir); + + while (fixture->flying_urbs) { + umockdev_ioctl_data_unref (fixture->flying_urbs->data); + fixture->flying_urbs = g_list_delete_link (fixture->flying_urbs, fixture->flying_urbs); + } + + pthread_mutex_destroy(&fixture->mutex); +} + +static void +test_open_close(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + libusb_device **devs = NULL; + struct libusb_device_descriptor desc; + libusb_device_handle *handle = NULL; + + g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, 1); + /* The linux_enumerate_device may happen from a different thread */ + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_get_device_list"); + /* We have exactly one device */ + g_assert_cmpint(libusb_get_bus_number(devs[0]), ==, 1); + g_assert_cmpint(libusb_get_device_address(devs[0]), ==, 1); + + /* Get/Check descriptor */ + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_INFO); + libusb_get_device_descriptor (devs[0], &desc); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "libusb_get_device_descriptor"); + g_assert_cmpint(desc.idVendor, ==, 0x04a9); + g_assert_cmpint(desc.idProduct, ==, 0x31c0); + + /* Open and close */ + g_assert_cmpint(libusb_open(devs[0], &handle), ==, 0); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "usbi_add_event_source"); + g_assert_nonnull(handle); + libusb_close(handle); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "usbi_remove_event_source"); + + libusb_free_device_list(devs, TRUE); + + /* Open and close using vid/pid */ + handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); + g_assert_nonnull(handle); + libusb_close(handle); +} + +static void +test_close_flying(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + UsbChat chat[] = { + { + .submit = TRUE, + .type = USBDEVFS_URB_TYPE_BULK, + .endpoint = LIBUSB_ENDPOINT_OUT, + .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, + .buffer_length = 4, + }, + { .submit = FALSE } + }; + libusb_device_handle *handle = NULL; + struct libusb_transfer *transfer = NULL; + + fixture->chat = chat; + + /* Open */ + handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); + g_assert_nonnull(handle); + + transfer = libusb_alloc_transfer(0); + libusb_fill_bulk_transfer(transfer, + handle, + LIBUSB_ENDPOINT_OUT, + (unsigned char*) chat[0].buffer, + chat[0].buffer_length, + NULL, + NULL, + 1); + + /* Submit */ + libusb_submit_transfer(transfer); + + /* Closing logs fat error (two lines) */ + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); + libusb_close(handle); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*connected as far as we know"); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*cancellation hasn't even been scheduled"); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[do_close\\] Removed transfer"); + + /* Free'ing the transfer works, and logs to the right context */ + libusb_free_transfer(transfer); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[libusb_free_transfer\\]"); +} + +static void +test_close_cancelled(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + UsbChat chat[] = { + { + .submit = TRUE, + .type = USBDEVFS_URB_TYPE_BULK, + .endpoint = LIBUSB_ENDPOINT_OUT, + .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, + .buffer_length = 4, + }, + { .submit = FALSE } + }; + libusb_device_handle *handle = NULL; + struct libusb_transfer *transfer = NULL; + + fixture->chat = chat; + + /* Open */ + handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); + g_assert_nonnull(handle); + + transfer = libusb_alloc_transfer(0); + libusb_fill_bulk_transfer(transfer, + handle, + LIBUSB_ENDPOINT_OUT, + (unsigned char*) chat[0].buffer, + chat[0].buffer_length, + NULL, + NULL, + 1); + + /* Submit */ + libusb_submit_transfer(transfer); + libusb_cancel_transfer(transfer); + + /* Closing logs fat error (two lines) */ + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); + libusb_close(handle); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[do_close\\] .*connected as far as we know"); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[do_close\\] .*cancellation.*hasn't completed"); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_DEBUG, "\\[do_close\\] Removed transfer"); + + libusb_free_transfer(transfer); +} + +static void +test_ctx_destroy(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + UsbChat chat[] = { + { + .submit = TRUE, + .type = USBDEVFS_URB_TYPE_BULK, + .endpoint = LIBUSB_ENDPOINT_OUT, + .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, + .buffer_length = 4, + }, + { .submit = FALSE } + }; + libusb_device_handle *handle = NULL; + struct libusb_transfer *transfer = NULL; + + fixture->chat = chat; + + /* Open */ + handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); + g_assert_nonnull(handle); + + transfer = libusb_alloc_transfer(0); + libusb_fill_bulk_transfer(transfer, + handle, + LIBUSB_ENDPOINT_OUT, + (unsigned char*) chat[0].buffer, + chat[0].buffer_length, + NULL, + NULL, + 1); + + /* Submit */ + libusb_submit_transfer(transfer); + + /* Now we are evil and destroy the ctx! */ + libusb_exit(fixture->ctx); + + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[libusb_exit\\] device.*still referenced"); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_WARNING, "\\[libusb_exit\\] application left some devices open"); + + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); + fixture->ctx = NULL; + + /* XXX: Closing crashes the application as it unref's the NULL pointer */ + /* libusb_close(handle); */ + + libusb_free_transfer(transfer); +} + +static void +test_get_string_descriptor(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + unsigned char data[255] = { 0, }; + libusb_device_handle *handle = NULL; + UsbChat chat[] = { + { + .submit = TRUE, + .reaps = &chat[1], + .type = USBDEVFS_URB_TYPE_CONTROL, + .buffer_length = 12, /* 8 byte out*/ + .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00", + }, { + /* String with content 0x0409 (en_US) */ + .reap = TRUE, + .actual_length = 12, + .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00\x04\x03\x09\x04", + }, { + .submit = TRUE, + .reaps = &chat[3], + .type = USBDEVFS_URB_TYPE_CONTROL, + .buffer_length = 263, /* 8 byte out*/ + .buffer = (const unsigned char*) "\x80\x06\x01\x03\x09\x04\xff\x00", + }, { + /* 4 byte string, "ab" */ + .reap = TRUE, + .actual_length = 14, + .buffer = (const unsigned char*) "\x80\x06\x01\x03\x09\x04\xff\x00\x06\x03\x61\x00\x62\x00", + }, { + .submit = TRUE, + .reaps = &chat[5], + .type = USBDEVFS_URB_TYPE_CONTROL, + .buffer_length = 12, /* 8 byte out*/ + .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00", + }, { + .reap = TRUE, + .status = -ENOENT, + }, { + .submit = TRUE, + .status = -ENOENT, + .type = USBDEVFS_URB_TYPE_CONTROL, + .buffer_length = 12, /* 8 byte out*/ + .buffer = (const unsigned char*) "\x80\x06\x00\x03\x00\x00\x04\x00", + }, { + .submit = FALSE, + } + }; + + fixture->chat = chat; + + handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); + g_assert_nonnull(handle); + + /* The chat allows us to fetch the descriptor */ + g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, 2); + g_assert_cmpint(memcmp(data, "ab", 2), ==, 0); + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); + + /* Again, but the URB fails with ENOENT when reaping */ + g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, -1); + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); + + /* Again, but the URB fails to submit with ENOENT */ + g_assert_cmpint(libusb_get_string_descriptor_ascii(handle, 1, data, sizeof(data)), ==, -1); + assert_libusb_log_msg(fixture, LIBUSB_LOG_LEVEL_ERROR, "\\[submit_control_transfer\\] submiturb failed, errno=2"); + clear_libusb_log(fixture, LIBUSB_LOG_LEVEL_DEBUG); + + libusb_close(handle); +} + +static void +transfer_cb_inc_user_data(struct libusb_transfer *transfer) +{ + *(int*)transfer->user_data += 1; +} + +static void +test_timeout(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + UsbChat chat[] = { + { + .submit = TRUE, + .type = USBDEVFS_URB_TYPE_BULK, + .endpoint = LIBUSB_ENDPOINT_OUT, + .buffer = (unsigned char[]) { 0x01, 0x02, 0x03, 0x04 }, + .buffer_length = 4, + }, + { + .submit = FALSE, + } + }; + int completed = 0; + libusb_device_handle *handle = NULL; + struct libusb_transfer *transfer = NULL; + + fixture->chat = chat; + + handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); + g_assert_nonnull(handle); + + transfer = libusb_alloc_transfer(0); + libusb_fill_bulk_transfer(transfer, + handle, + LIBUSB_ENDPOINT_OUT, + (unsigned char*) chat[0].buffer, + chat[0].buffer_length, + transfer_cb_inc_user_data, + &completed, + 10); + + libusb_submit_transfer(transfer); + while (!completed) { + g_assert_cmpint(libusb_handle_events_completed(fixture->ctx, &completed), ==, 0); + /* Silence after one iteration. */ + fixture->libusb_log_silence = TRUE; + } + fixture->libusb_log_silence = FALSE; + + g_assert_cmpint(transfer->status, ==, LIBUSB_TRANSFER_TIMED_OUT); + libusb_free_transfer(transfer); + + libusb_close(handle); +} + +#define THREADED_SUBMIT_URB_SETS 64 +#define THREADED_SUBMIT_URB_IN_FLIGHT 64 +typedef struct { + struct libusb_transfer *transfers[THREADED_SUBMIT_URB_IN_FLIGHT * THREADED_SUBMIT_URB_SETS]; + int submitted; + int completed; + int done; + UMockdevTestbedFixture *fixture; +} TestThreadedSubmit; + +static gpointer +transfer_submit_all_retry(TestThreadedSubmit *data) +{ + for (guint i = 0; i < G_N_ELEMENTS(data->transfers); i++) { + while (libusb_submit_transfer(data->transfers[i]) < 0) { + assert_libusb_log_msg(data->fixture, LIBUSB_LOG_LEVEL_ERROR, "submit_bulk_transfer"); + continue; + } + + data->submitted += 1; + } + + return NULL; +} + +static void +test_threaded_submit_transfer_cb(struct libusb_transfer *transfer) +{ + TestThreadedSubmit *data = transfer->user_data; + + /* We should only be receiving packets in the main thread */ + g_assert_cmpint (getpid(), ==, gettid()); + + /* Check that the transfer buffer has the expected value */ + g_assert_cmpint (*(int*)transfer->buffer, ==, data->completed); + data->completed += 1; + + if (data->completed == G_N_ELEMENTS(data->transfers)) + data->done = TRUE; +} + +static void +test_threaded_submit(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + GThread *thread = NULL; + TestThreadedSubmit data = { .fixture = fixture }; + UsbChat out_msg = { + .submit = TRUE, + .type = USBDEVFS_URB_TYPE_BULK, + .endpoint = LIBUSB_ENDPOINT_IN, + .buffer_length = sizeof(int), + }; + UsbChat in_msg = { + .reap = TRUE, + .actual_length = 4, + }; + UsbChat *c; + libusb_device_handle *handle = NULL; + int urb; + + handle = libusb_open_device_with_vid_pid(fixture->ctx, 0x04a9, 0x31c0); + g_assert_nonnull(handle); + + fixture->libusb_log_silence = TRUE; + + c = fixture->chat = g_new0(UsbChat, G_N_ELEMENTS(data.transfers) * 2 + 1); + urb = 0; + for (int i = 0; i < THREADED_SUBMIT_URB_SETS; i++) { + for (int j = 0; j < THREADED_SUBMIT_URB_IN_FLIGHT; j++) { + c[i*2*THREADED_SUBMIT_URB_IN_FLIGHT + j] = out_msg; + c[i*2*THREADED_SUBMIT_URB_IN_FLIGHT + j].reaps = &c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j]; + c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j] = in_msg; + c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j].buffer = (unsigned char*) g_new0(int, 1); + *(int*) c[(i*2+1)*THREADED_SUBMIT_URB_IN_FLIGHT + j].buffer = urb; + + data.transfers[urb] = libusb_alloc_transfer(0); + libusb_fill_bulk_transfer(data.transfers[urb], + handle, + LIBUSB_ENDPOINT_IN, + g_malloc(out_msg.buffer_length), + out_msg.buffer_length, + test_threaded_submit_transfer_cb, + &data, + G_MAXUINT); + data.transfers[urb]->flags = LIBUSB_TRANSFER_FREE_BUFFER | LIBUSB_TRANSFER_FREE_TRANSFER; + urb++; + } + } + + thread = g_thread_new("transfer all", (GThreadFunc) transfer_submit_all_retry, &data); + + while (!data.done) + g_assert_cmpint(libusb_handle_events_completed(fixture->ctx, &data.done), ==, 0); + + g_thread_join(thread); + + fixture->libusb_log_silence = FALSE; + libusb_close(handle); + + for (int i = 0; i < 2 * THREADED_SUBMIT_URB_SETS * THREADED_SUBMIT_URB_SETS; i++) + g_clear_pointer ((void**) &c->buffer, g_free); + g_free (c); +} + +static int +hotplug_count_arrival_cb(libusb_context *ctx, + libusb_device *device, + libusb_hotplug_event event, + void *user_data) +{ + g_assert_cmpint(event, ==, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED); + + (void) ctx; + (void) device; + + *(int*) user_data += 1; + + return 0; +} + +#ifdef UMOCKDEV_HOTPLUG +static int +hotplug_count_removal_cb(libusb_context *ctx, + libusb_device *device, + libusb_hotplug_event event, + void *user_data) +{ + g_assert_cmpint(event, ==, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT); + + (void) ctx; + (void) device; + + *(int*) user_data += 1; + + return 0; +} +#endif + +static void +test_hotplug_enumerate(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ + libusb_hotplug_callback_handle handle_enumerate; + libusb_hotplug_callback_handle handle_no_enumerate; + int event_count_enumerate = 0; + int event_count_no_enumerate = 0; + struct timeval zero_tv = { 0 }; + int r; + + r = libusb_hotplug_register_callback(fixture->ctx, + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, + LIBUSB_HOTPLUG_ENUMERATE, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + hotplug_count_arrival_cb, + &event_count_enumerate, + &handle_enumerate); + g_assert_cmpint(r, ==, 0); + + r = libusb_hotplug_register_callback(fixture->ctx, + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, + 0, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + hotplug_count_arrival_cb, + &event_count_no_enumerate, + &handle_no_enumerate); + g_assert_cmpint(r, ==, 0); + + g_assert_cmpint(event_count_enumerate, ==, 1); + g_assert_cmpint(event_count_no_enumerate, ==, 0); + + libusb_handle_events_timeout(fixture->ctx, &zero_tv); + + g_assert_cmpint(event_count_enumerate, ==, 1); + g_assert_cmpint(event_count_no_enumerate, ==, 0); + + libusb_hotplug_deregister_callback(fixture->ctx, handle_enumerate); + libusb_hotplug_deregister_callback(fixture->ctx, handle_no_enumerate); + + libusb_handle_events_timeout(fixture->ctx, &zero_tv); + + g_assert_cmpint(event_count_enumerate, ==, 1); + g_assert_cmpint(event_count_no_enumerate, ==, 0); +} + +static void +test_hotplug_add_remove(UMockdevTestbedFixture * fixture, UNUSED_DATA) +{ +#ifdef UMOCKDEV_HOTPLUG + libusb_device **devs = NULL; + libusb_hotplug_callback_handle handle_add; + libusb_hotplug_callback_handle handle_remove; + int event_count_add = 0; + int event_count_remove = 0; + struct timeval zero_tv = { 0 }; + int r; + + r = libusb_hotplug_register_callback(fixture->ctx, + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, + LIBUSB_HOTPLUG_ENUMERATE, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + hotplug_count_arrival_cb, + &event_count_add, + &handle_add); + g_assert_cmpint(r, ==, 0); + + r = libusb_hotplug_register_callback(fixture->ctx, + LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, + LIBUSB_HOTPLUG_ENUMERATE, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + LIBUSB_HOTPLUG_MATCH_ANY, + hotplug_count_removal_cb, + &event_count_remove, + &handle_remove); + g_assert_cmpint(r, ==, 0); + + /* No device, even going into the mainloop will not call cb. */ + libusb_handle_events_timeout(fixture->ctx, &zero_tv); + g_assert_cmpint(event_count_add, ==, 0); + g_assert_cmpint(event_count_remove, ==, 0); + + /* Add a device */ + test_fixture_add_canon(fixture); + + /* Either the thread has picked it up already, or we do so now. */ + g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, 1); + libusb_free_device_list(devs, TRUE); + + /* The hotplug event is pending now, but has not yet fired. */ + g_assert_cmpint(event_count_add, ==, 0); + g_assert_cmpint(event_count_remove, ==, 0); + + /* Fire hotplug event. */ + libusb_handle_events_timeout(fixture->ctx, &zero_tv); + g_assert_cmpint(event_count_add, ==, 1); + g_assert_cmpint(event_count_remove, ==, 0); + + umockdev_testbed_uevent(fixture->testbed, "/sys/devices/usb1", "remove"); + //umockdev_testbed_remove_device(fixture->testbed, "/devices/usb1"); + + /* Either the thread has picked it up already, or we do so now. */ + g_assert_cmpint(libusb_get_device_list(fixture->ctx, &devs), ==, 0); + libusb_free_device_list(devs, TRUE); + + /* The hotplug event is pending now, but has not yet fired. */ + g_assert_cmpint(event_count_add, ==, 1); + g_assert_cmpint(event_count_remove, ==, 0); + + /* Fire hotplug event. */ + libusb_handle_events_timeout(fixture->ctx, &zero_tv); + g_assert_cmpint(event_count_add, ==, 1); + g_assert_cmpint(event_count_remove, ==, 1); + + libusb_hotplug_deregister_callback(fixture->ctx, handle_add); + libusb_hotplug_deregister_callback(fixture->ctx, handle_remove); +#else + (void) fixture; + g_test_skip("UMockdev is too old to test hotplug"); +#endif +} + +int +main(int argc, char **argv) +{ + g_test_init(&argc, &argv, NULL); + + g_test_add("/libusb/open-close", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_open_close, + test_fixture_teardown); + + g_test_add("/libusb/close-flying", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_close_flying, + test_fixture_teardown); + g_test_add("/libusb/close-cancelled", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_close_cancelled, + test_fixture_teardown); + + g_test_add("/libusb/ctx-destroy", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_ctx_destroy, + test_fixture_teardown); + + g_test_add("/libusb/string-descriptor", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_get_string_descriptor, + test_fixture_teardown); + + g_test_add("/libusb/timeout", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_timeout, + test_fixture_teardown); + + g_test_add("/libusb/threaded-submit", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_threaded_submit, + test_fixture_teardown); + + g_test_add("/libusb/hotplug/enumerate", UMockdevTestbedFixture, NULL, + test_fixture_setup_with_canon, + test_hotplug_enumerate, + test_fixture_teardown); + + g_test_add("/libusb/hotplug/add-remove", UMockdevTestbedFixture, NULL, + test_fixture_setup_empty, + test_hotplug_add_remove, + test_fixture_teardown); + + return g_test_run(); +} |