smartcard 0.5.4 → 0.5.5

data/BUILD

@@ -75,3 +75,13 @@ Ubuntu (tested on 8.04, 8.10, 9.04 and 9.10):
 * libpcsclite-dev (depends on libpcsclite or libpcsclite1)
 * pcscd
 * pcsc-tools
+
+=== Fedora
+
+The following packages should do the trick on Fedora (tested on 18):
+* ruby-devel
+* pcsc-lite
+* pcsc-lite-ccid
+* pcsc-lite-devel
+* pcsc-lite-openct
+* pcsc-tools

data/CHANGELOG

@@ -1,3 +1,5 @@
+v0.5.5. Fixed crash in MRI 1.9.3.
+
 v0.5.4. Fixed ReaderStateQuery to work when the status has bits not defined in the PCSC header.
 
 v0.5.3. Fixed buggy protocol number decoding logic.
@@ -38,7 +40,7 @@ v0.3.1. Fixed documentation for the new PcscException class.
 
 v0.3.0. Added PcscException class used to wrap PC/SC exceptions.
 
-v0.2.3. Fixed minor bug in error string for PCSC::Card.transmit 
+v0.2.3. Fixed minor bug in error string for PCSC::Card.transmit
 
 v0.2.2. Fixed APDU exchange bugs on Windows
 	Restructured PCSC::IoRequest to allow PCI_ consts
@@ -51,7 +53,7 @@ v0.2.1. Added OSX Tiger support
 
 v0.2.0. Added automatic builds
 	Rakefile for auto builds using echoe
-	extconf.rb: hack to fix Windows makefiles 
+	extconf.rb: hack to fix Windows makefiles
 
 v0.1.2. Added Windows compatibility
 	*.c: restructured code so VC2005 likes it

data/Rakefile

@@ -1,26 +1,26 @@
 require 'rubygems'
 require 'echoe'
 
-require './tasks/ffi_codegen.rb' 
+require './tasks/ffi_codegen.rb'
 
 Echoe.new('smartcard') do |p|
   p.project = 'smartcard' # rubyforge project
-  
+
   p.author = 'Victor Costan'
   p.email = 'victor@costan.us'
   p.summary = 'Interface with ISO 7816 smart cards.'
   p.url = 'http://www.costan.us/smartcard'
-  p.dependencies = ['ffi >=0.5.3',
-                    'rubyzip >=0.9.1',
-                    'zerg_support >=0.1.5']
-  p.development_dependencies = ['echoe >=3.2',
-                                'flexmock >=0.8.6']
-  
+  p.dependencies = ['ffi >=1.2.0',
+                    'rubyzip >=0.9.9',
+                    'zerg_support >=0.1.6']
+  p.development_dependencies = ['echoe >=4.6.3',
+                                'flexmock >=1.2.0']
+
   p.need_tar_gz = !Gem.win_platform?
   p.need_zip = !Gem.win_platform?
   p.clean_pattern += ['ext/**/*.manifest', 'ext/**/*_autogen.h']
   p.rdoc_pattern =
-      /^(lib|bin|tasks|ext)|^BUILD|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/  
+      /^(lib|bin|tasks|ext)|^BUILD|^README|^CHANGELOG|^TODO|^LICENSE|^COPYING$/
 end
 
 file 'lib/smartcard/pcsc/ffi_autogen.rb' => 'tasks/ffi_codegen.rb' do

data/lib/smartcard/pcsc/card.rb

@@ -8,8 +8,8 @@ require 'set'
 
 # :nodoc: namespace
 module Smartcard::PCSC
-  
-  
+
+
 # Connects a smart-card in a PC/SC reader to the Ruby world.
 class Card
   # Establishes a connection to the card in a PC/SC reader.
@@ -19,10 +19,10 @@ class Card
   # Args:
   #   context:: the Smartcard::PCSC::Context for the PC/SC resource manager
   #   reader_name:: friendly name of the reader to connect to; reader names can
-  #                 be obtained from Smartcard::PCSC::Context#readers 
+  #                 be obtained from Smartcard::PCSC::Context#readers
   #   sharing_mode:: whether a shared or exclusive lock will be requested on the
   #                  reader; the possible values are +:shared+, +:exclusive+ and
-  #                  +:direct+ (see the SCARD_SHARE_ constants in the PC/SC API) 
+  #                  +:direct+ (see the SCARD_SHARE_ constants in the PC/SC API)
   #   preferred_protocols:: the desired communication protocol; the possible
   #                         values are +:t0+, +:t1+, +:t15+, +:raw+, and +:any+
   #                         (see the SCARD_PROTOCOL_ constants in the PC/SC API)
@@ -33,13 +33,13 @@ class Card
     status = FFILib.card_connect context._handle, reader_name, sharing_mode,
                                  preferred_protocols, handle_ptr, protocol_ptr
     raise Smartcard::PCSC::Exception, status unless status == :success
-    
+
     @context = context
     @sharing_mode = sharing_mode
     @_handle = handle_ptr[:value]
     set_protocol FFILib::PROTOCOLS[protocol_ptr[:value]]
   end
-  
+
   # Updates internal buffers to reflect a change in the communication protocol.
   #
   # Args:
@@ -47,36 +47,32 @@ class Card
   #              used to guess a valid protocol
   def set_protocol(protocol)
     @protocol = protocol
-    
+
     case protocol
     when :t0
-      @send_pci = @recv_pci = FFILib::PCI_T0
+      @send_pci = FFILib::PCI_T0
     when :t1
-      @send_pci = @recv_pci = FFILib::PCI_T1
+      @send_pci = FFILib::PCI_T1
     when :raw
-      @send_pci = @recv_pci = FFILib::PCI_RAW
+      @send_pci = FFILib::PCI_RAW
     else
       reconnect sharing_mode, guess_protocol_from_atr, :leave
-      return self      
-    end
-    
-    # Windows really doesn't like a receiving IoRequest.
-    if FFI::Platform.windows? || FFI::Platform.mac?
-      @recv_pci = nil
+      return self
     end
+
     self
   end
   private :set_protocol
-  
+
   # Reconnects to the smart-card, potentially using a different protocol.
   #
   # Args:
   #   sharing_mode:: whether a shared or exclusive lock will be requested on the
   #                  reader; the possible values are +:shared+, +:exclusive+ and
