libusb 0.7.0-x64-mingw-ucrt

data/test/test_libusb_mass_storage.rb

@@ -0,0 +1,268 @@
+# 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 test requires a connected, but not mounted mass storage device with
+# read/write access allowed. Based on the following specifications:
+#   http://www.usb.org/developers/devclass_docs/usbmassbulk_10.pdf
+#   http://en.wikipedia.org/wiki/SCSI_command
+#
+
+require "minitest/autorun"
+require "libusb"
+
+class TestLibusbMassStorage < Minitest::Test
+  include LIBUSB
+
+  class CSWError < RuntimeError; end
+  BOMS_RESET = 0xFF
+  BOMS_GET_MAX_LUN = 0xFE
+
+  attr_accessor :usb
+  attr_accessor :device
+  attr_accessor :dev
+  attr_accessor :endpoint_in
+  attr_accessor :endpoint_out
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 3
+    @asynchron = false
+
+    @device = usb.devices( bClass: CLASS_MASS_STORAGE, bSubClass: [0x06,0x01], bProtocol: 0x50 ).last
+    skip "no mass storage device found" unless @device
+
+    @endpoint_in = @device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN != 0 }
+    @endpoint_out = @device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN == 0 }
+    @dev = @device.open
+
+    if RUBY_PLATFORM=~/linux/i && dev.kernel_driver_active?(0)
+      dev.detach_kernel_driver(0)
+    end
+    dev.claim_interface(0)
+
+    # clear any pending data
+    dev.clear_halt(endpoint_in)
+  end
+
+  def teardown
+    dev.release_interface(0) if dev
+    dev.close if dev
+  end
+
+  def do_transfer(method, **args)
+    if @asynchron
+      stop = false
+      transfer = dev.send(method, args) do |tr|
+        stop = true
+        assert_equal transfer, tr, "block argument should be the transfer instance"
+#         p transfer.status
+      end
+
+      transfer.submit
+      usb.handle_events
+      until stop
+        sleep 0.001
+        usb.handle_events
+      end
+      transfer.result
+    else
+      dev.send(method, **args)
+    end
+  end
+  def control_transfer(**args)
+    do_transfer(:control_transfer, **args)
+  end
+  def bulk_transfer(**args)
+    do_transfer(:bulk_transfer, **args)
+  end
+
+  def send_mass_storage_command(cdb, data_length, direction=ENDPOINT_IN)
+    @tag ||= 0
+    @tag += 1
+    expected_tag = @tag
+    lun = 0
+
+    cbw = ['USBC', expected_tag, data_length, direction, lun, cdb.length, cdb].pack('a*VVCCCa*')
+    cbw = cbw.ljust(31, "\0")
+
+    num_bytes = bulk_transfer(endpoint: endpoint_out, dataOut: cbw)
+    assert_equal 31, num_bytes, "31 bytes CBW should be sent"
+
+    recv = bulk_transfer(endpoint: endpoint_in, dataIn: data_length)
+
+    get_mass_storage_status(expected_tag)
+    return recv
+  end
+
+  def get_mass_storage_status(expected_tag)
+    retries = 5
+    buffer = begin
+      bulk_transfer(endpoint: endpoint_in, dataIn: 13)
+    rescue LIBUSB::ERROR_PIPE
+      if (retries-=1)>=0
+        dev.clear_halt(endpoint_in)
+        retry
+      end
+      raise
+    end
+    assert_equal 13, buffer.bytesize, "CSW should be 13 bytes long"
+
+    dCSWSignature, dCSWTag, dCSWDataResidue, bCSWStatus = buffer.unpack('a4VVC')
+
+    assert_equal 'USBS', dCSWSignature, "CSW should start with USBS"
+    assert_kind_of Integer, dCSWDataResidue
+    assert_equal expected_tag, dCSWTag, "CSW-tag should be like CBW-tag"
+    raise CSWError, "CSW returned error #{bCSWStatus}" unless bCSWStatus==0
+    buffer
+  end
+
+  def send_inquiry
+    expected_length = 0x24 # INQUIRY_LENGTH
+    cdb = [ 0x12, 0, 0, # Inquiry
+            expected_length, 0,
+            ].pack('CCCnC')
+
+    send_mass_storage_command( cdb, expected_length )
+  end
+
+  def get_capacity
+    expected_length = 0x08 # READ_CAPACITY_LENGTH
+    cdb = [ 0x25, # Read Capacity
+            ].pack('Cx9')
+
+    cap = send_mass_storage_command( cdb, expected_length )
+
+    max_lba, block_size = cap.unpack('NN')
+    device_size = (max_lba + 1) * block_size / (1024*1024*1024.0);
+    printf("   Max LBA: %08X, Block Size: %08X (%.2f GB)\n", max_lba, block_size, device_size);
+  end
+
+  def read_block(start, nr_blocks)
+    expected_length = 0x200 * nr_blocks
+    cdb = [ 0x28, 0, # Read(10)
+            start, 0,
+            nr_blocks, 0,
+            ].pack('CCNCnC')
+    send_mass_storage_command( cdb, expected_length )
+  end
+
+  def invalid_command
+    expected_length = 0x100
+    cdb = [ 0x26, 0, # invalid command
+            ].pack('CC')
+    send_mass_storage_command( cdb, expected_length )
+  end
+
+  def mass_storage_reset
+    res = control_transfer(
+      bmRequestType: ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_RESET,
+      wValue: 0, wIndex: 0)
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+
+    res = control_transfer(
+      bmRequestType: ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_RESET,
+      wValue: 0, wIndex: 0, dataOut: '')
+    assert_equal 0, res, "BOMS_RESET response should be 0 byte"
+  end
+
+  def read_max_lun
+    res = control_transfer(
+      bmRequestType: ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_GET_MAX_LUN,
+      wValue: 0, wIndex: 0, dataIn: 1)
+    assert [0].pack("C")==res || [1].pack("C")==res, "BOMS_GET_MAX_LUN response is usually 0 or 1"
+  end
+
+  def test_read_access
+    send_inquiry
+    get_capacity
+
+    data = read_block(0, 1)
+    assert_equal 512, data.length, "Read block should be 512 bytes"
+
+    # closing device handle shouldn't matter, in the meantime
+    dev.close
+    @dev = @device.open
+    dev.claim_interface(0)
+
+    data = read_block(0, 2)
+    assert_equal 1024, data.length, "Read block should be 1024 bytes"
+  end
+#   def test_read_access_async
+#     @asynchron = true
+#     test_read_access
+#   end
+
+  def test_read_failed
+    count = 0
+    th = Thread.new do
+      loop do
+        count+=1
+        sleep 0.01
+      end
+    end
+    assert_raises(LIBUSB::ERROR_TIMEOUT) do
+      begin
+        bulk_transfer(endpoint: endpoint_in, dataIn: 123)
+      rescue LIBUSB::ERROR_TIMEOUT => err
+        assert_kind_of String, err.transferred
+        raise
+      end
+    end
+
+    th.kill
+    dev.clear_halt(endpoint_in)
+    dev.clear_halt(endpoint_out)
+    assert_operator 20, :<=, count, "libusb_handle_events should not block a parallel Thread"
+  end
+#   def test_read_failed_async
+#     @asynchron = true
+#     test_read_failed
+#   end
+
+  def test_max_lun
+    read_max_lun
+  end
+#   def test_max_lun_async
+#     @asynchron = true
+#     read_max_lun
+#   end
+
+  def test_mass_storage_reset
+    mass_storage_reset
+  end
+#   def test_mass_storage_reset_async
+#     @asynchron = true
+#     mass_storage_reset
+#   end
+
+  def test_read_long
+    1000.times do |bl|
+      data = read_block(bl, 1)
+      assert_equal 512, data.length, "Read block should be 512 bytes"
+    end
+  end
+
+  def test_wrong_argument
+    assert_raises(ArgumentError){ dev.bulk_transfer(endpoint: endpoint_in, dataOut: "data") }
+    assert_raises(ArgumentError){ dev.interrupt_transfer(endpoint: endpoint_in, dataOut: "data") }
+    assert_raises(ArgumentError){ dev.control_transfer(
+      bmRequestType: ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+      bRequest: BOMS_RESET,
+      wValue: 0, wIndex: 0, dataIn: 123) }
+  end
+end

