/*

    ifdhandler.c: IFDH API

    Copyright (C) 2003-2010   Ludovic Rousseau

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library 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

    Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License

	along with this library; if not, write to the Free Software Foundation,

	Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#include <config.h>

#ifdef HAVE_STDIO_H

#include <stdio.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#include "misc.h"

#include <pcsclite.h>

#include <ifdhandler.h>

#include <reader.h>

#include "ccid.h"

#include "defs.h"

#include "ccid_ifdhandler.h"

#include "debug.h"

#include "utils.h"

#include "commands.h"

#include "towitoko/atr.h"

#include "towitoko/pps.h"

#include "parser.h"

#include "strlcpycat.h"

#ifdef HAVE_PTHREAD

#include <pthread.h>

#endif

/* Array of structures to hold the ATR and other state value of each slot */

static CcidDesc CcidSlots[CCID_DRIVER_MAX_READERS];

/* global mutex */

#ifdef HAVE_PTHREAD

static pthread_mutex_t ifdh_context_mutex = PTHREAD_MUTEX_INITIALIZER;

#endif

int LogLevel = DEBUG_LEVEL_CRITICAL | DEBUG_LEVEL_INFO;

int DriverOptions = 0;

int PowerOnVoltage = -1;

static int DebugInitialized = FALSE;

/* local functions */

static void init_driver(void);

static char find_baud_rate(unsigned int baudrate, unsigned int *list);

static unsigned int T0_card_timeout(double f, double d, int TC1, int TC2,

	int clock_frequency);

static unsigned int T1_card_timeout(double f, double d, int TC1, int BWI,

	int CWI, int clock_frequency);

static int get_IFSC(ATR_t *atr, int *i);

static void FreeChannel(int reader_index)

{

#ifdef HAVE_PTHREAD

	(void)pthread_mutex_lock(&ifdh_context_mutex);

#endif

	(void)ClosePort(reader_index);

	free(CcidSlots[reader_index].readerName);

	memset(&CcidSlots[reader_index], 0, sizeof(CcidSlots[reader_index]));

	ReleaseReaderIndex(reader_index);

#ifdef HAVE_PTHREAD

	(void)pthread_mutex_unlock(&ifdh_context_mutex);

#endif

}

static RESPONSECODE CreateChannelByNameOrChannel(DWORD Lun,

	LPSTR lpcDevice, DWORD Channel)

