libusb 0.3.3-x64-mingw32

data/lib/libusb.rb

@@ -0,0 +1,51 @@
+# This file is part of Libusb for Ruby.
+#
+# Libusb for Ruby is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Libusb for Ruby is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
+
+module LIBUSB
+  require 'libusb/call'
+  require 'libusb/constants'
+  require 'libusb/context'
+  autoload :VERSION, 'libusb/version_gem'
+  autoload :Version, 'libusb/version_struct'
+  autoload :Configuration, 'libusb/configuration'
+  autoload :DevHandle, 'libusb/dev_handle'
+  autoload :Device, 'libusb/device'
+  autoload :Endpoint, 'libusb/endpoint'
+  autoload :Interface, 'libusb/interface'
+  autoload :Setting, 'libusb/setting'
+  %w[ Transfer BulkTransfer ControlTransfer InterruptTransfer IsoPacket IsochronousTransfer ].each do |klass|
+    autoload klass, 'libusb/transfer'
+  end
+
+  if Call.respond_to?(:libusb_get_version)
+    # Get version of the underlying libusb library.
+    # Available since libusb-1.0.10.
+    # @return [Version]  version object
+    def self.version
+      Version.new(Call.libusb_get_version)
+    end
+  end
+
+  if Call.respond_to?(:libusb_has_capability)
+    # Check at runtime if the loaded library has a given capability.
+    # Available since libusb-1.0.9.
+    # @param [Symbol] capability  the {Call::Capabilities Capabilities} symbol to check for
+    # @return [Boolean]  +true+ if the running library has the capability, +false+ otherwise
+    def self.has_capability?(capability)
+      r = Call.libusb_has_capability(capability)
+      return r != 0
+    end
+  end
+end

data/lib/libusb/call.rb

