libusb 0.1.0

data/lib/libusb/compat.rb

@@ -0,0 +1,370 @@
+# 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/>.
+#
+#   This file is for compatibility with ruby-usb and libusb-0.1.
+#
+#   Please visit the project website at http://github.com/larskanis/libusb
+#   for support.
+
+require 'libusb'
+require 'forwardable'
+
+# Compatibility layer for ruby-usb[http://www.a-k-r.org/ruby-usb/] (API based on libusb-0.1)
+#
+# This module provides some limited compatibility to ruby-usb.
+#
+# Usage example:
+#   begin
+#     require 'usb'
+#   rescue LoadError
+#     require 'libusb/compat'
+#   end
+#   p USB.devices => [#<USB::Device ...>]
+#
+# Known issues:
+# * Exceptions are different between ruby-usb and libusb and they don't get converted
+# * libusb-1.0 doesn't explicitly manage USB-buses, so only one Bus is used currently
+module USB
+  DefaultContext = LIBUSB::Context.new
+
+  USB_CLASS_PER_INTERFACE = LIBUSB::CLASS_PER_INTERFACE
+  USB_CLASS_AUDIO = LIBUSB::CLASS_AUDIO
+  USB_CLASS_COMM = LIBUSB::CLASS_COMM
+  USB_CLASS_HID = LIBUSB::CLASS_HID
+  USB_CLASS_PRINTER = LIBUSB::CLASS_PRINTER
+  USB_CLASS_PTP = LIBUSB::CLASS_PTP
+  USB_CLASS_MASS_STORAGE = LIBUSB::CLASS_MASS_STORAGE
+  USB_CLASS_HUB = LIBUSB::CLASS_HUB
+  USB_CLASS_DATA = LIBUSB::CLASS_DATA
+  USB_CLASS_VENDOR_SPEC = LIBUSB::CLASS_VENDOR_SPEC
+
+  USB_DT_DEVICE = LIBUSB::DT_DEVICE
+  USB_DT_CONFIG = LIBUSB::DT_CONFIG
+  USB_DT_STRING = LIBUSB::DT_STRING
+  USB_DT_INTERFACE = LIBUSB::DT_INTERFACE
+  USB_DT_ENDPOINT = LIBUSB::DT_ENDPOINT
+  USB_DT_HID = LIBUSB::DT_HID
+  USB_DT_REPORT = LIBUSB::DT_REPORT
+  USB_DT_PHYSICAL = LIBUSB::DT_PHYSICAL
+  USB_DT_HUB = LIBUSB::DT_HUB
+  USB_DT_DEVICE_SIZE = LIBUSB::DT_DEVICE_SIZE
+  USB_DT_CONFIG_SIZE = LIBUSB::DT_CONFIG_SIZE
+  USB_DT_INTERFACE_SIZE = LIBUSB::DT_INTERFACE_SIZE
+  USB_DT_ENDPOINT_SIZE = LIBUSB::DT_ENDPOINT_SIZE
+  USB_DT_ENDPOINT_AUDIO_SIZE = LIBUSB::DT_ENDPOINT_AUDIO_SIZE
+  USB_DT_HUB_NONVAR_SIZE = LIBUSB::DT_HUB_NONVAR_SIZE
+
+  USB_ENDPOINT_ADDRESS_MASK = LIBUSB::ENDPOINT_ADDRESS_MASK
+  USB_ENDPOINT_DIR_MASK = LIBUSB::ENDPOINT_DIR_MASK
+  USB_ENDPOINT_IN = LIBUSB::ENDPOINT_IN
+  USB_ENDPOINT_OUT = LIBUSB::ENDPOINT_OUT
+
+  USB_ENDPOINT_TYPE_MASK = LIBUSB::TRANSFER_TYPE_MASK
+  USB_ENDPOINT_TYPE_CONTROL = LIBUSB::TRANSFER_TYPE_CONTROL
+  USB_ENDPOINT_TYPE_ISOCHRONOUS = LIBUSB::TRANSFER_TYPE_ISOCHRONOUS
+  USB_ENDPOINT_TYPE_BULK = LIBUSB::TRANSFER_TYPE_BULK
+  USB_ENDPOINT_TYPE_INTERRUPT = LIBUSB::TRANSFER_TYPE_INTERRUPT
+
+  USB_REQ_GET_STATUS = LIBUSB::REQUEST_GET_STATUS
+  USB_REQ_CLEAR_FEATURE = LIBUSB::REQUEST_CLEAR_FEATURE
+  USB_REQ_SET_FEATURE = LIBUSB::REQUEST_SET_FEATURE
+  USB_REQ_SET_ADDRESS = LIBUSB::REQUEST_SET_ADDRESS
+  USB_REQ_GET_DESCRIPTOR = LIBUSB::REQUEST_GET_DESCRIPTOR
+  USB_REQ_SET_DESCRIPTOR = LIBUSB::REQUEST_SET_DESCRIPTOR
+  USB_REQ_GET_CONFIGURATION = LIBUSB::REQUEST_GET_CONFIGURATION
+  USB_REQ_SET_CONFIGURATION = LIBUSB::REQUEST_SET_CONFIGURATION
+  USB_REQ_GET_INTERFACE = LIBUSB::REQUEST_GET_INTERFACE
+  USB_REQ_SET_INTERFACE = LIBUSB::REQUEST_SET_INTERFACE
+  USB_REQ_SYNCH_FRAME = LIBUSB::REQUEST_SYNCH_FRAME
+  USB_TYPE_STANDARD = LIBUSB::REQUEST_TYPE_STANDARD
+  USB_TYPE_CLASS = LIBUSB::REQUEST_TYPE_CLASS
+  USB_TYPE_VENDOR = LIBUSB::REQUEST_TYPE_VENDOR
+  USB_TYPE_RESERVED = LIBUSB::REQUEST_TYPE_RESERVED
+  USB_RECIP_DEVICE = LIBUSB::RECIPIENT_DEVICE
+  USB_RECIP_INTERFACE = LIBUSB::RECIPIENT_INTERFACE
+  USB_RECIP_ENDPOINT = LIBUSB::RECIPIENT_ENDPOINT
+  USB_RECIP_OTHER = LIBUSB::RECIPIENT_OTHER
+
+  HAS_GET_DRIVER_NP = RUBY_PLATFORM=~/mswin|mingw/ ? false : true
+  HAS_DETACH_KERNEL_DRIVER_NP = RUBY_PLATFORM=~/mswin|mingw/ ? false : true
+
+  # not defined by libusb-1.0, but typical values are:
+  USB_MAXENDPOINTS = 32
+  USB_MAXINTERFACES = 32
+  USB_MAXALTSETTING = 128
+  USB_MAXCONFIG = 8
+
+
+  def USB.busses
+    [DefaultBus]
+  end
+
+  def USB.devices; DefaultContext.devices.map{|c| Device.new(c) }; end
+  def USB.configurations() USB.devices.map {|d| d.configurations }.flatten end
+  def USB.interfaces() USB.configurations.map {|d| d.interfaces }.flatten end
+  def USB.settings() USB.interfaces.map {|d| d.settings }.flatten end
+  def USB.endpoints() USB.settings.map {|d| d.endpoints }.flatten end
+
+  def USB.find_bus(n)
+    DefaultBus
+  end
+
+  def USB.each_device_by_class(devclass, subclass=nil, protocol=nil)
+    devs = DefaultContext.devices :bClass=>devclass, :bSubClass=>subclass, :bProtocol=>protocol
+    devs.each do |dev|
+      yield Device.new(dev)
+    end
+    nil
+  end
+
+  class Bus
+    def initialize(context)
+      @ct = context
+    end
+    def devices
+      @ct.devices.map{|d| Device.new(d) }
+    end
+
+    def configurations() self.devices.map{|d| d.configurations }.flatten end
+    def interfaces() self.configurations.map {|d| d.interfaces }.flatten end
+    def settings() self.interfaces.map {|d| d.settings }.flatten end
+    def endpoints() self.settings.map {|d| d.endpoints }.flatten end
+
+    def find_device(n)
+      raise NotImplementedError
+    end
+  end
+
+  DefaultBus = Bus.new(DefaultContext)
+
+  def USB.dev_string(base_class, sub_class, protocol)
+    LIBUSB.dev_string(base_class, sub_class, protocol)
+  end
+
+  class Device
+    extend Forwardable
+    include Comparable
+
+    def initialize(dev)
+      @dev = dev
+    end
+
+    def_delegators :@dev, :bLength, :bDescriptorType, :bcdUSB, :bDeviceClass,
+        :bDeviceSubClass, :bDeviceProtocol, :bMaxPacketSize0, :idVendor, :idProduct,
+        :bcdDevice, :iManufacturer, :iProduct, :iSerialNumber, :bNumConfigurations,
+        :manufacturer, :product, :serial_number,
+        :inspect
+
+    def <=>(o)
+      @dev<=>o.instance_variable_get(:@dev)
+    end
+
+    def open
+      h = DevHandle.new(@dev.open)
+      if block_given?
+        begin
+          r = yield h
+        ensure
+          h.usb_close
+        end
+      else
+        h
+      end
+    end
+
+    def bus; DefaultBus; end
+    def configurations; @dev.configurations.map{|c| Configuration.new(c) }; end
+    def interfaces; @dev.interfaces.map{|c| Interface.new(c) }; end
+    def settings; @dev.settings.map{|c| Setting.new(c) }; end
+    def endpoints; @dev.endpoints.map{|c| Endpoint.new(c) }; end
+  end
+
+  class Configuration
+    extend Forwardable
+    include Comparable
+
+    def initialize(cd)
+      @cd = cd
+    end
+
+    def_delegators :@cd, :bLength, :bDescriptorType, :wTotalLength, :bNumInterfaces,
+        :bConfigurationValue, :iConfiguration, :bmAttributes, :maxPower,
+        :inspect
+
+    def <=>(o)
+      @cd<=>o.instance_variable_get(:@cd)
+    end
+
+    def bus; DefaultBus; end
+    def device() Device.new(@cd.device) end
+    def interfaces; @cd.interfaces.map{|c| Interface.new(c) }; end
+    def settings() self.interfaces.map {|d| d.settings }.flatten end
+    def endpoints() self.settings.map {|d| d.endpoints }.flatten end
+  end
+
+  class Interface
+    extend Forwardable
+    include Comparable
+
+    def initialize(i)
+      @i = i
+    end
+
+    def_delegators :@i, :inspect
+
+    def <=>(o)
+      @i<=>o.instance_variable_get(:@i)
+    end
+
+    def bus() self.configuration.device.bus end
+    def device() self.configuration.device end
+    def configuration; Configuration.new(@i.configuration); end
+    def settings; @i.alt_settings.map{|c| Setting.new(c) }; end
+    def endpoints() self.settings.map {|d| d.endpoints }.flatten end
+  end
+
+  class Setting
+    extend Forwardable
+    include Comparable
+
+    def initialize(id)
+      @id = id
+    end
+
+    def_delegators :@id, :bLength, :bDescriptorType, :bInterfaceNumber, :bAlternateSetting,
+        :bNumEndpoints, :bInterfaceClass, :bInterfaceSubClass, :bInterfaceProtocol,
+        :iInterface, :inspect
+
+    def <=>(o)
+      @id<=>o.instance_variable_get(:@id)
+    end
+
+    def bus() self.interface.configuration.device.bus end
+    def device() self.interface.configuration.device end
+    def configuration() self.interface.configuration end
+    def interface; Interface.new(@id.interface); end
+    def endpoints() @id.endpoints.map {|d| Endpoint.new(d) }.flatten end
+  end
+
+  class Endpoint
+    extend Forwardable
+    include Comparable
+
+    def initialize(ep)
+      @ep = ep
+    end
+
+    def_delegators :@ep, :bLength, :bDescriptorType, :bEndpointAddress, :bmAttributes,
+        :wMaxPacketSize, :bInterval, :bRefresh, :bSynchAddress,
+        :inspect
+
+    def <=>(o)
+      @ep<=>o.instance_variable_get(:@ep)
+    end
+
+    def bus() self.setting.interface.configuration.device.bus end
+    def device() self.setting.interface.configuration.device end
+    def configuration() self.setting.interface.configuration end
+    def interface() self.setting.interface end
+    def setting; Setting.new(@ep.setting); end
+  end
+
+  class DevHandle
+    def initialize(dev)
+      @dev = dev
+    end
+
+    def usb_close; @dev.close; end
+    def usb_set_configuration(c); @dev.configuration=c; end
+    def usb_set_altinterface(c); @dev.set_interface_alt_setting=c; end
+    def usb_clear_halt(c); @dev.clear_halt(c); end
+    def usb_reset; @dev.reset_device; end
+    def usb_claim_interface(c); @dev.claim_interface(c); end
+    def usb_release_interface(c); @dev.release_interface(c); end
+    def usb_get_string(index, langid, buffer)
+      t = @dev.string_descriptor(index, langid)
+      buffer[0, t.length] = t
+      t.length
+    end
+    def usb_get_string_simple(index, buffer)
+      t = @dev.string_descriptor_ascii(index)
+      buffer[0, t.length] = t
+      t.length
+    end
+
+    def usb_control_msg(requesttype, request, value, index, bytes, timeout)
+      if requesttype&LIBUSB::ENDPOINT_IN != 0
+        # transfer direction in
+        res = @dev.control_transfer(:bmRequestType=>requesttype, :bRequest=>request,
+            :wValue=>value, :wIndex=>index, :dataIn=>bytes.bytesize, :timeout=>timeout)
+        bytes[0, res.bytesize] = res
+        res.bytesize
+      else
+        # transfer direction out
+        @dev.control_transfer(:bmRequestType=>requesttype, :bRequest=>request, :wValue=>value,
+            :wIndex=>index, :dataOut=>bytes, :timeout=>timeout)
+      end
+    end
+
+    def usb_bulk_write(endpoint, bytes, timeout)
+      @dev.bulk_transfer(:endpoint=>endpoint, :dataOut=>bytes, :timeout=>timeout)
+    end
+    def usb_bulk_read(endpoint, bytes, timeout)
+      res = @dev.bulk_transfer(:endpoint=>endpoint, :dataIn=>bytes.bytesize, :timeout=>timeout)
+      bytes[0, res.bytesize] = res
+      res.bytesize
+    end
+
+    def usb_interrupt_write(endpoint, bytes, timeout)
+      @dev.interrupt_transfer(:endpoint=>endpoint, :dataOut=>bytes, :timeout=>timeout)
+    end
+    def usb_interrupt_read(endpoint, bytes, timeout)
+      res = @dev.interrupt_transfer(:endpoint=>endpoint, :dataIn=>bytes.bytesize, :timeout=>timeout)
+      bytes[0, res.bytesize] = res
+      res.bytesize
+    end
+
+#   rb_define_method(rb_cUSB_DevHandle, "usb_get_descriptor", rusb_get_descriptor, 3);
+#   rb_define_method(rb_cUSB_DevHandle, "usb_get_descriptor_by_endpoint", rusb_get_descriptor_by_endpoint, 4);
+
+    if HAS_DETACH_KERNEL_DRIVER_NP
+      def usb_detach_kernel_driver_np(interface, dummy=nil)
+        @dev.detach_kernel_driver(interface)
+      end
+    end
+
+    if HAS_GET_DRIVER_NP
+      def usb_get_driver_np(interface, buffer)
+        if @dev.kernel_driver_active?(interface)
+          t = "unknown driver"
+          buffer[0, t.length] = t
+        else
+          raise Errno::ENODATA, "No data available"
+        end
+        nil
+      end
+    end
+
+    alias set_configuration usb_set_configuration
+    alias set_altinterface usb_set_altinterface
+    alias clear_halt usb_clear_halt
+    alias claim_interface usb_claim_interface
+    alias release_interface usb_release_interface
+
+    def get_string_simple(index)
+      @dev.string_descriptor_ascii(index)
+    end
+  end
+end

