libusb 0.4.1-x64-mingw32 → 0.5.0-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 73cc1af425996963568d9c77e4909d821a825140
+  data.tar.gz: f68970c05f9bd6cdf91dd1e640afd872a074d00c
+SHA512:
+  metadata.gz: 3b0b81620aac1dcc34065a8f19e86e40ee672676f507c9f87998af9fbbf581c420c8b5748afd202a37b28efbbf00cd80db278ba059a19ac0d30cb643eb366e42
+  data.tar.gz: 8de2450c4be88e6157990ce53368b38897b2333fde913f7c60024a600143df29b1c318083c67ffc815f92d7c6b94c957d209050c681acc93667f2556d69e77ff

checksums.yaml.gz.sig

@@ -0,0 +1,3 @@
+O��F�QВ�������Gޯ��K����ڇ��l�/+�՞+q\"bZ3��9��d_)�BO���6���/�K�;e�����⧇SJv&jL�<�^b���N�=чf{�������u,�.!m�Jee���K6�?H��C��%
+�@��¿O��0,��≪ֵ��Md��F�K5��jd2�WP��+�����s�x������qx��Z�V%*�U��W�G�,SQC۲]
m,.z�a�
+���

data.tar.gz.sig

@@ -0,0 +1,2 @@
+j����z��(f��G�W�A&F�:?$�v�R����}��1�B�>&v��G,�~s-Z�F)��i,�����6�"NI�P@����
+{��~�(�������N�h�g����PpD����� ���;s�����/�������q��`���e�׌��ZT��yK�l�T�gN�

data/.travis.yml

@@ -4,7 +4,7 @@ rvm:
   - "1.9.3"
   - "2.0.0"
   - "2.1"
-  - jruby-18mode # JRuby in 1.8 mode
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-2.2.6
+  - "2.2"
+  - jruby
+  - rbx
 script: bundle exec rake travis

data/History.md

@@ -1,3 +1,11 @@
+0.5.0 / 2015-01-08
+------------------
+* Add support for BOS describtors of libusb-1.0.16
+* Add support for superspeed endpoint companion descriptors of libusb-1.0.16
+* Add support for USB-3.0 bulk streams of libusb-1.0.19
+* Update bundled libusb version to 1.0.19.
+* Update windows cross build to gcc-4.8 and recent rubygems
+
 0.4.1 / 2014-05-17
 ------------------
 * Update bundled libusb version to 1.0.18.

data/README.md

@@ -18,6 +18,7 @@ Features
 
 * Access to descriptors of devices, configurations, interfaces, settings and endpoints
 * Synchronous and asynchronous communication for bulk, control, interrupt and isochronous transfers
+* Support for USB-3.0 descriptors and bulk streams
 * Compatibility layer for [ruby-usb](http://www.a-k-r.org/ruby-usb/) (API based on libusb-0.1). See {::USB} for description.
 
 Synopsis

data/Rakefile

@@ -25,7 +25,7 @@ COMPILE_HOME               = Pathname( "./tmp" ).expand_path
 STATIC_SOURCESDIR          = COMPILE_HOME + 'sources'
 
 # Fetch tarball from sourceforge
-LIBUSB_VERSION            = ENV['LIBUSB_VERSION'] || '1.0.18'
+LIBUSB_VERSION            = ENV['LIBUSB_VERSION'] || '1.0.19'
 LIBUSB_SOURCE_URI         = URI( "http://downloads.sourceforge.net/project/libusb/libusb-1.0/libusb-#{LIBUSB_VERSION}/libusb-#{LIBUSB_VERSION}.tar.bz2" )
 LIBUSB_TARBALL            = STATIC_SOURCESDIR + File.basename( LIBUSB_SOURCE_URI.path )
 
@@ -98,6 +98,8 @@ class CrossLibrary < OpenStruct
 
     libusb_env = [
       "CFLAGS='-fno-omit-frame-pointer'",
+      "LDFLAGS='-static-libgcc'",
+      "CC='#{host_platform}-gcc -static-libgcc'", # hack libtool, since it doesn't support -static-libgcc yet.
     ]
 
     # generate the makefile in a clean build location
@@ -123,17 +125,14 @@ class CrossLibrary < OpenStruct
 
     task "libusb_dll:#{ruby_platform}" => libusb_dll
 
-    desc "compile static libusb libraries"
-    task :libusb_dll => "libusb_dll:#{ruby_platform}"
-
     desc 'Cross compile libusb for win32'
     task :cross => [ "libusb_dll:#{ruby_platform}" ] do |t|
-      spec = Gem::Specification::load("libusb.gemspec")
-      spec.instance_variable_set(:"@cache_file", nil) if spec.respond_to?(:cache_file)
+      spec = Gem::Specification::load("libusb.gemspec").dup
       spec.platform = Gem::Platform.new(ruby_platform)
-      spec.files << "lib/#{File.basename(libusb_dll)}"
-      spec.files -= `git ls-files ext`.split("\n")
       spec.extensions = []
+      spec.files -= `git ls-files ext`.split("\n")
+      spec_text_files = spec.files.dup
+      spec.files << "lib/#{File.basename(libusb_dll)}"
 
       # Generate a package for this gem
       pkg = Gem::PackageTask.new(spec) do |pkg|
@@ -145,22 +144,23 @@ class CrossLibrary < OpenStruct
       end
 
       # copy files of the gem to pkg directory
-      file pkg.package_dir_path => spec.files do
-        spec.files.each do |fn|
-          next if fn == "lib/#{File.basename(libusb_dll)}"
+      file pkg.package_dir_path => spec_text_files do
+        spec_text_files.each do |fn|
           f = File.join(pkg.package_dir_path, fn)
           fdir = File.dirname(f)
           mkdir_p(fdir) if !File.exist?(fdir)
           rm_f f
           safe_ln(fn, f)
         end
-      end
-      # copy libusb.dll to pkg directory
-      file pkg.package_dir_path => [libusb_dll] do
+
+        # copy libusb.dll to pkg directory
         f = "#{pkg.package_dir_path}/lib/#{File.basename(libusb_dll)}"
+        mkdir_p File.dirname(f)
         rm_f f
         safe_ln libusb_dll, f
       end
+
+      file "lib/#{File.basename(libusb_dll)}" => [libusb_dll]
     end
   end
 end

data/lib/libusb.rb

@@ -25,7 +25,9 @@ module LIBUSB
   autoload :Endpoint, 'libusb/endpoint'
   autoload :Interface, 'libusb/interface'
   autoload :Setting, 'libusb/setting'
-  %w[ Transfer BulkTransfer ControlTransfer InterruptTransfer IsoPacket IsochronousTransfer ].each do |klass|
+  autoload :SsCompanion, 'libusb/ss_companion'
+  autoload :Bos, 'libusb/bos'
+  %w[ Transfer BulkTransfer BulkStreamTransfer ControlTransfer InterruptTransfer IsoPacket IsochronousTransfer ].each do |klass|
     autoload klass, 'libusb/transfer'
   end
 

data/lib/libusb/bos.rb

@@ -0,0 +1,306 @@
+# 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/>.
+
+require 'libusb/call'
+
+module LIBUSB
+  # A structure representing the Binary Device Object Store (BOS) descriptor.
+  # This descriptor is documented in section 9.6.2 of the USB 3.0 specification.
+  # All multiple-byte fields are represented in host-endian format.
+  class Bos < FFI::ManagedStruct
+
+    module GenericMethods
+      # @return [Integer]  Size of this descriptor (in bytes)
+      def bLength
+        self[:bLength]
+      end
+
+      # @return [Integer]  Descriptor type. Will have value LIBUSB::DT_DEVICE_CAPABILITY
+      # in this context.
+      def bDescriptorType
+        self[:bDescriptorType]
+      end
+
+      # @return [Integer] Device Capability type
+      def bDevCapabilityType
+        self[:bDevCapabilityType]
+      end
+
+      def inspect
+        "\#<#{self.class} cap: #{bDevCapabilityType} data: #{dev_capability_data.unpack("H*")[0]}>"
+      end
+
+      # @return [String]  Device Capability data (bLength - 3 bytes)
+      def dev_capability_data
+        pointer.read_bytes(bLength - 3)
+      end
+    end
+
+    # A generic representation of a BOS Device Capability descriptor.
+    class DeviceCapability < FFI::Struct
+      include GenericMethods
+
+      layout :bLength, :uint8,
+          :bDescriptorType, :uint8,
+          :bDevCapabilityType, :uint8
+
+      def initialize( bos, *args)
+        # Avoid that the bos struct is GC'ed before this instance
+        @bos = bos
+        super(*args)
+      end
+    end
+
+    # A structure representing the USB 2.0 Extension descriptor
+    # This descriptor is documented in section 9.6.2.1 of the USB 3.0 specification.
+    # All multiple-byte fields are represented in host-endian format.
+    class Usb20Extension < FFI::ManagedStruct
+      include GenericMethods
+
+      layout :bLength, :uint8,
+          :bDescriptorType, :uint8,
+          :bDevCapabilityType, :uint8,
+          :bmAttributes, :uint32
+
+      # Bitmap encoding of supported device level features.
+      # A value of one in a bit location indicates a feature is
+      # supported; a value of zero indicates it is not supported.
+      # @see Call::Usb20ExtensionAttributes
+      def bmAttributes
+        self[:bmAttributes]
+      end
+
+      # @return [Boolean] Supports Link Power Management (LPM)
+      def bm_lpm_support?
+        (bmAttributes & BM_LPM_SUPPORT) != 0
+      end
+
+      def inspect
+        attrs = Call::Usb20ExtensionAttributes.to_h.map do |k, v|
+          (bmAttributes & v) ? k.to_s : nil
+        end
+        "\#<#{self.class} #{attrs.compact.join(",")}>"
+      end
+
+      # @private
+      def self.release(ptr)
+        Call.libusb_free_usb_2_0_extension_descriptor(ptr)
+      end
+    end
+
+    # A structure representing the SuperSpeed USB Device Capability descriptor
+    # This descriptor is documented in section 9.6.2.2 of the USB 3.0 specification.
+    # All multiple-byte fields are represented in host-endian format.
+    class SsUsbDeviceCapability < FFI::ManagedStruct
+      include GenericMethods
+
+      layout :bLength, :uint8,
+          :bDescriptorType, :uint8,
+          :bDevCapabilityType, :uint8,
+          :bmAttributes, :uint32,
+          :wSpeedSupported, :uint16,
+          :bFunctionalitySupport, :uint8,
+          :bU1DevExitLat, :uint8,
+          :bU2DevExitLat, :uint16
+
+      # Bitmap encoding of supported device level features.
+      # A value of one in a bit location indicates a feature is
+      # supported; a value of zero indicates it is not supported.
+      #
+      # @return [Integer]
+      # @see Call::SsUsbDeviceCapabilityAttributes
+      def bmAttributes
+        self[:bmAttributes]
+      end
+
+      # @return [Boolean] Supports Latency Tolerance Messages (LTM)
+      def bm_ltm_support?
+        (bmAttributes & BM_LTM_SUPPORT) != 0
+      end
+
+      def inspect
+        attrs = Call::SsUsbDeviceCapabilityAttributes.to_h.map do |k,v|
+          (bmAttributes & v) != 0 ? k.to_s : nil
+        end
+        "\#<#{self.class} #{attrs.compact.join(",")} #{supported_speeds.join(",")}>"
+      end
+
+      # Bitmap encoding of the speed supported by this device when
+      # operating in SuperSpeed mode.
+      #
+      # @return [Integer]
+      # @see Call::SupportedSpeeds
+      def wSpeedSupported
+        self[:wSpeedSupported]
+      end
+
+      # @return [Array<Symbol>]  speeds supported by this device when
+      #     operating in SuperSpeed mode {Call::SupportedSpeeds}
+      def supported_speeds
+        speeds = Call::SupportedSpeeds.to_h.map do |k,v|
+          (wSpeedSupported & v) != 0 ? k : nil
+        end
+        speeds.compact
+      end
+
+      # The lowest speed at which all the functionality supported
+      # by the device is available to the user. For example if the
+      # device supports all its functionality when connected at
+      # full speed and above then it sets this value to 1.
+      #
+      # 0 - low speed
+      # 1 - full speed
+      # 2 - high speed
+      # 3 - super speed
+      # @return [Integer]
+      def bFunctionalitySupport
+        self[:bFunctionalitySupport]
+      end
+
+      # @return [Integer]  U1 Device Exit Latency.
+      def bU1DevExitLat
+        self[:bU1DevExitLat]
+      end
+
+      # @return [Integer]  U2 Device Exit Latency.
+      def bU2DevExitLat
+        self[:bU2DevExitLat]
+      end
+
+      # @private
+      def self.release(ptr)
+        Call.libusb_free_ss_usb_device_capability_descriptor(ptr)
+      end
+    end
+
+    # A structure representing the Container ID descriptor.
+    # This descriptor is documented in section 9.6.2.3 of the USB 3.0 specification.
+    # All multiple-byte fields, except UUIDs, are represented in host-endian format.
+    class ContainerId < FFI::ManagedStruct
+      include GenericMethods
+
+      layout :bLength, :uint8,
+          :bDescriptorType, :uint8,
+          :bDevCapabilityType, :uint8,
+          :bReserved, :uint8,
+          :ContainerID, [:uint8, 16]
+
+      # Reserved field
+      def bReserved
+        self[:bReserved]
+      end
+
+      # @return [String] 128 bit UUID
+      def container_id
+        self[:ContainerID].to_ptr.read_bytes(16)
+      end
+
+      def inspect
+        "\#<#{self.class} #{container_id.unpack("H*")[0]}>"
+      end
+
+      # @private
+      def self.release(ptr)
+        Call.libusb_free_container_id_descriptor(ptr)
+      end
+    end
+
+    def initialize( ctx, *args)
+      @ctx = ctx
+      super(*args)
+    end
+
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :wTotalLength, :uint16,
+        :bNumDeviceCaps, :uint8,
+        :dev_capability, [:pointer, 0]
+
+    # @return [Integer]  Size of this descriptor (in bytes)
+    def bLength
+      self[:bLength]
+    end
+
+    # @return [Integer]  Descriptor type. Will have value LIBUSB::DT_BOS LIBUSB_DT_BOS
+    # in this context.
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # @return [Integer]  Length of this descriptor and all of its sub descriptors
+    def wTotalLength
+      self[:wTotalLength]
+    end
+
+    # @return [Integer]  The number of separate device capability descriptors in
+    # the BOS
+    def bNumDeviceCaps
+      self[:bNumDeviceCaps]
+    end
+
+    # bNumDeviceCap Device Capability Descriptors
+    #
+    # @return [Array<Bos::DeviceCapability, Bos::Usb20Extension, Bos::SsUsbDeviceCapability, Bos::ContainerId>]
+    def device_capabilities
+      pp_ext = FFI::MemoryPointer.new :pointer
+      caps = []
+      # Capabilities are appended to the bos header
+      ptr = pointer + offset_of(:dev_capability)
+      bNumDeviceCaps.times do
+        cap = DeviceCapability.new self, ptr.read_pointer
+        case cap.bDevCapabilityType
+          when LIBUSB::BT_WIRELESS_USB_DEVICE_CAPABILITY
+            # no struct defined in libusb -> use generic DeviceCapability
+          when LIBUSB::BT_USB_2_0_EXTENSION
+            res = Call.libusb_get_usb_2_0_extension_descriptor(@ctx, cap.pointer, pp_ext)
+            cap = Usb20Extension.new(pp_ext.read_pointer) if res==0
+          when LIBUSB::BT_SS_USB_DEVICE_CAPABILITY
+            res = Call.libusb_get_ss_usb_device_capability_descriptor(@ctx, cap.pointer, pp_ext)
+            cap = SsUsbDeviceCapability.new(pp_ext.read_pointer) if res==0
+          when LIBUSB::BT_CONTAINER_ID
+            res = Call.libusb_get_container_id_descriptor(@ctx, cap.pointer, pp_ext)
+            cap = ContainerId.new(pp_ext.read_pointer) if res==0
+          else
+            # unknown capability -> use generic DeviceCapability
+        end
+        ptr += FFI.type_size(:pointer)
+        caps << cap
+      end
+      caps
+    end
+
+    # @return [Array<Symbol>]  Types of Capabilities
+    #
+    # @see Call::BosTypes
+    def device_capability_types
+      # Capabilities are appended to the bos header
+      ptr = pointer + offset_of(:dev_capability)
+      bNumDeviceCaps.times.map do
+        cap = DeviceCapability.new self, ptr.read_pointer
+        ptr += FFI.type_size(:pointer)
+        Call::BosTypes.find cap.bDevCapabilityType
+      end
+    end
+
+    def inspect
+      "\#<#{self.class} #{device_capability_types.join(", ")}>"
+    end
+
+    # @private
+    def self.release(ptr)
+      Call.libusb_free_bos_descriptor(ptr)
+    end
+  end
+end

data/lib/libusb/call.rb

@@ -81,11 +81,18 @@ module LIBUSB
       :TRANSFER_ADD_ZERO_PACKET, 1 << 3,
     ]
 
+    # Values for {Endpoint#transfer_type}.
     TransferTypes = enum :libusb_transfer_type, [
+      # Control endpoint
       :TRANSFER_TYPE_CONTROL, 0,
+      # Isochronous endpoint
       :TRANSFER_TYPE_ISOCHRONOUS, 1,
+      # Bulk endpoint
       :TRANSFER_TYPE_BULK, 2,
+      # Interrupt endpoint
       :TRANSFER_TYPE_INTERRUPT, 3,
+      # Stream endpoint
+      :TRANSFER_TYPE_BULK_STREAM, 4,
     ]
 
     StandardRequests = enum :libusb_standard_request, [
@@ -108,15 +115,32 @@ module LIBUSB
     ]
 
     DescriptorTypes = enum :libusb_descriptor_type, [
+      # Device descriptor. See {Device}
       :DT_DEVICE, 0x01,
+      # Configuration descriptor. See {Configuration}
       :DT_CONFIG, 0x02,
+      # String descriptor
       :DT_STRING, 0x03,
+      # Interface descriptor. See {Interface}
       :DT_INTERFACE, 0x04,
+      # Endpoint descriptor. See {Endpoint}
       :DT_ENDPOINT, 0x05,
+      # BOS descriptor
+      :DT_BOS, 0x0f,
+      # Device Capability descriptor
+      :DT_DEVICE_CAPABILITY, 0x10,
+      # HID descriptor
       :DT_HID, 0x21,
+      # HID report descriptor
       :DT_REPORT, 0x22,
+      # Physical descriptor
       :DT_PHYSICAL, 0x23,
+      # Hub descriptor
       :DT_HUB, 0x29,
+      # SuperSpeed Hub descriptor
+      :DT_SUPERSPEED_HUB, 0x2a,
+      # SuperSpeed Endpoint Companion descriptor
+      :DT_SS_ENDPOINT_COMPANION, 0x30,
     ]
 
     RequestTypes = enum :libusb_request_type, [
@@ -148,6 +172,19 @@ module LIBUSB
       :SPEED_SUPER, 4,
     ]
 
+    # Supported speeds (wSpeedSupported) bitfield. Indicates what
+    # speeds the device supports.
+    SupportedSpeeds = enum :libusb_supported_speed, [
+      # Low speed operation supported (1.5MBit/s).
+      :LOW_SPEED_OPERATION, 1,
+      # Full speed operation supported (12MBit/s).
+      :FULL_SPEED_OPERATION, 2,
+      # High speed operation supported (480MBit/s).
+      :HIGH_SPEED_OPERATION, 4,
+      # Superspeed operation supported (5000MBit/s).
+      :SUPER_SPEED_OPERATION, 8,
+    ]
+
     Capabilities = enum :libusb_capability, [
       :CAP_HAS_CAPABILITY, 0x0000,
       # Hotplug support is available on this platform.
@@ -162,6 +199,36 @@ module LIBUSB
       :CAP_SUPPORTS_DETACH_KERNEL_DRIVER, 0x0101,
     ]
 
+    # Masks for the bits of the
+    # {Bos::Usb20Extension#bmAttributes} field
+    # of the USB 2.0 Extension descriptor.
+    Usb20ExtensionAttributes = enum :libusb_usb_2_0_extension_attributes, [
+      # Supports Link Power Management (LPM)
+      :BM_LPM_SUPPORT, 2,
+    ]
+
+    # Masks for the bits of the
+    # {Bos::SsUsbDeviceCapability#bmAttributes} field
+    # field of the SuperSpeed USB Device Capability descriptor.
+    SsUsbDeviceCapabilityAttributes = enum :libusb_ss_usb_device_capability_attributes, [
+      # Supports Latency Tolerance Messages (LTM)
+      :BM_LTM_SUPPORT, 2,
+    ]
+
+    # USB capability types
+    #
+    # @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,
+    ]
+
     # Since libusb version 1.0.16.
     #
     # Hotplug events
@@ -186,6 +253,7 @@ module LIBUSB
     typedef :pointer, :libusb_context
     typedef :pointer, :libusb_device
     typedef :pointer, :libusb_device_handle
+    typedef :pointer, :libusb_transfer
     typedef :int, :libusb_hotplug_callback_handle
 
     def self.try_attach_function(method, *args)
@@ -221,6 +289,18 @@ module LIBUSB
     attach_function 'libusb_get_max_packet_size', [:pointer, :uint8], :int
     attach_function 'libusb_get_max_iso_packet_size', [:pointer, :uint8], :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
+
+    try_attach_function 'libusb_get_bos_descriptor', [:libusb_device_handle, :pointer], :int, :blocking=>true
+    try_attach_function 'libusb_free_bos_descriptor', [:pointer], :void
+    try_attach_function 'libusb_get_usb_2_0_extension_descriptor', [:libusb_context, :pointer, :pointer], :int
+    try_attach_function 'libusb_free_usb_2_0_extension_descriptor', [:pointer], :void
+    try_attach_function 'libusb_get_ss_usb_device_capability_descriptor', [:libusb_context, :pointer, :pointer], :int
+    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
+
     attach_function 'libusb_open', [:pointer, :pointer], :int
     attach_function 'libusb_close', [:pointer], :void
     attach_function 'libusb_get_device', [:libusb_device_handle], :pointer
@@ -234,6 +314,8 @@ module LIBUSB
     attach_function 'libusb_set_interface_alt_setting', [:libusb_device_handle, :int, :int], :int, :blocking=>true
     attach_function 'libusb_clear_halt', [:libusb_device_handle, :int], :int, :blocking=>true
     attach_function 'libusb_reset_device', [:libusb_device_handle], :int, :blocking=>true
+    try_attach_function 'libusb_alloc_streams', [:libusb_device_handle, :uint32, :pointer, :int], :int
+    try_attach_function 'libusb_free_streams', [:libusb_device_handle, :pointer, :int], :int
 
     attach_function 'libusb_kernel_driver_active', [:libusb_device_handle, :int], :int
     attach_function 'libusb_detach_kernel_driver', [:libusb_device_handle, :int], :int
@@ -246,6 +328,8 @@ module LIBUSB
     attach_function 'libusb_submit_transfer', [:pointer], :int
     attach_function 'libusb_cancel_transfer', [:pointer], :int
     attach_function 'libusb_free_transfer', [:pointer], :void
+    try_attach_function 'libusb_transfer_set_stream_id', [:libusb_transfer, :uint32], :void
+    try_attach_function 'libusb_transfer_get_stream_id', [:libusb_transfer], :uint32
 
     attach_function 'libusb_handle_events', [:libusb_context], :int, :blocking=>true
     try_attach_function 'libusb_handle_events_completed', [:libusb_context, :pointer], :int, :blocking=>true

data/lib/libusb/constants.rb

@@ -26,6 +26,10 @@ module LIBUSB
   Call::IsoSyncTypes.to_h.each{|k,v| const_set(k,v) }
   Call::Speeds.to_h.each{|k,v| const_set(k,v) }
   Call::Capabilities.to_h.each{|k,v| const_set(k,v) }
+  Call::SupportedSpeeds.to_h.each{|k,v| const_set(k,v) }
+  Call::Usb20ExtensionAttributes.to_h.each{|k,v| const_set(k,v) }
+  Call::SsUsbDeviceCapabilityAttributes.to_h.each{|k,v| const_set(k,v) }
+  Call::BosTypes.to_h.each{|k,v| const_set(k,v) }
   Call::HotplugEvents.to_h.each{|k,v| const_set(k,v) }
   Call::HotplugFlags.to_h.each{|k,v| const_set(k,v) }
 

data/lib/libusb/dev_handle.rb

@@ -189,6 +189,54 @@ module LIBUSB
       LIBUSB.raise_error res, "in libusb_reset_device" if res!=0
     end
 
+    if Call.respond_to?(:libusb_alloc_streams)
+
+      # @method alloc_streams
+      #
+      # Allocate up to num_streams usb bulk streams on the specified endpoints. This
+      # function takes an array of endpoints rather then a single endpoint because
+      # some protocols require that endpoints are setup with similar stream ids.
+      # All endpoints passed in must belong to the same interface.
+      #
+      # Note this function may return less streams then requested. Also note that the
+      # same number of streams are allocated for each endpoint in the endpoint array.
+      #
+      # Stream id 0 is reserved, and should not be used to communicate with devices.
+      # If {alloc_streams} returns with a value of N, you may use stream ids
+      # 1 to N.
+      #
+      # Available since libusb-1.0.19.
+      #
+      # @param [Fixnum] num_streams  number of streams to try to allocate
+      # @param [Array<Fixnum>, Array<Endpoint>] endpoints  array of endpoints to allocate streams on
+      # @return [Fixnum] number of streams allocated
+      # @see #free_streams
+      # @see BulkStreamTransfer
+      def alloc_streams(num_streams, endpoints)
+        pEndpoints = endpoints_as_ffi_bytes(endpoints)
+        res = Call.libusb_alloc_streams(@pHandle, num_streams, pEndpoints, endpoints.length)
+        LIBUSB.raise_error res, "in libusb_alloc_streams" unless res>=0
+        res
+      end
+
+      # @method free_streams
+      #
+      # Free usb bulk streams allocated with {alloc_streams}
+      #
+      # Note streams are automatically free-ed when releasing an interface.
+      #
+      # Available since libusb-1.0.19.
+      #
+      # @param [Array<Fixnum>, Array<Endpoint>] endpoints  array of endpoints to free streams on
+      # @see #alloc_streams
+      def free_streams(endpoints)
+        pEndpoints = endpoints_as_ffi_bytes(endpoints)
+        res = Call.libusb_free_streams(@pHandle, pEndpoints, endpoints.length)
+        LIBUSB.raise_error res, "in libusb_free_streams" unless res>=0
+        nil
+      end
+    end
+
     # Determine if a kernel driver is active on an interface.
     #
     # If a kernel driver is active, you cannot claim the interface,
@@ -253,6 +301,26 @@ module LIBUSB
       end
     end
 
+    # @private
+    if Call.respond_to?(:libusb_get_bos_descriptor)
+
+      # @method bos
+      # Get a Binary Object Store (BOS) descriptor.
+      #
+      # This is a BLOCKING function, which will send requests to the device.
+      #
+      # Since libusb version 1.0.16.
+      #
+      # @return [Bos]
+      def bos
+        ctx = device.context.instance_variable_get(:@ctx)
+        pp_desc = FFI::MemoryPointer.new :pointer
+        res = Call.libusb_get_bos_descriptor(@pHandle, pp_desc)
+        LIBUSB.raise_error res, "in libusb_get_bos_descriptor" if res!=0
+        Bos.new(ctx, pp_desc.read_pointer)
+      end
+    end
+
     # Perform a USB bulk transfer.
     #
     # When called without a block, the transfer is done synchronously - so all events are handled
@@ -473,5 +541,14 @@ module LIBUSB
         res
       end
     end
+
+    def endpoints_as_ffi_bytes(endpoints)
+      pEndpoints = FFI::MemoryPointer.new :char, endpoints.length
+      endpoints.each_with_index do |ep, epi|
+        ep = ep.bEndpointAddress if ep.respond_to? :bEndpointAddress
+        pEndpoints.put_uchar(epi, ep)
+      end
+      pEndpoints
+    end
   end
 end

data/lib/libusb/endpoint.rb

@@ -170,5 +170,25 @@ module LIBUSB
       t = bEndpointAddress<=>o.bEndpointAddress if t==0
       t
     end
+
+    if Call.respond_to?(:libusb_get_ss_endpoint_companion_descriptor)
+
+      # @method ss_companion
+      # Get the endpoints superspeed endpoint companion descriptor (if any).
+      #
+      # Since libusb version 1.0.16.
+      #
+      # @return [SsCompanion]
+      def ss_companion
+        ep_comp = FFI::MemoryPointer.new :pointer
+        res = Call.libusb_get_ss_endpoint_companion_descriptor(
+          device.context.instance_variable_get(:@ctx),
+          pointer,
+          ep_comp
+        )
+        LIBUSB.raise_error res, "in libusb_get_ss_endpoint_companion_descriptor" if res!=0
+        SsCompanion.new ep_comp.read_pointer
+      end
+    end
   end
 end

data/lib/libusb/ss_companion.rb

@@ -0,0 +1,69 @@
+# 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/>.
+
+require 'libusb/call'
+
+module LIBUSB
+  # A structure representing the superspeed endpoint companion descriptor.
+  #
+  # This descriptor is documented in section 9.6.7 of the USB 3.0 specification. All multiple-byte fields are represented in host-endian format.
+  class SsCompanion < FFI::ManagedStruct
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :bMaxBurst, :uint8,
+        :bmAttributes, :uint8,
+        :wBytesPerInterval, :uint16
+
+    # Size of this descriptor (in bytes)
+    def bLength
+      self[:bLength]
+    end
+
+    # Descriptor type.
+    #
+    # Will have value LIBUSB::DT_SS_ENDPOINT_COMPANION in this context.
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # The maximum number of packets the endpoint can send or recieve as part of a burst.
+    def bMaxBurst
+      self[:bMaxBurst]
+    end
+
+    # In bulk EP: bits 4:0 represents the maximum number of streams the EP supports.
+    #
+    # In isochronous EP: bits 1:0 represents the Mult - a zero based value that determines the maximum number of packets within a service interval
+    def bmAttributes
+      self[:bmAttributes]
+    end
+
+    # The total number of bytes this EP will transfer every service interval.
+    #
+    # valid only for periodic EPs.
+    def wBytesPerInterval
+      self[:wBytesPerInterval]
+    end
+
+    def inspect
+      "\#<#{self.class} burst: #{bMaxBurst} attrs: #{bmAttributes}>"
+    end
+
+    # @private
+    def self.release(ptr)
+      Call.libusb_free_ss_endpoint_companion_descriptor(ptr)
+    end
+  end
+end

data/lib/libusb/transfer.rb

@@ -203,6 +203,40 @@ module LIBUSB
     end
   end
 
+  if Call.respond_to?(:libusb_transfer_get_stream_id)
+
+    # Transfer class for USB bulk transfers using USB-3.0 streams.
+    #
+    # @see DevHandle#alloc_streams
+    #
+    # Available since libusb-1.0.19.
+    class BulkStreamTransfer < Transfer
+      def initialize(args={})
+        @transfer = Call::Transfer.new Call.libusb_alloc_transfer(0)
+        @transfer[:type] = TRANSFER_TYPE_BULK_STREAM
+        @transfer[:timeout] = 1000
+        super
+      end
+
+      # Set a transfers bulk stream id.
+      #
+      # @param [Fixnum] stream_id  the stream id to set
+      def stream_id=(v)
+        Call.libusb_transfer_set_stream_id(@transfer, v)
+        v
+      end
+
+      # Get a transfers bulk stream id.
+      #
+      # Since version 1.0.19.
+      #
+      # @return [Fixnum] the stream id for the transfer
+      def stream_id
+        Call.libusb_transfer_get_stream_id(@transfer)
+      end
+    end
+  end
+
   class ControlTransfer < Transfer
     def initialize(args={})
       @transfer = Call::Transfer.new Call.libusb_alloc_transfer(0)

data/lib/libusb/version_gem.rb

@@ -15,5 +15,5 @@
 
 module LIBUSB
   # Library version of libusb for Ruby
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/libusb.gemspec

@@ -10,6 +10,7 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/larskanis/libusb"
   s.summary     = %q{Access USB devices from Ruby via libusb-1.0}
   s.description = %q{LIBUSB is a Ruby binding that gives Ruby programmers access to arbitrary USB devices}
+  s.licenses    = ['LGPL-3']
   s.rdoc_options = %w[--main README.md --charset=UTF-8]
 
   s.rubyforge_project = "libusb"

data/test/test_libusb_bos.rb

@@ -0,0 +1,118 @@
+# 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/>.
+
+require "minitest/autorun"
+require "libusb"
+
+class TestLibusbBos < Minitest::Test
+  include LIBUSB
+
+  attr_accessor :usb
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 0
+  end
+
+  def test_bos
+    did_bos = false
+    did_cap = false
+    usb.devices.each do |dev|
+      # devices with USB version >= 0x201 could support bos
+      # devices with USB version >= 0x210 must support bos
+      if dev.bcdUSB >= 0x210
+        dev.open do |devh|
+          bos = devh.bos
+          did_bos = true
+
+          assert_equal 5, bos.bLength
+          assert_equal 0x0f, bos.bDescriptorType
+          assert_operator 5, :<=, bos.wTotalLength
+          assert_operator 0, :<=, bos.bNumDeviceCaps
+
+          caps = bos.device_capabilities
+          assert_equal bos.bNumDeviceCaps, caps.length
+          cap_types = bos.device_capability_types
+          assert_equal bos.bNumDeviceCaps, cap_types.length
+
+          cap_types.each do |cap_type|
+            assert_operator [
+                :BT_WIRELESS_USB_DEVICE_CAPABILITY,
+                :BT_USB_2_0_EXTENSION,
+                :BT_SS_USB_DEVICE_CAPABILITY,
+                :BT_CONTAINER_ID,
+              ], :include?, cap_type
+          end
+
+
+          caps.each do |cap|
+            did_cap = true
+
+            assert_operator 4, :<=, cap.bLength
+            assert_equal LIBUSB::DT_DEVICE_CAPABILITY, cap.bDescriptorType
+            assert_kind_of String, cap.dev_capability_data, "should provide binary capability data"
+            assert_kind_of String, cap.inspect, "should respond to inspect"
+            assert_operator 1, :<=, cap.dev_capability_data.length, "dev_capability_data should be at least one byte"
+
+            case cap
+              when Bos::DeviceCapability
+                assert_kind_of Integer, cap.bDevCapabilityType
+
+              when Bos::Usb20Extension
+                assert_equal 2, cap.bDevCapabilityType
+                assert_operator 0, :<=, cap.bmAttributes
+                assert_operator [true, false], :include?, cap.bm_lpm_support?
+
+              when Bos::SsUsbDeviceCapability
+                assert_equal 3, cap.bDevCapabilityType
+                assert_operator 0, :<=, cap.bmAttributes
+                assert_operator [true, false], :include?, cap.bm_ltm_support?
+                assert_operator 0, :<=, cap.wSpeedSupported
+                assert_kind_of Array, cap.supported_speeds
+                assert_operator 0, :<=, cap.bFunctionalitySupport
+                assert_operator 0, :<=, cap.bU1DevExitLat
+                assert_operator 0, :<=, cap.bU2DevExitLat
+
+              when Bos::ContainerId
+                assert_equal 4, cap.bDevCapabilityType
+                assert_operator 0, :<=, cap.bReserved
+                assert_operator 16, :==, cap.container_id.bytesize, "container_id should be 16 bytes long"
+
+              else
+                refute true, "invalid device capability class"
+            end
+          end
+        end
+      end
+    end
+    skip "no device with BOS available" unless did_bos
+    skip "no device with BOS capability available" unless did_cap
+  end
+
+  def test_no_bos
+    did_failing_bos = false
+
+    # devices with USB version < 0x201 shouldn't support bos
+    if dev=usb.devices.find{|dev| dev.bcdUSB < 0x201 }
+      dev.open do |devh|
+        assert_raises LIBUSB::ERROR_PIPE do
+          devh.bos
+        end
+        did_failing_bos = true
+      end
+    end
+    skip "no device without BOS available" unless did_failing_bos
+  end
+end

data/test/test_libusb_bulk_stream_transfer.rb

@@ -0,0 +1,50 @@
+# 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/>.
+
+require "minitest/autorun"
+require "libusb"
+
+class TestLibusbBulkStreamTransfer < Minitest::Test
+  include LIBUSB
+
+  def setup
+    c = Context.new
+    begin
+      @dev = c.devices.first.open
+    rescue LIBUSB::ERROR_ACCESS
+      @dev = nil
+      skip "error opening device"
+    end
+  end
+
+  def teardown
+    @dev.close if @dev
+  end
+
+  def test_alloc_streams
+    assert_raises(ERROR_NOT_SUPPORTED, "TODO: test with a OS that supports bulk streams and against a real device") do
+      nr_allocated = @dev.alloc_streams( 2, @dev.device.endpoints )
+    end
+
+    assert_raises(ERROR_NOT_SUPPORTED) do
+      @dev.free_streams( [0x01,0x82] )
+    end
+  end
+
+  def test_bulk_stream_transfer
+    tr = BulkStreamTransfer.new :dev_handle=>@dev, :stream_id=>123, :buffer=>' '*100
+    assert_equal 123, tr.stream_id, "stream_id should match"
+  end
+end

data/test/test_libusb_descriptors.rb

@@ -113,6 +113,35 @@ class TestLibusbDescriptors < Minitest::Test
     end
   end
 
+  def test_ss_companion
+    did_cc_companion = false
+    did_failing_cc_companion = false
+
+    usb.devices.each do |dev|
+      dev.endpoints.each do |ep|
+        if dev.device_speed == :SPEED_SUPER
+          ss = ep.ss_companion
+          assert_match(/SsCompanion/, ss.inspect, "SsCompanion#inspect should work")
+
+          assert_kind_of Integer, ss.bLength
+          assert_equal LIBUSB::DT_SS_ENDPOINT_COMPANION, ss.bDescriptorType
+          assert_kind_of Integer, ss.bMaxBurst
+          assert_kind_of Integer, ss.bmAttributes
+          assert_kind_of Integer, ss.wBytesPerInterval
+          did_cc_companion = true
+        elsif !did_failing_cc_companion
+          assert_raises ERROR_NOT_FOUND do
+            ep.ss_companion
+          end
+          did_failing_cc_companion = true
+        end
+      end
+    end
+
+    skip "no device with cc_companion available" unless did_cc_companion
+    skip "no device without cc_companion available" unless did_failing_cc_companion
+  end
+
   def test_constants
     assert_equal 7, CLASS_PRINTER, "Printer class id should be defined"
     assert_equal 48, ISO_USAGE_TYPE_MASK, "iso usage type should be defined"

data/test/test_libusb_hotplug.rb

@@ -106,7 +106,7 @@ class TestLibusbHotplug < Minitest::Test
     ctx.handle_events 5000
     ctx.handle_events 5000
 
-    skip if devs.empty? && devs2.empty?
+    skip "no hotplug action taken" if devs.empty? && devs2.empty?
     assert_equal 1, devs.length, "Should be deregistered after the first event"
     assert_equal 2, devs2.length, "Should have received two events"
     assert_operator devs2.map(&:last), :include?, :HOTPLUG_EVENT_DEVICE_ARRIVED, "Should have received ARRIVED"

data/test/test_libusb_threads.rb

@@ -70,7 +70,7 @@ class TestLibusbThreads < Minitest::Test
     endpoint = endpoints_in[dev]
     1.times do
       st = Time.now
-      assert_raise LIBUSB::ERROR_TIMEOUT do
+      assert_raises LIBUSB::ERROR_TIMEOUT do
         dev.bulk_transfer(:endpoint=>endpoint, :dataIn=>123, :timeout=>100)
       end
       assert_operator Time.now-st, :<, 5

metadata

@@ -1,62 +1,76 @@
 --- !ruby/object:Gem::Specification
 name: libusb
 version: !ruby/object:Gem::Version
-  version: 0.4.1
-  prerelease: 
+  version: 0.5.0
 platform: x64-mingw32
 authors:
 - Lars Kanis
 autorequire: 
 bindir: bin
-cert_chain: []
-date: 2014-05-17 00:00:00.000000000 Z
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDLjCCAhagAwIBAgIBAjANBgkqhkiG9w0BAQUFADA9MQ4wDAYDVQQDDAVrYW5p
+  czEXMBUGCgmSJomT8ixkARkWB2NvbWNhcmQxEjAQBgoJkiaJk/IsZAEZFgJkZTAe
+  Fw0xNDAyMjYwOTMzMDBaFw0xNTAyMjYwOTMzMDBaMD0xDjAMBgNVBAMMBWthbmlz
+  MRcwFQYKCZImiZPyLGQBGRYHY29tY2FyZDESMBAGCgmSJomT8ixkARkWAmRlMIIB
+  IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApop+rNmg35bzRugZ21VMGqI6
+  HGzPLO4VHYncWn/xmgPU/ZMcZdfj6MzIaZJ/czXyt4eHpBk1r8QOV3gBXnRXEjVW
+  9xi+EdVOkTV2/AVFKThcbTAQGiF/bT1n2M+B1GTybRzMg6hyhOJeGPqIhLfJEpxn
+  lJi4+ENAVT4MpqHEAGB8yFoPC0GqiOHQsdHxQV3P3c2OZqG+yJey74QtwA2tLcLn
+  Q53c63+VLGsOjODl1yPn/2ejyq8qWu6ahfTxiIlSar2UbwtaQGBDFdb2CXgEufXT
+  L7oaPxlmj+Q2oLOfOnInd2Oxop59HoJCQPsg8f921J43NCQGA8VHK6paxIRDLQID
+  AQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUvgTdT7fe
+  x17ugO3IOsjEJwW7KP4wDQYJKoZIhvcNAQEFBQADggEBAFmIAhRT0awqLQN9e4Uv
+  ZEk+jUWv4zkb+TWiKFJXlwjPyjGbZY9gVfOwAwMibYOK/t/+57ZzW3d0L12OUwvo
+  on84NVvYtIr1/iskJFWFkMoIquAFCdi9p68stSPMQK2XcrJJuRot29fJtropsZBa
+  2cpaNd/sRYdK4oep2usdKifA1lI0hIkPb3r5nLfwG2lAqBH7WZsUICHcTgR0VEbG
+  z9Ug5qQp9Uz73xC9YdGvGiuOX53LYobHAR4MWi2xxDlHI+ER8mRz0eY2FUuNu/Wj
+  GrqF74zpLl7/KFdHC8VmzwZS18hvDjxeLVuVI2gIGnBInqnlqv05g/l4/1pISh5j
+  dS4=
+  -----END CERTIFICATE-----
+date: 2015-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.6'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: LIBUSB is a Ruby binding that gives Ruby programmers access to arbitrary
@@ -67,15 +81,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
-- .yardopts
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
 - COPYING
 - Gemfile
 - History.md
 - README.md
 - Rakefile
+- lib/libusb-1.0.dll
 - lib/libusb.rb
+- lib/libusb/bos.rb
 - lib/libusb/call.rb
 - lib/libusb/compat.rb
 - lib/libusb/configuration.rb
@@ -87,10 +103,13 @@ files:
 - lib/libusb/eventmachine.rb
 - lib/libusb/interface.rb
 - lib/libusb/setting.rb
+- lib/libusb/ss_companion.rb
 - lib/libusb/transfer.rb
 - lib/libusb/version_gem.rb
 - lib/libusb/version_struct.rb
 - libusb.gemspec
+- test/test_libusb_bos.rb
+- test/test_libusb_bulk_stream_transfer.rb
 - test/test_libusb_capability.rb
 - test/test_libusb_compat.rb
 - test/test_libusb_compat_mass_storage.rb
@@ -104,32 +123,31 @@ files:
 - test/test_libusb_structs.rb
 - test/test_libusb_threads.rb
 - test/test_libusb_version.rb
-- lib/libusb-1.0.dll
 homepage: http://github.com/larskanis/libusb
-licenses: []
+licenses:
+- LGPL-3
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.md
-- --charset=UTF-8
+- "--charset=UTF-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: libusb
-rubygems_version: 1.8.24
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Access USB devices from Ruby via libusb-1.0
 test_files: []

metadata.gz.sig

@@ -0,0 +1,3 @@
+s`���4�a}*&|�
+Q_��١e���P����N4��⏉��S7x�9�^˷�r��q,�\�V�#�Xh��!o�{�0��<��V�۠����ދ^ӐV�x�i���x;cMy\���8c;�Xܫ(�*��8������P���qU
dr{w[B�(�8B��Sm�
+���0R���1� �̜��x���'E�ji��H�����5���P��t�a4{, �c*��ߎ�|�)�]��