-  #                  +:direct+ (see the SCARD_SHARE_ constants in the PC/SC API) 
+  #                  +:direct+ (see the SCARD_SHARE_ constants in the PC/SC API)
   #   preferred_protocols:: the desired communication protocol; the possible
   #                         values are +:t0+, +:t1+, +:t15+, +:raw+, and +:any+
-  #                         (see the SCARD_PROTOCOL_ constants in the PC/SC API)  
+  #                         (see the SCARD_PROTOCOL_ constants in the PC/SC API)
   #   disposition:: what to do with the smart-card right before disconnecting;
   #                 the possible values are +:leave+, +:reset+, +:unpower+, and
   #                 +:eject+ (see the SCARD_*_CARD constants in the PC/SC API)
@@ -86,11 +82,11 @@ class Card
     status = FFILib.card_reconnect @_handle, sharing_mode,
         preferred_protocols, disposition, protocol_ptr
     raise Smartcard::PCSC::Exception, status unless status == :success
-  
+
     @sharing_mode = sharing_mode
     set_protocol FFILib::Protocol[protocol_ptr[:value]]
   end
-  
+
   # Disconnects from the smart-card.
   #
   # Future method calls on this object will raise PC/SC errors.
@@ -110,9 +106,9 @@ class Card
   # Starts a transaction, obtaining an exclusive lock on the smart-card.
   def begin_transaction
     status = FFILib.begin_transaction @_handle
-    raise Smartcard::PCSC::Exception, status unless status == :success    
+    raise Smartcard::PCSC::Exception, status unless status == :success
   end
-  
+
   # Ends a transaction started with begin_transaction.
   #
   # The calling application must be the owner of the previously started
@@ -126,7 +122,7 @@ class Card
     status = FFILib.end_transaction @_handle, disposition
     raise Smartcard::PCSC::Exception, status unless status == :success
   end
-  
+
   # Performs a block inside a transaction, with an exclusive smart-card lock.
   #
   # Args:
@@ -138,8 +134,8 @@ class Card
     yield
     end_transaction disposition
   end
-  
-  
+
+
   def [](attribute_name)
     length_ptr = FFILib::WordPtr.new
     status = FFILib.get_attrib @_handle, attribute_name, nil, length_ptr
@@ -150,13 +146,13 @@ class Card
       status = FFILib.get_attrib @_handle, attribute_name, value_ptr,
                                  length_ptr
       raise Smartcard::PCSC::Exception, status unless status == :success
-  
+
       value_ptr.get_bytes 0, length_ptr[:value]
     ensure
       value_ptr.free
-    end      
+    end
   end
-  
+
   # Sets the value of an attribute in the interface driver.
   #
   # The interface driver may not implement all possible attributes.
@@ -171,34 +167,34 @@ class Card
     begin
       status = FFILib.set_attrib @_handle, attribute_name, value_ptr,
                                  value.length
-      raise Smartcard::PCSC::Exception, status unless status == :success    
+      raise Smartcard::PCSC::Exception, status unless status == :success
       value
     ensure
-      value_ptr.free    
+      value_ptr.free
     end
   end
-  
+
   # Sends an APDU to the smart card, and returns the card's response.
   #
   # Args:
   #   send_data:: string containing the APDU bytes to be sent to the card
-  #   receive_buffer_size: the maximum number of bytes that can be received  
+  #   receive_buffer_size: the maximum number of bytes that can be received
   def transmit(data, receive_buffer_size = 65546)
     send_ptr = FFI::MemoryPointer.from_string data
     recv_ptr = FFI::MemoryPointer.new receive_buffer_size
     recv_size_ptr = FFILib::WordPtr.new
-    recv_size_ptr[:value] = receive_buffer_size 
+    recv_size_ptr[:value] = receive_buffer_size
     begin
       status = FFILib.transmit @_handle, @send_pci, send_ptr, data.length,
-                               @recv_pci, recv_ptr, recv_size_ptr
-      raise Smartcard::PCSC::Exception, status unless status == :success    
+                               nil, recv_ptr, recv_size_ptr
+      raise Smartcard::PCSC::Exception, status unless status == :success
       recv_ptr.get_bytes 0, recv_size_ptr[:value]
     ensure
       send_ptr.free
       recv_ptr.free
-    end    
+    end
   end
-  
+
   # Sends a interface driver command for the smart-card reader.
   #
   # This method is useful for creating client side reader drivers for functions
@@ -220,20 +216,20 @@ class Card
     send_ptr = FFI::MemoryPointer.from_string data
     recv_ptr = FFI::MemoryPointer.new receive_buffer_size
     recv_size_ptr = FFILib::WordPtr.new
-    recv_size_ptr[:value] = receive_buffer_size 
+    recv_size_ptr[:value] = receive_buffer_size
     begin
       status = FFILib.card_control @_handle, code, send_ptr, data.length,
                                    recv_ptr, receive_buffer_size, recv_size_ptr
-      raise Smartcard::PCSC::Exception, status unless status == :success    
+      raise Smartcard::PCSC::Exception, status unless status == :success
       recv_ptr.get_bytes 0, recv_size_ptr[:value]
     ensure
       send_ptr.free
       recv_ptr.free
     end
   end
-  
+
   # Assorted information about this smart-card.
-  # 
+  #
   # Returns a hash with the following keys:
   #   :state:: reader/card status, as a Set of symbols; the possible values are
   #            +:present+, +:swallowed+, +:absent+, +:specific+, and +:powered+
@@ -248,25 +244,25 @@ class Card
     protocol_ptr = FFILib::WordPtr.new
     atr_ptr = FFI::MemoryPointer.new FFILib::Consts::MAX_ATR_SIZE
     atr_length_ptr = FFILib::WordPtr.new
-    atr_length_ptr[:value] = FFILib::Consts::MAX_ATR_SIZE    
+    atr_length_ptr[:value] = FFILib::Consts::MAX_ATR_SIZE
 
     begin
       status = FFILib.card_status @_handle, nil, readers_length_ptr, state_ptr,
           protocol_ptr, atr_ptr, atr_length_ptr
