libusb 0.6.4-x64-mingw32 → 0.7.0-x64-mingw32

data/lib/libusb/call.rb

@@ -228,14 +228,23 @@ module LIBUSB
     #
     # @see Bos::DeviceCapability
     BosTypes = enum :libusb_bos_type, [
-      # Wireless USB device capability
-      :BT_WIRELESS_USB_DEVICE_CAPABILITY, 1,
-      # USB 2.0 extensions
-      :BT_USB_2_0_EXTENSION, 2,
-      # SuperSpeed USB device capability
-      :BT_SS_USB_DEVICE_CAPABILITY, 3,
-      # Container ID type
-      :BT_CONTAINER_ID, 4,
+      :BT_WIRELESS_USB_DEVICE_CAPABILITY, 0x01, # Wireless USB device capability
+      :BT_USB_2_0_EXTENSION, 0x02, # USB 2.0 extensions
+      :BT_SS_USB_DEVICE_CAPABILITY, 0x03, # SuperSpeed USB device capability
+      :BT_CONTAINER_ID, 0x04, # Container ID type
+      :BT_PLATFORM_DESCRIPTOR, 0x05, # Platform descriptor
+      :BT_POWER_DELIVERY_CAPABILITY, 0x06, # Defines the various PD Capabilities of this device
+      :BT_BATTERY_INFO_CAPABILITY, 0x07, # Provides information on each battery supported by the device
+      :BT_PD_CONSUMER_PORT_CAPABILITY, 0x08, # The consumer characteristics of a port on the device
+      :BT_PD_PROVIDER_PORT_CAPABILITY, 0x09, # The provider characteristics of a port on the device
+      :BT_SUPERSPEED_PLUS, 0x0A, # Defines the set of SuperSpeed Plus USB specific device level capabilities
+      :BT_PRECISION_TIME_MEASUREMENT, 0x0B, # Precision Time Measurement (PTM) Capability Descriptor
+      :BT_Wireless_USB_Ext, 0x0C, # Defines the set of Wireless USB 1.1-specific device level capabilities
+      :BT_BILLBOARD, 0x0D, # Billboard capability
+      :BT_AUTHENTICATION, 0x0E, # Authentication Capability Descriptor
+      :BT_BILLBOARD_EX, 0x0F, # Billboard Ex capability
+      :BT_CONFIGURATION_SUMMARY, 0x10, # Summarizes configuration information for a function implemented by the device
+      :BT_FWStatus_Capability, 0x11, # Describes the capability to support FWStatus
     ]
 
     # Since libusb version 1.0.16.
@@ -274,6 +283,25 @@ module LIBUSB
       :LOG_LEVEL_DEBUG, 4,
     ]
 
+    # /** \ingroup libusb_lib
+    #  *  Log callback mode.
+    #  *
+    #  *  Since version 1.0.23, \ref LIBUSB_API_VERSION >= 0x01000107
+    #  *
+    #  * \see libusb_set_log_cb()
+    #  */
+    # enum libusb_log_cb_mode {
+    #   /** Callback function handling all log messages. */
+    #   LIBUSB_LOG_CB_GLOBAL = (1 << 0),
+    #
+    #   /** Callback function handling context related log messages. */
+    #   LIBUSB_LOG_CB_CONTEXT = (1 << 1)
+    # };
+    LogCbMode = enum :libusb_log_cb_mode, [
+      :LOG_CB_GLOBAL, (1 << 0),
+      :LOG_CB_CONTEXT, (1 << 1),
+    ]
+
     # Available option values for {Context#set_option}.
     Options = enum :libusb_option, [
       # Set the log message verbosity.
@@ -296,7 +324,7 @@ module LIBUSB
       #
       # If libusb was compiled with verbose debug message logging, this function
       # does nothing: you'll always get messages from all levels.
-      :OPTION_LOG_LEVEL,
+      :OPTION_LOG_LEVEL, 0,
 
       # Use the UsbDk backend for a specific context, if available.
       #
@@ -306,7 +334,33 @@ module LIBUSB
       # Only valid on Windows.
       #
       # Available since libusb-1.0.22.
-      :OPTION_USE_USBDK,
+      :OPTION_USE_USBDK, 1,
+
+      # Do not scan for devices
+      #
+      # With this option set, libusb will skip scanning devices in
+      # libusb_init_context().
+      #
+      # Hotplug functionality will also be deactivated.
+      #
+      # The option is useful in combination with libusb_wrap_sys_device(),
+      # which can access a device directly without prior device scanning.
+      #
+      # This is typically needed on Android, where access to USB devices
+      # is limited.
+      #
+      # Only valid on Linux. Ignored on all other platforms.
+      :OPTION_NO_DEVICE_DISCOVERY, 2,
+
+      # Set the context log callback functon.
+      #
+      # Set the log callback function either on a context or globally.
+      # This option must be provided a Proc argument or +nil+ to remove the callback.
+      # Using this option with a +nil+ context is equivalent to calling libusb_set_log_cb with mode :LOG_CB_GLOBAL.
+      # Using it with a non- +nil+ context is equivalent to calling libusb_set_log_cb with mode :LOG_CB_CONTEXT.
+      :OPTION_LOG_CB, 3,
+
+      :OPTION_MAX, 4,
     ]
 
     typedef :pointer, :libusb_context