{

	RESPONSECODE return_value = IFD_SUCCESS;

	int reader_index;

	status_t ret;

	if (! DebugInitialized)

		init_driver();

	if (lpcDevice)

	{

		DEBUG_INFO3("Lun: " DWORD_X ", device: %s", Lun, lpcDevice);

	}

	else

	{

		DEBUG_INFO3("Lun: " DWORD_X ", Channel: " DWORD_X, Lun, Channel);

	}

#ifdef HAVE_PTHREAD

	(void)pthread_mutex_lock(&ifdh_context_mutex);

#endif

	reader_index = GetNewReaderIndex(Lun);

#ifdef HAVE_PTHREAD

	(void)pthread_mutex_unlock(&ifdh_context_mutex);

#endif

	if (-1 == reader_index)

		return IFD_COMMUNICATION_ERROR;

	/* Reset ATR buffer */

	CcidSlots[reader_index].nATRLength = 0;

	*CcidSlots[reader_index].pcATRBuffer = '\0';

	/* Reset PowerFlags */

	CcidSlots[reader_index].bPowerFlags = POWERFLAGS_RAZ;

	/* reader name */

	if (lpcDevice)

		CcidSlots[reader_index].readerName = strdup(lpcDevice);

	else

		CcidSlots[reader_index].readerName = strdup("no name");

	if (lpcDevice)

		ret = OpenPortByName(reader_index, lpcDevice);

	else

		ret = OpenPort(reader_index, Channel);

	if (ret != STATUS_SUCCESS)

	{

		DEBUG_CRITICAL("failed");

		if (STATUS_NO_SUCH_DEVICE == ret)

			return_value = IFD_NO_SUCH_DEVICE;

		else

			return_value = IFD_COMMUNICATION_ERROR;

		goto error;

	}

	else

	{

		unsigned char pcbuffer[SIZE_GET_SLOT_STATUS];

		unsigned int oldReadTimeout;

		RESPONSECODE cmd_ret;

		_ccid_descriptor *ccid_descriptor = get_ccid_descriptor(reader_index);

		/* Maybe we have a special treatment for this reader */

		(void)ccid_open_hack_pre(reader_index);

		/* Try to access the reader */

		/* This "warm up" sequence is sometimes needed when pcscd is

		 * restarted with the reader already connected. We get some

		 * "usb_bulk_read: Resource temporarily unavailable" on the first

		 * few tries. It is an empirical hack */

		/* The reader may have to start here so give it some time */

		cmd_ret = CmdGetSlotStatus(reader_index, pcbuffer);

		if (IFD_NO_SUCH_DEVICE == cmd_ret)

		{

			return_value = cmd_ret;

			goto error;

		}

		/* save the current read timeout computed from card capabilities */

		oldReadTimeout = ccid_descriptor->readTimeout;

		/* 100 ms just to resync the USB toggle bits */

		/* Do not use a fixed 100 ms value but compute it from the

		 * default timeout. It is now possible to use a different value

		 * by changing readTimeout in ccid_open_hack_pre() */

		ccid_descriptor->readTimeout = ccid_descriptor->readTimeout * 100.0 / DEFAULT_COM_READ_TIMEOUT;

		if ((IFD_COMMUNICATION_ERROR == CmdGetSlotStatus(reader_index, pcbuffer))

			&& (IFD_COMMUNICATION_ERROR == CmdGetSlotStatus(reader_index, pcbuffer)))

		{

			DEBUG_CRITICAL("failed");

			return_value = IFD_COMMUNICATION_ERROR;

		}

		else

		{

			/* Maybe we have a special treatment for this reader */

			return_value = ccid_open_hack_post(reader_index);

			if (return_value != IFD_SUCCESS)

			{

				DEBUG_CRITICAL("failed");

			}

		}

		/* set back the old timeout */

		ccid_descriptor->readTimeout = oldReadTimeout;

	}

error:

	if (return_value != IFD_SUCCESS)

	{

		/* release the allocated resources */

		FreeChannel(reader_index);

	}

	return return_value;

} /* CreateChannelByNameOrChannel */

EXTERNAL RESPONSECODE IFDHCreateChannelByName(DWORD Lun, LPSTR lpcDevice)

{

	return CreateChannelByNameOrChannel(Lun, lpcDevice, -1);

}

EXTERNAL RESPONSECODE IFDHCreateChannel(DWORD Lun, DWORD Channel)

{

	/*

	 * Lun - Logical Unit Number, use this for multiple card slots or

	 * multiple readers. 0xXXXXYYYY - XXXX multiple readers, YYYY multiple

	 * slots. The resource manager will set these automatically.  By

	 * default the resource manager loads a new instance of the driver so

	 * if your reader does not have more than one smartcard slot then

	 * ignore the Lun in all the functions. Future versions of PC/SC might

	 * support loading multiple readers through one instance of the driver

	 * in which XXXX would be important to implement if you want this.

	 */

	/*

	 * Channel - Channel ID.  This is denoted by the following: 0x000001 -

	 * /dev/pcsc/1 0x000002 - /dev/pcsc/2 0x000003 - /dev/pcsc/3

	 *

	 * USB readers may choose to ignore this parameter and query the bus

	 * for the particular reader.

	 */

	/*

	 * This function is required to open a communications channel to the

	 * port listed by Channel.  For example, the first serial reader on

	 * COM1 would link to /dev/pcsc/1 which would be a sym link to

	 * /dev/ttyS0 on some machines This is used to help with intermachine

	 * independance.

	 *

	 * Once the channel is opened the reader must be in a state in which

	 * it is possible to query IFDHICCPresence() for card status.

	 *

	 * returns:

	 *

	 * IFD_SUCCESS IFD_COMMUNICATION_ERROR

	 */

	return CreateChannelByNameOrChannel(Lun, NULL, Channel);

} /* IFDHCreateChannel */

EXTERNAL RESPONSECODE IFDHCloseChannel(DWORD Lun)

{

	/*

	 * This function should close the reader communication channel for the

	 * particular reader.  Prior to closing the communication channel the

	 * reader should make sure the card is powered down and the terminal

	 * is also powered down.

	 *

	 * returns:

	 *

	 * IFD_SUCCESS IFD_COMMUNICATION_ERROR

	 */

	int reader_index;

	if (-1 == (reader_index = LunToReaderIndex(Lun)))

		return IFD_COMMUNICATION_ERROR;

	DEBUG_INFO3("%s (lun: " DWORD_X ")", CcidSlots[reader_index].readerName,

		Lun);

	/* Restore the default timeout

	 * No need to wait too long if the reader disapeared */

	get_ccid_descriptor(reader_index)->readTimeout = DEFAULT_COM_READ_TIMEOUT;

	(void)CmdPowerOff(reader_index);

	/* No reader status check, if it failed, what can you do ? :) */

	FreeChannel(reader_index);

	return IFD_SUCCESS;

} /* IFDHCloseChannel */

#if !defined(TWIN_SERIAL)

static RESPONSECODE IFDHPolling(DWORD Lun, int timeout)

{

	int reader_index;

	if (-1 == (reader_index = LunToReaderIndex(Lun)))

		return IFD_COMMUNICATION_ERROR;

	/* log only if DEBUG_LEVEL_PERIODIC is set */

	if (LogLevel & DEBUG_LEVEL_PERIODIC)

		DEBUG_INFO4("%s (lun: " DWORD_X ") %d ms",

			CcidSlots[reader_index].readerName, Lun, timeout);

	return InterruptRead(reader_index, timeout);

}

/* on an ICCD device the card is always inserted

 * so no card movement will ever happen: just do nothing */

static RESPONSECODE IFDHSleep(DWORD Lun, int timeout)

{

	int reader_index;

	if (-1 == (reader_index = LunToReaderIndex(Lun)))

		return IFD_COMMUNICATION_ERROR;

	DEBUG_INFO4("%s (lun: " DWORD_X ") %d ms",

		CcidSlots[reader_index].readerName, Lun, timeout);

	/* just sleep for 5 seconds since the polling thread is NOT killable

	 * so pcscd event thread must loop to exit cleanly

	 *

	 * Once the driver (libusb in fact) will support

	 * TAG_IFD_POLLING_THREAD_KILLABLE then we could use a much longer delay

	 * and be killed before pcscd exits

	 */

	(void)usleep(timeout * 1000);

	return IFD_SUCCESS;

}

static RESPONSECODE IFDHStopPolling(DWORD Lun)

{

	int reader_index;

	if (-1 == (reader_index = LunToReaderIndex(Lun)))

		return IFD_COMMUNICATION_ERROR;

	DEBUG_INFO3("%s (lun: " DWORD_X ")",

		CcidSlots[reader_index].readerName, Lun);

	(void)InterruptStop(reader_index);

	return IFD_SUCCESS;

}

#endif

EXTERNAL RESPONSECODE IFDHGetCapabilities(DWORD Lun, DWORD Tag,

	PDWORD Length, PUCHAR Value)