-      raise Smartcard::PCSC::Exception, status unless status == :success    
+      raise Smartcard::PCSC::Exception, status unless status == :success
 
       readers_ptr = FFI::MemoryPointer.new :char, readers_length_ptr[:value]
       begin
         status = FFILib.card_status @_handle, readers_ptr, readers_length_ptr,
             state_ptr, protocol_ptr, atr_ptr, atr_length_ptr
-        raise Smartcard::PCSC::Exception, status unless status == :success    
-      
+        raise Smartcard::PCSC::Exception, status unless status == :success
+
         state_word = state_ptr[:value]
         state = Set.new
         FFILib::CardState.to_h.each do |key, mask|
           state << key if (state_word & mask) == mask && mask != 0
         end
-        
+
         { :readers => Context.decode_multi_string(readers_ptr),
           :protocol => FFILib::PROTOCOLS[protocol_ptr[:value]],
           :atr => atr_ptr.get_bytes(0, atr_length_ptr[:value]),
@@ -278,11 +274,11 @@ class Card
       atr_ptr.free
     end
   end
-  
-  # Returns the first valid protocol listed in the card's ATR.  
+
+  # Returns the first valid protocol listed in the card's ATR.
   def guess_protocol_from_atr
     atr = info[:atr]
-    
+
     # NOTE: inspired from the following sources:
     #       http://en.wikipedia.org/wiki/Answer_to_reset
     #       http://www.atmel.com/dyn/resources/prod_documents/doc5025.pdf
@@ -295,13 +291,13 @@ class Card
       next_bits = (0...4).map { |j| (next_nibble >> j) & 1 }
       next_bits.each { |bit| i += bit }
       if next_bits[3] == 1  # TD byte was last, i is right on it
-        protocols << (atr_bytes[i] & 0x0f)                
+        protocols << (atr_bytes[i] & 0x0f)
       else
         break  # No TD, no more bytes
       end
     end
 
-    protocols.sort!    
+    protocols.sort!
     case protocols[0]
     when 0
       :t0
@@ -312,15 +308,15 @@ class Card
     end
   end
   private :guess_protocol_from_atr
-  
+
   # The low-level _SCARDHANDLE_ data.
   #
   # This should not be used by client code.
   attr_reader :_handle
-  
+
   # The communication protocol in use with this smart-card.
   attr_reader :protocol
-  
+
   # The sharing mode for this smart-card session. (:shared or :exclusive)
   attr_reader :sharing_mode
 end  # class Smartcard::PCSC::Card

data/lib/smartcard/pcsc/ffi_autogen.rb

@@ -7,214 +7,214 @@ module Smartcard::PCSC
 module FFILib
   # Constant values extracted from headers.
   module Consts
-    SCARD_E_INVALID_VALUE = 0x80100011
-    SCARD_E_NO_SERVICE = 0x8010001D
-    SCARD_E_UNSUPPORTED_FEATURE = 0x8010001F
-    SCARD_E_INVALID_ATR = 0x80100015
-    SCARD_E_DUPLICATE_READER = 0x8010001B
-    SCARD_W_UNSUPPORTED_CARD = 0x80100065
-    SCARD_E_UNKNOWN_CARD = 0x8010000D
-    SCARD_E_UNEXPECTED = 0x8010001F
-    SCARD_E_SERVER_TOO_BUSY = 0x80100031
-    SCARD_W_UNPOWERED_CARD = 0x80100067
-    SCARD_W_CANCELLED_BY_USER = 0x8010006E
+    SCARD_S_SUCCESS = 0x00000000
     SCARD_E_CANCELLED = 0x80100002
-    SCARD_E_INVALID_CHV = 0x8010002A
-    SCARD_E_CERTIFICATE_UNAVAILABLE = 0x8010002D
-    SCARD_W_SECURITY_VIOLATION = 0x8010006A
+    SCARD_E_INVALID_HANDLE = 0x80100003
     SCARD_E_INVALID_PARAMETER = 0x80100004
-    SCARD_E_SYSTEM_CANCELLED = 0x80100012
-    SCARD_E_NO_KEY_CONTAINER = 0x80100030
+    SCARD_E_INVALID_TARGET = 0x80100005
+    SCARD_E_NO_MEMORY = 0x80100006
+    SCARD_E_INSUFFICIENT_BUFFER = 0x80100008
+    SCARD_E_UNKNOWN_READER = 0x80100009
+    SCARD_E_TIMEOUT = 0x8010000A
+    SCARD_E_SHARING_VIOLATION = 0x8010000B
+    SCARD_E_NO_SMARTCARD = 0x8010000C
+    SCARD_E_UNKNOWN_CARD = 0x8010000D
+    SCARD_E_CANT_DISPOSE = 0x8010000E
+    SCARD_E_PROTO_MISMATCH = 0x8010000F
     SCARD_E_NOT_READY = 0x80100010
+    SCARD_E_INVALID_VALUE = 0x80100011
+    SCARD_E_SYSTEM_CANCELLED = 0x80100012
+    SCARD_E_INVALID_ATR = 0x80100015
     SCARD_E_NOT_TRANSACTED = 0x80100016
     SCARD_E_READER_UNAVAILABLE = 0x80100017
+    SCARD_E_PCI_TOO_SMALL = 0x80100019
     SCARD_E_READER_UNSUPPORTED = 0x8010001A
+    SCARD_E_DUPLICATE_READER = 0x8010001B
     SCARD_E_CARD_UNSUPPORTED = 0x8010001C
-    SCARD_E_INVALID_TARGET = 0x80100005
-    SCARD_E_NO_MEMORY = 0x80100006
-    SCARD_E_UNKNOWN_READER = 0x80100009
-    SCARD_E_NO_SMARTCARD = 0x8010000C
+    SCARD_E_NO_SERVICE = 0x8010001D
+    SCARD_E_SERVICE_STOPPED = 0x8010001E
+    SCARD_E_UNEXPECTED = 0x8010001F
+    SCARD_E_UNSUPPORTED_FEATURE = 0x8010001F
     SCARD_E_ICC_INSTALLATION = 0x80100020
+    SCARD_E_ICC_CREATEORDER = 0x80100021
+    SCARD_E_DIR_NOT_FOUND = 0x80100023
     SCARD_E_FILE_NOT_FOUND = 0x80100024
-    SCARD_E_NO_SUCH_CERTIFICATE = 0x8010002C
-    SCARD_W_WRONG_CHV = 0x8010006B
+    SCARD_E_NO_DIR = 0x80100025
+    SCARD_E_NO_FILE = 0x80100026
     SCARD_E_NO_ACCESS = 0x80100027
     SCARD_E_WRITE_TOO_MANY = 0x80100028
-    SCARD_W_EOF = 0x8010006D
-    SCARD_E_INVALID_HANDLE = 0x80100003
-    SCARD_E_CANT_DISPOSE = 0x8010000E
-    SCARD_E_SERVICE_STOPPED = 0x8010001E
-    SCARD_E_ICC_CREATEORDER = 0x80100021
-    SCARD_E_NO_FILE = 0x80100026
+    SCARD_E_BAD_SEEK = 0x80100029
+    SCARD_E_INVALID_CHV = 0x8010002A
+    SCARD_E_UNKNOWN_RES_MNG = 0x8010002B
+    SCARD_E_NO_SUCH_CERTIFICATE = 0x8010002C
+    SCARD_E_CERTIFICATE_UNAVAILABLE = 0x8010002D
     SCARD_E_NO_READERS_AVAILABLE = 0x8010002E
     SCARD_E_COMM_DATA_LOST = 0x8010002F
-    SCARD_E_TIMEOUT = 0x8010000A
-    SCARD_E_SHARING_VIOLATION = 0x8010000B
-    SCARD_E_PROTO_MISMATCH = 0x8010000F
-    SCARD_E_PCI_TOO_SMALL = 0x80100019
+    SCARD_E_NO_KEY_CONTAINER = 0x80100030
+    SCARD_E_SERVER_TOO_BUSY = 0x80100031
+    SCARD_W_UNSUPPORTED_CARD = 0x80100065
+    SCARD_W_UNRESPONSIVE_CARD = 0x80100066
+    SCARD_W_UNPOWERED_CARD = 0x80100067
     SCARD_W_RESET_CARD = 0x80100068
     SCARD_W_REMOVED_CARD = 0x80100069
-    SCARD_S_SUCCESS = 0x00000000
-    SCARD_E_INSUFFICIENT_BUFFER = 0x80100008
-    SCARD_E_DIR_NOT_FOUND = 0x80100023
-    SCARD_E_NO_DIR = 0x80100025
-    SCARD_E_BAD_SEEK = 0x80100029
-    SCARD_E_UNKNOWN_RES_MNG = 0x8010002B
-    SCARD_W_UNRESPONSIVE_CARD = 0x80100066
+    SCARD_W_SECURITY_VIOLATION = 0x8010006A
+    SCARD_W_WRONG_CHV = 0x8010006B
     SCARD_W_CHV_BLOCKED = 0x8010006C
+    SCARD_W_EOF = 0x8010006D
+    SCARD_W_CANCELLED_BY_USER = 0x8010006E
     SCARD_W_CARD_NOT_AUTHENTICATED = 0x8010006F
     SCARD_SCOPE_USER = 0x00000000
-    SCARD_SCOPE_SYSTEM = 0x00000002
     SCARD_SCOPE_TERMINAL = 0x00000001
+    SCARD_SCOPE_SYSTEM = 0x00000002
     SCARD_PROTOCOL_UNDEFINED = 0x00000000
     SCARD_PROTOCOL_UNSET = 0x00000000
     SCARD_PROTOCOL_T0 = 0x00000001
     SCARD_PROTOCOL_T1 = 0x00000002
     SCARD_PROTOCOL_RAW = 0x00000004
-    SCARD_PROTOCOL_ANY = 0x00000003
     SCARD_PROTOCOL_T15 = 0x00000008
+    SCARD_PROTOCOL_ANY = 0x00000003
+    SCARD_SHARE_EXCLUSIVE = 0x00000001
     SCARD_SHARE_SHARED = 0x00000002
     SCARD_SHARE_DIRECT = 0x00000003
-    SCARD_SHARE_EXCLUSIVE = 0x00000001
-    SCARD_EJECT_CARD = 0x00000003
-    SCARD_UNPOWER_CARD = 0x00000002
     SCARD_LEAVE_CARD = 0x00000000
     SCARD_RESET_CARD = 0x00000001
+    SCARD_UNPOWER_CARD = 0x00000002
+    SCARD_EJECT_CARD = 0x00000003
+    SCARD_ATTR_VENDOR_NAME = 0x00010100
+    SCARD_ATTR_VENDOR_IFD_TYPE = 0x00010101
+    SCARD_ATTR_VENDOR_IFD_VERSION = 0x00010102
+    SCARD_ATTR_VENDOR_IFD_SERIAL_NO = 0x00010103
+    SCARD_ATTR_CHANNEL_ID = 0x00020110
+    SCARD_ATTR_ASYNC_PROTOCOL_TYPES = 0x00030120
+    SCARD_ATTR_DEFAULT_CLK = 0x00030121
+    SCARD_ATTR_MAX_CLK = 0x00030122
+    SCARD_ATTR_DEFAULT_DATA_RATE = 0x00030123
+    SCARD_ATTR_MAX_DATA_RATE = 0x00030124
+    SCARD_ATTR_MAX_IFSD = 0x00030125
     SCARD_ATTR_SYNC_PROTOCOL_TYPES = 0x00030126
-    SCARD_ATTR_CURRENT_CLK = 0x00080202
-    SCARD_ATTR_CURRENT_EBC_ENCODING = 0x0008020B
+    SCARD_ATTR_POWER_MGMT_SUPPORT = 0x00040131
     SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE = 0x00050140
+    SCARD_ATTR_USER_AUTH_INPUT_DEVICE = 0x00050142
+    SCARD_ATTR_CHARACTERISTICS = 0x00060150
+    SCARD_ATTR_CURRENT_PROTOCOL_TYPE = 0x00080201
+    SCARD_ATTR_CURRENT_CLK = 0x00080202
     SCARD_ATTR_CURRENT_F = 0x00080203
     SCARD_ATTR_CURRENT_D = 0x00080204
     SCARD_ATTR_CURRENT_N = 0x00080205
     SCARD_ATTR_CURRENT_W = 0x00080206
-    SCARD_ATTR_DEVICE_FRIENDLY_NAME = 0x7FFF0003
-    SCARD_ATTR_VENDOR_IFD_SERIAL_NO = 0x00010103
-    SCARD_ATTR_ESC_RESET = 0x0007A000
-    SCARD_ATTR_CHARACTERISTICS = 0x00060150
     SCARD_ATTR_CURRENT_IFSC = 0x00080207
     SCARD_ATTR_CURRENT_IFSD = 0x00080208
-    SCARD_ATTR_MAX_CLK = 0x00030122
-    SCARD_ATTR_MAX_DATA_RATE = 0x00030124
-    SCARD_ATTR_CURRENT_PROTOCOL_TYPE = 0x00080201
+    SCARD_ATTR_CURRENT_BWT = 0x00080209
+    SCARD_ATTR_CURRENT_CWT = 0x0008020A
+    SCARD_ATTR_CURRENT_EBC_ENCODING = 0x0008020B
+    SCARD_ATTR_EXTENDED_BWT = 0x0008020C
+    SCARD_ATTR_ICC_PRESENCE = 0x00090300
+    SCARD_ATTR_ICC_INTERFACE_STATUS = 0x00090301
+    SCARD_ATTR_CURRENT_IO_STATE = 0x00090302
     SCARD_ATTR_ATR_STRING = 0x00090303
+    SCARD_ATTR_ICC_TYPE_PER_ATR = 0x00090304
+    SCARD_ATTR_ESC_RESET = 0x0007A000
+    SCARD_ATTR_ESC_CANCEL = 0x0007A003
     SCARD_ATTR_ESC_AUTHREQUEST = 0x0007A005
-    SCARD_ATTR_DEVICE_SYSTEM_NAME_A = 0x7FFF0004
-    SCARD_ATTR_DEVICE_SYSTEM_NAME_W = 0x7FFF0006
-    SCARD_ATTR_DEFAULT_CLK = 0x00030121
-    SCARD_ATTR_MAX_IFSD = 0x00030125
-    SCARD_ATTR_VENDOR_NAME = 0x00010100
-    SCARD_ATTR_ASYNC_PROTOCOL_TYPES = 0x00030120
+    SCARD_ATTR_MAXINPUT = 0x0007A007
     SCARD_ATTR_DEVICE_UNIT = 0x7FFF0001
+    SCARD_ATTR_DEVICE_IN_USE = 0x7FFF0002
     SCARD_ATTR_DEVICE_FRIENDLY_NAME_A = 0x7FFF0003
+    SCARD_ATTR_DEVICE_SYSTEM_NAME_A = 0x7FFF0004
     SCARD_ATTR_DEVICE_FRIENDLY_NAME_W = 0x7FFF0005
+    SCARD_ATTR_DEVICE_SYSTEM_NAME_W = 0x7FFF0006
     SCARD_ATTR_SUPRESS_T1_IFS_REQUEST = 0x7FFF0007
-    SCARD_ATTR_CURRENT_BWT = 0x00080209
-    SCARD_ATTR_CURRENT_CWT = 0x0008020A
-    SCARD_ATTR_ICC_PRESENCE = 0x00090300
-    SCARD_ATTR_ESC_CANCEL = 0x0007A003
-    SCARD_ATTR_DEVICE_IN_USE = 0x7FFF0002
-    SCARD_ATTR_USER_AUTH_INPUT_DEVICE = 0x00050142
-    SCARD_ATTR_CURRENT_IO_STATE = 0x00090302
+    SCARD_ATTR_DEVICE_FRIENDLY_NAME = 0x7FFF0003
     SCARD_ATTR_DEVICE_SYSTEM_NAME = 0x7FFF0004
-    SCARD_ATTR_VENDOR_IFD_TYPE = 0x00010101
-    SCARD_ATTR_DEFAULT_DATA_RATE = 0x00030123
-    SCARD_ATTR_ICC_TYPE_PER_ATR = 0x00090304
-    SCARD_ATTR_VENDOR_IFD_VERSION = 0x00010102
-    SCARD_ATTR_CHANNEL_ID = 0x00020110
-    SCARD_ATTR_POWER_MGMT_SUPPORT = 0x00040131
-    SCARD_ATTR_EXTENDED_BWT = 0x0008020C
-    SCARD_ATTR_ICC_INTERFACE_STATUS = 0x00090301
-    SCARD_ATTR_MAXINPUT = 0x0007A007
-    SCARD_STATE_CHANGED = 0x00000002
-    SCARD_STATE_MUTE = 0x00000200
+    SCARD_STATE_UNAWARE = 0x00000000
     SCARD_STATE_IGNORE = 0x00000001
+    SCARD_STATE_CHANGED = 0x00000002
+    SCARD_STATE_UNKNOWN = 0x00000004
     SCARD_STATE_UNAVAILABLE = 0x00000008
     SCARD_STATE_EMPTY = 0x00000010
-    SCARD_STATE_UNKNOWN = 0x00000004
-    SCARD_STATE_ATRMATCH = 0x00000040
     SCARD_STATE_PRESENT = 0x00000020
+    SCARD_STATE_ATRMATCH = 0x00000040
     SCARD_STATE_EXCLUSIVE = 0x00000080
     SCARD_STATE_INUSE = 0x00000100
+    SCARD_STATE_MUTE = 0x00000200
     SCARD_STATE_UNPOWERED = 0x00000400
-    SCARD_STATE_UNAWARE = 0x00000000
-    SCARD_PRESENT = 0x00000004
     SCARD_AUTOALLOCATE = 0xFFFFFFFF
+    SCARD_UNKNOWN = 0x00000001
     SCARD_ABSENT = 0x00000002
+    SCARD_PRESENT = 0x00000004
     SCARD_SWALLOWED = 0x00000008
-    SCARD_UNKNOWN = 0x00000001
     SCARD_POWERED = 0x00000010
-    SCARD_SPECIFIC = 0x00000040
     SCARD_NEGOTIABLE = 0x00000020
+    SCARD_SPECIFIC = 0x00000040
     MAX_ATR_SIZE = 0x00000021
     INFINITE = 0xFFFFFFFF
   end  # module Smartcard::PCSC::FFILib::Consts
 
   # Error codes returned by the PCSC functions.
   Status = enum [
-    :invalid_value, Consts::SCARD_E_INVALID_VALUE,
-    :no_service, Consts::SCARD_E_NO_SERVICE,
-    :unsupported_feature, Consts::SCARD_E_UNSUPPORTED_FEATURE,
-    :invalid_atr, Consts::SCARD_E_INVALID_ATR,
-    :duplicate_reader, Consts::SCARD_E_DUPLICATE_READER,
-    :unsupported_card, Consts::SCARD_W_UNSUPPORTED_CARD,
-    :unknown_card, Consts::SCARD_E_UNKNOWN_CARD,
-    :unexpected, Consts::SCARD_E_UNEXPECTED,
-    :server_too_busy, Consts::SCARD_E_SERVER_TOO_BUSY,
-    :unpowered_card, Consts::SCARD_W_UNPOWERED_CARD,
-    :cancelled_by_user, Consts::SCARD_W_CANCELLED_BY_USER,
+    :success, Consts::SCARD_S_SUCCESS,
     :cancelled, Consts::SCARD_E_CANCELLED,
-    :invalid_chv, Consts::SCARD_E_INVALID_CHV,
-    :certificate_unavailable, Consts::SCARD_E_CERTIFICATE_UNAVAILABLE,
-    :security_violation, Consts::SCARD_W_SECURITY_VIOLATION,
+    :invalid_handle, Consts::SCARD_E_INVALID_HANDLE,
     :invalid_parameter, Consts::SCARD_E_INVALID_PARAMETER,
-    :system_cancelled, Consts::SCARD_E_SYSTEM_CANCELLED,
-    :no_key_container, Consts::SCARD_E_NO_KEY_CONTAINER,
+    :invalid_target, Consts::SCARD_E_INVALID_TARGET,
+    :no_memory, Consts::SCARD_E_NO_MEMORY,
+    :insufficient_buffer, Consts::SCARD_E_INSUFFICIENT_BUFFER,
+    :unknown_reader, Consts::SCARD_E_UNKNOWN_READER,
+    :timeout, Consts::SCARD_E_TIMEOUT,
+    :sharing_violation, Consts::SCARD_E_SHARING_VIOLATION,
+    :no_smartcard, Consts::SCARD_E_NO_SMARTCARD,
+    :unknown_card, Consts::SCARD_E_UNKNOWN_CARD,
+    :cant_dispose, Consts::SCARD_E_CANT_DISPOSE,
+    :proto_mismatch, Consts::SCARD_E_PROTO_MISMATCH,
     :not_ready, Consts::SCARD_E_NOT_READY,
+    :invalid_value, Consts::SCARD_E_INVALID_VALUE,
+    :system_cancelled, Consts::SCARD_E_SYSTEM_CANCELLED,
+    :invalid_atr, Consts::SCARD_E_INVALID_ATR,
     :not_transacted, Consts::SCARD_E_NOT_TRANSACTED,
     :reader_unavailable, Consts::SCARD_E_READER_UNAVAILABLE,
+    :pci_too_small, Consts::SCARD_E_PCI_TOO_SMALL,
     :reader_unsupported, Consts::SCARD_E_READER_UNSUPPORTED,
+    :duplicate_reader, Consts::SCARD_E_DUPLICATE_READER,
     :card_unsupported, Consts::SCARD_E_CARD_UNSUPPORTED,
-    :invalid_target, Consts::SCARD_E_INVALID_TARGET,
-    :no_memory, Consts::SCARD_E_NO_MEMORY,
-    :unknown_reader, Consts::SCARD_E_UNKNOWN_READER,
-    :no_smartcard, Consts::SCARD_E_NO_SMARTCARD,
+    :no_service, Consts::SCARD_E_NO_SERVICE,
+    :service_stopped, Consts::SCARD_E_SERVICE_STOPPED,
+    :unexpected, Consts::SCARD_E_UNEXPECTED,
+    :unsupported_feature, Consts::SCARD_E_UNSUPPORTED_FEATURE,
     :icc_installation, Consts::SCARD_E_ICC_INSTALLATION,
+    :icc_createorder, Consts::SCARD_E_ICC_CREATEORDER,
+    :dir_not_found, Consts::SCARD_E_DIR_NOT_FOUND,
     :file_not_found, Consts::SCARD_E_FILE_NOT_FOUND,
-    :no_such_certificate, Consts::SCARD_E_NO_SUCH_CERTIFICATE,
-    :wrong_chv, Consts::SCARD_W_WRONG_CHV,
+    :no_dir, Consts::SCARD_E_NO_DIR,
+    :no_file, Consts::SCARD_E_NO_FILE,
     :no_access, Consts::SCARD_E_NO_ACCESS,
     :write_too_many, Consts::SCARD_E_WRITE_TOO_MANY,
-    :eof, Consts::SCARD_W_EOF,
-    :invalid_handle, Consts::SCARD_E_INVALID_HANDLE,
-    :cant_dispose, Consts::SCARD_E_CANT_DISPOSE,
-    :service_stopped, Consts::SCARD_E_SERVICE_STOPPED,
-    :icc_createorder, Consts::SCARD_E_ICC_CREATEORDER,
-    :no_file, Consts::SCARD_E_NO_FILE,
+    :bad_seek, Consts::SCARD_E_BAD_SEEK,
+    :invalid_chv, Consts::SCARD_E_INVALID_CHV,
+    :unknown_res_mng, Consts::SCARD_E_UNKNOWN_RES_MNG,
+    :no_such_certificate, Consts::SCARD_E_NO_SUCH_CERTIFICATE,
+    :certificate_unavailable, Consts::SCARD_E_CERTIFICATE_UNAVAILABLE,
     :no_readers_available, Consts::SCARD_E_NO_READERS_AVAILABLE,
     :comm_data_lost, Consts::SCARD_E_COMM_DATA_LOST,
-    :timeout, Consts::SCARD_E_TIMEOUT,
-    :sharing_violation, Consts::SCARD_E_SHARING_VIOLATION,
-    :proto_mismatch, Consts::SCARD_E_PROTO_MISMATCH,
-    :pci_too_small, Consts::SCARD_E_PCI_TOO_SMALL,
+    :no_key_container, Consts::SCARD_E_NO_KEY_CONTAINER,
+    :server_too_busy, Consts::SCARD_E_SERVER_TOO_BUSY,
+    :unsupported_card, Consts::SCARD_W_UNSUPPORTED_CARD,
+    :unresponsive_card, Consts::SCARD_W_UNRESPONSIVE_CARD,
+    :unpowered_card, Consts::SCARD_W_UNPOWERED_CARD,
     :reset_card, Consts::SCARD_W_RESET_CARD,
     :removed_card, Consts::SCARD_W_REMOVED_CARD,
-    :success, Consts::SCARD_S_SUCCESS,
-    :insufficient_buffer, Consts::SCARD_E_INSUFFICIENT_BUFFER,
-    :dir_not_found, Consts::SCARD_E_DIR_NOT_FOUND,
-    :no_dir, Consts::SCARD_E_NO_DIR,
-    :bad_seek, Consts::SCARD_E_BAD_SEEK,
-    :unknown_res_mng, Consts::SCARD_E_UNKNOWN_RES_MNG,
-    :unresponsive_card, Consts::SCARD_W_UNRESPONSIVE_CARD,
+    :security_violation, Consts::SCARD_W_SECURITY_VIOLATION,
+    :wrong_chv, Consts::SCARD_W_WRONG_CHV,
     :chv_blocked, Consts::SCARD_W_CHV_BLOCKED,
+    :eof, Consts::SCARD_W_EOF,
+    :cancelled_by_user, Consts::SCARD_W_CANCELLED_BY_USER,
     :card_not_authenticated, Consts::SCARD_W_CARD_NOT_AUTHENTICATED,
   ]
 
   # Values for the context's scope.
   Scope = enum [
     :user, Consts::SCARD_SCOPE_USER,
-    :system, Consts::SCARD_SCOPE_SYSTEM,
     :terminal, Consts::SCARD_SCOPE_TERMINAL,
+    :system, Consts::SCARD_SCOPE_SYSTEM,
   ]
 
   # Smart-card communication protocols.
@@ -224,101 +224,101 @@ module FFILib
     :t0, Consts::SCARD_PROTOCOL_T0,
     :t1, Consts::SCARD_PROTOCOL_T1,
     :raw, Consts::SCARD_PROTOCOL_RAW,
-    :any, Consts::SCARD_PROTOCOL_ANY,
     :t15, Consts::SCARD_PROTOCOL_T15,
+    :any, Consts::SCARD_PROTOCOL_ANY,
   ]
 
   # Smart-card sharing modes.
   Share = enum [
+    :exclusive, Consts::SCARD_SHARE_EXCLUSIVE,
     :shared, Consts::SCARD_SHARE_SHARED,
     :direct, Consts::SCARD_SHARE_DIRECT,
-    :exclusive, Consts::SCARD_SHARE_EXCLUSIVE,
   ]
 
   # Smart-card dispositions.
   Disposition = enum [
-    :eject, Consts::SCARD_EJECT_CARD,
-    :unpower, Consts::SCARD_UNPOWER_CARD,
     :leave, Consts::SCARD_LEAVE_CARD,
     :reset, Consts::SCARD_RESET_CARD,
+    :unpower, Consts::SCARD_UNPOWER_CARD,
+    :eject, Consts::SCARD_EJECT_CARD,
   ]
 
   # Smart-card reader attributes.
   Attribute = enum [
+    :vendor_name, Consts::SCARD_ATTR_VENDOR_NAME,
+    :vendor_ifd_type, Consts::SCARD_ATTR_VENDOR_IFD_TYPE,
+    :vendor_ifd_version, Consts::SCARD_ATTR_VENDOR_IFD_VERSION,
+    :vendor_ifd_serial_no, Consts::SCARD_ATTR_VENDOR_IFD_SERIAL_NO,
+    :channel_id, Consts::SCARD_ATTR_CHANNEL_ID,
+    :async_protocol_types, Consts::SCARD_ATTR_ASYNC_PROTOCOL_TYPES,
+    :default_clk, Consts::SCARD_ATTR_DEFAULT_CLK,
+    :max_clk, Consts::SCARD_ATTR_MAX_CLK,
+    :default_data_rate, Consts::SCARD_ATTR_DEFAULT_DATA_RATE,
+    :max_data_rate, Consts::SCARD_ATTR_MAX_DATA_RATE,
+    :max_ifsd, Consts::SCARD_ATTR_MAX_IFSD,
     :sync_protocol_types, Consts::SCARD_ATTR_SYNC_PROTOCOL_TYPES,
-    :current_clk, Consts::SCARD_ATTR_CURRENT_CLK,
-    :current_ebc_encoding, Consts::SCARD_ATTR_CURRENT_EBC_ENCODING,
+    :power_mgmt_support, Consts::SCARD_ATTR_POWER_MGMT_SUPPORT,
     :user_to_card_auth_device, Consts::SCARD_ATTR_USER_TO_CARD_AUTH_DEVICE,
+    :user_auth_input_device, Consts::SCARD_ATTR_USER_AUTH_INPUT_DEVICE,
+    :characteristics, Consts::SCARD_ATTR_CHARACTERISTICS,
+    :current_protocol_type, Consts::SCARD_ATTR_CURRENT_PROTOCOL_TYPE,
+    :current_clk, Consts::SCARD_ATTR_CURRENT_CLK,
     :current_f, Consts::SCARD_ATTR_CURRENT_F,
     :current_d, Consts::SCARD_ATTR_CURRENT_D,
     :current_n, Consts::SCARD_ATTR_CURRENT_N,
     :current_w, Consts::SCARD_ATTR_CURRENT_W,
-    :device_friendly_name, Consts::SCARD_ATTR_DEVICE_FRIENDLY_NAME,
-    :vendor_ifd_serial_no, Consts::SCARD_ATTR_VENDOR_IFD_SERIAL_NO,
-    :esc_reset, Consts::SCARD_ATTR_ESC_RESET,
-    :characteristics, Consts::SCARD_ATTR_CHARACTERISTICS,
     :current_ifsc, Consts::SCARD_ATTR_CURRENT_IFSC,
     :current_ifsd, Consts::SCARD_ATTR_CURRENT_IFSD,
-    :max_clk, Consts::SCARD_ATTR_MAX_CLK,
-    :max_data_rate, Consts::SCARD_ATTR_MAX_DATA_RATE,
-    :current_protocol_type, Consts::SCARD_ATTR_CURRENT_PROTOCOL_TYPE,
+    :current_bwt, Consts::SCARD_ATTR_CURRENT_BWT,
+    :current_cwt, Consts::SCARD_ATTR_CURRENT_CWT,
+    :current_ebc_encoding, Consts::SCARD_ATTR_CURRENT_EBC_ENCODING,
+    :extended_bwt, Consts::SCARD_ATTR_EXTENDED_BWT,
+    :icc_presence, Consts::SCARD_ATTR_ICC_PRESENCE,
+    :icc_interface_status, Consts::SCARD_ATTR_ICC_INTERFACE_STATUS,
+    :current_io_state, Consts::SCARD_ATTR_CURRENT_IO_STATE,
     :atr_string, Consts::SCARD_ATTR_ATR_STRING,
+    :icc_type_per_atr, Consts::SCARD_ATTR_ICC_TYPE_PER_ATR,
+    :esc_reset, Consts::SCARD_ATTR_ESC_RESET,
+    :esc_cancel, Consts::SCARD_ATTR_ESC_CANCEL,
     :esc_authrequest, Consts::SCARD_ATTR_ESC_AUTHREQUEST,
-    :device_system_name_a, Consts::SCARD_ATTR_DEVICE_SYSTEM_NAME_A,
-    :device_system_name_w, Consts::SCARD_ATTR_DEVICE_SYSTEM_NAME_W,
-    :default_clk, Consts::SCARD_ATTR_DEFAULT_CLK,
-    :max_ifsd, Consts::SCARD_ATTR_MAX_IFSD,
-    :vendor_name, Consts::SCARD_ATTR_VENDOR_NAME,
-    :async_protocol_types, Consts::SCARD_ATTR_ASYNC_PROTOCOL_TYPES,
+    :maxinput, Consts::SCARD_ATTR_MAXINPUT,
     :device_unit, Consts::SCARD_ATTR_DEVICE_UNIT,
+    :device_in_use, Consts::SCARD_ATTR_DEVICE_IN_USE,
     :device_friendly_name_a, Consts::SCARD_ATTR_DEVICE_FRIENDLY_NAME_A,
+    :device_system_name_a, Consts::SCARD_ATTR_DEVICE_SYSTEM_NAME_A,
     :device_friendly_name_w, Consts::SCARD_ATTR_DEVICE_FRIENDLY_NAME_W,
+    :device_system_name_w, Consts::SCARD_ATTR_DEVICE_SYSTEM_NAME_W,
     :supress_t1_ifs_request, Consts::SCARD_ATTR_SUPRESS_T1_IFS_REQUEST,
-    :current_bwt, Consts::SCARD_ATTR_CURRENT_BWT,
-    :current_cwt, Consts::SCARD_ATTR_CURRENT_CWT,
-    :icc_presence, Consts::SCARD_ATTR_ICC_PRESENCE,
-    :esc_cancel, Consts::SCARD_ATTR_ESC_CANCEL,
-    :device_in_use, Consts::SCARD_ATTR_DEVICE_IN_USE,
-    :user_auth_input_device, Consts::SCARD_ATTR_USER_AUTH_INPUT_DEVICE,
-    :current_io_state, Consts::SCARD_ATTR_CURRENT_IO_STATE,
+    :device_friendly_name, Consts::SCARD_ATTR_DEVICE_FRIENDLY_NAME,
     :device_system_name, Consts::SCARD_ATTR_DEVICE_SYSTEM_NAME,
-    :vendor_ifd_type, Consts::SCARD_ATTR_VENDOR_IFD_TYPE,
-    :default_data_rate, Consts::SCARD_ATTR_DEFAULT_DATA_RATE,
-    :icc_type_per_atr, Consts::SCARD_ATTR_ICC_TYPE_PER_ATR,
-    :vendor_ifd_version, Consts::SCARD_ATTR_VENDOR_IFD_VERSION,
-    :channel_id, Consts::SCARD_ATTR_CHANNEL_ID,
-    :power_mgmt_support, Consts::SCARD_ATTR_POWER_MGMT_SUPPORT,
-    :extended_bwt, Consts::SCARD_ATTR_EXTENDED_BWT,
-    :icc_interface_status, Consts::SCARD_ATTR_ICC_INTERFACE_STATUS,
-    :maxinput, Consts::SCARD_ATTR_MAXINPUT,
   ]
 
   # Smart-card states.
   CardState = enum [
-    :changed, Consts::SCARD_STATE_CHANGED,
-    :mute, Consts::SCARD_STATE_MUTE,
+    :unaware, Consts::SCARD_STATE_UNAWARE,
     :ignore, Consts::SCARD_STATE_IGNORE,
+    :changed, Consts::SCARD_STATE_CHANGED,
+    :unknown, Consts::SCARD_STATE_UNKNOWN,
     :unavailable, Consts::SCARD_STATE_UNAVAILABLE,
     :empty, Consts::SCARD_STATE_EMPTY,
-    :unknown, Consts::SCARD_STATE_UNKNOWN,
-    :atrmatch, Consts::SCARD_STATE_ATRMATCH,
     :present, Consts::SCARD_STATE_PRESENT,
+    :atrmatch, Consts::SCARD_STATE_ATRMATCH,
     :exclusive, Consts::SCARD_STATE_EXCLUSIVE,
     :inuse, Consts::SCARD_STATE_INUSE,
+    :mute, Consts::SCARD_STATE_MUTE,
     :unpowered, Consts::SCARD_STATE_UNPOWERED,
-    :unaware, Consts::SCARD_STATE_UNAWARE,
   ]
 
   # Smart-card reader states.
   State = enum [
-    :present, Consts::SCARD_PRESENT,
     :autoallocate, Consts::SCARD_AUTOALLOCATE,
+    :unknown, Consts::SCARD_UNKNOWN,
     :absent, Consts::SCARD_ABSENT,
+    :present, Consts::SCARD_PRESENT,
     :swallowed, Consts::SCARD_SWALLOWED,
-    :unknown, Consts::SCARD_UNKNOWN,
     :powered, Consts::SCARD_POWERED,
-    :specific, Consts::SCARD_SPECIFIC,
     :negotiable, Consts::SCARD_NEGOTIABLE,
+    :specific, Consts::SCARD_SPECIFIC,
   ]
 
 end  # module Smartcard::PCSC::FFILib