libusb 0.6.0-x86-linux

data/Rakefile

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+# -*- ruby -*-
+
+require 'bundler/gem_tasks'
+require 'rubygems/package_task'
+require 'pathname'
+require 'uri'
+require 'ostruct'
+require 'rake/clean'
+require 'rake_compiler_dock'
+require_relative 'ext/libusb_recipe'
+
+task :gem => :build
+task :compile do
+  sh "ruby ext/extconf.rb --disable-system-libusb"
+end
+
+task :test=>:compile do
+  sh "ruby -w -W2 -I. -Ilib -e \"#{Dir["test/test_*.rb"].map{|f| "require '#{f}';"}.join}\" -- -v"
+end
+
+travis_tests = %w[test_libusb_capability.rb test_libusb_structs.rb test_libusb_version.rb]
+task :travis=>:compile do
+  sh "ruby -w -W2 -I. -Ilib -e \"#{travis_tests.map{|f| "require 'test/#{f}';"}.join}\" -- -v"
+end
+task :default => :test
+
+task "release:tag" do
+  hfile = "History.md"
+  version = LIBUSB::VERSION
+  reldate = Time.now.strftime("%Y-%m-%d")
+  headline = '([^\w]*)(\d+\.\d+\.\d+)([^\w]+)([2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])([^\w]*|$)'
+
+  hin = File.read(hfile)
+  hout = hin.sub(/#{headline}/) do
+    raise "#{hfile} isn't up-to-date for version #{version}" unless $2==version
+    $1 + $2 + $3 + reldate + $5
+  end
+  if hout != hin
+    Bundler.ui.confirm "Updating #{hfile} for release."
+    File.write(hfile, hout)
+    sh "git", "commit", hfile, "-m", "Update release date in #{hfile}"
+  end
+
+  Bundler.ui.confirm "Tag release with annotation:"
+  m = hout.match(/(?<annotation>#{headline}.*?)#{headline}/m) || raise("Unable to find release notes in #{hfile}")
+  Bundler.ui.info(m[:annotation].gsub(/^/, "    "))
+  IO.popen(["git", "tag", "--file=-", version], "w") do |fd|
+    fd.write m[:annotation]
+  end
+end
+
+task "release:guard_clean" => "release:tag"
+
+task "release:rubygem_push" => "gem:native" do
+  CrossLibraries.each do |ruby_platform, _|
+    gh = Bundler::GemHelper.new
+    gh.rubygem_push(gh.spec_path.gsub(".gem", "-#{ruby_platform}.gem"))
+  end
+end
+
+task 'gem:native' do
+  sh "bundle package"
+  RakeCompilerDock.sh <<-EOT
+    bundle --local &&
+    rake cross gem
+  EOT
+end
+
+class CrossLibrary < OpenStruct
+  include Rake::DSL
+
+  def initialize(ruby_platform, host_platform, libusb_dllname)
+    super()
+
+    self.ruby_platform = ruby_platform
+    self.recipe = LibusbRecipe.new
+    recipe.host = host_platform
+    recipe.configure_options << "--host=#{recipe.host}"
+    self.libusb_dll = Pathname.new(recipe.path) + libusb_dllname
+
+    file libusb_dll do
+      recipe.cook
+    end
+
+    task "libusb_dll:#{ruby_platform}" => libusb_dll
+
+    desc 'Cross compile libusb for win32'
+    task :cross => [ "libusb_dll:#{ruby_platform}" ] do |t|
+      spec = Gem::Specification::load("libusb.gemspec").dup
+      spec.platform = Gem::Platform.new(ruby_platform)
+      spec.extensions = []
+
+      # Remove files unnecessary for native gems
+      spec.files -= `git ls-files ext`.split("\n")
+      spec.files.reject!{|f| f.start_with?('ports') }
+      spec_text_files = spec.files.dup
+
+      # Add native libusb-dll
+      spec.files << "lib/#{libusb_dll.basename}"
+
+      # MiniPortile isn't required for native gems
+      spec.dependencies.reject!{|d| d.name=="mini_portile2" }
+
+      # Generate a package for this gem
+      pkg = Gem::PackageTask.new(spec) do |pkg|
+        pkg.need_zip = false
+        pkg.need_tar = false
+        # Do not copy any files per PackageTask, because
+        # we need the files from the platform specific directory
+        pkg.package_files.clear
+      end
+
+      # copy files of the gem to pkg directory
+      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
+
+        # copy libusb.dll to pkg directory
+        f = "#{pkg.package_dir_path}/lib/#{libusb_dll.basename}"
+        mkdir_p File.dirname(f)
+        rm_f f
+        safe_ln libusb_dll.realpath, f
+      end
+
+      file "lib/#{libusb_dll.basename}" => [libusb_dll]
+    end
+  end
+end
+
+CrossLibraries = [
+  ['i386-mingw32', 'i686-w64-mingw32', 'bin/libusb-1.0.dll'],
+  ['x64-mingw32', 'x86_64-w64-mingw32', 'bin/libusb-1.0.dll'],
+  ['x86-linux', 'i686-linux-gnu', 'lib/libusb-1.0.so'],
+  ['x86_64-linux', 'x86_64-linux-gnu', 'lib/libusb-1.0.so'],
+].each do |ruby_platform, host_platform, libusb_dll|
+  CrossLibrary.new ruby_platform, host_platform, libusb_dll
+end
+
+# vim: syntax=ruby

data/appveyor.yml

@@ -0,0 +1,23 @@
+init:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - SET PATH=C:\MinGW\msys\1.0\bin;%PATH%
+  - SET RAKEOPT=-rdevkit
+install:
+  - ruby --version
+  - gem --version
+  - bundle install
+build_script:
+  - bundle exec rake compile
+test_script:
+  - bundle exec rake travis
+environment:
+  matrix:
+    - ruby_version: "193"
+    - ruby_version: "200"
+    - ruby_version: "200-x64"
+    - ruby_version: "21"
+    - ruby_version: "21-x64"
+    - ruby_version: "22"
+    - ruby_version: "22-x64"
+    - ruby_version: "23"
+    - ruby_version: "23-x64"

data/lib/libusb.rb

@@ -0,0 +1,58 @@
+# 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
+  require 'libusb/call'
+  require 'libusb/constants'
+  require 'libusb/context'
+  autoload :VERSION, 'libusb/version_gem'
+  autoload :Version, 'libusb/version_struct'
+  autoload :Configuration, 'libusb/configuration'
+  autoload :DevHandle, 'libusb/dev_handle'
+  autoload :Device, 'libusb/device'
+  autoload :Endpoint, 'libusb/endpoint'
+  autoload :Interface, 'libusb/interface'
+  autoload :Setting, 'libusb/setting'
+  autoload :SsCompanion, 'libusb/ss_companion'
+  autoload :Stdio, 'libusb/stdio'
+  autoload :Bos, 'libusb/bos'
+  %w[ Transfer BulkTransfer BulkStreamTransfer ControlTransfer InterruptTransfer IsoPacket IsochronousTransfer ].each do |klass|
+    autoload klass, 'libusb/transfer'
+  end
+
+  if Call.respond_to?(:libusb_get_version)
+    # Get version of the underlying libusb library.
+    # Available since libusb-1.0.10.
+    # @return [Version]  version object
+    def self.version
+      Version.new(Call.libusb_get_version)
+    end
+  end
+
+  if Call.respond_to?(:libusb_has_capability)
+    # Check at runtime if the loaded library has a given capability.
+    # Available since libusb-1.0.9.
+    # @param [Symbol] capability  the {Call::Capabilities Capabilities} symbol to check for
+    # @return [Boolean]  +true+ if the running library has the capability, +false+ otherwise
+    def self.has_capability?(capability)
+      r = Call.libusb_has_capability(capability)
+      return r != 0
+    end
+  else
+    def self.has_capability?(capability)
+      false
+    end
+  end
+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