ccid/src/parse.c

/*
    parse.c: parse CCID structure
    Copyright (C) 2003-2004   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 <stdio.h>
#include <string.h> 
# ifdef S_SPLINT_S
# include <sys/types.h>
# endif
#include <usb.h>

#include <ifdhandler.h>
#include "defs.h"
#include "ccid_ifdhandler.h"
#include "ccid.h"

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif

static int ccid_parse_interface_descriptor(usb_dev_handle *handle,
        struct usb_device *dev);


/*****************************************************************************
 *
 *                                      main
 *
 ****************************************************************************/
int main(/*@unused@*/ int argc, /*@unused@*/ char *argv[])
{
        status_t res;
        unsigned int channel;

        for (channel=0; channel<CCID_DRIVER_MAX_READERS; channel++)
        {
                res = IFDHCreateChannel(channel<<16, channel);
                if (res != IFD_SUCCESS)
                {
                        fprintf(stderr, "ccid_OpenUSB: %d\n", res);
                        break;
                }
                else
                {
                        usb_dev_handle *handle;
                        struct usb_device *dev;

                        if (get_desc(channel<<16, &handle, &dev))
                                res = ccid_parse_interface_descriptor(handle, dev);
                        else
                                fprintf(stderr, "Reader %d not found\n", channel);
                }
        }

        if (channel == 0)
                printf("No known CCID reader found\n");
        else
                for (channel--; channel!=0; channel--)
                        (void)IFDHCloseChannel(channel<<16);

        return 0;
} /* main */


/*****************************************************************************
 *
 *                                      Parse a CCID USB Descriptor
 *
 ****************************************************************************/
static int ccid_parse_interface_descriptor(usb_dev_handle *handle,
        struct usb_device *dev)
{
        struct usb_interface_descriptor *usb_interface;
        unsigned char *extra;
        char buffer[255];

        /*
         * Interface Descriptor
         */
        printf("Parsing Interface Descriptor for device: %s/%s\n",
                dev->bus->dirname, dev->filename);

        /*
         * Vendor/model name
         */
        printf(" idVendor: 0x%04X\n", dev->descriptor.idVendor);
        if (usb_get_string_simple(handle, dev->descriptor.iManufacturer,
                buffer, sizeof(buffer)) < 0)
                printf("  Can't get iManufacturer string\n");
        else
                printf("  iManufacturer: %s\n", buffer);

        printf(" idProduct: 0x%04X\n", dev->descriptor.idProduct);
        if (usb_get_string_simple(handle, dev->descriptor.iProduct,
                buffer, sizeof(buffer)) < 0)
                printf("  Can't get iProduct string\n");
        else
                printf("  iProduct: %s\n", buffer);

        printf(" bcdDevice: %X.%02X (firmware release?)\n",
                dev->descriptor.bcdDevice >> 8, dev->descriptor.bcdDevice & 0xFF);

        usb_interface = get_ccid_usb_interface(dev)->altsetting;
        
        printf(" bLength: %d\n", usb_interface->bLength);
        
        printf(" bDescriptorType: %d\n", usb_interface->bDescriptorType);
        
        printf(" bInterfaceNumber: %d\n", usb_interface->bInterfaceNumber);
        
        printf(" bAlternateSetting: %d\n", usb_interface->bAlternateSetting);
        
        printf(" bNumEndpoints: %d\n", usb_interface->bNumEndpoints);

        printf(" bInterfaceClass: 0x%02X", usb_interface->bInterfaceClass);
        if (usb_interface->bInterfaceClass == 0x0b)
                printf(" [Chip Card Interface Device Class (CCID)]\n");
        else
        {
                printf("\n  NOT A CCID DEVICE\n");
                if (usb_interface->bInterfaceClass != 0xFF)
                        return TRUE;
                else
                        printf("  Class is 0xFF (proprietary)\n");
        }
        
        printf(" bInterfaceSubClass: %d\n", usb_interface->bInterfaceSubClass);
        if (usb_interface->bInterfaceSubClass)
                printf("  UNSUPPORTED SubClass\n");

