* \returns LIBUSB_ERROR_OVERFLOW if the array is too small
*/
int API_EXPORTED libusb_get_port_numbers(libusb_device *dev,
- uint8_t* port_numbers, int port_numbers_len)
+ uint8_t *port_numbers, int port_numbers_len)
{
int i = port_numbers_len;
struct libusb_context *ctx = DEVICE_CTX(dev);
* \deprecated Please use \ref libusb_get_port_numbers() instead.
*/
int API_EXPORTED libusb_get_port_path(libusb_context *ctx, libusb_device *dev,
- uint8_t* port_numbers, uint8_t port_numbers_len)
+ uint8_t *port_numbers, uint8_t port_numbers_len)
{
UNUSED(ctx);
* before your application terminates.
* \param ctx the context to deinitialize, or NULL for the default context
*/
-void API_EXPORTED libusb_exit(struct libusb_context *ctx)
+void API_EXPORTED libusb_exit(libusb_context *ctx)
{
struct libusb_device *dev, *next;
struct timeval tv = { 0, 0 };
static void clear_endpoint(struct libusb_endpoint_descriptor *endpoint)
{
- free((void *) endpoint->extra);
+ free((void *)endpoint->extra);
}
static int parse_endpoint(struct libusb_context *ctx,
/* Copy any unknown descriptors into a storage area for drivers */
/* to later parse */
len = (int)(buffer - begin);
- if (len <= 0) {
- endpoint->extra = NULL;
- endpoint->extra_length = 0;
+ if (len <= 0)
return parsed;
- }
extra = malloc((size_t)len);
- endpoint->extra = extra;
- if (!extra) {
- endpoint->extra_length = 0;
+ if (!extra)
return LIBUSB_ERROR_NO_MEM;
- }
memcpy(extra, begin, len);
+ endpoint->extra = extra;
endpoint->extra_length = len;
return parsed;
struct libusb_interface_descriptor *ifp =
(struct libusb_interface_descriptor *)
usb_interface->altsetting + i;
- free((void *) ifp->extra);
+
+ free((void *)ifp->extra);
if (ifp->endpoint) {
for (j = 0; j < ifp->bNumEndpoints; j++)
clear_endpoint((struct libusb_endpoint_descriptor *)
ifp->endpoint + j);
}
- free((void *) ifp->endpoint);
+ free((void *)ifp->endpoint);
}
}
- free((void *) usb_interface->altsetting);
+ free((void *)usb_interface->altsetting);
usb_interface->altsetting = NULL;
}
int interface_number = -1;
struct usbi_descriptor_header *header;
struct libusb_interface_descriptor *ifp;
+ unsigned char *extra;
unsigned char *begin;
- usb_interface->num_altsetting = 0;
-
while (size >= LIBUSB_DT_INTERFACE_SIZE) {
- struct libusb_interface_descriptor *altsetting =
- (struct libusb_interface_descriptor *) usb_interface->altsetting;
- altsetting = usbi_reallocf(altsetting,
- sizeof(struct libusb_interface_descriptor) *
- ((size_t)usb_interface->num_altsetting + 1));
+ struct libusb_interface_descriptor *altsetting;
+
+ altsetting = usbi_reallocf((void *)usb_interface->altsetting,
+ sizeof(*altsetting) * (size_t)(usb_interface->num_altsetting + 1));
if (!altsetting) {
r = LIBUSB_ERROR_NO_MEM;
goto err;
/* drivers to later parse */
len = (int)(buffer - begin);
if (len > 0) {
- ifp->extra = malloc((size_t)len);
- if (!ifp->extra) {
+ extra = malloc((size_t)len);
+ if (!extra) {
r = LIBUSB_ERROR_NO_MEM;
goto err;
}
- memcpy((unsigned char *) ifp->extra, begin, len);
+
+ memcpy(extra, begin, len);
+ ifp->extra = extra;
ifp->extra_length = len;
}
if (ifp->bNumEndpoints > 0) {
struct libusb_endpoint_descriptor *endpoint;
- endpoint = calloc(ifp->bNumEndpoints, sizeof(struct libusb_endpoint_descriptor));
- ifp->endpoint = endpoint;
+
+ endpoint = calloc(ifp->bNumEndpoints, sizeof(*endpoint));
if (!endpoint) {
r = LIBUSB_ERROR_NO_MEM;
goto err;
}
+ ifp->endpoint = endpoint;
for (i = 0; i < ifp->bNumEndpoints; i++) {
r = parse_endpoint(ctx, endpoint + i, buffer, size);
if (r < 0)
}
/* We check to see if it's an alternate to this one */
- ifp = (struct libusb_interface_descriptor *) buffer;
+ ifp = (struct libusb_interface_descriptor *)buffer;
if (size < LIBUSB_DT_INTERFACE_SIZE ||
ifp->bDescriptorType != LIBUSB_DT_INTERFACE ||
ifp->bInterfaceNumber != interface_number)
clear_interface((struct libusb_interface *)
config->interface + i);
}
- free((void *) config->interface);
- free((void *) config->extra);
+ free((void *)config->interface);
+ free((void *)config->extra);
}
static int parse_configuration(struct libusb_context *ctx,
int r;
struct usbi_descriptor_header *header;
struct libusb_interface *usb_interface;
+ unsigned char *extra;
if (size < LIBUSB_DT_CONFIG_SIZE) {
usbi_err(ctx, "short config descriptor read %d/%d",
return LIBUSB_ERROR_IO;
}
- usb_interface = calloc(config->bNumInterfaces, sizeof(struct libusb_interface));
- config->interface = usb_interface;
+ usb_interface = calloc(config->bNumInterfaces, sizeof(*usb_interface));
if (!usb_interface)
return LIBUSB_ERROR_NO_MEM;
+ config->interface = usb_interface;
+
buffer += config->bLength;
size -= config->bLength;
- config->extra = NULL;
- config->extra_length = 0;
-
for (i = 0; i < config->bNumInterfaces; i++) {
int len;
unsigned char *begin;
if (len > 0) {
/* FIXME: We should realloc and append here */
if (!config->extra_length) {
- config->extra = malloc((size_t)len);
- if (!config->extra) {
+ extra = malloc((size_t)len);
+ if (!extra) {
r = LIBUSB_ERROR_NO_MEM;
goto err;
}
- memcpy((unsigned char *) config->extra, begin, len);
+ memcpy(extra, begin, len);
+ config->extra = extra;
config->extra_length = len;
}
}
static int raw_desc_to_config(struct libusb_context *ctx,
unsigned char *buf, int size, struct libusb_config_descriptor **config)
{
- struct libusb_config_descriptor *_config = malloc(sizeof(*_config));
+ struct libusb_config_descriptor *_config = calloc(1, sizeof(*_config));
int r;
if (!_config)
struct libusb_device_descriptor *desc)
{
usbi_dbg(" ");
- memcpy((unsigned char *) desc, (unsigned char *) &dev->device_descriptor,
- sizeof (dev->device_descriptor));
+ memcpy(desc, &dev->device_descriptor, sizeof(dev->device_descriptor));
return 0;
}
* \returns another LIBUSB_ERROR code on error
*/
int API_EXPORTED libusb_get_ss_endpoint_companion_descriptor(
- struct libusb_context *ctx,
+ libusb_context *ctx,
const struct libusb_endpoint_descriptor *endpoint,
struct libusb_ss_endpoint_companion_descriptor **ep_comp)
{
return LIBUSB_ERROR_IO;
}
- _bos = calloc (1,
- sizeof(*_bos) + bos_header.bNumDeviceCaps * sizeof(void *));
+ _bos = calloc(1, sizeof(*_bos) + bos_header.bNumDeviceCaps * sizeof(void *));
if (!_bos)
return LIBUSB_ERROR_NO_MEM;
parse_descriptor(bos_header, "bbwb", &_bos);
usbi_dbg("found BOS descriptor: size %d bytes, %d capabilities",
_bos.wTotalLength, _bos.bNumDeviceCaps);
- bos_data = calloc(_bos.wTotalLength, 1);
+ bos_data = calloc(1, _bos.wTotalLength);
if (bos_data == NULL)
return LIBUSB_ERROR_NO_MEM;
* \returns a LIBUSB_ERROR code on error
*/
int API_EXPORTED libusb_get_usb_2_0_extension_descriptor(
- struct libusb_context *ctx,
+ libusb_context *ctx,
struct libusb_bos_dev_capability_descriptor *dev_cap,
struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension)
{
* \returns a LIBUSB_ERROR code on error
*/
int API_EXPORTED libusb_get_ss_usb_device_capability_descriptor(
- struct libusb_context *ctx,
+ libusb_context *ctx,
struct libusb_bos_dev_capability_descriptor *dev_cap,
struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap)
{
* \returns 0 on success
* \returns a LIBUSB_ERROR code on error
*/
-int API_EXPORTED libusb_get_container_id_descriptor(struct libusb_context *ctx,
+int API_EXPORTED libusb_get_container_id_descriptor(libusb_context *ctx,
struct libusb_bos_dev_capability_descriptor *dev_cap,
struct libusb_container_id_descriptor **container_id)
{
return LIBUSB_SUCCESS;
}
-void API_EXPORTED libusb_hotplug_deregister_callback(struct libusb_context *ctx,
+void API_EXPORTED libusb_hotplug_deregister_callback(libusb_context *ctx,
libusb_hotplug_callback_handle callback_handle)
{
struct libusb_hotplug_callback *hotplug_cb;
}
DEFAULT_VISIBILITY
-void * LIBUSB_CALL libusb_hotplug_get_user_data(struct libusb_context *ctx,
+void * LIBUSB_CALL libusb_hotplug_get_user_data(libusb_context *ctx,
libusb_hotplug_callback_handle callback_handle)
{
struct libusb_hotplug_callback *hotplug_cb;
if (r < 0)
goto out;
- /* arm for next timeout*/
+ /* arm for next timeout */
r = arm_timerfd_for_next_timeout(ctx);
out:
goto out;
list_for_each_entry(ipollfd, &ctx->ipollfds, list, struct usbi_pollfd)
- ret[i++] = (struct libusb_pollfd *) ipollfd;
+ ret[i++] = (struct libusb_pollfd *)ipollfd;
ret[ctx->pollfds_cnt] = NULL;
out:
usbi_mutex_unlock(&ctx->event_data_lock);
- return (const struct libusb_pollfd **) ret;
+ return (const struct libusb_pollfd **)ret;
#else
usbi_err(ctx, "external polling of libusb's internal descriptors "\
"is not yet supported on Windows platforms");
usbi_mutex_unlock(&to_cancel->lock);
usbi_handle_transfer_completion(to_cancel, LIBUSB_TRANSFER_NO_DEVICE);
}
-
}
void LIBUSB_CALL libusb_free_config_descriptor(
struct libusb_config_descriptor *config);
int LIBUSB_CALL libusb_get_ss_endpoint_companion_descriptor(
- struct libusb_context *ctx,
+ libusb_context *ctx,
const struct libusb_endpoint_descriptor *endpoint,
struct libusb_ss_endpoint_companion_descriptor **ep_comp);
void LIBUSB_CALL libusb_free_ss_endpoint_companion_descriptor(
struct libusb_bos_descriptor **bos);
void LIBUSB_CALL libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos);
int LIBUSB_CALL libusb_get_usb_2_0_extension_descriptor(
- struct libusb_context *ctx,
+ libusb_context *ctx,
struct libusb_bos_dev_capability_descriptor *dev_cap,
struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension);
void LIBUSB_CALL libusb_free_usb_2_0_extension_descriptor(
struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension);
int LIBUSB_CALL libusb_get_ss_usb_device_capability_descriptor(
- struct libusb_context *ctx,
+ libusb_context *ctx,
struct libusb_bos_dev_capability_descriptor *dev_cap,
struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap);
void LIBUSB_CALL libusb_free_ss_usb_device_capability_descriptor(
struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap);
-int LIBUSB_CALL libusb_get_container_id_descriptor(struct libusb_context *ctx,
+int LIBUSB_CALL libusb_get_container_id_descriptor(libusb_context *ctx,
struct libusb_bos_dev_capability_descriptor *dev_cap,
struct libusb_container_id_descriptor **container_id);
void LIBUSB_CALL libusb_free_container_id_descriptor(
static inline struct libusb_control_setup *libusb_control_transfer_get_setup(
struct libusb_transfer *transfer)
{
- return (struct libusb_control_setup *)(void *) transfer->buffer;
+ return (struct libusb_control_setup *)(void *)transfer->buffer;
}
/** \ingroup libusb_asyncio
uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
uint16_t wLength)
{
- struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *) buffer;
+ struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *)buffer;
setup->bmRequestType = bmRequestType;
setup->bRequest = bRequest;
setup->wValue = libusb_cpu_to_le16(wValue);
unsigned char *buffer, libusb_transfer_cb_fn callback, void *user_data,
unsigned int timeout)
{
- struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *) buffer;
+ struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *)buffer;
transfer->dev_handle = dev_handle;
transfer->endpoint = 0;
transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
* \param[in] ctx context this callback is registered with
* \param[in] callback_handle the handle of the callback to get the user_data of
*/
-void * LIBUSB_CALL libusb_hotplug_get_user_data(struct libusb_context *ctx,
+void * LIBUSB_CALL libusb_hotplug_get_user_data(libusb_context *ctx,
libusb_hotplug_callback_handle callback_handle);
/** \ingroup libusb_lib
static struct udev_monitor *udev_monitor = NULL;
static pthread_t linux_event_thread;
-static void udev_hotplug_event(struct udev_device* udev_dev);
+static void udev_hotplug_event(struct udev_device *udev_dev);
static void *linux_udev_event_thread_main(void *arg);
int linux_udev_start_event_monitor(void)
char dummy;
int r;
ssize_t nb;
- struct udev_device* udev_dev;
+ struct udev_device *udev_dev;
struct pollfd fds[] = {
{.fd = udev_control_pipe[0],
.events = POLLIN},
dev_node, *sys_name, -1);
}
-static void udev_hotplug_event(struct udev_device* udev_dev)
+static void udev_hotplug_event(struct udev_device *udev_dev)
{
- const char* udev_action;
- const char* sys_name = NULL;
+ const char *udev_action;
+ const char *sys_name = NULL;
uint8_t busnum = 0, devaddr = 0;
int detached;
int r;
void linux_udev_hotplug_poll(void)
{
- struct udev_device* udev_dev;
+ struct udev_device *udev_dev;
usbi_mutex_static_lock(&linux_hotplug_lock);
do {
usbi_mutex_static_lock(&active_contexts_lock);
list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
- dev = usbi_get_device_by_session_id (ctx, session_id);
+ dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev) {
usbi_disconnect_device(dev);
libusb_unref_device(dev);
usbi_dbg("received %d bytes of surplus data", urb->actual_length);
if (urb->buffer != target) {
usbi_dbg("moving surplus data from offset %zu to offset %zu",
- (unsigned char *) urb->buffer - transfer->buffer,
+ (unsigned char *)urb->buffer - transfer->buffer,
target - transfer->buffer);
memmove(target, urb->buffer, urb->actual_length);
}
if (fd_count == fd_table_size) {
struct file_descriptor **new_table;
- unsigned long* new_bitmap;
+ unsigned long *new_bitmap;
// Need to expand the fd table and bitmap
new_table = realloc(fd_table, (fd_table_size + FD_TABLE_INCR_SIZE) * sizeof(*new_table));
{
struct wait_thread_data *thread_data;
HANDLE notify_event;
- HANDLE* handles;
+ HANDLE *handles;
int n, num_threads;
DWORD error, status;
{
string_list_t *list;
- list = calloc(1, sizeof (string_list_t));
+ list = calloc(1, sizeof(string_list_t));
if (list == NULL)
return (NULL);
- list->string = calloc(DEFAULT_LISTSIZE, sizeof (char *));
+ list->string = calloc(DEFAULT_LISTSIZE, sizeof(char *));
if (list->string == NULL)
return (NULL);
list->nargs = 0;
if ((list->nargs + 1) == list->listsize) { /* +1 is for NULL */
char **tmp = realloc(list->string,
- sizeof (char *) * (list->listsize + 1));
+ sizeof(char *) * (list->listsize + 1));
if (tmp == NULL) {
free(str);
return (-1);
/* create filename */
if (hpriv->config_index > 0) {
- (void) snprintf(cfg_num, sizeof (cfg_num), "cfg%d",
+ (void) snprintf(cfg_num, sizeof(cfg_num), "cfg%d",
hpriv->config_index + 1);
} else {
- bzero(cfg_num, sizeof (cfg_num));
+ bzero(cfg_num, sizeof(cfg_num));
}
if (hpriv->altsetting[ifc] > 0) {
- (void) snprintf(alt_num, sizeof (alt_num), ".%d",
+ (void) snprintf(alt_num, sizeof(alt_num), ".%d",
hpriv->altsetting[ifc]);
} else {
- bzero(alt_num, sizeof (alt_num));
+ bzero(alt_num, sizeof(alt_num));
}
(void) snprintf(filename, PATH_MAX, "%s/%sif%d%s%s%d",
return (errno);
} else {
- count = write(fdstat, &control, sizeof (control));
+ count = write(fdstat, &control, sizeof(control));
if (count != 1) {
/* this should have worked */
usbi_dbg("can't write to %s: errno %d (%s)",
tpriv->transfer = transfer;
aiocb = &tpriv->aiocb;
- bzero(aiocb, sizeof (*aiocb));
+ bzero(aiocb, sizeof(*aiocb));
aiocb->aio_fildes = hpriv->eps[ep].datafd;
aiocb->aio_buf = transfer->buffer;
aiocb->aio_nbytes = transfer->length;
usbi_dbg("sunos_usb_get_status(): fd=%d", fd);
- ret = read(fd, &status, sizeof (status));
- if (ret == sizeof (status)) {
+ ret = read(fd, &status, sizeof(status));
+ if (ret == sizeof(status)) {
switch (status) {
case USB_LC_STAT_NOERROR:
usbi_dbg("No Error");
struct driver_lookup {
char list[MAX_KEY_LENGTH + 1]; // REG_MULTI_SZ list of services (driver) names
const DWORD reg_prop; // SPDRP registry key to use to retrieve list
- const char* designation; // internal designation (for debug output)
+ const char *designation; // internal designation (for debug output)
};
/*
* used, and only 2 letter ISO 639-1 codes are accepted for it, such as "de".
* The optional region, country_region or codeset parts are ignored. This
* means that functions which return translatable strings will NOT honor the
- * specified encoding.
+ * specified encoding.
* All strings returned are encoded as UTF-8 strings.
*
* If libusb_setlocale() is not called, all messages will be in English.
if (!transfer)
return LIBUSB_ERROR_NO_MEM;
- buffer = (unsigned char*) malloc(LIBUSB_CONTROL_SETUP_SIZE + wLength);
+ buffer = malloc(LIBUSB_CONTROL_SETUP_SIZE + wLength);
if (!buffer) {
libusb_free_transfer(transfer);
return LIBUSB_ERROR_NO_MEM;
* \returns LIBUSB_ERROR_BUSY if called from event handling context
* \returns another LIBUSB_ERROR code on other failures
*/
-int API_EXPORTED libusb_bulk_transfer(struct libusb_device_handle *dev_handle,
- unsigned char endpoint, unsigned char *data, int length, int *transferred,
- unsigned int timeout)
+int API_EXPORTED libusb_bulk_transfer(libusb_device_handle *dev_handle,
+ unsigned char endpoint, unsigned char *data, int length,
+ int *transferred, unsigned int timeout)
{
return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
transferred, timeout, LIBUSB_TRANSFER_TYPE_BULK);
* \returns LIBUSB_ERROR_BUSY if called from event handling context
* \returns another LIBUSB_ERROR code on other error
*/
-int API_EXPORTED libusb_interrupt_transfer(
- struct libusb_device_handle *dev_handle, unsigned char endpoint,
- unsigned char *data, int length, int *transferred, unsigned int timeout)
+int API_EXPORTED libusb_interrupt_transfer(libusb_device_handle *dev_handle,
+ unsigned char endpoint, unsigned char *data, int length,
+ int *transferred, unsigned int timeout)
{
return do_sync_bulk_transfer(dev_handle, endpoint, data, length,
transferred, timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
-#define LIBUSB_NANO 11508
+#define LIBUSB_NANO 11509