smartcard 0.3.2 → 0.4.0

data/CHANGELOG

@@ -1,3 +1,5 @@
+v0.4.0. High-level functionality for ISO7816 cards.
+
 v0.3.2. Fixed documentation for ReaderStates class.
 
 v0.3.1. Fixed documentation for the new PcscException class.

data/Manifest

@@ -1,23 +1,37 @@
-BUILD
-CHANGELOG
-ext/smartcard_pcsc/extconf.rb
-ext/smartcard_pcsc/pcsc.h
-ext/smartcard_pcsc/pcsc_card.c
-ext/smartcard_pcsc/pcsc_constants.c
-ext/smartcard_pcsc/pcsc_context.c
-ext/smartcard_pcsc/pcsc_exception.c
-ext/smartcard_pcsc/pcsc_io_request.c
-ext/smartcard_pcsc/pcsc_main.c
-ext/smartcard_pcsc/pcsc_multi_strings.c
-ext/smartcard_pcsc/pcsc_namespace.c
-ext/smartcard_pcsc/pcsc_reader_states.c
-ext/smartcard_pcsc/pcsc_surrogate_reader.h
-ext/smartcard_pcsc/pcsc_surrogate_wintypes.h
-lib/smartcard/pcsc_exception.rb
-lib/smartcard.rb
-LICENSE
-Manifest
-README
-test/test_containers.rb
-test/test_smoke.rb
-tests/ts_pcsc_ext.rb
+BUILD
+CHANGELOG
+ext/smartcard_pcsc/extconf.rb
+ext/smartcard_pcsc/pcsc.h
+ext/smartcard_pcsc/pcsc_card.c
+ext/smartcard_pcsc/pcsc_constants.c
+ext/smartcard_pcsc/pcsc_context.c
+ext/smartcard_pcsc/pcsc_exception.c
+ext/smartcard_pcsc/pcsc_io_request.c
+ext/smartcard_pcsc/pcsc_main.c
+ext/smartcard_pcsc/pcsc_multi_strings.c
+ext/smartcard_pcsc/pcsc_namespace.c
+ext/smartcard_pcsc/pcsc_reader_states.c
+ext/smartcard_pcsc/pcsc_surrogate_reader.h
+ext/smartcard_pcsc/pcsc_surrogate_wintypes.h
+lib/smartcard/gp/gp_card_mixin.rb
+lib/smartcard/iso/auto_configurator.rb
+lib/smartcard/iso/iso_card_mixin.rb
+lib/smartcard/iso/jcop_remote_protocol.rb
+lib/smartcard/iso/jcop_remote_server.rb
+lib/smartcard/iso/jcop_remote_transport.rb
+lib/smartcard/iso/pcsc_transport.rb
+lib/smartcard/iso/transport.rb
+lib/smartcard/pcsc/pcsc_exception.rb
+lib/smartcard.rb
+LICENSE
+Manifest
+Rakefile
+README
+smartcard.gemspec
+test/gp/gp_card_mixin_test.rb
+test/iso/auto_configurator_test.rb
+test/iso/iso_card_mixin_test.rb
+test/iso/jcop_remote_test.rb
+test/pcsc/containers_test.rb
+test/pcsc/smoke_test.rb
+tests/ts_pcsc_ext.rb

data/ext/smartcard_pcsc/pcsc_constants.c

@@ -119,7 +119,7 @@ void Init_PCSC_Consts() {
 #endif /* SCARD_STATE_UNPOWERED */
 	
 	/* INFINITE : Infinite timeout. */
-	rb_define_const(mPcsc, "INFINITE_TIMEOUT", INT2NUM(INFINITE));
+	rb_define_const(mPcsc, "INFINITE_TIMEOUT", UINT2NUM(INFINITE));
 	
 	
 	/* SCARD_UNKNOWNU : Card is absent. */

data/ext/smartcard_pcsc/pcsc_context.c

@@ -225,7 +225,7 @@ static VALUE PCSC_Context_get_status_change(VALUE self, VALUE rbReaderStates, VA
 	if(TYPE(rbTimeout) == T_NIL || TYPE(rbTimeout) == T_FALSE)
 		timeout = INFINITE;
 	else
-		timeout = NUM2INT(rbTimeout);
+		timeout = NUM2UINT(rbTimeout);
 	
 	if(_PCSC_ReaderStates_lowlevel_get(rbReaderStates, &reader_states, &reader_states_count) == 0)
 		rb_raise(rb_eArgError, "first parameter is not a ReaderStates instance or nil");

data/lib/smartcard.rb

@@ -1 +1,15 @@
 require 'smartcard/pcsc'
+require 'smartcard/pcsc/pcsc_exception.rb'
+
+
+require 'smartcard/iso/iso_card_mixin.rb'
+require 'smartcard/iso/jcop_remote_protocol.rb'
+require 'smartcard/iso/jcop_remote_transport.rb'
+require 'smartcard/iso/jcop_remote_server.rb'
+require 'smartcard/iso/pcsc_transport.rb'
+require 'smartcard/iso/transport.rb'
+
+require 'smartcard/iso/auto_configurator.rb'
+
+
+require 'smartcard/gp/gp_card_mixin.rb'

data/lib/smartcard/gp/gp_card_mixin.rb

@@ -0,0 +1,28 @@
+# GlobalPlatform (formerly OpenPlatform) interface.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2009 Massachusetts Institute of Technology
+# License:: MIT
+
+# :nodoc: namespace
+module Smartcard::Gp
+
+
+module GpCardMixin
+  include Smartcard::Iso::IsoCardMixin
+  
+  # Selects a GlobalPlatform application.
+  def select_application(app_id)
+    iso_apdu! :ins => 0xA4, :p1 => 0x04, :p2 => 0x00, :data => app_id
+  end
+  
+  # Installs a JavaCard applet on the JavaCard.
+  #
+  # This would be really, really nice to have. Sadly, it's a far away TBD right
+  # now.
+  def install_applet(cap_contents)
+    raise "Not implemeted; it'd be nice though, right?"
+  end
+end  # module GpCardMixin
+
+end  # namespace Smartcard::Gp

data/lib/smartcard/iso/auto_configurator.rb

@@ -0,0 +1,93 @@
+# Automatic smart-card transport selection and configuration.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+# :nodoc: namespace
+module Smartcard::Iso
+
+# Automatic configuration code.
+module AutoConfigurator  
+  # The name of the environment variable that might supply the transport
+  # configuration.
+  ENVIRONMENT_VARIABLE_NAME = 'SCARD_PORT'
+  
+  # The default configurations to be tried if no configuration is specified.
+  DEFAULT_CONFIGURATIONS = [
+    { :class => JcopRemoteTransport,
+      :opts => { :host => '127.0.0.1', :port => 8050} },
+    { :class => PcscTransport, :opts => { :reader_index => 0 }}
+  ]
+
+  # Creates a transport based on available configuration information.
+  def self.auto_transport
+    configuration = env_configuration
+    return try_transport(configuration) if configuration
+    
+    DEFAULT_CONFIGURATIONS.each do |config|
+      transport = try_transport(config)
+      return transport if transport
+    end
+    return nil
+  end
+
+  # Retrieves transport configuration information from an environment variable.
+  #
+  # :call-seq:
+  #   AutoConfigurator.env_configuration -> hash
+  #
+  # The returned configuration has the keys required by
+  # AutoConfigurator#try_transport
+  def self.env_configuration
+    return nil unless conf = ENV[ENVIRONMENT_VARIABLE_NAME]
+    
+    case conf[0]
+    when ?:
+      # :8050 -- JCOP emulator at port 8050
+      transport_class = JcopRemoteTransport
+      transport_opts = { :host => '127.0.0.1' }
+      transport_opts[:port] = conf[1..-1].to_i
+    when ?@
+      # @127.0.0.1:8050 -- JCOP emulator at host 127.0.0.1 port 8050
+      transport_class = JcopRemoteTransport
+      port_index = conf.rindex(?:) || conf.length
+      transport_opts = { :host => conf[1...port_index] }
+      transport_opts[:port] = conf[(port_index + 1)..-1].to_i
+    when ?#
+      # #2 -- 2nd PC/SC reader in the system
+      transport_class = PcscTransport
+      transport_opts = { :reader_index => conf[1..-1].to_i - 1 }
+    else
+      # Reader Name -- the PC/SC reader with the given name
+      transport_class = PcscTransport
+      transport_opts = { :reader_name => conf }
+    end
+    
+    transport_opts[:port] = 8050 if transport_opts[:port] == 0
+    if transport_opts[:reader_index] and transport_opts[:reader_index] < 0
+      transport_opts[:reader_index] = 0
+    end
+    { :class => transport_class, :opts => transport_opts }
+  end
+  
+  # Attempts to create a new ISO7816 transport with the given configuration.
+  # :call-seq:
+  #   AutoConfigurator.try_transport(configuration) -> Transport or nil
+  #
+  # The configuration should have the following keys:
+  #   class:: the Ruby class implementing the transport
+  #   opts:: the options to be passed to the implementation's constructor
+  def self.try_transport(configuration)
+    raise 'No transport class specified' unless configuration[:class]
+    begin
+      transport = configuration[:class].new(configuration[:opts] || {})
+      transport.connect
+      return transport
+    rescue Exception
+      return nil
+    end
+  end
+end  # module AutoConfigurator
+
+end  # module Smartcard::Iso

data/lib/smartcard/iso/iso_card_mixin.rb

@@ -0,0 +1,92 @@
+# Common code for talking to ISO7816 smart-cards on all transports.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+# :nodoc: namespace
+module Smartcard::Iso
+
+
+# Module intended to be mixed into transport implementations to mediate between
+# a high level format for ISO7816-specific APDUs and the wire-level APDU 
+# request and response formats.
+#
+# The mix-in calls exchange_apdu in the transport implementation. It supplies
+# the APDU data as an array of integers between 0 and 255, and expects a
+# response in the same format.
+module IsoCardMixin  
+  # APDU exchange with the ISO7816 card, raising an exception if the return
+  # code is not success (0x9000).
+  #
+  # :call_seq:
+  #   transport.iso_apdu!(apdu_data) -> array
+  #
+  # The apdu_data should be in the format expected by
+  # IsoCardMixin#serialize_apdu. Returns the response data, if the response
+  # status indicates success (0x9000). Otherwise, raises an exeception.
+  def iso_apdu!(apdu_data)
+    response = self.iso_apdu apdu_data
+    return response[:data] if response[:status] == 0x9000
+    raise "JavaCard response has error status 0x#{'%04x' % response[:status]}"
+  end
+
+  # Performs an APDU exchange with the ISO7816 card.
+  #
+  # :call-seq:
+  #   transport.iso_apdu(apdu_data) -> hash
+  #
+  # The apdu_data should be in the format expected by
+  # IsoCardMixin#serialize_apdu. The response will be as specified in
+  # IsoCardMixin#deserialize_response.
+  def iso_apdu(apdu_data)
+    response = self.exchange_apdu IsoCardMixin.serialize_apdu(apdu_data)
+    IsoCardMixin.deserialize_response response
+  end
+  
+  # Serializes an APDU for wire transmission.
+  #
+  # :call-seq:
+  #   transport.wire_apdu(apdu_data) -> array
+  #
+  # The following keys are recognized in the APDU hash:
+  #   cla:: the CLA byte in the APDU (optional, defaults to 0) 
+  #   ins:: the INS byte in the APDU -- the first byte seen by a JavaCard applet
+  #   p12:: 2-byte array containing the P1 and P2 bytes in the APDU
+  #   p1, p2:: the P1 and P2 bytes in the APDU (optional, both default to 0)
+  #   data:: the extra data in the APDU (optional, defaults to nothing)
+  def self.serialize_apdu(apdu_data)
+    raise 'Unspecified INS in apdu_data' unless apdu_data[:ins]
+    apdu = [ apdu_data[:cla] || 0, apdu_data[:ins] ]
+    if apdu_data[:p12]
+      unless apdu_data[:p12].length == 2
+        raise "Malformed P1,P2 - #{apdu_data[:p12]}"
+      end
+      apdu += apdu_data[:p12]
+    else
+      apdu << (apdu_data[:p1] || 0)
+      apdu << (apdu_data[:p2] || 0)
+    end
+    if apdu_data[:data]
+      apdu << apdu_data[:data].length
+      apdu += apdu_data[:data]
+    else
+      apdu << 0
+    end
+    apdu
+  end
+  
+  # De-serializes a ISO7816 response APDU.
+  # 
+  # :call-seq:
+  #   transport.deserialize_response(response) -> hash
+  #
+  # The response contains the following keys:
+  #   status:: the 2-byte status code (e.g. 0x9000 is OK)
+  #   data:: the additional data in the response
+  def self.deserialize_response(response)
+    { :status => response[-2] * 256 + response[-1], :data => response[0...-2] }
+  end  
+end  # module IsoCardMixin
+
+end  # module Smartcard::Iso

data/lib/smartcard/iso/jcop_remote_protocol.rb

@@ -0,0 +1,66 @@
+# The protocol used to talk to ISO7816 smart-cards in IBM JCOP simulators.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+# :nodoc: namespace
+module Smartcard::Iso
+
+
+# Mixin implementing the JCOP simulator protocol.
+#
+# The (pretty informal) protocol specification is contained in the JavaDocs for
+# the class com.ibm.jc.terminal.RemoteJCTerminal and should be easy to find by
+# http://www.google.com/search?q=%22com.ibm.jc.terminal.RemoteJCTerminal%22  
+module JcopRemoteProtocol
+  # Encodes and sends a JCOP simulator message to a TCP socket.
+  #
+  # The message must contain the following keys:
+  #   type:: Integer expressing the message type (e.g. 1 = APDU exchange)
+  #   node:: Integer expressing the node address (e.g. 0 for most purposes)
+  #   data:: message payload, as an array of Integers ranging from 0 to 255
+  def send_message(socket, message)
+    raw_message = [message[:type], message[:node], message[:data].length].
+                  pack('CCn') + message[:data].pack('C*')
+    socket.send raw_message, 0
+  end
+  
+  # Reads and decodes a JCOP simulator message from a TCP socket.
+  # 
+  # :call_seq:
+  #   client.read_message(socket) -> Hash or nil
+  #
+  # If the other side of the TCP socket closes the connection, this method
+  # returns nil. Otherwise, a Hash is returned, with the format required by the
+  # JcopRemoteProtocol#send_message.
+  def recv_message(socket)
+    header = ''
+    while header.length < 4
+      begin
+        partial = socket.recv 4 - header.length
+      rescue  # Abrupt hangups result in exceptions that we catch here.        
+        return nil
+      end
+      return false if partial.length == 0
+      header += partial
+    end
+    message_type, node_address, data_length = *header.unpack('CCn')
+    raw_data = ''
+    while raw_data.length < data_length
+      begin
+        partial = socket.recv data_length - raw_data.length
+      rescue  # Abrupt hangups result in exceptions that we catch here.
+        return nil
+      end
+      return false if partial.length == 0
+      raw_data += partial
+    end
+    
+    return false unless raw_data.length == data_length
+    data = raw_data.unpack('C*')
+    return { :type => message_type, :node => node_address, :data => data }
+  end
+end  # module JcopRemoteProtocol
+
+end  # namespace Smartcard::Iso

data/lib/smartcard/iso/jcop_remote_server.rb

@@ -0,0 +1,178 @@
+# The protocol used to talk to ISO7816 smart-cards in IBM JCOP simulators.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'socket'
+
+# :nodoc: namespace
+module Smartcard::Iso
+
+
+# Stubs out the methods that can be implemented by the serving logic in a
+# JCOP remote server. Serving logic classes should mix in this module, to
+# avoid having unimplemented methods.
+module JcopRemoteServingStubs
+  # Called when a client connection accepted.
+  #
+  # This method serves as a notification to the serving logic implementation.
+  # Its return value is discarded.
+  def connection_start
+    nil
+  end
+  
+  # Called when a client connection is closed.
+  #
+  # This method serves as a notification to the serving logic implementation.
+  # Its return value is discarded.
+  def connection_end
+    nil
+  end
+  
+  # Serving logic handling an APDU exchange.
+  #
+  # :call-seq:
+  #   logic.exchange_apdu(apdu) -> array
+  #
+  # The |apdu| parameter is the request APDU, formatted as an array of
+  # integers between 0 and 255. The method should return the response APDU,
+  # formatted in a similar manner.  
+  def exchange_apdu(apdu)
+    # Dumb implementation that always returns OK.
+    [0x90, 0x00]
+  end
+end  # module JcopRemoteServingStubs
+    
+
+# A server for the JCOP simulator protocol.
+#
+# The JCOP simulator protocol is generally useful when talking to a real JCOP
+# simulator. This server is only handy for testing, and for forwarding
+# connections (JCOP's Eclipse plug-in makes the simulator listen to 127.0.0.1,
+# and sometimes you want to use it from another box).
+class JcopRemoteServer
+  include JcopRemoteProtocol  
+  
+  # Creates a new JCOP server.
+  #
+  # The options hash supports the following keys:
+  #   port:: the port to serve on
+  #   ip:: the IP of the interface to serve on (defaults to all interfaces)
+  #   reusable:: if set, the serving port can be shared with another
+  #              application (REUSEADDR flag will be set on the socket)
+  #
+  # If the |serving_logic| parameter is nil, a serving logic implementation
+  # must be provided when calling JcopRemoteServer#run. The server will crash
+  # otherwise.
+  def initialize(options, serving_logic = nil)
+    @logic = serving_logic
+    @running = false
+    @options = options
+    @mutex = Mutex.new
+  end
+  
+  # Runs the serving loop indefinitely.
+  #
+  # This method serves incoming conenctions until #stop is called.
+  #
+  # If |serving_logic| contains a non-nil value, it overrides any previously
+  # specified serving logic implementation. If no implementation is specified
+  # when the server is instantiated via JcopRemoteServer#new, one must be
+  # passed into |serving_logic|.
+  def run(serving_logic = nil)
+    @mutex.synchronize do
+      @logic ||= serving_logic
+      @serving_socket = serving_socket @options
+      @running = true
+    end
+    loop do
+      break unless @mutex.synchronize { @running }
+      begin
+        client_socket, client_address = @serving_socket.accept
+      rescue
+        # An exception will occur if the socket is closed
+        break
+      end
+      @logic.connection_start
+      loop do        
+        break unless @mutex.synchronize { @running }
+        break unless process_request client_socket
+      end
+      client_socket.close rescue nil
+      @logic.connection_end  # implemented by subclass
+    end
+    @mutex.synchronize do
+      @serving_socket.close if @serving_socket
+      @serving_socket = nil
+    end
+  end
+
+  # Stops the serving loop.
+  def stop
+    @mutex.synchronize do
+      if @running
+        @serving_socket.close rescue nil
+        @serving_socket = nil
+        @running = false
+      end
+    end
+    
+    # TODO(costan): figure out a way to let serving logic reach this directly.
+  end
+  
+  
+  # Creates a socket listening to incoming connections to this server.
+  # 
+  # :call-seq:
+  #   server.establish_socket(options) -> Socket
+  #
+  # The |options| parameter supports the same keys as the options parameter
+  # of JcopRemoteServer#new.
+  #
+  # Returns a Socket configured to accept incoming connections. 
+  def serving_socket(options)
+    port = options[:port] || 0
+    interface_ip = options[:ip] || '0.0.0.0'
+    serving_address = Socket.pack_sockaddr_in port, interface_ip
+    
+    socket = Socket.new Socket::AF_INET, Socket::SOCK_STREAM,
+                        Socket::PF_UNSPEC
+    
+    if options[:reusable]
+      socket.setsockopt Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true
+    end
+    socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true      
+    socket.bind serving_address
+    socket.listen 5
+    socket
+  end
+  private :serving_socket
+
+  # Performs a request/response cycle.
+  #
+  # :call-seq:
+  #   server.process_request(socket) -> Boolean
+  #
+  # Returns true if the server should do another request/response cycle, or
+  # false if this client indicated it's done talking to the server.
+  def process_request(socket)
+    return false unless request = recv_message(socket)
+    
+    case request[:type]
+    when 0
+      # Wait for card; no-op, because that should have happen when the client
+      # connected.
+      send_message socket, :type => 0, :node => 0, :data => [3, 1, 4, 1, 5, 9]
+    when 1
+      # ATR exchange; the class' bread and butter
+      response = @logic.exchange_apdu request[:data]
+      send_message socket, :type => 1, :node => 0, :data => response
+    else
+      send_message socket, :type => request[:type], :node => 0, :data => []
+    end
+  end
+  private :process_request    
+end  # module JcopRemoteServer
+
+end  # namespace Smartcard::Iso

data/lib/smartcard/iso/jcop_remote_transport.rb

@@ -0,0 +1,72 @@
+# Interface to ISO7816 smart-cards in IBM JCOP simulators.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'socket'
+
+# :nodoc: namespace
+module Smartcard::Iso
+
+
+# Implements the transport layer for a JCOP simulator instance.
+class JcopRemoteTransport
+  include IsoCardMixin
+  include JcopRemoteProtocol
+  
+  # Creates a new unconnected transport for a JCOP simulator serving TCP/IP.
+  #
+  # The options parameter must have the following keys:
+  #   host:: the DNS name or IP of the host running the JCOP simulator
+  #   port:: the TCP/IP port of the JCOP simulator server
+  def initialize(options)
+    @host, @port = options[:host], options[:port]
+    @socket = nil
+  end
+  
+  # 
+  def exchange_apdu(apdu)
+    send_message @socket, :type => 1, :node => 0, :data => apdu
+    recv_message(@socket)[:data]
+  end  
+
+  # Makes a transport-level connection to the TEM.
+  def connect
+    begin
+      Socket.getaddrinfo(@host, @port, Socket::AF_INET,
+                         Socket::SOCK_STREAM).each do |addr_info|
+        begin
+          @socket = Socket.new(addr_info[4], addr_info[5], addr_info[6])
+          @socket.connect Socket.pack_sockaddr_in(addr_info[1], addr_info[3])
+          break
+        rescue
+          @socket = nil
+        end
+      end  
+      raise 'Connection refused' unless @socket
+      
+      # Wait for the card to be inserted.
+      send_message @socket, :type => 0, :node => 0, :data => [0, 1, 0, 0]
+      recv_message @socket  # ATR should come here, but who cares      
+    rescue Exception
+      @socket = nil
+      raise
+    end
+  end
+
+  # Breaks down the transport-level connection to the TEM.
+  def disconnect
+    if @socket
+      @socket.close
+      @socket = nil
+    end
+  end
+  
+  def to_s
+    "#<JCOP Remote Terminal: disconnected>" if @socket.nil?
+    "#<JCOP Remote Terminal: #{@host}:#{@port}>"
+  end  
+end  # class JcopRemoteTransport 
+
+end  # module Smartcard::Iso

data/lib/smartcard/iso/pcsc_transport.rb

@@ -0,0 +1,94 @@
+# Interface to ISO7816 smart-cards in PC/SC readers.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'rubygems'
+require 'smartcard'
+
+# :nodoc: namespace
+module Smartcard::Iso
+
+# Implements the transport layer for a smartcard connected to a PC/SC reader.
+class PcscTransport
+  include IsoCardMixin
+  PCSC = Smartcard::PCSC
+  
+  def initialize(options)
+    @options = options
+    @context = nil
+    @card = nil
+  end
+
+  def exchange_apdu(apdu)
+    xmit_apdu_string = apdu.pack('C*')
+    result_string = @card.transmit xmit_apdu_string, @xmit_ioreq, @recv_ioreq
+    return result_string.unpack('C*')
+  end
+  
+  def connect
+    @context = PCSC::Context.new(PCSC::SCOPE_SYSTEM) if @context.nil?
+    
+    if @options[:reader_name]
+      @reader_name = @options[:reader_name]
+    else
+      # get the first reader      
+      readers = @context.list_readers nil
+      @reader_name = readers[@options[:reader_index] || 0]
+    end
+    
+    # get the reader's status
+    reader_states = PCSC::ReaderStates.new(1)
+    reader_states.set_reader_name_of!(0, @reader_name)
+    reader_states.set_current_state_of!(0, PCSC::STATE_UNKNOWN)
+    @context.get_status_change reader_states, 100
+    reader_states.acknowledge_events!
+    
+    # prompt for card insertion unless that already happened
+    if (reader_states.current_state_of(0) & PCSC::STATE_PRESENT) == 0
+      puts "Please insert TEM card in reader #{@reader_name}\n"
+      while (reader_states.current_state_of(0) & PCSC::STATE_PRESENT) == 0 do
+        @context.get_status_change reader_states, PCSC::INFINITE_TIMEOUT
+        reader_states.acknowledge_events!
+      end
+      puts "Card detected\n"
+    end
+    
+    # connect to card
+    @card = PCSC::Card.new @context, @reader_name, PCSC::SHARE_EXCLUSIVE,
+                           PCSC::PROTOCOL_ANY
+    
+    # build the transmit / receive IoRequests
+    status = @card.status
+    @xmit_ioreq = @@xmit_iorequest[status[:protocol]]
+    if RUBY_PLATFORM =~ /win/ and (not RUBY_PLATFORM =~ /darwin/)
+      @recv_ioreq = nil
+    else
+      @recv_ioreq = PCSC::IoRequest.new
+    end
+  end
+  
+  def disconnect
+    unless @card.nil?
+      @card.disconnect PCSC::DISPOSITION_LEAVE
+      @card = nil
+    end
+    unless @context.nil?
+      @context.release
+      @context = nil
+    end
+  end  
+
+  def to_s
+    "#<PC/SC Terminal: disconnected>" if @card.nil?
+    "#<PC/SC Terminal: #{@reader_name}>"
+  end
+  
+  @@xmit_iorequest = {
+    Smartcard::PCSC::PROTOCOL_T0 => Smartcard::PCSC::IOREQUEST_T0,
+    Smartcard::PCSC::PROTOCOL_T1 => Smartcard::PCSC::IOREQUEST_T1,
+  }
+end  # class PcscTransport
+
+end  # module Smartcard::Iso

data/lib/smartcard/iso/transport.rb

@@ -0,0 +1,15 @@
+# Interface for ISO7816 cards.
+#
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+
+# The transport module contains classes responsible for transferring APDUs
+# from a high-level representation to the smart card hardware.
+module Smartcard::Iso
+  # Shortcut for Smartcard::Iso::AutoConfigurator#auto_transport
+  def self.auto_transport
+    Smartcard::Iso::AutoConfigurator.auto_transport
+  end
+end

data/smartcard.gemspec

@@ -2,23 +2,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{smartcard}
-  s.version = "0.3.2"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Victor Costan"]
-  s.date = %q{2009-05-31}
+  s.date = %q{2009-08-18}
   s.description = %q{Interface with ISO 7816 smart cards.}
   s.email = %q{victor@costan.us}
   s.extensions = ["ext/smartcard_pcsc/extconf.rb"]
-  s.extra_rdoc_files = ["BUILD", "CHANGELOG", "ext/smartcard_pcsc/extconf.rb", "ext/smartcard_pcsc/pcsc.h", "ext/smartcard_pcsc/pcsc_card.c", "ext/smartcard_pcsc/pcsc_constants.c", "ext/smartcard_pcsc/pcsc_context.c", "ext/smartcard_pcsc/pcsc_exception.c", "ext/smartcard_pcsc/pcsc_io_request.c", "ext/smartcard_pcsc/pcsc_main.c", "ext/smartcard_pcsc/pcsc_multi_strings.c", "ext/smartcard_pcsc/pcsc_namespace.c", "ext/smartcard_pcsc/pcsc_reader_states.c", "ext/smartcard_pcsc/pcsc_surrogate_reader.h", "ext/smartcard_pcsc/pcsc_surrogate_wintypes.h", "lib/smartcard/pcsc_exception.rb", "lib/smartcard.rb", "LICENSE", "README"]
-  s.files = ["BUILD", "CHANGELOG", "ext/smartcard_pcsc/extconf.rb", "ext/smartcard_pcsc/pcsc.h", "ext/smartcard_pcsc/pcsc_card.c", "ext/smartcard_pcsc/pcsc_constants.c", "ext/smartcard_pcsc/pcsc_context.c", "ext/smartcard_pcsc/pcsc_exception.c", "ext/smartcard_pcsc/pcsc_io_request.c", "ext/smartcard_pcsc/pcsc_main.c", "ext/smartcard_pcsc/pcsc_multi_strings.c", "ext/smartcard_pcsc/pcsc_namespace.c", "ext/smartcard_pcsc/pcsc_reader_states.c", "ext/smartcard_pcsc/pcsc_surrogate_reader.h", "ext/smartcard_pcsc/pcsc_surrogate_wintypes.h", "lib/smartcard/pcsc_exception.rb", "lib/smartcard.rb", "LICENSE", "Manifest", "README", "test/test_containers.rb", "test/test_smoke.rb", "tests/ts_pcsc_ext.rb", "smartcard.gemspec", "Rakefile"]
+  s.extra_rdoc_files = ["BUILD", "CHANGELOG", "ext/smartcard_pcsc/extconf.rb", "ext/smartcard_pcsc/pcsc.h", "ext/smartcard_pcsc/pcsc_card.c", "ext/smartcard_pcsc/pcsc_constants.c", "ext/smartcard_pcsc/pcsc_context.c", "ext/smartcard_pcsc/pcsc_exception.c", "ext/smartcard_pcsc/pcsc_io_request.c", "ext/smartcard_pcsc/pcsc_main.c", "ext/smartcard_pcsc/pcsc_multi_strings.c", "ext/smartcard_pcsc/pcsc_namespace.c", "ext/smartcard_pcsc/pcsc_reader_states.c", "ext/smartcard_pcsc/pcsc_surrogate_reader.h", "ext/smartcard_pcsc/pcsc_surrogate_wintypes.h", "lib/smartcard/gp/gp_card_mixin.rb", "lib/smartcard/iso/auto_configurator.rb", "lib/smartcard/iso/iso_card_mixin.rb", "lib/smartcard/iso/jcop_remote_protocol.rb", "lib/smartcard/iso/jcop_remote_server.rb", "lib/smartcard/iso/jcop_remote_transport.rb", "lib/smartcard/iso/pcsc_transport.rb", "lib/smartcard/iso/transport.rb", "lib/smartcard/pcsc/pcsc_exception.rb", "lib/smartcard.rb", "LICENSE", "README"]
+  s.files = ["BUILD", "CHANGELOG", "ext/smartcard_pcsc/extconf.rb", "ext/smartcard_pcsc/pcsc.h", "ext/smartcard_pcsc/pcsc_card.c", "ext/smartcard_pcsc/pcsc_constants.c", "ext/smartcard_pcsc/pcsc_context.c", "ext/smartcard_pcsc/pcsc_exception.c", "ext/smartcard_pcsc/pcsc_io_request.c", "ext/smartcard_pcsc/pcsc_main.c", "ext/smartcard_pcsc/pcsc_multi_strings.c", "ext/smartcard_pcsc/pcsc_namespace.c", "ext/smartcard_pcsc/pcsc_reader_states.c", "ext/smartcard_pcsc/pcsc_surrogate_reader.h", "ext/smartcard_pcsc/pcsc_surrogate_wintypes.h", "lib/smartcard/gp/gp_card_mixin.rb", "lib/smartcard/iso/auto_configurator.rb", "lib/smartcard/iso/iso_card_mixin.rb", "lib/smartcard/iso/jcop_remote_protocol.rb", "lib/smartcard/iso/jcop_remote_server.rb", "lib/smartcard/iso/jcop_remote_transport.rb", "lib/smartcard/iso/pcsc_transport.rb", "lib/smartcard/iso/transport.rb", "lib/smartcard/pcsc/pcsc_exception.rb", "lib/smartcard.rb", "LICENSE", "Manifest", "Rakefile", "README", "smartcard.gemspec", "test/gp/gp_card_mixin_test.rb", "test/iso/auto_configurator_test.rb", "test/iso/iso_card_mixin_test.rb", "test/iso/jcop_remote_test.rb", "test/pcsc/containers_test.rb", "test/pcsc/smoke_test.rb", "tests/ts_pcsc_ext.rb"]
   s.homepage = %q{http://www.costan.us/smartcard}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Smartcard", "--main", "README"]
   s.require_paths = ["lib", "ext"]
   s.rubyforge_project = %q{smartcard}
-  s.rubygems_version = %q{1.3.4}
+  s.rubygems_version = %q{1.3.5}
   s.summary = %q{Interface with ISO 7816 smart cards.}
-  s.test_files = ["test/test_containers.rb", "test/test_smoke.rb"]
+  s.test_files = ["test/gp/gp_card_mixin_test.rb", "test/iso/auto_configurator_test.rb", "test/iso/iso_card_mixin_test.rb", "test/iso/jcop_remote_test.rb", "test/pcsc/containers_test.rb", "test/pcsc/smoke_test.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/test/gp/gp_card_mixin_test.rb

@@ -0,0 +1,33 @@
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'smartcard'
+
+require 'test/unit'
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+
+class GpCardMixinTest < Test::Unit::TestCase
+  GpCardMixin = Smartcard::Gp::GpCardMixin
+  
+  # The sole purpose of this class is wrapping the mixin under test.
+  class MixinWrapper
+    include GpCardMixin
+    include Smartcard::Iso::IsoCardMixin
+  end
+  
+  def setup
+  end
+    
+  def test_select_application
+    mock = MixinWrapper.new
+    flexmock(mock).should_receive(:exchange_apdu).
+                   with([0x00, 0xA4, 0x04, 0x00, 0x05,
+                         0x19, 0x83, 0x12, 0x29, 0x10]).
+                   and_return([0x90, 0x00])
+    mock.select_application([0x19, 0x83, 0x12, 0x29, 0x10])
+  end
+end

data/test/iso/auto_configurator_test.rb

@@ -0,0 +1,119 @@
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'smartcard'
+
+require 'test/unit'
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+
+class AutoConfiguratorTest < Test::Unit::TestCase
+  AutoConfigurator = Smartcard::Iso::AutoConfigurator
+  PcscTransport = Smartcard::Iso::PcscTransport
+  JcopRemoteTransport = Smartcard::Iso::JcopRemoteTransport
+    
+  def setup
+    @env_var = AutoConfigurator::ENVIRONMENT_VARIABLE_NAME 
+  end
+
+  def test_env_configuration_blank
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(nil)
+    assert_equal nil, AutoConfigurator.env_configuration
+  end
+  def test_env_configuration_remote_port
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(':6996')
+    conf = AutoConfigurator.env_configuration
+    assert_equal JcopRemoteTransport, conf[:class]
+    assert_equal({:host => '127.0.0.1', :port => 6996}, conf[:opts])
+  end  
+  def test_env_configuration_remote_noport
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(':')
+    conf = AutoConfigurator.env_configuration
+    assert_equal JcopRemoteTransport, conf[:class]
+    assert_equal({:host => '127.0.0.1', :port => 8050}, conf[:opts])
+  end
+  def test_env_configuration_remote_host_port
+    flexmock(ENV).should_receive(:[]).with(@env_var).
+                  and_return('@moonstone:6996')
+    conf = AutoConfigurator.env_configuration
+    assert_equal JcopRemoteTransport, conf[:class]
+    assert_equal({:host => 'moonstone', :port => 6996}, conf[:opts])
+  end
+  def test_env_configuration_remote_host_noport    
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('@moonstone')
+    conf = AutoConfigurator.env_configuration
+    assert_equal JcopRemoteTransport, conf[:class]
+    assert_equal({:host => 'moonstone', :port => 8050}, conf[:opts])
+  end
+  def test_env_configuration_remote_ipv6_port
+    flexmock(ENV).should_receive(:[]).with(@env_var).
+                  and_return('@ff80::0080:6996')
+    conf = AutoConfigurator.env_configuration
+    assert_equal JcopRemoteTransport, conf[:class]
+    assert_equal({:host => 'ff80::0080', :port => 6996}, conf[:opts])
+  end
+  def test_env_configuration_remote_ipv6_noport
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('@ff80::0080:')
+    conf = AutoConfigurator.env_configuration
+    assert_equal JcopRemoteTransport, conf[:class]
+    assert_equal({:host => 'ff80::0080', :port => 8050}, conf[:opts])
+  end
+
+  def test_env_configuration_pcsc_reader_index
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('#1')
+    conf = AutoConfigurator.env_configuration
+    assert_equal PcscTransport, conf[:class]
+    assert_equal({:reader_index => 0}, conf[:opts])
+  end
+  def test_env_configuration_pcsc_reader_name
+    reader_name = 'Awesome Reader'
+    flexmock(ENV).should_receive(:[]).with(@env_var).
+                and_return(reader_name)
+    conf = AutoConfigurator.env_configuration
+    assert_equal PcscTransport, conf[:class]
+    assert_equal({:reader_name => reader_name}, conf[:opts])
+  end
+  
+  def test_try_transport
+    transport = Object.new
+    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 1).
+                            and_return(transport)
+    flexmock(transport).should_receive(:connect)
+    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 2).
+                            and_raise('Boom headshot')
+    failport = Object.new
+    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 3).
+                            and_return(failport)    
+    flexmock(failport).should_receive(:connect).and_raise('Lag')
+    
+    config = { :class => PcscTransport, :opts => {:reader_index => 1} }
+    assert_equal transport, AutoConfigurator.try_transport(config)
+    config = { :class => PcscTransport, :opts => {:reader_index => 2} }
+    assert_equal nil, AutoConfigurator.try_transport(config)
+    config = { :class => PcscTransport, :opts => {:reader_index => 3} }
+    assert_equal nil, AutoConfigurator.try_transport(config)
+  end
+  
+  def test_auto_transport_uses_env
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return('#1')
+    transport = Object.new
+    flexmock(PcscTransport).should_receive(:new).with(:reader_index => 0).
+                            and_return(transport)
+    flexmock(transport).should_receive(:connect)
+    
+    assert_equal transport, AutoConfigurator.auto_transport
+  end
+  
+  def test_auto_transport_with_defaults
+    flexmock(ENV).should_receive(:[]).with(@env_var).and_return(nil)
+    transport = Object.new
+    flexmock(JcopRemoteTransport).should_receive(:new).and_return(nil)
+    flexmock(PcscTransport).should_receive(:new).and_return(transport)
+    flexmock(transport).should_receive(:connect)    
+        
+    assert_equal transport, AutoConfigurator.auto_transport
+  end
+end

data/test/iso/iso_card_mixin_test.rb

@@ -0,0 +1,95 @@
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'smartcard'
+
+require 'test/unit'
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+
+class IsoCardMixinTest < Test::Unit::TestCase
+  IsoCardMixin = Smartcard::Iso::IsoCardMixin
+  
+  # The sole purpose of this class is wrapping the mixin under test.
+  class MixinWrapper
+    include IsoCardMixin
+  end
+  
+  def setup
+  end
+
+  def test_serialize_apdu
+    s = lambda { |apdu| IsoCardMixin.serialize_apdu apdu }
+
+    assert_equal [0x00, 0x05, 0x00, 0x00, 0x00], s[:ins => 0x05],
+                 'Specified INS'
+    assert_equal [0x00, 0x09, 0x00, 0x01, 0x00], s[:ins => 0x09, :p2 => 0x01],
+                 'Specified INS and P2'
+    assert_equal [0x00, 0xF9, 0xAC, 0xEF, 0x00],
+                 s[:ins => 0xF9, :p1 => 0xAC, :p2 => 0xEF],
+                 'Specified INS, P1, P2'
+    assert_equal [0x00, 0xFA, 0xAD, 0xEC, 0x00],
+                 s[:ins => 0xFA, :p12 => [0xAD, 0xEC]],
+                 'Specified INS, P1+P2'
+    assert_equal [0x00, 0x0E, 0x00, 0x00, 0x04, 0x33, 0x95, 0x81, 0x63],
+                 s[:ins => 0x0E, :data => [0x33, 0x95, 0x81, 0x63]],
+                 'Specified INS and DATA'
+    assert_equal [0x80, 0x0F, 0xBA, 0xBE, 0x03, 0x31, 0x41, 0x59],
+                 s[:cla => 0x80, :ins => 0x0F, :p1 => 0xBA, :p2 => 0xBE,
+                   :data => [0x31, 0x41, 0x59]],
+                 'Specified everything'
+    assert_raise(RuntimeError, 'Did not specify INS') do
+      s[:cla => 0x80, :p1 => 0xBA, :p2 => 0xBE, :data => [0x31, 0x41, 0x59]]
+    end
+  end
+  
+  def test_deserialize_response
+    d = lambda { |response| IsoCardMixin.deserialize_response response }
+    
+    assert_equal({ :status => 0x9000, :data => [] }, d[[0x90, 0x00]])
+    assert_equal({ :status => 0x8631, :data => [] }, d[[0x86, 0x31]])
+    assert_equal({ :status => 0x9000, :data => [0x31, 0x41, 0x59, 0x26] },
+                 d[[0x31, 0x41, 0x59, 0x26, 0x90, 0x00]])
+    assert_equal({ :status => 0x7395, :data => [0x31, 0x41, 0x59, 0x26] },
+                 d[[0x31, 0x41, 0x59, 0x26, 0x73, 0x95]])
+  end
+  
+  def win_mock
+    mock = MixinWrapper.new
+    flexmock(mock).should_receive(:exchange_apdu).
+                   with([0x00, 0xF9, 0xAC, 0x00, 0x02, 0x31, 0x41]).
+                   and_return([0x67, 0x31, 0x90, 0x00])
+    mock
+  end  
+  def win_apdu
+    {:ins => 0xF9, :p1 => 0xAC, :data => [0x31, 0x41]}
+  end
+  
+  def lose_mock
+    mock = MixinWrapper.new
+    flexmock(mock).should_receive(:exchange_apdu).
+                   with([0x00, 0xF9, 0xAC, 0x00, 0x02, 0x31, 0x41]).
+                   and_return([0x86, 0x31])
+    mock
+  end  
+  def lose_apdu
+    win_apdu
+  end
+
+  def test_iso_apdu
+    assert_equal({:status => 0x9000, :data => [0x67, 0x31]},
+                 win_mock.iso_apdu(win_apdu))
+    assert_equal({:status => 0x8631, :data => []},
+                 lose_mock.iso_apdu(lose_apdu))
+  end
+  
+  def test_iso_apdu_bang
+    assert_equal [0x67, 0x31], win_mock.iso_apdu!(win_apdu)
+    assert_raise(RuntimeError) do
+      lose_mock.iso_apdu!(lose_apdu)
+    end
+  end
+end

data/test/iso/jcop_remote_test.rb

@@ -0,0 +1,87 @@
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
+require 'smartcard'
+
+require 'test/unit'
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+
+# Tests JcopRemoteProtocol, JcopRemoteServer, and JcopRemoteTransport.
+class JcopRemoteTest < Test::Unit::TestCase
+  Protocol = Smartcard::Iso::JcopRemoteProtocol
+  Server = Smartcard::Iso::JcopRemoteServer
+  Transport = Smartcard::Iso::JcopRemoteTransport
+  
+  # Serving logic that records what it receives and replays a log.
+  class Logic
+    include Protocol
+    attr_reader :received
+    def initialize(responses)
+      @responses = responses
+      @received = []
+    end
+    def connection_start
+      @received << :start
+    end
+    def connection_end
+      @received << :end
+    end
+    def exchange_apdu(apdu)
+      @received << apdu
+      @responses.shift
+    end
+  end
+  
+  def setup
+    @server = Server.new(:ip => '127.0.0.1', :port => 51995)
+    @client = Transport.new :host => '127.0.0.1', :port => 51995
+    @old_abort_on_exception = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+  end
+  
+  def teardown
+    Thread.abort_on_exception = @old_abort_on_exception
+    @server.stop
+  end
+
+  def test_apdu_exchange
+    apdu_request = [0x31, 0x41, 0x59, 0x26, 0x53]
+    apdu_response = [0x27, 0x90, 0x00]
+    
+    logic = Logic.new([apdu_response])
+    Thread.new do
+      begin
+        @server.run logic
+      rescue Exception
+        print $!, "\n"
+        print $!.backtrace.join("\n")
+        raise
+      end
+    end
+    Kernel.sleep 0.05  # Wait for the server to start up.
+    @client.connect
+    assert_equal apdu_response, @client.exchange_apdu(apdu_request)
+    @client.disconnect
+    Kernel.sleep 0.05  # Wait for the server to process the disconnect.
+    assert_equal [:start, apdu_request, :end], logic.received
+  end
+  
+  def test_java_card_integration
+    apdu_request = [0x00, 0x31, 0x41, 0x59, 0x00]
+    apdu_response = [0x27, 0x90, 0x00]
+
+    logic = Logic.new([apdu_response])
+    Thread.new { @server.run logic }
+    Kernel.sleep 0.05  # Wait for the server to start up.
+    @client.connect
+    assert_equal [0x27],
+                 @client.iso_apdu!(:ins => 0x31, :p1 => 0x41, :p2 => 0x59)
+    @client.disconnect
+    Kernel.sleep 0.05  # Wait for the server to process the disconnect.
+    assert_equal [:start, apdu_request, :end], logic.received
+  end
+end

data/test/{test_containers.rb → pcsc/containers_test.rb}

@@ -1,6 +1,12 @@
-require 'test/unit'
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
 require 'smartcard'
 
+require 'test/unit'
+
+
 class ContainersTest < Test::Unit::TestCase
   def setup
     

data/test/{test_smoke.rb → pcsc/smoke_test.rb}

@@ -1,6 +1,12 @@
-require 'test/unit'
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
 require 'smartcard'
 
+require 'test/unit'
+
+
 class SmokeTest < Test::Unit::TestCase
   def setup
   end

data/tests/ts_pcsc_ext.rb

@@ -1,3 +1,7 @@
+# Author:: Victor Costan
+# Copyright:: Copyright (C) 2008 Massachusetts Institute of Technology
+# License:: MIT
+
 require 'smartcard'
 require 'pp'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: smartcard
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors: 
 - Victor Costan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-31 00:00:00 -04:00
+date: 2009-08-18 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -35,7 +35,15 @@ extra_rdoc_files:
 - ext/smartcard_pcsc/pcsc_reader_states.c
 - ext/smartcard_pcsc/pcsc_surrogate_reader.h
 - ext/smartcard_pcsc/pcsc_surrogate_wintypes.h
-- lib/smartcard/pcsc_exception.rb
+- lib/smartcard/gp/gp_card_mixin.rb
+- lib/smartcard/iso/auto_configurator.rb
+- lib/smartcard/iso/iso_card_mixin.rb
+- lib/smartcard/iso/jcop_remote_protocol.rb
+- lib/smartcard/iso/jcop_remote_server.rb
+- lib/smartcard/iso/jcop_remote_transport.rb
+- lib/smartcard/iso/pcsc_transport.rb
+- lib/smartcard/iso/transport.rb
+- lib/smartcard/pcsc/pcsc_exception.rb
 - lib/smartcard.rb
 - LICENSE
 - README
@@ -55,16 +63,28 @@ files:
 - ext/smartcard_pcsc/pcsc_reader_states.c
 - ext/smartcard_pcsc/pcsc_surrogate_reader.h
 - ext/smartcard_pcsc/pcsc_surrogate_wintypes.h
-- lib/smartcard/pcsc_exception.rb
+- lib/smartcard/gp/gp_card_mixin.rb
+- lib/smartcard/iso/auto_configurator.rb
+- lib/smartcard/iso/iso_card_mixin.rb
+- lib/smartcard/iso/jcop_remote_protocol.rb
+- lib/smartcard/iso/jcop_remote_server.rb
+- lib/smartcard/iso/jcop_remote_transport.rb
+- lib/smartcard/iso/pcsc_transport.rb
+- lib/smartcard/iso/transport.rb
+- lib/smartcard/pcsc/pcsc_exception.rb
 - lib/smartcard.rb
 - LICENSE
 - Manifest
+- Rakefile
 - README
-- test/test_containers.rb
-- test/test_smoke.rb
-- tests/ts_pcsc_ext.rb
 - smartcard.gemspec
-- Rakefile
+- test/gp/gp_card_mixin_test.rb
+- test/iso/auto_configurator_test.rb
+- test/iso/iso_card_mixin_test.rb
+- test/iso/jcop_remote_test.rb
+- test/pcsc/containers_test.rb
+- test/pcsc/smoke_test.rb
+- tests/ts_pcsc_ext.rb
 has_rdoc: true
 homepage: http://www.costan.us/smartcard
 licenses: []
@@ -95,10 +115,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: smartcard
-rubygems_version: 1.3.4
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Interface with ISO 7816 smart cards.
 test_files: 
-- test/test_containers.rb
-- test/test_smoke.rb
+- test/gp/gp_card_mixin_test.rb
+- test/iso/auto_configurator_test.rb
+- test/iso/iso_card_mixin_test.rb
+- test/iso/jcop_remote_test.rb
+- test/pcsc/containers_test.rb
+- test/pcsc/smoke_test.rb