@@ -315,15 +369,60 @@ module LIBUSB
     typedef :pointer, :libusb_transfer
     typedef :int, :libusb_hotplug_callback_handle
 
-    def self.try_attach_function(method, *args)
-      if ffi_libraries.find{|lib| lib.find_function(method) }
-        attach_function method, *args
+    # /** \ingroup libusb_lib
+    #  * Callback function for handling log messages.
+    #  * \param ctx the context which is related to the log message, or +nil+ if it
+    #  * is a global log message
+    #  * \param level the log level, see \ref libusb_log_level for a description
+    #  * \param str the log message
+    #  *
+    #  * Since version 1.0.23, \ref LIBUSB_API_VERSION >= 0x01000107
+    #  *
+    #  * \see libusb_set_log_cb()
+    #  */
+    # typedef void (LIBUSB_CALL *libusb_log_cb)(libusb_context *ctx,
+    #               enum libusb_log_level level, const char *str);
+    callback :libusb_log_cb, [:libusb_context, :libusb_log_level, :string], :void
+
+    # @private
+    # /** \ingroup libusb_lib
+    #  * Structure used for setting options through \ref libusb_init_context.
+    #  *
+    #  */
+    # struct libusb_init_option {
+    #     /** Which option to set */
+    #     enum libusb_option option;
+    #     /** An integer value used by the option (if applicable). */
+    #     union {
+    #         int64_t ival;
+    #         libusb_log_cb log_cbval;
+    #     } value;
+    # };
+    class InitOptionValue < FFI::Union
+      layout :ival, :int64_t,
+             :log_cbval, :libusb_log_cb
+    end
+    class InitOption < FFI::Struct
+      layout :option, :libusb_option,
+        :value, InitOptionValue
+    end
+
+    class << self
+      private def try_attach_function(method, *args, **kwargs)
+        if ffi_libraries.find{|lib| lib.find_function(method) }
+          attach_function method, *args, **kwargs
+        end
       end
     end
 
     try_attach_function 'libusb_get_version', [], :pointer
 
     attach_function 'libusb_init', [ :pointer ], :int
+    # int LIBUSB_CALL libusb_init_context(libusb_context **ctx, const struct libusb_init_option options[], int num_options);
+    try_attach_function 'libusb_init_context', [:pointer, :pointer, :int], :int
+    # may be deprecated in the future in favor of libusb_init_context()+libusb_set_option()
+    # void LIBUSB_CALL libusb_set_log_cb(libusb_context *ctx, libusb_log_cb cb, int mode);
+    try_attach_function 'libusb_set_log_cb', [:libusb_context, :libusb_log_cb, :int], :void
     attach_function 'libusb_exit', [ :pointer ], :void
     attach_function 'libusb_set_debug', [:pointer, :libusb_log_level], :void
     try_attach_function 'libusb_set_option', [:libusb_context, :libusb_option, :varargs], :int
@@ -348,6 +447,8 @@ module LIBUSB
     try_attach_function 'libusb_get_device_speed', [:pointer], :libusb_speed
     attach_function 'libusb_get_max_packet_size', [:pointer, :uint8], :int
     attach_function 'libusb_get_max_iso_packet_size', [:pointer, :uint8], :int
+    # int API_EXPORTED libusb_get_max_alt_packet_size(libusb_device *dev, int interface_number, int alternate_setting, unsigned char endpoint)
+    try_attach_function 'libusb_get_max_alt_packet_size', [:pointer, :int, :int, :uchar], :int
 
     try_attach_function 'libusb_get_ss_endpoint_companion_descriptor', [:pointer, :pointer, :pointer], :int
     try_attach_function 'libusb_free_ss_endpoint_companion_descriptor', [:pointer], :void