{

	/*

	 * This function should get the slot/card capabilities for a

	 * particular slot/card specified by Lun.  Again, if you have only 1

	 * card slot and don't mind loading a new driver for each reader then

	 * ignore Lun.

	 *

	 * Tag - the tag for the information requested example: TAG_IFD_ATR -

	 * return the Atr and its size (required). these tags are defined in

	 * ifdhandler.h

	 *

	 * Length - the length of the returned data Value - the value of the

	 * data

	 *

	 * returns:

	 *

	 * IFD_SUCCESS IFD_ERROR_TAG

	 */

	int reader_index;

	RESPONSECODE return_value = IFD_SUCCESS;

	if (-1 == (reader_index = LunToReaderIndex(Lun)))

		return IFD_COMMUNICATION_ERROR;

	DEBUG_INFO4("tag: 0x" DWORD_X ", %s (lun: " DWORD_X ")", Tag,

		CcidSlots[reader_index].readerName, Lun);

	switch (Tag)

	{

		case TAG_IFD_ATR:

		case SCARD_ATTR_ATR_STRING:

			/* If Length is not zero, powerICC has been performed.

			 * Otherwise, return NULL pointer

			 * Buffer size is stored in *Length */

			if ((int)*Length >= CcidSlots[reader_index].nATRLength)

			{

				*Length = CcidSlots[reader_index].nATRLength;

				memcpy(Value, CcidSlots[reader_index].pcATRBuffer, *Length);

			}

			else

				return_value = IFD_ERROR_INSUFFICIENT_BUFFER;

			break;

		case SCARD_ATTR_ICC_INTERFACE_STATUS:

			*Length = 1;

			if (IFD_ICC_PRESENT == IFDHICCPresence(Lun))

				/* nonzero if contact is active */

				*Value = 1;

			else

				/* smart card electrical contact is not active */

				*Value = 0;

			break;

		case SCARD_ATTR_ICC_PRESENCE:

			*Length = 1;

			/* Single byte indicating smart card presence:

			 * 0 = not present

			 * 1 = card present but not swallowed (applies only if

			 *     reader supports smart card swallowing)

			 * 2 = card present (and swallowed if reader supports smart

			 *     card swallowing)

			 * 4 = card confiscated. */

			if (IFD_ICC_PRESENT == IFDHICCPresence(Lun))

				/* Card present */

				*Value = 2;

			else

				/* Not present */

				*Value = 0;

			break;

#ifdef HAVE_PTHREAD

		case TAG_IFD_SIMULTANEOUS_ACCESS:

			if (*Length >= 1)

			{

				*Length = 1;

				*Value = CCID_DRIVER_MAX_READERS;

			}

			else

				return_value = IFD_ERROR_INSUFFICIENT_BUFFER;

			break;

		case TAG_IFD_THREAD_SAFE:

			if (*Length >= 1)

			{

				*Length = 1;

#ifdef __APPLE__

				*Value = 0; /* Apple pcscd is bogus (rdar://problem/5697388) */

#else

				*Value = 1; /* Can talk to multiple readers at the same time */

#endif

			}

			else

				return_value = IFD_ERROR_INSUFFICIENT_BUFFER;

			break;

#endif

		case TAG_IFD_SLOTS_NUMBER:

			if (*Length >= 1)

			{

				*Length = 1;

				*Value = 1 + get_ccid_descriptor(reader_index) -> bMaxSlotIndex;

#ifdef USE_COMPOSITE_AS_MULTISLOT

				{

					/* On MacOS X or Linux+libusb we can simulate a

					 * composite device with 2 CCID interfaces by a

					 * multi-slot reader */

					int readerID =  get_ccid_descriptor(reader_index) -> readerID;

					/* 2 CCID interfaces */

					if ((GEMALTOPROXDU == readerID)

						|| (GEMALTOPROXSU == readerID)

						|| (HID_OMNIKEY_5422 == readerID))

						*Value = 2;

					/* 3 CCID interfaces */

					if (FEITIANR502DUAL == readerID)

						*Value = 3;

				}

#endif

				DEBUG_INFO2("Reader supports %d slot(s)", *Value);

			}

			else

				return_value = IFD_ERROR_INSUFFICIENT_BUFFER;

			break;

		case TAG_IFD_SLOT_THREAD_SAFE:

			if (*Length >= 1)

			{

				*Length = 1;

				*Value = 0; /* Can NOT talk to multiple slots at the same time */

			}

			else

				return_value = IFD_ERROR_INSUFFICIENT_BUFFER;

			break;

		case SCARD_ATTR_VENDOR_IFD_VERSION:

			{

				int IFD_bcdDevice = get_ccid_descriptor(reader_index)->IFD_bcdDevice;

				/* Vendor-supplied interface device version (DWORD in the form

				 * 0xMMmmbbbb where MM = major version, mm = minor version, and

				 * bbbb = build number). */

				*Length = 4;

				if (Value)

					*(uint32_t *)Value = IFD_bcdDevice << 16;

			}

			break;

		case SCARD_ATTR_VENDOR_NAME:

			{

				const char *sIFD_iManufacturer = get_ccid_descriptor(reader_index) -> sIFD_iManufacturer;

				if (sIFD_iManufacturer)

				{

					strlcpy((char *)Value, sIFD_iManufacturer, *Length);

					*Length = strlen((char *)Value) +1;

				}

				else

				{

					/* not supported */

					*Length = 0;

				}

			}

			break;

		case SCARD_ATTR_MAXINPUT:

			*Length = sizeof(uint32_t);

			if (Value)

				*(uint32_t *)Value = get_ccid_descriptor(reader_index) -> dwMaxCCIDMessageLength -10;

			break;

#if !defined(TWIN_SERIAL)

		case TAG_IFD_POLLING_THREAD_WITH_TIMEOUT:

			{

				_ccid_descriptor *ccid_desc;

				/* default value: not supported */

				*Length = 0;

				ccid_desc = get_ccid_descriptor(reader_index);

				/* CCID and not ICCD */

				if ((PROTOCOL_CCID == ccid_desc -> bInterfaceProtocol)

					/* 3 end points */

					&& (3 == ccid_desc -> bNumEndpoints))

				{

					*Length = sizeof(void *);

					if (Value)

						*(void **)Value = IFDHPolling;

				}

				if ((PROTOCOL_ICCD_A == ccid_desc->bInterfaceProtocol)

					|| (PROTOCOL_ICCD_B == ccid_desc->bInterfaceProtocol))

				{

					*Length = sizeof(void *);

					if (Value)

						*(void **)Value = IFDHSleep;

				}

			}

			break;

		case TAG_IFD_POLLING_THREAD_KILLABLE:

			{

				_ccid_descriptor *ccid_desc;

				/* default value: not supported */

				*Length = 0;

				ccid_desc = get_ccid_descriptor(reader_index);

				if ((PROTOCOL_ICCD_A == ccid_desc->bInterfaceProtocol)

					|| (PROTOCOL_ICCD_B == ccid_desc->bInterfaceProtocol))

				{

					*Length = 1;	/* 1 char */

					if (Value)

						*Value = 1;	/* TRUE */

				}

			}

			break;

		case TAG_IFD_STOP_POLLING_THREAD:

			{

				_ccid_descriptor *ccid_desc;

				/* default value: not supported */

				*Length = 0;

				ccid_desc = get_ccid_descriptor(reader_index);

				/* CCID and not ICCD */

				if ((PROTOCOL_CCID == ccid_desc -> bInterfaceProtocol)

					/* 3 end points */

					&& (3 == ccid_desc -> bNumEndpoints))

				{

					*Length = sizeof(void *);

					if (Value)

						*(void **)Value = IFDHStopPolling;

				}

			}

			break;

#endif

		case SCARD_ATTR_VENDOR_IFD_SERIAL_NO:

			{

				_ccid_descriptor *ccid_desc;

				ccid_desc = get_ccid_descriptor(reader_index);

				if (ccid_desc->sIFD_serial_number)

				{

					strlcpy((char *)Value, ccid_desc->sIFD_serial_number, *Length);

					*Length = strlen((char *)Value)+1;

				}

				else

				{

					/* not supported */

					*Length = 0;

				}

			}

			break;

		default:

			return_value = IFD_ERROR_TAG;

	}

	return return_value;

} /* IFDHGetCapabilities */