        printf(" bInterfaceProtocol: %d\n", usb_interface->bInterfaceProtocol);
        if (usb_interface->bInterfaceProtocol)
                printf("  UNSUPPORTED InterfaceProtocol\n");

        printf(" iInterface: %d\n", usb_interface->iInterface);

        if (usb_interface->extralen < 54)
        {
                printf("USB extra length is too short: %d\n", usb_interface->extralen);
                printf("\n  NOT A CCID DEVICE\n");
                return TRUE;
        }

        /*
         * CCID Class Descriptor
         */
        printf(" CCID Class Descriptor\n");
        extra = usb_interface->extra;

        printf("  bLength: 0x%02X\n", extra[0]);
        if (extra[0] != 0x36)
        {
                printf("   UNSUPPORTED bLength\n");
                return TRUE;
        }

        printf("  bDescriptorType: 0x%02X\n", extra[1]);
        if (extra[1] != 0x21)
        {
                if (0xFF == extra[1])
                        printf("   PROPRIETARY bDescriptorType\n");
                else
                {
                        printf("   UNSUPPORTED bDescriptorType\n");
                        return TRUE;
                }
        }

        printf("  bcdCCID: %X.%02X\n", extra[3], extra[2]);
        printf("  bMaxSlotIndex: 0x%02X\n", extra[4]);
        printf("  bVoltageSupport: 0x%02X\n", extra[5]);
        if (extra[5] & 0x01)
                printf("   5.0V\n");
        if (extra[5] & 0x02)
                printf("   3.0V\n");
        if (extra[5] & 0x04)
                printf("   1.8V\n");

        printf("  dwProtocols: 0x%02X%02X 0x%02X%02X\n", extra[9], extra[8],
                extra[7],extra[6]);
        if (extra[6] & 0x01)
                printf("   T=0\n");
        if (extra[6] & 0x02)
                printf("   T=1\n");

        printf("  dwDefaultClock: %.3f MHz\n", dw2i(extra, 10)/1000.0);
        printf("  dwMaximumClock: %.3f MHz\n", dw2i(extra, 14)/1000.0);

        printf("  bNumClockSupported: 0x%02X\n", extra[18]);
        {
                unsigned char buffer[256*sizeof(int)];  /* maximum is 256 records */
                int n;

                /* See CCID 3.7.3 page 25 */
                n = usb_control_msg(handle,
                        0xA1, /* request type */
                        0x03, /* GET_DATA_RATES */
                        0x00, /* value */
                        usb_interface->bInterfaceNumber, /* interface */
                        (char *)buffer,
                        sizeof(buffer),
                        2 * 1000);

                /* we got an error? */
                if (n <= 0)
                        printf("   IFD does not support GET_DATA_RATES request\n");
                else
                        if (n % 4)      /* not a multiple of 4 */
                                printf("   wrong size for GET_DATA_RATES: %d\n", n);
                        else
                        {
                                int i;

                                for (i=0; i<n; i+=4)
                                        printf("   Support %d bps\n", dw2i(buffer, i));
                        }
        }
        printf("  dwDataRate: %d bps\n", dw2i(extra, 19));
        printf("  dwMaxDataRate: %d bps\n", dw2i(extra, 23));
        printf("  bNumDataRatesSupported: %d\n", extra[27]);
        printf("  dwMaxIFSD: %d\n", dw2i(extra, 28));
        printf("  dwSynchProtocols: 0x%08X\n", dw2i(extra, 32));

        printf("  dwMechanical: 0x%08X\n", dw2i(extra, 36));
        if (extra[36] == 0)
                printf("   No special characteristics\n");
        if (extra[36] & 0x01)
                printf("   Card accept mechanism\n");
        if (extra[36] & 0x02)
                printf("   Card ejection mechanism\n");
        if (extra[36] & 0x04)
                printf("   Card capture mechanism\n");
        if (extra[36] & 0x08)
                printf("   Card lock/unlock mechanism\n");

        printf("  dwFeatures: 0x%08X\n", dw2i(extra, 40));
        if (dw2i(extra, 40) == 0)
                printf("   No special characteristics\n");
        if (extra[40] & 0x02)
                printf("   ....02 Automatic parameter configuration based on ATR data\n");
        if (extra[40] & 0x04)
                printf("   ....04 Automatic activation of ICC on inserting\n");
        if (extra[40] & 0x08)
                printf("   ....08 Automatic ICC voltage selection\n");
        if (extra[40] & 0x10)
                printf("   ....10 Automatic ICC clock frequency change according to parameters\n");
        if (extra[40] & 0x20)
                printf("   ....20 Automatic baud rate change according to frequency and Fi, Di params\n");
        if (extra[40] & 0x40)
                printf("   ....40 Automatic parameters negotiation made by the CCID\n");
        if (extra[40] & 0x80)
                printf("   ....80 Automatic PPS made by the CCID\n");
        if (extra[41] & 0x01)
                printf("   ..01.. CCID can set ICC in clock stop mode\n");
        if (extra[41] & 0x02)
                printf("   ..02.. NAD value other than 00 accepted (T=1)\n");
        if (extra[41] & 0x04)
                printf("   ..04.. Automatic IFSD exchange as first exchange (T=1)\n");
        switch (extra[42] & 0x07)
        {
                case 0x00:
                        printf("   00.... Character level exchange\n");
                        break;

                case 0x01:
                        printf("   01.... TPDU level exchange\n");
                        break;

                case 0x02:
                        printf("   02.... Short APDU level exchange\n");
                        break;

                case 0x04:
                        printf("   04.... Short and Extended APDU level exchange\n");
                        break;
        }

        printf("  dwMaxCCIDMessageLength: %d bytes\n", dw2i(extra, 44));
        printf("  bClassGetResponse: %d\n", extra[48]);
        printf("  bClassEnveloppe: %d\n", extra[49]);
        printf("  wLcdLayout: 0x%04X\n", (extra[51] << 8)+extra[50]);
        printf("  bPINSupport: 0x%02X\n", extra[52]);
        if (extra[52] & 0x01)
                printf("   PIN Verification supported\n");
        if (extra[52] & 0x02)
                printf("   PIN Modification supported\n");
        printf("  bMaxCCIDBusySlots: %d\n", extra[53]);

        return FALSE;
} /* ccid_parse_interface_descriptor */

