/*
|
* Copyright (C) 2017 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
* Hack-y server to forward communication with an eSE during development.
|
* See README.md for more information.
|
*/
|
|
#include <arpa/inet.h>
|
#include <linux/un.h>
|
#include <stdint.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <sys/socket.h>
|
#include <unistd.h>
|
|
#define LOG_TAG "ese-relay"
|
#include <ese/ese.h>
|
#include <ese/log.h>
|
|
extern const uint8_t *kAtr;
|
extern size_t kAtrLength;
|
extern void *kEseOpenData;
|
void ese_relay_init(struct EseInterface *ese);
|
|
/*
|
* Aligned with vpcd.h in
|
* https://frankmorgner.github.io/vsmartcard/virtualsmartcard
|
*/
|
#define CMD_POWER_OFF 0
|
#define CMD_POWER_ON 1
|
#define CMD_RESET 2
|
#define CMD_ATR 4
|
|
int setup_socket(const char *name) {
|
int fd;
|
struct sockaddr_un addr;
|
|
memset(&addr, 0, sizeof(struct sockaddr_un));
|
addr.sun_family = AF_UNIX;
|
if (strlen(name) > UNIX_PATH_MAX - 1) {
|
ALOGE("Abstract listener name too long.");
|
return -1;
|
}
|
strncpy(&addr.sun_path[1], name, strlen(name));
|
fd = socket(AF_UNIX, SOCK_STREAM, 0);
|
if (fd == -1) {
|
ALOGE("Could not open socket.");
|
return fd;
|
}
|
if (bind(fd, (struct sockaddr *)&addr,
|
sizeof(sa_family_t) + strlen(name) + 1) == -1) {
|
ALOGE("Failed to bind to abstract socket name");
|
close(fd);
|
return -1;
|
}
|
return fd;
|
}
|
|
int main() {
|
int server_fd = setup_socket(LOG_TAG);
|
struct EseInterface ese;
|
ese_relay_init(&ese);
|
|
if (listen(server_fd, 4)) {
|
ALOGE("Failed to listen on socket.");
|
close(server_fd);
|
return -1;
|
}
|
|
while (server_fd) {
|
struct sockaddr client_info;
|
socklen_t client_info_len = (socklen_t)sizeof(&client_info);
|
int client_fd;
|
uint32_t tx_len, data_read;
|
uint32_t rx_len;
|
uint16_t network_tx_len;
|
uint16_t network_rx_len;
|
uint8_t tx_buf[4096];
|
uint8_t rx_buf[4096];
|
int connected = 0;
|
|
if ((client_fd = accept(server_fd, &client_info, &client_info_len)) == -1) {
|
ALOGE("Fatal error accept()ing a client connection.");
|
return -1;
|
}
|
printf("Client connected.\n");
|
connected = 1;
|
if (ese_open(&ese, kEseOpenData)) {
|
ALOGE("Cannot open hw");
|
if (ese_error(&ese))
|
ALOGE("eSE error (%d): %s", ese_error_code(&ese),
|
ese_error_message(&ese));
|
return 1;
|
}
|
printf("eSE is open\n");
|
|
while (connected) {
|
printf("Listening for data from client\n");
|
if (read(client_fd, &network_tx_len, sizeof(network_tx_len)) !=
|
sizeof(network_tx_len)) {
|
ALOGE("Client disconnected.");
|
break;
|
}
|
tx_len = (uint32_t)ntohs(network_tx_len);
|
printf("tx_len: %u\n", tx_len);
|
if (tx_len == 0) {
|
ALOGE("Client had nothing to say. Goodbye.");
|
break;
|
}
|
if (tx_len > sizeof(tx_buf)) {
|
ALOGE("Client payload too large: %u", tx_len);
|
break;
|
}
|
for (data_read = 0; data_read < tx_len;) {
|
printf("Reading payload: %u of %u remaining\n", data_read, tx_len);
|
ssize_t bytes = read(client_fd, tx_buf + data_read, tx_len - data_read);
|
if (bytes < 0) {
|
ALOGE("Client abandoned hope during transmission.");
|
connected = 0;
|
break;
|
}
|
data_read += bytes;
|
}
|
/* Finally, we can transcieve. */
|
if (tx_len) {
|
uint32_t i;
|
printf("Sending %u bytes to card\n", tx_len);
|
printf("TX: ");
|
for (i = 0; i < tx_len; ++i)
|
printf("%.2X ", tx_buf[i]);
|
printf("\n");
|
}
|
|
if (tx_len == 1) { /* Control request */
|
printf("Received a control request: %x\n", tx_buf[0]);
|
rx_len = 0;
|
switch (tx_buf[0]) {
|
case CMD_POWER_OFF:
|
ese.ops->hw_reset(&ese);
|
break;
|
case CMD_POWER_ON:
|
break;
|
case CMD_RESET:
|
ese.ops->hw_reset(&ese);
|
break;
|
case CMD_ATR:
|
/* Send a dummy ATR for another JCOP card */
|
rx_len = kAtrLength;
|
printf("Filling card RX buf with fake ATR (%u)\n", rx_len);
|
memcpy(rx_buf, kAtr, rx_len);
|
printf("Sending back ATR of length %u\n", rx_len);
|
break;
|
default:
|
ALOGE("Unknown control byte seen: %x", tx_buf[0]);
|
}
|
if (!rx_len)
|
continue;
|
} else {
|
rx_len = ese_transceive(&ese, tx_buf, tx_len, rx_buf, sizeof(rx_buf));
|
if (ese_error(&ese)) {
|
ALOGE("An error (%d) occurred: %s", ese_error_code(&ese),
|
ese_error_message(&ese));
|
return -1;
|
}
|
}
|
if (rx_len > 0) {
|
uint32_t i;
|
printf("Read %d bytes from card\n", rx_len);
|
printf("RX: ");
|
for (i = 0; i < rx_len; ++i)
|
printf("%.2X ", rx_buf[i]);
|
printf("\n");
|
}
|
|
/* Send to client */
|
network_rx_len = htons((uint16_t)rx_len);
|
if (write(client_fd, &network_rx_len, sizeof(network_rx_len)) !=
|
sizeof(network_rx_len)) {
|
ALOGE("Client abandoned hope during response size.");
|
break;
|
}
|
|
for (data_read = 0; data_read < rx_len;) {
|
ssize_t bytes =
|
write(client_fd, rx_buf + data_read, rx_len - data_read);
|
if (bytes < 0) {
|
ALOGE("Client abandoned hope during response.");
|
connected = 0;
|
break;
|
}
|
data_read += bytes;
|
}
|
usleep(1000);
|
}
|
close(client_fd);
|
printf("Session ended\n\n");
|
ese_close(&ese);
|
}
|
return 0;
|
}
|
