ccid/src/commands.c

/*
    commands.c: Commands sent to the card
    Copyright (C) 2003   Ludovic Rousseau

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/*
 * $Id$
 */

#include <string.h>

#include "pcscdefines.h"
#include "ifdhandler.h"
#include "commands.h"
#include "ccid_usb.h"
#include "defs.h"
#include "config.h"
#include "debug.h"

#define SET_ISO_MODE 1

RESPONSECODE CmdPowerOn(int lun, int * nlength, unsigned char buffer[])
{
        unsigned char cmd[10];
        status_t res;
        int atr_len, length, count = 1;
        RESPONSECODE return_value = IFD_SUCCESS;

        /* store length of buffer[] */
        length = *nlength;
again:
        cmd[0] = 0x62; /* IccPowerOn */
        cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0;  /* dwLength */
        cmd[5] = 0;     /* slot number */
        cmd[6] = ccid_get_seq(lun);
        cmd[7] = 0x01;  /* 5.0V */
        cmd[8] = cmd[9] = 0; /* RFU */

        res = WriteUSB(lun, sizeof(cmd), cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        /* reset available buffer size */
        /* needed if we go back after a switch to ISO mode */
        *nlength = length;

        res = ReadUSB(lun, nlength, buffer);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        if (buffer[STATUS_OFFSET] & 0x40)
        {
                ccid_error(buffer[ERROR_OFFSET], __FILE__, __LINE__);    /* bError */

                /* Protocol error in EMV mode */
                if (buffer[ERROR_OFFSET] == 0xBB)
                {
                        DEBUG_INFO("Switch reader in ISO mode");
                        if ((return_value = Escape(lun, SET_ISO_MODE)) != IFD_SUCCESS)
                                return return_value;

                        /* avoid looping if we can't switch mode */
                        if (count--)
                                goto again;
                        else
                                DEBUG_CRITICAL("Can't set reader in ISO mode");
                }

                return IFD_COMMUNICATION_ERROR;
        }

        /* extract the ATR */
        atr_len = dw2i(buffer, 1);      /* ATR length */
        if (atr_len > *nlength)
                atr_len = *nlength;
        else
                *nlength = atr_len;

        memcpy(buffer, buffer+10, atr_len);

        return return_value;
} /* CmdPowerOn */

RESPONSECODE Escape(int lun, int command)
{
        unsigned char cmd[12];
        status_t res;
        int length;
        RESPONSECODE return_value = IFD_SUCCESS;

        cmd[0] = 0x6B; /* PC_to_RDR_Escape */
        cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0;  /* dwLength */
        cmd[5] = 0;     /* slot number */
        cmd[6] = ccid_get_seq(lun);
        cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */

        switch (command)
        {
                /* Gemplus proprietary */
                case SET_ISO_MODE:
                        cmd[10] = 0x1F; /* switch mode */
                        cmd[11] = 0x01; /* set ISO mode */
                        cmd[1] = 2;     /* length of data */
                        length = 12;
                        break;

                default:
                        DEBUG_CRITICAL2("Unkown Escape command: %d", command);
                        return return_value;
        }

        res = WriteUSB(lun, length, cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        length = sizeof(cmd);
        res = ReadUSB(lun, &length, cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        if (cmd[STATUS_OFFSET] & 0x40)
        {
                ccid_error(cmd[ERROR_OFFSET], __FILE__, __LINE__);    /* bError */
                return_value = IFD_COMMUNICATION_ERROR;
        }

        return return_value;
} /* Escape */

RESPONSECODE CmdPowerOff(int lun)
{
        unsigned char cmd[10];
        status_t res;
        int length;
        RESPONSECODE return_value = IFD_SUCCESS;

        cmd[0] = 0x63; /* IccPowerOff */
        cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0;  /* dwLength */
        cmd[5] = 0;     /* slot number */
        cmd[6] = ccid_get_seq(lun);
        cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */

        res = WriteUSB(lun, sizeof(cmd), cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        length = sizeof(cmd);
        res = ReadUSB(lun, &length, cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        if (cmd[STATUS_OFFSET] & 0x40)
        {
                ccid_error(cmd[ERROR_OFFSET], __FILE__, __LINE__);    /* bError */
                return_value = IFD_COMMUNICATION_ERROR;
        }

        return return_value;
} /* CmdPowerOff */

RESPONSECODE CmdGetSlotStatus(int lun, unsigned char buffer[])
{
        unsigned char cmd[10];
        status_t res;
        int length;
        RESPONSECODE return_value = IFD_SUCCESS;

        cmd[0] = 0x65; /* GetSlotStatus */
        cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0;  /* dwLength */
        cmd[5] = 0;     /* slot number */
        cmd[6] = ccid_get_seq(lun);
        cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */

        res = WriteUSB(lun, sizeof(cmd), cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        length = SIZE_GET_SLOT_STATUS;
        res = ReadUSB(lun, &length, buffer);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        if (buffer[STATUS_OFFSET] & 0x40)
        {
                ccid_error(buffer[ERROR_OFFSET], __FILE__, __LINE__);    /* bError */
                return_value = IFD_COMMUNICATION_ERROR;
        }

        return return_value;
} /* CmdGetSlotStatus */

RESPONSECODE CmdXfrBlock(int lun, int tx_length, unsigned char tx_buffer[],
        PDWORD rx_length, unsigned char rx_buffer[])
{
        unsigned char cmd[10+CMD_BUF_SIZE];     /* CCID + APDU buffer */
        status_t res;
        int length;
        RESPONSECODE return_value = IFD_SUCCESS;

        cmd[0] = 0x6F; /* IccPowerOff */
        i2dw(tx_length, cmd+1); /* APDU length */
        cmd[5] = 0;     /* slot number */
        cmd[6] = ccid_get_seq(lun);
        cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */
        memcpy(cmd+10, tx_buffer, tx_length);

        res = WriteUSB(lun, 10+tx_length, cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        length = sizeof(cmd);
        res = ReadUSB(lun, &length, cmd);
        if (res != STATUS_SUCCESS)
                return IFD_COMMUNICATION_ERROR;

        if (cmd[STATUS_OFFSET] & 0x40)
        {
                ccid_error(cmd[ERROR_OFFSET], __FILE__, __LINE__);    /* bError */
                *rx_length = 0; /* nothing received */
                return_value = IFD_COMMUNICATION_ERROR;
        }

        length = dw2i(cmd, 1);
        if (length < *rx_length)
                *rx_length = length;
        else
                length = *rx_length;
        memcpy(rx_buffer, cmd+10, length);

        return return_value;
} /* CmdXfrBlock */

void i2dw(int value, unsigned char buffer[])
{
        buffer[0] = value & 0xFF;
        buffer[1] = (value >> 8) & 0xFF;
        buffer[2] = (value >> 16) & 0xFF;
        buffer[3] = (value >> 24) & 0xFF;
} /* i2dw */

1	/*
2	commands.c: Commands sent to the card
3	Copyright (C) 2003 Ludovic Rousseau
4
5	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 2 of the License, or
8	(at your option) any later version.
9
10	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software
17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*/
19
20	/*
21	* $Id$
22	*/
23
24	#include <string.h>
25
26	#include "pcscdefines.h"
27	#include "ifdhandler.h"
28	#include "commands.h"
29	#include "ccid_usb.h"
30	#include "defs.h"
31	#include "config.h"
32	#include "debug.h"
33
34	#define SET_ISO_MODE 1
35
36	RESPONSECODE CmdPowerOn(int lun, int * nlength, unsigned char buffer[])
37	{
38	unsigned char cmd[10];
39	status_t res;
40	int atr_len, length, count = 1;
41	RESPONSECODE return_value = IFD_SUCCESS;
42
43	/* store length of buffer[] */
44	length = *nlength;
45	again:
46	cmd[0] = 0x62; /* IccPowerOn */
47	cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0; /* dwLength */
48	cmd[5] = 0; /* slot number */
49	cmd[6] = ccid_get_seq(lun);
50	cmd[7] = 0x01; /* 5.0V */
51	cmd[8] = cmd[9] = 0; /* RFU */
52
53	res = WriteUSB(lun, sizeof(cmd), cmd);
54	if (res != STATUS_SUCCESS)
55	return IFD_COMMUNICATION_ERROR;
56
57	/* reset available buffer size */
58	/* needed if we go back after a switch to ISO mode */
59	*nlength = length;
60
61	res = ReadUSB(lun, nlength, buffer);
62	if (res != STATUS_SUCCESS)
63	return IFD_COMMUNICATION_ERROR;
64
65	if (buffer[STATUS_OFFSET] & 0x40)
66	{
67	ccid_error(buffer[ERROR_OFFSET], __FILE__, __LINE__); /* bError */
68
69	/* Protocol error in EMV mode */
70	if (buffer[ERROR_OFFSET] == 0xBB)
71	{
72	DEBUG_INFO("Switch reader in ISO mode");
73	if ((return_value = Escape(lun, SET_ISO_MODE)) != IFD_SUCCESS)
74	return return_value;
75
76	/* avoid looping if we can't switch mode */
77	if (count--)
78	goto again;
79	else
80	DEBUG_CRITICAL("Can't set reader in ISO mode");
81	}
82
83	return IFD_COMMUNICATION_ERROR;
84	}
85
86	/* extract the ATR */
87	atr_len = dw2i(buffer, 1); /* ATR length */
88	if (atr_len > *nlength)
89	atr_len = *nlength;
90	else
91	*nlength = atr_len;
92
93	memcpy(buffer, buffer+10, atr_len);
94
95	return return_value;
96	} /* CmdPowerOn */
97
98	RESPONSECODE Escape(int lun, int command)
99	{
100	unsigned char cmd[12];
101	status_t res;
102	int length;
103	RESPONSECODE return_value = IFD_SUCCESS;
104
105	cmd[0] = 0x6B; /* PC_to_RDR_Escape */
106	cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0; /* dwLength */
107	cmd[5] = 0; /* slot number */
108	cmd[6] = ccid_get_seq(lun);
109	cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */
110
111	switch (command)
112	{
113	/* Gemplus proprietary */
114	case SET_ISO_MODE:
115	cmd[10] = 0x1F; /* switch mode */
116	cmd[11] = 0x01; /* set ISO mode */
117	cmd[1] = 2; /* length of data */
118	length = 12;
119	break;
120
121	default:
122	DEBUG_CRITICAL2("Unkown Escape command: %d", command);
123	return return_value;
124	}
125
126	res = WriteUSB(lun, length, cmd);
127	if (res != STATUS_SUCCESS)
128	return IFD_COMMUNICATION_ERROR;
129
130	length = sizeof(cmd);
131	res = ReadUSB(lun, &length, cmd);
132	if (res != STATUS_SUCCESS)
133	return IFD_COMMUNICATION_ERROR;
134
135	if (cmd[STATUS_OFFSET] & 0x40)
136	{
137	ccid_error(cmd[ERROR_OFFSET], __FILE__, __LINE__); /* bError */
138	return_value = IFD_COMMUNICATION_ERROR;
139	}
140
141	return return_value;
142	} /* Escape */
143
144	RESPONSECODE CmdPowerOff(int lun)
145	{
146	unsigned char cmd[10];
147	status_t res;
148	int length;
149	RESPONSECODE return_value = IFD_SUCCESS;
150
151	cmd[0] = 0x63; /* IccPowerOff */
152	cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0; /* dwLength */
153	cmd[5] = 0; /* slot number */
154	cmd[6] = ccid_get_seq(lun);
155	cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */
156
157	res = WriteUSB(lun, sizeof(cmd), cmd);
158	if (res != STATUS_SUCCESS)
159	return IFD_COMMUNICATION_ERROR;
160
161	length = sizeof(cmd);
162	res = ReadUSB(lun, &length, cmd);
163	if (res != STATUS_SUCCESS)
164	return IFD_COMMUNICATION_ERROR;
165
166	if (cmd[STATUS_OFFSET] & 0x40)
167	{
168	ccid_error(cmd[ERROR_OFFSET], __FILE__, __LINE__); /* bError */
169	return_value = IFD_COMMUNICATION_ERROR;
170	}
171
172	return return_value;
173	} /* CmdPowerOff */
174
175	RESPONSECODE CmdGetSlotStatus(int lun, unsigned char buffer[])
176	{
177	unsigned char cmd[10];
178	status_t res;
179	int length;
180	RESPONSECODE return_value = IFD_SUCCESS;
181
182	cmd[0] = 0x65; /* GetSlotStatus */
183	cmd[1] = cmd[2] = cmd[3] = cmd[4] = 0; /* dwLength */
184	cmd[5] = 0; /* slot number */
185	cmd[6] = ccid_get_seq(lun);
186	cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */
187
188	res = WriteUSB(lun, sizeof(cmd), cmd);
189	if (res != STATUS_SUCCESS)
190	return IFD_COMMUNICATION_ERROR;
191
192	length = SIZE_GET_SLOT_STATUS;
193	res = ReadUSB(lun, &length, buffer);
194	if (res != STATUS_SUCCESS)
195	return IFD_COMMUNICATION_ERROR;
196
197	if (buffer[STATUS_OFFSET] & 0x40)
198	{
199	ccid_error(buffer[ERROR_OFFSET], __FILE__, __LINE__); /* bError */
200	return_value = IFD_COMMUNICATION_ERROR;
201	}
202
203	return return_value;
204	} /* CmdGetSlotStatus */
205
206	RESPONSECODE CmdXfrBlock(int lun, int tx_length, unsigned char tx_buffer[],
207	PDWORD rx_length, unsigned char rx_buffer[])
208	{
209	unsigned char cmd[10+CMD_BUF_SIZE]; /* CCID + APDU buffer */
210	status_t res;
211	int length;
212	RESPONSECODE return_value = IFD_SUCCESS;
213
214	cmd[0] = 0x6F; /* IccPowerOff */
215	i2dw(tx_length, cmd+1); /* APDU length */
216	cmd[5] = 0; /* slot number */
217	cmd[6] = ccid_get_seq(lun);
218	cmd[7] = cmd[8] = cmd[9] = 0; /* RFU */
219	memcpy(cmd+10, tx_buffer, tx_length);
220
221	res = WriteUSB(lun, 10+tx_length, cmd);
222	if (res != STATUS_SUCCESS)
223	return IFD_COMMUNICATION_ERROR;
224
225	length = sizeof(cmd);
226	res = ReadUSB(lun, &length, cmd);
227	if (res != STATUS_SUCCESS)
228	return IFD_COMMUNICATION_ERROR;
229
230	if (cmd[STATUS_OFFSET] & 0x40)
231	{
232	ccid_error(cmd[ERROR_OFFSET], __FILE__, __LINE__); /* bError */
233	rx_length = 0; / nothing received */
234	return_value = IFD_COMMUNICATION_ERROR;
235	}
236
237	length = dw2i(cmd, 1);
238	if (length < *rx_length)
239	*rx_length = length;
240	else
241	length = *rx_length;
242	memcpy(rx_buffer, cmd+10, length);
243
244	return return_value;
245	} /* CmdXfrBlock */
246
247	void i2dw(int value, unsigned char buffer[])
248	{
249	buffer[0] = value & 0xFF;
250	buffer[1] = (value >> 8) & 0xFF;
251	buffer[2] = (value >> 16) & 0xFF;
252	buffer[3] = (value >> 24) & 0xFF;
253	} /* i2dw */
254
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision