libusb 0.8.0-aarch64-mingw-ucrt

data/lib/libusb/eventmachine.rb

@@ -0,0 +1,203 @@
+# 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'
+require 'eventmachine'
+
+module LIBUSB
+class Context
+  # Register libusb's file descriptors and timeouts to EventMachine.
+  #
+  # @example
+  #   require 'libusb/eventmachine'
+  #   context = LIBUSB::Context.new
+  #   EventMachine.run do
+  #     context.eventmachine_register
+  #   end
+  #
+  # @see
+  #   DevHandle#eventmachine_bulk_transfer
+  #   DevHandle#eventmachine_control_transfer
+  #   DevHandle#eventmachine_interrupt_transfer
+  def eventmachine_register
+    @eventmachine_attached_fds = {}
+    @eventmachine_timer = nil
+
+    pollfds = self.pollfds
+    if pollfds
+      pollfds.each do |pollfd|
+        eventmachine_add_pollfd(pollfd)
+      end
+
+      self.on_pollfd_added do |pollfd|
+        eventmachine_add_pollfd(pollfd)
+      end
+
+      self.on_pollfd_removed do |pollfd|
+        eventmachine_rm_pollfd(pollfd)
+      end
+    else
+      # Libusb pollfd API is not available on this platform.
+      # Use simple polling timer, instead:
+      EventMachine.add_periodic_timer(0.01) do
+        begin
+          @eventmachine_timer = self.handle_events 0
+        rescue ERROR_INTERRUPTED
+          # Interrupted by a signal; nothing was handled. The next tick of this
+          # periodic timer retries. See the pollfd callback below.
+        end
+      end
+    end
+  end
+
+  def eventmachine_unregister
+    @eventmachine_timer.cancel if @eventmachine_timer
+    @eventmachine_attached_fds.each do |fd, watcher|
+      watcher.detach
+    end
+
+    # Deregister callbacks
+    on_pollfd_added
+    on_pollfd_removed
+  end
+
+  class EMPollfdHandler < EventMachine::Connection
+    def initialize
+      @callbacks = []
+      super
+    end
+
+    def on_need_handle_events(&block)
+      @callbacks << block
+    end
+
+    def need_handle_events
+      @callbacks.each do |cb|
+        cb.call
+      end
+    end
+    alias notify_readable need_handle_events
+    alias notify_writable need_handle_events
+  end
+
+  private
+  def eventmachine_add_pollfd(pollfd)
+    conn = EventMachine.watch(pollfd.io, EMPollfdHandler)
+    conn.notify_readable = pollfd.pollin?
+    conn.notify_writable = pollfd.pollout?
+    cb = proc do
+      if @eventmachine_timer
+        @eventmachine_timer.cancel
+        @eventmachine_timer = nil
+      end
+
+      begin
+        self.handle_events 0
+      rescue ERROR_INTERRUPTED
+        # poll() was interrupted by a signal, so no events were handled. This
+        # is transient and retryable: the descriptor stays watched and the next
+        # readable/writable event re-enters this callback. Without this rescue
+        # the exception unwinds out of EventMachine.run and takes the whole
+        # reactor (and typically the process) down. Same handling as the
+        # synchronous transfer path in transfer.rb.
+        next
+      end
+
+      timeout = self.next_timeout
+#         puts "libusb new timeout: #{timeout.inspect}"
+      if timeout
+        @eventmachine_timer = EventMachine.add_timer(timeout, &cb)
+      end
+    end
+    conn.on_need_handle_events(&cb)
+
+    @eventmachine_attached_fds[pollfd.fd] = conn
+#       puts "libusb pollfd added: #{pollfd.inspect}"
+  end
+
+  def eventmachine_rm_pollfd(pollfd)
+    @eventmachine_attached_fds[pollfd.fd].detach
+#       puts "libusb pollfd removed: #{pollfd.inspect}"
+  end
+end
+
+class DevHandle
+  class EMTransfer
+    include EM::Deferrable
+
+    def initialize(opts, dev_handle, transfer_method)
+      dev_handle.send(transfer_method, **opts) do |res|
+        EM.next_tick do
+          if res.kind_of?(LIBUSB::Error)
+            fail res
+          else
+            succeed res
+          end
+        end
+      end
+    end
+  end
+
+  # Execute an eventmachine driven USB interrupt transfer.
+  #
+  # @see Context#eventmachine_register
+  #   DevHandle#interrupt_transfer
+  def eventmachine_interrupt_transfer(**opts)
+    eventmachine_transfer(opts, :interrupt_transfer)
+  end
+
+  # Execute an eventmachine driven USB bulk transfer.
+  #
+  # @example
+  #   tr = devh.eventmachine_bulk_transfer( endpoint: 0x02, dataOut: "data" )
+  #   tr.callback do |data|
+  #     puts "sent: #{data.inspect}"
+  #   end
+  #   tr.errback do |ex|
+  #     puts "send-err: #{ex}"
+  #   end
+  #
+  # @see Context#eventmachine_register
+  #   DevHandle#bulk_transfer
+  def eventmachine_bulk_transfer(**opts)
+    eventmachine_transfer(opts, :bulk_transfer)
+  end
+
+  # Execute an eventmachine driven USB control transfer.
+  #
+  # @example
+  #   tr = devh.eventmachine_control_transfer(
+  #     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
+  #   tr.errback do |ex|
+  #     puts "recv-err: #{ex}"
+  #   end
+  #
+  # @see Context#eventmachine_register
+  #   DevHandle#control_transfer
+  def eventmachine_control_transfer(**opts)
+    eventmachine_transfer(opts, :control_transfer)
+  end
+
+  private
+  def eventmachine_transfer(opts, method)
+    EMTransfer.new opts, self, method
+  end
+end
+end

