void API_EXPORTED libusb_exit(struct libusb_context *ctx) { usbi_dbg(""); USBI_GET_CONTEXT(ctx); if (ctx == usbi_default_context) { usbi_mutex_static_lock(&default_context_lock); if (--default_context_refcnt > 0) { usbi_dbg("not destroying default context"); usbi_mutex_static_unlock(&default_context_lock); return; } usbi_dbg("destroying default context"); usbi_default_context = NULL; usbi_mutex_static_unlock(&default_context_lock); } if (!list_empty(&ctx->open_devs)) usbi_warn(ctx, "application left some devices open"); usbi_io_exit(ctx); if (usbi_backend->exit) usbi_backend->exit(); usbi_mutex_destroy(&ctx->open_devs_lock); usbi_mutex_destroy(&ctx->usb_devs_lock); free(ctx); }
void API_EXPORTED libusb_hotplug_deregister_callback (struct libusb_context *ctx, libusb_hotplug_callback_handle handle) { struct libusb_hotplug_callback *hotplug_cb; libusb_hotplug_message message; ssize_t ret; /* check for hotplug support */ if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) { return; } USBI_GET_CONTEXT(ctx); usbi_mutex_lock(&ctx->hotplug_cbs_lock); list_for_each_entry(hotplug_cb, &ctx->hotplug_cbs, list, struct libusb_hotplug_callback) { if (handle == hotplug_cb->handle) { /* Mark this callback for deregistration */ hotplug_cb->needs_free = 1; } } usbi_mutex_unlock(&ctx->hotplug_cbs_lock); /* wakeup handle_events to do the actual free */ memset(&message, 0, sizeof(message)); ret = usbi_write(ctx->hotplug_pipe[1], &message, sizeof(message)); if (sizeof(message) != ret) { usbi_err(ctx, "error writing hotplug message"); } }
ssize_t API_EXPORTED libusb_get_device_list(libusb_context *ctx, libusb_device ***list) { struct discovered_devs *discdevs = discovered_devs_alloc(); struct libusb_device **ret; int r = 0; ssize_t i, len; USBI_GET_CONTEXT(ctx); usbi_dbg(""); if (!discdevs) return LIBUSB_ERROR_NO_MEM; if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) { struct libusb_device *dev; if (usbi_backend->hotplug_poll) usbi_backend->hotplug_poll(); usbi_mutex_lock(&ctx->usb_devs_lock); list_for_each_entry(dev, &ctx->usb_devs, list, struct libusb_device) { discdevs = discovered_devs_append(discdevs, dev); if (!discdevs) { r = LIBUSB_ERROR_NO_MEM; break; } } usbi_mutex_unlock(&ctx->usb_devs_lock); } else {
void usbi_log_v(struct libusb_context *ctx, enum usbi_log_level level, const char *function, const char *format, va_list args) { FILE *stream = stdout; const char *prefix; struct timeval now; static struct timeval first = { 0, 0 }; #ifndef ENABLE_DEBUG_LOGGING USBI_GET_CONTEXT(ctx); if (!ctx->debug) return; if (level == LOG_LEVEL_WARNING && ctx->debug < 2) return; if (level == LOG_LEVEL_INFO && ctx->debug < 3) return; #endif usbi_gettimeofday(&now, NULL); if (!first.tv_sec) { first.tv_sec = now.tv_sec; first.tv_usec = now.tv_usec; } if (now.tv_usec < first.tv_usec) { now.tv_sec--; now.tv_usec += 1000000; } now.tv_sec -= first.tv_sec; now.tv_usec -= first.tv_usec; switch (level) { case LOG_LEVEL_INFO: prefix = "info"; break; case LOG_LEVEL_WARNING: stream = stderr; prefix = "warning"; break; case LOG_LEVEL_ERROR: stream = stderr; prefix = "error"; break; case LOG_LEVEL_DEBUG: stream = stderr; prefix = "debug"; break; default: stream = stderr; prefix = "unknown"; break; } fprintf(stream, "libusb: %d.%06d %s [%s] ", (int)now.tv_sec, (int)now.tv_usec, prefix, function); vfprintf(stream, format, args); fprintf(stream, "\n"); }
void API_EXPORTED libusb_hotplug_deregister_callback (struct libusb_context *ctx, libusb_hotplug_callback_handle handle) { struct libusb_hotplug_callback *hotplug_cb; /* check for hotplug support */ if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) { return; } USBI_GET_CONTEXT(ctx); usbi_mutex_lock(&ctx->hotplug_cbs_lock); list_for_each_entry(hotplug_cb, &ctx->hotplug_cbs, list, struct libusb_hotplug_callback) { if (handle == hotplug_cb->handle) { /* Mark this callback for deregistration */ hotplug_cb->needs_free = 1; } } usbi_mutex_unlock(&ctx->hotplug_cbs_lock); }
ssize_t API_EXPORTED libusb_get_device_list(libusb_context *ctx, libusb_device ***list) { struct discovered_devs *discdevs = discovered_devs_alloc(); struct libusb_device **ret; int r = 0; ssize_t i, len; USBI_GET_CONTEXT(ctx); usbi_dbg(""); if (!discdevs) return LIBUSB_ERROR_NO_MEM; r = usbi_backend->get_device_list(ctx, &discdevs); if (r < 0) { len = r; goto out; } len = discdevs->len; ret = malloc(sizeof(void *) * (len + 1)); if (!ret) { len = LIBUSB_ERROR_NO_MEM; goto out; } ret[len] = NULL; for (i = 0; i < len; i++) { struct libusb_device *dev = discdevs->devices[i]; ret[i] = libusb_ref_device(dev); } *list = ret; out: discovered_devs_free(discdevs); return len; }
int API_EXPORTED libusb_hotplug_register_callback(libusb_context *ctx, libusb_hotplug_event events, libusb_hotplug_flag flags, int vendor_id, int product_id, int dev_class, libusb_hotplug_callback_fn cb_fn, void *user_data, libusb_hotplug_callback_handle *handle) { libusb_hotplug_callback *new_callback; static int handle_id = 1; /* check for hotplug support */ if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) { return LIBUSB_ERROR_NOT_SUPPORTED; } /* check for sane values */ if ((LIBUSB_HOTPLUG_MATCH_ANY != vendor_id && (~0xffff & vendor_id)) || (LIBUSB_HOTPLUG_MATCH_ANY != product_id && (~0xffff & product_id)) || (LIBUSB_HOTPLUG_MATCH_ANY != dev_class && (~0xff & dev_class)) || !cb_fn) { return LIBUSB_ERROR_INVALID_PARAM; } USBI_GET_CONTEXT(ctx); new_callback = (libusb_hotplug_callback *)calloc(1, sizeof (*new_callback)); if (!new_callback) { return LIBUSB_ERROR_NO_MEM; } new_callback->ctx = ctx; new_callback->vendor_id = vendor_id; new_callback->product_id = product_id; new_callback->dev_class = dev_class; new_callback->flags = flags; new_callback->events = events; new_callback->cb = cb_fn; new_callback->user_data = user_data; new_callback->needs_free = 0; usbi_mutex_lock(&ctx->hotplug_cbs_lock); /* protect the handle by the context hotplug lock. it doesn't matter if the same handle * is used for different contexts only that the handle is unique for this context */ new_callback->handle = handle_id++; list_add(&new_callback->list, &ctx->hotplug_cbs); usbi_mutex_unlock(&ctx->hotplug_cbs_lock); if (flags & LIBUSB_HOTPLUG_ENUMERATE) { int i, len; struct libusb_device **devs; len = (int) libusb_get_device_list(ctx, &devs); if (len < 0) { libusb_hotplug_deregister_callback(ctx, new_callback->handle); return len; } for (i = 0; i < len; i++) { usbi_hotplug_match_cb(ctx, devs[i], LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, new_callback); } libusb_free_device_list(devs, 1); } if (handle) { *handle = new_callback->handle; } return LIBUSB_SUCCESS; }
int API_EXPORTED libusb_interrupt_handle_event(struct libusb_context* ctx) { unsigned char dummy = 1; USBI_GET_CONTEXT(ctx); return usbi_write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy)); }
void API_EXPORTED libusb_set_debug(libusb_context *ctx, int level) { USBI_GET_CONTEXT(ctx); if (!ctx->debug_fixed) ctx->debug = level; }