1	rousseau	269	/*
2			parse.c: parse CCID structure
3	rousseau	1160	Copyright (C) 2003-2004 Ludovic Rousseau
4	rousseau	269
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 <stdio.h>
25			#include <string.h>
26	rousseau	1055	# ifdef S_SPLINT_S
27			# include <sys/types.h>
28			# endif
29	rousseau	269	#include <usb.h>
30
31	rousseau	1144	#include <ifdhandler.h>
32	rousseau	877	#include "defs.h"
33			#include "ccid_ifdhandler.h"
34	rousseau	405	#include "ccid.h"
35	rousseau	269
36			#ifndef TRUE
37			#define TRUE 1
38			#define FALSE 0
39			#endif
40
41	rousseau	1057	static int ccid_parse_interface_descriptor(usb_dev_handle *handle,
42	rousseau	269	struct usb_device *dev);
43
44	rousseau	405
45			/*****************************************************************************
46			*
47			* main
48			*
49			****************************************************************************/
50	rousseau	1053	int main(/@unused@/ int argc, /@unused@/ char *argv[])
51	rousseau	269	{
52			status_t res;
53	rousseau	1056	unsigned int channel;
54	rousseau	269
55	rousseau	1077	for (channel=0; channel<CCID_DRIVER_MAX_READERS; channel++)
56	rousseau	269	{
57	rousseau	1144	res = IFDHCreateChannel(channel<<16, channel);
58			if (res != IFD_SUCCESS)
59	rousseau	269	{
60	rousseau	1144	fprintf(stderr, "ccid_OpenUSB: %d\n", res);
61	rousseau	269	break;
62			}
63			else
64			{
65			usb_dev_handle *handle;
66			struct usb_device *dev;
67
68	rousseau	1280	if (get_desc(channel<<16, &handle, &dev))
69			res = ccid_parse_interface_descriptor(handle, dev);
70			else
71			fprintf(stderr, "Reader %d not found\n", channel);
72	rousseau	269	}
73			}
74
75			if (channel == 0)
76			printf("No known CCID reader found\n");
77	rousseau	1160	else
78			for (channel--; channel!=0; channel--)
79			(void)IFDHCloseChannel(channel<<16);
80	rousseau	269
81			return 0;
82			} /* main */
83
84	rousseau	405
85	rousseau	269	/*****************************************************************************
86			*
87			* Parse a CCID USB Descriptor
88			*
89			****************************************************************************/
90	rousseau	1057	static int ccid_parse_interface_descriptor(usb_dev_handle *handle,
91	rousseau	269	struct usb_device *dev)
92			{
93			struct usb_interface_descriptor *usb_interface;
94			unsigned char *extra;
95			char buffer[255];
96
97			/*
98			* Interface Descriptor
99			*/
100	rousseau	661	printf("Parsing Interface Descriptor for device: %s/%s\n",
101			dev->bus->dirname, dev->filename);
102	rousseau	269
103			/*
104			* Vendor/model name
105			*/
106	rousseau	1277	printf(" idVendor: 0x%04X\n", dev->descriptor.idVendor);
107	rousseau	314	if (usb_get_string_simple(handle, dev->descriptor.iManufacturer,
108			buffer, sizeof(buffer)) < 0)
109	rousseau	1277	printf(" Can't get iManufacturer string\n");
110	rousseau	314	else
111	rousseau	1277	printf(" iManufacturer: %s\n", buffer);
112	rousseau	269
113	rousseau	1277	printf(" idProduct: 0x%04X\n", dev->descriptor.idProduct);
114	rousseau	314	if (usb_get_string_simple(handle, dev->descriptor.iProduct,
115			buffer, sizeof(buffer)) < 0)
116	rousseau	1277	printf(" Can't get iProduct string\n");
117	rousseau	314	else
118	rousseau	1277	printf(" iProduct: %s\n", buffer);
119	rousseau	269
120	rousseau	1276	printf(" bcdDevice: %X.%02X (firmware release?)\n",
121			dev->descriptor.bcdDevice >> 8, dev->descriptor.bcdDevice & 0xFF);
122
123	rousseau	737	usb_interface = get_ccid_usb_interface(dev)->altsetting;
124	rousseau	269
125			printf(" bLength: %d\n", usb_interface->bLength);
126
127			printf(" bDescriptorType: %d\n", usb_interface->bDescriptorType);
128
129			printf(" bInterfaceNumber: %d\n", usb_interface->bInterfaceNumber);
130
131			printf(" bAlternateSetting: %d\n", usb_interface->bAlternateSetting);
132
133			printf(" bNumEndpoints: %d\n", usb_interface->bNumEndpoints);
134
135			printf(" bInterfaceClass: 0x%02X", usb_interface->bInterfaceClass);
136			if (usb_interface->bInterfaceClass == 0x0b)
137			printf(" [Chip Card Interface Device Class (CCID)]\n");
138			else
139			{
140	rousseau	529	printf("\n NOT A CCID DEVICE\n");
141	rousseau	528	if (usb_interface->bInterfaceClass != 0xFF)
142			return TRUE;
143			else
144	rousseau	529	printf(" Class is 0xFF (proprietary)\n");
145	rousseau	269	}
146
147			printf(" bInterfaceSubClass: %d\n", usb_interface->bInterfaceSubClass);
148			if (usb_interface->bInterfaceSubClass)
149			printf(" UNSUPPORTED SubClass\n");
150
151			printf(" bInterfaceProtocol: %d\n", usb_interface->bInterfaceProtocol);
152			if (usb_interface->bInterfaceProtocol)
153			printf(" UNSUPPORTED InterfaceProtocol\n");
154
155			printf(" iInterface: %d\n", usb_interface->iInterface);
156
157	rousseau	579	if (usb_interface->extralen < 54)
158			{
159			printf("USB extra length is too short: %d\n", usb_interface->extralen);
160			printf("\n NOT A CCID DEVICE\n");
161			return TRUE;
162			}
163
164	rousseau	269	/*
165			* CCID Class Descriptor
166			*/
167			printf(" CCID Class Descriptor\n");
168			extra = usb_interface->extra;
169
170			printf(" bLength: 0x%02X\n", extra[0]);
171			if (extra[0] != 0x36)
172			{
173			printf(" UNSUPPORTED bLength\n");
174			return TRUE;
175			}
176
177			printf(" bDescriptorType: 0x%02X\n", extra[1]);
178			if (extra[1] != 0x21)
179			{
180	rousseau	737	if (0xFF == extra[1])
181			printf(" PROPRIETARY bDescriptorType\n");
182			else
183			{
184			printf(" UNSUPPORTED bDescriptorType\n");
185			return TRUE;
186			}
187	rousseau	269	}
188
189			printf(" bcdCCID: %X.%02X\n", extra[3], extra[2]);
190			printf(" bMaxSlotIndex: 0x%02X\n", extra[4]);
191	rousseau	405	printf(" bVoltageSupport: 0x%02X\n", extra[5]);
192	rousseau	269	if (extra[5] & 0x01)
193	rousseau	405	printf(" 5.0V\n");
194	rousseau	269	if (extra[5] & 0x02)
195	rousseau	405	printf(" 3.0V\n");
196	rousseau	269	if (extra[5] & 0x04)
197	rousseau	405	printf(" 1.8V\n");
198	rousseau	269
199	rousseau	405	printf(" dwProtocols: 0x%02X%02X 0x%02X%02X\n", extra[9], extra[8],
200			extra[7],extra[6]);
201	rousseau	269	if (extra[6] & 0x01)
202	rousseau	405	printf(" T=0\n");
203	rousseau	269	if (extra[6] & 0x02)
204	rousseau	405	printf(" T=1\n");
205	rousseau	269
206			printf(" dwDefaultClock: %.3f MHz\n", dw2i(extra, 10)/1000.0);
207			printf(" dwMaximumClock: %.3f MHz\n", dw2i(extra, 14)/1000.0);
208
209			printf(" bNumClockSupported: 0x%02X\n", extra[18]);
210	rousseau	1468	{
211			unsigned char buffer[256sizeof(int)]; / maximum is 256 records */
212			int n;
213
214			/* See CCID 3.7.3 page 25 */
215			n = usb_control_msg(handle,
216			0xA1, /* request type */
217			0x03, /* GET_DATA_RATES */
218			0x00, /* value */
219			usb_interface->bInterfaceNumber, /* interface */
220			(char *)buffer,
221			sizeof(buffer),
222			2 * 1000);
223
224			/* we got an error? */
225			if (n <= 0)
226			printf(" IFD does not support GET_DATA_RATES request\n");
227			else
228	rousseau	1480	if (n % 4) /* not a multiple of 4 */
229			printf(" wrong size for GET_DATA_RATES: %d\n", n);
230			else
231			{
232			int i;
233	rousseau	1468
234	rousseau	1480	for (i=0; i<n; i+=4)
235			printf(" Support %d bps\n", dw2i(buffer, i));
236			}
237	rousseau	1468	}
238	rousseau	269	printf(" dwDataRate: %d bps\n", dw2i(extra, 19));
239			printf(" dwMaxDataRate: %d bps\n", dw2i(extra, 23));
240			printf(" bNumDataRatesSupported: %d\n", extra[27]);
241			printf(" dwMaxIFSD: %d\n", dw2i(extra, 28));
242			printf(" dwSynchProtocols: 0x%08X\n", dw2i(extra, 32));
243
244	rousseau	405	printf(" dwMechanical: 0x%08X\n", dw2i(extra, 36));
245	rousseau	269	if (extra[36] == 0)
246	rousseau	405	printf(" No special characteristics\n");
247	rousseau	269	if (extra[36] & 0x01)
248	rousseau	405	printf(" Card accept mechanism\n");
249	rousseau	269	if (extra[36] & 0x02)
250	rousseau	405	printf(" Card ejection mechanism\n");
251	rousseau	269	if (extra[36] & 0x04)
252	rousseau	405	printf(" Card capture mechanism\n");
253	rousseau	269	if (extra[36] & 0x08)
254	rousseau	405	printf(" Card lock/unlock mechanism\n");
255	rousseau	269
256	rousseau	405	printf(" dwFeatures: 0x%08X\n", dw2i(extra, 40));
257	rousseau	1481	if (dw2i(extra, 40) == 0)
258	rousseau	405	printf(" No special characteristics\n");
259	rousseau	269	if (extra[40] & 0x02)
260	rousseau	1482	printf(" ....02 Automatic parameter configuration based on ATR data\n");
261	rousseau	269	if (extra[40] & 0x04)
262	rousseau	1482	printf(" ....04 Automatic activation of ICC on inserting\n");
263	rousseau	269	if (extra[40] & 0x08)
264	rousseau	1482	printf(" ....08 Automatic ICC voltage selection\n");
265	rousseau	269	if (extra[40] & 0x10)
266	rousseau	1482	printf(" ....10 Automatic ICC clock frequency change according to parameters\n");
267	rousseau	269	if (extra[40] & 0x20)
268	rousseau	1482	printf(" ....20 Automatic baud rate change according to frequency and Fi, Di params\n");
269	rousseau	269	if (extra[40] & 0x40)
270	rousseau	1482	printf(" ....40 Automatic parameters negotiation made by the CCID\n");
271	rousseau	269	if (extra[40] & 0x80)
272	rousseau	1482	printf(" ....80 Automatic PPS made by the CCID\n");
273	rousseau	269	if (extra[41] & 0x01)
274	rousseau	1482	printf(" ..01.. CCID can set ICC in clock stop mode\n");
275	rousseau	269	if (extra[41] & 0x02)
276	rousseau	1482	printf(" ..02.. NAD value other than 00 accepted (T=1)\n");
277	rousseau	269	if (extra[41] & 0x04)
278	rousseau	1482	printf(" ..04.. Automatic IFSD exchange as first exchange (T=1)\n");
279	rousseau	1275	switch (extra[42] & 0x07)
280			{
281			case 0x00:
282	rousseau	1482	printf(" 00.... Character level exchange\n");
283	rousseau	1275	break;
284	rousseau	269
285	rousseau	1275	case 0x01:
286	rousseau	1482	printf(" 01.... TPDU level exchange\n");
287	rousseau	1275	break;
288
289			case 0x02:
290	rousseau	1482	printf(" 02.... Short APDU level exchange\n");
291	rousseau	1275	break;
292
293			case 0x04:
294	rousseau	1482	printf(" 04.... Short and Extended APDU level exchange\n");
295	rousseau	1275	break;
296			}
297
298	rousseau	269	printf(" dwMaxCCIDMessageLength: %d bytes\n", dw2i(extra, 44));
299			printf(" bClassGetResponse: %d\n", extra[48]);
300			printf(" bClassEnveloppe: %d\n", extra[49]);
301			printf(" wLcdLayout: 0x%04X\n", (extra[51] << 8)+extra[50]);
302			printf(" bPINSupport: 0x%02X\n", extra[52]);
303	rousseau	779	if (extra[52] & 0x01)
304			printf(" PIN Verification supported\n");
305			if (extra[52] & 0x02)
306			printf(" PIN Modification supported\n");
307	rousseau	269	printf(" bMaxCCIDBusySlots: %d\n", extra[53]);
308
309			return FALSE;
310			} /* ccid_parse_interface_descriptor */
311
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision