#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <ifdhandler.h>
#include "defs.h"
#include "ccid_ifdhandler.h"
#include "config.h"
#include "debug.h"
#include "ccid.h"
#include "utils.h"
#include "commands.h"
#include "parser.h"
#define SYNC 0x03
#define CTRL_ACK 0x06
#define CTRL_NAK 0x15
#define RDR_to_PC_NotifySlotChange 0x50
#define CARD_ABSENT 0x02
#define CARD_PRESENT 0x03
#define GEMPCTWIN_MAXBUF (271 +2 +1) * 2
typedef struct
{
int fd;
char *device;
int real_nb_opened_slots;
int *nb_opened_slots;
int echo;
unsigned char buffer[GEMPCTWIN_MAXBUF];
int buffer_offset;
int buffer_offset_last;
_ccid_descriptor ccid;
} _serialDevice;
#include "ccid_serial.h"
unsigned int SerialTwinDataRates[] = { ISO_DATA_RATES, 0 };
unsigned int SerialExtendedDataRates[] = { ISO_DATA_RATES, 500000, 0 };
unsigned int SerialCustomDataRates[] = { GEMPLUS_CUSTOM_DATA_RATES, 0 };
static _serialDevice serialDevice[CCID_DRIVER_MAX_READERS];
static int ReadChunk(unsigned int reader_index, unsigned char *buffer,
int buffer_length, int min_length);
static int get_bytes(unsigned int reader_index, unsigned char *buffer,
int length);
status_t WriteSerial(unsigned int reader_index, unsigned int length,
unsigned char *buffer)
{
unsigned int i;
unsigned char lrc;
unsigned char low_level_buffer[GEMPCTWIN_MAXBUF];
char debug_header[] = "-> 123456 ";
(void)snprintf(debug_header, sizeof(debug_header), "-> %06X ",
reader_index);
if (length > GEMPCTWIN_MAXBUF-3)
{
DEBUG_CRITICAL3("command too long: %d for max %d",
length, GEMPCTWIN_MAXBUF-3);
return STATUS_UNSUCCESSFUL;
}
low_level_buffer[0] = 0x03;
low_level_buffer[1] = 0x06;
memcpy(low_level_buffer+2, buffer, length);
lrc = 0;
for(i=0; i<length+2; i++)
lrc ^= low_level_buffer[i];
low_level_buffer[length+2] = lrc;
DEBUG_XXD(debug_header, low_level_buffer, length+3);
if (write(serialDevice[reader_index].fd, low_level_buffer,
length+3) != length+3)
{
DEBUG_CRITICAL2("write error: %s", strerror(errno));
return STATUS_UNSUCCESSFUL;
}
return STATUS_SUCCESS;
}
status_t ReadSerial(unsigned int reader_index,
unsigned int *length, unsigned char *buffer)
{
unsigned char c;
int rv;
int echo;
int to_read;
int i;
echo = serialDevice[reader_index].echo;
start:
DEBUG_COMM("start");
if ((rv = get_bytes(reader_index, &c, 1)) != STATUS_SUCCESS)
return rv;
if (c == RDR_to_PC_NotifySlotChange)
goto slot_change;
if (c == SYNC)
goto sync;
if (c >= 0x80)
{
DEBUG_COMM2("time request: 0x%02X", c);
goto start;
}
DEBUG_CRITICAL2("Got 0x%02X", c);
return STATUS_COMM_ERROR;
slot_change:
DEBUG_COMM("slot change");
if ((rv = get_bytes(reader_index, &c, 1)) != STATUS_SUCCESS)
return rv;
if (c == CARD_ABSENT)
{
DEBUG_COMM("Card removed");
}
else
if (c == CARD_PRESENT)
{
DEBUG_COMM("Card inserted");
}
else
{
DEBUG_COMM2("Unknown card movement: %d", c);
}
goto start;
sync:
DEBUG_COMM("sync");
if ((rv = get_bytes(reader_index, &c, 1)) != STATUS_SUCCESS)
return rv;
if (c == CTRL_ACK)
goto ack;
if (c == CTRL_NAK)
goto nak;
DEBUG_CRITICAL2("Got 0x%02X instead of ACK/NAK", c);
return STATUS_COMM_ERROR;
nak:
DEBUG_COMM("nak");
if ((rv = get_bytes(reader_index, &c, 1)) != STATUS_SUCCESS)
return rv;
if (c != (SYNC ^ CTRL_NAK))
{
DEBUG_CRITICAL2("Wrong LRC: 0x%02X", c);
return STATUS_COMM_ERROR;
}
else
{
DEBUG_COMM("NAK requested");
return STATUS_COMM_NAK;
}
ack:
DEBUG_COMM("ack");
if ((rv = get_bytes(reader_index, buffer, 5)) != STATUS_SUCCESS)
return rv;
to_read = 10+dw2i(buffer, 1);
DEBUG_COMM2("frame size: %d", to_read);
if ((rv = get_bytes(reader_index, buffer+5, to_read-5)) != STATUS_SUCCESS)
return rv;
DEBUG_XXD("frame: ", buffer, to_read);
DEBUG_COMM("lrc");
if ((rv = get_bytes(reader_index, &c, 1)) != STATUS_SUCCESS)
return rv;
DEBUG_COMM2("lrc: 0x%02X", c);
for (i=0; i<to_read; i++)
c ^= buffer[i];
if (c != (SYNC ^ CTRL_ACK))
DEBUG_CRITICAL2("Wrong LRC: 0x%02X", c);
if (echo)
{
echo = FALSE;
goto start;
}
*length = to_read;
return STATUS_SUCCESS;
}
int get_bytes(unsigned int reader_index, unsigned char *buffer, int length)
{
int offset = serialDevice[reader_index].buffer_offset;
int offset_last = serialDevice[reader_index].buffer_offset_last;
DEBUG_COMM3("available: %d, needed: %d", offset_last-offset,
length);
if (offset + length <= offset_last)
{
DEBUG_COMM("data available");
memcpy(buffer, serialDevice[reader_index].buffer + offset, length);
serialDevice[reader_index].buffer_offset += length;
}
else
{
int present, rv;
present = offset_last - offset;
if (present > 0)
{
DEBUG_COMM2("some data available: %d", present);
memcpy(buffer, serialDevice[reader_index].buffer + offset,
present);
}
DEBUG_COMM2("get more data: %d", length - present);
rv = ReadChunk(reader_index, serialDevice[reader_index].buffer,
sizeof(serialDevice[reader_index].buffer), length - present);
if (rv < 0)
return STATUS_COMM_ERROR;
memcpy(buffer + present, serialDevice[reader_index].buffer,
length - present);
serialDevice[reader_index].buffer_offset = length - present;
serialDevice[reader_index].buffer_offset_last = rv;
DEBUG_COMM3("offset: %d, last_offset: %d",
serialDevice[reader_index].buffer_offset,
serialDevice[reader_index].buffer_offset_last);
}
return STATUS_SUCCESS;
}
static int ReadChunk(unsigned int reader_index, unsigned char *buffer,
int buffer_length, int min_length)
{
int fd = serialDevice[reader_index].fd;
# ifndef S_SPLINT_S
fd_set fdset;
# endif
struct timeval t;
int i, rv = 0;
int already_read;
char debug_header[] = "<- 123456 ";
(void)snprintf(debug_header, sizeof(debug_header), "<- %06X ",
reader_index);
already_read = 0;
while (already_read < min_length)
{
FD_ZERO(&fdset);
FD_SET(fd, &fdset);
t.tv_sec = serialDevice[reader_index].ccid.readTimeout;
t.tv_usec = 0;
i = select(fd+1, &fdset, NULL, NULL, &t);
if (i == -1)
{
DEBUG_CRITICAL2("select: %s", strerror(errno));
return -1;
}
else
if (i == 0)
{
DEBUG_COMM2("Timeout! (%d sec)", serialDevice[reader_index].ccid.readTimeout);
return -1;
}
rv = read(fd, buffer + already_read, buffer_length - already_read);
if (rv < 0)
{
DEBUG_COMM2("read error: %s", strerror(errno));
return -1;
}
DEBUG_XXD(debug_header, buffer + already_read, rv);
already_read += rv;
DEBUG_COMM3("read: %d, to read: %d", already_read,
min_length);
}
return already_read;
}
status_t OpenSerial(unsigned int reader_index, int channel)
{
char dev_name[FILENAME_MAX];
DEBUG_COMM3("Reader index: %X, Channel: %d", reader_index, channel);
if (channel == 0x0103F8)
channel = 1;
else
if (channel == 0x0102F8)
channel = 2;
else
if (channel == 0x0103E8)
channel = 3;
else
if (channel == 0x0102E8)
channel = 4;
if (channel < 0)
{
DEBUG_CRITICAL2("wrong port number: %d", (int) channel);
return STATUS_UNSUCCESSFUL;
}
(void)snprintf(dev_name, sizeof(dev_name), "/dev/pcsc/%d", (int) channel);
return OpenSerialByName(reader_index, dev_name);
}
static status_t set_ccid_descriptor(unsigned int reader_index,
const char *reader_name, const char *dev_name)
{
int readerID;
int i;
int already_used = FALSE;
static int previous_reader_index = -1;
readerID = GEMPCTWIN;
if (0 == strcasecmp(reader_name,"GemCorePOSPro"))
readerID = GEMCOREPOSPRO;
else if (0 == strcasecmp(reader_name,"GemCoreSIMPro"))
readerID = GEMCORESIMPRO;
else if (0 == strcasecmp(reader_name,"GemPCPinPad"))
readerID = GEMPCPINPAD;
for (i = 0; i < CCID_DRIVER_MAX_READERS; i++)
{
if (serialDevice[i].device
&& strcmp(serialDevice[i].device, dev_name) == 0)
{
already_used = TRUE;
DEBUG_COMM2("%s already used. Multi-slot reader?", dev_name);
break;
}
}
if (already_used)
{
if ((previous_reader_index != -1)
&& serialDevice[previous_reader_index].device
&& (strcmp(serialDevice[previous_reader_index].device, dev_name) == 0)
&& serialDevice[previous_reader_index].ccid.bCurrentSlotIndex < serialDevice[previous_reader_index].ccid.bMaxSlotIndex)
{
serialDevice[reader_index] = serialDevice[previous_reader_index];
*serialDevice[reader_index].nb_opened_slots += 1;
serialDevice[reader_index].ccid.bCurrentSlotIndex++;
DEBUG_INFO2("Opening slot: %d",
serialDevice[reader_index].ccid.bCurrentSlotIndex);
switch (readerID)
{
case GEMCOREPOSPRO:
case GEMCORESIMPRO:
serialDevice[reader_index].ccid.arrayOfSupportedDataRates = SerialCustomDataRates;
serialDevice[reader_index].ccid.dwMaxDataRate = 125000;
break;
default:
serialDevice[reader_index].ccid.arrayOfSupportedDataRates = SerialTwinDataRates;
serialDevice[reader_index].ccid.dwMaxDataRate = 344086;
break;
}
goto end;
}
else
{
DEBUG_CRITICAL2("Trying to open too many slots on %s", dev_name);
return STATUS_UNSUCCESSFUL;
}
}
serialDevice[reader_index].ccid.real_bSeq = 0;
serialDevice[reader_index].ccid.pbSeq = &serialDevice[reader_index].ccid.real_bSeq;
serialDevice[reader_index].real_nb_opened_slots = 1;
serialDevice[reader_index].nb_opened_slots = &serialDevice[reader_index].real_nb_opened_slots;
serialDevice[reader_index].ccid.bCurrentSlotIndex = 0;
serialDevice[reader_index].ccid.dwMaxCCIDMessageLength = 271;
serialDevice[reader_index].ccid.dwMaxIFSD = 254;
serialDevice[reader_index].ccid.dwFeatures = 0x00010230;
serialDevice[reader_index].ccid.dwDefaultClock = 4000;
serialDevice[reader_index].buffer_offset = 0;
serialDevice[reader_index].buffer_offset_last = 0;
serialDevice[reader_index].ccid.readerID = readerID;
serialDevice[reader_index].ccid.bPINSupport = 0x0;
serialDevice[reader_index].ccid.dwMaxDataRate = 344086;
serialDevice[reader_index].ccid.bMaxSlotIndex = 0;
serialDevice[reader_index].ccid.arrayOfSupportedDataRates = SerialTwinDataRates;
serialDevice[reader_index].ccid.dwSlotStatus = IFD_ICC_PRESENT;
serialDevice[reader_index].ccid.bVoltageSupport = 0x07;
serialDevice[reader_index].echo = TRUE;
switch (readerID)
{
case GEMCOREPOSPRO:
serialDevice[reader_index].ccid.bMaxSlotIndex = 4;
serialDevice[reader_index].ccid.arrayOfSupportedDataRates = SerialExtendedDataRates;
serialDevice[reader_index].echo = FALSE;
serialDevice[reader_index].ccid.dwMaxDataRate = 500000;
break;
case GEMCORESIMPRO:
serialDevice[reader_index].ccid.bMaxSlotIndex = 1;
serialDevice[reader_index].ccid.arrayOfSupportedDataRates = SerialExtendedDataRates;
serialDevice[reader_index].echo = FALSE;
serialDevice[reader_index].ccid.dwMaxDataRate = 500000;
break;
case GEMPCPINPAD:
serialDevice[reader_index].ccid.bPINSupport = 0x03;
serialDevice[reader_index].ccid.arrayOfSupportedDataRates = SerialExtendedDataRates;
serialDevice[reader_index].ccid.dwMaxDataRate = 500000;
break;
}
end:
previous_reader_index = reader_index;
if (already_used)
return STATUS_SECONDARY_SLOT;
return STATUS_SUCCESS;
}
status_t OpenSerialByName(unsigned int reader_index, char *dev_name)
{
struct termios current_termios;
unsigned int reader = reader_index;
char reader_name[TOKEN_MAX_VALUE_SIZE] = "GemPCTwin";
char *p;
status_t ret;
DEBUG_COMM3("Reader index: %X, Device: %s", reader_index, dev_name);
p = strchr(dev_name, ':');
if (p)
{
strncpy(reader_name, p+1, sizeof(reader_name));
*p = '\0';
}
ret = set_ccid_descriptor(reader_index, reader_name, dev_name);
if (STATUS_UNSUCCESSFUL == ret)
return STATUS_UNSUCCESSFUL;
if (STATUS_SECONDARY_SLOT == ret)
return STATUS_SUCCESS;
serialDevice[reader].fd = open(dev_name, O_RDWR | O_NOCTTY);
if (-1 == serialDevice[reader].fd)
{
DEBUG_CRITICAL3("open %s: %s", dev_name, strerror(errno));
return STATUS_UNSUCCESSFUL;
}
{
int flags;
if (ioctl(serialDevice[reader].fd, TIOCMGET, &flags) < 0)
{
DEBUG_CRITICAL2("Get RS232 signals state failed: %s",
strerror(errno));
}
else
{
flags &= ~TIOCM_RTS;
if (ioctl(serialDevice[reader].fd, TIOCMSET, &flags) < 0)
{
DEBUG_CRITICAL2("Set RTS to low failed: %s", strerror(errno));
}
else
{
DEBUG_COMM("Plug-n-Play inhibition successful");
}
}
}
serialDevice[reader].device = strdup(dev_name);
if (tcflush(serialDevice[reader].fd, TCIOFLUSH))
DEBUG_INFO2("tcflush() function error: %s", strerror(errno));
if (tcgetattr(serialDevice[reader].fd, ¤t_termios) == -1)
{
DEBUG_INFO2("tcgetattr() function error: %s", strerror(errno));
(void)close(serialDevice[reader].fd);
serialDevice[reader].fd = -1;
return STATUS_UNSUCCESSFUL;
}
current_termios.c_iflag = IGNBRK | IGNPAR;
current_termios.c_oflag = 0;
current_termios.c_cflag = CS8 | CSTOPB | CREAD | CLOCAL;
current_termios.c_lflag = 0;
(void)cfsetspeed(¤t_termios, B115200);
DEBUG_INFO("Set serial port baudrate to 115200 and correct configuration");
if (tcsetattr(serialDevice[reader].fd, TCSANOW, ¤t_termios) == -1)
{
(void)close(serialDevice[reader].fd);
serialDevice[reader].fd = -1;
DEBUG_INFO2("tcsetattr error: %s", strerror(errno));
return STATUS_UNSUCCESSFUL;
}
{
unsigned char tx_buffer[] = { 0x02 };
unsigned char rx_buffer[50];
unsigned int rx_length = sizeof(rx_buffer);
serialDevice[reader].ccid.readTimeout = 2;
if (IFD_SUCCESS != CmdEscape(reader_index, tx_buffer, sizeof(tx_buffer),
rx_buffer, &rx_length))
{
DEBUG_CRITICAL("Get firmware failed. Maybe the reader is not connected");
(void)CloseSerial(reader_index);
return STATUS_UNSUCCESSFUL;
}
serialDevice[reader].ccid.readTimeout = DEFAULT_COM_READ_TIMEOUT ;
rx_buffer[rx_length] = '\0';
DEBUG_INFO2("Firmware: %s", rx_buffer);
}
{
unsigned char tx_buffer[] = { 0x01, 0x01, 0x01};
unsigned char rx_buffer[50];
unsigned int rx_length = sizeof(rx_buffer);
if (IFD_SUCCESS != CmdEscape(reader_index, tx_buffer, sizeof(tx_buffer),
rx_buffer, &rx_length))
{
DEBUG_CRITICAL("Change card movement notification failed.");
(void)CloseSerial(reader_index);
return STATUS_UNSUCCESSFUL;
}
}
return STATUS_SUCCESS;
}
status_t CloseSerial(unsigned int reader_index)
{
unsigned int reader = reader_index;
if (NULL == serialDevice[reader_index].device)
return STATUS_UNSUCCESSFUL;
DEBUG_COMM2("Closing serial device: %s", serialDevice[reader_index].device);
(*serialDevice[reader_index].nb_opened_slots)--;
if (0 == *serialDevice[reader_index].nb_opened_slots)
{
DEBUG_COMM("Last slot closed. Release resources");
(void)close(serialDevice[reader].fd);
serialDevice[reader].fd = -1;
free(serialDevice[reader].device);
serialDevice[reader].device = NULL;
}
return STATUS_SUCCESS;
}
_ccid_descriptor *get_ccid_descriptor(unsigned int reader_index)
{
return &serialDevice[reader_index].ccid;
}