data/test/test_libusb_compat.rb

@@ -0,0 +1,78 @@
+# 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 "test/unit"
+require "libusb/compat"
+
+class TestLibusbCompat < Test::Unit::TestCase
+  include USB
+
+  attr_accessor :usb
+
+  def test_find
+    devlist = USB.devices
+    assert_kind_of Array, devlist, "Bus#find should return an Array"
+    assert_kind_of Device, devlist.first, "Bus#find should return Devices"
+    devlist.each do |dev|
+      assert_match( /Device/, dev.inspect, "Device#inspect should work")
+    end
+  end
+
+  def test_constants
+    assert_equal 7, USB_CLASS_PRINTER, "Printer class id should be defined"
+    assert_equal 32, USB_TYPE_CLASS, "type class should be defined"
+  end
+
+  def test_descriptors
+    USB.devices.each do |dev|
+      assert_match(/Device/, dev.inspect, "Device#inspect should work")
+      dev.configurations.each do |config_desc|
+        assert_match(/Configuration/, config_desc.inspect, "Configuration#inspect should work")
+        assert dev.configurations.include?(config_desc), "Device#configurations should include this one"
+
+        config_desc.interfaces.each do |interface|
+          assert_match(/Interface/, interface.inspect, "Interface#inspect should work")
+
+          assert dev.interfaces.include?(interface), "Device#interfaces should include this one"
+          assert config_desc.interfaces.include?(interface), "Configuration#interfaces should include this one"
+
+          interface.settings.each do |if_desc|
+            assert_match(/Setting/, if_desc.inspect, "Setting#inspect should work")
+
+            assert dev.settings.include?(if_desc), "Device#settings should include this one"
+            assert config_desc.settings.include?(if_desc), "Configuration#settings should include this one"
+            assert interface.settings.include?(if_desc), "Interface#settings should include this one"
+
+            if_desc.endpoints.each do |ep|
+              assert_match(/Endpoint/, ep.inspect, "Endpoint#inspect should work")
+
+              assert dev.endpoints.include?(ep), "Device#endpoints should include this one"
+              assert config_desc.endpoints.include?(ep), "Configuration#endpoints should include this one"
+              assert interface.endpoints.include?(ep), "Interface#endpoints should include this one"
+              assert if_desc.endpoints.include?(ep), "Setting#endpoints should include this one"
+
+              assert_equal if_desc, ep.setting, "backref should be correct"
+              assert_equal interface, ep.interface, "backref should be correct"
+              assert_equal config_desc, ep.configuration, "backref should be correct"
+              assert_equal dev, ep.device, "backref should be correct"
+
+              assert_operator 0, :<, ep.wMaxPacketSize, "packet size should be > 0"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_libusb_compat_mass_storage.rb