@@ -360,7 +461,11 @@ module LIBUSB
     try_attach_function 'libusb_free_ss_usb_device_capability_descriptor', [:pointer], :void
     try_attach_function 'libusb_get_container_id_descriptor', [:libusb_context, :pointer, :pointer], :int
     try_attach_function 'libusb_free_container_id_descriptor', [:pointer], :void
+    try_attach_function 'libusb_get_platform_descriptor', [:libusb_context, :pointer, :pointer], :int
+    try_attach_function 'libusb_free_platform_descriptor', [:pointer], :void
 
+    # int LIBUSB_CALL libusb_wrap_sys_device(libusb_context *ctx, intptr_t sys_dev, libusb_device_handle **dev_handle);
+    try_attach_function 'libusb_wrap_sys_device', [:libusb_context, :intptr_t, :pointer], :int
     attach_function 'libusb_open', [:pointer, :pointer], :int
     attach_function 'libusb_close', [:pointer], :void
     attach_function 'libusb_get_device', [:libusb_device_handle], :pointer
@@ -431,7 +536,7 @@ module LIBUSB
           :wLength, :uint16
     end
 
-    class Transfer < FFI::ManagedStruct
+    class Transfer < FFI::Struct
       layout :dev_handle, :libusb_device_handle,
         :flags, :uint8,
         :endpoint, :uchar,
@@ -445,8 +550,19 @@ module LIBUSB
         :buffer, :pointer,
         :num_iso_packets, :int
 
-      def self.release(ptr)
-        Call.libusb_free_transfer(ptr)
+      def initialize(*)
+        super
+
+        ptr = pointer
+        def ptr.free_struct(id)
+          Call.libusb_free_transfer(self)
+          return unless @ctx
+          @ctx.unref_context
+        end
+        # The ctx pointer is not yet assigned.
+        # It happens at LIBUSB::Transfer#dev_handle= later on.
+        ptr.instance_variable_set(:@ctx, nil)
+        ObjectSpace.define_finalizer(self, ptr.method(:free_struct))
       end
     end
 

data/lib/libusb/configuration.rb

@@ -16,8 +16,9 @@
 require 'libusb/call'
 
 module LIBUSB
-  class Configuration < FFI::ManagedStruct
+  class Configuration < FFI::Struct
     include Comparable
+    include ContextReference
 
     layout :bLength, :uint8,
         :bDescriptorType, :uint8,
@@ -108,10 +109,8 @@ module LIBUSB
     def initialize(device, *args)
       @device = device
       super(*args)
-    end
 
-    def self.release(ptr)
-      Call.libusb_free_config_descriptor(ptr)
+      register_context(device.context.instance_variable_get(:@ctx), :libusb_free_config_descriptor)
     end
 
     # @return [Device] the device this configuration belongs to.

data/lib/libusb/constants.rb

@@ -34,6 +34,7 @@ module LIBUSB
     Call::HotplugEvents,
     Call::HotplugFlags,
     Call::LogLevels,
+    Call::LogCbMode,
     Call::Options,
   ].each do |enum|
     enum.to_h.each{|k,v| const_set(k,v) }
@@ -52,6 +53,9 @@ module LIBUSB
     end
   end
 
+  class RemainingReferencesError < Error
+  end
+
   # @private
   ErrorClassForResult = {}
 

data/lib/libusb/context.rb

@@ -95,23 +95,87 @@ module LIBUSB
       end
     end
 
-
     # Initialize libusb context.
-    def initialize
+    #
+    # @param [Hash{Call::Options => Object}] options   Options are available since libusb-1.0.27
+    # @option options [Integer, Symbol] :OPTION_LOG_LEVEL   The log Level as a Integer or Symbol. See Call::LogLevels
+    # @option options [nil] :OPTION_USE_USBDK  Enable the use of USBDK driver. Pass a +nil+ as value like so: +OPTION_USE_USBDK: nil+
+    # @option options [nil] :OPTION_NO_DEVICE_DISCOVERY  Disable device discovery for use with libusb_wrap_sys_device(). Pass a +nil+ as value like so: +OPTION_NO_DEVICE_DISCOVERY: nil+
+    # @option options [Proc] :OPTION_LOG_CB   Set a context related log callback Proc. It is called with parameters (context, level, logstring).
+    def initialize(options={})
       m = FFI::MemoryPointer.new :pointer