data/test/test_libusb_mass_storage2.rb

@@ -0,0 +1,96 @@
+# 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 TestLibusbMassStorage2 < Minitest::Test
+  include LIBUSB
+
+  attr_accessor :usb
+  attr_accessor :device
+  attr_accessor :interface
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 3
+    @device = usb.devices( bClass: CLASS_MASS_STORAGE, bSubClass: [0x06,0x01], bProtocol: 0x50 ).last
+    skip "no mass storage device found" unless @device
+
+    @interface = device.interfaces.first
+
+    # Ensure kernel driver is detached
+    device.open do |dev|
+      if RUBY_PLATFORM=~/linux/i && dev.kernel_driver_active?(interface)
+        dev.detach_kernel_driver(interface)
+      end
+    end
+  end
+
+  def teardown
+  end
+
+  def test_open_with_block
+    device.open do |dev|
+      assert_kind_of DevHandle, dev
+      assert_kind_of String, dev.string_descriptor_ascii(1)
+    end
+  end
+
+  def test_claim_interface_with_block
+    res = device.open do |dev|
+      dev.claim_interface(interface) do |dev2|
+        assert_kind_of DevHandle, dev2
+        assert_kind_of String, dev2.string_descriptor_ascii(1)
+        12345
+      end
+    end
+    assert_equal 12345, res, "Block versions should pass through the result"
+  end
+
+  def test_open_interface
+    res = device.open_interface(interface) do |dev|
+      assert_kind_of DevHandle, dev
+      assert_kind_of String, dev.string_descriptor_ascii(1)
+      12345
+    end
+    assert_equal 12345, res, "Block versions should pass through the result"
+  end
+
+  def test_attach_kernel_driver
+    # Should work with both Fixnum and Interface parameter
+    [0, interface].each do |i|
+      device.open do |dev|
+        dev.attach_kernel_driver(i)
+        assert dev.kernel_driver_active?(i), "kernel driver should be active again"
+        dev.detach_kernel_driver(i)
+        refute dev.kernel_driver_active?(i), "kernel driver should be detached"
+      end
+    end
+  end
+
+  def test_auto_detach_kernel_driver
+    assert LIBUSB.has_capability?(:CAP_SUPPORTS_DETACH_KERNEL_DRIVER), "libusb should have CAP_SUPPORTS_DETACH_KERNEL_DRIVER"
+
+    device.open do |dev|
+      dev.attach_kernel_driver 0
+      assert dev.kernel_driver_active?(0), "kernel driver should attached, now"
+      dev.auto_detach_kernel_driver = true
+      dev.claim_interface(0)
+      refute dev.kernel_driver_active?(0), "kernel driver should get detached automatically"
+    end
+  end
+end

