libusb 0.5.1-x64-mingw32 → 0.6.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a4bd5976cd03324ad2345ce42c220da84fe9a90
-  data.tar.gz: 9412dd0efbf424aed55987eff4e81baf202da6e9
+  metadata.gz: a20d98f43636caf12240a486b0e9c22bb190394b
+  data.tar.gz: c47aa11c776f146fb16fb5329586b2a96fcecc84
 SHA512:
-  metadata.gz: c7fb7068c318e2a034882fe7f54bad93c203960974c65c790f7e522cb7d7dcc842b60ad94e465f7c2453d5cc784d22b0b547eefa1b1f7c23d7a491133e04019f
-  data.tar.gz: dbd3595551464323fb62366fb61994177e992a846fb022ee3f02fbe060fc81fd7926845bd16baeb140f9dbc07ac99244b9dee2d07b4f7b11f6d47580fffb84a2
+  metadata.gz: 83426e897d09ae1a468d134a69a31385f9694dabba99fc36bcfb71c92563098c7276cf43a8b77e1b0dfad39695327df034858e21fa9671d2a2768b9070298381
+  data.tar.gz: 6401e3b895dae693a044ffb9b894e4fb1f19e5a1d5cccbbf190572c5731bb1cfbfa6e1010218910586f6177bc94d604a71789feac26c4d3954d7313af83dac01

data/.travis.yml

@@ -1,11 +1,17 @@
 language: ruby
 sudo: false
 rvm:
-  - "1.8.7"
   - "1.9.3"
   - "2.0.0"
   - "2.1"
   - "2.2"
-  - jruby
+  - "2.3.1"
+  - "2.3.1-clang"
+  - jruby-1.7.26
+  - jruby-9.1.5.0
   - rbx
+matrix:
+  allow_failures:
+    - rvm: rbx
+    - rvm: "2.3.1-clang"
 script: bundle exec rake travis

data/Gemfile

@@ -7,3 +7,5 @@ group :test do
   gem 'eventmachine'
   gem 'minitest'
 end
+
+gem 'rake-compiler-dock', git: 'http://github.com/rake-compiler/rake-compiler-dock'

data/History.md

@@ -1,3 +1,15 @@
+0.6.0 / 2016-12-09
+------------------
+* Update bundled libusb version to 1.0.21.
+* Set minimum Ruby version requirement to 1.9.3.
+* Add binary gems for Linux in addition to Windows.
+* Switch to mini_portile2 for (cross-) builing the libusb library.
+* Add Context#interrupt_event_handler new in libusb-1.0.21
+* Add support for persistent/zerocopy device memory for transfers.
+  It is new in libusb-1.0.21 and enabled by default for DevHandle#*_transfer methods.
+* Raise a more meaningful exception in case of bulk stream transfers on too old libusb versions.
+* Prefer the bundled libusb-dll over installed system library.
+
 0.5.1 / 2015-09-29
 ------------------
 * Add ability to force use of the system or builtin libusb-1.0 library.

data/README.md