-      res = Call.libusb_init(m)
-      LIBUSB.raise_error res, "in libusb_init" if res!=0
+      if options.empty?
+        res = Call.libusb_init(m)
+        LIBUSB.raise_error res, "in libusb_init" if res!=0
+      else
+        raise ArgumentError, "options require libusb-1.0.27+" unless Call.respond_to?(:libusb_init_context)
+        i_opts = options.size
+        p_opts = FFI::MemoryPointer.new(Call::InitOption, i_opts)
+        options.each_with_index do |(k, v), i|
+          opt = Call::InitOption.new(p_opts + i * Call::InitOption.size)
+          opt[:option] = k
+
+          ffitype, ffival = LIBUSB.send(:option_args_to_ffi, k, Array(v), self)
+          case ffitype
+            when NilClass then nil
+            when :libusb_log_level then
+              opt[:value][:ival] = ffival
+            when :libusb_log_cb then
+              opt[:value][:log_cbval] = ffival
+            else raise ArgumentError, "internal error: unexpected ffitype: #{ffitype.inspect}"
+          end
+        end
+        res = Call.libusb_init_context(m, p_opts, i_opts)
+        LIBUSB.raise_error res, "in libusb_init_context" if res!=0
+      end
       @ctx = m.read_pointer
       @on_pollfd_added = nil
       @on_pollfd_removed = nil
       @hotplug_callbacks = {}
+
+      def @ctx.free_context(id)
+        @free_context = true
+        if @refs == 0
+          # puts "final libusb_exit #{to_i} #{id} #{caller[0]}"
+          if id # Is Context is about to be garbage collected?
+            # In GC mode there's no way to call the registered collbacks, since they are GC'ed as well.
+            # So disable callbacks now.
+            Call.libusb_set_log_cb(self, nil, LOG_CB_CONTEXT)
+            Call.libusb_set_pollfd_notifiers(self, nil, nil, nil)
+          end
+          Call.libusb_exit(self)
+          @refs = nil
+        end
+      end
+      def @ctx.ref_context
+        @refs += 1
+        # puts "ref_context #{to_i} #{@refs} #{caller[1]}"
+        self
+      end
+      def @ctx.unref_context
+        @refs -= 1
+        # puts "unref_context #{to_i} #{@refs}"
+        raise "more unref_context than ref_context" if @refs < 0
+        free_context(true) if @refs == 0 && @free_context
+        self
+      end
+      def @ctx.setref_context
+        @refs = 0
+        @free_context = false
+      end
+      def @ctx.refs
+        @refs
+      end
+      @ctx.setref_context
+      ObjectSpace.define_finalizer(self, @ctx.method(:free_context))
     end
 
     # Deinitialize libusb.
     #
     # Should be called after closing all open devices and before your application terminates.
     def exit
-      Call.libusb_exit(@ctx)
+      raise RemainingReferencesError, "#{@ctx.refs} remaining references to LIBUSB::Context" if @ctx.refs.to_i > 0
+      @ctx.free_context nil
     end
 
     # @deprecated Use {Context#set_option} instead using the +:OPTION_LOG_LEVEL+ option.
@@ -119,30 +183,37 @@ module LIBUSB
       Call.libusb_set_debug(@ctx, level)
     end
 
-    def expect_option_args(exp, is)
-      raise ArgumentError, "wrong number of arguments (given #{is+1}, expected #{exp+1})" if is != exp
+    private def wrap_log_cb(block, mode)
+      if block
+        cb_proc = proc do |p_ctx, lev, str|
+          ctx = case p_ctx
+            when FFI::Pointer::NULL then nil
+            when @ctx then self
+            else p_ctx.to_i
+          end
+          block.call(ctx, lev, str)
+        end
+      end
+
+      # Avoid garbage collection of the proc, since only the function pointer is given to libusb
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_GLOBAL != 0
+        @@log_cb_proc = cb_proc
+      end
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_CONTEXT != 0
+        @log_cb_proc = cb_proc
+      end
+      cb_proc
     end
-    private :expect_option_args
 
-    # Set a libusb option from the {Call::Options option list}.
+    # Set a context related libusb option from the {Call::Options option list}.
     #
     # @param [Symbol, Fixnum] option
     # @param args  Zero or more arguments depending on +option+
+    # @see set_options
     def set_option(option, *args)
       if Call.respond_to?(:libusb_set_option)
         # Available since libusb-1.0.22