data/test/test_libusb_structs.rb

@@ -0,0 +1,87 @@
+# 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 TestLibusbStructs < Minitest::Test
+  def test_struct_Timeval
+    s = LIBUSB::Call::Timeval.new
+    assert_equal 0, s.in_ms
+    s.in_ms = 12345678
+    assert_equal 12345, s[:tv_sec]
+    assert_equal 678000, s[:tv_usec]
+    assert_equal 12345678, s.in_ms
+
+    s.in_s = 1234.5678
+    assert_equal 1234, s[:tv_sec]
+    assert_equal 567800, s[:tv_usec]
+    assert_equal 1234.5678, s.in_s
+  end
+
+  def test_struct_CompletionFlag
+    s = LIBUSB::Context::CompletionFlag.new
+    assert_equal 0, s[:completed]
+    assert_equal false, s.completed?
+    s.completed = true
+    assert_equal 1, s[:completed]
+    assert_equal true, s.completed?
+    s.completed = false
+    assert_equal false, s.completed?
+    assert_equal 0, s[:completed]
+  end
+
+  def test_Transfer_buffer
+    t = LIBUSB::InterruptTransfer.new allow_device_memory: true
+    assert_equal :TRANSFER_COMPLETED, t.status
+    assert_equal true, t.allow_device_memory
+    assert_nil t.memory_type
+
+    t.alloc_buffer(10)
+    assert_equal :user_space, t.memory_type, "no device assigned -> should use memory from user space"
+
+    t.free_buffer
+    assert_nil t.memory_type
+  end
+
+  def test_Transfer_new
+    assert_raises(NoMethodError){ LIBUSB::Transfer.new }
+    LIBUSB::BulkStreamTransfer.new
+    LIBUSB::BulkTransfer.new
+    LIBUSB::ControlTransfer.new
+    LIBUSB::InterruptTransfer.new
+    LIBUSB::IsochronousTransfer.new(0)
+  end
+
+  def test_ControlTransfer_attributes
+    t = LIBUSB::ControlTransfer.new
+    t.timeout = 123
+    assert_equal 123, t.timeout
+    t.allow_device_memory = true
+    assert_equal true, t.allow_device_memory
+    assert_nil t.dev_handle
+  end
+
+  def test_ControlTransfer_new_args
+    t = LIBUSB::ControlTransfer.new allow_device_memory: false, timeout: 444
+    assert_equal false, t.allow_device_memory
+    assert_equal 444, t.timeout
+  end
+
+  def test_Transfer_no_dev_handle
+    t = LIBUSB::ControlTransfer.new
+    assert_raises(ArgumentError){ t.submit_and_wait }
+  end
+end