data/lib/libusb/gem_helper.rb

@@ -0,0 +1,152 @@
+# 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 "bundler/gem_helper"
+require 'ostruct'
+
+module LIBUSB
+  class GemHelper < Bundler::GemHelper
+    attr_accessor :cross_platforms
+
+    def install
+      super
+
+      task "release:guard_clean" => ["release:update_history"]
+
+      task "release:update_history" do
+        update_history
+      end
+
+      task "release:rubygem_push" => ["gem:native"]
+    end
+
+    def hfile
+      "History.md"
+    end
+
+    def headline
+      '([^\w]*)(\d+\.\d+\.\d+)([^\w]+)([2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])([^\w]*|$)'
+    end
+
+    def reldate
+      Time.now.strftime("%Y-%m-%d")
+    end
+
+    def update_history
+      hin = File.read(hfile)
+      hout = hin.sub(/#{headline}/) do
+        raise "#{hfile} isn't up-to-date for version #{version}" unless $2==version.to_s
+        $1 + $2 + $3 + reldate + $5
+      end
+      if hout != hin
+        Bundler.ui.confirm "Updating #{hfile} for release."
+        File.write(hfile, hout)
+        Rake::FileUtilsExt.sh "git", "commit", hfile, "-m", "Update release date in #{hfile}"
+      end
+    end
+
+    def tag_version
+      Bundler.ui.confirm "Tag release with annotation:"
+      m = File.read(hfile).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_tag], "w") do |fd|
+        fd.write m[:annotation]
+      end
+      yield if block_given?
+    rescue
+      Bundler.ui.error "Untagging #{version_tag} due to error."
+      sh_with_status %W[git tag -d #{version_tag}]
+      raise
+    end
+
+    def rubygem_push(path)
+      cross_platforms.each do |ruby_platform|
+        super(path.gsub(/\.gem\z/, "-#{ruby_platform}.gem"))
+      end
+      super(path)
+    end
+  end
+
+
+  class CrossLibrary < OpenStruct
+    include Rake::DSL
+
+    def initialize(ruby_platform, host_platform, libusb_dllname)
+      super()
+
+      self.ruby_platform = ruby_platform
+      self.recipe = LIBUSB::LibusbRecipe.new
+      recipe.host = ruby_platform
+      recipe.configure_options << "--host=#{host_platform}"
+      recipe.configure_options << "CC=#{host_platform}-gcc -static-libgcc" if recipe.host =~ /mingw/
+      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 all targets'
+      task :cross => "cross:#{ruby_platform}"
+
+      desc "Cross compile libusb for #{ruby_platform}"
+      task "cross:#{ruby_platform}" => [ "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
+end

data/lib/libusb/interface.rb

@@ -0,0 +1,60 @@
+# 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
+  class Interface < FFI::Struct
+    include Comparable
+
+    layout :altsetting, :pointer,
+        :num_altsetting, :int
+
+    # Number of this interface.
+    def bInterfaceNumber
+      settings.first.bInterfaceNumber
+    end
+
+    def initialize(configuration, *args)
+      @configuration = configuration
+      super(*args)
+    end
+
+    # @return [Configuration] the configuration this interface belongs to.
+    attr_reader :configuration
+
+    def alt_settings
+      ifs = []
+      self[:num_altsetting].times do |i|
+        ifs << Setting.new(self, self[:altsetting] + i*Setting.size)
+      end
+      return ifs
+    end
+    alias settings alt_settings
+
+    def inspect
+      "\#<#{self.class} #{bInterfaceNumber}>"
+    end
+
+    # The {Device} this Interface belongs to.
+    def device() self.configuration.device end
+    # Return all endpoints of all alternative settings as Array of {Endpoint}s.
+    def endpoints() self.alt_settings.map {|d| d.endpoints }.flatten end
+
+    def <=>(o)
+      configuration<=>o.configuration
+    end
+  end
+end

data/lib/libusb/libusb_recipe.rb

@@ -0,0 +1,29 @@
+require_relative 'dependencies'
+require 'rubygems'
+# Keep the version constraint in sync with libusb.gemspec
+gem "mini_portile2", LIBUSB::MINI_PORTILE_VERSION
+require "mini_portile2"
+
+module LIBUSB
+  class LibusbRecipe < MiniPortile
+    ROOT = File.expand_path('../../..', __FILE__)
+
+    def initialize
+      super("libusb", LIBUSB_VERSION)
+      self.target = File.join(ROOT, "ports")
+      self.files = [url: LIBUSB_SOURCE_URI, sha256: LIBUSB_SOURCE_SHA256]
+      self.patch_files = Dir[File.join(ROOT, "patches", self.name, self.version, "*.patch")].sort
+      self.configure_options = []
+    end
+
+    def cook_and_activate
+      checkpoint = File.join(self.target, "#{self.name}-#{self.version}-#{self.host}.installed")
+      unless File.exist?(checkpoint)
+        self.cook
+        FileUtils.touch checkpoint
+      end
+      self.activate
+      self
+    end
+  end
+end

data/lib/libusb/setting.rb

@@ -0,0 +1,132 @@
+# 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
+  class Setting < FFI::Struct
+    include Comparable
+
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :bInterfaceNumber, :uint8,
+        :bAlternateSetting, :uint8,
+        :bNumEndpoints, :uint8,
+        :bInterfaceClass, :uint8,
+        :bInterfaceSubClass, :uint8,
+        :bInterfaceProtocol, :uint8,
+        :iInterface, :uint8,
+        :endpoint, :pointer,
+        :extra, :pointer,
+        :extra_length, :int
+
+    # Size of this descriptor (in bytes).
+    def bLength
+      self[:bLength]
+    end
+
+    # Descriptor type (0x04)
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # Number of the interface this setting belongs to.
+    def bInterfaceNumber
+      self[:bInterfaceNumber]
+    end
+
+    # Value used to select this alternate setting for this interface.
+    def bAlternateSetting
+      self[:bAlternateSetting]
+    end
+
+    # Number of endpoints used by this interface (excluding the control endpoint).
+    def bNumEndpoints
+      self[:bNumEndpoints]
+    end
+
+    # USB-IF class code for this interface.
+    def bInterfaceClass
+      self[:bInterfaceClass]
+    end
+
+    # USB-IF subclass code for this interface, qualified by the {Setting#bInterfaceClass} value.
+    def bInterfaceSubClass
+      self[:bInterfaceSubClass]
+    end
+
+    # USB-IF protocol code for this interface, qualified by the {Setting#bInterfaceClass} and {Setting#bInterfaceSubClass} values.
+    def bInterfaceProtocol
+      self[:bInterfaceProtocol]
+    end
+
+    # Index of string descriptor describing this interface.
+    def iInterface
+      self[:iInterface]
+    end
+
+    # Extra descriptors.
+    #
+    # @return [String]
+    def extra
+      return if self[:extra].null?
+      self[:extra].read_string(self[:extra_length])
+    end
+
+    def initialize(interface, *args)
+      @interface = interface
+      super(*args)
+    end
+
+    # @return [Interface] the interface this setting belongs to.
+    attr_reader :interface
+
+    def endpoints
+      ifs = []
+      self[:bNumEndpoints].times do |i|
+        ifs << Endpoint.new(self, self[:endpoint] + i*Endpoint.size)
+      end
+      return ifs
+    end
+
+    def inspect
+      attrs = []
+      attrs << self.bAlternateSetting.to_s
+      devclass = LIBUSB.dev_string(self.bInterfaceClass, self.bInterfaceSubClass, self.bInterfaceProtocol)
+      attrs << devclass
+      desc = self.description
+      attrs << desc if desc != '?'
+      "\#<#{self.class} #{attrs.join(' ')}>"
+    end
+
+    # Return name of this interface as String.
+    def description
+      return @description if defined? @description
+      @description = device.try_string_descriptor_ascii(self.iInterface)
+    end
+
+    # The {Device} this Setting belongs to.
+    def device() self.interface.configuration.device end
+    # The {Configuration} this Setting belongs to.
+    def configuration() self.interface.configuration end
+
+    def <=>(o)
+      t = interface<=>o.interface
+      t = bInterfaceNumber<=>o.bInterfaceNumber if t==0
+      t = bAlternateSetting<=>o.bAlternateSetting if t==0
+      t
+    end
+  end
+end

data/lib/libusb/ss_companion.rb

@@ -0,0 +1,72 @@
+# This file is part of Libusb for Ruby.
+#
+# Libusb for Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libusb for Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'libusb/call'
+
+module LIBUSB
+  # A structure representing the superspeed endpoint companion descriptor.
+  #
+  # This descriptor is documented in section 9.6.7 of the USB 3.0 specification. All multiple-byte fields are represented in host-endian format.
+  class SsCompanion < FFI::Struct
+    include ContextReference
+
+    layout :bLength, :uint8,
+        :bDescriptorType, :uint8,
+        :bMaxBurst, :uint8,
+        :bmAttributes, :uint8,
+        :wBytesPerInterval, :uint16
+
+    def initialize(ctx, *args)
+      super(*args)
+
+      register_context(ctx, :libusb_free_ss_endpoint_companion_descriptor)
+    end
+
+    # Size of this descriptor (in bytes)
+    def bLength
+      self[:bLength]
+    end
+
+    # Descriptor type.
+    #
+    # Will have value LIBUSB::DT_SS_ENDPOINT_COMPANION in this context.
+    def bDescriptorType
+      self[:bDescriptorType]
+    end
+
+    # The maximum number of packets the endpoint can send or recieve as part of a burst.
+    def bMaxBurst
+      self[:bMaxBurst]
+    end
+
+    # In bulk EP: bits 4:0 represents the maximum number of streams the EP supports.
+    #
+    # In isochronous EP: bits 1:0 represents the Mult - a zero based value that determines the maximum number of packets within a service interval
+    def bmAttributes
+      self[:bmAttributes]
+    end
+
+    # The total number of bytes this EP will transfer every service interval.
+    #
+    # valid only for periodic EPs.
+    def wBytesPerInterval
+      self[:wBytesPerInterval]
+    end
+
+    def inspect
+      "\#<#{self.class} burst: #{bMaxBurst} attrs: #{bmAttributes}>"
+    end
+  end
+end

data/lib/libusb/stdio.rb

@@ -0,0 +1,25 @@
+# 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 'rubygems'
+require "ffi"
+
+module LIBUSB
+  module Stdio
+    extend FFI::Library
+    ffi_lib FFI::Platform::LIBC
+    attach_function :free, [ :pointer ], :void
+  end
+end