EXTERNAL RESPONSECODE IFDHSetCapabilities(DWORD Lun, DWORD Tag,

	/*@unused@*/ DWORD Length, /*@unused@*/ PUCHAR Value)

{

	/*

	 * This function should set the slot/card capabilities for a

	 * particular slot/card specified by Lun.  Again, if you have only 1

	 * card slot and don't mind loading a new driver for each reader then

	 * ignore Lun.

	 *

	 * Tag - the tag for the information needing set

	 *

	 * Length - the length of the returned data Value - the value of the

	 * data

	 *

	 * returns:

	 *

	 * IFD_SUCCESS IFD_ERROR_TAG IFD_ERROR_SET_FAILURE

	 * IFD_ERROR_VALUE_READ_ONLY

	 */

	(void)Length;

	(void)Value;

	int reader_index;

	if (-1 == (reader_index = LunToReaderIndex(Lun)))

		return IFD_COMMUNICATION_ERROR;

	DEBUG_INFO4("tag: 0x" DWORD_X ", %s (lun: " DWORD_X ")", Tag,

		CcidSlots[reader_index].readerName, Lun);

	return IFD_NOT_SUPPORTED;

} /* IFDHSetCapabilities */

EXTERNAL RESPONSECODE IFDHSetProtocolParameters(DWORD Lun, DWORD Protocol,

	UCHAR Flags, UCHAR PTS1, UCHAR PTS2, UCHAR PTS3)

