smartcard 0.3.1-x86-mswin32-60

data/ext/smartcard_pcsc/pcsc_exception.c

@@ -0,0 +1,39 @@
+#include "pcsc.h"
+
+VALUE ePcscException;
+
+#if defined(WIN32)
+static char scard_error_buffer[128];
+
+/* Produces a string for an error code yielded by the SCard* PC/SC functions. Returns a static global buffer. */
+static char *pcsc_stringify_error(DWORD scard_error) {
+	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+		NULL, scard_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        scard_error_buffer, sizeof(scard_error_buffer), NULL );
+	return scard_error_buffer;
+}
+#endif
+
+
+#ifdef MAKE_RDOC_HAPPY
+	mSmartcard = rb_define_module("Smartcard");
+	mPcsc = rb_define_module_under(mSmartcard, "PCSC");
+#endif
+
+/* :Document-class: Smartcard::PCSC::Exception
+ * Contains information about an exception at the PC/SC layer.
+ */
+void Init_PCSC_Exception() {
+	ePcscException = rb_define_class_under(mPcsc, "PcscException", rb_eRuntimeError);
+}
+
+/* Raises a PC/SC error. */
+void _PCSC_Exception_raise(DWORD pcsc_error, char *pcsc_function) {
+	char buf[BUFSIZ];
+	VALUE exception;
+	
+	sprintf(buf, "%s: %s", pcsc_function, pcsc_stringify_error(pcsc_error));
+	exception = rb_exc_new2(ePcscException, buf);
+	rb_iv_set(exception, "@errno", INT2NUM(pcsc_error));
+	rb_exc_raise(exception);
+}

data/ext/smartcard_pcsc/pcsc_io_request.c