-
-        ffi_args = case option
-          when :OPTION_LOG_LEVEL, LIBUSB::OPTION_LOG_LEVEL
-            expect_option_args(1, args.length)
-            [:libusb_log_level, args[0]]
-          when :OPTION_USE_USBDK, LIBUSB::OPTION_USE_USBDK
-            expect_option_args(0, args.length)
-            []
-          else
-            raise ArgumentError, "unknown option #{option.inspect}"
-        end
-
+        ffi_args = LIBUSB.send(:option_args_to_ffi, option, args, self)
         res = Call.libusb_set_option(@ctx, option, *ffi_args)
         LIBUSB.raise_error res, "in libusb_set_option" if res<0
 
@@ -154,6 +225,69 @@ module LIBUSB
       end
     end
 
+    # Convenience function to set context related options in the libusb library.
+    #
+    # Use this function to configure any number of options within the library.
+    # It takes a Hash the same way as given to {Context.initialize}.
+    # See also {Call::Options option list}.
+    #
+    # @param [Hash{Call::Options => Object}] options   Option hash
+    # @see set_option
+    def set_options(options={})
+      options.each do |k, v|
+        set_option(k, *Array(v))
+      end
+    end
+
+    if Call.respond_to?(:libusb_set_log_cb)
+      # Set log handler.
+      #
+      # libusb will redirect its log messages to the provided method block.
+      # libusb supports redirection of per context and global log messages.
+      # Log messages sent to the context will be sent to the global log handler too.
+      #
+      # If libusb is compiled without message logging or USE_SYSTEM_LOGGING_FACILITY
+      # is defined then global callback function will never be called.
+      # If ENABLE_DEBUG_LOGGING is defined then per context callback function will
+      # never be called.
+      #
+      # To disable the log callback, execute set_log_cb without a block.
+      #
+      # Available since libusb-1.0.23, LIBUSB_API_VERSION >= 0x01000107
+      #
+      # @param [Symbol, Integer] mode   mode of callback function operation.
+      #       Several modes can be selected for a single callback function, see Call::LogCbMode for a description.
+      #
+      # @yieldparam [Context, nil] context  The context which is related to the log message, or +nil+ if it is a global log message.
+      # @yieldparam [Symbol] level   The log level, see Call::LogLevels for a description.
+      # @yieldparam [String] str   The log message.
+      #
+      # @see Call::LogCbMode
+      #
+      def set_log_cb(mode, &block)
+        cb_proc = wrap_log_cb(block, mode)
+        Call.libusb_set_log_cb(@ctx, cb_proc, mode)
+        self
+      end
+    end
+
+    if Call.respond_to?(:libusb_wrap_sys_device)
+      def wrap_sys_device(dev_io)
+        dev_io = dev_io.is_a?(IO) ? dev_io.fileno : dev_io
+
+        ppHandle = FFI::MemoryPointer.new :pointer
+        res = Call.libusb_wrap_sys_device(@ctx, dev_io, ppHandle)
+        LIBUSB.raise_error res, "in libusb_wrap_sys_device" if res!=0
+        handle = DevHandle.new self, ppHandle.read_pointer
+        return handle unless block_given?
+        begin
+          yield handle
+        ensure
+          handle.close
+        end
+      end
+    end
+
     def device_list
       pppDevs = FFI::MemoryPointer.new :pointer
       size = Call.libusb_get_device_list(@ctx, pppDevs)
@@ -327,14 +461,18 @@ module LIBUSB
     # This block will be invoked for every new file descriptor that
     # libusb uses as an event source.
     #
+    # To disable the notification callback, execute on_pollfd_added without a block.
+    #
     # Note that file descriptors may have been added even before you register these
     # notifiers (e.g. at {Context#initialize} time).
     #
     # @yieldparam [Pollfd] pollfd  The added file descriptor is yielded to the block
     def on_pollfd_added &block
-      @on_pollfd_added = proc do |fd, events, _|
-        pollfd = Pollfd.new fd, events
-        block.call pollfd
+      @on_pollfd_added = if block
+        proc do |fd, events, _|
+          pollfd = Pollfd.new fd, events
+          block.call pollfd
+        end
       end
       Call.libusb_set_pollfd_notifiers @ctx, @on_pollfd_added, @on_pollfd_removed, nil
     end
