usb-ccid device (v2)
cover usb-ccid device (v2)
This patch adds a new device, it is described in full in the second patch intro and also in the documentation in docs. In brief it provides a standard smart card reader device.
The first patch is the configure change and docs.
The second patch contains the actual device, I couldn't figure out a good way to split it to ease review.
v2 changed:
* all QSIMPLEQ turned into fixed sized rings
* all allocated buffers turned into fixed size buffers
* added migration support
* added a message to tell client qemu has migrated to ip:port
* for lack of monitor commands ip:port are 0:0, which causes the updated vscclient to connect to one port higher on the same host. will add monitor commands in a separate patch. tested with current setup.
Alon Levy (2):
usb-ccid: add CCID device. add configure option.
usb-ccid: add CCID device (device itself)
Makefile.objs | 1 + configure | 12 + docs/usb-ccid.txt | 115 +++++ hw/usb-ccid.c | 1376 ++++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vscard_common.h | 131 +++++ 5 files changed, 1635 insertions(+), 0 deletions(-) create mode 100644 docs/usb-ccid.txt create mode 100644 hw/usb-ccid.c create mode 100644 hw/vscard_common.h
Signature · 1 line
1.7.3.1
PATCH 1/2 usb-ccid: add CCID device. add configure option.
This patch adds the configure option --enable-smartcard, adds hw/usb-ccid.c to Makefile.objs, and adds the documentation. Only an empty hw/usb-ccid.c is provided (couldn't add an empty file so added initial comment only).
--- Makefile.objs | 1 + configure | 12 +++++ docs/usb-ccid.txt | 115 +++++++++++++++++++++++++++++++++++++++++++++ hw/usb-ccid.c | 13 +++++ hw/vscard_common.h | 131 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 272 insertions(+), 0 deletions(-) create mode 100644 docs/usb-ccid.txt create mode 100644 hw/usb-ccid.c create mode 100644 hw/vscard_common.h
Makefile.objs +1 -0
@@ -170,6 +170,7 @@ hw-obj-$(CONFIG_FDC) += fdc.o hw-obj-$(CONFIG_ACPI) += acpi.o acpi_piix4.o hw-obj-$(CONFIG_APM) += pm_smbus.o apm.o hw-obj-$(CONFIG_DMA) += dma.o +hw-obj-$(CONFIG_SMARTCARD) += usb-ccid.o # PPC devices hw-obj-$(CONFIG_OPENPIC) += openpic.o
configure +12 -0
@@ -327,6 +327,7 @@ user_pie="no" zero_malloc="" trace_backend="nop" trace_file="trace" +smartcard="no" # OS specific if check_define __linux__ ; then
@@ -730,6 +731,10 @@ for opt do ;; --enable-vhost-net) vhost_net="yes" ;; + --disable-smartcard) smartcard="no" + ;; + --enable-smartcard) smartcard="yes" + ;; --*dir) ;; *) echo "ERROR: unknown option $opt"; show_help="yes"
@@ -921,6 +926,8 @@ echo " --enable-vhost-net enable vhost-net acceleration support" echo " --trace-backend=B Trace backend nop simple ust" echo " --trace-file=NAME Full PATH,NAME of file to store traces" echo " Default:trace-<pid>" +echo " --disable-smartcard disable smartcard support" +echo " --enable-smartcard enable smartcard support" echo "" echo "NOTE: The object files are built at the place where configure is launched" exit 1
@@ -2285,6 +2292,7 @@ echo "uuid support $uuid" echo "vhost-net support $vhost_net" echo "Trace backend $trace_backend" echo "Trace output file $trace_file-<pid>" +echo "smartcard support $smartcard" if test $sdl_too_old = "yes"; then echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -2540,6 +2548,10 @@ if test "$posix_madvise" = "yes" ; then echo "CONFIG_POSIX_MADVISE=y" >> $config_host_mak fi +if test "$smartcard" = "yes" ; then + echo "CONFIG_SMARTCARD=y" >> $config_host_mak +fi + # XXX: suppress that if [ "$bsd" = "yes" ] ; then echo "CONFIG_BSD=y" >> $config_host_mak
docs/usb-ccid.txt new file +115 -0
115 lines not on this page · raw message
hw/usb-ccid.c new file +13 -0
@@ -0,0 +1,13 @@ +/* +* CCID Device emulation +* +* Based on usb-serial.c: +* Copyright (c) 2006 CodeSourcery. +* Copyright (c) 2008 Samuel Thibault <[email protected]> +* Written by Paul Brook, reused for FTDI by Samuel Thibault, +* reused for CCID by Alon Levy. +* Copyright (c) 2010 Red Hat. +* +* This code is licenced under the LGPL. +*/ +
hw/vscard_common.h new file +131 -0
131 lines not on this page · raw message
Signature · 1 line
1.7.3.1
PATCH 2/2 usb-ccid: add CCID device (device itself)
In reply to Alon LevyA CCID device is a smart card reader. It is a USB device, defined at [2]. The usb-ccid device expects a chardev option and uses the VSCARD protocol defined in vscard_common.h. It starts as an unattached device unless auto_attach=1.
The utility vscclient, bundled with libcac_card, provides the client side, together they provide simultaneous access to the card reader an the card attached to it, both in the guest and client machines, as opposed t a simple usb host passthrough. You can also use it to provide a virtual card
[1] libcac_card http://cgit.freedesktop.org/~alon/cac_card (temporary home) written by Robert Relyea <[email protected]>
[2] http://www.usb.org/developers/devclass_docs/DWG_Smart-Card_CCID_Rev110.
--- hw/usb-ccid.c | 1363 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 1363 insertions(+), 0 deletions(-)
hw/usb-ccid.c +1363 -0
@@ -11,3 +11,1366 @@* This code is licenced under the LGPL. */ +/* References: +* +* CCID Specification Revision 1.1 April 22nd 2005 +* "Universal Serial Bus, Device Class: Smart Card" +* Specification for Integrated Circuit(s) Cards Interface Devices +* +* KNOWN BUGS +* 1. remove/insert can sometimes result in removed state instead of inserted. +* This is a result of the following: +* symptom: dmesg shows ERMOTEIO (-121), pcscd shows -99. Thsi happens +* when we send a too short packet, seen in uhci-usb.c, resulting from +* a urb requesting SPD and us returning a smaller packet. +* Not sure which messages trigger this. +* +*/ + +#include "qemu-common.h" +#include "qemu-error.h" +#include "usb.h" +#include "qemu-char.h" + +#include "hw/vscard_common.h" + +//#define DEBUG_CCID + +static int debug =0 ; + +#define DPRINTF (lvl, fmt, ...) \ +do { if (lvl <= debug) { printf("usb-ccid: " fmt , ## __VA_ARGS__); } } while (0) + +#define CCID_DEV_NAME "usb-ccid" + +/* The two options for variable sized buffers: +* make them constant size, for large enough constant, +* or handle the migration complexity - VMState doesn't handle this case. +* sizes are expected never to be exceeded, unless client misbehaves. */ +#define BULK_OUT_DATA_SIZE 65536 +#define PENDING_ANSWERS_NUM 128 +#define VSCARD_IN_SIZE 65536 + +#define BULK_IN_BUF_SIZE 384 +#define BULK_IN_PENDING_NUM 8 + +#define InterfaceOutClass ((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8) +#define InterfaceInClass ((USB_DIR_IN |USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8) + +#define CCID_CONTROL_ABORT 0x1 +#define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2 +#define CCID_CONTROL_GET_DATA_RATES 0x3 + +#define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID" +#define CCID_VENDOR_DESCRIPTION "QEMU " QEMU_VERSION +#define CCID_INTERFACE_NAME "CCID Interface" +#define CCID_SERIAL_NUMBER_STRING "1" +/* Using Gemplus Vendor and Product id +Effect on various drivers: +* usbccid.sys (winxp, others untested) is a class driver so it doesn't care. +* linux has a number of class drivers, but openct filters based on +vendor/product (/etc/openct.conf under fedora), hence Gemplus. +*/ +#define CCID_VENDOR_ID 0x08e6 +#define CCID_PRODUCT_ID 0x4433 +#define CCID_DEVICE_VERSION 0x0000 + +/* BULK_OUT messages from PC to Reader +Defined in CCID Rev 1.1 6.1 (page 26) +*/ +#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62 +#define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63 +#define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65 +#define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f +#define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c +#define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d +#define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61 +#define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b +#define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e +#define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a +#define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69 +#define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71 +#define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72 +#define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73 + +/* BULK_IN messages from Reader to PC +Defined in CCID Rev 1.1 6.2 (page 48) +*/ +#define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80 +#define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81 +#define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82 +#define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83 +#define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84 + +/* INTERRUPT_IN messages from Reader to PC +Defined in CCID Rev 1.1 6.3 (page 56) +*/ +#define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50 +#define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51 + +/* Endpoints for CCID - addresses are up to us to decide. +To support slot insertion and removal we must have an interrupt in ep +in addition we need a bulk in and bulk out ep +5.2, page 20 +*/ +#define CCID_INT_IN_EP 1 +#define CCID_BULK_IN_EP 2 +#define CCID_BULK_OUT_EP 3 + +/* bmSlotICCState masks */ +#define SLOT_0_STATE_MASK 1 +#define SLOT_0_CHANGED_MASK 2 + +/* Status codes that go in bStatus (see 6.2.6) */ +enum { +ICC_STATUS_PRESENT_ACTIVE =0 , +ICC_STATUS_PRESENT_INACTIVE , +ICC_STATUS_NOT_PRESENT +}; + +enum { +COMMAND_STATUS_NO_ERROR =0 , +COMMAND_STATUS_FAILED , +COMMAND_STATUS_TIME_EXTENSION_REQUIRED +}; + +/* Error codes that go in bError (see 6.2.6) +*/ +enum { +ERROR_CMD_NOT_SUPPORTED =0 , +ERROR_CMD_ABORTED =-1 , +ERROR_ICC_MUTE =-2 , +ERROR_XFR_PARITY_ERROR =-3 , +ERROR_XFR_OVERRUN =-4 , +ERROR_HW_ERROR =-5 , +}; + +/* 6.2.6 RDR_to_PC_SlotStatus definitions */ +enum { +CLOCK_STATUS_RUNNING =0 , +/* 0 - Clock Running, 1 - Clock stopped in State L, 2 - H, +3 - unkonwn state. rest are RFU +*/ +}; + +typedef struct __attribute__ ((__packed__ )) { +uint8_t bMessageType; +uint32_t dwLength; +uint8_t bSlot; +uint8_t bSeq; +}CCID_Header ; + +typedef struct __attribute__ ((__packed__ )) { +CCID_Header hdr; +uint8_t bStatus;/* Only used in BULK_IN */ +uint8_t bError;/* Only used in BULK_IN */ +}CCID_BULK_IN ; + +typedef struct __attribute__ ((__packed__ )) { +CCID_BULK_IN b; +uint8_t bClockStatus; +}CCID_SlotStatus ; + +typedef struct __attribute__ ((__packed__ )) { +CCID_BULK_IN b; +uint8_t bProtocolNum; +uint8_t abProtocolDataStructure[0 ]; +}CCID_Parameter ; + +typedef struct __attribute__ ((__packed__ )) { +CCID_BULK_IN b; +uint8_t bChainParameter; +uint8_t abData[0 ]; +}CCID_DataBlock ; + +/* 6.1.4 PC_to_RDR_XfrBlock */ +typedef struct __attribute__ ((__packed__ )) { +CCID_Header hdr; +uint8_t bBWI;/* Block Waiting Timeout */ +uint16_t wLevelParameter; +uint8_t abData[0 ]; +}CCID_XferBlock ; + +typedef struct __attribute__ ((__packed__ )) { +CCID_Header hdr; +uint8_t bPowerSelect; +uint16_t abRFU; +}CCID_IccPowerOn ; + +typedef struct __attribute__ ((__packed__ )) { +CCID_Header hdr; +uint16_t abRFU; +}CCID_IccPowerOff ; + +typedef struct __attribute__ ((__packed__ )) { +CCID_Header hdr; +uint8_t bProtocolNum; +uint8_t abProtocolDataStructure[0 ]; +}CCID_SetParameter ; + +typedef struct { +uint8_t bMessageType;/* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */ +uint8_t bmSlotICCState; +}CCID_Notify_Slot_Change ; + +#define MAX_ATR_SIZE 40 +#define MAX_PROTOCOL_SIZE 7 + +/* used for DataBlock response to XferBlock */ +typedef struct answer_t { +uint8_t slot; +uint8_t seq; +}answer_t ; + +/* pending bulk_in messages */ +typedef struct bulk_in_t { +uint8_t data[BULK_IN_BUF_SIZE ]; +uint32_t len; +uint32_t pos; +}bulk_in_t ; + +enum { +MIGRATION_NONE , +MIGRATION_MIGRATED , +}; + +/** +* powered - defaults to true, changed by PowerOn/PowerOff messages +*/ +typedef struct { +USBDevice dev; +CharDriverState *cs; +uint8_t debug; +uint8_t auto_attach; +uint8_t atr[MAX_ATR_SIZE ]; +uint8_t atr_length; +bulk_in_t bulk_in_pending[BULK_IN_PENDING_NUM ];/* circular */ +uint32_t bulk_in_pending_start; +uint32_t bulk_in_pending_end;/* first free */ +uint32_t bulk_in_pending_num; +bulk_in_t *current_bulk_in; +uint8_t bulk_out_data[BULK_OUT_DATA_SIZE ]; +uint32_t bulk_out_pos; +uint8_t vscard_in_data[VSCARD_IN_SIZE ]; +uint32_t vscard_in_pos; +uint32_t vscard_in_hdr; +uint8_t bmSlotICCState; +uint8_t powered; +uint8_t notify_slot_change; +uint64_t last_answer_error; +answer_t pending_answers[PENDING_ANSWERS_NUM ]; +uint32_t pending_answers_start; +uint32_t pending_answers_end; +uint32_t pending_answers_num; +uint8_t bError; +uint8_t bmCommandStatus; +uint8_t bProtocolNum; +uint8_t abProtocolDataStructure[MAX_PROTOCOL_SIZE ]; +uint32_t ulProtocolDataStructureSize; +uint8_t attached_vmstate; +uint32_t state_vmstate; +uint8_t migration_state; +uint32_t migration_target_ip; +uint16_t migration_target_port; +}USBCCIDState ; + +/* Slot specific variables. We emulate a single slot card reader. +*/ + +uint8_t DEFAULT_ATR [] = { +/* From some example somewhere +0x3B, 0xB0, 0x18, 0x00, 0xD1, 0x81, 0x05, 0xB1, 0x40, 0x38, 0x1F, 0x03, 0x28 +*/ + +/* From an Athena smart card */ +0x3B ,0xD5 ,0x18 ,0xFF ,0x80 ,0x91 ,0xFE ,0x1F ,0xC3 ,0x80 ,0x73 ,0xC8 ,0x21 ,0x13 ,0x08 + +};/* maximum size of ATR - from 7816-3 */ + + +/* CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9, +* "USB Device Framework", section 9.6.1, in the Universal Serial Bus +* Specification. +* +* This device implemented based on the spec and with an Athena Smart Card +* Reader as reference: +* 0dc3:1004 Athena Smartcard Solutions, Inc. +*/ + +static const uint8_t qemu_ccid_dev_descriptor[] = { +0x12 ,/* u8 bLength; */ +USB_DT_DEVICE ,/* u8 bDescriptorType; Device */ +0x10 ,0x01 ,/* u16 bcdUSB; v1.1 */ + +0x00 ,/* u8 bDeviceClass; */ +0x00 ,/* u8 bDeviceSubClass; */ +0x00 ,/* u8 bDeviceProtocol; [ low/full speeds only ] */ +0x40 ,/* u8 bMaxPacketSize0; 8 Bytes (valid: 8,16,32,64) */ + +/* Vendor and product id are arbitrary. */ +/* u16 idVendor */ +CCID_VENDOR_ID &0xff ,CCID_VENDOR_ID >>8 , +/* u16 idProduct */ +CCID_PRODUCT_ID &0xff ,CCID_PRODUCT_ID >>8 , +/* u16 bcdDevice */ +CCID_DEVICE_VERSION &0xff ,CCID_DEVICE_VERSION >>8 , +0x01 ,/* u8 iManufacturer; */ +0x02 ,/* u8 iProduct; */ +0x03 ,/* u8 iSerialNumber; */ +0x01 ,/* u8 bNumConfigurations; */ +}; + +static const uint8_t qemu_ccid_config_descriptor[] = { + +/* one configuration */ +0x09 ,/* u8 bLength; */ +USB_DT_CONFIG ,/* u8 bDescriptorType; Configuration */ +0x5d ,0x00 ,/* u16 wTotalLength; 9+9+54+7+7+7 */ +0x01 ,/* u8 bNumInterfaces; (1) */ +0x01 ,/* u8 bConfigurationValue; */ +0x00 ,/* u8 iConfiguration; */ +0xe0 ,/* u8 bmAttributes; +Bit 7: must be set, +6: Self-powered, +5: Remote wakeup, +4..0: resvd */ +100 /2 ,/* u8 MaxPower; 50 == 100mA */ + +/* one interface */ +0x09 ,/* u8 if_bLength; */ +USB_DT_INTERFACE ,/* u8 if_bDescriptorType; Interface */ +0x00 ,/* u8 if_bInterfaceNumber; */ +0x00 ,/* u8 if_bAlternateSetting; */ +0x03 ,/* u8 if_bNumEndpoints; */ +0x0b ,/* u8 if_bInterfaceClass; Smart Card Device Class */ +0x00 ,/* u8 if_bInterfaceSubClass; Subclass code */ +0x00 ,/* u8 if_bInterfaceProtocol; Protocol code */ +0x04 ,/* u8 if_iInterface; Index of string descriptor */ + +/* Smart Card Device Class Descriptor */ +0x36 ,/* u8 bLength; */ +0x21 ,/* u8 bDescriptorType; Functional */ +0x10 ,0x01 ,/* u16 bcdCCID; CCID Specification Release Number. */ +0x00 ,/* u8 bMaxSlotIndex; The index of the highest available +slot on this device. All slots are consecutive starting +at 00h. */ +0x07 ,/* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */ + +0x03 ,0x00 ,/* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/ +0x00 ,0x00 ,/* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */ +/* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */ +0xa0 ,0x0f ,0x00 ,0x00 , +/* u32 dwMaximumClock; */ +0x00 ,0x00 ,0x01 ,0x00 , +0x00 ,/* u8 bNumClockSupported; 0 means just the default and max. */ +/* u32 dwDataRate ;bps. 9600 == 00002580h */ +0x80 ,0x25 ,0x00 ,0x00 , +/* u32 dwMaxDataRate ; 11520 bps == 0001C200h */ +0x00 ,0xC2 ,0x01 ,0x00 , +0x00 ,/* u8 bNumDataRatesSupported; 00 means all rates between +* default and max */ +/* u32 dwMaxIFSD; maximum IFSD supported by CCID for protocol +* T=1 (Maximum seen from various cards) */ +0xfe ,0x00 ,0x00 ,0x00 , +/* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */ +0x00 ,0x00 ,0x00 ,0x00 , +/* u32 dwMechanical; 0 - no special characteristics. */ +0x00 ,0x00 ,0x00 ,0x00 , +/* u32 dwFeatures; +* 0 - No special characteristics +* + 2 Automatic parameter configuration based on ATR data +* + 4 Automatic activation of ICC on inserting +* + 8 Automatic ICC voltage selection +* + 10 Automatic ICC clock frequency change +* + 20 Automatic baud rate change +* + 40 Automatic parameters negotiation made by the CCID +* + 80 automatic PPS made by the CCID +* 100 CCID can set ICC in clock stop mode +* 200 NAD value other then 00 accepted (T=1 protocol) +* + 400 Automatic IFSD exchange as first exchange (T=1) +* One of the following only: +* + 10000 TPDU level exchanges with CCID +* 20000 Short APDU level exchange with CCID +* 40000 Short and Extended APDU level exchange with CCID +* +* + 100000 USB Wake up signaling supported on card insertion +* and removal. Must set bit 5 in bmAttributes in Configuration +* descriptor if 100000 is set.*/ +0xfe ,0x04 ,0x11 ,0x00 , +/* u32 dwMaxCCIDMessageLength; For extended APDU in [261 + 10 +* , 65544 + 10]. Otherwise the minimum is wMaxPacketSize of +* the Bulk-OUT endpoint */ +0x12 ,0x00 ,0x01 ,0x00 , +0xFF ,/* u8 bClassGetResponse; Significant only for CCID that +* offers an APDU level for exchanges. Indicates the default +* class value used by the CCID when it sends a Get Response +* command to perform the transportation of an APDU by T=0 +* protocol +* FFh indicates that the CCID echos the class of the APDU. +*/ +0xFF ,/* u8 bClassEnvelope; EAPDU only. Envelope command for T=0 */ +0x00 ,0x00 ,/* u16 wLcdLayout; XXYY Number of lines (XX) and chars per +* line for LCD display used for PIN entry. 0000 - no LCD */ +0x01 ,/* u8 bPINSupport; 01h PIN Verification, +* 02h PIN Modification */ +0x01 ,/* u8 bMaxCCIDBusySlots; */ + +/* Interrupt-IN endpoint */ +0x07 ,/* u8 ep_bLength; */ +/* u8 ep_bDescriptorType; Endpoint */ +USB_DT_ENDPOINT , +/* u8 ep_bEndpointAddress; IN Endpoint 1 */ +0x80 |CCID_INT_IN_EP , +0x03 ,/* u8 ep_bmAttributes; Interrupt */ +0x40 ,0x00 ,/* u16 ep_wMaxPacketSize; */ +0xff ,/* u8 ep_bInterval; */ + +/* Bulk-In endpoint */ +0x07 ,/* u8 ep_bLength; */ +/* u8 ep_bDescriptorType; Endpoint */ +USB_DT_ENDPOINT , +/* u8 ep_bEndpointAddress; IN Endpoint 2 */ +0x80 |CCID_BULK_IN_EP , +0x02 ,/* u8 ep_bmAttributes; Bulk */ +0x40 ,0x00 ,/* u16 ep_wMaxPacketSize; */ +0x00 ,/* u8 ep_bInterval; */ + +/* Bulk-Out endpoint */ +0x07 ,/* u8 ep_bLength; */ +/* u8 ep_bDescriptorType; Endpoint */ +USB_DT_ENDPOINT , +/* u8 ep_bEndpointAddress; OUT Endpoint 3 */ +CCID_BULK_OUT_EP , +0x02 ,/* u8 ep_bmAttributes; Bulk */ +0x40 ,0x00 ,/* u16 ep_wMaxPacketSize; */ +0x00 ,/* u8 ep_bInterval; */ + +}; + +static bool ccid_has_pending_answers (USBCCIDState *s) +{ +return s->pending_answers_num >0 ; +} + +static void ccid_clear_pending_answers (USBCCIDState *s) +{ + s->pending_answers_num =0 ; + s->pending_answers_start =0 ; + s->pending_answers_end =0 ; +} + +static void ccid_print_pending_answers (USBCCIDState *s) +{ +#ifdef DEBUG_CCID +answer_t *answer; +int i, count; + +printf ("usb-ccid: pending answers:" ); +if (!ccid_has_pending_answers (s)) { +printf (" empty\n" ); +return ; + } +for (i = s->pending_answers_start, count=s->pending_answers_num ; + count >0 ; count--, i++) { + answer = &s->pending_answers[i %PENDING_ANSWERS_NUM ]; +if (count ==1 ) { +printf ("%d:%d\n" , answer->slot, answer->seq); + }else { +printf ("%d:%d," , answer->slot, answer->seq); + } + } +#endif +} + +static void ccid_add_pending_answer (USBCCIDState *s,CCID_Header *hdr) +{ +answer_t * answer; + +assert (s->pending_answers_num++ <PENDING_ANSWERS_NUM ); + answer = &s->pending_answers[(s->pending_answers_end++) %PENDING_ANSWERS_NUM ]; + answer->slot = hdr->bSlot; + answer->seq = hdr->bSeq; +ccid_print_pending_answers (s); +} + +static void ccid_remove_pending_answer (USBCCIDState *s, +uint8_t *slot,uint8_t *seq) +{ +answer_t *answer; + +assert (s->pending_answers_num-- >0 ); + answer = &s->pending_answers[(s->pending_answers_start++) %PENDING_ANSWERS_NUM ]; + *slot = answer->slot; + *seq = answer->seq; +ccid_print_pending_answers (s); +} + +static void ccid_bulk_in_clear (USBCCIDState *s) +{ + s->bulk_in_pending_start =0 ; + s->bulk_in_pending_end =0 ; + s->bulk_in_pending_num =0 ; +} + +static void ccid_bulk_in_release (USBCCIDState *s) +{ +assert (s->current_bulk_in !=NULL ); + s->current_bulk_in->pos =0 ; + s->current_bulk_in =NULL ; +} + +static void ccid_bulk_in_get (USBCCIDState *s) +{ +if (s->current_bulk_in !=NULL || s->bulk_in_pending_num ==0 ) { +return ; + } +assert (s->bulk_in_pending_num >0 ); + s->bulk_in_pending_num--; + s->current_bulk_in = &s->bulk_in_pending[ + (s->bulk_in_pending_start++) %BULK_IN_PENDING_NUM ]; +} + +static uint8_t *ccid_reserve_recv_buf (USBCCIDState * s,uint16_t len) +{ +bulk_in_t * bulk_in; + +DPRINTF (4 ,"%s: QUEUE: reserve %d bytes\n" , __func__, len); + +/* look for an existing element */ +if (len >BULK_IN_BUF_SIZE ) { +printf ("usb-ccid.c: %s: len larger then max (%d>%d). bailing out.\n" , + __func__, len,BULK_IN_BUF_SIZE ); +exit (-1 ); + } +if (s->bulk_in_pending_num >=BULK_IN_PENDING_NUM ) { +printf ("usb-ccid.c: %s: No free bulk_in buffers. discarding message.\n" , + __func__); +return NULL ; + } + bulk_in = &s->bulk_in_pending[(s->bulk_in_pending_end++) %BULK_IN_PENDING_NUM ]; + s->bulk_in_pending_num++; + bulk_in->len = len; +return bulk_in->data; +} + +static void ccid_reset (USBCCIDState *s) +{ +ccid_bulk_in_clear (s); +ccid_clear_pending_answers (s); +} + +static void ccid_detach (USBCCIDState *s) +{ +ccid_reset (s); +if (s->auto_attach ==0 && s->dev.attached) { +usb_device_detach (&s->dev); + } +} + +static void ccid_handle_reset (USBDevice *dev) +{ +USBCCIDState *s = (USBCCIDState *)dev; + +DPRINTF (1 ,"Reset\n" ); + +ccid_reset (s); +} + +static int ccid_handle_control (USBDevice *dev,int request,int value, +int index,int length,uint8_t *data) +{ +int ret =0 ; + +DPRINTF (1 ,"got control %x, value %x\n" ,request, value); +switch (request) { +case DeviceRequest |USB_REQ_GET_STATUS : + data[0 ] = (0 <<USB_DEVICE_SELF_POWERED ) | + (dev->remote_wakeup <<USB_DEVICE_REMOTE_WAKEUP ); + data[1 ] =0x00 ; + ret =2 ; +break ; +case DeviceOutRequest |USB_REQ_CLEAR_FEATURE : +if (value ==USB_DEVICE_REMOTE_WAKEUP ) { + dev->remote_wakeup =0 ; + }else { + goto fail; + } + ret =0 ; +break ; +case DeviceOutRequest |USB_REQ_SET_FEATURE : +if (value ==USB_DEVICE_REMOTE_WAKEUP ) { + dev->remote_wakeup =1 ; + }else { + goto fail; + } + ret =0 ; +break ; +case DeviceOutRequest |USB_REQ_SET_ADDRESS : + dev->addr = value; + ret =0 ; +break ; +case DeviceRequest |USB_REQ_GET_DESCRIPTOR : +switch (value >>8 ) { +case USB_DT_DEVICE : +memcpy (data, qemu_ccid_dev_descriptor, +sizeof (qemu_ccid_dev_descriptor)); + ret =sizeof (qemu_ccid_dev_descriptor); +break ; +case USB_DT_CONFIG : +memcpy (data, qemu_ccid_config_descriptor, +sizeof (qemu_ccid_config_descriptor)); + ret =sizeof (qemu_ccid_config_descriptor); +break ; +case USB_DT_STRING : +switch (value &0xff ) { +case 0 : +/* language ids */ + data[0 ] =4 ; + data[1 ] =3 ; + data[2 ] =0x09 ; + data[3 ] =0x04 ; + ret =4 ; +break ; +case 1 : +/* vendor description */ + ret =set_usb_string (data,CCID_VENDOR_DESCRIPTION ); +break ; +case 2 : +/* product description */ + ret =set_usb_string (data,CCID_PRODUCT_DESCRIPTION ); +break ; +case 3 : +/* serial number */ + ret =set_usb_string (data,CCID_SERIAL_NUMBER_STRING ); +break ; +case 4 : +/* interface name */ + ret =set_usb_string (data,CCID_INTERFACE_NAME ); +break ; +default : + goto fail; + } +break ; +default : + goto fail; + } +break ; +case DeviceRequest |USB_REQ_GET_CONFIGURATION : + data[0 ] =1 ; + ret =1 ; +break ; +case DeviceOutRequest |USB_REQ_SET_CONFIGURATION : +/* Only one configuration - we just ignore the request */ + ret =0 ; +break ; +case DeviceRequest |USB_REQ_GET_INTERFACE : + data[0 ] =0 ; + ret =1 ; +break ; +case InterfaceOutRequest |USB_REQ_SET_INTERFACE : + ret =0 ; +break ; +case EndpointOutRequest |USB_REQ_CLEAR_FEATURE : + ret =0 ; +break ; + +/* Class specific requests. */ +case InterfaceOutClass |CCID_CONTROL_ABORT : +DPRINTF (1 ,"ccid_control abort UNIMPLEMENTED\n" ); + ret =USB_RET_STALL ; +break ; +case InterfaceInClass |CCID_CONTROL_GET_CLOCK_FREQUENCIES : +DPRINTF (1 ,"ccid_control get clock frequencies UNIMPLEMENTED\n" ); + ret =USB_RET_STALL ; +break ; +case InterfaceInClass |CCID_CONTROL_GET_DATA_RATES : +DPRINTF (1 ,"ccid_control get data rates UNIMPLEMENTED\n" ); + ret =USB_RET_STALL ; +break ; +default : + fail: +DPRINTF (1 ,"got unsupported/bogus control %x, value %x\n" , request, value); + ret =USB_RET_STALL ; +break ; + } +return ret; +} + +static bool ccid_card_inserted (USBCCIDState *s) +{ +return s->bmSlotICCState &SLOT_0_STATE_MASK ; +} + +static uint8_t ccid_card_status (USBCCIDState *s) +{ +return ccid_card_inserted (s) + ? (s->powered ? +ICC_STATUS_PRESENT_ACTIVE + :ICC_STATUS_PRESENT_INACTIVE + ) + :ICC_STATUS_NOT_PRESENT ; +} + +static uint8_t ccid_calc_status (USBCCIDState *s) +{ +/* page 55, 6.2.6, calculation of bStatus from bmICCStatus and +bmCommandStatus +*/ +uint8_t ret =ccid_card_status (s) | (s->bmCommandStatus <<6 ); +DPRINTF (4 ,"status = %d\n" , ret); +return ret; +} + +static void ccid_reset_error_status (USBCCIDState * s) +{ + s->bError =ERROR_CMD_NOT_SUPPORTED ; + s->bmCommandStatus =COMMAND_STATUS_NO_ERROR ; +} + +static void ccid_write_slot_status (USBCCIDState * s,CCID_Header * recv) +{ +CCID_SlotStatus *h = (CCID_SlotStatus *)ccid_reserve_recv_buf (s,sizeof (CCID_SlotStatus)); +if (h ==NULL ) { +return ; + } + h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus; + h->b.hdr.dwLength =0 ; + h->b.hdr.bSlot = recv->bSlot; + h->b.hdr.bSeq = recv->bSeq; + h->b.bStatus =ccid_calc_status (s); + h->b.bError = s->bError; + h->bClockStatus =CLOCK_STATUS_RUNNING ; +ccid_reset_error_status (s); +} + +static void ccid_write_parameters (USBCCIDState * s,CCID_Header * recv) +{ +CCID_Parameter *h; +uint32_t len = s->ulProtocolDataStructureSize; + + h = (CCID_Parameter *)ccid_reserve_recv_buf (s,sizeof (CCID_Parameter) + len); +if (h ==NULL ) { +return ; + } + h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_Parameters; + h->b.hdr.dwLength =0 ; + h->b.hdr.bSlot = recv->bSlot; + h->b.hdr.bSeq = recv->bSeq; + h->b.bStatus =ccid_calc_status (s); + h->b.bError = s->bError; + h->bProtocolNum = s->bProtocolNum; +memcpy (h->abProtocolDataStructure, s->abProtocolDataStructure, len); +ccid_reset_error_status (s); +} + +static void ccid_write_data_block ( +USBCCIDState * s,uint8_t slot,uint8_t seq, +const uint8_t * data,uint32_t len) +{ +CCID_DataBlock *p; + + p = (CCID_DataBlock *)ccid_reserve_recv_buf (s,sizeof (*p) + len); +if (p ==NULL ) { +return ; + } + p->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock; + p->b.hdr.dwLength = len; + p->b.hdr.bSlot = slot; + p->b.hdr.bSeq = seq; + p->b.bStatus =ccid_calc_status (s); + p->b.bError = s->bError; +#ifdef DEBUG_CCID +if (p->b.bError) { +DPRINTF (4 ,"error %d" , p->b.bError); + } +#endif +memcpy (p->abData, data, len); +ccid_reset_error_status (s); +} + +static void ccid_write_data_block_answer (USBCCIDState * s, +const uint8_t * data,uint32_t len) +{ +uint8_t seq; +uint8_t slot; + +if (!ccid_has_pending_answers (s)) { +abort (); + } +ccid_remove_pending_answer (s, &slot, &seq); +ccid_write_data_block (s, slot, seq, data, len); +} + +static void ccid_write_data_block_atr (USBCCIDState * s,CCID_Header * recv) +{ +ccid_write_data_block (s, recv->bSlot, recv->bSeq, s->atr, s->atr_length); +} + +static void ccid_set_parameters (USBCCIDState *s,CCID_Header *recv) +{ +CCID_SetParameter *ph = (CCID_SetParameter *) recv; +uint32_t len =0 ; +if (ph->bProtocolNum ==0 ) { + len =5 ; + } +if (ph->bProtocolNum ==1 ) { + len =7 ; + } +if (len ==0 ) { + s->bmCommandStatus =COMMAND_STATUS_FAILED ; + s->bError =7 ;/* Protocol invalid or not supported */ +return ; + } + s->bProtocolNum = ph->bProtocolNum; +memcpy (s->abProtocolDataStructure, ph->abProtocolDataStructure, len); + s->ulProtocolDataStructureSize = len; +DPRINTF (1 ,"%s: using len %d\n" , __func__, len); +} + +/* must be 5 bytes for T=0, 7 bytes for T=1 +* See page 52 */ +static const uint8_t abDefaultProtocolDataStructure[7 ] = + {0x77 ,0x00 ,0x00 ,0x00 ,0x00 ,0xfe /*IFSC*/ ,0x00 /*NAD*/ }; + +static void ccid_reset_parameters (USBCCIDState *s) +{ +uint32_t len =sizeof (abDefaultProtocolDataStructure); + + s->bProtocolNum =1 ;/* T=1 */ + s->ulProtocolDataStructureSize = len; +memcpy (s->abProtocolDataStructure, abDefaultProtocolDataStructure, len); +} + +/* NOTE: only a single slot is supported (SLOT_0) +*/ +static void ccid_on_slot_change (USBCCIDState * s,bool full) +{ +/* RDR_to_PC_NotifySlotChange, 6.3.1 page 56 +*/ +uint8_t current = s->bmSlotICCState; +if (full) { + s->bmSlotICCState |=SLOT_0_STATE_MASK ; + }else { + s->bmSlotICCState &= ~SLOT_0_STATE_MASK ; + } +if (current != s->bmSlotICCState) { + s->bmSlotICCState |=SLOT_0_CHANGED_MASK ; + } + s->notify_slot_change = true; +} + +static void ccid_write_data_block_error ( +USBCCIDState *s,uint8_t slot,uint8_t seq) +{ +ccid_write_data_block (s, slot, seq,NULL ,0 ); +} + +static void ccid_vscard_send_msg ( +USBCCIDState *s,VSCMsgType type,reader_id_t reader_id, +uint8_t * payload,uint32_t length) +{ +VSCMsgHeader scr_msg_header; + + scr_msg_header.type = type; + scr_msg_header.reader_id = reader_id; + scr_msg_header.length = length; +qemu_chr_write (s->cs, (uint8_t *)&scr_msg_header,sizeof (VSCMsgHeader)); +qemu_chr_write (s->cs, payload, length); +} + +static void ccid_vscard_send_apdu ( +USBCCIDState *s,uint8_t * apdu,uint32_t length) +{ +ccid_vscard_send_msg (s,VSC_APDU ,VSCARD_MINIMAL_READER_ID , apdu, length); +} + +static void ccid_vscard_send_error ( +USBCCIDState *s,reader_id_t reader_id,VSCErrorCode code) +{ +VSCMsgError msg = {.code=code}; + +ccid_vscard_send_msg (s, VSC_Error, reader_id, (uint8_t *)&msg,sizeof (msg)); +} + +static void ccid_vscard_send_init (USBCCIDState *s) +{ +VSCMsgInit msg = {.version=VSCARD_VERSION }; + +ccid_vscard_send_msg (s, VSC_Init,VSCARD_UNDEFINED_READER_ID , + (uint8_t *)&msg,sizeof (msg)); +} + +static void ccid_on_apdu_from_guest (USBCCIDState *s,CCID_XferBlock *recv) +{ +if (!s->cs) { +printf ("usb-ccid: discarding apdu length %d\n" , recv->hdr.dwLength); +return ; + } +if (ccid_card_status (s) !=ICC_STATUS_PRESENT_ACTIVE ) { +DPRINTF (1 ,"usb-ccid: not sending apdu to client, no card connected\n" ); +ccid_write_data_block_error (s, recv->hdr.bSlot, recv->hdr.bSeq); +return ; + } +DPRINTF (1 ,"%s: seq %d, len %d\n" , __FUNCTION__, + recv->hdr.bSeq, recv->hdr.dwLength); +ccid_add_pending_answer (s, (CCID_Header *)recv); +ccid_vscard_send_apdu (s, recv->abData, recv->hdr.dwLength); +} + +static void ccid_handle_bulk_out (USBCCIDState *s,USBPacket *p) +{ +CCID_Header * ccid_header; + +assert (p->len + s->bulk_out_pos <=BULK_OUT_DATA_SIZE ); + ccid_header = (CCID_Header *)s->bulk_out_data; +memcpy (s->bulk_out_data + s->bulk_out_pos, p->data, p->len); + s->bulk_out_pos += p->len; +if (p->len ==64 ) { +DPRINTF (4 ,"usb-ccid: bulk_in: expecting more packets (%d/%d)\n" , + p->len, ccid_header->dwLength); +return ; + } +if (s->bulk_out_pos <10 ) { +DPRINTF (1 ,"%s: bad USB_TOKEN_OUT length, should be at least 10 bytes\n" , __func__); + }else { +DPRINTF (3 ,"%s %x\n" , __func__, ccid_header->bMessageType); +switch (ccid_header->bMessageType) { +case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus: +ccid_write_slot_status (s, ccid_header); +break ; +case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn: +/* We need to send an ATR back */ +DPRINTF (1 ,"PowerOn: %d\n" , + ((CCID_IccPowerOn *)(ccid_header))->bPowerSelect); + s->powered = true; +ccid_write_data_block_atr (s, ccid_header); +break ; +case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff: +DPRINTF (1 ,"PowerOff\n" ); +ccid_reset_error_status (s); + s->powered = false; +ccid_write_slot_status (s, ccid_header); +break ; +case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock: +ccid_on_apdu_from_guest (s, (CCID_XferBlock *)s->bulk_out_data); +break ; +case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters: + s->bmCommandStatus =COMMAND_STATUS_NO_ERROR ; +ccid_set_parameters (s, ccid_header); +ccid_write_parameters (s, ccid_header); +break ; +case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters: + s->bmCommandStatus =COMMAND_STATUS_NO_ERROR ; +ccid_reset_parameters (s); +ccid_write_parameters (s, ccid_header); +break ; +case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters: + s->bmCommandStatus =COMMAND_STATUS_NO_ERROR ; +ccid_write_parameters (s, ccid_header); +break ; +default : +DPRINTF (1 ,"handle_data: ERROR: unhandled message type %Xh\n" , + ccid_header->bMessageType); +/* the caller is expecting the device to respond, tell it we +* do't support the operation */ + s->bmCommandStatus =COMMAND_STATUS_FAILED ; + s->bError =ERROR_CMD_NOT_SUPPORTED ; +ccid_write_slot_status (s, ccid_header); +break ; + } + } + s->bulk_out_pos =0 ; +} + +static int ccid_bulk_in_copy_out (USBCCIDState *s,uint8_t *data,int len) +{ +int ret =0 ; + +assert (len>0 ); +ccid_bulk_in_get (s); +if (s->current_bulk_in !=NULL ) { + ret =MIN (s->current_bulk_in->len - s->current_bulk_in->pos, len); +memcpy (data, s->current_bulk_in->data + s->current_bulk_in->pos, ret); + s->current_bulk_in->pos += ret; +if (s->current_bulk_in->pos == s->current_bulk_in->len) { +ccid_bulk_in_release (s); + } + }else { + ret =USB_RET_NAK ;/* return when device has no data - usb 2.0 spec Table 8-4 */ + } +if (ret >0 ) { +DPRINTF (3 ,"%s: %d/%d req/act to guest (BULK_IN)\n" , __func__, len, ret); + } +if (ret !=USB_RET_NAK && ret < len) { +DPRINTF (1 ,"%s: returning short (EREMOTEIO) %d < %d\n" , __func__, ret, len); + } +return ret; +} + +static int ccid_handle_data (USBDevice *dev,USBPacket *p) +{ +USBCCIDState *s = (USBCCIDState *)dev; +int ret =0 ; +uint8_t *data = p->data; +int len = p->len; + +switch (p->pid) { +case USB_TOKEN_OUT : +ccid_handle_bulk_out (s, p); +break ; + +case USB_TOKEN_IN : +switch (p->devep &0xf ) { +case CCID_BULK_IN_EP : +if (!len) { + ret =USB_RET_NAK ; + }else { + ret =ccid_bulk_in_copy_out (s, data, len); + } +break ; +case CCID_INT_IN_EP : +if (s->notify_slot_change) { +/* page 56, RDR_to_PC_NotifySlotChange */ + data[0 ] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange; + data[1 ] = s->bmSlotICCState; + ret =2 ; + s->notify_slot_change = false; + s->bmSlotICCState &= ~SLOT_0_CHANGED_MASK ; +DPRINTF (2 ,"handle_data: int_in: notify_slot_change %X, requested len %d\n" , + s->bmSlotICCState, len); + } +break ; +default : +DPRINTF (1 ,"Bad endpoint\n" ); +break ; + } +break ; +default : +DPRINTF (1 ,"Bad token\n" ); + ret =USB_RET_STALL ; +break ; + } + +return ret; +} + +static void ccid_handle_destroy (USBDevice *dev) +{ +USBCCIDState *s = (USBCCIDState *)dev; + +if (s->cs) { +qemu_chr_close (s->cs); + } +ccid_bulk_in_clear (s); +} + +/* APDU chardev */ + +static int ccid_vscard_can_read (void *opaque) +{ +return 65535 ; +} + +static void ccid_vscard_handle_message (USBCCIDState *s, +VSCMsgHeader * scr_msg_header) +{ +uint8_t *data = (uint8_t *)&scr_msg_header[1 ]; +answer_t *answer; + +switch (scr_msg_header->type) { +case VSC_ATR : +DPRINTF (1 ,"VSC_ATR %d\n" , scr_msg_header->length); +assert (scr_msg_header->length <=MAX_ATR_SIZE ); +memcpy (s->atr, data, scr_msg_header->length); + s->atr_length = scr_msg_header->length; + s->bmCommandStatus =COMMAND_STATUS_NO_ERROR ; +if (ccid_has_pending_answers (s)) { +ccid_write_data_block_answer (s,NULL ,0 ); + } +ccid_on_slot_change (s, true); +break ; +case VSC_APDU : +if (!ccid_has_pending_answers (s)) { +DPRINTF (1 ,"VSC_APDU: ERROR: got an APDU without pending answers\n" ); +break ; + } + s->bmCommandStatus =COMMAND_STATUS_NO_ERROR ; + answer = s->pending_answers_num ==0 ?NULL : &s->pending_answers[s->pending_answers_start %PENDING_ANSWERS_NUM ]; +if (answer ==NULL ) { +abort (); + } +DPRINTF (1 ,"VSC_APDU %d (answer seq %d, slot %d)\n" , + scr_msg_header->length, + answer->seq, answer->slot); +ccid_write_data_block_answer (s, data, scr_msg_header->length); +break ; +case VSC_CardRemove: +DPRINTF (1 ,"VSC_CardRemove\n" ); +ccid_on_slot_change (s, false); +if (ccid_has_pending_answers (s)) { +ccid_write_data_block_answer (s,NULL ,0 ); + } +ccid_reset (s); +break ; +case VSC_Init: +break ; +case VSC_Error: + s->bmCommandStatus =COMMAND_STATUS_FAILED ; + s->last_answer_error = *(uint64_t *)data; +DPRINTF (1 ,"VSC_Error: %lX\n" , s->last_answer_error); +ccid_write_data_block_answer (s,NULL ,0 ); +break ; +case VSC_ReaderAdd: +DPRINTF (1 ,"VSC_ReaderAdd\n" ); +if (s->auto_attach==0 && !s->dev.attached) { +usb_device_attach (&s->dev); +ccid_vscard_send_msg (s, VSC_ReaderAddResponse, +VSCARD_MINIMAL_READER_ID ,NULL ,0 ); + }else { +if (s->migration_state ==MIGRATION_MIGRATED ) { + s->migration_state =MIGRATION_NONE ; +ccid_vscard_send_msg (s, VSC_ReaderAddResponse, +VSCARD_MINIMAL_READER_ID ,NULL ,0 ); + }else { +ccid_vscard_send_error (s,VSCARD_UNDEFINED_READER_ID , +VSC_CANNOT_ADD_MORE_READERS ); + } + } +break ; +case VSC_ReaderRemove: +DPRINTF (1 ,"VSC_ReaderRemove\n" ); +if (ccid_card_inserted (s)) { +ccid_on_slot_change (s, false); +ccid_clear_pending_answers (s); + } +if (s->auto_attach ==0 && s->dev.attached) { +usb_device_detach (&s->dev); + } +break ; +default : +printf ("usb-ccid: chardev: unexpected message of type %X\n" , + scr_msg_header->type); +ccid_vscard_send_error (s, scr_msg_header->reader_id, +VSC_GENERAL_ERROR ); + } +} + +static void ccid_vscard_read (void *opaque,const uint8_t *buf,int size) +{ +USBCCIDState *s = opaque; +VSCMsgHeader *hdr; + +assert (s->vscard_in_pos + size <=VSCARD_IN_SIZE ); +memcpy (s->vscard_in_data + s->vscard_in_pos, buf, size); + s->vscard_in_pos += size; + hdr = (VSCMsgHeader *)(s->vscard_in_data + s->vscard_in_hdr); + +while ((s->vscard_in_pos - s->vscard_in_hdr >=sizeof (VSCMsgHeader)) && + (s->vscard_in_pos - s->vscard_in_hdr -sizeof (VSCMsgHeader) >= + hdr->length)) { +ccid_vscard_handle_message (s, hdr); + s->vscard_in_hdr += hdr->length +sizeof (VSCMsgHeader); + hdr = (VSCMsgHeader *)(s->vscard_in_data + s->vscard_in_hdr); + } +if (s->vscard_in_hdr == s->vscard_in_pos) { + s->vscard_in_pos = s->vscard_in_hdr =0 ; + } +} + +static void ccid_vscard_event (void *opaque,int event) +{ +USBCCIDState *s = opaque; + +switch (event) { +case CHR_EVENT_BREAK : +break ; +case CHR_EVENT_FOCUS : +break ; +case CHR_EVENT_OPENED : +DPRINTF (1 ,"%s: CHR_EVENT_OPENED\n" , __func__); +if (s->migration_state !=MIGRATION_MIGRATED ) { +ccid_detach (s); + } +break ; + } +} + +static int ccid_initfn (USBDevice *dev) +{ +USBCCIDState *s =DO_UPCAST (USBCCIDState, dev, dev); + + s->migration_state =MIGRATION_NONE ; + dev->auto_attach = s->auto_attach; + debug = s->debug; + s->migration_target_ip =0 ; + s->migration_target_port =0 ; + s->dev.speed =USB_SPEED_FULL ; + s->notify_slot_change = false; + s->powered = true; + s->pending_answers_num =0 ; + s->last_answer_error =0 ; + s->bulk_in_pending_start =0 ; + s->bulk_in_pending_end =0 ; + s->current_bulk_in =NULL ; +ccid_reset_error_status (s); +assert (sizeof (DEFAULT_ATR ) <=MAX_ATR_SIZE ); +memcpy (s->atr,DEFAULT_ATR ,sizeof (DEFAULT_ATR )); + s->atr_length =sizeof (DEFAULT_ATR ); + s->bulk_out_pos =0 ; + s->vscard_in_pos =0 ; + s->vscard_in_hdr =0 ; +if (s->cs) { +DPRINTF (1 ,"initing chardev\n" ); +qemu_chr_add_handlers (s->cs, + ccid_vscard_can_read, + ccid_vscard_read, + ccid_vscard_event, s); +ccid_vscard_send_init (s); + } +ccid_reset_parameters (s); +ccid_reset (s); +return 0 ; +} + +static int ccid_post_load (void *opaque,int version_id) +{ +USBCCIDState *s = opaque; + +if (s->auto_attach ==0 && s->attached_vmstate && !s->dev.attached) { +usb_device_attach (&s->dev); + } +// This must be done after usb_device_attach, which sets state to ATTACHED, +// while it must be DEFAULT in order to accept packets (like it is after +// reset, but reset will reset our addr and call our reset handler which +// may change state, and we don't want to do that when migrating). + s->dev.state = s->state_vmstate; +return 0 ; +} + +static void ccid_pre_save (void *opaque) +{ +USBCCIDState *s = opaque; +VSCMsgReconnect reconnect; + + reconnect.ip = s->migration_target_ip; + reconnect.port = s->migration_target_port; +ccid_vscard_send_msg (s, VSC_Reconnect,VSCARD_UNDEFINED_READER_ID , + (uint8_t *)&reconnect,sizeof (reconnect)); + s->attached_vmstate = s->dev.attached; + s->state_vmstate = s->dev.state; +if (s->dev.attached) { +// migrating an open device, ignore reconnection CHR_EVENT to avoid an +// erronous detach. + s->migration_state =MIGRATION_MIGRATED ; + } +} + +static VMStateDescription bulk_in_t_vmstate = { + .name ="bulk_in_t" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +VMSTATE_BUFFER (data, bulk_in_t), +VMSTATE_UINT32 (len, bulk_in_t), +VMSTATE_UINT32 (pos, bulk_in_t), +VMSTATE_END_OF_LIST () + } +}; + +static VMStateDescription answer_t_vmstate = { + .name ="answer_t" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +VMSTATE_UINT8 (slot, answer_t), +VMSTATE_UINT8 (seq, answer_t), +VMSTATE_END_OF_LIST () + } +}; + +static VMStateDescription usb_device_vmstate = { + .name ="usb_device" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +//int speed; +VMSTATE_UINT8 (addr, USBDevice), +//VMSTATE_BUFFER(product_desc, USBDevice), // char, not uint8_t - casting error +//int auto_attach; +//int attached; +//int state; +VMSTATE_BUFFER (setup_buf, USBDevice), +VMSTATE_BUFFER (data_buf, USBDevice), +// int remote_wakeup; +// int setup_state; +// int setup_len; +// int setup_index; +VMSTATE_END_OF_LIST () + } +}; + +static VMStateDescription ccid_vmstate = { + .name =CCID_DEV_NAME , + .version_id =1 , + .minimum_version_id =1 , + .post_load = ccid_post_load, + .pre_save = ccid_pre_save, + .fields = (VMStateField []) { +VMSTATE_STRUCT (dev, USBCCIDState,1 , usb_device_vmstate, USBDevice), +VMSTATE_UINT8 (debug, USBCCIDState), +VMSTATE_UINT8 (auto_attach, USBCCIDState), +VMSTATE_BUFFER (atr, USBCCIDState), +VMSTATE_UINT8 (atr_length, USBCCIDState), +VMSTATE_BUFFER (bulk_out_data, USBCCIDState), +VMSTATE_UINT32 (bulk_out_pos, USBCCIDState), +VMSTATE_BUFFER (vscard_in_data, USBCCIDState), +VMSTATE_UINT32 (vscard_in_pos, USBCCIDState), +VMSTATE_UINT32 (vscard_in_hdr, USBCCIDState), +VMSTATE_UINT8 (bmSlotICCState, USBCCIDState), +VMSTATE_UINT8 (powered, USBCCIDState), +VMSTATE_UINT8 (notify_slot_change, USBCCIDState), +VMSTATE_UINT64 (last_answer_error, USBCCIDState), +VMSTATE_UINT8 (bError, USBCCIDState), +VMSTATE_UINT8 (bmCommandStatus, USBCCIDState), +VMSTATE_UINT8 (bProtocolNum, USBCCIDState), +VMSTATE_BUFFER (abProtocolDataStructure, USBCCIDState), +VMSTATE_UINT32 (ulProtocolDataStructureSize, USBCCIDState), +VMSTATE_STRUCT_ARRAY (bulk_in_pending, USBCCIDState, +BULK_IN_PENDING_NUM ,1 , bulk_in_t_vmstate, bulk_in_t), +VMSTATE_UINT32 (bulk_in_pending_start, USBCCIDState), +VMSTATE_UINT32 (bulk_in_pending_end, USBCCIDState), +VMSTATE_STRUCT_ARRAY (pending_answers, USBCCIDState, +PENDING_ANSWERS_NUM ,1 , answer_t_vmstate, answer_t), +VMSTATE_UINT32 (pending_answers_num, USBCCIDState), +VMSTATE_UINT8 (migration_state, USBCCIDState), +VMSTATE_UINT8 (attached_vmstate, USBCCIDState), +VMSTATE_UINT32 (state_vmstate, USBCCIDState), +VMSTATE_END_OF_LIST () + } +}; + +static struct USBDeviceInfo ccid_info = { + .product_desc ="QEMU USB CCID" , + .qdev.name =CCID_DEV_NAME , + .qdev.size =sizeof (USBCCIDState), + .qdev.vmsd = &ccid_vmstate, + .init = ccid_initfn, + .handle_packet = usb_generic_handle_packet, + .handle_reset = ccid_handle_reset, + .handle_control = ccid_handle_control, + .handle_data = ccid_handle_data, + .handle_destroy = ccid_handle_destroy, + .usbdevice_name ="ccid" , + .qdev.props = (Property []) { +DEFINE_PROP_CHR ("chardev" , USBCCIDState, cs), +DEFINE_PROP_UINT8 ("auto_attach" , USBCCIDState, auto_attach,0 ), +DEFINE_PROP_UINT8 ("debug" , USBCCIDState, debug,0 ), +DEFINE_PROP_END_OF_LIST (), + }, +}; + +static void ccid_register_devices (void ) +{ +usb_qdev_register (&ccid_info); +} +device_init (ccid_register_devices)
Signature · 1 line
1.7.3.1
Quoted 8 lines · Alon Levy
This patch adds a new device, it is described in full in the second patch intro and also in the documentation in docs. In brief it provides a standard smart card reader device.
The first patch is the configure change and docs.
The second patch contains the actual device, I couldn't figure out a good way to split it to ease review.
Quoted 9 lines
v2 changed:
* all QSIMPLEQ turned into fixed sized rings
* all allocated buffers turned into fixed size buffers
* added migration support
* added a message to tell client qemu has migrated to ip:port
* for lack of monitor commands ip:port are 0:0, which causes the updated vscclient to connect to one port higher on the same host. will add monitor commands in a separate patch. tested with current setup.
This is way too much magic to live within a device. Devices manage reconnecting themselves during migration. When you create the destination qemu instance, you specify what to connect to.
IOW,
On the source:
qemu -chardev tcp:localhost:1025,id=foo -usbdevice ccid,chardev=foo ...
On the destination:
qemu -chardev tcp:localhost:1026,id=foo -usbdevice ccid,chardev=foo -incoming tcp:0.0.0.0:1024 ...
A connection happens when the device is created.
But now I'm even further confused then when I first reviewed it.. If you're now supporting migration, does that mean that you're relying on the daemon to emulate the device?
Regards,
Anthony Liguori
Quoted 15 lines
Alon Levy (2):
usb-ccid: add CCID device. add configure option.
usb-ccid: add CCID device (device itself)Makefile.objs | 1 + configure | 12 + docs/usb-ccid.txt | 115 +++++ hw/usb-ccid.c | 1376 ++++++++++++++++++++++++++++++++++++++++++++++++++++ hw/vscard_common.h | 131 +++++ 5 files changed, 1635 insertions(+), 0 deletions(-)create mode 100644
docs/usb-ccid.txt
create mode 100644hw/usb-ccid.c
create mode 100644hw/vscard_common.h