@@ -0,0 +1,316 @@
+# 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
+  # C level interface - for internal use only
+  #
+  # All enum codes are available as constants in {LIBUSB} namespace.
+  module Call
+    extend FFI::Library
+
+    root_path = File.expand_path("../../..", __FILE__)
+    ext = FFI::Platform::LIBSUFFIX
+    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])
+
+    ClassCodes = enum :libusb_class_code, [
+      :CLASS_PER_INTERFACE, 0,
+      :CLASS_AUDIO, 1,
+      :CLASS_COMM, 2,
+      :CLASS_HID, 3,
+      :CLASS_PRINTER, 7,
+      :CLASS_PTP, 6,
+      :CLASS_MASS_STORAGE, 8,
+      :CLASS_HUB, 9,
+      :CLASS_DATA, 10,
+      :CLASS_WIRELESS, 0xe0,
+      :CLASS_APPLICATION, 0xfe,
+      :CLASS_VENDOR_SPEC, 0xff
+    ]
+
+    Errors = enum :libusb_error, [
+      :SUCCESS, 0,
+      :ERROR_IO, -1,
+      :ERROR_INVALID_PARAM, -2,
+      :ERROR_ACCESS, -3,
+      :ERROR_NO_DEVICE, -4,
+      :ERROR_NOT_FOUND, -5,
+      :ERROR_BUSY, -6,
+      :ERROR_TIMEOUT, -7,
+      :ERROR_OVERFLOW, -8,
+      :ERROR_PIPE, -9,
+      :ERROR_INTERRUPTED, -10,
+      :ERROR_NO_MEM, -11,
+      :ERROR_NOT_SUPPORTED, -12,
+      :ERROR_OTHER, -99,
+    ]
+
+    # Transfer status codes
+    TransferStatus = enum :libusb_transfer_status, [
+      :TRANSFER_COMPLETED,
+      :TRANSFER_ERROR,
+      :TRANSFER_TIMED_OUT,
+      :TRANSFER_CANCELLED,
+      :TRANSFER_STALL,
+      :TRANSFER_NO_DEVICE,
+      :TRANSFER_OVERFLOW,
+    ]
+
+    # libusb_transfer.flags values
+    TransferFlags = enum :libusb_transfer_flags, [
+      :TRANSFER_SHORT_NOT_OK, 1 << 0,
+      :TRANSFER_FREE_BUFFER, 1 << 1,
+      :TRANSFER_FREE_TRANSFER, 1 << 2,
+      :TRANSFER_ADD_ZERO_PACKET, 1 << 3,
+    ]
+
+    TransferTypes = enum :libusb_transfer_type, [
+      :TRANSFER_TYPE_CONTROL, 0,
+      :TRANSFER_TYPE_ISOCHRONOUS, 1,
+      :TRANSFER_TYPE_BULK, 2,
+      :TRANSFER_TYPE_INTERRUPT, 3,
+    ]
+
+    StandardRequests = enum :libusb_standard_request, [
+      :REQUEST_GET_STATUS, 0x00,
+      :REQUEST_CLEAR_FEATURE, 0x01,
+      :REQUEST_SET_FEATURE, 0x03,
+      :REQUEST_SET_ADDRESS, 0x05,
+      :REQUEST_GET_DESCRIPTOR, 0x06,
+      :REQUEST_SET_DESCRIPTOR, 0x07,
+      :REQUEST_GET_CONFIGURATION, 0x08,
+      :REQUEST_SET_CONFIGURATION, 0x09,
+      :REQUEST_GET_INTERFACE, 0x0A,
+      :REQUEST_SET_INTERFACE, 0x0B,
+      :REQUEST_SYNCH_FRAME, 0x0C,
+    ]
+
+    EndpointDirections = enum :libusb_endpoint_direction, [
+      :ENDPOINT_IN, 0x80,
+      :ENDPOINT_OUT, 0x00,
+    ]
+
+    DescriptorTypes = enum :libusb_descriptor_type, [
+      :DT_DEVICE, 0x01,
+      :DT_CONFIG, 0x02,
+      :DT_STRING, 0x03,
+      :DT_INTERFACE, 0x04,
+      :DT_ENDPOINT, 0x05,
+      :DT_HID, 0x21,
+      :DT_REPORT, 0x22,
+      :DT_PHYSICAL, 0x23,
+      :DT_HUB, 0x29,
+    ]
+
+    RequestTypes = enum :libusb_request_type, [
+      :REQUEST_TYPE_STANDARD, (0x00 << 5),
+      :REQUEST_TYPE_CLASS, (0x01 << 5),
+      :REQUEST_TYPE_VENDOR, (0x02 << 5),
+      :REQUEST_TYPE_RESERVED, (0x03 << 5),
+    ]
+
+    RequestRecipients = enum :libusb_request_recipient, [
+      :RECIPIENT_DEVICE, 0x00,
+      :RECIPIENT_INTERFACE, 0x01,
+      :RECIPIENT_ENDPOINT, 0x02,
+      :RECIPIENT_OTHER, 0x03,
+    ]
+
+    IsoSyncTypes = enum :libusb_iso_sync_type, [
+      :ISO_SYNC_TYPE_NONE, 0,
+      :ISO_SYNC_TYPE_ASYNC, 1,
+      :ISO_SYNC_TYPE_ADAPTIVE, 2,
+      :ISO_SYNC_TYPE_SYNC, 3,
+    ]
+
+    Speeds = enum :libusb_speed, [
+      :SPEED_UNKNOWN, 0,
+      :SPEED_LOW, 1,
+      :SPEED_FULL, 2,
+      :SPEED_HIGH, 3,
+      :SPEED_SUPER, 4,
+    ]
+
+    Capabilities = enum :libusb_capability, [
+      :CAP_HAS_CAPABILITY, 0,
+    ]
+
+    typedef :pointer, :libusb_context
+    typedef :pointer, :libusb_device_handle
+
+    def self.try_attach_function(method, *args)
+      if ffi_libraries.find{|lib| lib.find_function(method) }
+        attach_function method, *args
+      end
+    end
+
+    try_attach_function 'libusb_get_version', [], :pointer
+
+    attach_function 'libusb_init', [ :pointer ], :int
+    attach_function 'libusb_exit', [ :pointer ], :void
+    attach_function 'libusb_set_debug', [:pointer, :int], :void
+    try_attach_function 'libusb_has_capability', [:libusb_capability], :int
+
+    attach_function 'libusb_get_device_list', [:pointer, :pointer], :ssize_t
+    attach_function 'libusb_free_device_list', [:pointer, :int], :void
+    attach_function 'libusb_ref_device', [:pointer], :pointer
+    attach_function 'libusb_unref_device', [:pointer], :void
+
+    attach_function 'libusb_get_device_descriptor', [:pointer, :pointer], :int
+    attach_function 'libusb_get_active_config_descriptor', [:pointer, :pointer], :int
+    attach_function 'libusb_get_config_descriptor', [:pointer, :uint8, :pointer], :int
+    attach_function 'libusb_get_config_descriptor_by_value', [:pointer, :uint8, :pointer], :int
+    attach_function 'libusb_free_config_descriptor', [:pointer], :void
+    attach_function 'libusb_get_bus_number', [:pointer], :uint8
+    try_attach_function 'libusb_get_port_number', [:pointer], :uint8
+    try_attach_function 'libusb_get_parent', [:pointer], :pointer
+    try_attach_function 'libusb_get_port_path', [:pointer, :pointer, :pointer, :uint8], :uint8
+    attach_function 'libusb_get_device_address', [:pointer], :uint8
+    try_attach_function 'libusb_get_device_speed', [:pointer], :libusb_speed
+    attach_function 'libusb_get_max_packet_size', [:pointer, :uint8], :int
+    attach_function 'libusb_get_max_iso_packet_size', [:pointer, :uint8], :int
+
+    attach_function 'libusb_open', [:pointer, :pointer], :int
+    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_claim_interface', [:libusb_device_handle, :int], :int
+    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_kernel_driver_active', [:libusb_device_handle, :int], :int
+    attach_function 'libusb_detach_kernel_driver', [:libusb_device_handle, :int], :int
+    attach_function 'libusb_attach_kernel_driver', [:libusb_device_handle, :int], :int
+
+    attach_function 'libusb_get_string_descriptor_ascii', [:pointer, :uint8, :pointer, :int], :int
+
+    attach_function 'libusb_alloc_transfer', [:int], :pointer
+    attach_function 'libusb_submit_transfer', [:pointer], :int
+    attach_function 'libusb_cancel_transfer', [:pointer], :int
+    attach_function 'libusb_free_transfer', [:pointer], :void
+
+    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
+
+    callback :libusb_pollfd_added_cb, [:int, :short, :pointer], :void
+    callback :libusb_pollfd_removed_cb, [:int, :pointer], :void
+
+    attach_function 'libusb_get_pollfds', [:libusb_context], :pointer
+    attach_function 'libusb_get_next_timeout', [:libusb_context, :pointer], :int
+    attach_function 'libusb_set_pollfd_notifiers', [:libusb_context, :libusb_pollfd_added_cb, :libusb_pollfd_removed_cb, :pointer], :void
+
+    callback :libusb_transfer_cb_fn, [:pointer], :void
+
+    class IsoPacketDescriptor < FFI::Struct
+      layout :length, :uint,
+          :actual_length, :uint,
+          :status, :libusb_transfer_status
+    end
+
+    # Setup packet for control transfers.
+    class ControlSetup < FFI::Struct
+      layout :bmRequestType, :uint8,
+          :bRequest, :uint8,
+          :wValue, :uint16,
+          :wIndex, :uint16,
+          :wLength, :uint16
+    end
+
+    class Transfer < FFI::ManagedStruct
+      layout :dev_handle, :libusb_device_handle,
+        :flags, :uint8,
+        :endpoint, :uchar,
+        :type, :uchar,
+        :timeout, :uint,
+        :status, :libusb_transfer_status,
+        :length, :int,
+        :actual_length, :int,
+        :callback, :libusb_transfer_cb_fn,
+        :user_data, :pointer,
+        :buffer, :pointer,
+        :num_iso_packets, :int
+
+      def self.release(ptr)
+        Call.libusb_free_transfer(ptr)
+      end
+    end
+
+    class DeviceDescriptor < FFI::Struct
+      include Comparable
+
+      layout :bLength, :uint8,
+          :bDescriptorType, :uint8,
+          :bcdUSB, :uint16,
+          :bDeviceClass, :uint8,
+          :bDeviceSubClass, :uint8,
+          :bDeviceProtocol, :uint8,
+          :bMaxPacketSize0, :uint8,
+          :idVendor, :uint16,
+          :idProduct, :uint16,
+          :bcdDevice, :uint16,
+          :iManufacturer, :uint8,
+          :iProduct, :uint8,
+          :iSerialNumber, :uint8,
+          :bNumConfigurations, :uint8
+    end
+
+    class Timeval < FFI::Struct
+      layout :tv_sec,  :long,
+        :tv_usec, :long
+
+      # set timeval to the number of milliseconds
+      # @param [Fixnum] value
+      def in_ms=(value)
+        self[:tv_sec], self[:tv_usec] = (value*1000).divmod(1000000)
+      end
+
+      # get the number of milliseconds in timeval
+      # @return [Fixnum]
+      def in_ms
+        self[:tv_sec]*1000 + self[:tv_usec]/1000
+      end
+
+      # set timeval to the number of seconds
+      # @param [Numeric] value
+      def in_s=(value)
+        self[:tv_sec], self[:tv_usec] = (value*1000000).divmod(1000000)
+      end
+
+      # get the number of seconds in timeval
+      # @return [Float]
+      def in_s
+        self[:tv_sec] + self[:tv_usec]/1000000.0
+      end
+    end
+
+    class Pollfd < FFI::Struct
+      layout :fd,  :int,
+          :events, :short
+    end
+  end
+end

data/lib/libusb/compat.rb

@@ -0,0 +1,376 @@
+# 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
+  @default_context = nil
+  def self.default_context
+    @default_context ||= LIBUSB::Context.new
+  end
+
+  @default_bus = nil
+  def self.default_bus
+    @default_bus ||= Bus.new(default_context)
+  end
+
+  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 = !FFI::Platform.windows?
+  HAS_DETACH_KERNEL_DRIVER_NP = !FFI::Platform.windows?
+
+  # 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
+    [default_bus]
+  end
+
+  def USB.devices; default_context.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)
+    default_bus
+  end
+
+  def USB.each_device_by_class(devclass, subclass=nil, protocol=nil)
+    devs = default_context.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
+
+  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
+          yield h
+        ensure
+          h.usb_close
+        end
+      else
+        h
+      end
+    end
+
+    def bus; default_bus; 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, :bMaxPower,
+        :inspect
+
+    def <=>(o)
+      @cd<=>o.instance_variable_get(:@cd)
+    end
+
+    def bus; default_bus; 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