@@ -344,6 +482,8 @@ module LIBUSB
     # This block will be invoked for every removed file descriptor that
     # libusb uses as an event source.
     #
+    # To disable the notification callback, execute on_pollfd_removed without a block.
+    #
     # Note that the removal notifier may be called during {Context#exit}
     # (e.g. when it is closing file descriptors that were opened and added to the poll
     # set at {Context#initialize} time). If you don't want this, overwrite the notifier
@@ -351,9 +491,11 @@ module LIBUSB
     #
     # @yieldparam [Pollfd] pollfd  The removed file descriptor is yielded to the block
     def on_pollfd_removed &block
-      @on_pollfd_removed = proc do |fd, _|
-        pollfd = Pollfd.new fd
-        block.call pollfd
+      @on_pollfd_removed = if block
+        proc do |fd, _|
+          pollfd = Pollfd.new fd
+          block.call pollfd
+        end
       end
       Call.libusb_set_pollfd_notifiers @ctx, @on_pollfd_added, @on_pollfd_removed, nil
     end
@@ -393,19 +535,18 @@ module LIBUSB
     # @yieldparam [Symbol] event  a {Call::HotplugEvents HotplugEvents} symbol
     # @yieldreturn [Symbol] +:finish+ to deregister the callback, +:repeat+ to receive additional events
     # @raise [ArgumentError, LIBUSB::Error] in case of failure
-    def on_hotplug_event(args={}, &block)
-      events = args.delete(:events) || (HOTPLUG_EVENT_DEVICE_ARRIVED | HOTPLUG_EVENT_DEVICE_LEFT)
-      flags = args.delete(:flags) || 0
-      vendor_id = args.delete(:vendor_id) || HOTPLUG_MATCH_ANY
-      product_id = args.delete(:product_id) || HOTPLUG_MATCH_ANY
-      dev_class = args.delete(:dev_class) || HOTPLUG_MATCH_ANY
-      raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
+    def on_hotplug_event(events: HOTPLUG_EVENT_DEVICE_ARRIVED | HOTPLUG_EVENT_DEVICE_LEFT,
+                         flags: 0,
+                         vendor_id: HOTPLUG_MATCH_ANY,
+                         product_id: HOTPLUG_MATCH_ANY,
+                         dev_class: HOTPLUG_MATCH_ANY,
+                         &block)
 
       handle = HotplugCallback.new self, @ctx, @hotplug_callbacks
 
       block2 = proc do |ctx, pDevice, event, _user_data|
         raise "internal error: unexpected context" unless @ctx==ctx
-        dev = Device.new @ctx, pDevice
+        dev = Device.new self, pDevice
 
         blres = block.call(dev, event)
 

data/lib/libusb/context_reference.rb

@@ -0,0 +1,38 @@
+# This file is part of Libusb for Ruby.
+#
+# Libusb for Ruby 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 3 of the License, or
+# (at your option) any later version.
+#
+# Libusb for Ruby 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 Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+module LIBUSB
+  module ContextReference
+    def register_context(ctx, free_sym)
+      ptr = pointer
+      def ptr.free_struct(id)
+        return unless @ctx
+        Call.send(@free_sym, self)
+        @ctx.unref_context
+      end
+      ptr.instance_variable_set(:@free_sym, free_sym)
+      ptr.instance_variable_set(:@ctx, ctx.ref_context)
+      ObjectSpace.define_finalizer(self, ptr.method(:free_struct))
+    end
+
+    def free
+      ptr = pointer
+      ptr.free_struct nil
+      ptr.instance_variable_set(:@ctx, nil)
+    end
+  end
+
+  private_constant :ContextReference
+end

data/lib/libusb/dependencies.rb

@@ -1,7 +1,7 @@
 module LIBUSB
-  LIBUSB_VERSION = ENV['LIBUSB_VERSION'] || '1.0.22'
+  LIBUSB_VERSION = ENV['LIBUSB_VERSION'] || '1.0.27'
   LIBUSB_SOURCE_URI = "https://github.com/libusb/libusb/releases/download/v#{LIBUSB_VERSION}/libusb-#{LIBUSB_VERSION}.tar.bz2"
-  LIBUSB_SOURCE_SHA1 = '10116aa265aac4273a0c894faa089370262ec0dc'
+  LIBUSB_SOURCE_SHA256 = 'ffaa41d741a8a3bee244ac8e54a72ea05bf2879663c098c82fc5757853441575'
 
   MINI_PORTILE_VERSION = '~> 2.1'
 end