data/test/test_libusb_threads.rb

@@ -0,0 +1,89 @@
+# 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 test requires two connected, but not mounted mass storage device with
+# read/write access allowed.
+
+require "minitest/autorun"
+require "libusb"
+
+class TestLibusbThreads < Minitest::Test
+  include LIBUSB
+
+  BOMS_GET_MAX_LUN = 0xFE
+
+  attr_accessor :usb
+  attr_accessor :devices
+  attr_accessor :devs
+  attr_accessor :endpoints_in
+  attr_accessor :endpoints_out
+
+  def setup
+    @usb = Context.new
+    @usb.debug = 3
+
+    @devices = usb.devices( bClass: CLASS_MASS_STORAGE, bSubClass: [0x06,0x01], bProtocol: 0x50 )
+    skip "less than two mass storage devices found" unless @devices.length >= 2
+
+    @devs = @devices.map do |device|
+      dev = device.open
+      if RUBY_PLATFORM=~/linux/i && dev.kernel_driver_active?(0)
+        dev.detach_kernel_driver(0)
+      end
+      dev.claim_interface(0)
+      dev
+    end
+
+    @endpoints_in = {}
+    @endpoints_out = {}
+
+    @devs.each do |dev|
+      @endpoints_in[dev] = dev.device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN != 0 }
+      @endpoints_out[dev] = dev.device.endpoints.find{|ep| ep.bEndpointAddress&ENDPOINT_IN == 0 }
+    end
+
+    Thread.abort_on_exception = true
+  end
+
+  def teardown
+    if devs
+      devs.each do |dev|
+        dev.release_interface(0)
+        dev.close
+      end
+    end
+  end
+
+  def thread_worker(dev)
+    endpoint = endpoints_in[dev]
+    1.times do
+      st = Time.now
+      assert_raises LIBUSB::ERROR_TIMEOUT do
+        dev.bulk_transfer(endpoint: endpoint, dataIn: 123, timeout: 100)
+      end
+      assert_operator Time.now-st, :<, 5
+      dev.clear_halt(endpoint)
+    end
+  end
+
+  def test_sync_api
+    threads = devs.map do |dev|
+      Thread.new do
+        thread_worker(dev)
+      end
+    end
+    threads.map(&:join)
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: libusb
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: x64-mingw-ucrt
+authors:
+- Lars Kanis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: LIBUSB is a Ruby binding that gives Ruby programmers access to arbitrary
+  USB devices
+email:
+- lars@greiz-reinsdorf.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".appveyor.yml"
+- ".github/workflows/ci.yml"
+- ".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
+- lib/libusb/constants.rb
+- lib/libusb/context.rb
+- lib/libusb/context_reference.rb
+- lib/libusb/dependencies.rb
+- lib/libusb/dev_handle.rb
+- lib/libusb/device.rb
+- lib/libusb/endpoint.rb
+- lib/libusb/eventmachine.rb
+- lib/libusb/gem_helper.rb
+- lib/libusb/interface.rb
+- lib/libusb/libusb_recipe.rb
+- lib/libusb/setting.rb
+- lib/libusb/ss_companion.rb
+- lib/libusb/stdio.rb
+- lib/libusb/transfer.rb
+- lib/libusb/version_gem.rb
+- lib/libusb/version_struct.rb
+- libusb.gemspec
+- test/test_libusb.rb
+- test/test_libusb_bos.rb
+- test/test_libusb_bulk_stream_transfer.rb
+- test/test_libusb_compat.rb
+- test/test_libusb_compat_mass_storage.rb
+- test/test_libusb_context.rb
+- test/test_libusb_descriptors.rb
+- test/test_libusb_event_machine.rb
+- test/test_libusb_gc.rb
+- test/test_libusb_hotplug.rb
+- test/test_libusb_iso_transfer.rb
+- test/test_libusb_mass_storage.rb
+- test/test_libusb_mass_storage2.rb
+- test/test_libusb_structs.rb
+- test/test_libusb_threads.rb
+- wireshark-usb-sniffer.png
+homepage: http://github.com/larskanis/libusb
+licenses:
+- LGPL-3.0
+metadata:
+  yard.run: yri
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: Access USB devices from Ruby via libusb-1.0
+test_files: []