@@ -0,0 +1,81 @@
+# 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 "test/unit"
+require "libusb/compat"
+
+class TestLibusbCompat < Test::Unit::TestCase
+  include USB
+
+  attr_accessor :devh
+
+  BOMS_RESET = 0xFF
+  BOMS_GET_MAX_LUN = 0xFE
+
+  def setup
+    devs = []
+    USB.each_device_by_class(USB_CLASS_MASS_STORAGE, 0x01, 0x50){|dev| devs << dev }
+    USB.each_device_by_class(USB_CLASS_MASS_STORAGE, 0x06, 0x50){|dev| devs << dev }
+
+    dev = devs.last
+    abort "no mass storage device found" unless dev
+    devh = dev.open
+    if RUBY_PLATFORM=~/linux/i
+      data = " "*1000
+      begin
+        devh.usb_get_driver_np 0, data
+      rescue Errno::ENODATA
+        data = "nodata exception".ljust(1000, "\0")
+      end
+      assert_match(/\w+/, data, "There should be a driver or an exception")
+      begin
+        # second param is needed because of a bug in ruby-usb
+        devh.usb_detach_kernel_driver_np 0, 123
+      rescue RuntimeError => e
+        assert_match(/ERROR_NOT_FOUND/, e.to_s, "Raise proper exception, if no kernel driver is active")
+      end
+    end
+
+    endpoint_in = dev.endpoints.find{|ep| ep.bEndpointAddress&USB_ENDPOINT_IN != 0 }
+    endpoint_out = dev.endpoints.find{|ep| ep.bEndpointAddress&USB_ENDPOINT_IN == 0 }
+
+    devh.set_configuration 1
+    devh.set_configuration dev.configurations.first
+    devh.claim_interface dev.settings.first
+    devh.clear_halt(endpoint_in)
+    devh.clear_halt(endpoint_out.bEndpointAddress)
+    @devh = devh
+  end
+
+  def teardown
+    if devh
+      devh.release_interface 0
+      devh.usb_close
+    end
+  end
+
+  def test_mass_storage_reset
+    res = devh.usb_control_msg(USB_ENDPOINT_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE,
+                BOMS_RESET, 0, 0, "", 2000)
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+  end
+
+  def test_read_max_lun
+    bytes = [].pack('x1')
+    devh.usb_control_msg(USB_ENDPOINT_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE,
+                BOMS_GET_MAX_LUN, 0, 0, bytes, 100)
+    assert [0].pack("C")==bytes || [1].pack("C")==bytes, "BOMS_GET_MAX_LUN response is usually 0 or 1"
+  end
+end