{

	/*

	 * This function should set the PTS of a particular card/slot using

	 * the three PTS parameters sent

	 *

	 * Protocol - SCARD_PROTOCOL_T0 or SCARD_PROTOCOL_T1

	 * Flags - Logical OR of possible values:

	 *  IFD_NEGOTIATE_PTS1

	 *  IFD_NEGOTIATE_PTS2

	 *  IFD_NEGOTIATE_PTS3

	 * to determine which PTS values to negotiate.

	 * PTS1,PTS2,PTS3 - PTS Values.

	 *

	 * returns:

	 *  IFD_SUCCESS

	 *  IFD_ERROR_PTS_FAILURE

	 *  IFD_COMMUNICATION_ERROR

	 *  IFD_PROTOCOL_NOT_SUPPORTED

	 */

	BYTE pps[PPS_MAX_LENGTH];

	ATR_t atr;

	unsigned int len;

	int convention;

	int reader_index;

	int atr_ret;

	/* Set ccid desc params */

	CcidDesc *ccid_slot;

	_ccid_descriptor *ccid_desc;

	if (-1 == (reader_index = LunToReaderIndex(Lun)))

		return IFD_COMMUNICATION_ERROR;

	DEBUG_INFO4("protocol T=" DWORD_D ", %s (lun: " DWORD_X ")",

		Protocol-SCARD_PROTOCOL_T0, CcidSlots[reader_index].readerName, Lun);

	/* Set to zero buffer */

	memset(pps, 0, sizeof(pps));

	memset(&atr, 0, sizeof(atr));

	/* Get ccid params */

	ccid_slot = get_ccid_slot(reader_index);

	ccid_desc = get_ccid_descriptor(reader_index);

	/* Do not send CCID command SetParameters or PPS to the CCID

	 * The CCID will do this himself */

	if (ccid_desc->dwFeatures & CCID_CLASS_AUTO_PPS_PROP)

	{

		DEBUG_COMM2("Timeout: %d ms", ccid_desc->readTimeout);

		goto end;

	}

	/* Get ATR of the card */

	atr_ret = ATR_InitFromArray(&atr, ccid_slot->pcATRBuffer,

		ccid_slot->nATRLength);

	if (ATR_MALFORMED == atr_ret)

		return IFD_PROTOCOL_NOT_SUPPORTED;

	if (SCARD_PROTOCOL_T0 == Protocol)

		pps[1] |= ATR_PROTOCOL_TYPE_T0;

	else

		if (SCARD_PROTOCOL_T1 == Protocol)

			pps[1] |= ATR_PROTOCOL_TYPE_T1;

		else

			return IFD_PROTOCOL_NOT_SUPPORTED;

	/* TA2 present -> specific mode */

	if (atr.ib[1][ATR_INTERFACE_BYTE_TA].present)

	{

		if (pps[1] != (atr.ib[1][ATR_INTERFACE_BYTE_TA].value & 0x0F))

		{

			/* wrong protocol */

			DEBUG_COMM3("Specific mode in T=%d and T=%d requested",

				atr.ib[1][ATR_INTERFACE_BYTE_TA].value & 0x0F, pps[1]);

			return IFD_PROTOCOL_NOT_SUPPORTED;

		}

	}

	/* TCi (i>2) indicates CRC instead of LRC */

	if (SCARD_PROTOCOL_T1 == Protocol)

	{

		t1_state_t *t1 = &(ccid_slot -> t1);

		int i;

		/* TCi (i>2) present? */

		for (i=2; i

			if (atr.ib[i][ATR_INTERFACE_BYTE_TC].present)

			{

				if (0 == atr.ib[i][ATR_INTERFACE_BYTE_TC].value)

				{

					DEBUG_COMM("Use LRC");

					(void)t1_set_param(t1, IFD_PROTOCOL_T1_CHECKSUM_LRC, 0);

				}

				else

					if (1 == atr.ib[i][ATR_INTERFACE_BYTE_TC].value)

					{

						DEBUG_COMM("Use CRC");

						(void)t1_set_param(t1, IFD_PROTOCOL_T1_CHECKSUM_CRC, 0);

					}

					else

						DEBUG_COMM2("Wrong value for TCi: %d",

							atr.ib[i][ATR_INTERFACE_BYTE_TC].value);

				/* only the first TCi (i>2) must be used */

				break;

			}

	}

	/* PTS1? */

	if (Flags & IFD_NEGOTIATE_PTS1)

	{

		/* just use the value passed in argument */

		pps[1] |= 0x10; /* PTS1 presence */

		pps[2] = PTS1;

	}

	else

	{

		/* TA1 present */

		if (atr.ib[0][ATR_INTERFACE_BYTE_TA].present)

		{

			unsigned int card_baudrate;

			unsigned int default_baudrate;

			double f, d;

			(void)ATR_GetParameter(&atr, ATR_PARAMETER_D, &d);

			(void)ATR_GetParameter(&atr, ATR_PARAMETER_F, &f);

			/* may happen with non ISO cards */

			if ((0 == f) || (0 == d))

			{

				/* values for TA1=11 */

				f = 372;

				d = 1;

			}

			/* Baudrate = f x D/F */

			card_baudrate = (unsigned int) (1000 * ccid_desc->dwDefaultClock

				* d / f);

			default_baudrate = (unsigned int) (1000 * ccid_desc->dwDefaultClock

				* ATR_DEFAULT_D / ATR_DEFAULT_F);

			/* if the card does not try to lower the default speed */

			if ((card_baudrate > default_baudrate)

				/* and the reader is fast enough */

				&& (card_baudrate <= ccid_desc->dwMaxDataRate))

			{

				/* the reader has no baud rates table */

				if ((NULL == ccid_desc->arrayOfSupportedDataRates)

					/* or explicitely support it */

					|| find_baud_rate(card_baudrate,

						ccid_desc->arrayOfSupportedDataRates))

				{

					pps[1] |= 0x10; /* PTS1 presence */

					pps[2] = atr.ib[0][ATR_INTERFACE_BYTE_TA].value;

					DEBUG_COMM2("Set speed to %d bauds", card_baudrate);

				}

				else

				{

					DEBUG_COMM2("Reader does not support %d bauds",

						card_baudrate);

					/* TA2 present -> specific mode: the card is supporting

					 * only the baud rate specified in TA1 but reader does not

					 * support this value. Reject the card. */

					if (atr.ib[1][ATR_INTERFACE_BYTE_TA].present)

						return IFD_COMMUNICATION_ERROR;

				}

			}

			else

			{

				/* the card is too fast for the reader */

				if ((card_baudrate > ccid_desc->dwMaxDataRate +2)

					/* but TA1 <= 97 */

					&& (atr.ib[0][ATR_INTERFACE_BYTE_TA].value <= 0x97))

				{

					unsigned char old_TA1;

					old_TA1 = atr.ib[0][ATR_INTERFACE_BYTE_TA].value;

					while (atr.ib[0][ATR_INTERFACE_BYTE_TA].value > 0x94)

					{

						/* use a lower TA1 */

						atr.ib[0][ATR_INTERFACE_BYTE_TA].value--;

						(void)ATR_GetParameter(&atr, ATR_PARAMETER_D, &d);

						(void)ATR_GetParameter(&atr, ATR_PARAMETER_F, &f);

						/* Baudrate = f x D/F */

						card_baudrate = (unsigned int) (1000 *

							ccid_desc->dwDefaultClock * d / f);

						/* the reader has a baud rate table */

						if ((ccid_desc->arrayOfSupportedDataRates

							/* and the baud rate is supported */

							&& find_baud_rate(card_baudrate,

							ccid_desc->arrayOfSupportedDataRates))

							/* or the reader has NO baud rate table */

							|| ((NULL == ccid_desc->arrayOfSupportedDataRates)

							/* and the baud rate is bellow the limit */

							&& (card_baudrate <= ccid_desc->dwMaxDataRate)))

						{

							pps[1] |= 0x10; /* PTS1 presence */

							pps[2] = atr.ib[0][ATR_INTERFACE_BYTE_TA].value;

							DEBUG_COMM2("Set adapted speed to %d bauds",

								card_baudrate);

							break;

						}

					}

					/* restore original TA1 value */

					atr.ib[0][ATR_INTERFACE_BYTE_TA].value = old_TA1;

				}

			}

		}

	}