@@ -0,0 +1,129 @@
+#include "pcsc.h"
+
+VALUE cPcscIoRequest;
+
+/* Wraps a SCARD_IO_REQUEST, tracking its allocation etc. */
+struct SCardIoRequestEx {
+	SCARD_IO_REQUEST *pcsc_request;
+	int mallocd; 
+};
+
+/* Custom free for Smartcard::PCSC::IoRequest. */
+static void PCSC_IoRequest_free(struct SCardIoRequestEx *_request) {
+	if(_request != NULL) {
+		if(_request->mallocd)
+			xfree(_request->pcsc_request);
+		xfree(_request);
+	}
+}
+
+/* Custom allocation for Smartcard::PCSC::Card. Wraps a SCardIoRequestEx. */
+static VALUE PCSC_IoRequest_alloc(VALUE klass) {
+	struct SCardIoRequestEx *request;
+	
+	VALUE rbIoRequest = Data_Make_Struct(klass, struct SCardIoRequestEx, NULL, PCSC_IoRequest_free, request);
+	request->pcsc_request = NULL;
+	request->mallocd = 0;
+	return rbIoRequest;
+}
+
+/* :Document-method: new
+ * call-seq:
+ *      new() --> io_request
+ * 
+ * Creates an uninitialized IoRequest. 
+ * The request can be used as a receiving IoRequest in Smartcard::PCSC::Card#transmit.
+ */
+static VALUE PCSC_IoRequest_initialize(VALUE self) {
+	struct SCardIoRequestEx *request;	
+	
+	Data_Get_Struct(self, struct SCardIoRequestEx, request);
+	request->pcsc_request = ALLOC(SCARD_IO_REQUEST);
+	request->mallocd = 1;
+	
+	return self;
+}
+
+/* :Document-method: protocol
+ * call-seq:
+ *      io_request.protocol --> protocol
+ * 
+ * The protocol of this instance.
+ * 
+ * The returned protocol is a number, and should be checked against one of the Smartcard::PCSC::PROTOCOL_ constants.
+ */
+static VALUE PCSC_IoRequest_get_protocol(VALUE self) {
+	struct SCardIoRequestEx *request;
+	
+	Data_Get_Struct(self, struct SCardIoRequestEx, request);
+	if(request == NULL) return Qnil;
+	
+	return UINT2NUM(request->pcsc_request->dwProtocol);
+}
+
+/* :Document-method: protocol=
+ * call-seq:
+ *      io_request.protocol = protocol
+ * 
+ * Sets the protocol of this instance.
+ * 
+ * +protocol+:: use one of the Smartcard::PCSC::PROTOCOL_ constants
+ */
+static VALUE PCSC_IoRequest_set_protocol(VALUE self, VALUE rbProtocol) {
+	struct SCardIoRequestEx *request;
+	
+	Data_Get_Struct(self, struct SCardIoRequestEx, request);
+	if(request == NULL) return self;
+	
+	if(request->mallocd == 0)
+		rb_raise(rb_eSecurityError, "cannot modify PC/SC-global (read-only) IO_REQUEST");
+	else
+		request->pcsc_request->dwProtocol = NUM2UINT(rbProtocol);
+	return self;
+}
+
+#ifdef MAKE_RDOC_HAPPY
+	mSmartcard = rb_define_module("Smartcard");
+	mPcsc = rb_define_module_under(mSmartcard, "PCSC");
+#endif
+
+/* :Document-class: Smartcard::PCSC::IoRequest
+ * Protocol information used in Smartcard::PCSC::Card#transmit.
+ * Wraps a _SCARD_IO_REQUEST_ structure.
+ * 
+ * I know the name is retarded, but it reflects the PC/SC name well. The choice makes sense given that this
+ * is an API meant for people familiar with the PC/SC specification.
+ */
+void Init_PCSC_IoRequest() {
+	cPcscIoRequest = rb_define_class_under(mPcsc, "IoRequest", rb_cObject);
+	rb_define_alloc_func(cPcscIoRequest, PCSC_IoRequest_alloc);
+	rb_define_method(cPcscIoRequest, "initialize", PCSC_IoRequest_initialize, 0);	
+	rb_define_method(cPcscIoRequest, "protocol", PCSC_IoRequest_get_protocol, 0);	
+	rb_define_method(cPcscIoRequest, "protocol=", PCSC_IoRequest_set_protocol, 1);	
+}
+
+/* Retrieves the SCARD_IO_REQUEST wrapped into a Smartcard::PCSC::IoRequest instance. */
+int _PCSC_IoRequest_lowlevel_get(VALUE rbIoRequest, SCARD_IO_REQUEST **io_request) {
+	struct SCardIoRequestEx *request;	
+
+	if(!RTEST(rbIoRequest)) {
+		*io_request = NULL;
+		return 1;
+	}
+	if(TYPE(rbIoRequest) != T_DATA || RDATA(rbIoRequest)->dfree != (void (*)(void *))PCSC_IoRequest_free)
+		return 0;
+	
+	Data_Get_Struct(rbIoRequest, struct SCardIoRequestEx, request);
+	*io_request = request->pcsc_request;
+	return 1;
+}
+
+/* Creates a Smartcard::PCSC::IoRequest instance wrapping a given SCARD_IO_REQUEST. */
+VALUE _PCSC_IoRequest_lowlevel_new(const SCARD_IO_REQUEST *io_request) {
+	struct SCardIoRequestEx *request;
+	
+	VALUE rbIoRequest = Data_Make_Struct(cPcscIoRequest, struct SCardIoRequestEx, NULL, PCSC_IoRequest_free, request);
+	request->pcsc_request = io_request;
+	request->mallocd = 0;
+	return rbIoRequest;
+}

data/ext/smartcard_pcsc/pcsc_main.c

@@ -0,0 +1,11 @@
+#include "pcsc.h"
+
+void Init_pcsc() {
+	Init_PCSC_Namespace();
+	Init_PCSC_ReaderStates();
+	Init_PCSC_IoRequest();
+	Init_PCSC_Context();
+	Init_PCSC_Card();
+	Init_PCSC_Consts();
+	Init_PCSC_Exception();
+}

data/ext/smartcard_pcsc/pcsc_multi_strings.c

@@ -0,0 +1,70 @@
+#include <string.h>
+#include "pcsc.h"
+
+/* Converts a multi-string "str1\0str_2\0str3\0\0" into a Ruby array of Ruby strings. */
+VALUE PCSC_Internal_multistring_to_ruby_array(char *mstr, size_t mstr_len) {
+	VALUE rbArray, rbString;
+	size_t i, start_offset;
+	
+	rbArray = rb_ary_new();
+	for(i = 0; i < mstr_len; i++) {
+		if(mstr[i] == '\0') break;
+		start_offset = i;
+		for(; i < mstr_len; i++)
+			if(mstr[i] == '\0') break;
+		rbString = rb_str_new(mstr + start_offset, i - start_offset);
+		rb_ary_push(rbArray, rbString);
+	}
+	return rbArray;
+}
+
+/* Constructs a multi-string "str1\0str_2\0str3\0\0". Takes nil, a string, or an array of strings.
+ * The returned buffer must be released with xfree.
+ * If false is returned, something went wrong and the method did not return a buffer. 
+ */
+int PCSC_Internal_ruby_strings_to_multistring(VALUE rbStrings, char **strings) {
+	VALUE *array_elements;
+	char *buffer;
+	size_t string_length, array_length, buffer_length, i;
+	
+	/* nil -> NULL */ 
+	if(TYPE(rbStrings) == T_NIL || TYPE(rbStrings) == T_FALSE) {
+		*strings = NULL;
+		return 1;
+	}
+	/* string -> [string] */
+	if(TYPE(rbStrings) == T_STRING) {
+		string_length = RSTRING(rbStrings)->len; 
+		buffer = ALLOC_N(char, string_length + 2);
+		memcpy(buffer, RSTRING(rbStrings)->ptr, string_length);
+		buffer[string_length] = buffer[string_length + 1] = '\0';
+		*strings = buffer;
+		return 1;
+	}
+	/* array -> array */
+	if(TYPE(rbStrings) == T_ARRAY) {
+		/* compute buffer length */
+		array_length = RARRAY(rbStrings)->len;
+		array_elements = RARRAY(rbStrings)->ptr;
+		buffer_length = 1; /* for the trailing '\0' */
+		for(i = 0; i < array_length; i++) {
+			if(TYPE(array_elements[i]) != T_STRING)
+				return 0;
+			buffer_length += RSTRING(array_elements[i])->len + 1; 
+		}
+		
+		/* concatenate strings into buffer */
+		buffer = ALLOC_N(char, buffer_length);
+		for(buffer_length = 0, i = 0; i < array_length; i++) {
+			string_length = RSTRING(array_elements[i])->len;
+			memcpy(buffer + buffer_length, RSTRING(array_elements[i])->ptr, string_length);
+			buffer[buffer_length] = '\0';
+			buffer_length += string_length + 1;
+		}
+		buffer[buffer_length] = '\0';
+		*strings = buffer;
+		return 1;
+	}
+	
+	return 0;
+}

data/ext/smartcard_pcsc/pcsc_namespace.c

@@ -0,0 +1,18 @@
+#include "pcsc.h"
+
+VALUE mSmartcard;
+VALUE mPcsc;
+
+/* :Document-class: Smartcard::PCSC
+ * Bindings to the PC/SC Smartcard API.
+ * 
+ */
+static void Init_PCSC() {
+	mPcsc = rb_define_module_under(mSmartcard, "PCSC");
+}
+
+void Init_PCSC_Namespace() {
+	mSmartcard = rb_define_module("Smartcard");
+	Init_PCSC();
+}
+

data/ext/smartcard_pcsc/pcsc_reader_states.c

@@ -0,0 +1,326 @@
+#include "pcsc.h"
+
+VALUE cPcscReaderStates;
+
+/* Wraps an array of SCARD_READERSTATE elements. */
+struct PCSCReaderStates {
+	size_t states_count; 
+	SCARD_READERSTATE *states;
+};
+
+/* Custom free for Smartcard::PCSC::ReaderStates. Also releases the referenced buffers (for the reader names). */
+static void PCSC_ReaderStates_free(struct PCSCReaderStates *_states) {
+	size_t i;
+	if(_states != NULL) {
+		if(_states->states != NULL) {
+			for(i = 0; i < _states->states_count; i++) {
+				if(_states->states[i].szReader != NULL)
+					xfree((char *)_states->states[i].szReader);
+			}
+			xfree(_states->states);
+		}
+		xfree(_states);
+	}
+}
+
+/* Custom allocation for Smartcard::PCSC::ReaderStates. Wraps a reference to an array of SCARD_READERSTATE. */
+static VALUE PCSC_ReaderStates_alloc(VALUE klass) {
+	struct PCSCReaderStates *states;
+	
+	VALUE rbReaderStates = Data_Make_Struct(klass, struct PCSCReaderStates, NULL, PCSC_ReaderStates_free, states);
+	states->states_count = 0;
+	states->states = NULL;
+	return rbReaderStates;
+}
+
+/* :Document-method: new
+ * call-seq:
+ *      new(num_states) --> reader_states
+ * 
+ * Creates an array of +num_states+ reader state elements.
+ * The states are unusable until they are assigned reader names by calling ReaderStates#set_reader_name_of.
+ */
+static VALUE PCSC_ReaderStates_initialize(VALUE self, VALUE rbNumStates) {
+	struct PCSCReaderStates *states;	
+	size_t states_count, i;
+	
+	Data_Get_Struct(self, struct PCSCReaderStates, states);
+	
+	states_count = NUM2UINT(rbNumStates);
+	if(states_count > 0) {
+		states->states = ALLOC_N(SCARD_READERSTATE, states_count);
+		if(states->states != NULL) {
+			states->states_count = states_count;
+			for(i = 0; i < states_count; i++) {
+				states->states[i].szReader = NULL;
+				states->states[i].dwCurrentState = SCARD_STATE_UNAWARE;
+			}
+		}
+	}
+	return self;
+}
+
+static int _validate_readerstates_args(VALUE rbReaderStates, VALUE rbIndex, struct PCSCReaderStates **states, size_t *index) {
+	Data_Get_Struct(rbReaderStates, struct PCSCReaderStates, *states);
+	if(*states == NULL) return 0;
+
+	*index = NUM2UINT(rbIndex);
+	if(*index >= (*states)->states_count) {
+		rb_raise(rb_eIndexError, "index %u is invalid (states array has %u elements)", *index, (*states)->states_count);
+		return 0;
+	}
+	
+	return 1;
+}
+
+/* :Document-method: current_state_of
+ * call-seq:
+ *      current_state_of(index) --> current_state
+ * 
+ * The current state (_dwCurrentState_ in PC/SC) in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change blocks as long as the reader state equals this value. 
+ * 
+ * The returned state is a bitfield; the bits are defined in the Smartcard::PCSC::STATE_ constants. 
+ * 
+ * +index+:: the 0-based index of the reader state element to be queried
+ */
+static VALUE PCSC_ReaderStates_current_state_of(VALUE self, VALUE rbIndex) {
+	struct PCSCReaderStates *states;
+	size_t index;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return Qnil;
+	
+	return UINT2NUM(states->states[index].dwCurrentState);
+}
+
+/* :Document-method: event_state_of
+ * call-seq:
+ *      event_state_of(index) --> event_state
+ * 
+ * The event state (_dwEventState_ in PC/SC) in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change stores the updated reader state in this value. 
+ * 
+ * The returned state is a bitfield; the bits are defined in the Smartcard::PCSC::STATE_ constants. 
+ * 
+ * +index+:: the 0-based index of the reader state element to be queried
+ */
+static VALUE PCSC_ReaderStates_event_state_of(VALUE self, VALUE rbIndex) {
+	struct PCSCReaderStates *states;
+	size_t index;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return Qnil;
+	
+	return UINT2NUM(states->states[index].dwEventState);
+}
+
+/* :Document-method: set_current_state_of!
+ * call-seq:
+ *      set_current_state_of!(index, current_state) --> self 
+ * 
+ * Sets the current state (_dwCurrentState_ in PC/SC) in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change blocks as long as the reader state equals this value. 
+ * 
+ * 
+ * +index+:: the 0-based index of the reader state element to be modified
+ * +current_state+:: a bitfield; the bits are defined in the Smartcard::PCSC::STATE_ constants. 
+ */
+static VALUE PCSC_ReaderStates_set_current_state_of(VALUE self, VALUE rbIndex, VALUE rbCurrentState) {
+	struct PCSCReaderStates *states;
+	size_t index;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return self;
+
+	states->states[index].dwCurrentState = NUM2UINT(rbCurrentState);
+	return self;
+}
+
+/* :Document-method: set_event_state_of!
+ * call-seq:
+ *      set_event_state_of!(index, event_state) --> self 
+ * 
+ * Sets the event state (_dwEventState_ in PC/SC) in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change stores the updated reader state in this value. 
+ * 
+ * +index+:: the 0-based index of the reader state element to be modified
+ * +event_state+:: a bitfield; the bits are defined in the Smartcard::PCSC::STATE_ constants. 
+ */
+static VALUE PCSC_ReaderStates_set_event_state_of(VALUE self, VALUE rbIndex, VALUE rbEventState) {
+	struct PCSCReaderStates *states;
+	size_t index;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return self;
+
+	states->states[index].dwEventState = NUM2UINT(rbEventState);
+	return self;
+}
+
+/* :Document-method: atr_of
+ * call-seq:
+ *      atr_of(index) --> atr
+ * 
+ * The card ATR string in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change stores the updated ATR string in this value. 
+ * 
+ * The returned ATR bytes are wrapped into a string. (don't complain, it's a low-level API)
+ * 
+ * +index+:: the 0-based index of the reader state element to be queried
+ */
+static VALUE PCSC_ReaderStates_atr_of(VALUE self, VALUE rbIndex) {
+	struct PCSCReaderStates *states;
+	size_t index;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return Qnil;
+	
+	return rb_str_new((char *)states->states[index].rgbAtr, states->states[index].cbAtr);
+}
+
+/* :Document-method: set_atr_of!
+ * call-seq:
+ *      set_atr_of!(index, atr) --> self
+ * 
+ * Sets the card ATR string in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change stores the updated ATR string in this value. 
+ * 
+ * +index+:: the 0-based index of the reader state element to be modified
+ * +atr+:: ATR bytes wrapped into a string (low-level API, remember?)
+ */
+static VALUE PCSC_ReaderStates_set_atr_of(VALUE self, VALUE rbIndex, VALUE rbAtr) {
+	struct PCSCReaderStates *states;
+	size_t index;
+	VALUE rbFinalAtr;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return self;
+	
+	rbFinalAtr = rb_check_string_type(rbAtr);
+	if(NIL_P(rbFinalAtr))
+		return self;
+
+	if(RSTRING(rbFinalAtr)->len > MAX_ATR_SIZE) {
+		rb_raise(rb_eArgError, "given ATR is too long (%d characters given; can do at most MAX_ATR_SIZE = %d)", RSTRING(rbFinalAtr)->len, MAX_ATR_SIZE);
+		return self;		
+	}
+	
+	states->states[index].cbAtr = RSTRING(rbAtr)->len; 
+	memcpy(states->states[index].rgbAtr, RSTRING(rbAtr)->ptr, states->states[index].cbAtr);
+	return self;
+}
+
+/* :Document-method: reader_name_of
+ * call-seq:
+ *      reader_name_of(index) --> reader_name
+ * 
+ * The name of the reader whose status is represented in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change reads this value, and never updates it. 
+ * 
+ * +index+:: the 0-based index of the reader state element to be queried
+ */
+static VALUE PCSC_ReaderStates_reader_name_of(VALUE self, VALUE rbIndex) {
+	struct PCSCReaderStates *states;
+	size_t index;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return Qnil;
+	
+	return rb_str_new2(states->states[index].szReader);
+}
+
+/* :Document-method: set_reader_name_of!
+ * call-seq:
+ *      set_reader_name_of!(index, reader_name) --> self
+ * 
+ * The name of the reader whose status is represented in the <tt>index</tt>th reader state element.
+ * Smartcard::PCSC::Context#get_status_change reads this value, and never updates it. 
+ * 
+ * +index+:: the 0-based index of the reader state element to be modified
+ * +reader_name+:: a string-like object containing the reader name to be associated with the state element
+ */
+static VALUE PCSC_ReaderStates_set_reader_name_of(VALUE self, VALUE rbIndex, VALUE rbReaderName) {
+	struct PCSCReaderStates *states;
+	size_t index, reader_name_length;
+	VALUE rbFinalReaderName;
+	
+	if(_validate_readerstates_args(self, rbIndex, &states, &index) == 0)
+		return self;
+	
+	rbFinalReaderName = rb_check_string_type(rbReaderName);
+	if(NIL_P(rbFinalReaderName))
+		return self;
+
+	reader_name_length = RSTRING(rbFinalReaderName)->len;
+	if(states->states[index].szReader != NULL)
+		xfree((char *)states->states[index].szReader);
+	states->states[index].szReader = ALLOC_N(char, reader_name_length + 1);
+	if(states->states[index].szReader != NULL) {
+		memcpy((char *)states->states[index].szReader, RSTRING(rbFinalReaderName)->ptr, reader_name_length);
+		((char *)states->states[index].szReader)[reader_name_length] = '\0';
+	}	
+	return self;
+}
+
+/* :Document-method: acknowledge_events!
+ * call-seq:
+ *      acknowledge_events!() --> self
+ * 
+ * Mass-assigns +current_state+ to +event_state+ for each reader state element.
+ * Useful to acknowledge all the status changed communicated after a call to Smartcard::PCSC::Context#get_status_change
+ * (and thus prepare for a new call). 
+ */
+static VALUE PCSC_ReaderStates_acknowledge_events(VALUE self) {
+	struct PCSCReaderStates *states;
+	size_t i;
+	
+	Data_Get_Struct(self, struct PCSCReaderStates, states);
+	if(states != NULL) {
+		for(i = 0; i < states->states_count; i++)
+			states->states[i].dwCurrentState = states->states[i].dwEventState; 
+	}
+	return self;
+}
+
+#ifdef MAKE_RDOC_HAPPY
+	mSmartcard = rb_define_module("Smartcard");
+	mPcsc = rb_define_module_under(mSmartcard, "PCSC");
+#endif
+
+/* :Document-class: Smartcard::PCSC::ReaderStates
+ * Tracks reader status information, and is used in Smartcard::PCSC::Context#get_status_change.
+ * Wraps an array of <i>SCARD_READERSTATE</i> structures.
+ */
+void Init_PCSC_ReaderStates() {
+	cPcscReaderStates = rb_define_class_under(mPcsc, "ReaderStates", rb_cObject);
+	rb_define_alloc_func(cPcscReaderStates, PCSC_ReaderStates_alloc);
+	rb_define_method(cPcscReaderStates, "initialize", PCSC_ReaderStates_initialize, 1);	
+	rb_define_method(cPcscReaderStates, "current_state_of", PCSC_ReaderStates_current_state_of, 1);	
+	rb_define_method(cPcscReaderStates, "set_current_state_of!", PCSC_ReaderStates_set_current_state_of, 2);	
+	rb_define_method(cPcscReaderStates, "event_state_of", PCSC_ReaderStates_event_state_of, 1);	
+	rb_define_method(cPcscReaderStates, "set_event_state_of!", PCSC_ReaderStates_set_event_state_of, 2);	
+	rb_define_method(cPcscReaderStates, "reader_name_of", PCSC_ReaderStates_reader_name_of, 1);	
+	rb_define_method(cPcscReaderStates, "set_reader_name_of!", PCSC_ReaderStates_set_reader_name_of, 2);	
+	rb_define_method(cPcscReaderStates, "atr_of", PCSC_ReaderStates_atr_of, 1);	
+	rb_define_method(cPcscReaderStates, "set_atr_of!", PCSC_ReaderStates_set_atr_of, 2);	
+	rb_define_method(cPcscReaderStates, "acknowledge_events!", PCSC_ReaderStates_acknowledge_events, 0);	
+}
+
+/* Retrieves the SCARD_READERSTATE array wrapped into a Smartcard::PCSC::ReaderStates instance. */
+int _PCSC_ReaderStates_lowlevel_get(VALUE rbReaderStates, SCARD_READERSTATE **reader_states, size_t *reader_states_count) {
+	struct PCSCReaderStates *states;	
+
+	if(!RTEST(rbReaderStates)) {
+		*reader_states = NULL;
+		*reader_states_count = 0;
+		return 1;
+	}
+	if(TYPE(rbReaderStates) != T_DATA || RDATA(rbReaderStates)->dfree != (void (*)(void *))PCSC_ReaderStates_free)
+		return 0;
+	
+	Data_Get_Struct(rbReaderStates, struct PCSCReaderStates, states);
+	*reader_states = states->states;
+	*reader_states_count = states->states_count;
+	return 1;
+}