@@ -1,6 +1,7 @@
 <!-- -*- coding: utf-8 -*- -->
 
 [![Build Status](https://travis-ci.org/larskanis/libusb.svg)](https://travis-ci.org/larskanis/libusb)
+[![Build Status](https://ci.appveyor.com/api/projects/status/mdfnfdwu4mil42o3?svg=true)](https://ci.appveyor.com/project/larskanis/libusb)
 
 Access USB devices from Ruby
 ============================
@@ -23,15 +24,13 @@ Features
 
 Synopsis
 --------
-See [the documentation](http://rubydoc.info/gems/libusb/frames) for a full API description.
-
 ```ruby
 require "libusb"
 
 usb = LIBUSB::Context.new
-device = usb.devices(:idVendor => 0x04b4, :idProduct => 0x8613).first
+device = usb.devices(idVendor: 0x04b4, idProduct: 0x8613).first
 device.open_interface(0) do |handle|
-  handle.control_transfer(:bmRequestType => 0x40, :bRequest => 0xa0, :wValue => 0xe600, :wIndex => 0x0000, :dataOut => 1.chr)
+  handle.control_transfer(bmRequestType: 0x40, bRequest: 0xa0, wValue: 0xe600, wIndex: 0x0000, dataOut: 1.chr)
 end
 ```
 {LIBUSB::Context#devices} is used to get all or only particular devices.
@@ -55,18 +54,20 @@ Each {LIBUSB::Setting} specifies it's own set of communication endpoints.
 Each {LIBUSB::Endpoint} specifies the type of transfer, direction, polling interval and
 maximum packet size.
 
+See [the documentation](http://rubydoc.info/gems/libusb/frames) for a full API description.
 
 Prerequisites
 -------------
 
-* Linux, MacOSX or Windows system with Ruby MRI 1.8.7/1.9/2.0, JRuby or recent version of Rubinius
-* Optionally: [libusb](http://libusb.info) or [libusbx](http://libusbx.org) library version 1.0.8+ :
+* Linux, MacOS or Windows system with Ruby MRI 1.9/2.x, JRuby or recent version of Rubinius
+* Optionally: [libusb](http://libusb.info) C-library version 1.0.8 or any newer version.
+  The system libusb library can be installed like so:
   * Debian or Ubuntu:
 
       ```
       $ sudo apt-get install libusb-1.0-0-dev
       ```
-  * OS-X: install with homebrew:
+  * MacOS: install with homebrew:
 
       ```
       $ brew install libusb
@@ -83,7 +84,7 @@ Install
 
     $ gem install libusb
 
-While ```gem install``` the system is checked for a usable libusb(x) library installation.
+While ```gem install``` the system is checked for a usable libusb library installation.
 If none could be found, a bundled libusb version is built and used, instead.
 
 Latest code can be used in this way:
@@ -92,11 +93,21 @@ Latest code can be used in this way:
     $ bundle
     $ rake install_gem
 
+Troubleshooting
+------------------------
+In order to implement a driver for a USB device, it's essential to have a look at the packets that are send to and received back from the USB device. [Wireshark](https://www.wireshark.org) has builtin capabilities to sniff USB traffic. On Linux you possibly need to load the usbmon kernel module before start:
+```
+    sudo modprobe usbmon
+```
+On Windows it's possible to sniff USB, if the USB kernel driver was installed by the Wireshark setup.
+
+![Wireshark](wireshark-usb-sniffer.png?raw=true "Wireshark sniffing USB packets")
+
 Device hotplug support
 ----------------------
 
 Support for device hotplugging can be used, if ```LIBUSB.has_capability?(:CAP_HAS_HOTPLUG)``` returns ```true```.
-This requires libusb(x)-1.0.16 or newer on Linux or OS-X. Windows support is [still on the way](https://github.com/libusbx/libusbx/issues/9).
+This requires libusb-1.0.16 or newer on Linux or MacOS. Windows support is [still on the way](https://github.com/libusbx/libusbx/issues/9).
 
 A hotplug event handler can be registered with {LIBUSB::Context#on_hotplug_event}.
 You then need to call {LIBUSB::Context#handle_events} in order to receive any events.
@@ -109,21 +120,21 @@ Usage on Windows
 
 In contrast to Linux, any access to an USB device by LIBUSB on Windows requires a proper driver
 installed in the system. Fortunately creating such a driver is quite easy with
-[Zadig](http://sourceforge.net/projects/libwdi/files/zadig/). Select the interesting USB device,
+[Zadig](http://zadig.akeo.ie/). Select the interesting USB device,
 choose WinUSB driver and press "Install Driver". That's it. You may take the generated output directory
-with it's INI-file and use it for driver installation on other 32 or 64 bit Windows
+with it's INI-file and use it for driver installations on other 32 or 64 bit Windows
 systems.
 
 
 Cross compiling for Windows
 ---------------------------
 
-Libusb-gem can be cross built for the win32 platform, using the [rake-compiler-dock](https://github.com/larskanis/rake-compiler-dock) .
+Libusb-gem can be cross built for Windows and Linux operating systems, using the [rake-compiler-dock](https://github.com/larskanis/rake-compiler-dock) .
 Just run:
 
-    $ rake gem:windows
+    $ rake gem:native
 
-If everything works, there should be `libusb-VERSION-x86-mingw32.gem` in the pkg
+If everything works, there are several platform specific gem files (like `libusb-VERSION-x64-mingw32.gem`) in the pkg
 directory.
 
 EventMachine integration

data/Rakefile

@@ -8,10 +8,11 @@ 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"
+  sh "ruby ext/extconf.rb --disable-system-libusb"
 end
 
 task :test=>:compile do
@@ -24,110 +25,62 @@ task :travis=>:compile do
 end
 task :default => :test
 
-task 'gem:windows' do
-  RakeCompilerDock.sh "bundle && rake cross gem"
-end
-
-COMPILE_HOME               = Pathname( "./tmp" ).expand_path
-STATIC_SOURCESDIR          = COMPILE_HOME + 'sources'
-
-# Fetch tarball from sourceforge
-LIBUSB_VERSION            = ENV['LIBUSB_VERSION'] || '1.0.20'
-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 )
-
-# Fetch tarball from git repo
-# LIBUSB_VERSION            = ENV['LIBUSB_VERSION'] || '295c9d1'
-# LIBUSB_SOURCE_URI         = URI( "http://git.libusb.org/?p=libusb.git;a=snapshot;h=#{LIBUSB_VERSION};sf=tbz2" )
-# LIBUSB_TARBALL            = STATIC_SOURCESDIR + "libusb-#{LIBUSB_VERSION}.tar.bz2"
+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]*|$)'
 
-# Fetch tarball from libusbx
-# LIBUSB_VERSION            = ENV['LIBUSB_VERSION'] || '1.0.17'
-# LIBUSB_SOURCE_URI         = URI( "http://downloads.sourceforge.net/project/libusbx/releases/#{LIBUSB_VERSION[/^\d+\.\d+\.\d+/]}/source/libusbx-#{LIBUSB_VERSION}.tar.bz2" )
-# LIBUSB_TARBALL            = STATIC_SOURCESDIR + File.basename( LIBUSB_SOURCE_URI.path )
-
-# Fetch tarball from Pete Batard's git repo
-# LIBUSB_VERSION            = ENV['LIBUSB_VERSION'] || '4cc72d0'
-# LIBUSB_SOURCE_URI         = URI( "http://git.libusb.org/?p=libusb-pbatard.git;a=snapshot;h=#{LIBUSB_VERSION};sf=tbz2" )
-# LIBUSB_TARBALL            = STATIC_SOURCESDIR + "libusb-pbatard-#{LIBUSB_VERSION}.tar.bz2"
+  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
 
-EXT_BUILDDIR              = Pathname( "./ext" ).expand_path
-EXT_LIBUSB_BUILDDIR       = EXT_BUILDDIR + LIBUSB_TARBALL.basename(".tar.bz2")
+  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
 
-directory STATIC_SOURCESDIR.to_s
+task "release:guard_clean" => "release:tag"
 
-# libusb source file should be stored there
-file LIBUSB_TARBALL => STATIC_SOURCESDIR do |t|
-  # download the source file using wget or curl
-  chdir File.dirname(t.name) do
-    url = LIBUSB_SOURCE_URI
-    sh "wget '#{url}' -O #{LIBUSB_TARBALL}"
+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)
+  def initialize(ruby_platform, host_platform, libusb_dllname)
     super()
 
-    self.ruby_platform              = ruby_platform
-    self.host_platform              = host_platform
-
-    self.static_builddir            = COMPILE_HOME + 'builds' + ruby_platform
-    self.ruby_build                 = RbConfig::CONFIG["host"]
-
-    # Static libusb build vars
-    self.static_libusb_builddir    = static_builddir + LIBUSB_TARBALL.basename(".tar.bz2")
-    self.libusb_configure          = static_libusb_builddir + 'configure'
-    self.libusb_makefile           = static_libusb_builddir + 'Makefile'
-    self.libusb_dll                = static_libusb_builddir + 'libusb/.libs/libusb-1.0.dll'
-
-    #
-    # Static libusb build tasks
-    #
-    CLEAN.include static_libusb_builddir.to_s
-
-    directory static_libusb_builddir.to_s
+    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
 
-    # Extract the libusb builds
-    file static_libusb_builddir => LIBUSB_TARBALL do |t|
-      sh 'tar', '-xjf', LIBUSB_TARBALL.to_s, '-C', static_libusb_builddir.parent.to_s
-      libusb_makefile.unlink if libusb_makefile.exist?
-    end
-
-    file libusb_configure => static_libusb_builddir do |t|
-      Dir.chdir( static_libusb_builddir ) do
-        sh "sh autogen.sh && make distclean"
-      end
-    end
-
-    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
-    file libusb_makefile => libusb_configure do |t|
-      Dir.chdir( static_libusb_builddir ) do
-        options = [
-          "--target=#{host_platform}",
-          "--host=#{host_platform}",
-          "--build=#{ruby_build}",
-        ]
-
-        configure_path = static_libusb_builddir + 'configure'
-        sh "env #{[libusb_env, configure_path.to_s, *options].join(" ")}"
-      end
-    end
-
-    # make libusb-1.0.dll
-    task libusb_dll => [ libusb_makefile ] do |t|
-      Dir.chdir( static_libusb_builddir ) do
-        sh 'make'
-      end
+    file libusb_dll do
+      recipe.cook
     end
 
     task "libusb_dll:#{ruby_platform}" => libusb_dll
@@ -137,9 +90,17 @@ class CrossLibrary < OpenStruct
       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
-      spec.files << "lib/#{File.basename(libusb_dll)}"
+
+      # 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|
@@ -161,32 +122,24 @@ class CrossLibrary < OpenStruct
         end
 
         # copy libusb.dll to pkg directory
-        f = "#{pkg.package_dir_path}/lib/#{File.basename(libusb_dll)}"
+        f = "#{pkg.package_dir_path}/lib/#{libusb_dll.basename}"
         mkdir_p File.dirname(f)
         rm_f f
-        safe_ln libusb_dll, f
+        safe_ln libusb_dll.realpath, f
       end
 
-      file "lib/#{File.basename(libusb_dll)}" => [libusb_dll]
+      file "lib/#{libusb_dll.basename}" => [libusb_dll]
     end
   end
 end
 
 CrossLibraries = [
-  ['i386-mingw32', 'i686-w64-mingw32'],
-  ['x64-mingw32', 'x86_64-w64-mingw32'],
-].map do |ruby_platform, host_platform|
-  CrossLibrary.new ruby_platform, host_platform
-end
-
-desc "Download and update bundled libusb"
-task :update_libusb => LIBUSB_TARBALL do
-  sh 'rm', '-r', (EXT_BUILDDIR + "libusb-*").to_s do end
-  sh 'git', 'rm', '-rfq', (EXT_BUILDDIR + "libusb-*").to_s do end
-  sh 'tar', '-xjf', LIBUSB_TARBALL.to_s, '-C', EXT_LIBUSB_BUILDDIR.parent.to_s
-  drops = %w[msvc].map{|f| (EXT_LIBUSB_BUILDDIR+f).to_s }
-  sh 'rm', '-r', '-f', *drops
-  sh 'git', 'add', EXT_LIBUSB_BUILDDIR.to_s
+  ['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/call.rb

@@ -28,7 +28,7 @@ module LIBUSB
     prefix = FFI::Platform::LIBPREFIX.empty? ? 'lib' : FFI::Platform::LIBPREFIX
     bundled_dll = File.join(root_path, "lib/#{prefix}usb-1.0.#{ext}")
     bundled_dll_cygwin = File.join(root_path, "bin/#{prefix}usb-1.0.#{ext}")
-    ffi_lib(["#{prefix}usb-1.0", bundled_dll, bundled_dll_cygwin])
+    ffi_lib([bundled_dll, bundled_dll_cygwin, "#{prefix}usb-1.0"])
 
     ClassCodes = enum :libusb_class_code, [
       :CLASS_PER_INTERFACE, 0,
@@ -292,7 +292,7 @@ module LIBUSB
     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_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
@@ -305,17 +305,19 @@ module LIBUSB
     attach_function 'libusb_close', [:pointer], :void
     attach_function 'libusb_get_device', [:libusb_device_handle], :pointer
 
-    attach_function 'libusb_set_configuration', [:libusb_device_handle, :int], :int, :blocking=>true
+    attach_function 'libusb_set_configuration', [:libusb_device_handle, :int], :int, blocking: true
     attach_function 'libusb_claim_interface', [:libusb_device_handle, :int], :int
-    attach_function 'libusb_release_interface', [:libusb_device_handle, :int], :int, :blocking=>true
+    attach_function 'libusb_release_interface', [:libusb_device_handle, :int], :int, blocking: true
 
     attach_function 'libusb_open_device_with_vid_pid', [:pointer, :int, :int], :pointer
 
-    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
+    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
+    try_attach_function 'libusb_dev_mem_alloc', [:libusb_device_handle, :size_t], :pointer
+    try_attach_function 'libusb_dev_mem_free', [:libusb_device_handle, :pointer, :size_t], :int
 
     attach_function 'libusb_kernel_driver_active', [:libusb_device_handle, :int], :int
     attach_function 'libusb_detach_kernel_driver', [:libusb_device_handle, :int], :int
@@ -331,10 +333,11 @@ module LIBUSB
     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
-    attach_function 'libusb_handle_events_timeout', [:libusb_context, :pointer], :int, :blocking=>true
-    try_attach_function 'libusb_handle_events_timeout_completed', [:libusb_context, :pointer, :pointer], :int, :blocking=>true
+    attach_function 'libusb_handle_events', [:libusb_context], :int, blocking: true
+    try_attach_function 'libusb_handle_events_completed', [:libusb_context, :pointer], :int, blocking: true
+    attach_function 'libusb_handle_events_timeout', [:libusb_context, :pointer], :int, blocking: true
+    try_attach_function 'libusb_handle_events_timeout_completed', [:libusb_context, :pointer, :pointer], :int, blocking: true
+    try_attach_function 'libusb_interrupt_event_handler', [:libusb_context], :void
 
     callback :libusb_pollfd_added_cb, [:int, :short, :pointer], :void
     callback :libusb_pollfd_removed_cb, [:int, :pointer], :void

data/lib/libusb/compat.rb

@@ -130,7 +130,7 @@ module USB
   end
 
   def USB.each_device_by_class(devclass, subclass=nil, protocol=nil)
-    devs = default_context.devices :bClass=>devclass, :bSubClass=>subclass, :bProtocol=>protocol
+    devs = default_context.devices bClass: devclass, bSubClass: subclass, bProtocol: protocol
     devs.each do |dev|
       yield Device.new(dev)
     end
@@ -313,31 +313,31 @@ module USB
     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)
+        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)
+        @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)
+      @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)
+      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)
+      @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)
+      res = @dev.interrupt_transfer(endpoint: endpoint, dataIn: bytes.bytesize, timeout: timeout)
       bytes[0, res.bytesize] = res
       res.bytesize
     end

data/lib/libusb/context.rb

@@ -181,6 +181,8 @@ module LIBUSB
     # @param [Integer, nil] timeout  the maximum time (in millseconds) to block waiting for
     #                                events, or 0 for non-blocking mode
     # @param [Context::CompletionFlag, nil] completion_flag  CompletionFlag to check
+    #
+    # @see interrupt_event_handler
     def handle_events(timeout=nil, completion_flag=nil)
       if completion_flag && !completion_flag.is_a?(Context::CompletionFlag)
         raise ArgumentError, "completion_flag is not a CompletionFlag"
@@ -203,6 +205,19 @@ module LIBUSB
       LIBUSB.raise_error res, "in libusb_handle_events" if res<0
     end
 
+    if Call.respond_to?(:libusb_interrupt_event_handler)
+      # Interrupt any active thread that is handling events.
+      #
+      # This is mainly useful for interrupting a dedicated event handling thread when an application wishes to call {Context#exit}.
+      #
+      # Available since libusb-1.0.21.
+      #
+      # @see handle_events
+      def interrupt_event_handler
+        Call.libusb_interrupt_event_handler(@ctx)
+      end
+    end
+
     # Obtain a list of devices currently attached to the USB system, optionally matching certain criteria.
     #
     # @param [Hash] filter_hash  A number of criteria can be defined in key-value pairs.
@@ -218,7 +233,7 @@ module LIBUSB
     #
     # @example
     #   # Return all devices of vendor 0x0ab1 where idProduct is 3 or 4:
-    #   context.device :idVendor=>0x0ab1, :idProduct=>[0x0003, 0x0004]
+    #   context.device idVendor: 0x0ab1, idProduct: [0x0003, 0x0004]
     #
     # @return [Array<LIBUSB::Device>]
     def devices(filter_hash={})

data/lib/libusb/dependencies.rb

@@ -0,0 +1,7 @@
+module LIBUSB
+  LIBUSB_VERSION = ENV['LIBUSB_VERSION'] || '1.0.21'
+  LIBUSB_SOURCE_URI = "https://github.com/libusb/libusb/releases/download/v#{LIBUSB_VERSION}/libusb-#{LIBUSB_VERSION}.tar.bz2"
+  LIBUSB_SOURCE_SHA1 = '54d71841542eb1a6f0b0420878a4d5434efe8d28'
+
+  MINI_PORTILE_VERSION = '~> 2.1'
+end

data/lib/libusb/dev_handle.rb

@@ -41,6 +41,9 @@ module LIBUSB
     #
     # This is a non-blocking function; no requests are sent over the bus.
     def close
+      @bulk_transfer.free_buffer if @bulk_transfer
+      @interrupt_transfer.free_buffer if @interrupt_transfer
+      @control_transfer.free_buffer if @control_transfer
       Call.libusb_close(@pHandle)
     end
 
@@ -235,6 +238,13 @@ module LIBUSB
         LIBUSB.raise_error res, "in libusb_free_streams" unless res>=0
         nil
       end
+
+    else
+
+      def alloc_streams(num_streams, endpoints)
+        raise NotImplementedError, "libusb-1.0.19+ is required for bulk stream transfers"
+      end
+
     end
 
     # Determine if a kernel driver is active on an interface.
@@ -374,7 +384,7 @@ module LIBUSB
       raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @bulk_transfer ||= BulkTransfer.new :dev_handle => self
+      @bulk_transfer ||= BulkTransfer.new dev_handle: self, allow_device_memory: true
       tr = @bulk_transfer
       tr.endpoint = endpoint
       tr.timeout = timeout
@@ -442,7 +452,7 @@ module LIBUSB
       raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @interrupt_transfer ||= InterruptTransfer.new :dev_handle => self
+      @interrupt_transfer ||= InterruptTransfer.new dev_handle: self, allow_device_memory: true
       tr = @interrupt_transfer
       tr.endpoint = endpoint
       tr.timeout = timeout
@@ -502,7 +512,7 @@ module LIBUSB
       raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
 
       # reuse transfer struct to speed up transfer
-      @control_transfer ||= ControlTransfer.new :dev_handle => self
+      @control_transfer ||= ControlTransfer.new dev_handle: self, allow_device_memory: true
       tr = @control_transfer
       tr.timeout = timeout
       if dataIn

data/lib/libusb/eventmachine.rb

@@ -141,7 +141,7 @@ class DevHandle
   # Execute an eventmachine driven USB bulk transfer.
   #
   # @example
-  #   tr = devh.eventmachine_bulk_transfer( :endpoint => 0x02, :dataOut => "data" )
+  #   tr = devh.eventmachine_bulk_transfer( endpoint: 0x02, dataOut: "data" )
   #   tr.callback do |data|
   #     puts "sent: #{data.inspect}"
   #   end
@@ -159,9 +159,9 @@ class DevHandle
   #
   # @example
   #   tr = devh.eventmachine_control_transfer(
-  #     :bmRequestType=>ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
-  #     :bRequest=>0x01,
-  #     :wValue=>0, :wIndex=>0, :dataIn=>1 )
+  #     bmRequestType: ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+  #     bRequest: 0x01,
+  #     wValue: 0, wIndex: 0, dataIn: 1 )
   #   tr.callback do |data|
   #     puts "recved: #{data.inspect}"
   #   end

data/lib/libusb/transfer.rb

@@ -25,10 +25,29 @@ module LIBUSB
   # Using {Transfer} derived classes directly, however, is needed for isochronous transfers and
   # allows a more advanced buffer management.
   class Transfer
+    class ZeroCopyMemory < FFI::Pointer
+      attr_reader :size
+
+      def initialize(dev_handle, ptr, size)
+        @dev_handle = dev_handle
+        @size = size
+        super(ptr)
+      end
+
+      def free(id=nil)
+        return unless @size
+#         puts format("libusb_dev_mem_free(%#x, %d)%s", address, @size, id ? " by GC" : '')
+        res = Call.libusb_dev_mem_free( @dev_handle.pHandle, self, @size )
+        LIBUSB.raise_error res, "in libusb_dev_mem_free" if res!=0
+        @size = nil
+      end
+    end
+
     def initialize(args={})
-      args.each{|k,v| send("#{k}=", v) }
       @buffer = nil
       @completion_flag = Context::CompletionFlag.new
+      @allow_device_memory = false
+      args.each{|k,v| send("#{k}=", v) }
     end
     private :initialize
 
@@ -52,11 +71,9 @@ module LIBUSB
     end
 
     # Set output data that should be sent.
+    # @see #allow_device_memory
     def buffer=(data)
-      if !@buffer || data.bytesize>@buffer.size
-        free_buffer
-        @buffer = FFI::MemoryPointer.new(data.bytesize, 1, false)
-      end
+      ensure_enough_buffer(data.bytesize)
       @buffer.put_bytes(0, data)
       @transfer[:buffer] = @buffer
       @transfer[:length] = data.bytesize
@@ -81,11 +98,9 @@ module LIBUSB
     #
     # @param [Fixnum]  len  Number of bytes to allocate
     # @param [String, nil] data  some data to initialize the buffer with
+    # @see #allow_device_memory
     def alloc_buffer(len, data=nil)
-      if !@buffer || len>@buffer.size
-        free_buffer
-        @buffer = FFI::MemoryPointer.new(len, 1, false)
-      end
+      ensure_enough_buffer(len)
       @buffer.put_bytes(0, data) if data
       @transfer[:buffer] = @buffer
       @transfer[:length] = len
@@ -96,6 +111,52 @@ module LIBUSB
       @transfer[:actual_length]
     end
 
+    # Try to use persistent device memory.
+    #
+    # If enabled, attempts to allocate a block of persistent DMA memory suitable for transfers against the given device.
+    # The memory is allocated by {#alloc_buffer} or {#buffer=}.
+    # If unsuccessful, ordinary user space memory will be used.
+    #
+    # Using this memory instead of regular memory means that the host controller can use DMA directly into the buffer to increase performance, and also that transfers can no longer fail due to kernel memory fragmentation.
+    #
+    # It requires libusb-1.0.21 and Linux-4.6 to be effective, but it can safely be enabled on other systems.
+    #
+    # Note that this type of memory is bound to the {#dev_handle=}.
+    # So even if the {DevHandle} is closed, the memory is still accessable and the device is locked.
+    # It is free'd by the garbage collector eventually, but in order to close the device deterministic, it is required to call {#free_buffer} on all {Transfer}s which use persistent device memory.
+    #
+    # @see #free_buffer
+    # @see #memory_type
+    attr_accessor :allow_device_memory
+
+    # @return +:device_memory+   - If persistent device memory is allocated.
+    # @return +:user_space+      - If user space memory is allocated.
+    # @return +nil+              - If no memory is allocated.
+    def memory_type
+      case @buffer
+        when ZeroCopyMemory then :device_memory
+        when FFI::MemoryPointer then :user_space
+        else nil
+      end
+    end
+
+    def ensure_enough_buffer(len)
+      if !@buffer || len>@buffer.size
+        free_buffer
+        # Try to use zero-copy-memory and fallback to FFI-memory if not available
+        if @allow_device_memory && @dev_handle && Call.respond_to?(:libusb_dev_mem_alloc)
+          ptr = Call.libusb_dev_mem_alloc( @dev_handle.pHandle, len )
+#           puts format("libusb_dev_mem_alloc(%d) => %#x", len, ptr.address)
+          unless ptr.null?
+            buffer = ZeroCopyMemory.new(@dev_handle, ptr, len)
+            ObjectSpace.define_finalizer(self, buffer.method(:free))
+          end
+        end
+        @buffer = buffer || FFI::MemoryPointer.new(len, 1, false)
+      end
+    end
+    private :ensure_enough_buffer
+
     # Retrieve the data actually transferred.
     #
     # @param [Fixnum] offset  optional offset of the retrieved data in the buffer.
@@ -228,7 +289,7 @@ module LIBUSB
 
       # Get a transfers bulk stream id.
       #
-      # Since version 1.0.19.
+      # Available since libusb-1.0.19.
       #
       # @return [Fixnum] the stream id for the transfer
       def stream_id

data/lib/libusb/version_gem.rb

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

data/libusb.gemspec

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
 require "libusb/version_gem"
+require "libusb/dependencies"
 
 Gem::Specification.new do |s|
   s.name        = "libusb"
@@ -10,19 +11,20 @@ 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.licenses    = ['LGPL-3.0']
   s.rdoc_options = %w[--main README.md --charset=UTF-8]
 
-  s.rubyforge_project = "libusb"
-
   s.files         = `git ls-files`.split("\n")
+  s.files         << "ports/archives/libusb-#{LIBUSB::LIBUSB_VERSION}.tar.bz2"
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   s.extensions    = ['ext/extconf.rb']
 
-  s.add_runtime_dependency 'ffi', '>= 1.0'
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
+  s.add_runtime_dependency 'ffi', '~> 1.0'
+  s.add_runtime_dependency 'mini_portile2', LIBUSB::MINI_PORTILE_VERSION
   s.add_development_dependency 'rake-compiler', '~> 0.9'
   s.add_development_dependency 'rake-compiler-dock', '~> 0.2'
-  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'bundler', '~> 1.0'
 end

data/test/test_libusb_bulk_stream_transfer.rb

@@ -44,7 +44,7 @@ class TestLibusbBulkStreamTransfer < Minitest::Test
   end
 
   def test_bulk_stream_transfer
-    tr = BulkStreamTransfer.new :dev_handle=>@dev, :stream_id=>123, :buffer=>' '*100
+    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

@@ -161,11 +161,11 @@ class TestLibusbDescriptors < Minitest::Test
       end
     end
 
-    devs2 =  usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>0x01, :bProtocol=>0x50 )
-    devs2 += usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>0x06, :bProtocol=>0x50 )
+    devs2 =  usb.devices( bClass: CLASS_MASS_STORAGE, bSubClass: 0x01, bProtocol: 0x50 )
+    devs2 += usb.devices( bClass: CLASS_MASS_STORAGE, bSubClass: 0x06, bProtocol: 0x50 )
     assert_equal devs1.sort, devs2.sort, "devices and devices with filter should deliver the same device"
 
-    devs3 =  usb.devices( :bClass=>[CLASS_MASS_STORAGE], :bSubClass=>[0x01,0x06], :bProtocol=>[0x50] )
+    devs3 =  usb.devices( bClass: [CLASS_MASS_STORAGE], bSubClass: [0x01,0x06], bProtocol: [0x50] )
     assert_equal devs1.sort, devs3.sort, "devices and devices with array-filter should deliver the same device"
   end
 
@@ -179,7 +179,7 @@ class TestLibusbDescriptors < Minitest::Test
       end
     end
 
-    devs2 = usb.devices( :bClass=>CLASS_HUB )
+    devs2 = usb.devices( bClass: CLASS_HUB )
     assert_equal devs1.sort, devs2.sort, "devices and devices with filter should deliver the same device"
   end
 

data/test/test_libusb_event_machine.rb

@@ -32,7 +32,7 @@ class TestLibusbEventMachine < Minitest::Test
     @context = Context.new
     @context.debug = 3
 
-    @device = context.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>[0x06,0x01], :bProtocol=>0x50 ).last
+    @device = context.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 }
@@ -70,9 +70,9 @@ class TestLibusbEventMachine < Minitest::Test
     em_run do
       ticks = 0
       tr = devh.eventmachine_bulk_transfer(
-          :endpoint => @endpoint_in,
-          :timeout => 1500,
-          :dataIn => 123 )
+          endpoint: @endpoint_in,
+          timeout: 1500,
+          dataIn: 123 )
 #       puts "started usb transfer #{tr}"
 
       tr.callback do |data|
@@ -98,9 +98,9 @@ class TestLibusbEventMachine < Minitest::Test
   def test_event_loop
     em_run do
       tr = devh.eventmachine_control_transfer(
-        :bmRequestType=>ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
-        :bRequest=>BOMS_GET_MAX_LUN,
-        :wValue=>0, :wIndex=>0, :dataIn=>1 )
+        bmRequestType: ENDPOINT_IN|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
+        bRequest: BOMS_GET_MAX_LUN,
+        wValue: 0, wIndex: 0, dataIn: 1 )
 
 #       puts "started usb transfer #{tr}"
       tr.callback do |data|

data/test/test_libusb_hotplug.rb

@@ -31,7 +31,7 @@ class TestLibusbHotplug < Minitest::Test
 
   def test_enumerate
     devs = []
-    ctx.on_hotplug_event :flags => HOTPLUG_ENUMERATE do |dev, event|
+    ctx.on_hotplug_event flags: HOTPLUG_ENUMERATE do |dev, event|
       devs << dev
       assert_equal :HOTPLUG_EVENT_DEVICE_ARRIVED, event
       :repeat
@@ -44,7 +44,7 @@ class TestLibusbHotplug < Minitest::Test
 
   def test_enumerate_with_left
     devs = []
-    ctx.on_hotplug_event :flags => HOTPLUG_ENUMERATE, :events => HOTPLUG_EVENT_DEVICE_LEFT do |dev, event|
+    ctx.on_hotplug_event flags: HOTPLUG_ENUMERATE, events: HOTPLUG_EVENT_DEVICE_LEFT do |dev, event|
       devs << dev
       assert_equal :HOTPLUG_EVENT_DEVICE_ARRIVED, event
       :repeat
@@ -65,7 +65,7 @@ class TestLibusbHotplug < Minitest::Test
 
   def test_wrong_yieldreturn
     ex = assert_raises(ArgumentError) do
-      ctx.on_hotplug_event :flags => :HOTPLUG_ENUMERATE do |dev, event|
+      ctx.on_hotplug_event flags: :HOTPLUG_ENUMERATE do |dev, event|
       end
     end
 
@@ -112,4 +112,16 @@ class TestLibusbHotplug < Minitest::Test
     assert_operator devs2.map(&:last), :include?, :HOTPLUG_EVENT_DEVICE_ARRIVED, "Should have received ARRIVED"
     assert_operator devs2.map(&:last), :include?, :HOTPLUG_EVENT_DEVICE_LEFT, "Should have received LEFT"
   end
+
+  def test_interrupt_event_handler
+    th = Thread.new do
+      ctx.handle_events 5000
+    end
+
+    sleep 0.1 # Workaround a bug in libusb-1,0.21
+    st = Time.now
+    ctx.interrupt_event_handler
+    th.join
+    assert_operator Time.now-st, :<, 5.0
+  end
 end

data/test/test_libusb_iso_transfer.rb

@@ -34,7 +34,7 @@ class TestLibusbIsoTransfer < Minitest::Test
   end
 
   def test_iso_transfer
-    tr = IsochronousTransfer.new 10, :dev_handle=>@dev
+    tr = IsochronousTransfer.new 10, dev_handle: @dev
     assert_equal 10, tr.num_packets, "number of packets should match"
 
     tr.buffer = " "*130

data/test/test_libusb_mass_storage.rb

@@ -40,7 +40,7 @@ class TestLibusbMassStorage < Minitest::Test
     @usb.debug = 3
     @asynchron = false
 
-    @device = usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>[0x06,0x01], :bProtocol=>0x50 ).last
+    @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 }
@@ -97,10 +97,10 @@ class TestLibusbMassStorage < Minitest::Test
     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)
+    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)
+    recv = bulk_transfer(endpoint: endpoint_in, dataIn: data_length)
 
     get_mass_storage_status(expected_tag)
     return recv
@@ -109,7 +109,7 @@ class TestLibusbMassStorage < Minitest::Test
   def get_mass_storage_status(expected_tag)
     retries = 5
     buffer = begin
-      bulk_transfer(:endpoint=>endpoint_in, :dataIn=>13)
+      bulk_transfer(endpoint: endpoint_in, dataIn: 13)
     rescue LIBUSB::ERROR_PIPE
       if (retries-=1)>=0
         dev.clear_halt(endpoint_in)
@@ -167,23 +167,23 @@ class TestLibusbMassStorage < Minitest::Test
 
   def mass_storage_reset
     res = control_transfer(
-      :bmRequestType=>ENDPOINT_OUT|REQUEST_TYPE_CLASS|RECIPIENT_INTERFACE,
-      :bRequest=>BOMS_RESET,
-      :wValue=>0, :wIndex=>0)
+      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=>'')
+      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)
+      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
 
@@ -217,7 +217,7 @@ class TestLibusbMassStorage < Minitest::Test
     end
     assert_raises(LIBUSB::ERROR_TIMEOUT) do
       begin
-        bulk_transfer(:endpoint=>endpoint_in, :dataIn=>123)
+        bulk_transfer(endpoint: endpoint_in, dataIn: 123)
       rescue LIBUSB::ERROR_TIMEOUT => err
         assert_kind_of String, err.transferred
         raise
@@ -258,11 +258,11 @@ class TestLibusbMassStorage < Minitest::Test
   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.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) }
+      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

@@ -27,7 +27,7 @@ class TestLibusbMassStorage2 < Minitest::Test
   def setup
     @usb = Context.new
     @usb.debug = 3
-    @device = usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>[0x06,0x01], :bProtocol=>0x50 ).last
+    @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

data/test/test_libusb_structs.rb

@@ -42,4 +42,17 @@ class TestLibusbStructs < Minitest::Test
     assert_equal false, s.completed?
     assert_equal 0, s[:completed]
   end
+
+  def test_Transfer
+    t = LIBUSB::InterruptTransfer.new allow_device_memory: true
+    assert_equal :TRANSFER_COMPLETED, t.status
+    assert_equal true, t.allow_device_memory
+    assert_equal 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_equal nil, t.memory_type
+  end
 end

data/test/test_libusb_threads.rb

@@ -34,7 +34,7 @@ class TestLibusbThreads < Minitest::Test
     @usb = Context.new
     @usb.debug = 3
 
-    @devices = usb.devices( :bClass=>CLASS_MASS_STORAGE, :bSubClass=>[0x06,0x01], :bProtocol=>0x50 )
+    @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|
@@ -71,7 +71,7 @@ class TestLibusbThreads < Minitest::Test
     1.times do
       st = Time.now
       assert_raises LIBUSB::ERROR_TIMEOUT do
-        dev.bulk_transfer(:endpoint=>endpoint, :dataIn=>123, :timeout=>100)
+        dev.bulk_transfer(endpoint: endpoint, dataIn: 123, timeout: 100)
       end
       assert_operator Time.now-st, :<, 5
       dev.clear_halt(endpoint)

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: libusb
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: x64-mingw32
 authors:
 - Lars Kanis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-29 00:00:00.000000000 Z
+date: 2016-12-09 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'
 - !ruby/object:Gem::Dependency
@@ -56,16 +56,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 description: LIBUSB is a Ruby binding that gives Ruby programmers access to arbitrary
   USB devices
 email:
@@ -82,6 +82,7 @@ files:
 - History.md
 - README.md
 - Rakefile
+- appveyor.yml
 - lib/libusb-1.0.dll
 - lib/libusb.rb
 - lib/libusb/bos.rb
@@ -90,6 +91,7 @@ files:
 - lib/libusb/configuration.rb
 - lib/libusb/constants.rb
 - lib/libusb/context.rb
+- lib/libusb/dependencies.rb
 - lib/libusb/dev_handle.rb
 - lib/libusb/device.rb
 - lib/libusb/endpoint.rb
@@ -117,9 +119,10 @@ files:
 - test/test_libusb_structs.rb
 - test/test_libusb_threads.rb
 - test/test_libusb_version.rb
+- wireshark-usb-sniffer.png
 homepage: http://github.com/larskanis/libusb
 licenses:
-- LGPL-3
+- LGPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options:
@@ -132,15 +135,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: libusb
-rubygems_version: 2.4.8
+rubyforge_project: 
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Access USB devices from Ruby via libusb-1.0